kairos/luet
1
0
Fork 0
mirror of https://github.com/mudler/luet.git synced 2025-07-31 23:05:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Expand also when ordering assertions

Browse Source
This commit is contained in:
Ettore Di Giacinto 2019-11-29 19:01:52 +01:00
parent 91b3daf180
commit d0c84d24a0
No known key found for this signature in database
GPG Key ID: 1ADA699B145A2D1C
5 changed files with 53 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
pkg/compiler/compiler.go
View File

@ -349,7 +349,8 @@ func (cs *LuetCompiler) ComputeDepTree(p CompilationSpec) (solver.PackagesAssert
if err != nil {
return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().GetName())
}
dependencies := solution.Order(p.GetPackage().GetFingerPrint())
dependencies := solution.Order(cs.Database, p.GetPackage().GetFingerPrint())
assertions := solver.PackagesAssertions{}
for _, assertion := range dependencies { //highly dependent on the order
@ -360,8 +361,8 @@ func (cs *LuetCompiler) ComputeDepTree(p CompilationSpec) (solver.PackagesAssert
}
assertion.Hash = solver.PackageHash{
BuildHash: nthsolution.Order(assertion.Package.GetFingerPrint()).Drop(assertion.Package).AssertionHash(),
PackageHash: nthsolution.Order(assertion.Package.GetFingerPrint()).AssertionHash(),
BuildHash: nthsolution.Order(cs.Database, assertion.Package.GetFingerPrint()).Drop(assertion.Package).AssertionHash(),
PackageHash: nthsolution.Order(cs.Database, assertion.Package.GetFingerPrint()).AssertionHash(),
}
assertions = append(assertions, assertion)
}

5
pkg/package/package.go
View File

@ -356,11 +356,8 @@ func (pack *DefaultPackage) BuildFormula(definitiondb PackageDatabase, db Packag
// TODO: Expansion needs to go here - and so we ditch Resolvedeps()
p, err := definitiondb.FindPackage(pack)
if err != nil {
p = pack
// FIXME? : returning an errors here makes the world the only source of truth - which is ok in case definitions are all there
//return nil, errors.Wrap(err, "Couldn't find required package in db definition")
p = pack // Relax failures and trust the def
}
// NormalizeFlagged(definitiondb, p)
encodedA, err := p.Encode(db)
if err != nil {
return nil, err

20
pkg/solver/decoder.go
View File

@ -122,7 +122,7 @@ func (assertions PackagesAssertions) EnsureOrder() PackagesAssertions {
return orderedAssertions
}
func (assertions PackagesAssertions) Order(fingerprint string) PackagesAssertions {
func (assertions PackagesAssertions) Order(definitiondb pkg.PackageDatabase, fingerprint string) PackagesAssertions {
orderedAssertions := PackagesAssertions{}
unorderedAssertions := PackagesAssertions{}
@ -145,12 +145,28 @@ func (assertions PackagesAssertions) Order(fingerprint string) PackagesAssertion
}
sort.Sort(unorderedAssertions)
w := definitiondb.World() // FIXME: this is heavy
// Build a topological graph
//graph := toposort.NewGraph(len(unorderedAssertions))
// graph.AddNodes(fingerprints...)
for _, a := range unorderedAssertions {
for _, req := range a.Package.GetRequires() {
for _, requiredDef := range a.Package.GetRequires() {
req, err := definitiondb.FindPackage(requiredDef)
if err != nil {
// return nil, errors.Wrap(err, "Couldn't find required package in db definition")
packages, err := requiredDef.Expand(&w)
// Info("Expanded", packages, err)
if err != nil || len(packages) == 0 {
req = requiredDef
} else {
req = pkg.Best(packages)
}
//required = &DefaultPackage{Name: "test"}
}
// Expand also here, as we need to order them (or instead the solver should give back the dep correctly?)
graph.AddEdge(a.Package.GetFingerPrint(), req.GetFingerPrint())
}
}

32
pkg/solver/solver.go
View File

@ -45,36 +45,6 @@ type Solver struct {
// NewSolver accepts as argument two lists of packages, the first is the initial set,
// the second represent all the known packages.
func NewSolver(installed pkg.PackageDatabase, definitiondb pkg.PackageDatabase, solverdb pkg.PackageDatabase) PackageSolver {
// inst := pkg.NewInMemoryDatabase(false)
// def := pkg.NewInMemoryDatabase(false)
// // // FIXME: This should all be locked in the db - for now forbid the solver to be run in threads.
// for _, k := range installed.GetPackages() {
// pack, err := installed.GetPackage(k)
// if err == nil {
// inst.CreatePackage(pack)
// }
// }
// for _, k := range definitiondb.GetPackages() {
// pack, err := definitiondb.GetPackage(k)
// if err == nil {
// def.CreatePackage(pack)
// }
// }
// // FIXME:
// for _, k := range inst.GetPackages() {
// pack, err := inst.GetPackage(k)
// if err == nil {
// pkg.NormalizeFlagged(inst, pack)
// }
// }
// for _, k := range def.GetPackages() {
// pack, err := def.GetPackage(k)
// if err == nil {
// pkg.NormalizeFlagged(def, pack)
// }
// }
return &Solver{InstalledDatabase: installed, DefinitionDatabase: definitiondb, SolverDatabase: solverdb}
}
@ -169,8 +139,6 @@ func (s *Solver) ConflictsWith(pack pkg.Package, lsp []pkg.Package) (bool, error
return false, errors.Wrap(err, "Package not found in definition db")
}
// TODO: Needs to be find in package def before encoding!
// pkg.NormalizeFlagged(s.DefinitionDatabase, p)
var formulas []bf.Formula
if s.noRulesWorld() {

33
pkg/solver/solver_test.go
View File

@ -245,13 +245,40 @@ var _ = Describe("Solver", func() {
Expect(len(solution)).To(Equal(3))
Expect(err).ToNot(HaveOccurred())
})
It("Solves deps with moreexpansion", func() {
It("Solves deps with more expansion", func() {
C := pkg.NewPackage("c", "", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "a", Version: ">=1.0", Category: "test"}}, []*pkg.DefaultPackage{})
C.SetCategory("test")
B := pkg.NewPackage("b", "1.0", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B.SetCategory("test")
A := pkg.NewPackage("a", "1.1", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "b", Version: "1.0", Category: "test"}}, []*pkg.DefaultPackage{})
A.SetCategory("test")
for _, p := range []pkg.Package{A, B, C} {
_, err := dbDefinitions.CreatePackage(p)
Expect(err).ToNot(HaveOccurred())
}
for _, p := range []pkg.Package{} {
_, err := dbInstalled.CreatePackage(p)
Expect(err).ToNot(HaveOccurred())
}
s = NewSolver(dbInstalled, dbDefinitions, db)
solution, err := s.Install([]pkg.Package{C})
Expect(solution).To(ContainElement(PackageAssert{Package: A, Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: B, Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: C, Value: true}))
Expect(len(solution)).To(Equal(3))
Expect(err).ToNot(HaveOccurred())
})
It("Solves deps with more expansion", func() {
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "1.4", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "1.1", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "D", Version: ">1.0"}}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "B", Version: ">1.0"}}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "1.1", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "D", Version: ">=1.0"}}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "B", Version: ">=1.0"}}, []*pkg.DefaultPackage{})
for _, p := range []pkg.Package{A, B, C, D, E} {
_, err := dbDefinitions.CreatePackage(p)