External: configure sc properties for external cluster EC RBD pool

Adding extra field in storageClass "dataPool" when pool is
erasure coded pool in case of RBD.

Links:
1) storageClass https://github.com/rook/rook/blob/master/deploy/examples/csi/rbd/storageclass-ec.yaml#L45
2) Json Blob in case of EC RBD pool rook/rook#9276 (comment)

Signed-off-by: subhamkrai <srai@redhat.com>

controllers/storagecluster/external_resources.go

@@ -308,7 +308,7 @@ func (r *StorageClusterReconciler) createExternalStorageClusterResources(instanc
 				scc = newCephFilesystemStorageClassConfiguration(instance)
 				enableRookCSICephFS = true
 			} else if d.Name == cephRbdStorageClassName {
-				scc = newCephBlockPoolStorageClassConfiguration(instance)
+				scc = newCephBlockPoolStorageClassConfiguration(instance, d.Data)
 			} else if d.Name == cephRgwStorageClassName {
 				rgwEndpoint := d.Data[externalCephRgwEndpointKey]
 				if err := checkEndpointReachable(rgwEndpoint, 5*time.Second); err != nil {

controllers/storagecluster/external_resources_test.go

@@ -557,3 +557,61 @@ func TestExternalMonitoringResources(t *testing.T) {
 		})
 	}
 }
+
+func TestErasureCodedExternalResources(t *testing.T) {
+	cr := &api.StorageCluster{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "ocsinit",
+			Namespace: "openshift-storage",
+		},
+		Spec: api.StorageClusterSpec{
+			ExternalStorage: api.ExternalStorageClusterSpec{
+				Enable: true,
+			},
+			Monitoring: &api.MonitoringSpec{
+				ReconcileStrategy: string(ReconcileStrategyIgnore),
+			},
+		},
+	}
+	externalResource := []ExternalResource{
+		{
+			Name: "ceph-rbd",
+			Kind: "StorageClass",
+			Data: map[string]string{
+				"pool": generateNameForCephBlockPool(cr),
+			},
+		},
+		{
+			Name: "ceph-rbd-ec",
+			Kind: "StorageClass",
+			Data: map[string]string{
+				"dataPool": generateNameForCephBlockPool(cr),
+				"pool":     generateNameForErasureCodedCephBlockPool(cr),
+			},
+		},
+	}
+
+	actualSC := &storagev1.StorageClass{
+		Parameters: map[string]string{
+			"clusterID": cr.Namespace,
+			"pool":      generateNameForCephBlockPool(cr),
+			"csi.storage.k8s.io/provisioner-secret-name":      "rook-csi-rbd-provisioner",
+			"csi.storage.k8s.io/provisioner-secret-namespace": cr.Namespace,
+		},
+	}
+
+	for _, extR := range externalResource {
+		t.Run(extR.Name, func(t *testing.T) {
+			expectedSC := newCephBlockPoolStorageClassConfiguration(cr, extR.Data)
+			if extR.Data["dataPool"] != "" {
+				actualSC.Parameters["pool"] = generateNameForErasureCodedCephBlockPool(cr)
+				actualSC.Parameters["dataPool"] = generateNameForCephBlockPool(cr)
+			}
+			assert.Equal(t, expectedSC.storageClass.Parameters["clusterID"], actualSC.Parameters["clusterID"])
+			assert.Equal(t, expectedSC.storageClass.Parameters["dataPool"], actualSC.Parameters["dataPool"])
+			assert.Equal(t, expectedSC.storageClass.Parameters["pool"], actualSC.Parameters["pool"])
+			assert.Equal(t, expectedSC.storageClass.Parameters["csi.storage.k8s.io/provisioner-secret-name"], actualSC.Parameters["csi.storage.k8s.io/provisioner-secret-name"])
+			assert.Equal(t, expectedSC.storageClass.Parameters["csi.storage.k8s.io/provisioner-secret-namespace"], actualSC.Parameters["csi.storage.k8s.io/provisioner-secret-namespace"])
+		})
+	}
+}

controllers/storagecluster/generate.go

@@ -27,6 +27,10 @@ func generateNameForCephBlockPool(initData *ocsv1.StorageCluster) string {
 	return fmt.Sprintf("%s-cephblockpool", initData.Name)
 }
 
+func generateNameForErasureCodedCephBlockPool(initData *ocsv1.StorageCluster) string {
+	return fmt.Sprintf("ec-%s-cephblockpool", initData.Name)
+}
+
 func generateNameForCephObjectStore(initData *ocsv1.StorageCluster) string {
 	return fmt.Sprintf("%s-%s", initData.Name, "cephobjectstore")
 }

controllers/storagecluster/storageclasses.go

@@ -194,11 +194,11 @@ func newCephFilesystemStorageClassConfiguration(initData *ocsv1.StorageCluster)
 }
 
 // newCephBlockPoolStorageClassConfiguration generates configuration options for a Ceph Block Pool StorageClass.
-func newCephBlockPoolStorageClassConfiguration(initData *ocsv1.StorageCluster) StorageClassConfiguration {
+func newCephBlockPoolStorageClassConfiguration(initData *ocsv1.StorageCluster, data map[string]string) StorageClassConfiguration {
 	persistentVolumeReclaimDelete := corev1.PersistentVolumeReclaimDelete
 	allowVolumeExpansion := true
 	managementSpec := initData.Spec.ManagedResources.CephBlockPools
-	return StorageClassConfiguration{
+	sc := StorageClassConfiguration{
 		storageClass: &storagev1.StorageClass{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: generateNameForCephBlockPoolSC(initData),
@@ -228,6 +228,13 @@ func newCephBlockPoolStorageClassConfiguration(initData *ocsv1.StorageCluster) S
 		disable:           managementSpec.DisableStorageClass,
 		isClusterExternal: initData.Spec.ExternalStorage.Enable,
 	}
+
+	// In case of erasure coded, parameter `dataPool` is not empty. The parameter`dataPool` is the name of pool and `pool` is the name erasure coded pool
+	if data["dataPool"] != "" {
+		sc.storageClass.Parameters["pool"] = generateNameForErasureCodedCephBlockPool(initData)
+		sc.storageClass.Parameters["dataPool"] = generateNameForCephBlockPool(initData)
+	}
+	return sc
 }
 
 // newCephOBCStorageClassConfiguration generates configuration options for a Ceph Object Store StorageClass.
@@ -261,7 +268,7 @@ func newCephOBCStorageClassConfiguration(initData *ocsv1.StorageCluster) Storage
 func (r *StorageClusterReconciler) newStorageClassConfigurations(initData *ocsv1.StorageCluster) ([]StorageClassConfiguration, error) {
 	ret := []StorageClassConfiguration{
 		newCephFilesystemStorageClassConfiguration(initData),
-		newCephBlockPoolStorageClassConfiguration(initData),
+		newCephBlockPoolStorageClassConfiguration(initData, map[string]string{}),
 	}
 	// OBC storageclass will be returned only in TWO conditions,
 	// a. either 'externalStorage' is enabled