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

⚙️ Small fixups and enhancements

Browse Source
This commit is contained in:
Ettore Di Giacinto 2022-04-27 18:59:41 +02:00 committed by mudler
parent e70a543f42
commit c363c916d6
10 changed files with 95 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
pkg/api/core/types/package.go
View File

@ -301,7 +301,16 @@ func (p *Package) HashFingerprint(salt string) string {
} }
func (p *Package) HumanReadableString() string { func (p *Package) HumanReadableString() string {
return fmt.Sprintf("%s/%s-%s", p.Category, p.Name, p.Version) switch {
case p.Category != "" && p.Name != "" && p.Version == "":
return fmt.Sprintf("%s/%s", p.Category, p.Name)
case p.Category == "" && p.Name != "" && p.Version == "":
return p.Name
case p.Category == "" && p.Name != "" && p.Version != "":
return fmt.Sprintf("%s@%s", p.Category, p.Name)
default:
return fmt.Sprintf("%s/%s-%s", p.Category, p.Name, p.Version)
}
} }
func PackageFromString(s string) *Package { func PackageFromString(s string) *Package {
@ -571,10 +580,10 @@ func (p *Package) Revdeps(definitiondb PackageDatabase) Packages {
func walkPackage(p *Package, definitiondb PackageDatabase, visited map[string]interface{}) Packages { func walkPackage(p *Package, definitiondb PackageDatabase, visited map[string]interface{}) Packages {
var versionsInWorld Packages var versionsInWorld Packages
if _, ok := visited[p.HumanReadableString()]; ok { if _, ok := visited[p.GetFingerPrint()]; ok {
return versionsInWorld return versionsInWorld
} }
visited[p.HumanReadableString()] = true visited[p.GetFingerPrint()] = true
revdeps, _ := definitiondb.GetRevdeps(p) revdeps, _ := definitiondb.GetRevdeps(p)
for _, r := range revdeps { for _, r := range revdeps {
@ -628,10 +637,10 @@ func DecodePackage(ID string, db PackageDatabase) (*Package, error) {
} }
func (pack *Package) scanRequires(definitiondb PackageDatabase, s *Package, visited map[string]interface{}) (bool, error) { func (pack *Package) scanRequires(definitiondb PackageDatabase, s *Package, visited map[string]interface{}) (bool, error) {
if _, ok := visited[pack.HumanReadableString()]; ok { if _, ok := visited[pack.GetFingerPrint()]; ok {
return false, nil return false, nil
} }
visited[pack.HumanReadableString()] = true visited[pack.GetFingerPrint()] = true
p, err := definitiondb.FindPackage(pack) p, err := definitiondb.FindPackage(pack)
if err != nil { if err != nil {
p = pack //relax things p = pack //relax things
@ -745,10 +754,10 @@ func (p *Package) GetRuntimePackage() (*Package, error) {
} }
func (pack *Package) buildFormula(definitiondb PackageDatabase, db PackageDatabase, visited map[string]interface{}) ([]bf.Formula, error) { func (pack *Package) buildFormula(definitiondb PackageDatabase, db PackageDatabase, visited map[string]interface{}) ([]bf.Formula, error) {
if _, ok := visited[pack.HumanReadableString()]; ok { if _, ok := visited[pack.GetFingerPrint()]; ok {
return nil, nil return nil, nil
} }
visited[pack.HumanReadableString()] = true visited[pack.GetFingerPrint()] = true
p, err := definitiondb.FindPackage(pack) p, err := definitiondb.FindPackage(pack)
if err != nil { if err != nil {
p = pack // Relax failures and trust the def p = pack // Relax failures and trust the def

38
pkg/compiler/compiler_test.go
View File

@ -24,6 +24,7 @@ import (
"github.com/mudler/luet/pkg/api/core/logger" "github.com/mudler/luet/pkg/api/core/logger"
"github.com/mudler/luet/pkg/api/core/types" "github.com/mudler/luet/pkg/api/core/types"
"github.com/mudler/luet/pkg/compiler"
helpers "github.com/mudler/luet/tests/helpers" helpers "github.com/mudler/luet/tests/helpers"
@ -32,7 +33,6 @@ import (
"github.com/mudler/luet/pkg/api/core/types/artifact" "github.com/mudler/luet/pkg/api/core/types/artifact"
. "github.com/mudler/luet/pkg/compiler" . "github.com/mudler/luet/pkg/compiler"
sd "github.com/mudler/luet/pkg/compiler/backend" sd "github.com/mudler/luet/pkg/compiler/backend"
"github.com/mudler/luet/pkg/compiler/types/options"
pkg "github.com/mudler/luet/pkg/database" pkg "github.com/mudler/luet/pkg/database"
fileHelper "github.com/mudler/luet/pkg/helpers/file" fileHelper "github.com/mudler/luet/pkg/helpers/file"
"github.com/mudler/luet/pkg/tree" "github.com/mudler/luet/pkg/tree"
@ -52,7 +52,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -95,7 +95,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "c", Category: "test", Version: "1.2"}) spec, err := compiler.FromPackage(&types.Package{Name: "c", Category: "test", Version: "1.2"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -125,7 +125,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "c", Category: "test", Version: "1.2"}) spec, err := compiler.FromPackage(&types.Package{Name: "c", Category: "test", Version: "1.2"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -157,7 +157,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(1), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(1), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -191,7 +191,7 @@ var _ = Describe("Compiler", func() {
err = generalRecipe.Load("../../tests/fixtures/templates") err = generalRecipe.Load("../../tests/fixtures/templates")
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(context.NewContext()))
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(1)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(1))
pkg, err := generalRecipe.GetDatabase().FindPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) pkg, err := generalRecipe.GetDatabase().FindPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
@ -215,7 +215,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(4)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(4))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "c", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&types.Package{Name: "c", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -271,7 +271,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(1), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(1), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "extra", Category: "layer", Version: "1.0"}) spec, err := compiler.FromPackage(&types.Package{Name: "extra", Category: "layer", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -795,7 +795,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "c", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&types.Package{Name: "c", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -873,7 +873,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2))
compiler := NewLuetCompiler(b, generalRecipe.GetDatabase(), compiler := NewLuetCompiler(b, generalRecipe.GetDatabase(),
options.EnablePushFinalImages, options.ForcePushFinalImages, options.WithFinalRepository(imageName)) compiler.EnablePushFinalImages, compiler.ForcePushFinalImages, compiler.WithFinalRepository(imageName))
spec, err := compiler.FromPackage(&types.Package{Name: "runtime", Category: "layer", Version: "0.1"}) spec, err := compiler.FromPackage(&types.Package{Name: "runtime", Category: "layer", Version: "0.1"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -984,7 +984,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "runtime", Category: "layer", Version: "0.1"}) spec, err := compiler.FromPackage(&types.Package{Name: "runtime", Category: "layer", Version: "0.1"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -1019,7 +1019,7 @@ var _ = Describe("Compiler", func() {
err := generalRecipe.Load("../../tests/fixtures/includeimage") err := generalRecipe.Load("../../tests/fixtures/includeimage")
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(context.NewContext()))
specs, err := compiler.FromDatabase(generalRecipe.GetDatabase(), true, "") specs, err := compiler.FromDatabase(generalRecipe.GetDatabase(), true, "")
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -1038,7 +1038,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "runtime", Category: "layer", Version: "0.1"}) spec, err := compiler.FromPackage(&types.Package{Name: "runtime", Category: "layer", Version: "0.1"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -1074,7 +1074,7 @@ var _ = Describe("Compiler", func() {
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(2))
compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(context.NewContext())) compiler := NewLuetCompiler(sd.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "runtime", Category: "layer", Version: "0.1"}) spec, err := compiler.FromPackage(&types.Package{Name: "runtime", Category: "layer", Version: "0.1"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -1155,11 +1155,11 @@ var _ = Describe("Compiler", func() {
defer cleanup(allImages...) defer cleanup(allImages...)
compiler := NewLuetCompiler(b, generalRecipe.GetDatabase(), compiler := NewLuetCompiler(b, generalRecipe.GetDatabase(),
options.WithFinalRepository("test/test"), compiler.WithFinalRepository("test/test"),
options.EnableGenerateFinalImages, compiler.EnableGenerateFinalImages,
options.WithRuntimeDatabase(installerRecipe.GetDatabase()), compiler.WithRuntimeDatabase(installerRecipe.GetDatabase()),
options.PullFirst(true), compiler.PullFirst(true),
options.WithContext(c)) compiler.WithContext(c))
spec, err := compiler.FromPackage(&types.Package{Name: "x", Category: "test", Version: "0.1"}) spec, err := compiler.FromPackage(&types.Package{Name: "x", Category: "test", Version: "0.1"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())

8
pkg/database/database_mem.go
View File

@ -134,10 +134,10 @@ func (db *InMemoryDatabase) GetAllPackages(packages chan *types.Package) error {
func (db *InMemoryDatabase) getRevdeps(p *types.Package, visited map[string]interface{}) (types.Packages, error) { func (db *InMemoryDatabase) getRevdeps(p *types.Package, visited map[string]interface{}) (types.Packages, error) {
var versionsInWorld types.Packages var versionsInWorld types.Packages
if _, ok := visited[p.HumanReadableString()]; ok { if _, ok := visited[p.GetFingerPrint()]; ok {
return versionsInWorld, nil return versionsInWorld, nil
} }
visited[p.HumanReadableString()] = true visited[p.GetFingerPrint()] = true
var res types.Packages var res types.Packages
packs, err := db.FindPackages(p) packs, err := db.FindPackages(p)
@ -443,7 +443,9 @@ func (db *InMemoryDatabase) RemovePackageFiles(p *types.Package) error {
func (db *InMemoryDatabase) RemovePackage(p *types.Package) error { func (db *InMemoryDatabase) RemovePackage(p *types.Package) error {
db.Lock() db.Lock()
defer db.Unlock() defer db.Unlock()
if _, exists := db.CacheNoVersion[p.GetPackageName()]; exists {
delete(db.CacheNoVersion[p.GetPackageName()], p.GetVersion())
}
delete(db.Database, p.GetFingerPrint()) delete(db.Database, p.GetFingerPrint())
return nil return nil
} }

2
pkg/installer/cli.go
View File

@ -87,7 +87,7 @@ func printMatches(artefacts map[string]ArtifactMatch) {
d := pterm.TableData{{"Program Name", "Version", "License", "Repository"}} d := pterm.TableData{{"Program Name", "Version", "License", "Repository"}}
for _, m := range artefacts { for _, m := range artefacts {
d = append(d, []string{ d = append(d, []string{
fmt.Sprintf("%s/%s", m.Package.GetCategory(), m.Package.GetName()), m.Package.HumanReadableString(),
pterm.LightGreen(m.Package.GetVersion()), m.Package.GetLicense(), m.Repository.GetName()}) pterm.LightGreen(m.Package.GetVersion()), m.Package.GetLicense(), m.Repository.GetName()})
} }
pterm.DefaultTable.WithHasHeader().WithData(d).Render() pterm.DefaultTable.WithHasHeader().WithData(d).Render()

10
pkg/installer/installer.go
View File

@ -1,4 +1,4 @@
// Copyright © 2019-2021 Ettore Di Giacinto <mudler@gentoo.org> // Copyright © 2019-2022 Ettore Di Giacinto <mudler@gentoo.org>
// //
// This program is free software; you can redistribute it and/or modify // 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 // it under the terms of the GNU General Public License as published by
@ -28,6 +28,7 @@ import (
"github.com/mudler/luet/pkg/api/core/config" "github.com/mudler/luet/pkg/api/core/config"
"github.com/mudler/luet/pkg/api/core/logger" "github.com/mudler/luet/pkg/api/core/logger"
"github.com/mudler/luet/pkg/helpers" "github.com/mudler/luet/pkg/helpers"
"github.com/mudler/luet/pkg/tree"
"github.com/mudler/luet/pkg/api/core/bus" "github.com/mudler/luet/pkg/api/core/bus"
"github.com/mudler/luet/pkg/api/core/types" "github.com/mudler/luet/pkg/api/core/types"
@ -801,6 +802,9 @@ func (l *LuetInstaller) getFinalizers(allRepos types.PackageDatabase, solution t
if !nodeps { if !nodeps {
// TODO: Lower those errors as l.Options.Context.Warning // TODO: Lower those errors as l.Options.Context.Warning
for _, w := range toInstall { for _, w := range toInstall {
if !fileHelper.Exists(w.Package.Rel(tree.FinalizerFile)) {
continue
}
// Finalizers needs to run in order and in sequence. // Finalizers needs to run in order and in sequence.
ordered, err := solution.Order(allRepos, w.Package.GetFingerPrint()) ordered, err := solution.Order(allRepos, w.Package.GetFingerPrint())
if err != nil { if err != nil {
@ -822,10 +826,12 @@ func (l *LuetInstaller) getFinalizers(allRepos types.PackageDatabase, solution t
toFinalize = append(toFinalize, treePackage) toFinalize = append(toFinalize, treePackage)
} }
} }
} }
} else { } else {
for _, c := range toInstall { for _, c := range toInstall {
if !fileHelper.Exists(c.Package.Rel(tree.FinalizerFile)) {
continue
}
treePackage, err := c.Repository.GetTree().GetDatabase().FindPackage(c.Package) treePackage, err := c.Repository.GetTree().GetDatabase().FindPackage(c.Package)
if err != nil { if err != nil {
return toFinalize, errors.Wrap(err, "Error getting package "+c.Package.HumanReadableString()) return toFinalize, errors.Wrap(err, "Error getting package "+c.Package.HumanReadableString())

29
pkg/installer/installer_test.go
View File

@ -25,7 +25,6 @@ import (
"github.com/mudler/luet/pkg/api/core/types" "github.com/mudler/luet/pkg/api/core/types"
compiler "github.com/mudler/luet/pkg/compiler" compiler "github.com/mudler/luet/pkg/compiler"
backend "github.com/mudler/luet/pkg/compiler/backend" backend "github.com/mudler/luet/pkg/compiler/backend"
"github.com/mudler/luet/pkg/compiler/types/options"
fileHelper "github.com/mudler/luet/pkg/helpers/file" fileHelper "github.com/mudler/luet/pkg/helpers/file"
pkg "github.com/mudler/luet/pkg/database" pkg "github.com/mudler/luet/pkg/database"
@ -73,7 +72,7 @@ var _ = Describe("Installer", func() {
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx),
generalRecipe.GetDatabase(), generalRecipe.GetDatabase(),
options.Concurrency(2)) compiler.Concurrency(2))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -190,7 +189,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx),
generalRecipe.GetDatabase(), options.Concurrency(2)) generalRecipe.GetDatabase(), compiler.Concurrency(2))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -313,7 +312,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(),
options.Concurrency(2)) compiler.Concurrency(2))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -442,7 +441,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(),
options.Concurrency(2)) compiler.Concurrency(2))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -540,7 +539,7 @@ urls:
Expect(len(generalRecipe2.GetDatabase().GetPackages())).To(Equal(1)) Expect(len(generalRecipe2.GetDatabase().GetPackages())).To(Equal(1))
c = compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe2.GetDatabase(), options.Concurrency(2)) c = compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe2.GetDatabase(), compiler.Concurrency(2))
spec, err = c.FromPackage(&types.Package{Name: "alpine", Category: "seed", Version: "1.0"}) spec, err = c.FromPackage(&types.Package{Name: "alpine", Category: "seed", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -601,7 +600,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(4)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(4))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2)) c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -714,7 +713,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(4)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(4))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2)) c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -831,7 +830,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(6)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(6))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2)) c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -969,7 +968,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
Expect(len(generalRecipeNewRepo.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipeNewRepo.GetDatabase().GetPackages())).To(Equal(3))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.Concurrency(2)) c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.Concurrency(2))
c2 := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipeNewRepo.GetDatabase()) c2 := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipeNewRepo.GetDatabase())
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
@ -1107,8 +1106,8 @@ urls:
c := compiler.NewLuetCompiler( c := compiler.NewLuetCompiler(
backend.NewSimpleDockerBackend(ctx), backend.NewSimpleDockerBackend(ctx),
generalRecipe.GetDatabase(), generalRecipe.GetDatabase(),
options.Concurrency(2), compiler.Concurrency(2),
options.WithCompressionType(types.GZip), compiler.WithCompressionType(types.GZip),
) )
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
@ -1271,8 +1270,8 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(4)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(4))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(),
options.Concurrency(2), compiler.Concurrency(2),
options.WithCompressionType(types.GZip)) compiler.WithCompressionType(types.GZip))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -1380,7 +1379,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), c := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(),
options.WithCompressionType(types.GZip)) compiler.WithCompressionType(types.GZip))
spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := c.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())

17
pkg/installer/repository_test.go
View File

@ -29,7 +29,6 @@ import (
artifact "github.com/mudler/luet/pkg/api/core/types/artifact" artifact "github.com/mudler/luet/pkg/api/core/types/artifact"
"github.com/mudler/luet/pkg/compiler" "github.com/mudler/luet/pkg/compiler"
backend "github.com/mudler/luet/pkg/compiler/backend" backend "github.com/mudler/luet/pkg/compiler/backend"
"github.com/mudler/luet/pkg/compiler/types/options"
pkg "github.com/mudler/luet/pkg/database" pkg "github.com/mudler/luet/pkg/database"
fileHelper "github.com/mudler/luet/pkg/helpers/file" fileHelper "github.com/mudler/luet/pkg/helpers/file"
. "github.com/mudler/luet/pkg/installer" . "github.com/mudler/luet/pkg/installer"
@ -139,11 +138,11 @@ var _ = Describe("Repository", func() {
Expect(len(generalRecipe2.GetDatabase().GetPackages())).To(Equal(1)) Expect(len(generalRecipe2.GetDatabase().GetPackages())).To(Equal(1))
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler2 := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe2.GetDatabase(), options.WithContext(context.NewContext())) compiler2 := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe2.GetDatabase(), compiler.WithContext(context.NewContext()))
spec2, err := compiler2.FromPackage(&types.Package{Name: "alpine", Category: "seed", Version: "1.0"}) spec2, err := compiler2.FromPackage(&types.Package{Name: "alpine", Category: "seed", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
compiler := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(context.NewContext())) compiler := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(context.NewContext()))
spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -236,11 +235,11 @@ urls:
Expect(len(generalRecipe2.GetDatabase().GetPackages())).To(Equal(1)) Expect(len(generalRecipe2.GetDatabase().GetPackages())).To(Equal(1))
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler2 := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe2.GetDatabase(), options.WithContext(ctx)) compiler2 := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe2.GetDatabase(), compiler.WithContext(ctx))
spec2, err := compiler2.FromPackage(&types.Package{Name: "alpine", Category: "seed", Version: "1.0"}) spec2, err := compiler2.FromPackage(&types.Package{Name: "alpine", Category: "seed", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
compiler := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(ctx)) compiler := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(ctx))
spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -354,11 +353,11 @@ urls:
Expect(len(generalRecipe2.GetDatabase().GetPackages())).To(Equal(1)) Expect(len(generalRecipe2.GetDatabase().GetPackages())).To(Equal(1))
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
compiler2 := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe2.GetDatabase(), options.WithContext(ctx)) compiler2 := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe2.GetDatabase(), compiler.WithContext(ctx))
spec2, err := compiler2.FromPackage(&types.Package{Name: "alpine", Category: "seed", Version: "1.0"}) spec2, err := compiler2.FromPackage(&types.Package{Name: "alpine", Category: "seed", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
compiler := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(ctx)) compiler := compiler.NewLuetCompiler(backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(ctx))
spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := compiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -488,7 +487,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(3))
localcompiler := compiler.NewLuetCompiler( localcompiler := compiler.NewLuetCompiler(
backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(ctx)) backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(ctx))
spec, err := localcompiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"}) spec, err := localcompiler.FromPackage(&types.Package{Name: "b", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
@ -563,7 +562,7 @@ urls:
Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(5)) Expect(len(generalRecipe.GetDatabase().GetPackages())).To(Equal(5))
localcompiler := compiler.NewLuetCompiler( localcompiler := compiler.NewLuetCompiler(
backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), options.WithContext(ctx)) backend.NewSimpleDockerBackend(ctx), generalRecipe.GetDatabase(), compiler.WithContext(ctx))
spec, err := localcompiler.FromPackage(&types.Package{Name: "a", Category: "test", Version: "1.99"}) spec, err := localcompiler.FromPackage(&types.Package{Name: "a", Category: "test", Version: "1.99"})
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())

