kairos/luet
1
0
Fork 0
mirror of https://github.com/mudler/luet.git synced 2025-08-13 21:15:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Drop ResolveDeps, and the Tree structure #20

Browse Source
This commit is contained in:
Ettore Di Giacinto 2019-11-29 19:01:46 +01:00
parent b5381e0248
commit 66cd6d1027
No known key found for this signature in database
GPG Key ID: 1ADA699B145A2D1C
12 changed files with 72 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/tree/builder.go
View File

@ -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
WithTree(pkg.Tree)
GetDatabase() pkg.PackageDatabase
WithDatabase(d pkg.PackageDatabase)
GetSourcePath() string
}

40
pkg/tree/builder/gentoo/gentoo.go
View File

@ -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 {
return "/usr/portage/"
}
func (gb *GentooBuilder) scanEbuild(path string, t pkg.Tree) error {
func (gb *GentooBuilder) scanEbuild(path string, db pkg.PackageDatabase) 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 gtree, gtree.ResolveDeps(gb.Concurrency)
return db, nil
}

6
pkg/tree/builder/gentoo/gentoo_test.go
View File

@ -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))
})
}
})

2
pkg/tree/builder/gentoo/simpleparser.go
View File

@ -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)

9
pkg/tree/builder/gentoo/simpleparser_test.go
View File

@ -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."))
}

12
pkg/tree/compiler_recipe.go
View File

@ -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) WithTree(t pkg.Tree) { r.PackageTree = t }
func (r *CompilerRecipe) GetSourcePath() string { return r.SourcePath }
func (r *CompilerRecipe) GetDatabase() pkg.PackageDatabase { return r.Database }
func (r *CompilerRecipe) WithDatabase(d pkg.PackageDatabase) { r.Database = d }
func (r *CompilerRecipe) GetSourcePath() string { return r.SourcePath }

28
pkg/tree/installer_recipe.go
View File

@ -35,26 +35,19 @@ const (
)
func NewInstallerRecipe(db pkg.PackageDatabase) Builder {
tree := NewDefaultTree()
tree.SetPackageSet(db)
return &InstallerRecipe{Database: db, PackageTree: tree}
return &InstallerRecipe{Database: db}
}
// InstallerRecipe is the "general" reciper for Trees
type InstallerRecipe struct {
PackageTree pkg.Tree
SourcePath string
Database pkg.PackageDatabase
SourcePath string
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) WithTree(t pkg.Tree) { r.PackageTree = t }
func (r *InstallerRecipe) GetSourcePath() string { return r.SourcePath }
func (r *InstallerRecipe) GetDatabase() pkg.PackageDatabase { return r.Database }
func (r *InstallerRecipe) WithDatabase(d pkg.PackageDatabase) { r.Database = d }
func (r *InstallerRecipe) GetSourcePath() string { return r.SourcePath }

2
pkg/tree/parser.go
View File

@ -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)
}

29
pkg/tree/recipes.go
View File

@ -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
Database pkg.PackageDatabase
SourcePath string
Database pkg.PackageDatabase
}
func (r *Recipe) Save(path string) error {
for _, pid := range r.PackageTree.GetPackageSet().GetPackages() {
p, err := r.PackageTree.GetPackageSet().GetPackage(pid)
if err != nil {
return err
}
for _, p := range r.Database.World() {
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) WithTree(t pkg.Tree) { r.PackageTree = t }
func (r *Recipe) GetSourcePath() string { return r.SourcePath }
func (r *Recipe) GetDatabase() pkg.PackageDatabase { return r.Database }
func (r *Recipe) WithDatabase(d pkg.PackageDatabase) { r.Database = d }
func (r *Recipe) GetSourcePath() string { return r.SourcePath }

39
pkg/tree/recipes_test.go
View File

@ -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.WithTree(tree)
generalRecipe := NewGeneralRecipe(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.WithTree(tree)
generalRecipe := NewGeneralRecipe(tree)
err = generalRecipe.Save(tmpdir)
Expect(err).ToNot(HaveOccurred())
db := pkg.NewInMemoryDatabase(false)
generalRecipe = NewGeneralRecipe(db)
generalRecipe.WithTree(nil)
Expect(generalRecipe.Tree()).To(BeNil())
generalRecipe.WithDatabase(nil)
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() {
p, err := tree.GetPackageSet().GetPackage(pid)
Expect(err).ToNot(HaveOccurred())
for _, p := range tree.World() {
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 1.1.0-r2 installed: false"))
Expect(allSol).To(ContainSubstring("app-crypt/pinentry 1.0.0-r2 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 not installed"))
Expect(allSol).To(ContainSubstring("app-crypt/pinentry 1.0.0-r2 installed"))
})
})
}

227
pkg/tree/tree.go
View File

@ -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
}

25
pkg/tree/tree_test.go
View File

@ -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))
err = generalRecipe.Tree().ResolveDeps(1)
Expect(err).ToNot(HaveOccurred())
Expect(len(generalRecipe.GetDatabase().World())).To(Equal(4))
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()
Expect(err).ToNot(HaveOccurred())
s := solver.NewSolver([]pkg.Package{}, w, db)
pack, err := generalRecipe.Tree().FindPackage(&pkg.DefaultPackage{Name: "d", Category: "test", Version: "1.0"})
s := solver.NewSolver(pkg.NewInMemoryDatabase(false), generalRecipe.GetDatabase(), db)
pack, err := generalRecipe.GetDatabase().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())
}