fix(bundler): skip components with overrides.enabled: false (#382)

Author: xdu31

pkg/bundler/bundler.go

@@ -188,6 +188,33 @@ func (b *DefaultBundler) Make(ctx context.Context, input recipe.RecipeInput, dir
 			"recipe must contain at least one component reference")
 	}
 
+	// Filter out disabled components (overrides.enabled: false)
+	enabledRefs := make([]recipe.ComponentRef, 0, len(recipeResult.ComponentRefs))
+	enabledSet := make(map[string]struct{})
+	for _, ref := range recipeResult.ComponentRefs {
+		if !ref.IsEnabled() {
+			slog.Info("skipping disabled component", "component", ref.Name)
+			continue
+		}
+		enabledRefs = append(enabledRefs, ref)
+		enabledSet[ref.Name] = struct{}{}
+	}
+	recipeResult.ComponentRefs = enabledRefs
+
+	// Filter DeploymentOrder to match enabled components
+	filteredOrder := make([]string, 0, len(recipeResult.DeploymentOrder))
+	for _, name := range recipeResult.DeploymentOrder {
+		if _, ok := enabledSet[name]; ok {
+			filteredOrder = append(filteredOrder, name)
+		}
+	}
+	recipeResult.DeploymentOrder = filteredOrder
+
+	if len(enabledRefs) == 0 {
+		return nil, errors.New(errors.ErrCodeInvalidRequest,
+			"recipe has no enabled components after filtering")
+	}
+
 	// Set default output directory
 	if dir == "" {
 		dir = "."

pkg/bundler/bundler_test.go

@@ -271,6 +271,70 @@ func TestMake_Success(t *testing.T) {
 	}
 }
 
+func TestMake_DisabledComponentsFiltered(t *testing.T) {
+	bundler, err := New()
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+
+	ctx := context.Background()
+	tmpDir := t.TempDir()
+
+	recipeResult := &recipe.RecipeResult{
+		APIVersion: "aicr.nvidia.com/v1alpha1",
+		Kind:       "Recipe",
+		Criteria: &recipe.Criteria{
+			Service:     "eks",
+			Accelerator: "h100",
+			Intent:      "training",
+		},
+		ComponentRefs: []recipe.ComponentRef{
+			{
+				Name:    "gpu-operator",
+				Version: "v25.3.3",
+				Type:    "helm",
+				Source:  "https://helm.ngc.nvidia.com/nvidia",
+			},
+			{
+				Name:      "aws-ebs-csi-driver",
+				Version:   "2.55.0",
+				Type:      "helm",
+				Source:    "https://kubernetes-sigs.github.io/aws-ebs-csi-driver",
+				Overrides: map[string]any{"enabled": false},
+			},
+		},
+		DeploymentOrder: []string{"gpu-operator", "aws-ebs-csi-driver"},
+	}
+
+	output, err := bundler.Make(ctx, recipeResult, tmpDir)
+	if err != nil {
+		t.Fatalf("Make() error = %v", err)
+	}
+
+	if output == nil {
+		t.Fatal("Make() returned nil output")
+	}
+
+	// Enabled component should have a directory
+	if _, statErr := os.Stat(filepath.Join(tmpDir, "gpu-operator", "values.yaml")); os.IsNotExist(statErr) {
+		t.Error("expected gpu-operator/values.yaml to be created")
+	}
+
+	// Disabled component should NOT have a directory
+	if _, statErr := os.Stat(filepath.Join(tmpDir, "aws-ebs-csi-driver")); !os.IsNotExist(statErr) {
+		t.Error("expected aws-ebs-csi-driver directory to NOT be created")
+	}
+
+	// deploy.sh should not reference the disabled component
+	deployScript, readErr := os.ReadFile(filepath.Join(tmpDir, "deploy.sh"))
+	if readErr != nil {
+		t.Fatalf("failed to read deploy.sh: %v", readErr)
+	}
+	if strings.Contains(string(deployScript), "aws-ebs-csi-driver") {
+		t.Error("deploy.sh should not contain aws-ebs-csi-driver")
+	}
+}
+
 func TestMake_WithValueOverrides(t *testing.T) {
 	cfg := config.NewConfig(
 		config.WithValueOverrides(map[string]map[string]string{

pkg/recipe/metadata.go

@@ -17,6 +17,7 @@ package recipe
 
 import (
 	"fmt"
+	"log/slog"
 	"maps"
 	"sort"
 	"strings"
@@ -119,6 +120,23 @@ type ComponentRef struct {
 	HealthCheckAsserts string `json:"healthCheckAsserts,omitempty" yaml:"healthCheckAsserts,omitempty"`
 }
 
+// IsEnabled returns whether this component is enabled for deployment.
+// A component is disabled when its Overrides map contains enabled: false.
+// Components without an explicit enabled override are enabled by default.
+func (c ComponentRef) IsEnabled() bool {
+	v, ok := c.Overrides["enabled"]
+	if !ok {
+		return true
+	}
+	enabled, ok := v.(bool)
+	if !ok {
+		slog.Warn("overrides.enabled is not a bool, treating component as enabled",
+			"component", c.Name, "value", v)
+		return true
+	}
+	return enabled
+}
+
 // ExpectedResource represents a Kubernetes resource that should exist after deployment.
 type ExpectedResource struct {
 	// Kind is the resource kind (e.g., "Deployment", "DaemonSet").

pkg/recipe/metadata_test.go

@@ -286,6 +286,48 @@ func TestRecipeMetadataSpecMerge(t *testing.T) {
 	}
 }
 
+func TestComponentRefIsEnabled(t *testing.T) {
+	tests := []struct {
+		name     string
+		ref      ComponentRef
+		expected bool
+	}{
+		{
+			name:     "no overrides",
+			ref:      ComponentRef{Name: "gpu-operator"},
+			expected: true,
+		},
+		{
+			name:     "enabled true",
+			ref:      ComponentRef{Name: "gpu-operator", Overrides: map[string]any{"enabled": true}},
+			expected: true,
+		},
+		{
+			name:     "enabled false",
+			ref:      ComponentRef{Name: "aws-ebs-csi-driver", Overrides: map[string]any{"enabled": false}},
+			expected: false,
+		},
+		{
+			name:     "enabled string false is not recognized",
+			ref:      ComponentRef{Name: "test", Overrides: map[string]any{"enabled": "false"}},
+			expected: true,
+		},
+		{
+			name:     "other overrides no enabled key",
+			ref:      ComponentRef{Name: "test", Overrides: map[string]any{"replicas": 3}},
+			expected: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.ref.IsEnabled()
+			if got != tt.expected {
+				t.Errorf("IsEnabled() = %v, want %v", got, tt.expected)
+			}
+		})
+	}
+}
+
 // TestComponentRefMergeInheritsFromBase verifies that when an overlay specifies
 // only partial fields for a component, the missing fields are inherited from base.
 func TestComponentRefMergeInheritsFromBase(t *testing.T) {