feat: adds template command (#83)

Author: jmgilman

.github/workflows/deploy.yml

@@ -67,7 +67,7 @@ jobs:
       - name: Deploy
         uses: input-output-hk/catalyst-forge/actions/run@master
         with:
-          command: deploy
+          command: deploy push
           args: ${{ matrix.deployment }}
           local: ${{ inputs.local }}
           verbosity: ${{ inputs.verbosity }}

cli/cmd/cmds/deploy/cmd.go

@@ -0,0 +1,6 @@
+package deploy
+
+type DeployCmd struct {
+	Push     PushCmd     `cmd:"" help:"Pushes a project deployment to the GitOps repo."`
+	Template TemplateCmd `cmd:"" help:"Generates a project's deployment YAML."`
+}

cli/cmd/cmds/deploy.go renamed to cli/cmd/cmds/deploy/deploy.go

@@ -1,4 +1,4 @@
-package cmds
+package deploy
 
 import (
 	"fmt"
@@ -7,11 +7,11 @@ import (
 	"github.com/input-output-hk/catalyst-forge/cli/pkg/run"
 )
 
-type DeployCmd struct {
+type PushCmd struct {
 	Project string `arg:"" help:"The path to the project to deploy." kong:"arg,predictor=path"`
 }
 
-func (c *DeployCmd) Run(ctx run.RunContext) error {
+func (c *PushCmd) Run(ctx run.RunContext) error {
 	project, err := ctx.ProjectLoader.Load(c.Project)
 	if err != nil {
 		return fmt.Errorf("could not load project: %w", err)

cli/cmd/cmds/deploy/template.go

@@ -0,0 +1,38 @@
+package deploy
+
+import (
+	"fmt"
+
+	"github.com/input-output-hk/catalyst-forge/cli/pkg/deployment"
+	"github.com/input-output-hk/catalyst-forge/cli/pkg/run"
+)
+
+type TemplateCmd struct {
+	Project string `arg:"" help:"The path to the project." kong:"arg,predictor=path"`
+}
+
+func (c *TemplateCmd) Run(ctx run.RunContext) error {
+	project, err := ctx.ProjectLoader.Load(c.Project)
+	if err != nil {
+		return fmt.Errorf("could not load project: %w", err)
+	}
+
+	bundle, err := deployment.GenerateBundle(&project)
+	if err != nil {
+		return fmt.Errorf("could not generate bundle: %w", err)
+	}
+
+	templater, err := deployment.NewDefaultBundleTemplater(ctx.Logger)
+	if err != nil {
+		return fmt.Errorf("could not create bundle templater: %w", err)
+	}
+
+	out, err := templater.Render(bundle)
+	if err != nil {
+		return fmt.Errorf("could not render bundle: %w", err)
+	}
+
+	fmt.Println(out)
+
+	return nil
+}

cli/cmd/cmds/run.go

@@ -1,6 +1,7 @@
 package cmds
 
 import (
+	"github.com/input-output-hk/catalyst-forge/cli/pkg/earthly"
 	"github.com/input-output-hk/catalyst-forge/cli/pkg/run"
 	"github.com/input-output-hk/catalyst-forge/lib/tools/earthfile"
 )
@@ -35,3 +36,30 @@ func (c *RunCmd) Run(ctx run.RunContext) error {
 
 	return nil
 }
+
+// generateOpts generates the options for the Earthly executor based on command
+// flags.
+func generateOpts(flags *RunCmd, ctx run.RunContext) []earthly.EarthlyExecutorOption {
+	var opts []earthly.EarthlyExecutorOption
+
+	if flags != nil {
+		if flags.Artifact != "" {
+			opts = append(opts, earthly.WithArtifact(flags.Artifact))
+		}
+
+		if ctx.CI {
+			opts = append(opts, earthly.WithCI())
+		}
+
+		// Users can explicitly set the platforms to use without being in CI mode.
+		if flags.Platform != nil {
+			opts = append(opts, earthly.WithPlatforms(flags.Platform...))
+		}
+
+		if len(flags.TargetArgs) > 0 && flags.TargetArgs[0] != "" {
+			opts = append(opts, earthly.WithTargetArgs(flags.TargetArgs...))
+		}
+	}
+
+	return opts
+}

cli/cmd/cmds/scan.go

@@ -9,6 +9,7 @@ import (
 	"cuelang.org/go/cue"
 	"github.com/input-output-hk/catalyst-forge/cli/pkg/run"
 	"github.com/input-output-hk/catalyst-forge/cli/pkg/scan"
+	"github.com/input-output-hk/catalyst-forge/cli/pkg/utils"
 	"golang.org/x/exp/maps"
 )
 
@@ -55,14 +56,14 @@ func (c *ScanCmd) Run(ctx run.RunContext) error {
 			}
 		}
 
-		printJson(result, c.Pretty)
+		utils.PrintJson(result, c.Pretty)
 	case c.Blueprint:
 		result := make(map[string]cue.Value)
 		for path, project := range projects {
 			result[path] = project.Raw().Value()
 		}
 
-		printJson(result, c.Pretty)
+		utils.PrintJson(result, c.Pretty)
 	case c.Earthfile && len(c.Filter) > 0:
 		result := make(map[string]map[string][]string)
 		for _, filter := range c.Filter {
@@ -97,9 +98,9 @@ func (c *ScanCmd) Run(ctx run.RunContext) error {
 				sort.Strings(enumerated[filter])
 			}
 
-			printJson(enumerated, c.Pretty)
+			utils.PrintJson(enumerated, c.Pretty)
 		} else {
-			printJson(result, c.Pretty)
+			utils.PrintJson(result, c.Pretty)
 		}
 	case c.Earthfile:
 		result := make(map[string][]string)
@@ -112,15 +113,27 @@ func (c *ScanCmd) Run(ctx run.RunContext) error {
 		if ctx.CI {
 			enumerated := enumerate(result)
 			sort.Strings(enumerated)
-			printJson(enumerated, c.Pretty)
+			utils.PrintJson(enumerated, c.Pretty)
 		} else {
-			printJson(result, c.Pretty)
+			utils.PrintJson(result, c.Pretty)
 		}
 	default:
 		keys := maps.Keys(projects)
 		sort.Strings(keys)
-		printJson(keys, c.Pretty)
+		utils.PrintJson(keys, c.Pretty)
 	}
 
 	return nil
 }
+
+// enumerate enumerates the Earthfile+Target pairs from the target map.
+func enumerate(data map[string][]string) []string {
+	var result []string
+	for path, targets := range data {
+		for _, target := range targets {
+			result = append(result, fmt.Sprintf("%s+%s", path, target))
+		}
+	}
+
+	return result
+}

cli/cmd/cmds/secret.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/input-output-hk/catalyst-forge/cli/pkg/run"
+	"github.com/input-output-hk/catalyst-forge/cli/pkg/utils"
 	"github.com/input-output-hk/catalyst-forge/lib/project/schema"
 	"github.com/input-output-hk/catalyst-forge/lib/project/secrets"
 )
@@ -99,7 +100,7 @@ func (c *Get) Run(ctx run.RunContext) error {
 			fmt.Println(mappedSecret[c.Key])
 			return nil
 		} else {
-			printJson(mappedSecret, false)
+			utils.PrintJson(mappedSecret, false)
 			return nil
 		}
 	}

cli/cmd/cmds/util.go

@@ -10,6 +10,7 @@ import (
 	"github.com/alecthomas/kong"
 	"github.com/charmbracelet/log"
 	"github.com/input-output-hk/catalyst-forge/cli/cmd/cmds"
+	"github.com/input-output-hk/catalyst-forge/cli/cmd/cmds/deploy"
 	"github.com/input-output-hk/catalyst-forge/cli/pkg/run"
 	"github.com/input-output-hk/catalyst-forge/lib/project/project"
 	"github.com/input-output-hk/catalyst-forge/lib/project/schema"
@@ -21,18 +22,24 @@ import (
 
 var version = "dev"
 
+type GlobalArgs struct {
+	CI      bool `help:"Run in CI mode."`
+	Local   bool `short:"l" help:"Forces all runs to happen locally (ignores any remote satellites)."`
+	Verbose int  `short:"v" type:"counter" help:"Enable verbose logging."`
+}
+
 var cli struct {
-	cmds.GlobalArgs
-
-	Deploy   cmds.DeployCmd   `kong:"cmd" help:"Deploy a project."`
-	Dump     cmds.DumpCmd     `kong:"cmd" help:"Dumps a project's blueprint to JSON."`
-	CI       cmds.CICmd       `kong:"cmd" help:"Simulate a CI run."`
-	Release  cmds.ReleaseCmd  `kong:"cmd" help:"Release a project."`
-	Run      cmds.RunCmd      `kong:"cmd" help:"Run an Earthly target."`
-	Scan     cmds.ScanCmd     `kong:"cmd" help:"Scan for Earthfiles."`
-	Secret   cmds.SecretCmd   `kong:"cmd" help:"Manage secrets."`
-	Validate cmds.ValidateCmd `kong:"cmd" help:"Validates a project."`
-	Version  VersionCmd       `kong:"cmd" help:"Print the version."`
+	GlobalArgs
+
+	Deploy   deploy.DeployCmd `kong:"cmd" help:"Deploy a project."`
+	Dump     cmds.DumpCmd     `cmd:"" help:"Dumps a project's blueprint to JSON."`
+	CI       cmds.CICmd       `cmd:"" help:"Simulate a CI run."`
+	Release  cmds.ReleaseCmd  `cmd:"" help:"Release a project."`
+	Run      cmds.RunCmd      `cmd:"" help:"Run an Earthly target."`
+	Scan     cmds.ScanCmd     `cmd:"" help:"Scan for Earthfiles."`
+	Secret   cmds.SecretCmd   `cmd:"" help:"Manage secrets."`
+	Validate cmds.ValidateCmd `cmd:"" help:"Validates a project."`
+	Version  VersionCmd       `cmd:"" help:"Print the version."`
 
 	InstallCompletions kongplete.InstallCompletions `cmd:"" help:"install shell completions"`
 }

cli/cmd/main.go

@@ -0,0 +1,70 @@
+package deployment
+
+import (
+	"bytes"
+	"fmt"
+	"log/slog"
+	"path/filepath"
+
+	"github.com/input-output-hk/catalyst-forge/cli/pkg/executor"
+	"github.com/spf13/afero"
+)
+
+// BundleTemplater is an interface for rendering a bundle template to YAML.
+type BundleTemplater interface {
+	Render(Bundle) (string, error)
+}
+
+type DefaultBundleTemplater struct {
+	fs      afero.Fs
+	logger  *slog.Logger
+	timoni  executor.WrappedExecuter
+	stdout  *bytes.Buffer
+	stderr  *bytes.Buffer
+	workdir string
+}
+
+func (t DefaultBundleTemplater) Render(bundle Bundle) (string, error) {
+	t.logger.Info("Encoding bundle")
+	src, err := bundle.Encode()
+	if err != nil {
+		return "", err
+	}
+
+	bundlePath := filepath.Join(t.workdir, "bundle.cue")
+	t.logger.Info("Writing bundle", "path", bundlePath)
+	if err := afero.WriteFile(t.fs, bundlePath, src, 0644); err != nil {
+		return "", fmt.Errorf("could not write bundle: %w", err)
+	}
+
+	_, err = t.timoni.Execute("bundle", "build", "--log-pretty=false", "--log-color=false", "-f", bundlePath)
+	if err != nil {
+		t.logger.Error("Failed to build bundle", "error", err)
+		t.logger.Error("Timoni output", "output", t.stderr.String())
+		return "", fmt.Errorf("could not build bundle: %w", err)
+	}
+
+	return t.stdout.String(), nil
+}
+
+func NewDefaultBundleTemplater(logger *slog.Logger) (*DefaultBundleTemplater, error) {
+	fs := afero.NewOsFs()
+	workdir, err := afero.TempDir(fs, "", "catalyst-forge-")
+	if err != nil {
+		return nil, fmt.Errorf("failed to create temporary directory: %w", err)
+	}
+
+	var stdout, stderr bytes.Buffer
+
+	return &DefaultBundleTemplater{
+		fs:     afero.NewOsFs(),
+		logger: logger,
+		timoni: executor.NewLocalWrappedExecutor(
+			executor.NewLocalExecutor(logger, executor.WithRedirectTo(&stdout, &stderr)),
+			"timoni",
+		),
+		stdout:  &stdout,
+		stderr:  &stderr,
+		workdir: workdir,
+	}, nil
+}