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

Rename Solve to Install

Browse Source
This commit is contained in:
Ettore Di Giacinto 2019-06-04 22:22:45 +02:00
parent 2b095601eb
commit fef6467cc9
No known key found for this signature in database
GPG Key ID: F557248F4D256736
2 changed files with 28 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
pkg/solver/solver.go
View File

@ -25,10 +25,8 @@ import (
type State interface{ Encode() string } type State interface{ Encode() string }
type PackageSolver interface { type PackageSolver interface {
BuildFormula() (bf.Formula, error)
Solve() ([]PackageAssert, error)
Apply() (map[string]bool, bf.Formula, error)
SetWorld(p []pkg.Package) SetWorld(p []pkg.Package)
Install(p []pkg.Package) ([]PackageAssert, error)
} }
type Solver struct { type Solver struct {
Wanted []pkg.Package Wanted []pkg.Package
@ -36,17 +34,14 @@ type Solver struct {
World []pkg.Package World []pkg.Package
} }
func NewSolver(pcoll []pkg.Package, init []pkg.Package, w []pkg.Package) PackageSolver { func NewSolver(init []pkg.Package, w []pkg.Package) PackageSolver {
for _, v := range init { for _, v := range init {
v.IsFlagged(true) v.IsFlagged(true)
} }
for _, v := range pcoll {
v.IsFlagged(false)
}
for _, v := range w { for _, v := range w {
v.IsFlagged(true) v.IsFlagged(true)
} }
return &Solver{Wanted: pcoll, Installed: init, World: w} return &Solver{Installed: init, World: w}
} }
func (s *Solver) SetWorld(p []pkg.Package) { func (s *Solver) SetWorld(p []pkg.Package) {
@ -108,19 +103,27 @@ func (s *Solver) solve(f bf.Formula) (map[string]bool, bf.Formula, error) {
return model, f, nil return model, f, nil
} }
func (s *Solver) Apply() (map[string]bool, bf.Formula, error) {
f, err := s.BuildFormula()
if err != nil {
return map[string]bool{}, nil, err
}
return s.solve(f)
}
func (s *Solver) Solve() ([]PackageAssert, error) { func (s *Solver) Solve() ([]PackageAssert, error) {
model, _, err := s.Apply()
f, err := s.BuildFormula()
if err != nil {
return nil, err
}
model, _, err := s.solve(f)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return DecodeModel(model) return DecodeModel(model)
} }
func (s *Solver) Install(coll []pkg.Package) ([]PackageAssert, error) {
for _, v := range coll {
v.IsFlagged(false)
}
s.Wanted = coll
return s.Solve()
}

16
pkg/solver/solver_test.go
View File

@ -32,8 +32,8 @@ var _ = Describe("Solver", func() {
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{}) A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{}) C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A}, []pkg.Package{C}, []pkg.Package{A, B, C}) // XXX: goes fatal with odd numbers of cnf ? s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C}) // XXX: goes fatal with odd numbers of cnf ?
solution, err := s.Solve() solution, err := s.Install([]pkg.Package{A})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true})) Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true})) Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
@ -47,9 +47,9 @@ var _ = Describe("Solver", func() {
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{}) A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
C.IsFlagged(true) // installed C.IsFlagged(true) // installed
s := NewSolver([]pkg.Package{A.IsFlagged(true)}, []pkg.Package{C}, []pkg.Package{A, B, C, D}) s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D})
solution, err := s.Solve() solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true})) Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true})) Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true})) Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
@ -66,9 +66,9 @@ var _ = Describe("Solver", func() {
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{}) B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{}) A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A}, []pkg.Package{}, []pkg.Package{A, B, C, D}) s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C, D})
solution, err := s.Solve() solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true})) Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true})) Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true})) Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
@ -86,9 +86,9 @@ var _ = Describe("Solver", func() {
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{C}) B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{C})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{}) A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A}, []pkg.Package{C}, []pkg.Package{A, B, C}) s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C})
solution, err := s.Solve() solution, err := s.Install([]pkg.Package{A})
Expect(len(solution)).To(Equal(0)) Expect(len(solution)).To(Equal(0))
Expect(err).To(HaveOccurred()) Expect(err).To(HaveOccurred())
}) })