Make Expand and Revdeps consume a database

pkg/compiler/compiler.go

@@ -24,9 +24,8 @@ import (
 	"strings"
 	"sync"
 
-	. "github.com/mudler/luet/pkg/logger"
-
 	"github.com/mudler/luet/pkg/helpers"
+	. "github.com/mudler/luet/pkg/logger"
 	pkg "github.com/mudler/luet/pkg/package"
 	"github.com/mudler/luet/pkg/solver"
 	"github.com/mudler/luet/pkg/tree"
@@ -80,9 +79,8 @@ func (cs *LuetCompiler) CompileWithReverseDeps(concurrency int, keepPermissions
 	Info(":ant: Resolving reverse dependencies")
 	toCompile := NewLuetCompilationspecs()
 	for _, a := range artifacts {
-		w := cs.Database.World()
 
-		revdeps := a.GetCompileSpec().GetPackage().Revdeps(&w)
+		revdeps := a.GetCompileSpec().GetPackage().Revdeps(cs.Database)
 		for _, r := range revdeps {
 			spec, asserterr := cs.FromPackage(r)
 			if err != nil {
@@ -249,7 +247,7 @@ func (cs *LuetCompiler) compileWithImage(image, buildertaggedImage, packageImage
 		cs.Backend.DownloadImage(CompilerBackendOptions{ImageName: packageImage})
 	}
 
-	Info(pkgTag, "Generating :whale: definition")
+	Info(pkgTag, "Generating :whale: definition for builder image from", image)
 
 	// First we create the builder image
 	p.WriteBuildImageDefinition(filepath.Join(buildDir, p.GetPackage().GetFingerPrint()+"-builder.dockerfile"))
@@ -521,7 +519,7 @@ func (cs *LuetCompiler) compile(concurrency int, keepPermissions bool, p Compila
 
 		buildImageHash := cs.ImageRepository + ":" + assertion.Hash.BuildHash
 		currentPackageImageHash := cs.ImageRepository + ":" + assertion.Hash.PackageHash
-		Debug(pkgTag, "    :arrow_right_hook: :whale: Builder image name", buildImageHash)
+		Debug(pkgTag, "    :arrow_right_hook: :whale: Builder image from", buildImageHash)
 		Debug(pkgTag, "    :arrow_right_hook: :whale: Package image name", currentPackageImageHash)
 
 		lastHash = currentPackageImageHash

pkg/package/database_boltdb.go

@@ -276,9 +276,9 @@ func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
 
 	required, err := db.FindPackage(p)
 	if err != nil {
-		w := db.World()
+
 		//	return nil, errors.Wrap(err, "Couldn't find required package in db definition")
-		packages, err := p.Expand(&w)
+		packages, err := p.Expand(db)
 		//	Info("Expanded", packages, err)
 		if err != nil || len(packages) == 0 {
 			required = p

pkg/package/database_mem.go

@@ -228,9 +228,8 @@ func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
 
 	required, err := db.FindPackage(p)
 	if err != nil {
-		w := db.World()
 		//	return nil, errors.Wrap(err, "Couldn't find required package in db definition")
-		packages, err := p.Expand(&w)
+		packages, err := p.Expand(db)
 		//	Info("Expanded", packages, err)
 		if err != nil || len(packages) == 0 {
 			required = p

pkg/package/package.go

@@ -41,13 +41,14 @@ type Package interface {
 	IsFlagged(bool) Package
 	Flagged() bool
 	GetFingerPrint() string
+	GetPackageName() string
 	Requires([]*DefaultPackage) Package
 	Conflicts([]*DefaultPackage) Package
-	Revdeps(world *[]Package) []Package
+	Revdeps(PackageDatabase) []Package
 
 	GetRequires() []*DefaultPackage
 	GetConflicts() []*DefaultPackage
-	Expand(*[]Package) ([]Package, error)
+	Expand(PackageDatabase) ([]Package, error)
 	SetCategory(string)
 
 	GetName() string
@@ -148,6 +149,10 @@ func (p *DefaultPackage) GetFingerPrint() string {
 	return fmt.Sprintf("%s-%s-%s", p.Name, p.Category, p.Version)
 }
 
+func (p *DefaultPackage) GetPackageName() string {
+	return fmt.Sprintf("%s-%s", p.Name, p.Category)
+}
+
 // GetPath returns the path where the definition file was found
 func (p *DefaultPackage) GetPath() string {
 	return p.Path
@@ -257,14 +262,14 @@ func (p *DefaultPackage) Matches(m Package) bool {
 	return false
 }
 
-func (p *DefaultPackage) Expand(world *[]Package) ([]Package, error) {
+func (p *DefaultPackage) Expand(definitiondb PackageDatabase) ([]Package, error) {
-
 	var versionsInWorld []Package
-	for _, w := range *world {
-		if w.GetName() != p.GetName() || w.GetCategory() != p.GetCategory() {
-			continue
-		}
 
+	all, err := definitiondb.FindPackages(p)
+	if err != nil {
+		return nil, err
+	}
+	for _, w := range all {
 		v, err := version.NewVersion(w.GetVersion())
 		if err != nil {
 			return nil, err
@@ -281,16 +286,16 @@ func (p *DefaultPackage) Expand(world *[]Package) ([]Package, error) {
 	return versionsInWorld, nil
 }
 
-func (p *DefaultPackage) Revdeps(world *[]Package) []Package {
+func (p *DefaultPackage) Revdeps(definitiondb PackageDatabase) []Package {
 	var versionsInWorld []Package
-	for _, w := range *world {
+	for _, w := range definitiondb.World() {
 		if w.Matches(p) {
 			continue
 		}
 		for _, re := range w.GetRequires() {
 			if re.Matches(p) {
 				versionsInWorld = append(versionsInWorld, w)
-				versionsInWorld = append(versionsInWorld, w.Revdeps(world)...)
+				versionsInWorld = append(versionsInWorld, w.Revdeps(definitiondb)...)
 			}
 		}
 	}
@@ -309,13 +314,12 @@ func (pack *DefaultPackage) RequiresContains(definitiondb PackageDatabase, s Pac
 		//return false, errors.Wrap(err, "Package not found in definition db")
 	}
 
-	w := definitiondb.World()
 	for _, re := range p.GetRequires() {
 		if re.Matches(s) {
 			return true, nil
 		}
 
-		packages, _ := re.Expand(&w)
+		packages, _ := re.Expand(definitiondb)
 		for _, pa := range packages {
 			if pa.Matches(s) {
 				return true, nil
@@ -367,7 +371,6 @@ func (pack *DefaultPackage) BuildFormula(definitiondb PackageDatabase, db Packag
 	A := bf.Var(encodedA)
 
 	var formulas []bf.Formula
-	w := definitiondb.World() // FIXME: this is heavy
 	for _, requiredDef := range p.GetRequires() {
 		required, err := definitiondb.FindPackageCandidate(requiredDef)
 		if err != nil {
@@ -392,7 +395,7 @@ func (pack *DefaultPackage) BuildFormula(definitiondb PackageDatabase, db Packag
 	for _, requiredDef := range p.GetConflicts() {
 		required, err := definitiondb.FindPackage(requiredDef)
 		if err != nil {
-			packages, err := requiredDef.Expand(&w)
+			packages, err := requiredDef.Expand(definitiondb)
 			if err != nil || len(packages) == 0 {
 				required = requiredDef
 			} else {

pkg/package/package_test.go

@@ -29,7 +29,12 @@ var _ = Describe("Package", func() {
 		a11 := NewPackage("A", "1.1", []*DefaultPackage{}, []*DefaultPackage{})
 		a01 := NewPackage("A", "0.1", []*DefaultPackage{}, []*DefaultPackage{})
 		It("Expands correctly", func() {
-			lst, err := a.Expand(&[]Package{a1, a11, a01})
+			definitions := NewInMemoryDatabase(false)
+			for _, p := range []Package{a1, a11, a01} {
+				_, err := definitions.CreatePackage(p)
+				Expect(err).ToNot(HaveOccurred())
+			}
+			lst, err := a.Expand(definitions)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(lst).To(ContainElement(a11))
 			Expect(lst).To(ContainElement(a1))
@@ -46,7 +51,12 @@ var _ = Describe("Package", func() {
 		c := NewPackage("C", "1.1", []*DefaultPackage{b}, []*DefaultPackage{})
 		d := NewPackage("D", "0.1", []*DefaultPackage{}, []*DefaultPackage{})
 		It("Computes correctly", func() {
-			lst := a.Revdeps(&[]Package{a, b, c, d})
+			definitions := NewInMemoryDatabase(false)
+			for _, p := range []Package{a, b, c, d} {
+				_, err := definitions.CreatePackage(p)
+				Expect(err).ToNot(HaveOccurred())
+			}
+			lst := a.Revdeps(definitions)
 			Expect(lst).To(ContainElement(b))
 			Expect(lst).To(ContainElement(c))
 			Expect(len(lst)).To(Equal(2))
@@ -61,11 +71,16 @@ var _ = Describe("Package", func() {
 		e := NewPackage("E", "0.1", []*DefaultPackage{c}, []*DefaultPackage{})
 
 		It("Computes correctly", func() {
-			lst := b.Revdeps(&[]Package{a, b, c, d, e})
+			definitions := NewInMemoryDatabase(false)
+			for _, p := range []Package{a, b, c, d, e} {
+				_, err := definitions.CreatePackage(p)
+				Expect(err).ToNot(HaveOccurred())
+			}
+			lst := a.Revdeps(definitions)
 			Expect(lst).To(ContainElement(c))
 			Expect(lst).To(ContainElement(d))
 			Expect(lst).To(ContainElement(e))
-			Expect(len(lst)).To(Equal(3))
+			Expect(len(lst)).To(Equal(4))
 		})
 	})
 

pkg/solver/solver.go

@@ -115,12 +115,11 @@ func (s *Solver) BuildWorld(includeInstalled bool) (bf.Formula, error) {
 
 func (s *Solver) getList(db pkg.PackageDatabase, lsp []pkg.Package) ([]pkg.Package, error) {
 	var ls []pkg.Package
-	w := db.World()
 
 	for _, pp := range lsp {
 		cp, err := db.FindPackage(pp)
 		if err != nil {
-			packages, err := pp.Expand(&w)
+			packages, err := pp.Expand(db)
 			// Expand, and relax search - if not found pick the same one
 			if err != nil || len(packages) == 0 {
 				cp = pp
@@ -249,10 +248,9 @@ func (s *Solver) Uninstall(c pkg.Package) ([]pkg.Package, error) {
 	var res []pkg.Package
 	candidate, err := s.InstalledDatabase.FindPackage(c)
 	if err != nil {
-		w := s.InstalledDatabase.World()
 
 		//	return nil, errors.Wrap(err, "Couldn't find required package in db definition")
-		packages, err := c.Expand(&w)
+		packages, err := c.Expand(s.InstalledDatabase)
 		//	Info("Expanded", packages, err)
 		if err != nil || len(packages) == 0 {
 			candidate = c

pkg/solver/solver_test.go

@@ -665,7 +665,12 @@ var _ = Describe("Solver", func() {
 		old := pkg.NewPackage("A", "1.3.1", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
 
 		It("Expands correctly", func() {
-			lst, err := a.Expand(&[]pkg.Package{a1, a11, a01, a02, a03, old})
+			definitions := pkg.NewInMemoryDatabase(false)
+			for _, p := range []pkg.Package{a1, a11, a01, a02, a03, old} {
+				_, err := definitions.CreatePackage(p)
+				Expect(err).ToNot(HaveOccurred())
+			}
+			lst, err := a.Expand(definitions)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(lst).To(ContainElement(a11))
 			Expect(lst).To(ContainElement(a1))