40
pkg/installer/system.go
View File

@ -45,29 +45,31 @@ func (s *System) ExecuteFinalizers(ctx types.Context, packs []*types.Package) er
var errs error var errs error
executedFinalizer := map[string]bool{} executedFinalizer := map[string]bool{}
for _, p := range packs { for _, p := range packs {
if fileHelper.Exists(p.Rel(tree.FinalizerFile)) { if !fileHelper.Exists(p.Rel(tree.FinalizerFile)) {
out, err := template.RenderWithValues([]string{p.Rel(tree.FinalizerFile)}, p.Rel(types.PackageDefinitionFile)) continue
}
out, err := template.RenderWithValues([]string{p.Rel(tree.FinalizerFile)}, p.Rel(types.PackageDefinitionFile))
if err != nil {
ctx.Warning("Failed rendering finalizer for ", p.HumanReadableString(), err.Error())
errs = multierror.Append(errs, err)
continue
}
if _, exists := executedFinalizer[p.GetFingerPrint()]; !exists {
executedFinalizer[p.GetFingerPrint()] = true
ctx.Info("Executing finalizer for " + p.HumanReadableString())
finalizer, err := NewLuetFinalizerFromYaml([]byte(out))
if err != nil { if err != nil {
ctx.Warning("Failed rendering finalizer for ", p.HumanReadableString(), err.Error()) ctx.Warning("Failed reading finalizer for ", p.HumanReadableString(), err.Error())
errs = multierror.Append(errs, err) errs = multierror.Append(errs, err)
continue continue
} }
err = finalizer.RunInstall(ctx, s)
if _, exists := executedFinalizer[p.GetFingerPrint()]; !exists { if err != nil {
executedFinalizer[p.GetFingerPrint()] = true ctx.Warning("Failed running finalizer for ", p.HumanReadableString(), err.Error())
ctx.Info("Executing finalizer for " + p.HumanReadableString()) errs = multierror.Append(errs, err)
finalizer, err := NewLuetFinalizerFromYaml([]byte(out)) continue
if err != nil {
ctx.Warning("Failed reading finalizer for ", p.HumanReadableString(), err.Error())
errs = multierror.Append(errs, err)
continue
}
err = finalizer.RunInstall(ctx, s)
if err != nil {
ctx.Warning("Failed running finalizer for ", p.HumanReadableString(), err.Error())
errs = multierror.Append(errs, err)
continue
}
} }
} }
} }

