Always resolve buildhash image, add --rebuild to build

cmd/build.go

@@ -111,6 +111,8 @@ Build packages specifying multiple definition trees:
 		onlydeps := viper.GetBool("onlydeps")
 		onlyTarget, _ := cmd.Flags().GetBool("only-target-package")
 		full, _ := cmd.Flags().GetBool("full")
+		rebuild, _ := cmd.Flags().GetBool("rebuild")
+
 		concurrent, _ := cmd.Flags().GetBool("solver-concurrent")
 		var results Results
 		backendArgs := viper.GetStringSlice("backend-args")
@@ -176,6 +178,7 @@ Build packages specifying multiple definition trees:
 			options.WithBuildValues(values),
 			options.WithPullRepositories(pullRepo),
 			options.WithPushRepository(imageRepository),
+			options.Rebuild(rebuild),
 			options.WithSolverOptions(*opts),
 			options.Wait(wait),
 			options.OnlyTarget(onlyTarget),
@@ -329,7 +332,7 @@ func init() {
 	buildCmd.Flags().Bool("solver-concurrent", false, "Use concurrent solver (experimental)")
 	buildCmd.Flags().Bool("live-output", LuetCfg.GetGeneral().ShowBuildOutput, "Enable live output of the build phase.")
 	buildCmd.Flags().Bool("from-repositories", false, "Consume the user-defined repositories to pull specfiles from")
-
+	buildCmd.Flags().Bool("rebuild", false, "To combine with --pull. Allows to rebuild the target package even if an image is available, against a local values file")
 	buildCmd.Flags().Bool("pretend", false, "Just print what packages will be compiled")
 	buildCmd.Flags().StringArrayP("pull-repository", "p", []string{}, "A list of repositories to pull the cache from")
 

pkg/compiler/compiler.go

@@ -606,7 +606,8 @@ func (cs *LuetCompiler) compileWithImage(image, builderHash string, packageTagHa
 	}
 
 	packageImage := fmt.Sprintf("%s:%s", cs.Options.PushImageRepository, packageTagHash)
-	buildertaggedImage := fmt.Sprintf("%s:%s", cs.Options.PushImageRepository, builderHash)
+	remoteBuildertaggedImage := fmt.Sprintf("%s:%s", cs.Options.PushImageRepository, builderHash)
+	builderResolved := cs.resolveExistingImageHash(builderHash, p)
 	//generated := false
 	// if buildertaggedImage == "" {
 	// 	buildertaggedImage = fmt.Sprintf("%s:%s", cs.Options.PushImageRepository, buildertaggedImage)
@@ -614,15 +615,13 @@ func (cs *LuetCompiler) compileWithImage(image, builderHash string, packageTagHa
 	// 	//	Debug(pkgTag, "Creating intermediary image", buildertaggedImage, "from", image)
 	// }
 
-	if cs.Options.PullFirst {
+	if cs.Options.PullFirst && !cs.Options.Rebuild {
 		Debug("Checking if an image is already available")
 		// FIXUP here. If packageimage hash exists and pull is true, generate package
 		resolved := cs.resolveExistingImageHash(packageTagHash, p)
 
-		builderResolved := cs.resolveExistingImageHash(builderHash, p)
-
 		//
-		if resolved != packageImage && buildertaggedImage != builderResolved { // an image is there already
+		if resolved != packageImage && remoteBuildertaggedImage != builderResolved { // an image is there already
 			Debug("Images available for", p.Package.HumanReadableString(), "generating artifact from remote images:", resolved)
 			return cs.genArtifact(p, backend.Options{ImageName: builderResolved}, backend.Options{ImageName: resolved}, concurrency, keepPermissions)
 		} else {
@@ -631,7 +630,7 @@ func (cs *LuetCompiler) compileWithImage(image, builderHash string, packageTagHa
 	}
 
 	// always going to point at the destination from the repo defined
-	builderOpts, runnerOpts, err := cs.buildPackageImage(image, buildertaggedImage, packageImage, concurrency, keepPermissions, p)
+	builderOpts, runnerOpts, err := cs.buildPackageImage(image, builderResolved, packageImage, concurrency, keepPermissions, p)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed building package image")
 	}

pkg/compiler/types/options/compiler_options.go

@@ -38,6 +38,7 @@ type Compiler struct {
 	BuildValues     []map[string]interface{}
 
 	PackageTargetOnly bool
+	Rebuild           bool
 
 	BackendArgs []string
 
@@ -131,6 +132,13 @@ func KeepImg(b bool) func(cfg *Compiler) error {
 	}
 }
 
+func Rebuild(b bool) func(cfg *Compiler) error {
+	return func(cfg *Compiler) error {
+		cfg.Rebuild = b
+		return nil
+	}
+}
+
 func PushImages(b bool) func(cfg *Compiler) error {
 	return func(cfg *Compiler) error {
 		cfg.Push = b