Added basic remote repository functionality to the install subcommand

utils/package_utils.go

@@ -1311,6 +1311,55 @@ func CheckConflicts(pkgInfo *PackageInfo, checkConditional bool, rootDir string)
 	return ret
 }
 
+func ResolveAll(pkgInfo *PackageInfo, checkMake, ignoreInstalled bool, rootDir string) ([]string, []string, error) {
+	resolved := make([]string, 0)
+	unresolved := make([]string, 0)
+	toResolve := []string{pkgInfo.Name}
+	allDepends := make([]string, 0)
+	allDepends = append(allDepends, pkgInfo.Depends...)
+	for condition, depends := range pkgInfo.ConditionalDepends {
+		if IsPackageInstalled(condition, rootDir) {
+			allDepends = append(allDepends, depends...)
+		}
+	}
+	if checkMake {
+		allDepends = append(allDepends, pkgInfo.MakeDepends...)
+		for condition, depends := range pkgInfo.ConditionalMakeDepends {
+			if IsPackageInstalled(condition, rootDir) {
+				allDepends = append(allDepends, depends...)
+			}
+		}
+	}
+
+	resolve := func(depend string) {
+		if slices.Contains(resolved, depend) {
+			return
+		}
+		if ignoreInstalled && IsPackageInstalled(depend, rootDir) {
+			return
+		}
+		entry, _, err := GetRepositoryEntry(depend)
+		if err != nil {
+			if !slices.Contains(unresolved, depend) {
+				unresolved = append(unresolved, depend)
+			}
+			return
+		}
+		resolved = append(resolved, depend)
+		toResolve = append(toResolve, entry.Info.Depends...)
+	}
+
+	for len(toResolve) > 0 {
+		clone := slices.Clone(toResolve)
+		toResolve = make([]string, 0)
+		for _, depend := range clone {
+			resolve(depend)
+		}
+	}
+
+	return resolved, unresolved, nil
+}
+
 func IsPackageInstalled(pkg, rootDir string) bool {
 	installedDir := path.Join(rootDir, "var/lib/bpm/installed/")
 	pkgDir := path.Join(installedDir, pkg)
@@ -1329,7 +1378,11 @@ func IsPackageProvided(pkg, rootDir string) bool {
 		if p == pkg {
 			return true
 		}
-		if slices.Contains(GetPackageInfo(p, rootDir, true).Provides, pkg) {
+		i := GetPackageInfo(p, rootDir, true)
+		if i == nil {
+			continue
+		}
+		if slices.Contains(i.Provides, pkg) {
 			return true
 		}
 	}

utils/repo_utils.go

@@ -19,8 +19,8 @@ type Repository struct {
 }
 
 type RepositoryEntry struct {
-	Info     PackageInfo `yaml:"info"`
-	Download string      `yaml:"download"`
+	Info     *PackageInfo `yaml:"info"`
+	Download string       `yaml:"download"`
 }
 
 func (repo *Repository) ContainsPackage(pkg string) bool {
@@ -42,7 +42,7 @@ func (repo *Repository) ReadLocalDatabase() error {
 	data := string(bytes)
 	for _, b := range strings.Split(data, "---") {
 		entry := RepositoryEntry{
-			Info: PackageInfo{
+			Info: &PackageInfo{
 				Name:                   "",
 				Description:            "",
 				Version:                "",
@@ -110,52 +110,60 @@ func GetRepository(name string) *Repository {
 	return nil
 }
 
-func GetRepositoryEntry(str string) (*RepositoryEntry, error) {
+func GetRepositoryEntry(str string) (*RepositoryEntry, *Repository, 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")
+			return nil, 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 repo.Entries[pkgName], repo, nil
 			}
 		}
-		return nil, errors.New("could not find repository entry for this package")
+		return nil, 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")
+			return nil, 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 nil, nil, errors.New("could not find repository entry for this package")
 		}
-		return repo.Entries[pkgName], nil
+		return repo.Entries[pkgName], repo, nil
 	} else {
-		return nil, errors.New("could not find repository entry for this package")
+		return nil, nil, errors.New("could not find repository entry for this package")
 	}
 }
 
-func (repo *Repository) FetchPackage(pkg, savePath string) (string, error) {
+func (repo *Repository) FetchPackage(pkg 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)
+	URL, err := url.JoinPath(repo.Source, entry.Download)
+	if err != nil {
+		return "", err
+	}
+	resp, err := http.Get(URL)
 	if err != nil {
 		return "", err
 	}
 	defer resp.Body.Close()
 
-	out, err := os.Create(savePath)
+	err = os.MkdirAll("/var/cache/bpm/packages/", 0755)
+	if err != nil {
+		return "", err
+	}
+	out, err := os.Create("/var/cache/bpm/packages/" + path.Base(entry.Download))
 	if err != nil {
 		return "", err
 	}
 	defer out.Close()
 
 	_, err = io.Copy(out, resp.Body)
-	return savePath, nil
+	return "/var/cache/bpm/packages/" + path.Base(entry.Download), nil
 }