feat: adds git deployment generator (#161)

Author: jmgilman

cli/cmd/cmds/module/template.go

@@ -65,7 +65,8 @@ func (c *TemplateCmd) Run(ctx run.RunContext) error {
 			mod.Path = path
 		}
 
-		out, err := gen.Generate(mod, bundle.Bundle.Env)
+		raw := bundle.Raw.LookupPath(cue.ParsePath(fmt.Sprintf("modules.%s", c.Module)))
+		out, err := gen.Generate(mod, raw, bundle.Bundle.Env)
 		if err != nil {
 			return fmt.Errorf("failed to generate manifest: %w", err)
 		}

lib/project/deployment/generator/generator.go

@@ -42,7 +42,8 @@ func (d *Generator) GenerateBundle(b deployment.ModuleBundle, env cue.Value) (Ge
 	results := make(map[string][]byte)
 	for name, module := range nb.Bundle.Modules {
 		d.logger.Debug("Generating module", "name", name)
-		result, err := d.Generate(module, b.Bundle.Env)
+		raw := nb.Raw.LookupPath(cue.ParsePath(fmt.Sprintf("modules.%s", name)))
+		result, err := d.Generate(module, raw, b.Bundle.Env)
 		if err != nil {
 			return GeneratorResult{}, fmt.Errorf("failed to generate module %s: %w", name, err)
 		}
@@ -57,7 +58,7 @@ func (d *Generator) GenerateBundle(b deployment.ModuleBundle, env cue.Value) (Ge
 }
 
 // Generate generates manifests for a deployment module.
-func (d *Generator) Generate(m sp.Module, env string) ([]byte, error) {
+func (d *Generator) Generate(m sp.Module, raw cue.Value, env string) ([]byte, error) {
 	if err := deployment.Validate(m); err != nil {
 		return nil, fmt.Errorf("failed to validate module: %w", err)
 	}
@@ -67,7 +68,7 @@ func (d *Generator) Generate(m sp.Module, env string) ([]byte, error) {
 		return nil, fmt.Errorf("failed to get generator for module: %w", err)
 	}
 
-	manifests, err := mg.Generate(m, env)
+	manifests, err := mg.Generate(m, raw, env)
 	if err != nil {
 		return nil, fmt.Errorf("failed to generate manifest for module: %w", err)
 	}

lib/project/deployment/generator/generator_test.go

@@ -98,7 +98,7 @@ func TestGeneratorGenerateBundle(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			mg := &mocks.ManifestGeneratorMock{
-				GenerateFunc: func(mod sp.Module, env string) ([]byte, error) {
+				GenerateFunc: func(mod sp.Module, raw cue.Value, env string) ([]byte, error) {
 					if tt.err {
 						return nil, fmt.Errorf("error")
 					}
@@ -120,7 +120,7 @@ func TestGeneratorGenerateBundle(t *testing.T) {
 				store:  store,
 			}
 
-			tt.bundle.Raw = getRaw(tt.bundle.Bundle)
+			tt.bundle.Raw = getRawBundle(tt.bundle.Bundle)
 			result, err := gen.GenerateBundle(tt.bundle, tt.env)
 			tt.validate(t, result, err)
 		})
@@ -177,7 +177,7 @@ func TestGeneratorGenerate(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			mg := &mocks.ManifestGeneratorMock{
-				GenerateFunc: func(mod sp.Module, env string) ([]byte, error) {
+				GenerateFunc: func(mod sp.Module, raw cue.Value, env string) ([]byte, error) {
 					if tt.err {
 						return nil, fmt.Errorf("error")
 					}
@@ -199,15 +199,22 @@ func TestGeneratorGenerate(t *testing.T) {
 				store:  store,
 			}
 
-			result, err := gen.Generate(tt.module, tt.env)
+			result, err := gen.Generate(tt.module, getRawModule(tt.module), tt.env)
 			tt.validate(t, result, err)
 		})
 	}
 }
 
-func getRaw(mod sp.ModuleBundle) cue.Value {
+func getRawBundle(b sp.ModuleBundle) cue.Value {
 	ctx := cuecontext.New()
-	v := ctx.Encode(mod)
+	v := ctx.Encode(b)
+
+	return v
+}
+
+func getRawModule(m sp.Module) cue.Value {
+	ctx := cuecontext.New()
+	v := ctx.Encode(m)
 
 	return v
 }

lib/project/deployment/manifest_gen.go

@@ -1,6 +1,7 @@
 package deployment
 
 import (
+	"cuelang.org/go/cue"
 	sp "github.com/input-output-hk/catalyst-forge/lib/schema/blueprint/project"
 )
 
@@ -9,5 +10,5 @@ import (
 // ManifestGenerator generates deployment manifests.
 type ManifestGenerator interface {
 	// Generate generates a deployment manifest for the given module.
-	Generate(mod sp.Module, env string) ([]byte, error)
+	Generate(mod sp.Module, raw cue.Value, env string) ([]byte, error)
 }

lib/project/deployment/mocks/manifest.go

@@ -0,0 +1,86 @@
+package git
+
+import (
+	"fmt"
+	"log/slog"
+	"strings"
+
+	"cuelang.org/go/cue"
+	sp "github.com/input-output-hk/catalyst-forge/lib/schema/blueprint/project"
+	"github.com/input-output-hk/catalyst-forge/lib/tools/fs"
+	"github.com/input-output-hk/catalyst-forge/lib/tools/fs/billy"
+	"github.com/input-output-hk/catalyst-forge/lib/tools/git/repo"
+	"github.com/input-output-hk/catalyst-forge/lib/tools/git/repo/remote"
+)
+
+// Options is the configuration for the GitManifestGenerator.
+type Options struct {
+	Paths []string `json:"paths"`
+}
+
+// GitManifestGenerator is a ManifestGenerator that uses Git.
+// It clones the git repository and checks out the specified ref.
+// It then reads the file at the specified path and returns its contents.
+type GitManifestGenerator struct {
+	fs     fs.Filesystem
+	logger *slog.Logger
+	remote remote.GitRemoteInteractor
+}
+
+func (g *GitManifestGenerator) Generate(mod sp.Module, raw cue.Value, env string) ([]byte, error) {
+	var opts Options
+	v := raw.LookupPath(cue.ParsePath("values"))
+	if err := v.Decode(&opts); err != nil {
+		return nil, fmt.Errorf("failed to decode options: %w", err)
+	} else if len(opts.Paths) == 0 {
+		return nil, fmt.Errorf("no paths specified")
+	}
+
+	r, err := repo.NewGitRepo("/repo", g.logger, repo.WithFS(g.fs), repo.WithGitRemoteInteractor(g.remote))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create git repo: %w", err)
+	}
+
+	g.logger.Debug("Cloning git repo", "url", mod.Registry)
+	if err := r.Clone(mod.Registry); err != nil {
+		return nil, fmt.Errorf("failed to clone git repo %s: %w", mod.Registry, err)
+	}
+
+	g.logger.Debug("Checking out git ref", "ref", mod.Version)
+	if err := r.CheckoutRef(mod.Version); err != nil {
+		return nil, fmt.Errorf("failed to checkout ref %s: %w", mod.Version, err)
+	}
+
+	var final string
+	for _, path := range opts.Paths {
+		g.logger.Debug("Reading file from git repo", "path", path)
+		exists, err := r.Exists(path)
+		if err != nil {
+			return nil, fmt.Errorf("failed to check if path %s exists: %w", path, err)
+		} else if !exists {
+			return nil, fmt.Errorf("path %s does not exist in git repo", path)
+		}
+
+		contents, err := r.ReadFile(path)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read file %s: %w", path, err)
+		}
+
+		if final == "" {
+			final = strings.TrimPrefix(string(contents), "---\n")
+		} else {
+			final += "\n---\n" + strings.TrimPrefix(string(contents), "---\n")
+		}
+	}
+
+	return []byte(final), nil
+}
+
+// NewGitManifestGenerator creates a new GitManifestGenerator instance.
+func NewGitManifestGenerator(logger *slog.Logger) *GitManifestGenerator {
+	return &GitManifestGenerator{
+		fs:     billy.NewInMemoryFs(),
+		logger: logger,
+		remote: remote.GoGitRemoteInteractor{},
+	}
+}