Merge branch 'main' into taint_addition

Author: mchmarny

pkg/bundler/deployer/helm/helm.go

@@ -23,14 +23,12 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
-	"text/template"
 	"time"
 
-	"gopkg.in/yaml.v3"
-
 	"github.com/NVIDIA/eidos/pkg/bundler/checksum"
 	"github.com/NVIDIA/eidos/pkg/bundler/deployer/shared"
 	"github.com/NVIDIA/eidos/pkg/errors"
+	"github.com/NVIDIA/eidos/pkg/manifest"
 	"github.com/NVIDIA/eidos/pkg/recipe"
 )
 
@@ -323,7 +321,13 @@ func (g *Generator) generateComponentDirectories(ctx context.Context, input *Gen
 							fmt.Sprintf("invalid manifest filename %q in component %s", filename, comp.Name))
 					}
 
-					rendered, renderErr := renderManifest(content, comp, input.ComponentValues[comp.Name])
+					rendered, renderErr := manifest.Render(content, manifest.RenderInput{
+						ComponentName: comp.Name,
+						Namespace:     comp.Namespace,
+						ChartName:     comp.ChartName,
+						ChartVersion:  comp.ChartVersion,
+						Values:        input.ComponentValues[comp.Name],
+					})
 					if renderErr != nil {
 						return nil, 0, errors.WrapWithContext(errors.ErrCodeInternal, "failed to render manifest template", renderErr,
 							map[string]any{"component": comp.Name, "filename": filename})
@@ -480,88 +484,6 @@ func reverseComponents(components []ComponentData) []ComponentData {
 	return reversed
 }
 
-// manifestData provides Helm-compatible template data for rendering manifests.
-type manifestData struct {
-	ComponentData
-	Values  map[string]any
-	Release releaseData
-	Chart   chartData
-}
-
-type releaseData struct {
-	Namespace string
-	Service   string
-}
-
-type chartData struct {
-	Name    string
-	Version string
-}
-
-// helmFuncMap returns Helm-compatible template functions for manifest rendering.
-func helmFuncMap() template.FuncMap {
-	return template.FuncMap{
-		"toYaml": func(v any) string {
-			out, err := yaml.Marshal(v)
-			if err != nil {
-				return ""
-			}
-			return strings.TrimSuffix(string(out), "\n")
-		},
-		"nindent": func(indent int, s string) string {
-			pad := strings.Repeat(" ", indent)
-			lines := strings.Split(s, "\n")
-			for i, line := range lines {
-				if line != "" {
-					lines[i] = pad + line
-				}
-			}
-			return "\n" + strings.Join(lines, "\n")
-		},
-		"toString": func(v any) string {
-			return fmt.Sprintf("%v", v)
-		},
-		"default": func(def, val any) any {
-			if val == nil {
-				return def
-			}
-			if s, ok := val.(string); ok && s == "" {
-				return def
-			}
-			return val
-		},
-	}
-}
-
-// renderManifest renders manifest content as a Go template with Helm-compatible
-// data and functions. Manifests can use .Values, .Release, .Chart, and functions
-// like toYaml, nindent, toString, and default.
-func renderManifest(content []byte, data ComponentData, values map[string]any) ([]byte, error) {
-	tmpl, err := template.New("manifest").Funcs(helmFuncMap()).Parse(string(content))
-	if err != nil {
-		return nil, err
-	}
-
-	md := manifestData{
-		ComponentData: data,
-		Values:        map[string]any{data.Name: values},
-		Release: releaseData{
-			Namespace: data.Namespace,
-			Service:   "Helm",
-		},
-		Chart: chartData{
-			Name:    data.ChartName,
-			Version: data.ChartVersion,
-		},
-	}
-
-	var buf strings.Builder
-	if err := tmpl.Execute(&buf, md); err != nil {
-		return nil, err
-	}
-	return []byte(buf.String()), nil
-}
-
 // hasYAMLObjects returns true if content contains at least one YAML object
 // (a non-comment, non-blank, non-separator line).
 func hasYAMLObjects(content []byte) bool {

pkg/bundler/deployer/helm/helm_test.go

@@ -1098,142 +1098,3 @@ func TestReverseComponents(t *testing.T) {
 		})
 	}
 }
