Add Nodeps, Onlydeps and Force options to Compiler

See #41

cmd/build.go

@@ -45,6 +45,8 @@ var buildCmd = &cobra.Command{
 		viper.BindPFlag("revdeps", cmd.Flags().Lookup("revdeps"))
 		viper.BindPFlag("all", cmd.Flags().Lookup("all"))
 		viper.BindPFlag("compression", cmd.Flags().Lookup("compression"))
+		viper.BindPFlag("nodeps", cmd.Flags().Lookup("nodeps"))
+		viper.BindPFlag("onlydeps", cmd.Flags().Lookup("onlydeps"))
 
 		viper.BindPFlag("image-repository", cmd.Flags().Lookup("image-repository"))
 		viper.BindPFlag("push", cmd.Flags().Lookup("push"))
@@ -72,6 +74,8 @@ var buildCmd = &cobra.Command{
 		push := viper.GetBool("push")
 		pull := viper.GetBool("pull")
 		keepImages := viper.GetBool("keep-images")
+		nodeps := viper.GetBool("nodeps")
+		onlydeps := viper.GetBool("onlydeps")
 
 		compilerSpecs := compiler.NewLuetCompilationspecs()
 		var compilerBackend compiler.CompilerBackend
@@ -126,6 +130,8 @@ var buildCmd = &cobra.Command{
 		opts.PullFirst = pull
 		opts.KeepImg = keepImages
 		opts.Push = push
+		opts.OnlyDeps = onlydeps
+		opts.NoDeps = nodeps
 		luetCompiler := compiler.NewLuetCompiler(compilerBackend, generalRecipe.GetDatabase(), opts)
 		luetCompiler.SetConcurrency(concurrency)
 		luetCompiler.SetCompressionType(compiler.CompressionImplementation(compressionType))
@@ -212,7 +218,8 @@ func init() {
 	buildCmd.Flags().Bool("push", false, "Push images to a hub")
 	buildCmd.Flags().Bool("pull", false, "Pull images from a hub")
 	buildCmd.Flags().Bool("keep-images", true, "Keep built docker images in the host")
-
+	buildCmd.Flags().Bool("nodeps", false, "Build only the target packages, skipping deps (it works only if you already built the deps locally, or by using --pull) ")
+	buildCmd.Flags().Bool("onlydeps", false, "Build only package dependencies")
 	buildCmd.Flags().String("solver-type", "", "Solver strategy")
 	buildCmd.Flags().Float32("solver-rate", 0.7, "Solver learning rate")
 	buildCmd.Flags().Float32("solver-discount", 1.0, "Solver discount rate")

pkg/compiler/compiler.go

@@ -427,7 +427,7 @@ func (cs *LuetCompiler) packageFromImage(p CompilationSpec, tag string, keepPerm
 			return art, err
 		}
 	}
-	pkgTag := ":package:  " + p.GetPackage().GetName()
+	pkgTag := ":package:  " + p.GetPackage().HumanReadableString()
 
 	Info(pkgTag, "   🍩 Build starts 🔨 🔨 🔨 ")
 
@@ -498,7 +498,7 @@ func (cs *LuetCompiler) ComputeDepTree(p CompilationSpec) (solver.PackagesAssert
 
 	solution, err := s.Install([]pkg.Package{p.GetPackage()})
 	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().HumanReadableString())
 	}
 
 	dependencies := solution.Order(cs.Database, p.GetPackage().GetFingerPrint())
@@ -530,7 +530,7 @@ func (cs *LuetCompiler) Compile(keepPermissions bool, p CompilationSpec) (Artifa
 }
 
 func (cs *LuetCompiler) compile(concurrency int, keepPermissions bool, p CompilationSpec) (Artifact, error) {
-	Info(":package: Compiling", p.GetPackage().GetName(), "version", p.GetPackage().GetVersion(), ".... :coffee:")
+	Info(":package: Compiling", p.GetPackage().HumanReadableString(), ".... :coffee:")
 
 	if len(p.GetPackage().GetRequires()) == 0 && p.GetImage() == "" {
 		Error("Package with no deps and no seed image supplied, bailing out")
@@ -558,16 +558,16 @@ func (cs *LuetCompiler) compile(concurrency int, keepPermissions bool, p Compila
 	depsN := 0
 	currentN := 0
 
-	Info(":deciduous_tree: Build dependencies for " + p.GetPackage().GetName())
+	if !cs.Options.NoDeps {
+		Info(":deciduous_tree: Build dependencies for " + p.GetPackage().HumanReadableString())
 		for _, assertion := range dependencies { //highly dependent on the order
 			depsN++
-		Info(" :arrow_right_hook:", assertion.Package.GetName(), ":leaves:", assertion.Package.GetVersion(), "(", assertion.Package.GetCategory(), ")")
-
+			Info(" :arrow_right_hook:", assertion.Package.HumanReadableString(), ":leaves:")
 		}
 
 		for _, assertion := range dependencies { //highly dependent on the order
 			currentN++
-		pkgTag := fmt.Sprintf(":package:  %d/%d %s ⤑ %s", currentN, depsN, p.GetPackage().GetName(), assertion.Package.GetName())
+			pkgTag := fmt.Sprintf(":package:  %d/%d %s ⤑ %s", currentN, depsN, p.GetPackage().HumanReadableString(), assertion.Package.HumanReadableString())
 			Info(pkgTag, "   :zap:  Building dependency")
 			compileSpec, err := cs.FromPackage(assertion.Package)
 			if err != nil {
@@ -585,31 +585,31 @@ func (cs *LuetCompiler) compile(concurrency int, keepPermissions bool, p Compila
 				// TODO: Refactor this
 				if compileSpec.ImageUnpack() { // If it is just an entire image, create a package from it
 					if compileSpec.GetImage() == "" {
-					return nil, errors.New("No image defined for package: " + assertion.Package.GetName())
+						return nil, errors.New("No image defined for package: " + assertion.Package.HumanReadableString())
 					}
 					Info(pkgTag, ":whale: Sourcing package from image", compileSpec.GetImage())
 					artifact, err := cs.packageFromImage(compileSpec, currentPackageImageHash, keepPermissions, cs.KeepImg, concurrency)
 					if err != nil {
-					return nil, errors.Wrap(err, "Failed compiling "+compileSpec.GetPackage().GetName())
+						return nil, errors.Wrap(err, "Failed compiling "+compileSpec.GetPackage().HumanReadableString())
 					}
 					departifacts = append(departifacts, artifact)
 					continue
 				}
 
-			Debug(pkgTag, " :wrench: Compiling "+compileSpec.GetPackage().GetFingerPrint()+" from image")
+				Debug(pkgTag, " :wrench: Compiling "+compileSpec.GetPackage().HumanReadableString()+" from image")
 				artifact, err := cs.compileWithImage(compileSpec.GetImage(), buildImageHash, currentPackageImageHash, concurrency, keepPermissions, cs.KeepImg, compileSpec)
 				if err != nil {
-				return nil, errors.Wrap(err, "Failed compiling "+compileSpec.GetPackage().GetName())
+					return nil, errors.Wrap(err, "Failed compiling "+compileSpec.GetPackage().HumanReadableString())
 				}
 				departifacts = append(departifacts, artifact)
 				Info(pkgTag, ":white_check_mark: Done")
 				continue
 			}
 
-		Debug(pkgTag, " :wrench: Compiling "+compileSpec.GetPackage().GetFingerPrint()+" from tree")
+			Debug(pkgTag, " :wrench: Compiling "+compileSpec.GetPackage().HumanReadableString()+" from tree")
 			artifact, err := cs.compileWithImage(buildImageHash, "", currentPackageImageHash, concurrency, keepPermissions, cs.KeepImg, compileSpec)
 			if err != nil {
-			return nil, errors.Wrap(err, "Failed compiling "+compileSpec.GetPackage().GetName())
+				return nil, errors.Wrap(err, "Failed compiling "+compileSpec.GetPackage().HumanReadableString())
 				//	deperrs = append(deperrs, err)
 				//		break // stop at first error
 			}
@@ -617,7 +617,12 @@ func (cs *LuetCompiler) compile(concurrency int, keepPermissions bool, p Compila
 			Info(pkgTag, ":collision: Done")
 		}
 
-	Info(":package:", p.GetPackage().GetName(), ":cyclone:  Building package target from:", lastHash)
+	} else if len(dependencies) > 0 {
+		lastHash = dependencies[len(dependencies)-1].Hash.PackageHash
+	}
+
+	if !cs.Options.OnlyDeps {
+		Info(":package:", p.GetPackage().HumanReadableString(), ":cyclone:  Building package target from:", lastHash)
 		artifact, err := cs.compileWithImage(lastHash, "", "", concurrency, keepPermissions, cs.KeepImg, p)
 		if err != nil {
 			return artifact, err
@@ -626,6 +631,9 @@ func (cs *LuetCompiler) compile(concurrency int, keepPermissions bool, p Compila
 		artifact.SetSourceAssertion(p.GetSourceAssertion())
 
 		return artifact, err
+	} else {
+		return departifacts[len(departifacts)-1], nil
+	}
 }
 
 func (cs *LuetCompiler) FromPackage(p pkg.Package) (CompilationSpec, error) {

pkg/compiler/interface.go

@@ -50,6 +50,8 @@ type CompilerOptions struct {
 	CompressionType          CompressionImplementation
 	Clean                    bool
 
+	OnlyDeps      bool
+	NoDeps        bool
 	SolverOptions config.LuetSolverOptions
 }
 
@@ -62,6 +64,8 @@ func NewDefaultCompilerOptions() *CompilerOptions {
 		KeepImg:         true,
 		Concurrency:     runtime.NumCPU(),
 		Clean:           true,
+		OnlyDeps:        false,
+		NoDeps:          false,
 	}
 }