Create an initcontainer for persistent home setup

apis/controller/v1alpha1/devworkspaceoperatorconfig_types.go

@@ -152,6 +152,12 @@ type PersistentHomeConfig struct {
 	// Must be used with the 'per-user'/'common' or 'per-workspace' storage class in order to take effect.
 	// Disabled by default.
 	Enabled *bool `json:"enabled,omitempty"`
+	// Determines whether the init container that initializes the persistent home directory should be disabled.
+	// When the `/home/user` directory is persisted, the init container is used to initialize the directory before
+	// the workspace starts. If set to true, the init container will not be created.
+	// This field is not used if the `workspace.persistUserHome.enabled` field is set to false.
+	// Enabled by default.
+	DisableInitContainer *bool `json:"disableInitContainer,omitempty"`
 }
 
 type Proxy struct {

controllers/workspace/devworkspace_controller.go

@@ -294,7 +294,7 @@ func (r *DevWorkspaceReconciler) Reconcile(ctx context.Context, req ctrl.Request
 	if home.NeedsPersistentHomeDirectory(workspace) {
 		workspaceWithHomeVolume, err := home.AddPersistentHomeVolume(workspace)
 		if err != nil {
-			reconcileStatus.addWarning(fmt.Sprintf("Info: default persistentHome volume is not being used: %s", err.Error()))
+			reconcileStatus.addWarning(fmt.Sprintf("Info: unable to setup home persistence: %s", err.Error()))
 		} else {
 			workspace.Spec.Template = *workspaceWithHomeVolume
 		}

pkg/config/defaults.go

@@ -44,7 +44,8 @@ var defaultConfig = &v1alpha1.OperatorConfiguration{
 			PerWorkspace: &perWorkspaceStorageSize,
 		},
 		PersistUserHome: &v1alpha1.PersistentHomeConfig{
-			Enabled: pointer.Bool(false),
+			Enabled:              pointer.Bool(false),
+			DisableInitContainer: pointer.Bool(false),
 		},
 		IdleTimeout:              "15m",
 		ProgressTimeout:          "5m",

pkg/config/sync.go

@@ -338,6 +338,9 @@ func mergeConfig(from, to *controller.OperatorConfiguration) {
 			if from.Workspace.PersistUserHome.Enabled != nil {
 				to.Workspace.PersistUserHome.Enabled = from.Workspace.PersistUserHome.Enabled
 			}
+			if from.Workspace.PersistUserHome.DisableInitContainer != nil {
+				to.Workspace.PersistUserHome.DisableInitContainer = from.Workspace.PersistUserHome.DisableInitContainer
+			}
 		}
 		if from.Workspace.DefaultTemplate != nil {
 			templateSpecContentCopy := from.Workspace.DefaultTemplate.DeepCopy()
@@ -522,6 +525,9 @@ func GetCurrentConfigString(currConfig *controller.OperatorConfiguration) string
 			if workspace.PersistUserHome.Enabled != nil && *workspace.PersistUserHome.Enabled != *defaultConfig.Workspace.PersistUserHome.Enabled {
 				config = append(config, fmt.Sprintf("workspace.persistUserHome.enabled=%t", *workspace.PersistUserHome.Enabled))
 			}
+			if workspace.PersistUserHome.DisableInitContainer != nil && *workspace.PersistUserHome.DisableInitContainer != *defaultConfig.Workspace.PersistUserHome.DisableInitContainer {
+				config = append(config, fmt.Sprintf("workspace.persistUserHome.disableInitContainer=%t", *workspace.PersistUserHome.DisableInitContainer))
+			}
 		}
 		if !reflect.DeepEqual(workspace.PodSecurityContext, defaultConfig.Workspace.PodSecurityContext) {
 			config = append(config, "workspace.podSecurityContext is set")

pkg/constants/constants.go

@@ -41,6 +41,10 @@ const (
 
 	HomeVolumeName = "persistent-home"
 
+	HomeInitComponentName = "init-persistent-home"
+
+	HomeInitEventId = "init-persistent-home"
+
 	ServiceAccount = "devworkspace"
 
 	PVCStorageSize = "10Gi"

pkg/library/home/persistentHome.go

@@ -27,6 +27,24 @@ import (
 	"github.com/devfile/devworkspace-operator/pkg/constants"
 )
 
+const initScript = `(echo "Checking for stow command"
+STOW_COMPLETE=/home/user/.stow_completed
+if command -v stow &> /dev/null; then
+  if  [ ! -f $STOW_COMPLETE ]; then
+    echo "Running stow command"
+    stow . -t /home/user/ -d /home/tooling/ --no-folding -v 2 > /home/user/.stow.log 2>&1
+    cp -n /home/tooling/.viminfo /home/user/.viminfo
+    cp -n /home/tooling/.bashrc /home/user/.bashrc
+    cp -n /home/tooling/.bash_profile /home/user/.bash_profile
+    touch $STOW_COMPLETE
+  else
+    echo "Stow command already run. If you wish to re-run it, delete $STOW_COMPLETE from the persistent volume and restart the workspace."
+  fi
+else
+  echo "Stow command not found"
+fi) || true
+`
+
 // Returns a modified copy of the given DevWorkspace's Template Spec which contains an additional
 // Devfile volume 'persistentHome' that is mounted  to `/home/user/` for every container component defined in the DevWorkspace.
 // An error is returned if the addition of the 'persistentHome' volume would result
@@ -44,6 +62,13 @@ func AddPersistentHomeVolume(workspace *common.DevWorkspaceWithConfig) (*v1alpha
 		Path: constants.HomeUserDirectory,
 	}
 
+	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)
+		}
+	}
+
 	dwTemplateSpecCopy.Components = append(dwTemplateSpecCopy.Components, homeVolume)
 	for _, component := range dwTemplateSpecCopy.Components {
 		if component.Container == nil {
@@ -95,3 +120,122 @@ func storageStrategySupportsPersistentHome(workspace *common.DevWorkspaceWithCon
 	storageClass := workspace.Spec.Template.Attributes.GetString(constants.DevWorkspaceStorageTypeAttribute, nil)
 	return storageClass != constants.EphemeralStorageClassType
 }
+
+func addInitContainer(dwTemplateSpec *v1alpha2.DevWorkspaceTemplateSpec) error {
+
+	if initComponentExists(dwTemplateSpec) {
+		return fmt.Errorf("component named %s already exists in the devworkspace", constants.HomeInitComponentName)
+	}
+
+	if initCommandExists(dwTemplateSpec) {
+		return fmt.Errorf("command with id %s already exists in the devworkspace", constants.HomeInitEventId)
+	}
+
+	if initEventExists(dwTemplateSpec) {
+		return fmt.Errorf("event with id %s already exists in the devworkspace", constants.HomeInitEventId)
+	}
+
+	initContainer := inferInitContainer(dwTemplateSpec)
+	if initContainer == nil {
+		return fmt.Errorf("cannot infer initcontainer for home persistence setup")
+	}
+
+	addInitContainerComponent(dwTemplateSpec, initContainer)
+
+	if dwTemplateSpec.Commands == nil {
+		dwTemplateSpec.Commands = []v1alpha2.Command{}
+	}
+
+	if dwTemplateSpec.Events == nil {
+		dwTemplateSpec.Events = &v1alpha2.Events{}
+	}
+
+	dwTemplateSpec.Commands = append(dwTemplateSpec.Commands, v1alpha2.Command{
+		Id: constants.HomeInitEventId,
+		CommandUnion: v1alpha2.CommandUnion{
+			Apply: &v1alpha2.ApplyCommand{
+				Component: constants.HomeInitComponentName,
+			},
+		},
+	})
+
+	dwTemplateSpec.Events.PreStart = append(dwTemplateSpec.Events.PreStart, constants.HomeInitEventId)
+
+	return nil
+}
+
+func initComponentExists(dwTemplateSpec *v1alpha2.DevWorkspaceTemplateSpec) bool {
+	if dwTemplateSpec.Components == nil {
+		return false
+	}
+	for _, component := range dwTemplateSpec.Components {
+		if component.Name == constants.HomeInitComponentName {
+			return true
+		}
+	}
+	return false
+
+}
+
+func initCommandExists(dwTemplateSpec *v1alpha2.DevWorkspaceTemplateSpec) bool {
+	if dwTemplateSpec.Commands == nil {
+		return false
+	}
+	for _, command := range dwTemplateSpec.Commands {
+		if command.Id == constants.HomeInitEventId {
+			return true
+		}
+	}
+	return false
+}
+
+func initEventExists(dwTemplateSpec *v1alpha2.DevWorkspaceTemplateSpec) bool {
+	if dwTemplateSpec.Events == nil {
+		return false
+	}
+	for _, event := range dwTemplateSpec.Events.PreStart {
+		if event == constants.HomeInitEventId {
+			return true
+		}
+	}
+	return false
+
+}
+
+func addInitContainerComponent(dwTemplateSpec *v1alpha2.DevWorkspaceTemplateSpec, initContainer *v1alpha2.Container) {
+	initComponent := v1alpha2.Component{
+		Name: constants.HomeInitComponentName,
+		ComponentUnion: v1alpha2.ComponentUnion{
+			Container: &v1alpha2.ContainerComponent{
+				Container: *initContainer,
+			},
+		},
+	}
+	dwTemplateSpec.Components = append(dwTemplateSpec.Components, initComponent)
+}
+
+func inferInitContainer(dwTemplateSpec *v1alpha2.DevWorkspaceTemplateSpec) *v1alpha2.Container {
+	var nonImportedComponent v1alpha2.Component
+	for _, component := range dwTemplateSpec.Components {
+		if component.Container == nil {
+			continue
+		}
+
+		pluginSource := component.Attributes.GetString(constants.PluginSourceAttribute, nil)
+		if pluginSource == "" || pluginSource == "parent" {
+			// First non-imported container component is selected
+			nonImportedComponent = component
+			break
+		}
+	}
+
+	if nonImportedComponent.Name != "" {
+		image := nonImportedComponent.Container.Image
+		return &v1alpha2.Container{
+			Image:   image,
+			Command: []string{"/bin/sh", "-c"},
+			Args:    []string{initScript},
+		}
+	}
+	return nil
+}

pkg/library/home/testdata/persistent-home/creates-home-vm-when-enabled.yaml

@@ -6,6 +6,7 @@ input:
     workspace:
       persistUserHome:
         enabled: true
+        disableInitContainer: true
   workspace:
     components:
       - name: testing-container-1