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 bpmFile string
isDependency bool isDependency bool
shouldFetch bool shouldFetch bool
pkgInfo *utils.PackageInfo bpmpkg *utils.BPMPackage
}]() }]()
unresolvedDepends := make([]string, 0) unresolvedDepends := make([]string, 0)
// Search for packages // Search for packages
for _, pkg := range pkgs { for _, pkg := range pkgs {
if stat, err := os.Stat(pkg); err == nil && !stat.IsDir() { if stat, err := os.Stat(pkg); err == nil && !stat.IsDir() {
pkgInfo, err := utils.ReadPackage(pkg) bpmpkg, err := utils.ReadPackage(pkg)
if err != nil { if err != nil {
log.Fatalf("Error: could not read package: %s\n", err) 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 continue
} }
pkgsToInstall.Set(pkgInfo.Name, &struct { pkgsToInstall.Set(bpmpkg.PkgInfo.Name, &struct {
bpmFile string bpmFile string
isDependency bool isDependency bool
shouldFetch bool shouldFetch bool
pkgInfo *utils.PackageInfo bpmpkg *utils.BPMPackage
}{bpmFile: pkg, isDependency: false, shouldFetch: false, pkgInfo: pkgInfo}) }{bpmFile: pkg, isDependency: false, shouldFetch: false, bpmpkg: bpmpkg})
} else { } else {
entry, _, err := utils.GetRepositoryEntry(pkg) entry, _, err := utils.GetRepositoryEntry(pkg)
if err != nil { if err != nil {
@ -210,8 +210,11 @@ func resolveCommand() {
bpmFile string bpmFile string
isDependency bool isDependency bool
shouldFetch bool shouldFetch bool
pkgInfo *utils.PackageInfo bpmpkg *utils.BPMPackage
}{bpmFile: "", isDependency: false, shouldFetch: true, pkgInfo: entry.Info}) }{bpmFile: "", isDependency: false, shouldFetch: true, bpmpkg: &utils.BPMPackage{
PkgInfo: entry.Info,
PkgFiles: nil,
}})
} }
} }
@ -220,14 +223,14 @@ func resolveCommand() {
bpmFile string bpmFile string
isDependency bool isDependency bool
shouldFetch bool shouldFetch bool
pkgInfo *utils.PackageInfo bpmpkg *utils.BPMPackage
}]() }]()
for _, pkg := range clone.Keys() { for _, pkg := range clone.Keys() {
value, _ := clone.Get(pkg) 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...) unresolvedDepends = append(unresolvedDepends, unresolved...)
for _, depend := range resolved { 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) { if !reinstallAll && utils.IsPackageInstalled(depend, rootDir) {
continue continue
} }
@ -239,8 +242,11 @@ func resolveCommand() {
bpmFile string bpmFile string
isDependency bool isDependency bool
shouldFetch bool shouldFetch bool
pkgInfo *utils.PackageInfo bpmpkg *utils.BPMPackage
}{bpmFile: "", isDependency: true, shouldFetch: true, pkgInfo: entry.Info}) }{bpmFile: "", isDependency: true, shouldFetch: true, bpmpkg: &utils.BPMPackage{
PkgInfo: entry.Info,
PkgFiles: nil,
}})
} }
} }
pkgsToInstall.Set(pkg, value) pkgsToInstall.Set(pkg, value)
@ -259,12 +265,13 @@ func resolveCommand() {
os.Exit(0) os.Exit(0)
} }
var totalOperationSize uint64 = 0
for _, pkg := range pkgsToInstall.Keys() { for _, pkg := range pkgsToInstall.Keys() {
value, _ := pkgsToInstall.Get(pkg) value, _ := pkgsToInstall.Get(pkg)
pkgInfo := value.pkgInfo bpmpkg := value.bpmpkg
installedInfo := utils.GetPackageInfo(pkgInfo.Name, rootDir, false) installedInfo := utils.GetPackageInfo(bpmpkg.PkgInfo.Name, rootDir, false)
sourceInfo := "" sourceInfo := ""
if pkgInfo.Type == "source" { if bpmpkg.PkgInfo.Type == "source" {
if rootDir != "/" && !force { if rootDir != "/" && !force {
log.Fatalf("Error: cannot compile and install source packages to a different root directory") log.Fatalf("Error: cannot compile and install source packages to a different root directory")
} }
@ -272,21 +279,29 @@ func resolveCommand() {
} }
if installedInfo == nil { 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 { } else {
comparison := utils.ComparePackageVersions(*pkgInfo, *installedInfo) comparison := utils.ComparePackageVersions(*bpmpkg.PkgInfo, *installedInfo)
if comparison < 0 { 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 { } 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 { } 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 != "/" { if rootDir != "/" {
fmt.Println("Warning: Operating in " + 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 { if !yesAll {
reader := bufio.NewReader(os.Stdin) reader := bufio.NewReader(os.Stdin)
if pkgsToInstall.Len() == 1 { if pkgsToInstall.Len() == 1 {
@ -317,7 +332,7 @@ func resolveCommand() {
if err != nil { if err != nil {
log.Fatalf("Error: could not fetch package (%s): %s\n", pkg, err) 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 value.bpmFile = fetchedPackage
pkgsToInstall.Set(pkg, value) pkgsToInstall.Set(pkg, value)
} }
@ -325,7 +340,7 @@ func resolveCommand() {
// Install fetched packages // Install fetched packages
for _, pkg := range pkgsToInstall.Keys() { for _, pkg := range pkgsToInstall.Keys() {
value, _ := pkgsToInstall.Get(pkg) value, _ := pkgsToInstall.Get(pkg)
pkgInfo := value.pkgInfo bpmpkg := value.bpmpkg
var err error var err error
if value.isDependency { if value.isDependency {
err = utils.InstallPackage(value.bpmFile, rootDir, verbose, true, buildSource, skipCheck, keepTempDir) err = utils.InstallPackage(value.bpmFile, rootDir, verbose, true, buildSource, skipCheck, keepTempDir)
@ -334,19 +349,19 @@ func resolveCommand() {
} }
if err != nil { if err != nil {
if pkgInfo.Type == "source" && keepTempDir { if bpmpkg.PkgInfo.Type == "source" && keepTempDir {
fmt.Println("BPM temp directory was created at /var/tmp/bpm_source-" + pkgInfo.Name) 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) 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 { if value.isDependency {
err := utils.SetInstallationReason(pkgInfo.Name, utils.Dependency, rootDir) err := utils.SetInstallationReason(bpmpkg.PkgInfo.Name, utils.Dependency, rootDir)
if err != nil { if err != nil {
log.Fatalf("Error: could not set installation reason for package: %s\n", err) 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 **") 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 package utils
import ( import (
"fmt"
"io" "io"
"math"
"os" "os"
"os/exec" "os/exec"
"strings" "strings"
@ -56,3 +58,14 @@ func stringSliceRemoveEmpty(s []string) []string {
} }
return r 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)
}

382
utils/package_utils.go
View File

@ -3,6 +3,7 @@ package utils
import ( import (
"archive/tar" "archive/tar"
"bufio" "bufio"
"bytes"
"compress/gzip" "compress/gzip"
"errors" "errors"
"fmt" "fmt"
@ -20,6 +21,11 @@ import (
"syscall" "syscall"
) )
type BPMPackage struct {
PkgInfo *PackageInfo
PkgFiles []*PackageFileEntry
}
type PackageInfo struct { type PackageInfo struct {
Name string `yaml:"name,omitempty"` Name string `yaml:"name,omitempty"`
Description string `yaml:"description,omitempty"` Description string `yaml:"description,omitempty"`
@ -37,6 +43,29 @@ type PackageInfo struct {
Provides []string `yaml:"provides,omitempty"` 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 { func (pkgInfo *PackageInfo) GetFullVersion() string {
return pkgInfo.Version + "-" + strconv.Itoa(pkgInfo.Revision) return pkgInfo.Version + "-" + strconv.Itoa(pkgInfo.Revision)
} }
@ -93,11 +122,8 @@ func GetPackageInfoRaw(filename string) (string, error) {
if err != nil { if err != nil {
return "", err return "", err
} }
archive, err := gzip.NewReader(file)
if err != nil { tr := tar.NewReader(file)
return "", err
}
tr := tar.NewReader(archive)
for { for {
header, err := tr.Next() header, err := tr.Next()
if err == io.EOF { if err == io.EOF {
@ -118,19 +144,21 @@ func GetPackageInfoRaw(filename string) (string, error) {
return "", errors.New("pkg.info not found in archive") 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) { if _, err := os.Stat(filename); os.IsNotExist(err) {
return nil, err return nil, err
} }
file, err := os.Open(filename) file, err := os.Open(filename)
defer file.Close()
if err != nil { if err != nil {
return nil, err return nil, err
} }
archive, err := gzip.NewReader(file)
if err != nil { tr := tar.NewReader(file)
return nil, err
}
tr := tar.NewReader(archive)
for { for {
header, err := tr.Next() header, err := tr.Next()
if err == io.EOF { if err == io.EOF {
@ -141,18 +169,49 @@ func ReadPackage(filename string) (*PackageInfo, error) {
} }
if header.Name == "pkg.info" { if header.Name == "pkg.info" {
bs, _ := io.ReadAll(tr) bs, _ := io.ReadAll(tr)
err := file.Close() pkgInfo, err = ReadPackageInfo(string(bs))
if err != nil { if err != nil {
return nil, err return nil, err
} }
pkgInfo, err := ReadPackageInfo(string(bs)) } else if header.Name == "pkg.files" {
if err != nil { bs, _ := io.ReadAll(tr)
return nil, err 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
}
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,
})
} }
return pkgInfo, nil
} }
} }
return nil, errors.New("pkg.info not found in archive")
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) { func ReadPackageScripts(filename string) (map[string]string, error) {
@ -163,11 +222,8 @@ func ReadPackageScripts(filename string) (map[string]string, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
archive, err := gzip.NewReader(file)
if err != nil { tr := tar.NewReader(file)
return nil, err
}
tr := tar.NewReader(archive)
ret := make(map[string]string) ret := make(map[string]string)
for { for {
header, err := tr.Next() header, err := tr.Next()
@ -209,10 +265,7 @@ func ReadPackageScripts(filename string) (map[string]string, error) {
ret[header.Name] = string(bs) ret[header.Name] = string(bs)
} }
} }
err = archive.Close()
if err != nil {
return nil, err
}
err = file.Close() err = file.Close()
if err != nil { if err != nil {
return nil, err return nil, err
@ -257,25 +310,25 @@ func ExecutePackageScripts(filename, rootDir string, operation Operation, postOp
cmd.Dir = rootDir cmd.Dir = rootDir
cmd.Env = os.Environ() cmd.Env = os.Environ()
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", rootDir)) 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_NAME=%s", pkgInfo.PkgInfo.Name))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description)) 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.Version)) cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.PkgInfo.Version))
if operation != Install { 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 { 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_URL=%s", pkgInfo.PkgInfo.Url))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.Arch)) cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.PkgInfo.Arch))
depends := make([]string, len(pkgInfo.Depends)) depends := make([]string, len(pkgInfo.PkgInfo.Depends))
copy(depends, pkgInfo.Depends) copy(depends, pkgInfo.PkgInfo.Depends)
for i := 0; i < len(depends); i++ { for i := 0; i < len(depends); i++ {
depends[i] = fmt.Sprintf("\"%s\"", depends[i]) depends[i] = fmt.Sprintf("\"%s\"", depends[i])
} }
makeDepends := make([]string, len(pkgInfo.MakeDepends)) makeDepends := make([]string, len(pkgInfo.PkgInfo.MakeDepends))
copy(makeDepends, pkgInfo.MakeDepends) copy(makeDepends, pkgInfo.PkgInfo.MakeDepends)
for i := 0; i < len(makeDepends); i++ { for i := 0; i < len(makeDepends); i++ {
makeDepends[i] = fmt.Sprintf("\"%s\"", 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") 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 var files []string
if !IsPackageInstalled(pkgInfo.Name, rootDir) { if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
err := ExecutePackageScripts(filename, rootDir, Install, false) err := ExecutePackageScripts(filename, rootDir, Install, false)
if err != nil { if err != nil {
return err, nil return err, nil
@ -429,7 +482,13 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
if err != nil { if err != nil {
return 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 { if err != nil {
return err, nil return err, nil
} }
@ -442,97 +501,95 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
if err != nil { if err != nil {
return err, nil return err, nil
} }
if strings.HasPrefix(header.Name, "files/") && header.Name != "files/" { trimmedName := strings.TrimPrefix(header.Name, "./")
trimmedName := strings.TrimPrefix(header.Name, "files/") extractFilename := path.Join(rootDir, trimmedName)
extractFilename := path.Join(rootDir, trimmedName) switch header.Typeflag {
switch header.Typeflag { case tar.TypeDir:
case tar.TypeDir: files = append(files, strings.TrimPrefix(header.Name, "./"))
files = append(files, strings.TrimPrefix(header.Name, "files/")) if err := os.Mkdir(extractFilename, 0755); err != nil {
if err := os.Mkdir(extractFilename, 0755); err != nil { if !os.IsExist(err) {
if !os.IsExist(err) { return err, nil
return err, nil
}
} else {
if verbose {
fmt.Println("Creating Directory: " + extractFilename)
}
} }
case tar.TypeReg: } else {
skip := false if verbose {
if _, err := os.Stat(extractFilename); err == nil { fmt.Println("Creating Directory: " + extractFilename)
for _, k := range pkgInfo.Keep { }
if strings.HasSuffix(k, "/") { }
if strings.HasPrefix(trimmedName, k) { case tar.TypeReg:
if verbose { skip := false
fmt.Println("Skipping File: " + extractFilename + " (Containing directory is set to be kept during installs/updates)") if _, err := os.Stat(extractFilename); err == nil {
} for _, k := range bpmpkg.PkgInfo.Keep {
files = append(files, strings.TrimPrefix(header.Name, "files/")) if strings.HasSuffix(k, "/") {
skip = true if strings.HasPrefix(trimmedName, k) {
continue if verbose {
fmt.Println("Skipping File: " + extractFilename + " (Containing directory is set to be kept during installs/updates)")
} }
} else { files = append(files, strings.TrimPrefix(header.Name, "./"))
if trimmedName == k { skip = true
if verbose { continue
fmt.Println("Skipping File: " + extractFilename + " (File is configured to be kept during installs/updates)") }
} } else {
files = append(files, strings.TrimPrefix(header.Name, "files/")) if trimmedName == k {
skip = true if verbose {
continue fmt.Println("Skipping File: " + extractFilename + " (File is configured to be kept during installs/updates)")
} }
files = append(files, strings.TrimPrefix(header.Name, "./"))
skip = true
continue
} }
} }
} }
if skip {
continue
}
err := os.Remove(extractFilename)
if err != nil && !os.IsNotExist(err) {
return err, nil
}
outFile, err := os.Create(extractFilename)
if verbose {
fmt.Println("Creating File: " + extractFilename)
}
files = append(files, strings.TrimPrefix(header.Name, "files/"))
if err != nil {
return err, nil
}
if _, err := io.Copy(outFile, tr); err != nil {
return err, nil
}
if err := os.Chmod(extractFilename, header.FileInfo().Mode()); err != nil {
return err, nil
}
err = outFile.Close()
if err != nil {
return err, nil
}
case tar.TypeSymlink:
if verbose {
fmt.Println("Creating Symlink: " + extractFilename + " -> " + header.Linkname)
}
files = append(files, strings.TrimPrefix(header.Name, "files/"))
err := os.Remove(extractFilename)
if err != nil && !os.IsNotExist(err) {
return err, nil
}
err = os.Symlink(header.Linkname, extractFilename)
if err != nil {
return err, nil
}
case tar.TypeLink:
if verbose {
fmt.Println("Detected Hard Link: " + extractFilename + " -> " + path.Join(rootDir, strings.TrimPrefix(header.Linkname, "files/")))
}
files = append(files, strings.TrimPrefix(header.Name, "files/"))
seenHardlinks[extractFilename] = path.Join(strings.TrimPrefix(header.Linkname, "files/"))
err := os.Remove(extractFilename)
if err != nil && !os.IsNotExist(err) {
return err, nil
}
default:
return errors.New("unknown type (" + strconv.Itoa(int(header.Typeflag)) + ") in " + extractFilename), nil
} }
if skip {
continue
}
err := os.Remove(extractFilename)
if err != nil && !os.IsNotExist(err) {
return err, nil
}
outFile, err := os.Create(extractFilename)
if verbose {
fmt.Println("Creating File: " + extractFilename)
}
files = append(files, strings.TrimPrefix(header.Name, "./"))
if err != nil {
return err, nil
}
if _, err := io.Copy(outFile, tr); err != nil {
return err, nil
}
if err := os.Chmod(extractFilename, header.FileInfo().Mode()); err != nil {
return err, nil
}
err = outFile.Close()
if err != nil {
return err, nil
}
case tar.TypeSymlink:
if verbose {
fmt.Println("Creating Symlink: " + extractFilename + " -> " + header.Linkname)
}
files = append(files, strings.TrimPrefix(header.Name, "./"))
err := os.Remove(extractFilename)
if err != nil && !os.IsNotExist(err) {
return err, nil
}
err = os.Symlink(header.Linkname, extractFilename)
if err != nil {
return err, nil
}
case tar.TypeLink:
if verbose {
fmt.Println("Detected Hard Link: " + extractFilename + " -> " + path.Join(rootDir, strings.TrimPrefix(header.Linkname, "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) {
return err, nil
}
default:
return errors.New("unknown type (" + strconv.Itoa(int(header.Typeflag)) + ") in " + extractFilename), nil
} }
} }
for extractFilename, destination := range seenHardlinks { for extractFilename, destination := range seenHardlinks {
@ -554,7 +611,7 @@ func isSplitPackage(filename string) bool {
if err != nil { if err != nil {
return false return false
} }
if pkgInfo.Type != "source" { if pkgInfo.PkgInfo.Type != "source" {
return false return false
} }
cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("test $(tar -tf %s | grep '^pkg.info' | wc -l) -eq 1", filename)) 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 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 var files []string
if !IsPackageInstalled(pkgInfo.Name, rootDir) { if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
err := ExecutePackageScripts(filename, rootDir, Install, false) err := ExecutePackageScripts(filename, rootDir, Install, false)
if err != nil { if err != nil {
return err, nil return err, nil
@ -582,13 +639,10 @@ func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, bin
if err != nil { if err != nil {
return 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) err = os.RemoveAll(temp)
if err != nil { if err != nil {
return err, nil return err, nil
@ -690,7 +744,7 @@ func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, bin
return err, nil return err, nil
} }
fmt.Println("Running source.sh file...") fmt.Println("Running source.sh file...")
if !IsPackageInstalled(pkgInfo.Name, rootDir) { if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
err = ExecutePackageScripts(filename, rootDir, Install, false) err = ExecutePackageScripts(filename, rootDir, Install, false)
if err != nil { if err != nil {
return err, nil return err, nil
@ -800,19 +854,19 @@ fi
cmd.Env = append(cmd.Env, "SKIPCHECK="+strconv.FormatBool(skipCheck)) 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_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_NAME=%s", bpmpkg.PkgInfo.Name))
cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description)) 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", pkgInfo.Version)) 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", pkgInfo.Revision)) 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", pkgInfo.Url)) 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", pkgInfo.Arch)) cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", bpmpkg.PkgInfo.Arch))
depends := make([]string, len(pkgInfo.Depends)) depends := make([]string, len(bpmpkg.PkgInfo.Depends))
copy(depends, pkgInfo.Depends) copy(depends, bpmpkg.PkgInfo.Depends)
for i := 0; i < len(depends); i++ { for i := 0; i < len(depends); i++ {
depends[i] = fmt.Sprintf("\"%s\"", depends[i]) depends[i] = fmt.Sprintf("\"%s\"", depends[i])
} }
makeDepends := make([]string, len(pkgInfo.MakeDepends)) makeDepends := make([]string, len(bpmpkg.PkgInfo.MakeDepends))
copy(makeDepends, pkgInfo.MakeDepends) copy(makeDepends, bpmpkg.PkgInfo.MakeDepends)
for i := 0; i < len(makeDepends); i++ { for i := 0; i < len(makeDepends); i++ {
makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i]) makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i])
} }
@ -864,7 +918,7 @@ fi
} }
} else if d.Type().IsRegular() { } else if d.Type().IsRegular() {
if _, err := os.Stat(extractFilename); err == nil { if _, err := os.Stat(extractFilename); err == nil {
if slices.Contains(pkgInfo.Keep, relFilename) { if slices.Contains(bpmpkg.PkgInfo.Keep, relFilename) {
if verbose { if verbose {
fmt.Println("Skipping File: " + extractFilename + "(File is configured to be kept during installs/updates)") fmt.Println("Skipping File: " + extractFilename + "(File is configured to be kept during installs/updates)")
} }
@ -933,7 +987,7 @@ fi
compiledDir := path.Join(BPMConfig.BinaryOutputDir) compiledDir := path.Join(BPMConfig.BinaryOutputDir)
err = os.MkdirAll(compiledDir, 0755) err = os.MkdirAll(compiledDir, 0755)
compiledInfo := PackageInfo{} compiledInfo := PackageInfo{}
compiledInfo = *pkgInfo compiledInfo = *bpmpkg.PkgInfo
compiledInfo.Type = "binary" compiledInfo.Type = "binary"
compiledInfo.Arch = GetArch() compiledInfo.Arch = GetArch()
err = os.WriteFile(path.Join(temp, "pkg.info"), []byte(CreateInfoFile(&compiledInfo)), 0644) 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 return errors.New("no output files for source package. Cancelling package installation"), nil
} }
defer archive.Close()
defer file.Close() defer file.Close()
return nil, files return nil, files
} }
@ -1002,39 +1055,39 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc,
} }
var oldFiles []string var oldFiles []string
var files []string var files []string
pkgInfo, err := ReadPackage(filename) bpmpkg, err := ReadPackage(filename)
if err != nil { if err != nil {
return err return err
} }
packageInstalled := IsPackageInstalled(pkgInfo.Name, rootDir) packageInstalled := IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir)
if packageInstalled { if packageInstalled {
oldFiles = GetPackageFiles(pkgInfo.Name, rootDir) oldFiles = GetPackageFiles(bpmpkg.PkgInfo.Name, rootDir)
} }
if !force { 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") 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, ", ")) return errors.New("the following dependencies are not installed: " + strings.Join(unresolved, ", "))
} }
} }
if pkgInfo.Type == "binary" { if bpmpkg.PkgInfo.Type == "binary" {
err, i := extractPackage(pkgInfo, verbose, filename, rootDir) err, i := extractPackage(bpmpkg, verbose, filename, rootDir)
if err != nil { if err != nil {
return err return err
} }
files = i files = i
} else if pkgInfo.Type == "source" { } else if bpmpkg.PkgInfo.Type == "source" {
if isSplitPackage(filename) { if isSplitPackage(filename) {
return errors.New("BPM is unable to install split source packages") 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 { if err != nil {
return err return err
} }
files = i files = i
} else { } else {
return errors.New("unknown package type: " + pkgInfo.Type) return errors.New("unknown package type: " + bpmpkg.PkgInfo.Type)
} }
slices.Sort(files) slices.Sort(files)
slices.Reverse(files) slices.Reverse(files)
@ -1048,7 +1101,7 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc,
if err != nil { if err != nil {
return err return err
} }
pkgDir := path.Join(installedDir, pkgInfo.Name) pkgDir := path.Join(installedDir, bpmpkg.PkgInfo.Name)
err = os.RemoveAll(pkgDir) err = os.RemoveAll(pkgDir)
if err != nil { if err != nil {
return err return err
@ -1201,25 +1254,22 @@ func GetSourceScript(filename string) (string, error) {
if err != nil { if err != nil {
return "", err return "", err
} }
if pkgInfo.Type != "source" { if pkgInfo.PkgInfo.Type != "source" {
return "", errors.New("package not of source type") return "", errors.New("package not of source type")
} }
file, err := os.Open(filename) file, err := os.Open(filename)
if err != nil { if err != nil {
return "", err return "", err
} }
archive, err := gzip.NewReader(file)
if err != nil { tr := tar.NewReader(file)
return "", err
}
tr := tar.NewReader(archive)
for { for {
header, err := tr.Next() header, err := tr.Next()
if err == io.EOF { if err == io.EOF {
break break
} }
if header.Name == "source.sh" { if header.Name == "source.sh" {
err := archive.Close() err := file.Close()
if err != nil { if err != nil {
return "", err return "", err
} }