From 123697e1dc14ead88f7edf0779d2428db64d5eb5 Mon Sep 17 00:00:00 2001 From: EnumDev Date: Wed, 28 Aug 2024 10:34:27 +0300 Subject: [PATCH] Added basic remote repository functionality --- config/bpm.conf | 6 +- main.go | 97 +++++++++++++++++++++++-- utils/config.go | 23 ++++-- utils/package_utils.go | 9 +++ utils/repo_utils.go | 161 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 280 insertions(+), 16 deletions(-) create mode 100644 utils/repo_utils.go diff --git a/config/bpm.conf b/config/bpm.conf index d2649af..6b92f57 100644 --- a/config/bpm.conf +++ b/config/bpm.conf @@ -1,4 +1,8 @@ compilation_env: [] silent_compilation: false compilation_dir: "/var/tmp/" -binary_output_dir: "/var/lib/bpm/compiled/" \ No newline at end of file +binary_output_dir: "/var/lib/bpm/compiled/" +repositories: + - name: example-repository + source: https://my-repo.xyz/ + disabled: true \ No newline at end of file diff --git a/main.go b/main.go index f16b05f..8676752 100644 --- a/main.go +++ b/main.go @@ -29,10 +29,12 @@ var yesAll = false var buildSource = false var skipCheck = false var keepTempDir = false -var forceInstall = false +var force = false var showInstalled = false var pkgListNumbers = false var pkgListNames = false +var reinstall = false +var nosync = true func main() { utils.ReadConfig() @@ -48,6 +50,8 @@ const ( info list install + update + sync remove file ) @@ -62,6 +66,10 @@ func getCommandType() commandType { return list case "install": return install + case "update": + return update + case "sync": + return sync case "remove": return remove case "file": @@ -91,16 +99,23 @@ func resolveCommand() { continue } - } else { + } else if showInstalled { info = utils.GetPackageInfo(pkg, rootDir, false) if info == nil { - fmt.Printf("Package (%s) could not be found\n", pkg) + fmt.Printf("Package (%s) is not installed\n", pkg) continue } + } else { + entry, err := utils.GetRepositoryEntry(pkg) + if err != nil { + fmt.Printf("Package (%s) could not be found in any repository\n", pkg) + continue + } + info = &entry.Info } fmt.Println("----------------") if showInstalled { - fmt.Println(utils.CreateReadableInfo(false, false, true, false, true, info, rootDir)) + fmt.Println(utils.CreateReadableInfo(true, true, true, false, true, info, rootDir)) } else { fmt.Println(utils.CreateReadableInfo(true, true, true, true, true, info, rootDir)) } @@ -164,7 +179,7 @@ func resolveCommand() { } verb = "build" } - if !forceInstall { + if !force { if pkgInfo.Arch != "any" && pkgInfo.Arch != utils.GetArch() { fmt.Printf("skipping... cannot %s a package with a different architecture\n", verb) continue @@ -226,7 +241,7 @@ func resolveCommand() { } } - err = utils.InstallPackage(file, rootDir, verbose, forceInstall, buildSource, skipCheck, keepTempDir) + err = utils.InstallPackage(file, 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) @@ -238,6 +253,34 @@ func resolveCommand() { fmt.Println("** It is recommended you delete the temporary bpm folder in /var/tmp **") } } + case sync: + if os.Getuid() != 0 { + fmt.Println("This subcommand needs to be run with superuser permissions") + os.Exit(0) + } + if !yesAll { + fmt.Printf("Are you sure you wish to sync all databases? [y\\N] ") + 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...") + os.Exit(0) + } + } + for _, repo := range utils.BPMConfig.Repositories { + if repo.Disabled { + if verbose { + fmt.Printf("Skipping repository (%s) because it is disabled\n", repo.Name) + } + continue + } + fmt.Printf("Fetching package database for repository (%s)...\n", repo.Name) + err := repo.SyncLocalDatabase() + if err != nil { + log.Fatal(err) + } + } + fmt.Println("All package databases synced successfully!") case remove: if os.Getuid() != 0 { fmt.Println("This subcommand needs to be run with superuser permissions") @@ -344,11 +387,22 @@ func printHelp() { fmt.Println(" -R= lets you define the root path which will be used") fmt.Println(" -v Show additional information about what BPM is doing") fmt.Println(" -y skips the confirmation prompt") - fmt.Println(" -f skips dependency and architecture checking") + fmt.Println(" -f skips dependency, conflict and architecture checking") fmt.Println(" -o= set the binary package output directory (defaults to /var/lib/bpm/compiled)") fmt.Println(" -c= set the compilation directory (defaults to /var/tmp)") fmt.Println(" -b creates a binary package from a source package after compilation and saves it in the binary package output directory") fmt.Println(" -k keeps the compilation directory created by BPM after source package installation") + fmt.Println("-> bpm update [-R, -v, -y, -f, --reinstall, --nosync] | updates all packages that are available in the repositories") + fmt.Println(" -R= lets you define the root path which will be used") + fmt.Println(" -v Show additional information about what BPM is doing") + fmt.Println(" -y skips the confirmation prompt") + fmt.Println(" -f skips dependency, conflict and architecture checking") + fmt.Println(" --reinstall Fetches and reinstalls all packages even if they do not have a newer version available") + fmt.Println(" --nosync Skips package database syncing") + fmt.Println("-> bpm sync [-R, -v] | Syncs package databases without updating packages") + fmt.Println(" -R= lets you define the root path which will be used") + fmt.Println(" -v Show additional information about what BPM is doing") + fmt.Println(" -y skips the confirmation prompt") fmt.Println("-> bpm remove [-R, -v, -y] | removes the following packages") fmt.Println(" -v Show additional information about what BPM is doing") fmt.Println(" -R= lets you define the root path which will be used") @@ -380,8 +434,23 @@ func resolveFlags() { installFlagSet.BoolVar(&buildSource, "b", false, "Build binary package from source package") installFlagSet.BoolVar(&skipCheck, "s", false, "Skip check function during source compilation") installFlagSet.BoolVar(&keepTempDir, "k", false, "Keep temporary directory after source compilation") - installFlagSet.BoolVar(&forceInstall, "f", false, "Force installation by skipping architecture and dependency resolution") + installFlagSet.BoolVar(&force, "f", false, "Force installation by skipping architecture and dependency resolution") installFlagSet.Usage = printHelp + // Update flags + updateFlagSet := flag.NewFlagSet("Update flags", flag.ExitOnError) + updateFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root") + updateFlagSet.BoolVar(&verbose, "v", false, "Show additional information about what BPM is doing") + updateFlagSet.BoolVar(&yesAll, "y", false, "Skip confirmation prompts") + updateFlagSet.BoolVar(&force, "f", false, "Force update by skipping architecture and dependency resolution") + updateFlagSet.BoolVar(&reinstall, "reinstall", false, "Fetches and reinstalls all packages even if they do not have a newer version available") + updateFlagSet.BoolVar(&nosync, "nosync", false, "Skips package database syncing") + updateFlagSet.Usage = printHelp + // Sync flags + syncFlagSet := flag.NewFlagSet("Sync flags", flag.ExitOnError) + syncFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root") + syncFlagSet.BoolVar(&verbose, "v", false, "Show additional information about what BPM is doing") + syncFlagSet.BoolVar(&yesAll, "y", false, "Skip confirmation prompts") + syncFlagSet.Usage = printHelp // Remove flags removeFlagSet := flag.NewFlagSet("Remove flags", flag.ExitOnError) removeFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root") @@ -415,6 +484,18 @@ func resolveFlags() { return } subcommandArgs = installFlagSet.Args() + } else if getCommandType() == update { + err := updateFlagSet.Parse(subcommandArgs) + if err != nil { + return + } + subcommandArgs = updateFlagSet.Args() + } else if getCommandType() == sync { + err := syncFlagSet.Parse(subcommandArgs) + if err != nil { + return + } + subcommandArgs = syncFlagSet.Args() } else if getCommandType() == remove { err := removeFlagSet.Parse(subcommandArgs) if err != nil { diff --git a/utils/config.go b/utils/config.go index 9fd0a81..833a063 100644 --- a/utils/config.go +++ b/utils/config.go @@ -2,14 +2,16 @@ package utils import ( "gopkg.in/yaml.v3" + "log" "os" ) type BPMConfigStruct struct { - CompilationEnv []string `yaml:"compilation_env"` - SilentCompilation bool `yaml:"silent_compilation"` - BinaryOutputDir string `yaml:"binary_output_dir"` - CompilationDir string `yaml:"compilation_dir"` + CompilationEnv []string `yaml:"compilation_env"` + SilentCompilation bool `yaml:"silent_compilation"` + BinaryOutputDir string `yaml:"binary_output_dir"` + CompilationDir string `yaml:"compilation_dir"` + Repositories []*Repository `yaml:"repositories"` } var BPMConfig BPMConfigStruct = BPMConfigStruct{ @@ -21,14 +23,21 @@ var BPMConfig BPMConfigStruct = BPMConfigStruct{ func ReadConfig() { if _, err := os.Stat("/etc/bpm.conf"); os.IsNotExist(err) { - return + log.Fatal(err) } bytes, err := os.ReadFile("/etc/bpm.conf") if err != nil { - return + log.Fatal(err) } err = yaml.Unmarshal(bytes, &BPMConfig) if err != nil { - return + log.Fatal(err) + } + for _, repo := range BPMConfig.Repositories { + repo.Entries = make(map[string]*RepositoryEntry) + err := repo.ReadLocalDatabase() + if err != nil { + log.Fatal(err) + } } } diff --git a/utils/package_utils.go b/utils/package_utils.go index ddec923..2916824 100644 --- a/utils/package_utils.go +++ b/utils/package_utils.go @@ -403,6 +403,15 @@ func CreateReadableInfo(showArchitecture, showType, showPackageRelations, showRe appendMap("Conditional conflicting packages", pkgInfo.ConditionalConflicts) appendMap("Conditional optional dependencies", pkgInfo.ConditionalOptional) } + if showRemoteInfo { + arr := make([]string, 0) + for _, repo := range BPMConfig.Repositories { + if repo.ContainsPackage(pkgInfo.Name) { + arr = append(arr, repo.Name) + } + } + appendArray("Repositories", arr) + } if showInstallationReason { if IsPackageInstalled(pkgInfo.Name, rootDir) { ret = append(ret, "Installed: yes") diff --git a/utils/repo_utils.go b/utils/repo_utils.go new file mode 100644 index 0000000..28b4583 --- /dev/null +++ b/utils/repo_utils.go @@ -0,0 +1,161 @@ +package utils + +import ( + "errors" + "gopkg.in/yaml.v3" + "io" + "net/http" + "net/url" + "os" + "path" + "strings" +) + +type Repository struct { + Name string `yaml:"name"` + Source string `yaml:"source"` + Disabled bool `yaml:"disabled"` + Entries map[string]*RepositoryEntry +} + +type RepositoryEntry struct { + Info PackageInfo `yaml:"info"` + Download string `yaml:"download"` +} + +func (repo *Repository) ContainsPackage(pkg string) bool { + _, ok := repo.Entries[pkg] + return ok +} + +func (repo *Repository) ReadLocalDatabase() error { + repoFile := "/var/lib/bpm/repositories/" + repo.Name + ".bpmdb" + if _, err := os.Stat(repoFile); err != nil { + return nil + } + + bytes, err := os.ReadFile(repoFile) + if err != nil { + return err + } + + data := string(bytes) + for _, b := range strings.Split(data, "---") { + entry := RepositoryEntry{ + Info: PackageInfo{ + Name: "", + Description: "", + Version: "", + Url: "", + License: "", + Arch: "", + Type: "", + Keep: make([]string, 0), + Depends: make([]string, 0), + ConditionalDepends: make(map[string][]string), + MakeDepends: make([]string, 0), + ConditionalMakeDepends: make(map[string][]string), + Conflicts: make([]string, 0), + ConditionalConflicts: make(map[string][]string), + Optional: make([]string, 0), + ConditionalOptional: make(map[string][]string), + Provides: make([]string, 0), + }, + Download: "", + } + err := yaml.Unmarshal([]byte(b), &entry) + if err != nil { + return err + } + repo.Entries[entry.Info.Name] = &entry + } + return nil +} + +func (repo *Repository) SyncLocalDatabase() error { + repoFile := "/var/lib/bpm/repositories/" + repo.Name + ".bpmdb" + err := os.MkdirAll(path.Dir(repoFile), 0755) + if err != nil { + return err + } + + u, err := url.JoinPath(repo.Source, "database.bpmdb") + if err != nil { + return err + } + + resp, err := http.Get(u) + if err != nil { + return err + } + defer resp.Body.Close() + + out, err := os.Create(repoFile) + if err != nil { + return err + } + defer out.Close() + + _, err = io.Copy(out, resp.Body) + + return nil +} + +func GetRepository(name string) *Repository { + for _, repo := range BPMConfig.Repositories { + if repo.Name == name { + return repo + } + } + return nil +} + +func GetRepositoryEntry(str string) (*RepositoryEntry, error) { + split := strings.Split(str, "/") + if len(split) == 1 { + pkgName := strings.TrimSpace(split[0]) + if pkgName == "" { + return nil, errors.New("could not find repository entry for this package") + } + for _, repo := range BPMConfig.Repositories { + if repo.ContainsPackage(pkgName) { + return repo.Entries[pkgName], nil + } + } + return nil, errors.New("could not find repository entry for this package") + } else if len(split) == 2 { + repoName := strings.TrimSpace(split[0]) + pkgName := strings.TrimSpace(split[1]) + if repoName == "" || pkgName == "" { + return nil, errors.New("could not find repository entry for this package") + } + repo := GetRepository(repoName) + if repo == nil || !repo.ContainsPackage(pkgName) { + return nil, errors.New("could not find repository entry for this package") + } + return repo.Entries[pkgName], nil + } else { + return nil, errors.New("could not find repository entry for this package") + } +} + +func (repo *Repository) FetchPackage(pkg, savePath string) (string, error) { + if !repo.ContainsPackage(pkg) { + return "", errors.New("Could not fetch package '" + pkg + "'") + } + entry := repo.Entries[pkg] + resp, err := http.Get(entry.Download) + if err != nil { + return "", err + } + defer resp.Body.Close() + + out, err := os.Create(savePath) + if err != nil { + return "", err + } + defer out.Close() + + _, err = io.Copy(out, resp.Body) + return savePath, nil +}