[devbox] Put generated files in hidden directory (#2495)

## Summary
Write generated files into the `.devbox` hidden directory. The directory comes with a .gitignore so that users don't accidentally check in the generated files. I've updated `shell` and `build` to use the files in that directory.

## How was it tested?
Compiled, ran on test project.

## Is this change backwards-compatible?
Yes.

Author: loreto

BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
         "tmpl/default.nix.tmpl",
         "tmpl/shell.nix.tmpl",
         "tmpl/Dockerfile.tmpl",
+        "tmpl/.gitignore.tmpl",
     ],
     importpath = "go.jetpack.io/axiom/opensource/devbox",
     visibility = ["//visibility:public"],

boxcli/build.go

@@ -11,9 +11,10 @@ func BuildCmd() *cobra.Command {
 	flags := &docker.BuildFlags{}
 
 	command := &cobra.Command{
-		Use:  "build [<dir>]",
-		Args: cobra.MaximumNArgs(1),
-		RunE: buildCmdFunc(flags),
+		Use:    "build [<dir>]",
+		Args:   cobra.MaximumNArgs(1),
+		Hidden: true, // Hide until ready for release.
+		RunE:   buildCmdFunc(flags),
 	}
 
 	command.Flags().BoolVar(

boxcli/generate.go

@@ -6,13 +6,12 @@ import (
 	"go.jetpack.io/axiom/opensource/devbox"
 )
 
-// TODO: this command is useful for debugging.
-// Decide whether we want to keep it for real – or it should be removed.
 func GenerateCmd() *cobra.Command {
 	command := &cobra.Command{
-		Use:  "generate [<dir>]",
-		Args: cobra.MaximumNArgs(1),
-		RunE: runGenerateCmd,
+		Use:    "generate [<dir>]",
+		Args:   cobra.MaximumNArgs(1),
+		Hidden: true, // For debugging only
+		RunE:   runGenerateCmd,
 	}
 	return command
 }

boxcli/plan.go

@@ -8,8 +8,6 @@ import (
 	"go.jetpack.io/axiom/opensource/devbox"
 )
 
-// TODO: this command is useful for debugging.
-// Decide whether we want to keep it for real – or it should be removed.
 func PlanCmd() *cobra.Command {
 	command := &cobra.Command{
 		Use:  "plan [<dir>]",

devbox.go

@@ -64,7 +64,8 @@ func (d *Devbox) Remove(pkgs ...string) error {
 
 func (d *Devbox) Build(opts ...docker.BuildOptions) error {
 	defaultFlags := &docker.BuildFlags{
-		Name: "devbox",
+		Name:           "devbox",
+		DockerfilePath: filepath.Join(d.srcDir, ".devbox/gen", "Dockerfile"),
 	}
 	opts = append([]docker.BuildOptions{docker.WithFlags(defaultFlags)}, opts...)
 
@@ -82,7 +83,6 @@ func (d *Devbox) Plan() *planner.BuildPlan {
 	return planner.MergePlans(basePlan, planner.Plan(d.srcDir))
 }
 
-// TODO: generate necessary files without modifying src directory.
 func (d *Devbox) Generate() error {
 	plan := d.Plan()
 	return generate(d.srcDir, plan)
@@ -93,7 +93,8 @@ func (d *Devbox) Shell() error {
 	if err != nil {
 		return errors.WithStack(err)
 	}
-	return nix.Shell(d.srcDir)
+	nixDir := filepath.Join(d.srcDir, ".devbox/gen")
+	return nix.Shell(nixDir)
 }
 
 func (d *Devbox) saveCfg() error {

docker/args.go

@@ -19,7 +19,9 @@ func ToArgs(args []string, flags *BuildFlags) []string {
 			args = append(args, "-t", fmt.Sprintf("%s:%s", flags.Name, tag))
 		}
 	}
-
+	if flags.DockerfilePath != "" {
+		args = append(args, "-f", flags.DockerfilePath)
+	}
 	if len(flags.Platforms) > 0 {
 		args = append(args, fmt.Sprintf("--platform=%s", strings.Join(flags.Platforms, ",")))
 	}

docker/docker.go

@@ -19,10 +19,11 @@ import (
 //   management.
 
 type BuildFlags struct {
-	Name      string
-	Tags      []string
-	Platforms []string
-	NoCache   bool
+	Name           string
+	Tags           []string
+	Platforms      []string
+	NoCache        bool
+	DockerfilePath string
 }
 
 type BuildOptions func(*BuildFlags)

generate.go

@@ -12,32 +12,38 @@ import (
 	"go.jetpack.io/axiom/opensource/devbox/planner"
 )
 
-//go:embed tmpl
+//go:embed tmpl/* tmpl/.*
 var tmplFS embed.FS
 
-func generate(path string, plan *planner.BuildPlan) error {
-	err := writeFromTemplate(path, plan, "Dockerfile")
-	if err != nil {
-		return errors.WithStack(err)
-	}
+func generate(rootPath string, plan *planner.BuildPlan) error {
+	// TODO: we should also generate a .dockerignore file
+	files := []string{".gitignore", "Dockerfile", "shell.nix", "default.nix"}
 
-	err = writeFromTemplate(path, plan, "shell.nix")
-	if err != nil {
-		return errors.WithStack(err)
-	}
+	outPath := filepath.Join(rootPath, ".devbox/gen")
 
-	err = writeFromTemplate(path, plan, "default.nix")
-	if err != nil {
-		return errors.WithStack(err)
+	for _, file := range files {
+		err := writeFromTemplate(outPath, plan, file)
+		if err != nil {
+			return errors.WithStack(err)
+		}
 	}
+
 	return nil
 }
 
 func writeFromTemplate(path string, plan *planner.BuildPlan, tmplName string) error {
-	tmplPath := fmt.Sprintf("tmpl/%s.tmpl", tmplName)
-	t := template.Must(template.New(tmplName+".tmpl").Funcs(templateFuncs).ParseFS(tmplFS, tmplPath))
+	embeddedPath := fmt.Sprintf("tmpl/%s.tmpl", tmplName)
+	t := template.Must(template.New(tmplName+".tmpl").Funcs(templateFuncs).ParseFS(tmplFS, embeddedPath))
+
+	// Should we clear the directory so we start "fresh"?
+	outPath := filepath.Join(path, tmplName)
+	outDir := filepath.Dir(outPath)
+	err := os.MkdirAll(outDir, 0755) // Ensure directory exists.
+	if err != nil {
+		return errors.WithStack(err)
+	}
 
-	f, err := os.Create(filepath.Join(path, tmplName))
+	f, err := os.Create(outPath)
 	defer func() {
 		_ = f.Close()
 	}()

tmpl/.gitignore.tmpl

@@ -0,0 +1,2 @@
+*
+.*

tmpl/Dockerfile.tmpl

@@ -1,6 +1,8 @@
 # syntax=docker/dockerfile:1
 
-FROM nixos/nix as builder
+FROM nixos/nix:2.10.3 as base
+
+FROM base as builder
 
 # 1. SETUP PHASE
 #    Setup the container, and install nix packages.
@@ -11,25 +13,25 @@ SHELL [ "/bin/sh", "-eux", "-o", "pipefail", "-c"]
 WORKDIR /scratch
 
 # Setup nix in its own layer so it can be cached.
-COPY --link ./default.nix ./
+COPY --link ./.devbox/gen/default.nix ./.devbox/gen/
 # Setup /nix/store as a cache directory.
 # Declaring it as a cache directory makes it empty directory, so we need to
 # specify, using from= and source=, that we want to re-copy the contents of
 # the directory from nixos/nix.
-RUN --mount=type=cache,target=/nix/store,from=nixos/nix,source=/nix/store \
-  nix-env -if default.nix
+RUN --mount=type=cache,target=/nix/store,from=base,source=/nix/store \
+  nix-env -if ./.devbox/gen/default.nix
 
 # 2. INSTALL PHASE
 #    Install libraries needed by the source code.
 # -----------------------------------------------
 
 COPY --link . ./
-RUN --mount=type=cache,target=/nix/store,from=nixos/nix,source=/nix/store {{.InstallCommand}}
+RUN --mount=type=cache,target=/nix/store,from=base,source=/nix/store {{.InstallCommand}}
 
 # 3. BUILD PHASE
 #    Compile the source code into an executable.
 # ----------------------------------------------
-RUN --mount=type=cache,target=/nix/store,from=nixos/nix,source=/nix/store {{.BuildCommand}}
+RUN --mount=type=cache,target=/nix/store,from=base,source=/nix/store {{.BuildCommand}}
 
 # 4. PACKAGING PHASE
 #    Create a minimal image that contains the executable.