4
pkg/solver/solver_test.go
View File

@ -1213,7 +1213,7 @@ var _ = Describe("Solver", func() {
} }
val, err := s.Conflicts(A, dbInstalled.World()) val, err := s.Conflicts(A, dbInstalled.World())
Expect(err.Error()).To(Equal("\n/B-")) Expect(err.Error()).To(Equal("\nB"))
Expect(val).To(BeTrue()) Expect(val).To(BeTrue())
}) })
@ -1237,7 +1237,7 @@ var _ = Describe("Solver", func() {
} }
val, err := s.Conflicts(D, dbInstalled.World()) val, err := s.Conflicts(D, dbInstalled.World())
Expect(err.Error()).To(Or(Equal("\n/A-\n/B-"), Equal("\n/B-\n/A-"))) Expect(err.Error()).To(Or(Equal("\nA\nB"), Equal("\nB\nA")))
Expect(val).To(BeTrue()) Expect(val).To(BeTrue())
}) })

2
tests/integration/29_nobuildtreeinheritvalues_noignored.sh
View File

@ -56,7 +56,7 @@ EOF
assertTrue 'create package' "[ -e '$tmpdir/testbuild/c-test-1.0.package.tar.zst' ]" assertTrue 'create package' "[ -e '$tmpdir/testbuild/c-test-1.0.package.tar.zst' ]"
assertTrue 'create package Z' "[ -e '$tmpdir/testbuild/z-test-1.0+2.package.tar.zst' ]" assertTrue 'create package Z' "[ -e '$tmpdir/testbuild/z-test-1.0+2.package.tar.zst' ]"
assertTrue 'create package interpolated' "[ -e '$tmpdir/testbuild/interpolated-test-1.0+2.package.tar.zst' ]" assertTrue 'create package interpolated' "[ -e '$tmpdir/testbuild/interpolated-test-1.0+2.package.tar.zst' ]"
assertContains 'Does use the upstream cache without specifying it (test/c-1.0)' "$build_output" "quay.io/mocaccinoos/integration-test-cache:895697a8bb51b219b78ed081fa1b778801e81505bb03f56acafcf3c476620fc1" assertContains 'Does use the upstream cache without specifying it (test/c-1.0)' "$build_output" "quay.io/mocaccinoos/integration-test-cache:bf767dba10e4aa9c25e09f1f61ed9944b8e4736f72b2a1f9ac0125f68a714580"
} }
testRepo() { testRepo() {