-
-func TestRenderManifest(t *testing.T) {
-	tests := []struct {
-		name    string
-		content string
-		data    ComponentData
-		values  map[string]any
-		wantErr bool
-		wantSub string // substring expected in output
-	}{
-		{
-			name:    "valid template with values",
-			content: "namespace: {{ .Release.Namespace }}",
-			data:    ComponentData{Name: "gpu-operator", Namespace: "gpu-operator"},
-			values:  map[string]any{"enabled": true},
-			wantSub: "namespace: gpu-operator",
-		},
-		{
-			name:    "invalid template syntax",
-			content: "{{ .Invalid {{ }}",
-			data:    ComponentData{Name: "test"},
-			values:  nil,
-			wantErr: true,
-		},
-		{
-			name:    "chart data rendered",
-			content: "chart: {{ .Chart.Name }}-{{ .Chart.Version }}",
-			data:    ComponentData{Name: "gpu-operator", ChartName: "gpu-operator", ChartVersion: "25.3.3"},
-			values:  nil,
-			wantSub: "chart: gpu-operator-25.3.3",
-		},
-		{
-			name:    "nil values map",
-			content: "name: {{ .Name }}",
-			data:    ComponentData{Name: "test-comp"},
-			values:  nil,
-			wantSub: "name: test-comp",
-		},
-		{
-			name:    "toYaml function",
-			content: "config: {{ toYaml .Values.mycomp }}",
-			data:    ComponentData{Name: "mycomp"},
-			values:  map[string]any{"key": "value"},
-			wantSub: "key: value",
-		},
-		{
-			name:    "default function",
-			content: `ns: {{ default "fallback" .Release.Namespace }}`,
-			data:    ComponentData{Name: "test", Namespace: ""},
-			values:  nil,
-			wantSub: "ns: fallback",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result, err := renderManifest([]byte(tt.content), tt.data, tt.values)
-			if (err != nil) != tt.wantErr {
-				t.Fatalf("error = %v, wantErr %v", err, tt.wantErr)
-			}
-			if err == nil && tt.wantSub != "" {
-				if !strings.Contains(string(result), tt.wantSub) {
-					t.Errorf("output %q does not contain %q", string(result), tt.wantSub)
-				}
-			}
-		})
-	}
-}
-
-func TestHelmFuncMap(t *testing.T) {
-	funcs := helmFuncMap()
-
-	t.Run("toYaml", func(t *testing.T) {
-		fn := funcs["toYaml"].(func(any) string)
-
-		// map input
-		got := fn(map[string]string{"key": "value"})
-		if !strings.Contains(got, "key: value") {
-			t.Errorf("toYaml(map) = %q, want to contain 'key: value'", got)
-		}
-
-		// string input
-		got = fn("hello")
-		if got != "hello" {
-			t.Errorf("toYaml(string) = %q, want 'hello'", got)
-		}
-
-		// nil input
-		got = fn(nil)
-		if got != "null" {
-			t.Errorf("toYaml(nil) = %q, want 'null'", got)
-		}
-	})
-
-	t.Run("nindent", func(t *testing.T) {
-		fn := funcs["nindent"].(func(int, string) string)
-		got := fn(4, "line1\nline2")
-		if !strings.Contains(got, "    line1") {
-			t.Errorf("nindent should indent line1: got %q", got)
-		}
-		if !strings.Contains(got, "    line2") {
-			t.Errorf("nindent should indent line2: got %q", got)
-		}
-		if got[0] != '\n' {
-			t.Error("nindent should start with newline")
-		}
-	})
-
-	t.Run("toString", func(t *testing.T) {
-		fn := funcs["toString"].(func(any) string)
-		if got := fn(42); got != "42" {
-			t.Errorf("toString(42) = %q, want '42'", got)
-		}
-		if got := fn(nil); got != "<nil>" {
-			t.Errorf("toString(nil) = %q, want '<nil>'", got)
-		}
-	})
-
-	t.Run("default", func(t *testing.T) {
-		fn := funcs["default"].(func(any, any) any)
-
-		// nil value returns default
-		if got := fn("fallback", nil); got != "fallback" {
-			t.Errorf("default(fallback, nil) = %v, want 'fallback'", got)
-		}
-		// empty string returns default
-		if got := fn("fallback", ""); got != "fallback" {
-			t.Errorf("default(fallback, empty) = %v, want 'fallback'", got)
-		}
-		// non-empty returns value
-		if got := fn("fallback", "actual"); got != "actual" {
-			t.Errorf("default(fallback, actual) = %v, want 'actual'", got)
-		}
-		// non-string non-nil returns value
-		if got := fn("fallback", 42); got != 42 {
-			t.Errorf("default(fallback, 42) = %v, want 42", got)
-		}
-	})
-}

pkg/component/helpers.go

@@ -57,10 +57,10 @@ func MarshalYAMLWithHeader(v any, header ValuesHeader) ([]byte, error) {
 	var buf bytes.Buffer
 
 	// Write header comments
-	buf.WriteString(fmt.Sprintf("# %s Helm Values\n", header.ComponentName))
+	fmt.Fprintf(&buf, "# %s Helm Values\n", header.ComponentName)
 	buf.WriteString("# Generated from Cloud Native Stack Recipe\n")
-	buf.WriteString(fmt.Sprintf("# Bundler Version: %s\n", header.BundlerVersion))
-	buf.WriteString(fmt.Sprintf("# Recipe Version: %s\n", header.RecipeVersion))
+	fmt.Fprintf(&buf, "# Bundler Version: %s\n", header.BundlerVersion)
+	fmt.Fprintf(&buf, "# Recipe Version: %s\n", header.RecipeVersion)
 	buf.WriteString("\n")
 
 	// Serialize the values

pkg/defaults/timeouts.go

@@ -131,6 +131,10 @@ const (
 	// ResourceVerificationTimeout is the timeout for verifying individual
 	// expected resources exist and are healthy during deployment validation.
 	ResourceVerificationTimeout = 10 * time.Second
+
+	// ComponentRenderTimeout is the maximum time to render a single component
+	// via helm template or manifest file rendering during resource discovery.
+	ComponentRenderTimeout = 60 * time.Second
 )
 
 // Pod operation timeouts for validation and agent operations.