kairos/luet
1
0
Fork 0
mirror of https://github.com/mudler/luet.git synced 2025-09-14 22:29:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement basic install algorithm

Browse Source
This commit is contained in:
Ettore Di Giacinto
2019-06-04 21:25:17 +02:00
parent 5184a26e69
commit a342bc515f
5 changed files with 198 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
pkg/solver/decoder.go
View File

@@ -16,24 +16,36 @@
package solver
import (
"fmt"
pkg "gitlab.com/mudler/luet/pkg/package"
)
func DecodeModel(model map[string]bool) []pkg.Package {
ass := make([]pkg.Package, 0)
type PackageAssert struct {
Package pkg.Package
Value bool
}
func DecodeModel(model map[string]bool) ([]PackageAssert, error) {
ass := make([]PackageAssert, 0)
for k, v := range model {
if a, err := pkg.DecodePackage(k); err == nil {
fmt.Println(a)
a.IsFlagged(false)
if v {
a.IsFlagged(true)
}
// fmt.Println("Flagged", v, a.Flagged())
// if v {
// fmt.Println("To flag", a)
// }
// if a.Flagged() && !v {
// a.IsFlagged(false)
// } else if !a.Flagged() && v {
// fmt.Println("To flag ", a)
// a.IsFlagged(true)
// }
//if a.State == common.STATE_CURRENT {
ass = append(ass, a)
ass = append(ass, PackageAssert{Package: a, Value: v})
//} // Else, there was a state transition between Initial state and current run
} else {
return nil, err
}
}
return ass
return ass, nil
}

110
pkg/solver/solver.go
View File

@@ -27,32 +27,43 @@ type State interface{ Encode() string }
type PackageSolver interface {
BuildFormula() (bf.Formula, error)
Solve() ([]pkg.Package, error)
Solve() ([]PackageAssert, error)
Apply() (map[string]bool, bf.Formula, error)
SetSteps(int)
SetWorld(p []pkg.Package)
}
type Solver struct {
PackageCollection []pkg.Package
InitialState []pkg.Package
Wanted []pkg.Package
Installed []pkg.Package
World []pkg.Package
Steps int
}
func NewSolver(pcoll []pkg.Package, init []pkg.Package) PackageSolver {
return &Solver{PackageCollection: pcoll, InitialState: init}
func NewSolver(pcoll []pkg.Package, init []pkg.Package, w []pkg.Package) PackageSolver {
for _, v := range init {
v.IsFlagged(true)
}
for _, v := range pcoll {
v.IsFlagged(false)
}
for _, v := range w {
v.IsFlagged(true)
}
return &Solver{Wanted: pcoll, Installed: init, World: w}
}
func (s *Solver) BuildFormula() (bf.Formula, error) {
//f := bf.True
func (s *Solver) SetSteps(st int) {
s.Steps = st
}
func (s *Solver) SetWorld(p []pkg.Package) {
s.World = p
}
func (s *Solver) BuildWorld() (bf.Formula, error) {
var formulas []bf.Formula
for _, a := range s.InitialState {
init, err := a.BuildFormula()
if err != nil {
return nil, err
}
//f = bf.And(f, init)
formulas = append(formulas, init...)
}
for _, p := range s.PackageCollection {
for _, p := range s.Wanted {
solvable, err := p.BuildFormula()
if err != nil {
return nil, err
@@ -61,7 +72,34 @@ func (s *Solver) BuildFormula() (bf.Formula, error) {
formulas = append(formulas, solvable...)
}
return bf.And(formulas...), nil
}
func (s *Solver) BuildFormula() (bf.Formula, error) {
//f := bf.True
var formulas []bf.Formula
r, err := s.BuildWorld()
if err != nil {
return nil, err
}
formulas = append(formulas, r)
for _, wanted := range s.Wanted {
encodedW, err := wanted.IsFlagged(true).Encode()
if err != nil {
return nil, err
}
W := bf.Var(encodedW)
for _, installed := range s.Installed {
encodedI, err := installed.IsFlagged(true).Encode()
if err != nil {
return nil, err
}
I := bf.Var(encodedI)
formulas = append(formulas, bf.And(W, I))
}
}
//return bf.And(r), nil
return bf.And(formulas...), nil
}
@@ -70,23 +108,51 @@ func (s *Solver) solve(f bf.Formula) (map[string]bool, bf.Formula, error) {
if model == nil {
return model, f, errors.New("Unsolvable")
}
return model, f, nil
}
func (s *Solver) Apply() (map[string]bool, bf.Formula, error) {
f, err := s.BuildFormula()
fmt.Println(f)
fmt.Println("Steps", s.Steps, f)
if err != nil {
return map[string]bool{}, nil, err
}
// if s.Steps != 0 {
// for i := s.Steps; i >= 0; i-- {
// f, err = s.BuildFormula()
// if err != nil {
// return map[string]bool{}, nil, err
// }
// model, _, err := s.solve(f)
// if err != nil {
// return map[string]bool{}, nil, err
// }
// fmt.Println("Step ", i, model)
// ass := DecodeModel(model)
// s.Installed = append(s.Installed, ass...)
// }
// }
return s.solve(f)
}
func (s *Solver) Solve() ([]pkg.Package, error) {
func (s *Solver) Solve() ([]PackageAssert, error) {
model, _, err := s.Apply()
if err != nil {
return []pkg.Package{}, err
return nil, err
}
ass := DecodeModel(model)
return ass, nil
// for _, wanted := range s.Wanted {
// encodedW, err := wanted.Encode()
// if err != nil {
// return nil, err
// }
// model[encodedW] = true
// fmt.Println("adding wanted", model)
// }
return DecodeModel(model)
}

50
pkg/solver/solver_test.go
View File

@@ -28,33 +28,31 @@ var _ = Describe("Solver", func() {
Context("Simple set", func() {
It("Solves correctly", func() {
B := pkg.NewPackage("B", "", []pkg.Package{}, []pkg.Package{})
A := pkg.NewPackage("A", "", []pkg.Package{B}, []pkg.Package{})
C := pkg.NewPackage("C", "", []pkg.Package{}, []pkg.Package{})
C.IsFlagged(true) // installed
s := NewSolver([]pkg.Package{A.IsFlagged(true)}, []pkg.Package{C}) // XXX: goes fatal with odd numbers of cnf ?
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*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.SetSteps(1)
solution, err := s.Solve()
Expect(err).ToNot(HaveOccurred())
Expect(solution).To(ContainElement(A.IsFlagged(true)))
Expect(solution).To(ContainElement(B.IsFlagged(true)))
Expect(solution).To(ContainElement(C.IsFlagged(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: C.IsFlagged(true), Value: true}))
})
It("Solves correctly more complex ones", func() {
C := pkg.NewPackage("C", "", []pkg.Package{}, []pkg.Package{})
D := pkg.NewPackage("D", "", []pkg.Package{}, []pkg.Package{})
B := pkg.NewPackage("B", "", []pkg.Package{D}, []pkg.Package{})
A := pkg.NewPackage("A", "", []pkg.Package{B}, []pkg.Package{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
C.IsFlagged(true) // installed
s := NewSolver([]pkg.Package{A.IsFlagged(true)}, []pkg.Package{C})
s := NewSolver([]pkg.Package{A.IsFlagged(true)}, []pkg.Package{C}, []pkg.Package{A, B, C, D})
solution, err := s.Solve()
Expect(solution).To(ContainElement(C.IsFlagged(true)))
Expect(solution).To(ContainElement(D.IsFlagged(true)))
Expect(solution).To(ContainElement(B.IsFlagged(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: D.IsFlagged(true), Value: true}))
Expect(err).ToNot(HaveOccurred())
})
@@ -62,19 +60,17 @@ var _ = Describe("Solver", func() {
Context("Conflict set", func() {
It("Solves correctly", func() {
C := pkg.NewPackage("C", "", []pkg.Package{}, []pkg.Package{})
It("is unsolvable - as we something we ask to install conflict with system stuff", func() {
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
// D := pkg.NewPackage("D", "", []pkg.Package{}, []pkg.Package{})
B := pkg.NewPackage("B", "", []pkg.Package{}, []pkg.Package{C})
A := pkg.NewPackage("A", "", []pkg.Package{B}, []pkg.Package{})
C.IsFlagged(true) // installed
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{C})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A.IsFlagged(true)}, []pkg.Package{C})
s := NewSolver([]pkg.Package{A}, []pkg.Package{C}, []pkg.Package{A, B, C})
solution, err := s.Solve()
Expect(solution).To(Equal([]pkg.Package{C}))
Expect(err).ToNot(HaveOccurred())
Expect(len(solution)).To(Equal(0))
Expect(err).To(HaveOccurred())
})
})