Drop ResolveDeps, and the Tree structure #20

pkg/tree/builder.go

@@ -23,8 +23,8 @@ import (
 type Builder interface {
 	Save(string) error // A tree might be saved to a folder structure (human editable)
 	Load(string) error // A tree might be loaded from a db (e.g. bolt) and written to folder
-	Tree() pkg.Tree    // generates world
+	GetDatabase() pkg.PackageDatabase
-	WithTree(pkg.Tree)
+	WithDatabase(d pkg.PackageDatabase)
 
 	GetSourcePath() string
 }

pkg/tree/builder/gentoo/gentoo.go

@@ -49,32 +49,24 @@ type GentooBuilder struct {
 	DBType       MemoryDB
 }
 
-type GentooTree struct {
-	*tree.DefaultTree
-}
-
 type EbuildParser interface {
-	ScanEbuild(string, pkg.Tree) ([]pkg.Package, error)
+	ScanEbuild(string) ([]pkg.Package, error)
 }
 
-func (gt *GentooTree) Prelude() string {
+func (gb *GentooBuilder) scanEbuild(path string, db pkg.PackageDatabase) error {
-	return "/usr/portage/"
-}
-
-func (gb *GentooBuilder) scanEbuild(path string, t pkg.Tree) error {
 	defer func() {
 		if r := recover(); r != nil {
 			Error(r)
 		}
 	}()
-	pkgs, err := gb.EbuildParser.ScanEbuild(path, t)
+	pkgs, err := gb.EbuildParser.ScanEbuild(path)
 	if err != nil {
 		return err
 	}
 	for _, p := range pkgs {
-		_, err := t.GetPackageSet().FindPackage(p)
+		_, err := db.FindPackage(p)
 		if err != nil {
-			_, err := t.GetPackageSet().CreatePackage(p)
+			_, err := db.CreatePackage(p)
 			if err != nil {
 				return err
 			}
@@ -83,12 +75,12 @@ func (gb *GentooBuilder) scanEbuild(path string, t pkg.Tree) error {
 	return nil
 }
 
-func (gb *GentooBuilder) worker(i int, wg *sync.WaitGroup, s <-chan string, t pkg.Tree) {
+func (gb *GentooBuilder) worker(i int, wg *sync.WaitGroup, s <-chan string, db pkg.PackageDatabase) {
 	defer wg.Done()
 
 	for path := range s {
 		Info("#"+strconv.Itoa(i), "parsing", path)
-		err := gb.scanEbuild(path, t)
+		err := gb.scanEbuild(path, db)
 		if err != nil {
 			Error(path, ":", err.Error())
 		}
@@ -96,25 +88,24 @@ func (gb *GentooBuilder) worker(i int, wg *sync.WaitGroup, s <-chan string, t pk
 
 }
 
-func (gb *GentooBuilder) Generate(dir string) (pkg.Tree, error) {
+func (gb *GentooBuilder) Generate(dir string) (pkg.PackageDatabase, error) {
 
 	var toScan = make(chan string)
 	Spinner(27)
 	defer SpinnerStop()
-	var gtree *GentooTree
+	var db pkg.PackageDatabase
-
 	// Support for
 	switch gb.DBType {
 	case InMemory:
-		gtree = &GentooTree{DefaultTree: &tree.DefaultTree{Packages: pkg.NewInMemoryDatabase(false)}}
+		db = pkg.NewInMemoryDatabase(false)
 	case BoltDB:
 		tmpfile, err := ioutil.TempFile("", "boltdb")
 		if err != nil {
 			return nil, err
 		}
-		gtree = &GentooTree{DefaultTree: &tree.DefaultTree{Packages: pkg.NewBoltDatabase(tmpfile.Name())}}
+		db = pkg.NewBoltDatabase(tmpfile.Name())
 	default:
-		gtree = &GentooTree{DefaultTree: &tree.DefaultTree{Packages: pkg.NewInMemoryDatabase(false)}}
+		db = pkg.NewInMemoryDatabase(false)
 	}
 
 	Debug("Concurrency", gb.Concurrency)
@@ -122,7 +113,7 @@ func (gb *GentooBuilder) Generate(dir string) (pkg.Tree, error) {
 	var wg = new(sync.WaitGroup)
 	for i := 0; i < gb.Concurrency; i++ {
 		wg.Add(1)
-		go gb.worker(i, wg, toScan, gtree)
+		go gb.worker(i, wg, toScan, db)
 	}
 
 	// TODO: Handle cleaning after? Cleanup implemented in GetPackageSet().Clean()
@@ -142,9 +133,8 @@ func (gb *GentooBuilder) Generate(dir string) (pkg.Tree, error) {
 	close(toScan)
 	wg.Wait()
 	if err != nil {
-		return gtree, err
+		return db, err
 	}
 
-	Info("Resolving deps")
+	return db, nil
-	return gtree, gtree.ResolveDeps(gb.Concurrency)
 }

pkg/tree/builder/gentoo/gentoo_test.go

@@ -26,7 +26,7 @@ import (
 type FakeParser struct {
 }
 
-func (f *FakeParser) ScanEbuild(path string, t pkg.Tree) ([]pkg.Package, error) {
+func (f *FakeParser) ScanEbuild(path string) ([]pkg.Package, error) {
 	return []pkg.Package{&pkg.DefaultPackage{Name: path}}, nil
 }
 
@@ -38,10 +38,10 @@ var _ = Describe("GentooBuilder", func() {
 				gb := NewGentooBuilder(&FakeParser{}, 20, dbType)
 				tree, err := gb.Generate("../../../../tests/fixtures/overlay")
 				defer func() {
-					Expect(tree.GetPackageSet().Clean()).ToNot(HaveOccurred())
+					Expect(tree.Clean()).ToNot(HaveOccurred())
 				}()
 				Expect(err).ToNot(HaveOccurred())
-				Expect(len(tree.GetPackageSet().GetPackages())).To(Equal(10))
+				Expect(len(tree.GetPackages())).To(Equal(10))
 			})
 		}
 	})

pkg/tree/builder/gentoo/simpleparser.go

@@ -247,7 +247,7 @@ func SourceFile(ctx context.Context, path string, pkg *_gentoo.GentooPackage) (m
 }
 
 // ScanEbuild returns a list of packages (always one with SimpleEbuildParser) decoded from an ebuild.
-func (ep *SimpleEbuildParser) ScanEbuild(path string, tree pkg.Tree) ([]pkg.Package, error) {
+func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
 	Debug("Starting parsing of ebuild", path)
 
 	pkgstr := filepath.Base(path)

pkg/tree/builder/gentoo/simpleparser_test.go

@@ -651,14 +651,13 @@ var _ = Describe("GentooBuilder", func() {
 				tree, err := gb.Generate("../../../../tests/fixtures/overlay")
 				Expect(err).ToNot(HaveOccurred())
 				defer func() {
-					Expect(tree.GetPackageSet().Clean()).ToNot(HaveOccurred())
+					Expect(tree.Clean()).ToNot(HaveOccurred())
 				}()
 
-				Expect(len(tree.GetPackageSet().GetPackages())).To(Equal(10))
+				Expect(len(tree.GetPackages())).To(Equal(10))
+
+				for _, p := range tree.World() {
 
-				for _, pid := range tree.GetPackageSet().GetPackages() {
-					p, err := tree.GetPackageSet().GetPackage(pid)
-					Expect(err).ToNot(HaveOccurred())
 					Expect(p.GetName()).To(ContainSubstring("pinentry"))
 					Expect(p.GetVersion()).To(ContainSubstring("1."))
 				}

pkg/tree/compiler_recipe.go

@@ -45,16 +45,12 @@ type CompilerRecipe struct {
 
 func (r *CompilerRecipe) Load(path string) error {
 
-	if r.Tree() == nil {
-		r.PackageTree = NewDefaultTree()
-	}
 	r.SourcePath = path
 	//tmpfile, err := ioutil.TempFile("", "luet")
 	//if err != nil {
 	//	return err
 	//}
 
-	r.Tree().SetPackageSet(r.Database)
 	//r.Tree().SetPackageSet(pkg.NewBoltDatabase(tmpfile.Name()))
 	// TODO: Handle cleaning after? Cleanup implemented in GetPackageSet().Clean()
 	// the function that handles each file or dir
@@ -91,7 +87,7 @@ func (r *CompilerRecipe) Load(path string) error {
 			pack.Conflicts(packbuild.GetConflicts())
 		}
 
-		_, err = r.Tree().GetPackageSet().CreatePackage(&pack)
+		_, err = r.Database.CreatePackage(&pack)
 		if err != nil {
 			return errors.Wrap(err, "Error creating package "+pack.GetName())
 		}
@@ -106,6 +102,6 @@ func (r *CompilerRecipe) Load(path string) error {
 	return nil
 }
 
-func (r *CompilerRecipe) Tree() pkg.Tree        { return r.PackageTree }
+func (r *CompilerRecipe) GetDatabase() pkg.PackageDatabase   { return r.Database }
-func (r *CompilerRecipe) WithTree(t pkg.Tree)   { r.PackageTree = t }
+func (r *CompilerRecipe) WithDatabase(d pkg.PackageDatabase) { r.Database = d }
-func (r *CompilerRecipe) GetSourcePath() string { return r.SourcePath }
+func (r *CompilerRecipe) GetSourcePath() string              { return r.SourcePath }

pkg/tree/installer_recipe.go

@@ -35,26 +35,19 @@ const (
 )
 
 func NewInstallerRecipe(db pkg.PackageDatabase) Builder {
-	tree := NewDefaultTree()
+	return &InstallerRecipe{Database: db}
-	tree.SetPackageSet(db)
-	return &InstallerRecipe{Database: db, PackageTree: tree}
 }
 
 // InstallerRecipe is the "general" reciper for Trees
 type InstallerRecipe struct {
-	PackageTree pkg.Tree
+	SourcePath string
-	SourcePath  string
+	Database   pkg.PackageDatabase
-	Database    pkg.PackageDatabase
 }
 
 func (r *InstallerRecipe) Save(path string) error {
 
-	for _, pid := range r.PackageTree.GetPackageSet().GetPackages() {
+	for _, p := range r.Database.World() {
 
-		p, err := r.PackageTree.GetPackageSet().GetPackage(pid)
-		if err != nil {
-			return err
-		}
 		dir := filepath.Join(path, p.GetCategory(), p.GetName(), p.GetVersion())
 		os.MkdirAll(dir, os.ModePerm)
 		data, err := p.Yaml()
@@ -77,15 +70,10 @@ func (r *InstallerRecipe) Save(path string) error {
 
 func (r *InstallerRecipe) Load(path string) error {
 
-	if r.Tree() == nil {
-		r.PackageTree = NewDefaultTree()
-	}
-
 	// tmpfile, err := ioutil.TempFile("", "luet")
 	// if err != nil {
 	// 	return err
 	// }
-	r.Tree().SetPackageSet(r.Database)
 	r.SourcePath = path
 
 	//r.Tree().SetPackageSet(pkg.NewBoltDatabase(tmpfile.Name()))
@@ -109,7 +97,7 @@ func (r *InstallerRecipe) Load(path string) error {
 
 		// Path is set only internally when tree is loaded from disk
 		pack.SetPath(filepath.Dir(currentpath))
-		_, err = r.Tree().GetPackageSet().CreatePackage(&pack)
+		_, err = r.Database.CreatePackage(&pack)
 		if err != nil {
 			return errors.Wrap(err, "Error creating package "+pack.GetName())
 		}
@@ -124,6 +112,6 @@ func (r *InstallerRecipe) Load(path string) error {
 	return nil
 }
 
-func (r *InstallerRecipe) Tree() pkg.Tree        { return r.PackageTree }
+func (r *InstallerRecipe) GetDatabase() pkg.PackageDatabase   { return r.Database }
-func (r *InstallerRecipe) WithTree(t pkg.Tree)   { r.PackageTree = t }
+func (r *InstallerRecipe) WithDatabase(d pkg.PackageDatabase) { r.Database = d }
-func (r *InstallerRecipe) GetSourcePath() string { return r.SourcePath }
+func (r *InstallerRecipe) GetSourcePath() string              { return r.SourcePath }

pkg/tree/parser.go

@@ -19,5 +19,5 @@ import pkg "github.com/mudler/luet/pkg/package"
 
 // parses ebuilds (?) and generates data which is readable by the builder
 type Parser interface {
-	Generate(string) (pkg.Tree, error) // Generate scannable luet tree (by builder)
+	Generate(string) (pkg.PackageDatabase, error) // Generate scannable luet tree (by builder)
 }

pkg/tree/recipes.go

@@ -37,19 +37,13 @@ func NewGeneralRecipe(db pkg.PackageDatabase) Builder { return &Recipe{Database:
 
 // Recipe is the "general" reciper for Trees
 type Recipe struct {
-	PackageTree pkg.Tree
+	SourcePath string
-	SourcePath  string
+	Database   pkg.PackageDatabase
-	Database    pkg.PackageDatabase
 }
 
 func (r *Recipe) Save(path string) error {
 
-	for _, pid := range r.PackageTree.GetPackageSet().GetPackages() {
+	for _, p := range r.Database.World() {
-
-		p, err := r.PackageTree.GetPackageSet().GetPackage(pid)
-		if err != nil {
-			return err
-		}
 		dir := filepath.Join(path, p.GetCategory(), p.GetName(), p.GetVersion())
 		os.MkdirAll(dir, os.ModePerm)
 		data, err := p.Yaml()
@@ -67,17 +61,16 @@ func (r *Recipe) Save(path string) error {
 
 func (r *Recipe) Load(path string) error {
 
-	if r.Tree() == nil {
-		r.PackageTree = NewDefaultTree()
-	}
-
 	// tmpfile, err := ioutil.TempFile("", "luet")
 	// if err != nil {
 	// 	return err
 	// }
-	r.Tree().SetPackageSet(r.Database)
 	r.SourcePath = path
 
+	if r.Database == nil {
+		r.Database = pkg.NewInMemoryDatabase(false)
+	}
+
 	//r.Tree().SetPackageSet(pkg.NewBoltDatabase(tmpfile.Name()))
 	// TODO: Handle cleaning after? Cleanup implemented in GetPackageSet().Clean()
 
@@ -99,7 +92,7 @@ func (r *Recipe) Load(path string) error {
 
 		// Path is set only internally when tree is loaded from disk
 		pack.SetPath(filepath.Dir(currentpath))
-		_, err = r.Tree().GetPackageSet().CreatePackage(&pack)
+		_, err = r.Database.CreatePackage(&pack)
 		if err != nil {
 			return errors.Wrap(err, "Error creating package "+pack.GetName())
 		}
@@ -114,6 +107,6 @@ func (r *Recipe) Load(path string) error {
 	return nil
 }
 
-func (r *Recipe) Tree() pkg.Tree        { return r.PackageTree }
+func (r *Recipe) GetDatabase() pkg.PackageDatabase   { return r.Database }
-func (r *Recipe) WithTree(t pkg.Tree)   { r.PackageTree = t }
+func (r *Recipe) WithDatabase(d pkg.PackageDatabase) { r.Database = d }
-func (r *Recipe) GetSourcePath() string { return r.SourcePath }
+func (r *Recipe) GetSourcePath() string              { return r.SourcePath }

pkg/tree/recipes_test.go

@@ -48,13 +48,12 @@ var _ = Describe("Recipe", func() {
 				tree, err := gb.Generate("../../tests/fixtures/overlay")
 				Expect(err).ToNot(HaveOccurred())
 				defer func() {
-					Expect(tree.GetPackageSet().Clean()).ToNot(HaveOccurred())
+					Expect(tree.Clean()).ToNot(HaveOccurred())
 				}()
 
-				Expect(len(tree.GetPackageSet().GetPackages())).To(Equal(10))
+				Expect(len(tree.GetPackages())).To(Equal(10))
 
-				generalRecipe := NewGeneralRecipe(tree.GetPackageSet())
+				generalRecipe := NewGeneralRecipe(tree)
-				generalRecipe.WithTree(tree)
 				err = generalRecipe.Save(tmpdir)
 				Expect(err).ToNot(HaveOccurred())
 			})
@@ -70,31 +69,27 @@ var _ = Describe("Recipe", func() {
 				tree, err := gb.Generate("../../tests/fixtures/overlay")
 				Expect(err).ToNot(HaveOccurred())
 				defer func() {
-					Expect(tree.GetPackageSet().Clean()).ToNot(HaveOccurred())
+					Expect(tree.Clean()).ToNot(HaveOccurred())
 				}()
 
-				Expect(len(tree.GetPackageSet().GetPackages())).To(Equal(10))
+				Expect(len(tree.GetPackages())).To(Equal(10))
 
-				generalRecipe := NewGeneralRecipe(tree.GetPackageSet())
+				generalRecipe := NewGeneralRecipe(tree)
-				generalRecipe.WithTree(tree)
 				err = generalRecipe.Save(tmpdir)
 				Expect(err).ToNot(HaveOccurred())
 
 				db := pkg.NewInMemoryDatabase(false)
 				generalRecipe = NewGeneralRecipe(db)
 
-				generalRecipe.WithTree(nil)
+				generalRecipe.WithDatabase(nil)
-				Expect(generalRecipe.Tree()).To(BeNil())
+				Expect(generalRecipe.GetDatabase()).To(BeNil())
 
 				err = generalRecipe.Load(tmpdir)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(generalRecipe.Tree()).ToNot(BeNil()) // It should be populated back at this point
 
-				Expect(len(generalRecipe.Tree().GetPackageSet().GetPackages())).To(Equal(10))
+				Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(10))
 
-				for _, pid := range tree.GetPackageSet().GetPackages() {
+				for _, p := range tree.World() {
-					p, err := tree.GetPackageSet().GetPackage(pid)
-					Expect(err).ToNot(HaveOccurred())
 					Expect(p.GetName()).To(ContainSubstring("pinentry"))
 				}
 			})
@@ -110,10 +105,10 @@ var _ = Describe("Recipe", func() {
 				tree, err := gb.Generate("../../tests/fixtures/overlay")
 				Expect(err).ToNot(HaveOccurred())
 				defer func() {
-					Expect(tree.GetPackageSet().Clean()).ToNot(HaveOccurred())
+					Expect(tree.Clean()).ToNot(HaveOccurred())
 				}()
 
-				Expect(len(tree.GetPackageSet().GetPackages())).To(Equal(10))
+				Expect(len(tree.GetPackages())).To(Equal(10))
 
 				pack, err := tree.FindPackage(&pkg.DefaultPackage{
 					Name:     "pinentry",
@@ -121,10 +116,8 @@ var _ = Describe("Recipe", func() {
 					Category: "app-crypt",
 				}) // Note: the definition depends on pinentry-base without an explicit version
 				Expect(err).ToNot(HaveOccurred())
-				world, err := tree.World()
-				Expect(err).ToNot(HaveOccurred())
 
-				s := solver.NewSolver([]pkg.Package{}, world, tree.GetPackageSet())
+				s := solver.NewSolver(pkg.NewInMemoryDatabase(false), tree, tree)
 				solution, err := s.Install([]pkg.Package{pack})
 				Expect(err).ToNot(HaveOccurred())
 				Expect(len(solution)).To(Equal(10))
@@ -134,9 +127,9 @@ var _ = Describe("Recipe", func() {
 					allSol = allSol + "\n" + sol.ToString()
 				}
 
-				Expect(allSol).To(ContainSubstring("app-crypt/pinentry-base 1.0.0 installed: true"))
+				Expect(allSol).To(ContainSubstring("app-crypt/pinentry-base 1.0.0 installed"))
-				Expect(allSol).To(ContainSubstring("app-crypt/pinentry 1.1.0-r2 installed: false"))
+				Expect(allSol).To(ContainSubstring("app-crypt/pinentry 1.1.0-r2 not installed"))
-				Expect(allSol).To(ContainSubstring("app-crypt/pinentry 1.0.0-r2 installed: true"))
+				Expect(allSol).To(ContainSubstring("app-crypt/pinentry 1.0.0-r2 installed"))
 			})
 		})
 	}

pkg/tree/tree.go

@@ -1,227 +0,0 @@
-// Copyright © 2019 Ettore Di Giacinto <mudler@gentoo.org>
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with this program; if not, see <http://www.gnu.org/licenses/>.
-
-// Recipe is a builder imeplementation.
-
-// It reads a Tree and spit it in human readable form (YAML), called recipe,
-// It also loads a tree (recipe) from a YAML (to a db, e.g. BoltDB), allowing to query it
-// with the solver, using the package object.
-package tree
-
-import (
-	"sync"
-
-	. "github.com/mudler/luet/pkg/logger"
-	"github.com/mudler/luet/pkg/solver"
-	"github.com/pkg/errors"
-
-	pkg "github.com/mudler/luet/pkg/package"
-)
-
-func NewDefaultTree() pkg.Tree { return &DefaultTree{} }
-
-type DefaultTree struct {
-	sync.Mutex
-	Packages   pkg.PackageDatabase
-	CacheWorld []pkg.Package
-}
-
-func (gt *DefaultTree) GetPackageSet() pkg.PackageDatabase {
-	return gt.Packages
-}
-
-func (gt *DefaultTree) Prelude() string {
-	return ""
-}
-
-func (gt *DefaultTree) SetPackageSet(s pkg.PackageDatabase) {
-	gt.Packages = s
-}
-
-func (gt *DefaultTree) World() ([]pkg.Package, error) {
-	gt.Lock()
-	defer gt.Unlock()
-	if len(gt.CacheWorld) > 0 {
-		return gt.CacheWorld, nil
-	}
-	packages := []pkg.Package{}
-	for _, pid := range gt.GetPackageSet().GetPackages() {
-
-		p, err := gt.GetPackageSet().GetPackage(pid)
-		if err != nil {
-			return packages, errors.Wrap(err, "Package "+pid+" not found in the packageset")
-		}
-		packages = append(packages, p)
-	}
-	gt.CacheWorld = packages
-	return packages, nil
-}
-
-func (gt *DefaultTree) UpdateWorldPackage(p pkg.Package) {
-	gt.Lock()
-	defer gt.Unlock()
-	//var CacheWorld []pkg.Package
-	for _, pid := range gt.CacheWorld {
-		if p.Matches(pid) {
-			pid.Requires(p.GetRequires())
-			pid.Conflicts(p.GetConflicts())
-		}
-	}
-
-}
-
-// FIXME: Dup in Packageset
-func (gt *DefaultTree) FindPackage(pack pkg.Package) (pkg.Package, error) {
-	packages, err := gt.World()
-	if err != nil {
-		return nil, err
-	}
-	for _, pid := range packages {
-		if pack.Matches(pid) {
-			return pid, nil
-		}
-	}
-	return nil, errors.New("No package found")
-}
-
-func (gb *DefaultTree) updatePackage(p pkg.Package) error {
-	Debug("🔧 Calculating deps for", p.GetName())
-	for i, r := range p.GetRequires() {
-		foundPackage, err := gb.FindPackage(r)
-		if err == nil {
-			found, ok := foundPackage.(*pkg.DefaultPackage)
-			if !ok {
-				return errors.New("Simpleparser should deal only with DefaultPackages")
-			}
-
-			p.GetRequires()[i] = found
-		} else {
-			Warning("Unmatched require for", r.GetFingerPrint())
-			w, err := gb.World()
-			if err != nil {
-				return errors.Wrap(err, "Error while computing world")
-			}
-			packages, err := r.Expand(&w)
-			if err != nil {
-				return errors.Wrap(err, "Error while expanding to world")
-			}
-			if len(packages) == 0 {
-				Warning("Could not expand")
-				continue
-			}
-
-			s := solver.NewSolver([]pkg.Package{}, []pkg.Package{}, gb.GetPackageSet())
-			best := s.Best(packages)
-			found, ok := best.(*pkg.DefaultPackage)
-			if !ok {
-				return errors.New("Simpleparser should deal only with DefaultPackages")
-			}
-			Info(":ok_hand: Automatically selected", found.GetName(), found.GetVersion())
-			p.GetRequires()[i] = found
-		}
-	}
-
-	Debug("🔍 Walking conflicts for", p.GetName())
-	for i, r := range p.GetConflicts() {
-		foundPackage, err := gb.FindPackage(r)
-		if err == nil {
-			found, ok := foundPackage.(*pkg.DefaultPackage)
-			if !ok {
-				return errors.New("Simpleparser should deal only with DefaultPackages")
-			}
-
-			p.GetConflicts()[i] = found
-		} else {
-			Warning("Unmatched conflict for", r.GetFingerPrint())
-			w, err := gb.World()
-			if err != nil {
-				return errors.Wrap(err, "Error while computing world")
-			}
-			packages, err := r.Expand(&w)
-			if err != nil {
-				return errors.Wrap(err, "Error while expanding to world")
-			}
-			if len(packages) == 0 {
-				Warning("Could not expand")
-				continue
-			}
-
-			confs := []*pkg.DefaultPackage{}
-			for _, c := range packages {
-				found, ok := c.(*pkg.DefaultPackage)
-				if !ok {
-					return errors.New("Simpleparser should deal only with DefaultPackages")
-				}
-				confs = append(confs, found)
-			}
-			p.Conflicts(append(p.GetConflicts(), confs...))
-
-		}
-	}
-	//	Debug("💫 Finished processing", p.GetName())
-
-	if err := gb.GetPackageSet().UpdatePackage(p); err != nil {
-		return err
-	}
-
-	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
-}
-
-// 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)
-	for i := 0; i < concurrency; i++ {
-		wg.Add(1)
-		go t.depsWorker(i, wg, all)
-	}
-
-	err := t.GetPackageSet().GetAllPackages(all)
-	close(all)
-	wg.Wait()
-	return err
-}

pkg/tree/tree_test.go

@@ -45,25 +45,21 @@ var _ = Describe("Tree", func() {
 
 				err = generalRecipe.Load("../../tests/fixtures/buildableseed")
 				Expect(err).ToNot(HaveOccurred())
-				Expect(generalRecipe.Tree()).ToNot(BeNil()) // It should be populated back at this point
 
-				Expect(len(generalRecipe.Tree().GetPackageSet().GetPackages())).To(Equal(4))
+				Expect(len(generalRecipe.GetDatabase().World())).To(Equal(4))
-				err = generalRecipe.Tree().ResolveDeps(1)
-				Expect(err).ToNot(HaveOccurred())
 
-				D, err := generalRecipe.Tree().FindPackage(&pkg.DefaultPackage{Name: "d", Category: "test", Version: "1.0"})
+				D, err := generalRecipe.GetDatabase().FindPackage(&pkg.DefaultPackage{Name: "d", Category: "test", Version: "1.0"})
 				Expect(err).ToNot(HaveOccurred())
 
 				Expect(D.GetRequires()[0].GetName()).To(Equal("c"))
-				CfromD := D.GetRequires()[0]
+				CfromD, err := generalRecipe.GetDatabase().FindPackage(D.GetRequires()[0])
+				Expect(err).ToNot(HaveOccurred())
+
 				Expect(len(CfromD.GetRequires()) != 0).To(BeTrue())
 				Expect(CfromD.GetRequires()[0].GetName()).To(Equal("b"))
 
-				w, err := generalRecipe.Tree().World()
+				s := solver.NewSolver(pkg.NewInMemoryDatabase(false), generalRecipe.GetDatabase(), db)
-				Expect(err).ToNot(HaveOccurred())
+				pack, err := generalRecipe.GetDatabase().FindPackage(&pkg.DefaultPackage{Name: "d", Category: "test", Version: "1.0"})
-
-				s := solver.NewSolver([]pkg.Package{}, w, db)
-				pack, err := generalRecipe.Tree().FindPackage(&pkg.DefaultPackage{Name: "d", Category: "test", Version: "1.0"})
 				Expect(err).ToNot(HaveOccurred())
 
 				solution, err := s.Install([]pkg.Package{pack})
@@ -72,19 +68,15 @@ var _ = Describe("Tree", func() {
 				solution = solution.Order(pack.GetFingerPrint())
 
 				Expect(solution[0].Package.GetName()).To(Equal("a"))
-				Expect(solution[0].Package.Flagged()).To(BeTrue())
 				Expect(solution[0].Value).To(BeFalse())
 
 				Expect(solution[1].Package.GetName()).To(Equal("b"))
-				Expect(solution[1].Package.Flagged()).To(BeTrue())
 				Expect(solution[1].Value).To(BeTrue())
 
 				Expect(solution[2].Package.GetName()).To(Equal("c"))
-				Expect(solution[2].Package.Flagged()).To(BeTrue())
 				Expect(solution[2].Value).To(BeTrue())
 
 				Expect(solution[3].Package.GetName()).To(Equal("d"))
-				Expect(solution[3].Package.Flagged()).To(BeTrue())
 				Expect(solution[3].Value).To(BeTrue())
 				Expect(len(solution)).To(Equal(4))
 
@@ -92,15 +84,12 @@ var _ = Describe("Tree", func() {
 				Expect(len(newsolution)).To(Equal(3))
 
 				Expect(newsolution[0].Package.GetName()).To(Equal("a"))
-				Expect(newsolution[0].Package.Flagged()).To(BeTrue())
 				Expect(newsolution[0].Value).To(BeFalse())
 
 				Expect(newsolution[1].Package.GetName()).To(Equal("b"))
-				Expect(newsolution[1].Package.Flagged()).To(BeTrue())
 				Expect(newsolution[1].Value).To(BeTrue())
 
 				Expect(newsolution[2].Package.GetName()).To(Equal("c"))
-				Expect(newsolution[2].Package.Flagged()).To(BeTrue())
 				Expect(newsolution[2].Value).To(BeTrue())
 
 			}