bubble-package-manager/bpm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switch to new BPM file structure #8

Merged
EnumDev merged 11 commits from improve_bpm_structure into master 2024-10-23 06:22:40 +00:00
Conversation 5 Commits 11 Files Changed 6 +312 -194
4 changed files with 312 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 76efa42bcf - Show all commits

71
main.go
View File

@ -178,26 +178,26 @@ func resolveCommand() {
bpmFile string
isDependency bool
shouldFetch bool
pkgInfo *utils.PackageInfo
bpmpkg *utils.BPMPackage
}]()
unresolvedDepends := make([]string, 0)
// Search for packages
for _, pkg := range pkgs {
if stat, err := os.Stat(pkg); err == nil && !stat.IsDir() {
pkgInfo, err := utils.ReadPackage(pkg)
bpmpkg, err := utils.ReadPackage(pkg)
if err != nil {
log.Fatalf("Error: could not read package: %s\n", err)
}
if !reinstall && utils.IsPackageInstalled(pkgInfo.Name, rootDir) && utils.GetPackageInfo(pkgInfo.Name, rootDir, true).GetFullVersion() == pkgInfo.GetFullVersion() {
if !reinstall && utils.IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) && utils.GetPackageInfo(bpmpkg.PkgInfo.Name, rootDir, true).GetFullVersion() == bpmpkg.PkgInfo.GetFullVersion() {
continue
}
pkgsToInstall.Set(pkgInfo.Name, &struct {
pkgsToInstall.Set(bpmpkg.PkgInfo.Name, &struct {
bpmFile string
isDependency bool
shouldFetch bool
pkgInfo *utils.PackageInfo
}{bpmFile: pkg, isDependency: false, shouldFetch: false, pkgInfo: pkgInfo})
bpmpkg *utils.BPMPackage
}{bpmFile: pkg, isDependency: false, shouldFetch: false, bpmpkg: bpmpkg})
} else {
entry, _, err := utils.GetRepositoryEntry(pkg)
if err != nil {
@ -210,8 +210,11 @@ func resolveCommand() {
bpmFile string
isDependency bool
shouldFetch bool
pkgInfo *utils.PackageInfo
}{bpmFile: "", isDependency: false, shouldFetch: true, pkgInfo: entry.Info})
bpmpkg *utils.BPMPackage
}{bpmFile: "", isDependency: false, shouldFetch: true, bpmpkg: &utils.BPMPackage{
PkgInfo: entry.Info,
PkgFiles: nil,
}})
}
}
@ -220,14 +223,14 @@ func resolveCommand() {
bpmFile string
isDependency bool
shouldFetch bool
pkgInfo *utils.PackageInfo
bpmpkg *utils.BPMPackage
}]()
for _, pkg := range clone.Keys() {
value, _ := clone.Get(pkg)
resolved, unresolved := value.pkgInfo.ResolveAll(&[]string{}, &[]string{}, value.pkgInfo.Type == "source", !noOptional, !reinstall, verbose, rootDir)
resolved, unresolved := value.bpmpkg.PkgInfo.ResolveAll(&[]string{}, &[]string{}, value.bpmpkg.PkgInfo.Type == "source", !noOptional, !reinstall, verbose, rootDir)
unresolvedDepends = append(unresolvedDepends, unresolved...)
for _, depend := range resolved {
if _, ok := pkgsToInstall.Get(depend); !ok && depend != value.pkgInfo.Name {
if _, ok := pkgsToInstall.Get(depend); !ok && depend != value.bpmpkg.PkgInfo.Name {
if !reinstallAll && utils.IsPackageInstalled(depend, rootDir) {
continue
}
@ -239,8 +242,11 @@ func resolveCommand() {
bpmFile string
isDependency bool
shouldFetch bool
pkgInfo *utils.PackageInfo
}{bpmFile: "", isDependency: true, shouldFetch: true, pkgInfo: entry.Info})
bpmpkg *utils.BPMPackage
}{bpmFile: "", isDependency: true, shouldFetch: true, bpmpkg: &utils.BPMPackage{
PkgInfo: entry.Info,
PkgFiles: nil,
}})
}
}
pkgsToInstall.Set(pkg, value)
@ -259,12 +265,13 @@ func resolveCommand() {
os.Exit(0)
}
var totalOperationSize uint64 = 0
for _, pkg := range pkgsToInstall.Keys() {
value, _ := pkgsToInstall.Get(pkg)
pkgInfo := value.pkgInfo
installedInfo := utils.GetPackageInfo(pkgInfo.Name, rootDir, false)
bpmpkg := value.bpmpkg
installedInfo := utils.GetPackageInfo(bpmpkg.PkgInfo.Name, rootDir, false)
sourceInfo := ""
if pkgInfo.Type == "source" {
if bpmpkg.PkgInfo.Type == "source" {
if rootDir != "/" && !force {
log.Fatalf("Error: cannot compile and install source packages to a different root directory")
}
@ -272,21 +279,29 @@ func resolveCommand() {
}
if installedInfo == nil {
fmt.Printf("%s: %s (Install) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), sourceInfo)
fmt.Printf("%s: %s (Install) %s\n", bpmpkg.PkgInfo.Name, bpmpkg.PkgInfo.GetFullVersion(), sourceInfo)
totalOperationSize += bpmpkg.GetInstalledSize()
} else {
comparison := utils.ComparePackageVersions(*pkgInfo, *installedInfo)
comparison := utils.ComparePackageVersions(*bpmpkg.PkgInfo, *installedInfo)
if comparison < 0 {
fmt.Printf("%s: %s -> %s (Downgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), sourceInfo)
fmt.Printf("%s: %s -> %s (Downgrade) %s\n", bpmpkg.PkgInfo.Name, installedInfo.GetFullVersion(), bpmpkg.PkgInfo.GetFullVersion(), sourceInfo)
} else if comparison > 0 {
fmt.Printf("%s: %s -> %s (Upgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), sourceInfo)
fmt.Printf("%s: %s -> %s (Upgrade) %s\n", bpmpkg.PkgInfo.Name, installedInfo.GetFullVersion(), bpmpkg.PkgInfo.GetFullVersion(), sourceInfo)
} else {
fmt.Printf("%s: %s (Reinstall) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), sourceInfo)
fmt.Printf("%s: %s (Reinstall) %s\n", bpmpkg.PkgInfo.Name, bpmpkg.PkgInfo.GetFullVersion(), sourceInfo)
}
totalOperationSize += bpmpkg.GetInstalledSize()
}
}
if rootDir != "/" {
fmt.Println("Warning: Operating in " + rootDir)
}
if totalOperationSize >= 0 {
fmt.Printf("A total of %s will be used to complete this operation\n", utils.BytesToHumanReadable(totalOperationSize))
} else {
fmt.Printf("A total of %s will be freed by this operation\n", utils.BytesToHumanReadable(totalOperationSize))
}
if !yesAll {
reader := bufio.NewReader(os.Stdin)
if pkgsToInstall.Len() == 1 {
@ -317,7 +332,7 @@ func resolveCommand() {
if err != nil {
log.Fatalf("Error: could not fetch package (%s): %s\n", pkg, err)
}
fmt.Printf("Package (%s) was successfully fetched!\n", value.pkgInfo.Name)
fmt.Printf("Package (%s) was successfully fetched!\n", value.bpmpkg.PkgInfo.Name)
value.bpmFile = fetchedPackage
pkgsToInstall.Set(pkg, value)
}
@ -325,7 +340,7 @@ func resolveCommand() {
// Install fetched packages
for _, pkg := range pkgsToInstall.Keys() {
value, _ := pkgsToInstall.Get(pkg)
pkgInfo := value.pkgInfo
bpmpkg := value.bpmpkg
var err error
if value.isDependency {
err = utils.InstallPackage(value.bpmFile, rootDir, verbose, true, buildSource, skipCheck, keepTempDir)
@ -334,19 +349,19 @@ func resolveCommand() {
}
if err != nil {
if pkgInfo.Type == "source" && keepTempDir {
fmt.Println("BPM temp directory was created at /var/tmp/bpm_source-" + pkgInfo.Name)
if bpmpkg.PkgInfo.Type == "source" && keepTempDir {
fmt.Println("BPM temp directory was created at /var/tmp/bpm_source-" + bpmpkg.PkgInfo.Name)
}
log.Fatalf("Error: could not install package (%s): %s\n", pkg, err)
}
fmt.Printf("Package (%s) was successfully installed\n", pkgInfo.Name)
fmt.Printf("Package (%s) was successfully installed\n", bpmpkg.PkgInfo.Name)
if value.isDependency {
err := utils.SetInstallationReason(pkgInfo.Name, utils.Dependency, rootDir)
err := utils.SetInstallationReason(bpmpkg.PkgInfo.Name, utils.Dependency, rootDir)
if err != nil {
log.Fatalf("Error: could not set installation reason for package: %s\n", err)
}
}
if pkgInfo.Type == "source" && keepTempDir {
if bpmpkg.PkgInfo.Type == "source" && keepTempDir {
fmt.Println("** It is recommended you delete the temporary bpm folder in /var/tmp **")
}
}

40
utils/extract_utils.go Normal file
View File

@ -0,0 +1,40 @@
package utils
import (
"archive/tar"
"errors"
"io"
"os"
)
func ReadTarballContent(tarballPath, fileToExtract string) ([]byte, error) {
file, err := os.Open(tarballPath)
if err != nil {
return nil, err
}
defer file.Close()
tr := tar.NewReader(file)
for {
header, err := tr.Next()
if err == io.EOF {
break
}
if err != nil {
return nil, err
}
if header.Name == fileToExtract {
if header.Typeflag != tar.TypeReg {
return nil, errors.New("file to extract must be a regular file")
}
bytes, err := io.ReadAll(tr)
if err != nil {
return nil, err
}
return bytes, nil
}
}
return nil, errors.New("could not file in tarball")
}

13
utils/general_utils.go
View File

@ -1,7 +1,9 @@
package utils
import (
"fmt"
"io"
"math"
"os"
"os/exec"
"strings"
@ -56,3 +58,14 @@ func stringSliceRemoveEmpty(s []string) []string {
}
return r
}
func BytesToHumanReadable(b uint64) string {
bf := float64(b)
for _, unit := range []string{"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"} {
if math.Abs(bf) < 1024.0 {
return fmt.Sprintf("%3.1f%sB", bf, unit)
}
bf /= 1024.0
}
return fmt.Sprintf("%.1fYiB", bf)
}

228
utils/package_utils.go
View File

@ -3,6 +3,7 @@ package utils
import (
"archive/tar"
"bufio"
"bytes"
"compress/gzip"
"errors"
"fmt"
@ -20,6 +21,11 @@ import (
"syscall"
)
type BPMPackage struct {
PkgInfo *PackageInfo
PkgFiles []*PackageFileEntry
}
type PackageInfo struct {
Name string `yaml:"name,omitempty"`
Description string `yaml:"description,omitempty"`
@ -37,6 +43,29 @@ type PackageInfo struct {
Provides []string `yaml:"provides,omitempty"`
}
type PackageFileEntry struct {
Path string
UserID int
GroupID int
SizeInBytes uint64
}
func (pkg *BPMPackage) GetInstalledSize() uint64 {
var totalSize uint64 = 0
for _, entry := range pkg.PkgFiles {
totalSize += entry.SizeInBytes
}
return totalSize
}
func (pkg *BPMPackage) ConvertFilesToString() string {
str := ""
for _, file := range pkg.PkgFiles {
str += fmt.Sprintf("%s %d %d %d\n", file.Path, file.UserID, file.GroupID, file.SizeInBytes)
}
return str
}
func (pkgInfo *PackageInfo) GetFullVersion() string {
return pkgInfo.Version + "-" + strconv.Itoa(pkgInfo.Revision)
}
@ -93,11 +122,8 @@ func GetPackageInfoRaw(filename string) (string, error) {
if err != nil {
return "", err
}
archive, err := gzip.NewReader(file)
if err != nil {
return "", err
}
tr := tar.NewReader(archive)
tr := tar.NewReader(file)
for {
header, err := tr.Next()
if err == io.EOF {
@ -118,19 +144,21 @@ func GetPackageInfoRaw(filename string) (string, error) {
return "", errors.New("pkg.info not found in archive")
}
func ReadPackage(filename string) (*PackageInfo, error) {
func ReadPackage(filename string) (*BPMPackage, error) {
var pkgInfo *PackageInfo
var pkgFiles []*PackageFileEntry
if _, err := os.Stat(filename); os.IsNotExist(err) {
return nil, err
}
file, err := os.Open(filename)
defer file.Close()
if err != nil {
return nil, err
}
archive, err := gzip.NewReader(file)
if err != nil {
return nil, err
}
tr := tar.NewReader(archive)
tr := tar.NewReader(file)
for {
header, err := tr.Next()
if err == io.EOF {
@ -141,18 +169,49 @@ func ReadPackage(filename string) (*PackageInfo, error) {
}
if header.Name == "pkg.info" {
bs, _ := io.ReadAll(tr)
err := file.Close()
pkgInfo, err = ReadPackageInfo(string(bs))
if err != nil {
return nil, err
}
pkgInfo, err := ReadPackageInfo(string(bs))
} else if header.Name == "pkg.files" {
bs, _ := io.ReadAll(tr)
for _, line := range strings.Split(string(bs), "\n") {
if strings.TrimSpace(line) == "" {
continue
}
stringEntry := strings.Split(strings.TrimSpace(line), " ")
if len(stringEntry) != 4 {
return nil, errors.New("pkg.files is not formatted correctly")
}
uid, err := strconv.ParseInt(stringEntry[1], 0, 32)
if err != nil {
return nil, err
}
return pkgInfo, nil
gid, err := strconv.ParseInt(stringEntry[2], 0, 32)
if err != nil {
return nil, err
}
size, err := strconv.ParseUint(stringEntry[3], 0, 64)
if err != nil {
return nil, err
}
pkgFiles = append(pkgFiles, &PackageFileEntry{
Path: stringEntry[0],
UserID: int(uid),
GroupID: int(gid),
SizeInBytes: size,
})
}
}
}
if pkgInfo == nil {
return nil, errors.New("pkg.info not found in archive")
}
return &BPMPackage{
PkgInfo: pkgInfo,
PkgFiles: pkgFiles,
}, nil
}
func ReadPackageScripts(filename string) (map[string]string, error) {
@ -163,11 +222,8 @@ func ReadPackageScripts(filename string) (map[string]string, error) {
if err != nil {
return nil, err
}
archive, err := gzip.NewReader(file)
if err != nil {
return nil, err
}
tr := tar.NewReader(archive)
tr := tar.NewReader(file)
ret := make(map[string]string)
for {
header, err := tr.Next()
@ -209,10 +265,7 @@ func ReadPackageScripts(filename string) (map[string]string, error) {
ret[header.Name] = string(bs)
}
}
err = archive.Close()
if err != nil {
return nil, err
}
err = file.Close()
if err != nil {
return nil, err
@ -257,25 +310,25 @@ func ExecutePackageScripts(filename, rootDir string, operation Operation, postOp
cmd.Dir = rootDir
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", rootDir))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.Name))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.Version))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.PkgInfo.Name))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.PkgInfo.Description))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.PkgInfo.Version))
if operation != Install {
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_OLD_VERSION=%s", GetPackageInfo(pkgInfo.Name, rootDir, true).Version))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_OLD_VERSION=%s", GetPackageInfo(pkgInfo.PkgInfo.Name, rootDir, true).Version))
}
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_REVISION=%d", pkgInfo.Revision))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_REVISION=%d", pkgInfo.PkgInfo.Revision))
if operation != Install {
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_OLD_REVISION=%d", GetPackageInfo(pkgInfo.Name, rootDir, true).Revision))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_OLD_REVISION=%d", GetPackageInfo(pkgInfo.PkgInfo.Name, rootDir, true).Revision))
}
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.Url))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.Arch))
depends := make([]string, len(pkgInfo.Depends))
copy(depends, pkgInfo.Depends)
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.PkgInfo.Url))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.PkgInfo.Arch))
depends := make([]string, len(pkgInfo.PkgInfo.Depends))
copy(depends, pkgInfo.PkgInfo.Depends)
for i := 0; i < len(depends); i++ {
depends[i] = fmt.Sprintf("\"%s\"", depends[i])
}
makeDepends := make([]string, len(pkgInfo.MakeDepends))
copy(makeDepends, pkgInfo.MakeDepends)
makeDepends := make([]string, len(pkgInfo.PkgInfo.MakeDepends))
copy(makeDepends, pkgInfo.PkgInfo.MakeDepends)
for i := 0; i < len(makeDepends); i++ {
makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i])
}
@ -411,9 +464,9 @@ func CreateReadableInfo(showArchitecture, showType, showPackageRelations bool, p
return strings.Join(ret, "\n")
}
func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string) (error, []string) {
func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string) (error, []string) {
var files []string
if !IsPackageInstalled(pkgInfo.Name, rootDir) {
if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
err := ExecutePackageScripts(filename, rootDir, Install, false)
if err != nil {
return err, nil
@ -429,7 +482,13 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
if err != nil {
return err, nil
}
archive, err := gzip.NewReader(file)
content, err := ReadTarballContent(filename, "files.tar.gz")
if err != nil {
return err, nil
}
archive, err := gzip.NewReader(bytes.NewReader(content))
if err != nil {
return err, nil
}
@ -442,12 +501,11 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
if err != nil {
return err, nil
}
if strings.HasPrefix(header.Name, "files/") && header.Name != "files/" {
trimmedName := strings.TrimPrefix(header.Name, "files/")
trimmedName := strings.TrimPrefix(header.Name, "./")
extractFilename := path.Join(rootDir, trimmedName)
switch header.Typeflag {
case tar.TypeDir:
files = append(files, strings.TrimPrefix(header.Name, "files/"))
files = append(files, strings.TrimPrefix(header.Name, "./"))
if err := os.Mkdir(extractFilename, 0755); err != nil {
if !os.IsExist(err) {
return err, nil
@ -460,13 +518,13 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
case tar.TypeReg:
skip := false
if _, err := os.Stat(extractFilename); err == nil {
for _, k := range pkgInfo.Keep {
for _, k := range bpmpkg.PkgInfo.Keep {
if strings.HasSuffix(k, "/") {
if strings.HasPrefix(trimmedName, k) {
if verbose {
fmt.Println("Skipping File: " + extractFilename + " (Containing directory is set to be kept during installs/updates)")
}
files = append(files, strings.TrimPrefix(header.Name, "files/"))
files = append(files, strings.TrimPrefix(header.Name, "./"))
skip = true
continue
}
@ -475,7 +533,7 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
if verbose {
fmt.Println("Skipping File: " + extractFilename + " (File is configured to be kept during installs/updates)")
}
files = append(files, strings.TrimPrefix(header.Name, "files/"))
files = append(files, strings.TrimPrefix(header.Name, "./"))
skip = true
continue
}
@ -493,7 +551,7 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
if verbose {
fmt.Println("Creating File: " + extractFilename)
}
files = append(files, strings.TrimPrefix(header.Name, "files/"))
files = append(files, strings.TrimPrefix(header.Name, "./"))
if err != nil {
return err, nil
}
@ -511,7 +569,7 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
if verbose {
fmt.Println("Creating Symlink: " + extractFilename + " -> " + header.Linkname)
}
files = append(files, strings.TrimPrefix(header.Name, "files/"))
files = append(files, strings.TrimPrefix(header.Name, "./"))
err := os.Remove(extractFilename)
if err != nil && !os.IsNotExist(err) {
return err, nil
@ -524,7 +582,7 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
if verbose {
fmt.Println("Detected Hard Link: " + extractFilename + " -> " + path.Join(rootDir, strings.TrimPrefix(header.Linkname, "files/")))
}
files = append(files, strings.TrimPrefix(header.Name, "files/"))
files = append(files, strings.TrimPrefix(header.Name, "./"))
seenHardlinks[extractFilename] = path.Join(strings.TrimPrefix(header.Linkname, "files/"))
err := os.Remove(extractFilename)
if err != nil && !os.IsNotExist(err) {
@ -534,7 +592,6 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
return errors.New("unknown type (" + strconv.Itoa(int(header.Typeflag)) + ") in " + extractFilename), nil
}
}
}
for extractFilename, destination := range seenHardlinks {
if verbose {
fmt.Println("Creating Hard Link: " + extractFilename + " -> " + path.Join(rootDir, destination))
@ -554,7 +611,7 @@ func isSplitPackage(filename string) bool {
if err != nil {
return false
}
if pkgInfo.Type != "source" {
if pkgInfo.PkgInfo.Type != "source" {
return false
}
cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("test $(tar -tf %s | grep '^pkg.info' | wc -l) -eq 1", filename))
@ -564,9 +621,9 @@ func isSplitPackage(filename string) bool {
return true
}
func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, binaryPkgFromSrc, skipCheck, keepTempDir bool) (error, []string) {
func compilePackage(bpmpkg *BPMPackage, filename, rootDir string, verbose, binaryPkgFromSrc, skipCheck, keepTempDir bool) (error, []string) {
var files []string
if !IsPackageInstalled(pkgInfo.Name, rootDir) {
if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
err := ExecutePackageScripts(filename, rootDir, Install, false)
if err != nil {
return err, nil
@ -582,13 +639,10 @@ func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, bin
if err != nil {
return err, nil
}
archive, err := gzip.NewReader(file)
if err != nil {
return err, nil
}
tr := tar.NewReader(archive)
temp := path.Join(BPMConfig.CompilationDir, "bpm_source-"+pkgInfo.Name)
tr := tar.NewReader(file)
temp := path.Join(BPMConfig.CompilationDir, "bpm_source-"+bpmpkg.PkgInfo.Name)
err = os.RemoveAll(temp)
if err != nil {
return err, nil
@ -690,7 +744,7 @@ func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, bin
return err, nil
}
fmt.Println("Running source.sh file...")
if !IsPackageInstalled(pkgInfo.Name, rootDir) {
if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
err = ExecutePackageScripts(filename, rootDir, Install, false)
if err != nil {
return err, nil
@ -800,19 +854,19 @@ fi
cmd.Env = append(cmd.Env, "SKIPCHECK="+strconv.FormatBool(skipCheck))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", rootDir))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.Name))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.Version))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_REVISION=%d", pkgInfo.Revision))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.Url))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.Arch))
depends := make([]string, len(pkgInfo.Depends))
copy(depends, pkgInfo.Depends)
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", bpmpkg.PkgInfo.Name))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", bpmpkg.PkgInfo.Description))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", bpmpkg.PkgInfo.Version))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_REVISION=%d", bpmpkg.PkgInfo.Revision))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", bpmpkg.PkgInfo.Url))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", bpmpkg.PkgInfo.Arch))
depends := make([]string, len(bpmpkg.PkgInfo.Depends))
copy(depends, bpmpkg.PkgInfo.Depends)
for i := 0; i < len(depends); i++ {
depends[i] = fmt.Sprintf("\"%s\"", depends[i])
}
makeDepends := make([]string, len(pkgInfo.MakeDepends))
copy(makeDepends, pkgInfo.MakeDepends)
makeDepends := make([]string, len(bpmpkg.PkgInfo.MakeDepends))
copy(makeDepends, bpmpkg.PkgInfo.MakeDepends)
for i := 0; i < len(makeDepends); i++ {
makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i])
}
@ -864,7 +918,7 @@ fi
}
} else if d.Type().IsRegular() {
if _, err := os.Stat(extractFilename); err == nil {
if slices.Contains(pkgInfo.Keep, relFilename) {
if slices.Contains(bpmpkg.PkgInfo.Keep, relFilename) {
if verbose {
fmt.Println("Skipping File: " + extractFilename + "(File is configured to be kept during installs/updates)")
}
@ -933,7 +987,7 @@ fi
compiledDir := path.Join(BPMConfig.BinaryOutputDir)
err = os.MkdirAll(compiledDir, 0755)
compiledInfo := PackageInfo{}
compiledInfo = *pkgInfo
compiledInfo = *bpmpkg.PkgInfo
compiledInfo.Type = "binary"
compiledInfo.Arch = GetArch()
err = os.WriteFile(path.Join(temp, "pkg.info"), []byte(CreateInfoFile(&compiledInfo)), 0644)
@ -991,7 +1045,6 @@ fi
return errors.New("no output files for source package. Cancelling package installation"), nil
}
defer archive.Close()
defer file.Close()
return nil, files
}
@ -1002,39 +1055,39 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc,
}
var oldFiles []string
var files []string
pkgInfo, err := ReadPackage(filename)
bpmpkg, err := ReadPackage(filename)
if err != nil {
return err
}
packageInstalled := IsPackageInstalled(pkgInfo.Name, rootDir)
packageInstalled := IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir)
if packageInstalled {
oldFiles = GetPackageFiles(pkgInfo.Name, rootDir)
oldFiles = GetPackageFiles(bpmpkg.PkgInfo.Name, rootDir)
}
if !force {
if pkgInfo.Arch != "any" && pkgInfo.Arch != GetArch() {
if bpmpkg.PkgInfo.Arch != "any" && bpmpkg.PkgInfo.Arch != GetArch() {
return errors.New("cannot install a package with a different architecture")
}
if unresolved := pkgInfo.CheckDependencies(pkgInfo.Type == "source", true, rootDir); len(unresolved) != 0 {
if unresolved := bpmpkg.PkgInfo.CheckDependencies(bpmpkg.PkgInfo.Type == "source", true, rootDir); len(unresolved) != 0 {
return errors.New("the following dependencies are not installed: " + strings.Join(unresolved, ", "))
}
}
if pkgInfo.Type == "binary" {
err, i := extractPackage(pkgInfo, verbose, filename, rootDir)
if bpmpkg.PkgInfo.Type == "binary" {
err, i := extractPackage(bpmpkg, verbose, filename, rootDir)
if err != nil {
return err
}
files = i
} else if pkgInfo.Type == "source" {
} else if bpmpkg.PkgInfo.Type == "source" {
if isSplitPackage(filename) {
return errors.New("BPM is unable to install split source packages")
}
err, i := compilePackage(pkgInfo, filename, rootDir, verbose, binaryPkgFromSrc, skipCheck, keepTempDir)
err, i := compilePackage(bpmpkg, filename, rootDir, verbose, binaryPkgFromSrc, skipCheck, keepTempDir)
if err != nil {
return err
}
files = i
} else {
return errors.New("unknown package type: " + pkgInfo.Type)
return errors.New("unknown package type: " + bpmpkg.PkgInfo.Type)
}
slices.Sort(files)
slices.Reverse(files)
@ -1048,7 +1101,7 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc,
if err != nil {
return err
}
pkgDir := path.Join(installedDir, pkgInfo.Name)
pkgDir := path.Join(installedDir, bpmpkg.PkgInfo.Name)
err = os.RemoveAll(pkgDir)
if err != nil {
return err
@ -1201,25 +1254,22 @@ func GetSourceScript(filename string) (string, error) {
if err != nil {
return "", err
}
if pkgInfo.Type != "source" {
if pkgInfo.PkgInfo.Type != "source" {
return "", errors.New("package not of source type")
}
file, err := os.Open(filename)
if err != nil {
return "", err
}
archive, err := gzip.NewReader(file)
if err != nil {
return "", err
}
tr := tar.NewReader(archive)
tr := tar.NewReader(file)
for {
header, err := tr.Next()
if err == io.EOF {
break
}
if header.Name == "source.sh" {
err := archive.Close()
err := file.Close()
if err != nil {
return "", err
}