diff --git a/main.go b/main.go index 739dd31..c5b69d8 100644 --- a/main.go +++ b/main.go @@ -4,7 +4,6 @@ import ( "bufio" "flag" "fmt" - "github.com/elliotchance/orderedmap/v2" "gitlab.com/bubble-package-manager/bpm/utils" "log" "os" @@ -18,7 +17,7 @@ import ( /* A simple-to-use package manager */ /* ------------------------------------------------------- */ -var bpmVer = "0.4.2" +var bpmVer = "0.5.0" var subcommand = "help" var subcommandArgs []string @@ -97,7 +96,7 @@ func resolveCommand() { } for n, pkg := range packages { var info *utils.PackageInfo - info = utils.GetPackageInfo(pkg, rootDir, false) + info = utils.GetPackageInfo(pkg, rootDir) if info == nil { log.Fatalf("Error: package (%s) is not installed\n", pkg) } @@ -125,7 +124,7 @@ func resolveCommand() { return } for n, pkg := range packages { - info := utils.GetPackageInfo(pkg, rootDir, false) + info := utils.GetPackageInfo(pkg, rootDir) if info == nil { fmt.Printf("Package (%s) could not be found\n", pkg) continue @@ -174,181 +173,78 @@ func resolveCommand() { return } - pkgsToInstall := orderedmap.NewOrderedMap[string, *struct { - bpmFile string - isDependency bool - shouldFetch bool - pkgInfo *utils.PackageInfo - }]() - unresolvedDepends := make([]string, 0) + operation := utils.BPMOperation{ + Actions: make([]utils.OperationAction, 0), + UnresolvedDepends: make([]string, 0), + RootDir: rootDir, + } // 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).GetFullVersion() == bpmpkg.PkgInfo.GetFullVersion() { continue } - pkgsToInstall.Set(pkgInfo.Name, &struct { - bpmFile string - isDependency bool - shouldFetch bool - pkgInfo *utils.PackageInfo - }{bpmFile: pkg, isDependency: false, shouldFetch: false, pkgInfo: pkgInfo}) + operation.Actions = append(operation.Actions, &utils.InstallPackageAction{ + File: pkg, + IsDependency: false, + BpmPackage: bpmpkg, + }) } else { entry, _, err := utils.GetRepositoryEntry(pkg) if err != nil { log.Fatalf("Error: could not find package (%s) in any repository\n", pkg) } - if !reinstall && utils.IsPackageInstalled(entry.Info.Name, rootDir) && utils.GetPackageInfo(entry.Info.Name, rootDir, true).GetFullVersion() == entry.Info.GetFullVersion() { + if !reinstall && utils.IsPackageInstalled(entry.Info.Name, rootDir) && utils.GetPackageInfo(entry.Info.Name, rootDir).GetFullVersion() == entry.Info.GetFullVersion() { continue } - pkgsToInstall.Set(entry.Info.Name, &struct { - bpmFile string - isDependency bool - shouldFetch bool - pkgInfo *utils.PackageInfo - }{bpmFile: "", isDependency: false, shouldFetch: true, pkgInfo: entry.Info}) + operation.Actions = append(operation.Actions, &utils.FetchPackageAction{ + IsDependency: false, + RepositoryEntry: entry, + }) } } - clone := pkgsToInstall.Copy() - pkgsToInstall = orderedmap.NewOrderedMap[string, *struct { - bpmFile string - isDependency bool - shouldFetch bool - pkgInfo *utils.PackageInfo - }]() - for _, pkg := range clone.Keys() { - value, _ := clone.Get(pkg) - resolved, unresolved := value.pkgInfo.ResolveAll(&[]string{}, &[]string{}, value.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 !reinstallAll && utils.IsPackageInstalled(depend, rootDir) { - continue - } - entry, _, err := utils.GetRepositoryEntry(depend) - if err != nil { - log.Fatalf("Error: could not find package (%s) in any repository\n", pkg) - } - pkgsToInstall.Set(depend, &struct { - bpmFile string - isDependency bool - shouldFetch bool - pkgInfo *utils.PackageInfo - }{bpmFile: "", isDependency: true, shouldFetch: true, pkgInfo: entry.Info}) - } - } - pkgsToInstall.Set(pkg, value) + // Resolve dependencies + err := operation.ResolveDependencies(reinstallAll, !noOptional, verbose) + if err != nil { + log.Fatalf("Error: could not resolve dependencies: %s\n", err) } - - // Show summary - if len(unresolvedDepends) != 0 { + if len(operation.UnresolvedDepends) != 0 { if !force { - log.Fatalf("Error: the following dependencies could not be found in any repositories: %s\n", strings.Join(unresolvedDepends, ", ")) + log.Fatalf("Error: the following dependencies could not be found in any repositories: %s\n", strings.Join(operation.UnresolvedDepends, ", ")) } else { - log.Println("Warning: The following dependencies could not be found in any repositories: " + strings.Join(unresolvedDepends, ", ")) + log.Println("Warning: The following dependencies could not be found in any repositories: " + strings.Join(operation.UnresolvedDepends, ", ")) } } - if pkgsToInstall.Len() == 0 { - fmt.Println("All packages are up to date!") - os.Exit(0) - } - for _, pkg := range pkgsToInstall.Keys() { - value, _ := pkgsToInstall.Get(pkg) - pkgInfo := value.pkgInfo - installedInfo := utils.GetPackageInfo(pkgInfo.Name, rootDir, false) - sourceInfo := "" - if pkgInfo.Type == "source" { - if rootDir != "/" && !force { - log.Fatalf("Error: cannot compile and install source packages to a different root directory") - } - sourceInfo = "(From Source)" - } + // Show operation summary + operation.ShowOperationSummary() - if installedInfo == nil { - fmt.Printf("%s: %s (Install) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), sourceInfo) - } else { - comparison := utils.ComparePackageVersions(*pkgInfo, *installedInfo) - if comparison < 0 { - fmt.Printf("%s: %s -> %s (Downgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), sourceInfo) - } else if comparison > 0 { - fmt.Printf("%s: %s -> %s (Upgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), sourceInfo) - } else { - fmt.Printf("%s: %s (Reinstall) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), sourceInfo) - } - } - } - if rootDir != "/" { - fmt.Println("Warning: Operating in " + rootDir) - } + // Confirmation Prompt if !yesAll { reader := bufio.NewReader(os.Stdin) - if pkgsToInstall.Len() == 1 { + if len(operation.Actions) == 1 { fmt.Printf("Do you wish to install this package? [y\\N] ") } else { - fmt.Printf("Do you wish to install these %d packages? [y\\N] ", pkgsToInstall.Len()) + fmt.Printf("Do you wish to install these %d packages? [y\\N] ", len(operation.Actions)) } text, _ := reader.ReadString('\n') if strings.TrimSpace(strings.ToLower(text)) != "y" && strings.TrimSpace(strings.ToLower(text)) != "yes" { - fmt.Println("Cancelling...") + fmt.Println("Cancelling package installation...") os.Exit(1) } } - // Fetch packages from repositories - fmt.Println("Fetching packages from available repositories...") - for _, pkg := range pkgsToInstall.Keys() { - value, _ := pkgsToInstall.Get(pkg) - if !value.shouldFetch { - continue - } - entry, repo, err := utils.GetRepositoryEntry(pkg) - if err != nil { - log.Fatalf("Error: could not find package (%s) in any repository\n", pkg) - } - fetchedPackage, err := repo.FetchPackage(entry.Info.Name) - 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) - value.bpmFile = fetchedPackage - pkgsToInstall.Set(pkg, value) - } - - // Install fetched packages - for _, pkg := range pkgsToInstall.Keys() { - value, _ := pkgsToInstall.Get(pkg) - pkgInfo := value.pkgInfo - var err error - if value.isDependency { - err = utils.InstallPackage(value.bpmFile, rootDir, verbose, true, buildSource, skipCheck, keepTempDir) - } else { - err = utils.InstallPackage(value.bpmFile, rootDir, verbose, force, buildSource, skipCheck, keepTempDir) - } - - if err != nil { - if pkgInfo.Type == "source" && keepTempDir { - fmt.Println("BPM temp directory was created at /var/tmp/bpm_source-" + pkgInfo.Name) - } - log.Fatalf("Error: could not install package (%s): %s\n", pkg, err) - } - fmt.Printf("Package (%s) was successfully installed\n", pkgInfo.Name) - if value.isDependency { - err := utils.SetInstallationReason(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 { - fmt.Println("** It is recommended you delete the temporary bpm folder in /var/tmp **") - } + // Execute operation + err = operation.Execute(verbose, force) + if err != nil { + log.Fatalf("Error: could not complete operation: %s\n", err) } case update: if os.Getuid() != 0 { @@ -374,145 +270,64 @@ func resolveCommand() { if err != nil { log.Fatalf("Error: could not get installed packages: %s\n", err) } - toUpdate := orderedmap.NewOrderedMap[string, *struct { - isDependency bool - entry *utils.RepositoryEntry - }]() + + operation := utils.BPMOperation{ + Actions: make([]utils.OperationAction, 0), + UnresolvedDepends: make([]string, 0), + RootDir: rootDir, + } + + // Search for packages for _, pkg := range pkgs { entry, _, err := utils.GetRepositoryEntry(pkg) if err != nil { continue } - installedInfo := utils.GetPackageInfo(pkg, rootDir, true) + installedInfo := utils.GetPackageInfo(pkg, rootDir) if installedInfo == nil { log.Fatalf("Error: could not get package info for (%s)\n", pkg) } else { comparison := utils.ComparePackageVersions(*entry.Info, *installedInfo) - if comparison > 0 { - toUpdate.Set(entry.Info.Name, &struct { - isDependency bool - entry *utils.RepositoryEntry - }{isDependency: false, entry: entry}) - } else if reinstall { - toUpdate.Set(entry.Info.Name, &struct { - isDependency bool - entry *utils.RepositoryEntry - }{isDependency: false, entry: entry}) + if comparison > 0 || reinstall { + operation.Actions = append(operation.Actions, &utils.FetchPackageAction{ + IsDependency: false, + RepositoryEntry: entry, + }) } } } - if toUpdate.Len() == 0 { - fmt.Println("All packages are up to date!") - os.Exit(0) - } // Check for new dependencies in updated packages - unresolved := make([]string, 0) - clone := toUpdate.Copy() - for _, key := range clone.Keys() { - pkg, _ := clone.Get(key) - r, u := pkg.entry.Info.ResolveAll(&[]string{}, &[]string{}, pkg.entry.Info.Type == "source", !noOptional, true, verbose, rootDir) - unresolved = append(unresolved, u...) - for _, depend := range r { - if _, ok := toUpdate.Get(depend); !ok { - entry, _, err := utils.GetRepositoryEntry(depend) - if err != nil { - log.Fatalf("Error: could not find package (%s) in any repository\n", depend) - } - toUpdate.Set(depend, &struct { - isDependency bool - entry *utils.RepositoryEntry - }{isDependency: true, entry: entry}) - } - } + err = operation.ResolveDependencies(reinstallAll, !noOptional, verbose) + if err != nil { + log.Fatalf("Error: could not resolve dependencies: %s\n", err) } - - if len(unresolved) != 0 { + if len(operation.UnresolvedDepends) != 0 { if !force { - log.Fatalf("Error: the following dependencies could not be found in any repositories: %s\n", strings.Join(unresolved, ", ")) + log.Fatalf("Error: the following dependencies could not be found in any repositories: %s\n", strings.Join(operation.UnresolvedDepends, ", ")) } else { - log.Printf("Warning: the following dependencies could not be found in any repositories: %s\n", strings.Join(unresolved, ", ")) + log.Println("Warning: The following dependencies could not be found in any repositories: " + strings.Join(operation.UnresolvedDepends, ", ")) } } - for _, key := range toUpdate.Keys() { - value, _ := toUpdate.Get(key) - installedInfo := utils.GetPackageInfo(value.entry.Info.Name, rootDir, true) - sourceInfo := "" - if value.entry.Info.Type == "source" { - sourceInfo = "(From Source)" - } - if installedInfo == nil { - fmt.Printf("%s: %s (Install) %s\n", value.entry.Info.Name, value.entry.Info.GetFullVersion(), sourceInfo) - continue - } else { - comparison := utils.ComparePackageVersions(*value.entry.Info, *installedInfo) - if comparison > 0 { - fmt.Printf("%s: %s -> %s (Upgrade) %s\n", value.entry.Info.Name, installedInfo.GetFullVersion(), value.entry.Info.GetFullVersion(), sourceInfo) - } else if reinstall { - fmt.Printf("%s: %s -> %s (Reinstall) %s\n", value.entry.Info.Name, installedInfo.GetFullVersion(), value.entry.Info.GetFullVersion(), sourceInfo) - } - } - } + // Show operation summary + operation.ShowOperationSummary() - // Update confirmation prompt + // Confirmation Prompt if !yesAll { - fmt.Printf("Are you sure you wish to update all %d packages? [y\\N] ", toUpdate.Len()) + fmt.Printf("Are you sure you wish to update all %d packages? [y\\N] ", len(operation.Actions)) reader := bufio.NewReader(os.Stdin) text, _ := reader.ReadString('\n') if strings.TrimSpace(strings.ToLower(text)) != "y" && strings.TrimSpace(strings.ToLower(text)) != "yes" { - fmt.Println("Cancelling update...") + fmt.Println("Cancelling package update...") os.Exit(1) } } - // Fetch packages - pkgsToInstall := orderedmap.NewOrderedMap[string, *struct { - isDependency bool - entry *utils.RepositoryEntry - }]() - fmt.Println("Fetching packages from available repositories...") - for _, pkg := range toUpdate.Keys() { - value, _ := toUpdate.Get(pkg) - entry, repo, err := utils.GetRepositoryEntry(pkg) - if err != nil { - log.Fatalf("Error: could not find package (%s) in any repository\n", pkg) - } - fetchedPackage, err := repo.FetchPackage(entry.Info.Name) - if err != nil { - log.Fatalf("Error: could not fetch package (%s): %s\n", pkg, err) - } - fmt.Printf("Package (%s) was successfully fetched!\n", value.entry.Info.Name) - pkgsToInstall.Set(fetchedPackage, value) - } - - // Install fetched packages - for _, pkg := range pkgsToInstall.Keys() { - value, _ := pkgsToInstall.Get(pkg) - pkgInfo := value.entry.Info - var err error - if value.isDependency { - err = utils.InstallPackage(pkg, rootDir, verbose, true, buildSource, skipCheck, keepTempDir) - } else { - err = utils.InstallPackage(pkg, rootDir, verbose, force, buildSource, skipCheck, keepTempDir) - } - - if err != nil { - if pkgInfo.Type == "source" && keepTempDir { - fmt.Println("BPM temp directory was created at /var/tmp/bpm_source-" + pkgInfo.Name) - } - log.Fatalf("Error: could not install package (%s): %s\n", pkg, err) - } - fmt.Printf("Package (%s) was successfully installed!\n", pkgInfo.Name) - if value.isDependency { - err := utils.SetInstallationReason(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 { - fmt.Println("** It is recommended you delete the temporary bpm folder in /var/tmp **") - } + // Execute operation + err = operation.Execute(verbose, force) + if err != nil { + log.Fatalf("Error: could not complete operation: %s\n", err) } case sync: if os.Getuid() != 0 { @@ -523,7 +338,7 @@ func resolveCommand() { reader := bufio.NewReader(os.Stdin) text, _ := reader.ReadString('\n') if strings.TrimSpace(strings.ToLower(text)) != "y" && strings.TrimSpace(strings.ToLower(text)) != "yes" { - fmt.Println("Cancelling sync...") + fmt.Println("Cancelling database synchronization...") os.Exit(1) } } @@ -544,32 +359,40 @@ func resolveCommand() { fmt.Println("No packages were given") return } - for _, pkg := range packages { - pkgInfo := utils.GetPackageInfo(pkg, rootDir, false) - if pkgInfo == nil { - fmt.Printf("Package (%s) could not be found\n", pkg) - continue - } - fmt.Println("----------------\n" + utils.CreateReadableInfo(false, false, false, pkgInfo, rootDir)) - fmt.Println("----------------") - if rootDir != "/" { - fmt.Println("Warning: Operating in " + rootDir) - } - if !yesAll { - reader := bufio.NewReader(os.Stdin) - fmt.Print("Do you wish to remove this package? [y\\N] ") - text, _ := reader.ReadString('\n') - if strings.TrimSpace(strings.ToLower(text)) != "y" && strings.TrimSpace(strings.ToLower(text)) != "yes" { - fmt.Printf("Skipping package (%s)...\n", pkgInfo.Name) - continue - } - } - err := utils.RemovePackage(pkg, verbose, rootDir) - if err != nil { - log.Fatalf("Error: could not remove package: %s\n", err) + operation := &utils.BPMOperation{ + Actions: make([]utils.OperationAction, 0), + UnresolvedDepends: make([]string, 0), + RootDir: rootDir, + } + + // Search for packages + for _, pkg := range packages { + bpmpkg := utils.GetPackage(pkg, rootDir) + if bpmpkg == nil { + log.Fatalf("Error: package (%s) could not be found\n", pkg) } - fmt.Printf("Package (%s) was successfully removed!\n", pkgInfo.Name) + operation.Actions = append(operation.Actions, &utils.RemovePackageAction{BpmPackage: bpmpkg}) + } + + // Show operation summary + operation.ShowOperationSummary() + + // Confirmation Prompt + if !yesAll { + fmt.Printf("Are you sure you wish to remove all %d packages? [y\\N] ", len(operation.Actions)) + reader := bufio.NewReader(os.Stdin) + text, _ := reader.ReadString('\n') + if strings.TrimSpace(strings.ToLower(text)) != "y" && strings.TrimSpace(strings.ToLower(text)) != "yes" { + fmt.Println("Cancelling package removal...") + os.Exit(1) + } + } + + // Execute operation + err := operation.Execute(verbose, force) + if err != nil { + log.Fatalf("Error: could not complete operation: %s\n", err) } case file: files := subcommandArgs @@ -605,7 +428,9 @@ func resolveCommand() { var pkgList []string for _, pkg := range pkgs { - if slices.Contains(utils.GetPackageFiles(pkg, rootDir), absFile) { + if slices.ContainsFunc(utils.GetPackageFiles(pkg, rootDir), func(entry *utils.PackageFileEntry) bool { + return entry.Path == absFile + }) { pkgList = append(pkgList, pkg) } } diff --git a/utils/extract_utils.go b/utils/extract_utils.go new file mode 100644 index 0000000..6c51928 --- /dev/null +++ b/utils/extract_utils.go @@ -0,0 +1,43 @@ +package utils + +import ( + "archive/tar" + "errors" + "io" + "os" +) + +type TarballFileReader struct { + tarReader *tar.Reader + file *os.File +} + +func ReadTarballContent(tarballPath, fileToExtract string) (*TarballFileReader, error) { + file, err := os.Open(tarballPath) + if err != nil { + return nil, err + } + + 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") + } + + return &TarballFileReader{ + tarReader: tr, + file: file, + }, nil + } + } + + return nil, errors.New("could not file in tarball") +} diff --git a/utils/general_utils.go b/utils/general_utils.go index ca568c1..dd1e812 100644 --- a/utils/general_utils.go +++ b/utils/general_utils.go @@ -1,18 +1,26 @@ package utils import ( + "fmt" "io" + "math" "os" - "os/exec" - "strings" + "syscall" ) func GetArch() string { - output, err := exec.Command("/usr/bin/uname", "-m").Output() + uname := syscall.Utsname{} + err := syscall.Uname(&uname) if err != nil { return "" } - return strings.TrimSpace(string(output)) + + var byteString [65]byte + var indexLength int + for ; uname.Machine[indexLength] != 0; indexLength++ { + byteString[indexLength] = uint8(uname.Machine[indexLength]) + } + return string(byteString[:indexLength]) } func copyFileContents(src, dst string) (err error) { @@ -47,12 +55,24 @@ func stringSliceRemove(s []string, r string) []string { return s } -func stringSliceRemoveEmpty(s []string) []string { - var r []string - for _, str := range s { - if str != "" { - r = append(r, str) +func UnsignedBytesToHumanReadable(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 r + return fmt.Sprintf("%.1fYiB", bf) +} + +func BytesToHumanReadable(b int64) 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) } diff --git a/utils/operations.go b/utils/operations.go new file mode 100644 index 0000000..57772d3 --- /dev/null +++ b/utils/operations.go @@ -0,0 +1,289 @@ +package utils + +import ( + "errors" + "fmt" + "log" + "os" + "slices" + "strings" +) + +type BPMOperation struct { + Actions []OperationAction + UnresolvedDepends []string + RootDir string +} + +func (operation *BPMOperation) ActionsContainPackage(pkg string) bool { + for _, action := range operation.Actions { + if action.GetActionType() == "install" { + if action.(*InstallPackageAction).BpmPackage.PkgInfo.Name == pkg { + return true + } + } else if action.GetActionType() == "fetch" { + if action.(*FetchPackageAction).RepositoryEntry.Info.Name == pkg { + return true + } + } else if action.GetActionType() == "remove" { + if action.(*RemovePackageAction).BpmPackage.PkgInfo.Name == pkg { + return true + } + } + } + return false +} + +func (operation *BPMOperation) InsertActionAt(index int, action OperationAction) { + if len(operation.Actions) == index { // nil or empty slice or after last element + operation.Actions = append(operation.Actions, action) + } + operation.Actions = append(operation.Actions[:index+1], operation.Actions[index:]...) // index < len(a) + operation.Actions[index] = action +} + +func (operation *BPMOperation) GetTotalDownloadSize() uint64 { + var ret uint64 = 0 + for _, action := range operation.Actions { + if action.GetActionType() == "fetch" { + ret += action.(*FetchPackageAction).RepositoryEntry.DownloadSize + } + } + return ret +} + +func (operation *BPMOperation) GetTotalInstalledSize() uint64 { + var ret uint64 = 0 + for _, action := range operation.Actions { + if action.GetActionType() == "install" { + ret += action.(*InstallPackageAction).BpmPackage.GetInstalledSize() + } else if action.GetActionType() == "fetch" { + ret += action.(*FetchPackageAction).RepositoryEntry.InstalledSize + } + } + return ret +} + +func (operation *BPMOperation) GetFinalActionSize(rootDir string) int64 { + var ret int64 = 0 + for _, action := range operation.Actions { + if action.GetActionType() == "install" { + ret += int64(action.(*InstallPackageAction).BpmPackage.GetInstalledSize()) + if IsPackageInstalled(action.(*InstallPackageAction).BpmPackage.PkgInfo.Name, rootDir) { + ret -= int64(GetPackage(action.(*InstallPackageAction).BpmPackage.PkgInfo.Name, rootDir).GetInstalledSize()) + } + } else if action.GetActionType() == "fetch" { + ret += int64(action.(*FetchPackageAction).RepositoryEntry.InstalledSize) + } else if action.GetActionType() == "remove" { + ret -= int64(action.(*RemovePackageAction).BpmPackage.GetInstalledSize()) + } + } + return ret +} + +func (operation *BPMOperation) ResolveDependencies(reinstallDependencies, installOptionalDependencies, verbose bool) error { + pos := 0 + for _, value := range slices.Clone(operation.Actions) { + var pkgInfo *PackageInfo + if value.GetActionType() == "install" { + action := value.(*InstallPackageAction) + pkgInfo = action.BpmPackage.PkgInfo + } else if value.GetActionType() == "fetch" { + action := value.(*FetchPackageAction) + pkgInfo = action.RepositoryEntry.Info + } else { + pos++ + continue + } + + resolved, unresolved := pkgInfo.ResolveDependencies(&[]string{}, &[]string{}, pkgInfo.Type == "source", installOptionalDependencies, !reinstallDependencies, verbose, operation.RootDir) + + operation.UnresolvedDepends = append(operation.UnresolvedDepends, unresolved...) + + for _, depend := range resolved { + if !operation.ActionsContainPackage(depend) && depend != pkgInfo.Name { + if !reinstallDependencies && IsPackageInstalled(depend, operation.RootDir) { + continue + } + entry, _, err := GetRepositoryEntry(depend) + if err != nil { + return errors.New("could not get repository entry for package (" + depend + ")") + } + operation.InsertActionAt(pos, &FetchPackageAction{ + IsDependency: true, + RepositoryEntry: entry, + }) + pos++ + } + } + pos++ + } + + return nil +} + +func (operation *BPMOperation) ShowOperationSummary() { + if len(operation.Actions) == 0 { + fmt.Println("All packages are up to date!") + os.Exit(0) + } + + for _, value := range operation.Actions { + var pkgInfo *PackageInfo + if value.GetActionType() == "install" { + pkgInfo = value.(*InstallPackageAction).BpmPackage.PkgInfo + } else if value.GetActionType() == "fetch" { + pkgInfo = value.(*FetchPackageAction).RepositoryEntry.Info + } else { + pkgInfo = value.(*RemovePackageAction).BpmPackage.PkgInfo + fmt.Printf("%s: %s (Remove)\n", pkgInfo.Name, pkgInfo.GetFullVersion()) + continue + } + + installedInfo := GetPackageInfo(pkgInfo.Name, operation.RootDir) + sourceInfo := "" + if pkgInfo.Type == "source" { + if operation.RootDir != "/" { + log.Fatalf("cannot compile and install source packages to a different root directory") + } + sourceInfo = "(From Source)" + } + + if installedInfo == nil { + fmt.Printf("%s: %s (Install) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), sourceInfo) + } else { + comparison := ComparePackageVersions(*pkgInfo, *installedInfo) + if comparison < 0 { + fmt.Printf("%s: %s -> %s (Downgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), sourceInfo) + } else if comparison > 0 { + fmt.Printf("%s: %s -> %s (Upgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), sourceInfo) + } else { + fmt.Printf("%s: %s (Reinstall) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), sourceInfo) + } + } + } + + if operation.RootDir != "/" { + fmt.Println("Warning: Operating in " + operation.RootDir) + } + if operation.GetTotalDownloadSize() > 0 { + fmt.Printf("%s will be downloaded to complete this operation\n", UnsignedBytesToHumanReadable(operation.GetTotalDownloadSize())) + } + if operation.GetFinalActionSize(operation.RootDir) > 0 { + fmt.Printf("A total of %s will be installed after the operation finishes\n", BytesToHumanReadable(operation.GetFinalActionSize(operation.RootDir))) + } else if operation.GetFinalActionSize(operation.RootDir) < 0 { + fmt.Printf("A total of %s will be freed after the operation finishes\n", strings.TrimPrefix(BytesToHumanReadable(operation.GetFinalActionSize(operation.RootDir)), "-")) + } +} + +func (operation *BPMOperation) Execute(verbose, force bool) error { + // Fetch packages from repositories + if slices.ContainsFunc(operation.Actions, func(action OperationAction) bool { + return action.GetActionType() == "fetch" + }) { + fmt.Println("Fetching packages from available repositories...") + for i, action := range operation.Actions { + if action.GetActionType() != "fetch" { + continue + } + entry := action.(*FetchPackageAction).RepositoryEntry + fetchedPackage, err := entry.Repository.FetchPackage(entry.Info.Name) + if err != nil { + return errors.New(fmt.Sprintf("could not fetch package (%s): %s\n", entry.Info.Name, err)) + } + bpmpkg, err := ReadPackage(fetchedPackage) + if err != nil { + return errors.New(fmt.Sprintf("could not fetch package (%s): %s\n", entry.Info.Name, err)) + } + fmt.Printf("Package (%s) was successfully fetched!\n", bpmpkg.PkgInfo.Name) + operation.Actions[i] = &InstallPackageAction{ + File: fetchedPackage, + IsDependency: action.(*FetchPackageAction).IsDependency, + BpmPackage: bpmpkg, + } + } + } + + // Determine words to be used for the following message + words := make([]string, 0) + if slices.ContainsFunc(operation.Actions, func(action OperationAction) bool { + return action.GetActionType() == "install" + }) { + words = append(words, "Installing") + } + + if slices.ContainsFunc(operation.Actions, func(action OperationAction) bool { + return action.GetActionType() == "remove" + }) { + words = append(words, "Removing") + } + + if len(words) == 0 { + return nil + } + fmt.Printf("%s packages...\n", strings.Join(words, "/")) + + // Installing/Removing packages from system + for _, action := range operation.Actions { + if action.GetActionType() == "remove" { + pkgInfo := action.(*RemovePackageAction).BpmPackage.PkgInfo + err := RemovePackage(pkgInfo.Name, verbose, operation.RootDir) + if err != nil { + return errors.New(fmt.Sprintf("could not remove package (%s): %s\n", pkgInfo.Name, err)) + } + } else if action.GetActionType() == "install" { + value := action.(*InstallPackageAction) + bpmpkg := value.BpmPackage + var err error + if value.IsDependency { + err = InstallPackage(value.File, operation.RootDir, verbose, true, false, false, false) + } else { + err = InstallPackage(value.File, operation.RootDir, verbose, force, false, false, false) + } + if err != nil { + return errors.New(fmt.Sprintf("could not install package (%s): %s\n", bpmpkg.PkgInfo.Name, err)) + } + fmt.Printf("Package (%s) was successfully installed\n", bpmpkg.PkgInfo.Name) + if value.IsDependency { + err := SetInstallationReason(bpmpkg.PkgInfo.Name, Dependency, operation.RootDir) + if err != nil { + return errors.New(fmt.Sprintf("could not set installation reason for package (%s): %s\n", value.BpmPackage.PkgInfo.Name, err)) + } + } + } + } + fmt.Println("Operation complete!") + + return nil +} + +type OperationAction interface { + GetActionType() string +} + +type InstallPackageAction struct { + File string + IsDependency bool + BpmPackage *BPMPackage +} + +func (action *InstallPackageAction) GetActionType() string { + return "install" +} + +type FetchPackageAction struct { + IsDependency bool + RepositoryEntry *RepositoryEntry +} + +func (action *FetchPackageAction) GetActionType() string { + return "fetch" +} + +type RemovePackageAction struct { + BpmPackage *BPMPackage +} + +func (action *RemovePackageAction) GetActionType() string { + return "remove" +} diff --git a/utils/package_utils.go b/utils/package_utils.go index 04b4435..1ef7f16 100644 --- a/utils/package_utils.go +++ b/utils/package_utils.go @@ -2,7 +2,6 @@ package utils import ( "archive/tar" - "bufio" "compress/gzip" "errors" "fmt" @@ -15,11 +14,17 @@ import ( "path" "path/filepath" "slices" + "sort" "strconv" "strings" "syscall" ) +type BPMPackage struct { + PkgInfo *PackageInfo + PkgFiles []*PackageFileEntry +} + type PackageInfo struct { Name string `yaml:"name,omitempty"` Description string `yaml:"description,omitempty"` @@ -37,6 +42,30 @@ type PackageInfo struct { Provides []string `yaml:"provides,omitempty"` } +type PackageFileEntry struct { + Path string + OctalPerms uint32 + 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) } @@ -62,11 +91,11 @@ func GetInstallationReason(pkg, rootDir string) InstallationReason { if stat, err := os.Stat(path.Join(pkgDir, "installation_reason")); err != nil || stat.IsDir() { return Manual } - bytes, err := os.ReadFile(path.Join(pkgDir, "installation_reason")) + b, err := os.ReadFile(path.Join(pkgDir, "installation_reason")) if err != nil { return Unknown } - reason := string(bytes) + reason := string(b) if reason == "manual" { return Manual } else if reason == "dependency" { @@ -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,22 @@ 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) { + fmt.Println("a") 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 +170,54 @@ 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)) - if err != nil { - return nil, err + } 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) < 5 { + return nil, errors.New("pkg.files is not formatted correctly") + } + octalPerms, err := strconv.ParseUint(stringEntry[len(stringEntry)-4], 8, 32) + if err != nil { + return nil, err + } + uid, err := strconv.ParseInt(stringEntry[len(stringEntry)-3], 0, 32) + if err != nil { + return nil, err + } + gid, err := strconv.ParseInt(stringEntry[len(stringEntry)-2], 0, 32) + if err != nil { + return nil, err + } + size, err := strconv.ParseUint(stringEntry[len(stringEntry)-1], 0, 64) + if err != nil { + return nil, err + } + pkgFiles = append(pkgFiles, &PackageFileEntry{ + Path: strings.Join(stringEntry[:len(stringEntry)-4], " "), + OctalPerms: uint32(octalPerms), + 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) { @@ -163,11 +228,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() @@ -178,41 +240,38 @@ func ReadPackageScripts(filename string) (map[string]string, error) { return nil, err } if header.Name == "pre_install.sh" { - bs, _ := io.ReadAll(tr) + bs, err := io.ReadAll(tr) if err != nil { return nil, err } ret[header.Name] = string(bs) } else if header.Name == "post_install.sh" { - bs, _ := io.ReadAll(tr) + bs, err := io.ReadAll(tr) if err != nil { return nil, err } ret[header.Name] = string(bs) } else if header.Name == "pre_update.sh" { - bs, _ := io.ReadAll(tr) + bs, err := io.ReadAll(tr) if err != nil { return nil, err } ret[header.Name] = string(bs) } else if header.Name == "post_update.sh" { - bs, _ := io.ReadAll(tr) + bs, err := io.ReadAll(tr) if err != nil { return nil, err } ret[header.Name] = string(bs) } else if header.Name == "post_remove.sh" { - bs, _ := io.ReadAll(tr) + bs, err := io.ReadAll(tr) if err != nil { return nil, err } 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 +316,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).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).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]) } @@ -373,11 +432,11 @@ func ReadPackageInfo(contents string) (*PackageInfo, error) { } func CreateInfoFile(pkgInfo *PackageInfo) string { - bytes, err := yaml.Marshal(&pkgInfo) + b, err := yaml.Marshal(&pkgInfo) if err != nil { return "" } - return string(bytes) + return string(b) } func CreateReadableInfo(showArchitecture, showType, showPackageRelations bool, pkgInfo *PackageInfo, rootDir string) string { @@ -411,128 +470,125 @@ func CreateReadableInfo(showArchitecture, showType, showPackageRelations bool, p return strings.Join(ret, "\n") } -func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string) (error, []string) { - var files []string - if !IsPackageInstalled(pkgInfo.Name, rootDir) { +func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string) error { + if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) { err := ExecutePackageScripts(filename, rootDir, Install, false) if err != nil { - return err, nil + return err } } else { err := ExecutePackageScripts(filename, rootDir, Update, false) if err != nil { - return err, nil + return err } } seenHardlinks := make(map[string]string) file, err := os.Open(filename) if err != nil { - return err, nil + return err } - archive, err := gzip.NewReader(file) + + tarballFile, err := ReadTarballContent(filename, "files.tar.gz") if err != nil { - return err, nil + return err } - tr := tar.NewReader(archive) + defer tarballFile.file.Close() + + archive, err := gzip.NewReader(tarballFile.tarReader) + if err != nil { + return err + } + packageFilesReader := tar.NewReader(archive) for { - header, err := tr.Next() + header, err := packageFilesReader.Next() if err == io.EOF { break } if err != nil { - return err, nil + return err } - if strings.HasPrefix(header.Name, "files/") && header.Name != "files/" { - trimmedName := strings.TrimPrefix(header.Name, "files/") - extractFilename := path.Join(rootDir, trimmedName) - switch header.Typeflag { - case tar.TypeDir: - files = append(files, strings.TrimPrefix(header.Name, "files/")) - if err := os.Mkdir(extractFilename, 0755); err != nil { - if !os.IsExist(err) { - return err, nil - } - } else { - if verbose { - fmt.Println("Creating Directory: " + extractFilename) - } + extractFilename := path.Join(rootDir, header.Name) + switch header.Typeflag { + case tar.TypeDir: + if err := os.Mkdir(extractFilename, 0755); err != nil { + if !os.IsExist(err) { + return err } - case tar.TypeReg: - skip := false - if _, err := os.Stat(extractFilename); err == nil { - for _, k := range 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/")) - skip = true - continue + } else { + if verbose { + fmt.Println("Creating Directory: " + extractFilename) + } + } + case tar.TypeReg: + skip := false + if _, err := os.Stat(extractFilename); err == nil { + for _, k := range bpmpkg.PkgInfo.Keep { + if strings.HasSuffix(k, "/") { + if strings.HasPrefix(header.Name, k) { + if verbose { + fmt.Println("Skipping File: " + extractFilename + " (Containing directory is set to be kept during reinstalls/updates)") } - } else { - if trimmedName == k { - if verbose { - fmt.Println("Skipping File: " + extractFilename + " (File is configured to be kept during installs/updates)") - } - files = append(files, strings.TrimPrefix(header.Name, "files/")) - skip = true - continue + skip = true + continue + } + } else { + if header.Name == k { + if verbose { + fmt.Println("Skipping File: " + extractFilename + " (File is configured to be kept during reinstalls/updates)") } + 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 + } + outFile, err := os.Create(extractFilename) + if verbose { + fmt.Println("Creating File: " + extractFilename) + } + if err != nil { + return err + } + if _, err := io.Copy(outFile, packageFilesReader); err != nil { + return err + } + if err := os.Chmod(extractFilename, header.FileInfo().Mode()); err != nil { + return err + } + err = outFile.Close() + if err != nil { + return err + } + case tar.TypeSymlink: + if verbose { + fmt.Println("Creating Symlink: " + extractFilename + " -> " + header.Linkname) + } + err := os.Remove(extractFilename) + if err != nil && !os.IsNotExist(err) { + return err + } + err = os.Symlink(header.Linkname, extractFilename) + if err != nil { + return err + } + case tar.TypeLink: + if verbose { + fmt.Println("Detected Hard Link: " + extractFilename + " -> " + path.Join(rootDir, strings.TrimPrefix(header.Linkname, "files/"))) + } + seenHardlinks[extractFilename] = path.Join(strings.TrimPrefix(header.Linkname, "files/")) + err := os.Remove(extractFilename) + if err != nil && !os.IsNotExist(err) { + return err + } + default: + return errors.New("unknown type (" + strconv.Itoa(int(header.Typeflag)) + ") in " + extractFilename) } } for extractFilename, destination := range seenHardlinks { @@ -541,12 +597,12 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string } err := os.Link(path.Join(rootDir, destination), extractFilename) if err != nil { - return err, nil + return err } } defer archive.Close() defer file.Close() - return nil, files + return nil } func isSplitPackage(filename string) bool { @@ -554,7 +610,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 +620,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 +638,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 @@ -686,11 +739,8 @@ func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, bin if _, err := os.Stat(path.Join(temp, "source.sh")); os.IsNotExist(err) { return errors.New("source.sh file could not be found in the temporary build directory"), nil } - if err != nil { - 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 +850,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 +914,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 +983,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 +1041,6 @@ fi return errors.New("no output files for source package. Cancelling package installation"), nil } - defer archive.Close() defer file.Close() return nil, files } @@ -1000,55 +1049,138 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc, if _, err := os.Stat(filename); os.IsNotExist(err) { return err } - 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) + // Check if package is installed and remove current files if packageInstalled { - oldFiles = GetPackageFiles(pkgInfo.Name, rootDir) - } - if !force { - if pkgInfo.Arch != "any" && 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 { - return errors.New("the following dependencies are not installed: " + strings.Join(unresolved, ", ")) - } - } - if pkgInfo.Type == "binary" { - err, i := extractPackage(pkgInfo, verbose, filename, rootDir) + // Fetching and reversing package file entry list + fileEntries := GetPackageFiles(bpmpkg.PkgInfo.Name, rootDir) + sort.Slice(fileEntries, func(i, j int) bool { + return fileEntries[i].Path < fileEntries[j].Path + }) + slices.Reverse(fileEntries) + files, err := GetAllPackageFiles(rootDir, bpmpkg.PkgInfo.Name) if err != nil { return err } - files = i - } else if pkgInfo.Type == "source" { + + // Removing old package files + if verbose { + fmt.Printf("Removing old files for package (%s)...\n", bpmpkg.PkgInfo.Name) + } + for _, entry := range fileEntries { + file := path.Join(rootDir, entry.Path) + stat, err := os.Lstat(file) + if os.IsNotExist(err) { + continue + } + if err != nil { + return err + } + if len(files[entry.Path]) != 0 { + if verbose { + fmt.Println("Skipping path: " + file + " (Path is managed by multiple packages)") + } + continue + } + shouldContinue := false + for _, value := range bpmpkg.PkgInfo.Keep { + if strings.HasSuffix(value, "/") { + if strings.HasPrefix(entry.Path, value) || entry.Path == strings.TrimSuffix(value, "/") { + if verbose { + fmt.Println("Skipping path: " + file + " (Path is set to be kept during reinstalls/updates)") + } + shouldContinue = true + continue + } + } else { + if entry.Path == value { + if verbose { + fmt.Println("Skipping path: " + file + " (Path is set to be kept during reinstalls/updates)") + } + shouldContinue = true + continue + } + } + } + if shouldContinue { + continue + } + if stat.Mode()&os.ModeSymlink != 0 { + if verbose { + fmt.Println("Removing: " + file) + } + err := os.Remove(file) + if err != nil { + return err + } + continue + } + if stat.IsDir() { + dir, err := os.ReadDir(file) + if err != nil { + return err + } + if len(dir) != 0 { + if verbose { + fmt.Println("Skipping non-empty directory: " + file) + } + continue + } + if verbose { + fmt.Println("Removing: " + file) + } + err = os.Remove(file) + if err != nil { + return err + } + } else { + if verbose { + fmt.Println("Removing: " + file) + } + err := os.Remove(file) + if err != nil { + return err + } + } + } + } + if !force { + if bpmpkg.PkgInfo.Arch != "any" && bpmpkg.PkgInfo.Arch != GetArch() { + return errors.New("cannot install a package with a different architecture") + } + } + + if verbose { + fmt.Printf("Extracting files for package (%s)...\n", bpmpkg.PkgInfo.Name) + } + + if bpmpkg.PkgInfo.Type == "binary" { + err := extractPackage(bpmpkg, verbose, filename, rootDir) + if err != nil { + return err + } + } 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, _ := 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) - - filesDiff := slices.DeleteFunc(oldFiles, func(f string) bool { - return slices.Contains(files, f) - }) installedDir := path.Join(rootDir, "var/lib/bpm/installed/") err = os.MkdirAll(installedDir, 0755) 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 @@ -1062,13 +1194,14 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc, if err != nil { return err } - for _, line := range files { - _, err := f.WriteString(line + "\n") - if err != nil { - return err - } + + tarballFile, err := ReadTarballContent(filename, "pkg.files") + if err != nil { + return err } - err = f.Close() + defer tarballFile.file.Close() + + _, err = io.Copy(f, tarballFile.tarReader) if err != nil { return err } @@ -1109,79 +1242,6 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc, } } - if len(filesDiff) != 0 { - fmt.Println("Removing obsolete files...") - var symlinks []string - for _, f := range filesDiff { - f = path.Join(rootDir, f) - lstat, err := os.Lstat(f) - if os.IsNotExist(err) { - continue - } else if err != nil { - return err - } - if lstat.Mode()&os.ModeSymlink != 0 { - symlinks = append(symlinks, f) - continue - } - stat, err := os.Stat(f) - if os.IsNotExist(err) { - continue - } else if err != nil { - return err - } - if stat.IsDir() { - dir, err := os.ReadDir(f) - if err != nil { - return err - } - if len(dir) == 0 { - if verbose { - fmt.Println("Removing: " + f) - } - err := os.Remove(f) - if err != nil { - return err - } - } - } else { - if verbose { - fmt.Println("Removing: " + f) - } - err := os.Remove(f) - if err != nil { - return err - } - } - } - removals := -1 - for len(symlinks) > 0 && removals != 0 { - removals = 0 - for i := len(symlinks) - 1; i >= 0; i-- { - f := symlinks[i] - f = path.Join(rootDir, f) - _, err := os.Lstat(f) - if os.IsNotExist(err) { - continue - } else if err != nil { - return err - } - _, err = filepath.EvalSymlinks(f) - if os.IsNotExist(err) { - err := os.Remove(f) - if err != nil { - return err - } - removals++ - if verbose { - fmt.Println("Removing: " + f) - } - } else if err != nil { - return err - } - } - } - } if !packageInstalled { err = ExecutePackageScripts(filename, rootDir, Install, true) if err != nil { @@ -1196,47 +1256,6 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc, return nil } -func GetSourceScript(filename string) (string, error) { - pkgInfo, err := ReadPackage(filename) - if err != nil { - return "", err - } - if 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) - for { - header, err := tr.Next() - if err == io.EOF { - break - } - if header.Name == "source.sh" { - err := archive.Close() - if err != nil { - return "", err - } - err = file.Close() - if err != nil { - return "", err - } - bs, err := io.ReadAll(tr) - if err != nil { - return "", err - } - return string(bs), nil - } - } - return "", errors.New("package does not contain a source.sh file") -} - func (pkgInfo *PackageInfo) GetAllDependencies(checkMake, checkOptional bool) []string { allDepends := make([]string, 0) allDepends = append(allDepends, pkgInfo.Depends...) @@ -1284,7 +1303,7 @@ func (pkgInfo *PackageInfo) CheckConflicts(rootDir string) []string { return ret } -func (pkgInfo *PackageInfo) ResolveAll(resolved, unresolved *[]string, checkMake, checkOptional, ignoreInstalled, verbose bool, rootDir string) ([]string, []string) { +func (pkgInfo *PackageInfo) ResolveDependencies(resolved, unresolved *[]string, checkMake, checkOptional, ignoreInstalled, verbose bool, rootDir string) ([]string, []string) { *unresolved = append(*unresolved, pkgInfo.Name) for _, depend := range pkgInfo.GetAllDependencies(checkMake, checkOptional) { depend = strings.TrimSpace(depend) @@ -1308,7 +1327,7 @@ func (pkgInfo *PackageInfo) ResolveAll(resolved, unresolved *[]string, checkMake } continue } - entry.Info.ResolveAll(resolved, unresolved, checkMake, checkOptional, ignoreInstalled, verbose, rootDir) + entry.Info.ResolveDependencies(resolved, unresolved, checkMake, checkOptional, ignoreInstalled, verbose, rootDir) } } if !slices.Contains(*resolved, pkgInfo.Name) { @@ -1336,7 +1355,7 @@ func IsPackageProvided(pkg, rootDir string) bool { if p == pkg { return true } - i := GetPackageInfo(p, rootDir, true) + i := GetPackageInfo(p, rootDir) if i == nil { continue } @@ -1363,8 +1382,8 @@ func GetInstalledPackages(rootDir string) ([]string, error) { return ret, nil } -func GetPackageFiles(pkg, rootDir string) []string { - var ret []string +func GetPackageFiles(pkg, rootDir string) []*PackageFileEntry { + var pkgFiles []*PackageFileEntry installedDir := path.Join(rootDir, "var/lib/bpm/installed/") pkgDir := path.Join(installedDir, pkg) files := path.Join(pkgDir, "files") @@ -1374,18 +1393,55 @@ func GetPackageFiles(pkg, rootDir string) []string { if _, err := os.Stat(pkgDir); os.IsNotExist(err) { return nil } - file, err := os.Open(files) + bs, err := os.ReadFile(files) if err != nil { return nil } - scanner := bufio.NewScanner(file) - for scanner.Scan() { - ret = append(ret, scanner.Text()) + + for _, line := range strings.Split(string(bs), "\n") { + if strings.TrimSpace(line) == "" { + continue + } + stringEntry := strings.Split(strings.TrimSpace(line), " ") + if len(stringEntry) < 5 { + pkgFiles = append(pkgFiles, &PackageFileEntry{ + Path: strings.TrimSuffix(line, "/"), + OctalPerms: 0, + UserID: 0, + GroupID: 0, + SizeInBytes: 0, + }) + continue + } + uid, err := strconv.ParseInt(stringEntry[len(stringEntry)-4], 0, 32) + if err != nil { + return nil + } + octalPerms, err := strconv.ParseInt(stringEntry[len(stringEntry)-3], 0, 32) + if err != nil { + return nil + } + gid, err := strconv.ParseInt(stringEntry[len(stringEntry)-2], 0, 32) + if err != nil { + return nil + } + size, err := strconv.ParseUint(stringEntry[len(stringEntry)-1], 0, 64) + if err != nil { + return nil + } + pkgFiles = append(pkgFiles, &PackageFileEntry{ + Path: strings.TrimSuffix(strings.Join(stringEntry[:len(stringEntry)-4], " "), "/"), + OctalPerms: uint32(octalPerms), + UserID: int(uid), + GroupID: int(gid), + SizeInBytes: size, + }) } - return ret + + return pkgFiles } -func GetPackageInfo(pkg, rootDir string, defaultValues bool) *PackageInfo { +func GetPackageInfo(pkg, rootDir string) *PackageInfo { installedDir := path.Join(rootDir, "var/lib/bpm/installed/") pkgDir := path.Join(installedDir, pkg) files := path.Join(pkgDir, "info") @@ -1410,17 +1466,67 @@ func GetPackageInfo(pkg, rootDir string, defaultValues bool) *PackageInfo { return info } +func GetPackage(pkg, rootDir string) *BPMPackage { + if !IsPackageInstalled(pkg, rootDir) { + return nil + } + + return &BPMPackage{ + PkgInfo: GetPackageInfo(pkg, rootDir), + PkgFiles: GetPackageFiles(pkg, rootDir), + } +} + +func GetAllPackageFiles(rootDir string, excludePackages ...string) (map[string][]*BPMPackage, error) { + ret := make(map[string][]*BPMPackage) + + pkgNames, err := GetInstalledPackages(rootDir) + if err != nil { + return nil, err + } + + for _, pkgName := range pkgNames { + if slices.Contains(excludePackages, pkgName) { + continue + } + bpmpkg := GetPackage(pkgName, rootDir) + if bpmpkg == nil { + return nil, errors.New(fmt.Sprintf("could not get BPM package (%s)", pkgName)) + } + for _, entry := range bpmpkg.PkgFiles { + if _, ok := ret[entry.Path]; ok { + ret[entry.Path] = append(ret[entry.Path], bpmpkg) + } else { + ret[entry.Path] = []*BPMPackage{bpmpkg} + } + } + } + + return ret, nil +} + func RemovePackage(pkg string, verbose bool, rootDir string) error { installedDir := path.Join(rootDir, "var/lib/bpm/installed/") pkgDir := path.Join(installedDir, pkg) - pkgInfo := GetPackageInfo(pkg, rootDir, false) + pkgInfo := GetPackageInfo(pkg, rootDir) if pkgInfo == nil { return errors.New("could not get package info") } - files := GetPackageFiles(pkg, rootDir) - var symlinks []string - for _, file := range files { - file = path.Join(rootDir, file) + + // Fetching and reversing package file entry list + fileEntries := GetPackageFiles(pkg, rootDir) + sort.Slice(fileEntries, func(i, j int) bool { + return fileEntries[i].Path < fileEntries[j].Path + }) + slices.Reverse(fileEntries) + files, err := GetAllPackageFiles(rootDir, pkg) + if err != nil { + return err + } + + // Removing package files + for _, entry := range fileEntries { + file := path.Join(rootDir, entry.Path) lstat, err := os.Lstat(file) if os.IsNotExist(err) { continue @@ -1428,8 +1534,20 @@ func RemovePackage(pkg string, verbose bool, rootDir string) error { if err != nil { return err } + if len(files[entry.Path]) != 0 { + if verbose { + fmt.Println("Skipping path: " + file + "(Path is managed by multiple packages)") + } + continue + } if lstat.Mode()&os.ModeSymlink != 0 { - symlinks = append(symlinks, file) + if verbose { + fmt.Println("Removing: " + file) + } + err := os.Remove(file) + if err != nil { + return err + } continue } stat, err := os.Stat(file) @@ -1444,14 +1562,18 @@ func RemovePackage(pkg string, verbose bool, rootDir string) error { if err != nil { return err } - if len(dir) == 0 { + if len(dir) != 0 { if verbose { - fmt.Println("Removing: " + file) - } - err := os.Remove(file) - if err != nil { - return err + fmt.Println("Skipping non-empty directory: " + file) } + continue + } + if verbose { + fmt.Println("Removing: " + file) + } + err = os.Remove(file) + if err != nil { + return err } } else { if verbose { @@ -1463,33 +1585,8 @@ func RemovePackage(pkg string, verbose bool, rootDir string) error { } } } - removals := -1 - for len(symlinks) > 0 && removals != 0 { - removals = 0 - for i := len(symlinks) - 1; i >= 0; i-- { - file := symlinks[i] - file = path.Join(rootDir, file) - _, err := os.Lstat(file) - if os.IsNotExist(err) { - continue - } else if err != nil { - return err - } - _, err = filepath.EvalSymlinks(file) - if os.IsNotExist(err) { - err := os.Remove(file) - if err != nil { - return err - } - removals++ - if verbose { - fmt.Println("Removing: " + file) - } - } else if err != nil { - return err - } - } - } + + // Executing post_remove script if _, err := os.Stat(path.Join(pkgDir, "post_remove.sh")); err == nil { cmd := exec.Command("/bin/bash", path.Join(pkgDir, "post_remove.sh")) if !BPMConfig.SilentCompilation { @@ -1524,12 +1621,15 @@ func RemovePackage(pkg string, verbose bool, rootDir string) error { return err } } - err := os.RemoveAll(pkgDir) - if err != nil { - return err - } + + // Removing package directory if verbose { fmt.Println("Removing: " + pkgDir) } + err = os.RemoveAll(pkgDir) + if err != nil { + return err + } + return nil } diff --git a/utils/repo_utils.go b/utils/repo_utils.go index d28ae00..28fdaeb 100644 --- a/utils/repo_utils.go +++ b/utils/repo_utils.go @@ -22,7 +22,10 @@ type Repository struct { type RepositoryEntry struct { Info *PackageInfo `yaml:"info"` Download string `yaml:"download"` + DownloadSize uint64 `yaml:"download_size"` + InstalledSize uint64 `yaml:"installed_size"` IsVirtualPackage bool `yaml:"-"` + Repository *Repository } func (repo *Repository) ContainsPackage(pkg string) bool { @@ -63,7 +66,10 @@ func (repo *Repository) ReadLocalDatabase() error { Provides: make([]string, 0), }, Download: "", + DownloadSize: 0, + InstalledSize: 0, IsVirtualPackage: false, + Repository: repo, } err := yaml.Unmarshal([]byte(b), &entry) if err != nil { @@ -84,7 +90,10 @@ func (repo *Repository) ReadLocalDatabase() error { entry := RepositoryEntry{ Info: repo.Entries[value[0]].Info, Download: repo.Entries[value[0]].Download, + DownloadSize: repo.Entries[value[0]].DownloadSize, + InstalledSize: repo.Entries[value[0]].InstalledSize, IsVirtualPackage: true, + Repository: repo, } repo.Entries[key] = &entry }