Propagate reverse dep calculation

Whenever we update the tree with new informations, all the sibilings
needs to be updated as well

Also switch to inmemory db for recipe - even if this should be a switch

pkg/compiler/compiler_test.go

@@ -125,6 +125,10 @@ var _ = Describe("Compiler", func() {
 			Expect(err).ToNot(HaveOccurred())
 			spec3, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "d", Category: "test", Version: "1.0"})
 			Expect(err).ToNot(HaveOccurred())
+
+			//		err = generalRecipe.Tree().ResolveDeps(3)
+			//		Expect(err).ToNot(HaveOccurred())
+
 			Expect(spec3.GetPackage().GetRequires()[0].GetName()).To(Equal("c"))
 
 			spec.SetOutputPath(tmpdir)

pkg/tree/recipes.go

@@ -69,12 +69,13 @@ func (r *Recipe) Load(path string) error {
 		r.PackageTree = NewDefaultTree()
 	}
 
-	tmpfile, err := ioutil.TempFile("", "luet")
+	// tmpfile, err := ioutil.TempFile("", "luet")
-	if err != nil {
+	// if err != nil {
-		return err
+	// 	return err
-	}
+	// }
+	r.Tree().SetPackageSet(pkg.NewInMemoryDatabase(false))
 
-	r.Tree().SetPackageSet(pkg.NewBoltDatabase(tmpfile.Name()))
+	//r.Tree().SetPackageSet(pkg.NewBoltDatabase(tmpfile.Name()))
 	// TODO: Handle cleaning after? Cleanup implemented in GetPackageSet().Clean()
 
 	// the function that handles each file or dir
@@ -103,7 +104,7 @@ func (r *Recipe) Load(path string) error {
 		return nil
 	}
 
-	err = filepath.Walk(path, ff)
+	err := filepath.Walk(path, ff)
 	if err != nil {
 		return err
 	}

pkg/tree/tree.go

@@ -21,10 +21,10 @@
 package tree
 
 import (
-	"errors"
 	"sync"
 
 	. "github.com/mudler/luet/pkg/logger"
+	"github.com/pkg/errors"
 
 	pkg "github.com/mudler/luet/pkg/package"
 )
@@ -65,6 +65,22 @@ func (gt *DefaultTree) World() ([]pkg.Package, error) {
 	return packages, nil
 }
 
+func (gt *DefaultTree) UpdateWorldPackage(p pkg.Package) {
+	//FIXME: Improve, no copy is needed
+	var CacheWorld []pkg.Package
+
+	for _, pid := range gt.CacheWorld {
+		if p.GetFingerPrint() == pid.GetFingerPrint() {
+			CacheWorld = append(CacheWorld, p)
+		} else {
+			CacheWorld = append(CacheWorld, pid)
+
+		}
+	}
+
+	gt.CacheWorld = CacheWorld
+}
+
 // FIXME: Dup in Packageset
 func (gt *DefaultTree) FindPackage(pack pkg.Package) (pkg.Package, error) {
 	packages, err := gt.World()
@@ -79,38 +95,45 @@ func (gt *DefaultTree) FindPackage(pack pkg.Package) (pkg.Package, error) {
 	return nil, errors.New("No package found")
 }
 
-func (gb *DefaultTree) depsWorker(i int, wg *sync.WaitGroup, c <-chan pkg.Package) error {
+func (gb *DefaultTree) updatePackage(p pkg.Package) error {
-	defer wg.Done()
+	Debug(" "+p.GetName(), "Deps ")
+	for i, r := range p.GetRequires() {
 
-	for p := range c {
+		foundPackage, err := gb.FindPackage(r)
-		SpinnerText(" "+p.GetName(), "Deps ")
-		for _, r := range p.GetRequires() {
-
-			foundPackage, err := gb.GetPackageSet().FindPackage(r)
 		if err == nil {
 
 			found, ok := foundPackage.(*pkg.DefaultPackage)
 			if !ok {
 				panic("Simpleparser should deal only with DefaultPackages")
 			}
-				r = found
+			// err = gb.updatePackage(foundPackage)
+			// if err != nil {
+			// 	return errors.Wrap(err, "Failure while updating recursively")
+			// }
+			p.GetRequires()[i] = found
 		} else {
 			Warning("Unmatched require for", r.GetName())
 		}
 	}
 
 	Debug("Walking conflicts for", p.GetName())
-		for _, r := range p.GetConflicts() {
+	for i, r := range p.GetConflicts() {
 		Debug("conflict", r.GetName())
 
-			foundPackage, err := gb.GetPackageSet().FindPackage(r)
+		foundPackage, err := gb.FindPackage(r)
 		if err == nil {
 
 			found, ok := foundPackage.(*pkg.DefaultPackage)
 			if !ok {
 				panic("Simpleparser should deal only with DefaultPackages")
 			}
-				r = found
+			// err = gb.updatePackage(foundPackage)
+			// if err != nil {
+			// 	return errors.Wrap(err, "Failure while updating recursively")
+			// }
+			p.GetConflicts()[i] = found
+
+			//r = found
 		} else {
 			Warning("Unmatched conflict for", r.GetName())
 
@@ -121,8 +144,34 @@ func (gb *DefaultTree) depsWorker(i int, wg *sync.WaitGroup, c <-chan pkg.Packag
 	if err := gb.GetPackageSet().UpdatePackage(p); err != nil {
 		return err
 	}
-		Debug("Update done", p.GetName())
 
+	gb.UpdateWorldPackage(p)
+	Debug("Update done", p.GetName())
+	Debug("Triggering propagation", p.GetName())
+
+	Debug(" "+p.GetName(), "Deps ")
+	for _, r := range p.GetRequires() {
+		if err := gb.updatePackage(r); err != nil {
+			return err
+		}
+	}
+
+	Debug("Walking conflicts for", p.GetName())
+	for _, r := range p.GetConflicts() {
+		if err := gb.updatePackage(r); err != nil {
+			return err
+		}
+	}
+
+	return nil
+
+}
+
+func (gb *DefaultTree) depsWorker(i int, wg *sync.WaitGroup, c <-chan pkg.Package) error {
+	defer wg.Done()
+
+	for p := range c {
+		gb.updatePackage(p)
 	}
 
 	return nil
@@ -130,6 +179,8 @@ func (gb *DefaultTree) depsWorker(i int, wg *sync.WaitGroup, c <-chan pkg.Packag
 
 // Search for deps/conflicts in db and replaces it with packages in the db
 func (t *DefaultTree) ResolveDeps(concurrency int) error {
+	Spinner(32)
+	defer SpinnerStop()
 	all := make(chan pkg.Package)
 
 	var wg = new(sync.WaitGroup)