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

Adapt compiler and installer to Tree removal

Browse Source
This commit is contained in:
Ettore Di Giacinto
2019-11-29 19:01:49 +01:00
parent f71cc5281e
commit fa46601638
6 changed files with 40 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
pkg/compiler/artifact_test.go
View File

@@ -38,11 +38,10 @@ var _ = Describe("Artifact", func() {
err := generalRecipe.Load("../../tests/fixtures/buildtree") err := generalRecipe.Load("../../tests/fixtures/buildtree")
Expect(err).ToNot(HaveOccurred()) 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(1)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(1))
compiler := NewLuetCompiler(nil, generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(nil, generalRecipe.GetDatabase())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "enman", Category: "app-admin", Version: "1.4.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "enman", Category: "app-admin", Version: "1.4.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())

47
pkg/compiler/compiler.go
View File

@@ -39,12 +39,12 @@ type LuetCompiler struct {
Database pkg.PackageDatabase Database pkg.PackageDatabase
} }
func NewLuetCompiler(backend CompilerBackend, t pkg.Tree, db pkg.PackageDatabase) Compiler { func NewLuetCompiler(backend CompilerBackend, db pkg.PackageDatabase) Compiler {
// The CompilerRecipe will gives us a tree with only build deps listed. // The CompilerRecipe will gives us a tree with only build deps listed.
return &LuetCompiler{ return &LuetCompiler{
Backend: backend, Backend: backend,
CompilerRecipe: &tree.CompilerRecipe{ CompilerRecipe: &tree.CompilerRecipe{
tree.Recipe{PackageTree: t}, tree.Recipe{Database: db},
}, },
Database: db, Database: db,
} }
@@ -73,10 +73,8 @@ func (cs *LuetCompiler) CompileWithReverseDeps(concurrency int, keepPermissions
Info(":ant: Resolving reverse dependencies") Info(":ant: Resolving reverse dependencies")
toCompile := NewLuetCompilationspecs() toCompile := NewLuetCompilationspecs()
for _, a := range artifacts { for _, a := range artifacts {
w, asserterr := cs.Tree().World() w := cs.Database.World()
if asserterr != nil {
return nil, append(err, asserterr)
}
revdeps := a.GetCompileSpec().GetPackage().Revdeps(&w) revdeps := a.GetCompileSpec().GetPackage().Revdeps(&w)
for _, r := range revdeps { for _, r := range revdeps {
spec, asserterr := cs.FromPackage(r) spec, asserterr := cs.FromPackage(r)
@@ -291,14 +289,6 @@ func (cs *LuetCompiler) compileWithImage(image, buildertaggedImage, packageImage
return artifact, nil return artifact, nil
} }
func (cs *LuetCompiler) Prepare(concurrency int) error {
err := cs.Tree().ResolveDeps(concurrency) // FIXME: When done in parallel, this could be done on top before starting
if err != nil {
return errors.Wrap(err, "While resoolving tree world deps")
}
return nil
}
func (cs *LuetCompiler) packageFromImage(p CompilationSpec, tag string, keepPermissions bool) (Artifact, error) { func (cs *LuetCompiler) packageFromImage(p CompilationSpec, tag string, keepPermissions bool) (Artifact, error) {
pkgTag := ":package: " + p.GetPackage().GetName() pkgTag := ":package: " + p.GetPackage().GetName()
@@ -353,17 +343,9 @@ func (cs *LuetCompiler) packageFromImage(p CompilationSpec, tag string, keepPerm
func (cs *LuetCompiler) ComputeDepTree(p CompilationSpec) (solver.PackagesAssertions, error) { func (cs *LuetCompiler) ComputeDepTree(p CompilationSpec) (solver.PackagesAssertions, error) {
// Get build deps tree (ordered) s := solver.NewSolver(pkg.NewInMemoryDatabase(false), cs.Database, pkg.NewInMemoryDatabase(false))
world, err := cs.Tree().World()
if err != nil { solution, err := s.Install([]pkg.Package{p.GetPackage()})
return nil, errors.Wrap(err, "While computing tree world")
}
s := solver.NewSolver([]pkg.Package{}, world, cs.Database)
pack, err := cs.Tree().FindPackage(p.GetPackage())
if err != nil {
return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().GetName())
}
solution, err := s.Install([]pkg.Package{pack})
if err != nil { if err != nil {
return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().GetName()) return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().GetName())
} }
@@ -371,19 +353,16 @@ func (cs *LuetCompiler) ComputeDepTree(p CompilationSpec) (solver.PackagesAssert
assertions := solver.PackagesAssertions{} assertions := solver.PackagesAssertions{}
for _, assertion := range dependencies { //highly dependent on the order for _, assertion := range dependencies { //highly dependent on the order
if assertion.Value && assertion.Package.Flagged() { if assertion.Value {
depPack, err := cs.Tree().FindPackage(assertion.Package)
if err != nil { nthsolution, err := s.Install([]pkg.Package{assertion.Package})
return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().GetName())
}
nthsolution, err := s.Install([]pkg.Package{depPack})
if err != nil { if err != nil {
return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().GetName()) return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().GetName())
} }
assertion.Hash = solver.PackageHash{ assertion.Hash = solver.PackageHash{
BuildHash: nthsolution.Order(depPack.GetFingerPrint()).Drop(depPack).AssertionHash(), BuildHash: nthsolution.Order(assertion.Package.GetFingerPrint()).Drop(assertion.Package).AssertionHash(),
PackageHash: nthsolution.Order(depPack.GetFingerPrint()).AssertionHash(), PackageHash: nthsolution.Order(assertion.Package.GetFingerPrint()).AssertionHash(),
} }
assertions = append(assertions, assertion) assertions = append(assertions, assertion)
} }
@@ -503,7 +482,7 @@ func (cs *LuetCompiler) compile(concurrency int, keepPermissions bool, p Compila
func (cs *LuetCompiler) FromPackage(p pkg.Package) (CompilationSpec, error) { func (cs *LuetCompiler) FromPackage(p pkg.Package) (CompilationSpec, error) {
pack, err := cs.Tree().FindPackage(p) pack, err := cs.Database.FindPackage(p)
if err != nil { if err != nil {
return nil, err return nil, err
} }

73
pkg/compiler/compiler_test.go
View File

@@ -35,13 +35,10 @@ var _ = Describe("Compiler", func() {
err := generalRecipe.Load("../../tests/fixtures/buildable") err := generalRecipe.Load("../../tests/fixtures/buildable")
Expect(err).ToNot(HaveOccurred()) 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(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -80,13 +77,10 @@ var _ = Describe("Compiler", func() {
err := generalRecipe.Load("../../tests/fixtures/buildable") err := generalRecipe.Load("../../tests/fixtures/buildable")
Expect(err).ToNot(HaveOccurred()) 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(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -120,14 +114,10 @@ var _ = Describe("Compiler", func() {
err = generalRecipe.Load("../../tests/fixtures/buildableseed") err = generalRecipe.Load("../../tests/fixtures/buildableseed")
Expect(err).ToNot(HaveOccurred()) 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().GetPackages())).To(Equal(4))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "c", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "c", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -180,13 +170,10 @@ var _ = Describe("Compiler", func() {
err = generalRecipe.Load("../../tests/fixtures/layers") err = generalRecipe.Load("../../tests/fixtures/layers")
Expect(err).ToNot(HaveOccurred()) 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(2)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "extra", Category: "layer", Version: "1.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "extra", Category: "layer", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -225,13 +212,10 @@ var _ = Describe("Compiler", func() {
err = generalRecipe.Load("../../tests/fixtures/include") err = generalRecipe.Load("../../tests/fixtures/include")
Expect(err).ToNot(HaveOccurred()) 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(1)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(1))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -262,13 +246,10 @@ var _ = Describe("Compiler", func() {
err = generalRecipe.Load("../../tests/fixtures/layered") err = generalRecipe.Load("../../tests/fixtures/layered")
Expect(err).ToNot(HaveOccurred()) 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(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "pkgs-checker", Category: "package", Version: "9999"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "pkgs-checker", Category: "package", Version: "9999"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -305,13 +286,10 @@ var _ = Describe("Compiler", func() {
err = generalRecipe.Load("../../tests/fixtures/layered") err = generalRecipe.Load("../../tests/fixtures/layered")
Expect(err).ToNot(HaveOccurred()) 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(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "extra", Category: "layer", Version: "0.1"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "extra", Category: "layer", Version: "0.1"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -346,13 +324,10 @@ var _ = Describe("Compiler", func() {
err = generalRecipe.Load("../../tests/fixtures/buildableseed") err = generalRecipe.Load("../../tests/fixtures/buildableseed")
Expect(err).ToNot(HaveOccurred()) 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().GetPackages())).To(Equal(4))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"})
@@ -401,13 +376,10 @@ var _ = Describe("Compiler", func() {
err := generalRecipe.Load("../../tests/fixtures/expansion") err := generalRecipe.Load("../../tests/fixtures/expansion")
Expect(err).ToNot(HaveOccurred()) 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(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "c", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "c", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -445,13 +417,10 @@ var _ = Describe("Compiler", func() {
err := generalRecipe.Load("../../tests/fixtures/packagelayers") err := generalRecipe.Load("../../tests/fixtures/packagelayers")
Expect(err).ToNot(HaveOccurred()) 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(2)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(), generalRecipe.GetDatabase())
err = compiler.Prepare(1)
Expect(err).ToNot(HaveOccurred())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "runtime", Category: "layer", Version: "0.1"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "runtime", Category: "layer", Version: "0.1"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@@ -468,7 +437,7 @@ var _ = Describe("Compiler", func() {
Expect(len(artifacts)).To(Equal(1)) Expect(len(artifacts)).To(Equal(1))
Expect(len(artifacts[0].GetDependencies())).To(Equal(1)) Expect(len(artifacts[0].GetDependencies())).To(Equal(1))
Expect(helpers.Untar(spec.Rel("runtime-layer-0.1.package.tar"), tmpdir, false)).ToNot(HaveOccurred()) Expect(helpers.Untar(spec.Rel("runtime-layer-0.1.package.tar"), tmpdir, false)).ToNot(HaveOccurred())
Expect(helpers.Exists(spec.Rel("bin/sh"))).To(BeTrue()) Expect(helpers.Exists(spec.Rel("bin/busybox"))).To(BeTrue())
Expect(helpers.Exists(spec.Rel("var"))).ToNot(BeTrue()) Expect(helpers.Exists(spec.Rel("var"))).ToNot(BeTrue())
}) })
}) })

1
pkg/compiler/interface.go
View File

@@ -25,7 +25,6 @@ type Compiler interface {
CompileParallel(concurrency int, keepPermissions bool, ps CompilationSpecs) ([]Artifact, []error) CompileParallel(concurrency int, keepPermissions bool, ps CompilationSpecs) ([]Artifact, []error)
CompileWithReverseDeps(concurrency int, keepPermissions bool, ps CompilationSpecs) ([]Artifact, []error) CompileWithReverseDeps(concurrency int, keepPermissions bool, ps CompilationSpecs) ([]Artifact, []error)
ComputeDepTree(p CompilationSpec) (solver.PackagesAssertions, error) ComputeDepTree(p CompilationSpec) (solver.PackagesAssertions, error)
Prepare(concurrency int) error
FromPackage(pkg.Package) (CompilationSpec, error) FromPackage(pkg.Package) (CompilationSpec, error)

5
pkg/compiler/spec_test.go
View File

@@ -58,11 +58,10 @@ var _ = Describe("Spec", func() {
err := generalRecipe.Load("../../tests/fixtures/buildtree") err := generalRecipe.Load("../../tests/fixtures/buildtree")
Expect(err).ToNot(HaveOccurred()) 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(1)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(1))
compiler := NewLuetCompiler(nil, generalRecipe.Tree(), generalRecipe.Tree().GetPackageSet()) compiler := NewLuetCompiler(nil, generalRecipe.GetDatabase())
spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "enman", Category: "app-admin", Version: "1.4.0"}) spec, err := compiler.FromPackage(&pkg.DefaultPackage{Name: "enman", Category: "app-admin", Version: "1.4.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())

4
pkg/installer/installer.go
View File

@@ -167,7 +167,7 @@ func (l *LuetInstaller) Install(p []pkg.Package, s *System) error {
// Gathers things to install // Gathers things to install
toInstall := map[string]ArtifactMatch{} toInstall := map[string]ArtifactMatch{}
for _, assertion := range solution { for _, assertion := range solution {
if assertion.Value && assertion.Package.Flagged() { if assertion.Value {
matches := syncedRepos.PackageMatches([]pkg.Package{assertion.Package}) matches := syncedRepos.PackageMatches([]pkg.Package{assertion.Package})
if len(matches) != 1 { if len(matches) != 1 {
return errors.New("Failed matching solutions against repository - where are definitions coming from?!") return errors.New("Failed matching solutions against repository - where are definitions coming from?!")
@@ -209,7 +209,7 @@ func (l *LuetInstaller) Install(p []pkg.Package, s *System) error {
// Finalizers needs to run in order and in sequence. // Finalizers needs to run in order and in sequence.
ordered := solution.Order(w.GetFingerPrint()) ordered := solution.Order(w.GetFingerPrint())
for _, ass := range ordered { for _, ass := range ordered {
if ass.Value && ass.Package.Flagged() { if ass.Value {
// Annotate to the system that the package was installed // Annotate to the system that the package was installed
// TODO: Annotate also files that belong to the package, somewhere to uninstall // TODO: Annotate also files that belong to the package, somewhere to uninstall
if _, err := s.Database.FindPackage(ass.Package); err == nil { if _, err := s.Database.FindPackage(ass.Package); err == nil {