feat : [CRW-5722] Add configuration option in DevWorkspaceOperatorConfig for storage access mode (#1019)

- Add configuration option named StorageAccessMode in WorkspaceConfig struct
- Set PVC accessMode if abovementioned option is set in WorkspaceConfig, default
  to ReadWriteOnce

Signed-off-by: Rohan Kumar <[email protected]>

Author: rohanKanojia

apis/controller/v1alpha1/devworkspaceoperatorconfig_types.go

@@ -134,7 +134,8 @@ type WorkspaceConfig struct {
 	StorageClassName *string `json:"storageClassName,omitempty"`
 	// DefaultStorageSize defines an optional struct with fields to specify the sizes of Persistent Volume Claims for storage
 	// classes used by DevWorkspaces.
-	DefaultStorageSize *StorageSizes `json:"defaultStorageSize,omitempty"`
+	DefaultStorageSize *StorageSizes                       `json:"defaultStorageSize,omitempty"`
+	StorageAccessMode  []corev1.PersistentVolumeAccessMode `json:"storageAccessMode,omitempty"`
 	// PersistUserHome defines configuration options for persisting the `/home/user/`
 	// directory in workspaces.
 	PersistUserHome *PersistentHomeConfig `json:"persistUserHome,omitempty"`

apis/controller/v1alpha1/zz_generated.deepcopy.go

@@ -130,13 +130,13 @@ func TestUseCommonStorageProvisionerForPerUserStorageClass(t *testing.T) {
 func TestProvisionStorageForCommonStorageClass(t *testing.T) {
 	tests := loadAllTestCasesOrPanic(t, "testdata/common-storage")
 	commonStorage := CommonStorageProvisioner{}
-	commonPVC, err := getPVCSpec("claim-devworkspace", "test-namespace", nil, resource.MustParse("10Gi"))
+	commonPVC, err := getPVCSpec("claim-devworkspace", "test-namespace", nil, resource.MustParse("10Gi"), nil)
 	if err != nil {
 		t.Fatalf("Failure during setup: %s", err)
 	}
 	commonPVC.Status.Phase = corev1.ClaimBound
 	clusterAPI := sync.ClusterAPI{
-		Client: fake.NewFakeClientWithScheme(scheme, commonPVC),
+		Client: fake.NewClientBuilder().WithScheme(scheme).WithObjects(commonPVC).Build(),
 		Logger: zap.New(),
 	}
 
@@ -166,15 +166,15 @@ func TestProvisionStorageForCommonStorageClass(t *testing.T) {
 
 func TestTerminatingPVC(t *testing.T) {
 	commonStorage := CommonStorageProvisioner{}
-	commonPVC, err := getPVCSpec("claim-devworkspace", "test-namespace", nil, resource.MustParse("10Gi"))
+	commonPVC, err := getPVCSpec("claim-devworkspace", "test-namespace", nil, resource.MustParse("10Gi"), nil)
 	if err != nil {
 		t.Fatalf("Failure during setup: %s", err)
 	}
 	testTime := metav1.Now()
 	commonPVC.SetDeletionTimestamp(&testTime)
 
 	clusterAPI := sync.ClusterAPI{
-		Client: fake.NewFakeClientWithScheme(scheme, commonPVC),
+		Client: fake.NewClientBuilder().WithScheme(scheme).WithObjects(commonPVC).Build(),
 		Logger: zap.New(),
 	}
 	testCase := loadTestCaseOrPanic(t, "testdata/common-storage/rewrites-volumes-for-common-pvc-strategy.yaml")

pkg/provision/storage/commonStorage_test.go

@@ -219,7 +219,7 @@ func syncPerWorkspacePVC(workspace *common.DevWorkspaceWithConfig, clusterAPI sy
 	}
 
 	storageClass := workspace.Config.Workspace.StorageClassName
-	pvc, err := getPVCSpec(common.PerWorkspacePVCName(workspace.Status.DevWorkspaceId), workspace.Namespace, storageClass, *pvcSize)
+	pvc, err := getPVCSpec(common.PerWorkspacePVCName(workspace.Status.DevWorkspaceId), workspace.Namespace, storageClass, *pvcSize, workspace.Config.Workspace.StorageAccessMode)
 	if err != nil {
 		return nil, err
 	}

pkg/provision/storage/perWorkspaceStorage.go

@@ -60,17 +60,18 @@ func WorkspaceNeedsStorage(workspace *dw.DevWorkspaceTemplateSpec) bool {
 	return containerlib.AnyMountSources(workspace.Components)
 }
 
-func getPVCSpec(name, namespace string, storageClass *string, size resource.Quantity) (*corev1.PersistentVolumeClaim, error) {
+func getPVCSpec(name, namespace string, storageClass *string, size resource.Quantity, storageAccessMode []corev1.PersistentVolumeAccessMode) (*corev1.PersistentVolumeClaim, error) {
+	if storageAccessMode == nil || len(storageAccessMode) == 0 {
+		storageAccessMode = []corev1.PersistentVolumeAccessMode{corev1.ReadWriteOnce}
+	}
 
 	return &corev1.PersistentVolumeClaim{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      name,
 			Namespace: namespace,
 		},
 		Spec: corev1.PersistentVolumeClaimSpec{
-			AccessModes: []corev1.PersistentVolumeAccessMode{
-				corev1.ReadWriteOnce,
-			},
+			AccessModes: storageAccessMode,
 			Resources: corev1.ResourceRequirements{
 				Requests: corev1.ResourceList{
 					"storage": size,
@@ -99,7 +100,7 @@ func syncCommonPVC(namespace string, config *v1alpha1.OperatorConfiguration, clu
 		}
 	}
 
-	pvc, err := getPVCSpec(config.Workspace.PVCName, namespace, config.Workspace.StorageClassName, pvcSize)
+	pvc, err := getPVCSpec(config.Workspace.PVCName, namespace, config.Workspace.StorageClassName, pvcSize, config.Workspace.StorageAccessMode)
 	if err != nil {
 		return nil, err
 	}

pkg/provision/storage/shared.go

@@ -0,0 +1,61 @@
+//
+// Copyright (c) 2019-2025 Red Hat, Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package storage
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+)
+
+func TestGetPVCSpecWithDefaultStorageAccessMode(t *testing.T) {
+	// Given
+	name := "test-pvc"
+	namespace := "default"
+	storageClass := "standard"
+
+	// When
+	pvc, err := getPVCSpec(name, namespace, &storageClass, resource.MustParse("5Gi"), nil)
+
+	// Then
+	assert.NoError(t, err, "Expected no error")
+	assert.Equal(t, name, pvc.Name, "PVC name should match")
+	assert.Equal(t, namespace, pvc.Namespace, "PVC namespace should match")
+	assert.Equal(t, storageClass, *pvc.Spec.StorageClassName, "Storage class should match")
+	assert.Equal(t, []corev1.PersistentVolumeAccessMode{corev1.ReadWriteOnce}, pvc.Spec.AccessModes, "Access modes should match")
+	assert.Equal(t, "5Gi", pvc.Spec.Resources.Requests.Storage().String(), "Storage size should match")
+}
+
+func TestGetPVCSpecWithCustomStorageAccessMode(t *testing.T) {
+	// Given
+	name := "test-pvc"
+	namespace := "default"
+	storageClass := "standard"
+	storageAccessMode := []corev1.PersistentVolumeAccessMode{corev1.ReadWriteOncePod}
+
+	// When
+	pvc, err := getPVCSpec(name, namespace, &storageClass, resource.MustParse("5Gi"), storageAccessMode)
+
+	// Then
+	assert.NoError(t, err, "Expected no error")
+	assert.Equal(t, name, pvc.Name, "PVC name should match")
+	assert.Equal(t, namespace, pvc.Namespace, "PVC namespace should match")
+	assert.Equal(t, storageClass, *pvc.Spec.StorageClassName, "Storage class should match")
+	assert.Equal(t, []corev1.PersistentVolumeAccessMode{corev1.ReadWriteOncePod}, pvc.Spec.AccessModes, "Access modes should match")
+	assert.Equal(t, "5Gi", pvc.Spec.Resources.Requests.Storage().String(), "Storage size should match")
+}