fixup! fixup! fixup! fixup! fixup! fixup! fixes

Signed-off-by: Oleksii Kurinnyi <[email protected]>

Author: akurinnoy

controllers/workspace/devworkspace_controller.go

@@ -69,22 +69,6 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 )
 
-// applyHomeInitDefaults applies default values for image and command fields
-// of the init-persistent-home container.
-func applyHomeInitDefaults(c corev1.Container, workspace *common.DevWorkspaceWithConfig) (corev1.Container, error) {
-	if c.Image == "" {
-		inferred := home.InferWorkspaceImage(&workspace.Spec.Template)
-		if inferred == "" {
-			return c, fmt.Errorf("unable to infer workspace image for %s; specify image explicitly", constants.HomeInitComponentName)
-		}
-		c.Image = inferred
-	}
-	if len(c.Command) == 0 {
-		c.Command = []string{"/bin/sh", "-c"}
-	}
-	return c, nil
-}
-
 // validateNoAdvancedFields validates that the init-persistent-home container
 // does not use advanced Kubernetes container fields that could make behavior unpredictable.
 func validateNoAdvancedFields(c corev1.Container) error {
@@ -127,23 +111,36 @@ func validateNoAdvancedFields(c corev1.Container) error {
 }
 
 // validateHomeInitContainer validates all aspects of the init-persistent-home container.
+// It only validates fields that are present, as missing fields will be filled by
+// the strategic merge with the default init container.
 func validateHomeInitContainer(c corev1.Container) error {
-	if err := validateImageReference(c.Image); err != nil {
-		return fmt.Errorf("invalid image reference for %s: %w", constants.HomeInitComponentName, err)
+	// Only validate if present
+	if c.Image != "" {
+		if err := validateImageReference(c.Image); err != nil {
+			return fmt.Errorf("invalid image reference for %s: %w", constants.HomeInitComponentName, err)
+		}
 	}
 
-	if len(c.Command) != 2 || c.Command[0] != "/bin/sh" || c.Command[1] != "-c" {
-		return fmt.Errorf("command must be exactly [/bin/sh, -c] for %s", constants.HomeInitComponentName)
+	// Only validate if present
+	if c.Command != nil {
+		if len(c.Command) != 2 || c.Command[0] != "/bin/sh" || c.Command[1] != "-c" {
+			return fmt.Errorf("command must be exactly [/bin/sh, -c] for %s", constants.HomeInitComponentName)
+		}
 	}
 
-	if len(c.Args) != 1 {
-		return fmt.Errorf("args must contain exactly one script string for %s", constants.HomeInitComponentName)
+	// Only validate if present
+	if c.Args != nil {
+		if len(c.Args) != 1 {
+			return fmt.Errorf("args must contain exactly one script string for %s", constants.HomeInitComponentName)
+		}
 	}
 
+	// Always validate - should not be provided
 	if len(c.VolumeMounts) > 0 {
 		return fmt.Errorf("volumeMounts are not allowed for %s; persistent-home is auto-mounted at /home/user/", constants.HomeInitComponentName)
 	}
 
+	// Always validate - should not be provided
 	if err := validateNoAdvancedFields(c); err != nil {
 		return err
 	}
@@ -209,28 +206,6 @@ func ensureHomeInitContainerFields(c *corev1.Container) error {
 	return nil
 }
 
-// defaultAndValidateHomeInitContainer applies defaults and validation for a custom
-// DWOC-provided init container named init-persistent-home. It ensures a shell execution
-// model, a single script arg, injects the persistent-home mount at /home/user/, and
-// defaults image to the inferred workspace image if not provided.
-func defaultAndValidateHomeInitContainer(c corev1.Container, workspace *common.DevWorkspaceWithConfig) (corev1.Container, error) {
-	var err error
-
-	if c, err = applyHomeInitDefaults(c, workspace); err != nil {
-		return c, err
-	}
-
-	if err = validateHomeInitContainer(c); err != nil {
-		return c, err
-	}
-
-	if err = ensureHomeInitContainerFields(&c); err != nil {
-		return c, err
-	}
-
-	return c, nil
-}
-
 const (
 	startingWorkspaceRequeueInterval = 5 * time.Second
 )
@@ -552,9 +527,8 @@ func (r *DevWorkspaceReconciler) Reconcile(ctx context.Context, req ctrl.Request
 					reqLogger.Info("Skipping init-persistent-home container: DisableInitContainer is true")
 					continue
 				}
-				// Apply defaults and validation for init-persistent-home
-				container, err = defaultAndValidateHomeInitContainer(container, workspace)
-				if err != nil {
+				// Validate custom home init container
+				if err := validateHomeInitContainer(container); err != nil {
 					return r.failWorkspace(workspace, fmt.Sprintf("Invalid %s container: %s", constants.HomeInitComponentName, err), metrics.ReasonBadRequest, reqLogger, &reconcileStatus), nil
 				}
 			}

controllers/workspace/init_container_validation_test.go

@@ -19,71 +19,34 @@ import (
 	"strings"
 	"testing"
 
-	dw "github.com/devfile/api/v2/pkg/apis/workspaces/v1alpha2"
-	"github.com/devfile/devworkspace-operator/apis/controller/v1alpha1"
-	"github.com/devfile/devworkspace-operator/pkg/common"
 	"github.com/devfile/devworkspace-operator/pkg/constants"
 	"github.com/stretchr/testify/assert"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 )
 
-func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
-	workspace := &common.DevWorkspaceWithConfig{
-		DevWorkspace: &dw.DevWorkspace{
-			Spec: dw.DevWorkspaceSpec{
-				Template: dw.DevWorkspaceTemplateSpec{
-					DevWorkspaceTemplateSpecContent: dw.DevWorkspaceTemplateSpecContent{
-						Components: []dw.Component{
-							{
-								Name: "main-container",
-								ComponentUnion: dw.ComponentUnion{
-									Container: &dw.ContainerComponent{
-										Container: dw.Container{
-											Image: "test-image:latest",
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		Config: &v1alpha1.OperatorConfiguration{
-			Workspace: &v1alpha1.WorkspaceConfig{},
-		},
-	}
-
+func TestValidateInitContainer(t *testing.T) {
 	tests := []struct {
 		name        string
 		container   corev1.Container
 		expectError bool
 		errorMsg    string
-		validate    func(t *testing.T, result corev1.Container)
 	}{
 		{
-			name: "Defaults image when empty",
+			name: "Accepts container with only args (image and command will be filled by merge)",
 			container: corev1.Container{
 				Name: constants.HomeInitComponentName,
 				Args: []string{"echo 'test'"},
 			},
 			expectError: false,
-			validate: func(t *testing.T, result corev1.Container) {
-				assert.Equal(t, "test-image:latest", result.Image)
-			},
 		},
 		{
-			name: "Defaults command when empty",
+			name: "Accepts container with only image (command and args will be filled by merge)",
 			container: corev1.Container{
 				Name:  constants.HomeInitComponentName,
 				Image: "custom-image:latest",
-				Args:  []string{"echo 'test'"},
 			},
 			expectError: false,
-			validate: func(t *testing.T, result corev1.Container) {
-				assert.Equal(t, []string{"/bin/sh", "-c"}, result.Command)
-			},
 		},
 		{
 			name: "Accepts valid command",
@@ -100,7 +63,18 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 			container: corev1.Container{
 				Name:    constants.HomeInitComponentName,
 				Image:   "custom-image:latest",
-				Command: []string{"/bin/bash"},
+				Command: []string{"/bin/sh"},
+				Args:    []string{"echo 'test'"},
+			},
+			expectError: true,
+			errorMsg:    "command must be exactly [/bin/sh, -c]",
+		},
+		{
+			name: "Rejects empty command",
+			container: corev1.Container{
+				Name:    constants.HomeInitComponentName,
+				Image:   "custom-image:latest",
+				Command: []string{},
 				Args:    []string{"echo 'test'"},
 			},
 			expectError: true,
@@ -131,7 +105,6 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 			container: corev1.Container{
 				Name:  constants.HomeInitComponentName,
 				Image: "custom-image:latest",
-				Args:  []string{"echo 'test'"},
 				VolumeMounts: []corev1.VolumeMount{
 					{
 						Name:      "custom-volume",
@@ -142,44 +115,29 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 			expectError: true,
 			errorMsg:    "volumeMounts are not allowed for init-persistent-home",
 		},
-		{
-			name: "Injects persistent-home volumeMount",
-			container: corev1.Container{
-				Name:  constants.HomeInitComponentName,
-				Image: "custom-image:latest",
-				Args:  []string{"echo 'test'"},
-			},
-			expectError: false,
-			validate: func(t *testing.T, result corev1.Container) {
-				assert.Len(t, result.VolumeMounts, 1)
-				assert.Equal(t, constants.HomeVolumeName, result.VolumeMounts[0].Name)
-				assert.Equal(t, constants.HomeUserDirectory, result.VolumeMounts[0].MountPath)
-			},
-		},
 		{
 			name: "Allows env variables",
 			container: corev1.Container{
 				Name:  constants.HomeInitComponentName,
 				Image: "custom-image:latest",
-				Args:  []string{"echo 'test'"},
 				Env: []corev1.EnvVar{
-					{Name: "TEST_VAR", Value: "test-value"},
+					{
+						Name:  "TEST_VAR",
+						Value: "test-var",
+					},
 				},
 			},
 			expectError: false,
-			validate: func(t *testing.T, result corev1.Container) {
-				assert.Len(t, result.Env, 1)
-				assert.Equal(t, "TEST_VAR", result.Env[0].Name)
-			},
 		},
 		{
 			name: "Rejects ports",
 			container: corev1.Container{
 				Name:  constants.HomeInitComponentName,
 				Image: "custom-image:latest",
-				Args:  []string{"echo 'test'"},
 				Ports: []corev1.ContainerPort{
-					{ContainerPort: 8080},
+					{
+						ContainerPort: 8080,
+					},
 				},
 			},
 			expectError: true,
@@ -190,10 +148,11 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 			container: corev1.Container{
 				Name:  constants.HomeInitComponentName,
 				Image: "custom-image:latest",
-				Args:  []string{"echo 'test'"},
 				LivenessProbe: &corev1.Probe{
 					ProbeHandler: corev1.ProbeHandler{
-						HTTPGet: &corev1.HTTPGetAction{Path: "/health"},
+						HTTPGet: &corev1.HTTPGetAction{
+							Path: "/health",
+						},
 					},
 				},
 			},
@@ -205,7 +164,6 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 			container: corev1.Container{
 				Name:  constants.HomeInitComponentName,
 				Image: "custom-image:latest",
-				Args:  []string{"echo 'test'"},
 				SecurityContext: &corev1.SecurityContext{
 					RunAsUser: new(int64),
 				},
@@ -218,7 +176,6 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 			container: corev1.Container{
 				Name:  constants.HomeInitComponentName,
 				Image: "custom-image:latest",
-				Args:  []string{"echo 'test'"},
 				Resources: corev1.ResourceRequirements{
 					Limits: corev1.ResourceList{
 						corev1.ResourceMemory: resource.MustParse("128Mi"),
@@ -233,7 +190,6 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 			container: corev1.Container{
 				Name:       constants.HomeInitComponentName,
 				Image:      "custom-image:latest",
-				Args:       []string{"echo 'test'"},
 				WorkingDir: "/tmp",
 			},
 			expectError: true,
@@ -243,8 +199,7 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 			name: "Rejects image with whitespace",
 			container: corev1.Container{
 				Name:  constants.HomeInitComponentName,
-				Image: "nginx\nmalicious",
-				Args:  []string{"echo 'test'"},
+				Image: "nginx\tmalicious",
 			},
 			expectError: true,
 			errorMsg:    "invalid image reference",
@@ -253,7 +208,7 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := defaultAndValidateHomeInitContainer(tt.container, workspace)
+			err := validateHomeInitContainer(tt.container)
 
 			if tt.expectError {
 				assert.Error(t, err)
@@ -262,47 +217,11 @@ func TestDefaultAndValidateHomeInitContainer(t *testing.T) {
 				}
 			} else {
 				assert.NoError(t, err)
-				if tt.validate != nil {
-					tt.validate(t, result)
-				}
 			}
 		})
 	}
 }
 
-func TestDefaultAndValidateHomeInitContainer_NoWorkspaceImage(t *testing.T) {
-	workspaceNoImage := &common.DevWorkspaceWithConfig{
-		DevWorkspace: &dw.DevWorkspace{
-			Spec: dw.DevWorkspaceSpec{
-				Template: dw.DevWorkspaceTemplateSpec{
-					DevWorkspaceTemplateSpecContent: dw.DevWorkspaceTemplateSpecContent{
-						Components: []dw.Component{
-							{
-								Name: "volume-component",
-								ComponentUnion: dw.ComponentUnion{
-									Volume: &dw.VolumeComponent{},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		Config: &v1alpha1.OperatorConfiguration{
-			Workspace: &v1alpha1.WorkspaceConfig{},
-		},
-	}
-
-	container := corev1.Container{
-		Name: constants.HomeInitComponentName,
-		Args: []string{"echo 'test'"},
-	}
-
-	_, err := defaultAndValidateHomeInitContainer(container, workspaceNoImage)
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "unable to infer workspace image")
-}
-
 func TestValidateImageReference(t *testing.T) {
 	tests := []struct {
 		name        string

pkg/library/home/persistentHome.go

@@ -62,19 +62,8 @@ func AddPersistentHomeVolume(workspace *common.DevWorkspaceWithConfig) (*v1alpha
 		Path: constants.HomeUserDirectory,
 	}
 
-	// Determine if a custom home init container is configured via DWOC
-	hasCustomHomeInit := false
-	if workspace.Config != nil && workspace.Config.Workspace != nil {
-		for _, c := range workspace.Config.Workspace.InitContainers {
-			if c.Name == constants.HomeInitComponentName {
-				hasCustomHomeInit = true
-				break
-			}
-		}
-	}
-
 	// Add default init container only if not disabled and no custom init is configured
-	if (workspace.Config.Workspace.PersistUserHome.DisableInitContainer == nil || !*workspace.Config.Workspace.PersistUserHome.DisableInitContainer) && !hasCustomHomeInit {
+	if workspace.Config.Workspace.PersistUserHome.DisableInitContainer == nil || !*workspace.Config.Workspace.PersistUserHome.DisableInitContainer {
 		err := addInitContainer(dwTemplateSpecCopy)
 		if err != nil {
 			return nil, fmt.Errorf("failed to add init container for home persistence setup: %w", err)