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

Move image removal in compileWithImage and further cleanup

Browse Source
This commit is contained in:
Ettore Di Giacinto 2020-11-10 18:40:35 +01:00
parent 14c1d6ef24
commit a8624fe451
1 changed files with 43 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
pkg/compiler/compiler.go
View File

@ -281,7 +281,7 @@ func (cs *LuetCompiler) unpackDelta(rootfs string, concurrency int, keepPermissi
} }
func (cs *LuetCompiler) buildPackageImage(image, buildertaggedImage, packageImage string, func (cs *LuetCompiler) buildPackageImage(image, buildertaggedImage, packageImage string,
concurrency int, keepPermissions, keepImg bool, concurrency int, keepPermissions bool,
p CompilationSpec) (CompilerBackendOptions, CompilerBackendOptions, error) { p CompilationSpec) (CompilerBackendOptions, CompilerBackendOptions, error) {
var runnerOpts, builderOpts CompilerBackendOptions var runnerOpts, builderOpts CompilerBackendOptions
@ -339,9 +339,14 @@ func (cs *LuetCompiler) buildPackageImage(image, buildertaggedImage, packageImag
Info(pkgTag, ":whale: Generating 'builder' image definition from", image) Info(pkgTag, ":whale: Generating 'builder' image definition from", image)
// First we create the builder image // First we create the builder image
p.WriteBuildImageDefinition(filepath.Join(buildDir, p.GetPackage().GetFingerPrint()+"-builder.dockerfile")) if err := p.WriteBuildImageDefinition(filepath.Join(buildDir, p.GetPackage().GetFingerPrint()+"-builder.dockerfile")); err != nil {
return builderOpts, runnerOpts, errors.Wrap(err, "Could not generate image definition")
}
// Then we write the step image, which uses the builder one // Then we write the step image, which uses the builder one
p.WriteStepImageDefinition(buildertaggedImage, filepath.Join(buildDir, p.GetPackage().GetFingerPrint()+".dockerfile")) if err := p.WriteStepImageDefinition(buildertaggedImage, filepath.Join(buildDir, p.GetPackage().GetFingerPrint()+".dockerfile")); err != nil {
return builderOpts, runnerOpts, errors.Wrap(err, "Could not generate image definition")
}
builderOpts = CompilerBackendOptions{ builderOpts = CompilerBackendOptions{
ImageName: buildertaggedImage, ImageName: buildertaggedImage,
@ -356,57 +361,34 @@ func (cs *LuetCompiler) buildPackageImage(image, buildertaggedImage, packageImag
Destination: p.Rel(p.GetPackage().GetFingerPrint() + ".image.tar"), Destination: p.Rel(p.GetPackage().GetFingerPrint() + ".image.tar"),
} }
buildBuilderImage := true buildAndPush := func(opts CompilerBackendOptions) error {
buildImage := true
if cs.Options.PullFirst { if cs.Options.PullFirst {
if err := cs.Backend.DownloadImage(builderOpts); err == nil { if err := cs.Backend.DownloadImage(opts); err == nil {
buildBuilderImage = false buildImage = false
} }
} }
if buildImage {
if buildBuilderImage { if err := cs.Backend.BuildImage(opts); err != nil {
if err := cs.Backend.BuildImage(builderOpts); err != nil { return errors.Wrap(err, "Could not build image: "+image+" "+opts.DockerFileName)
return builderOpts, runnerOpts, errors.Wrap(err, "Could not build image: "+image+" "+builderOpts.DockerFileName)
} }
if cs.Options.Push { if cs.Options.Push {
if err = cs.Backend.Push(builderOpts); err != nil { if err = cs.Backend.Push(opts); err != nil {
return errors.Wrap(err, "Could not push image: "+image+" "+opts.DockerFileName)
}
}
}
return nil
}
if err := buildAndPush(builderOpts); err != nil {
return builderOpts, runnerOpts, errors.Wrap(err, "Could not push image: "+image+" "+builderOpts.DockerFileName) return builderOpts, runnerOpts, errors.Wrap(err, "Could not push image: "+image+" "+builderOpts.DockerFileName)
} }
}
}
if !keepImg { if err := buildAndPush(runnerOpts); err != nil {
defer func() {
// We keep them around, so to not reload them from the tar (which should be the "correct way") and we automatically share the same layers
err = cs.Backend.RemoveImage(builderOpts)
if err != nil {
Warning("Could not remove image ", builderOpts.ImageName)
}
err = cs.Backend.RemoveImage(runnerOpts)
if err != nil {
Warning("Could not remove image ", builderOpts.ImageName)
}
}()
}
buildPackageImage := true
if cs.Options.PullFirst {
//Best effort pull
if err := cs.Backend.DownloadImage(runnerOpts); err == nil {
buildPackageImage = false
}
}
if buildPackageImage {
if err := cs.Backend.BuildImage(runnerOpts); err != nil {
return builderOpts, runnerOpts, errors.Wrap(err, "Failed building image for "+runnerOpts.ImageName+" "+runnerOpts.DockerFileName)
}
if cs.Options.Push {
err = cs.Backend.Push(runnerOpts)
if err != nil {
return builderOpts, runnerOpts, errors.Wrap(err, "Could not push image: "+image+" "+builderOpts.DockerFileName) return builderOpts, runnerOpts, errors.Wrap(err, "Could not push image: "+image+" "+builderOpts.DockerFileName)
} }
}
}
return builderOpts, runnerOpts, nil return builderOpts, runnerOpts, nil
} }
@ -492,11 +474,23 @@ func (cs *LuetCompiler) compileWithImage(image, buildertaggedImage, packageImage
} }
} }
builderOpts, runnerOpts, err := cs.buildPackageImage(image, buildertaggedImage, packageImage, concurrency, keepPermissions, keepImg, p) builderOpts, runnerOpts, err := cs.buildPackageImage(image, buildertaggedImage, packageImage, concurrency, keepPermissions, p)
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed building package image") return nil, errors.Wrap(err, "failed building package image")
} }
if !keepImg {
defer func() {
// We keep them around, so to not reload them from the tar (which should be the "correct way") and we automatically share the same layers
if err := cs.Backend.RemoveImage(builderOpts); err != nil {
Warning("Could not remove image ", builderOpts.ImageName)
}
if err := cs.Backend.RemoveImage(runnerOpts); err != nil {
Warning("Could not remove image ", runnerOpts.ImageName)
}
}()
}
if !generateArtifact { if !generateArtifact {
return &PackageArtifact{}, nil return &PackageArtifact{}, nil
} }