Add SPR labels to PVC if needed (#3463)

Author: xing-yang

pkg/syncer/cnsoperator/controller/cnsregistervolume/cnsregistervolume_controller.go

@@ -560,7 +560,7 @@ func (r *ReconcileCnsRegisterVolume) Reconcile(ctx context.Context,
 	// Create PVC mapping to above created PV.
 	log.Infof("Creating PVC: %s", instance.Spec.PvcName)
 	pvcSpec, err := getPersistentVolumeClaimSpec(ctx, instance.Spec.PvcName, instance.Namespace, capacityInMb,
-		storageClassName, accessMode, pvName, datastoreAccessibleTopology)
+		storageClassName, accessMode, pvName, datastoreAccessibleTopology, instance)
 	if err != nil {
 		msg := fmt.Sprintf("Failed to create spec for PVC: %q. Error: %v", instance.Spec.PvcName, err)
 		log.Errorf(msg)

pkg/syncer/cnsoperator/controller/cnsregistervolume/cnsregistervolume_controller_test.go

@@ -47,6 +47,7 @@ import (
 	commoncotypes "sigs.k8s.io/vsphere-csi-driver/v3/pkg/csi/service/common/commonco/types"
 	"sigs.k8s.io/vsphere-csi-driver/v3/pkg/internalapis/cnsvolumeoperationrequest"
 	"sigs.k8s.io/vsphere-csi-driver/v3/pkg/syncer"
+	cnsoperatortypes "sigs.k8s.io/vsphere-csi-driver/v3/pkg/syncer/cnsoperator/types"
 )
 
 type mockVolumeManager struct {
@@ -450,10 +451,16 @@ var _ = Describe("Reconcile Accessibility Logic", func() {
 		patches.ApplyFunc(common.QueryVolumeByID, func(ctx context.Context, vm cnsvolume.Manager,
 			volumeID string, querySelection *cnstypes.CnsQuerySelection) (*cnstypes.CnsVolume, error) {
 			return &cnstypes.CnsVolume{
-				VolumeId:        cnstypes.CnsVolumeId{Id: volumeID},
-				DatastoreUrl:    "dummy-ds-url",
-				StoragePolicyId: "dummy-storage-policy-id",
-			}, nil
+					VolumeId:        cnstypes.CnsVolumeId{Id: volumeID},
+					DatastoreUrl:    "dummy-ds-url",
+					StoragePolicyId: "dummy-storage-policy-id",
+					BackingObjectDetails: &cnstypes.CnsBlockBackingDetails{
+						CnsBackingObjectDetails: cnstypes.CnsBackingObjectDetails{
+							CapacityInMb: 1024,
+						},
+					},
+				},
+				nil
 		})
 
 		patches.ApplyFunc(common.GetClusterComputeResourceMoIds, func(ctx context.Context) ([]string, bool, error) {
@@ -522,6 +529,88 @@ var _ = Describe("Reconcile Accessibility Logic", func() {
 		Expect(err).NotTo(HaveOccurred())
 		Expect(result).To(Equal(reconcile.Result{RequeueAfter: 0}))
 	})
+
+	It("should add vm name and storage policy reservation labels to PVC when both present on CR", func() {
+		// Test the getPersistentVolumeClaimSpec function directly
+		instance := &cnsregistervolumev1alpha1.CnsRegisterVolume{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "test-volume-with-labels",
+				Namespace: "test-ns",
+				Labels: map[string]string{
+					cnsoperatortypes.LabelVirtualMachineName:           "test-vm-name",
+					cnsoperatortypes.LabelStoragePolicyReservationName: "test-storage-policy-reservation-name",
+				},
+			},
+			Spec: cnsregistervolumev1alpha1.CnsRegisterVolumeSpec{
+				PvcName:    "test-pvc-with-labels",
+				VolumeID:   "dummy-volume-id",
+				AccessMode: "ReadWriteOnce",
+			},
+		}
+
+		// Test getPersistentVolumeClaimSpec function directly
+		pvcSpec, err := getPersistentVolumeClaimSpec(ctx, "test-pvc", "test-ns", 1024,
+			"test-storage-class", corev1.ReadWriteOnce, "test-pv", nil, instance)
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(pvcSpec).NotTo(BeNil())
+		Expect(pvcSpec.Labels).To(HaveKeyWithValue(cnsoperatortypes.LabelVirtualMachineName, "test-vm-name"))
+		Expect(pvcSpec.Labels).To(HaveKeyWithValue(cnsoperatortypes.LabelStoragePolicyReservationName,
+			"test-storage-policy-reservation-name"))
+	})
+
+	It("should not add labels to PVC when not present on CR", func() {
+		// Test the getPersistentVolumeClaimSpec function directly without labels
+		instance := &cnsregistervolumev1alpha1.CnsRegisterVolume{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "test-volume-without-labels",
+				Namespace: "test-ns",
+				// No labels set
+			},
+			Spec: cnsregistervolumev1alpha1.CnsRegisterVolumeSpec{
+				PvcName:    "test-pvc-without-labels",
+				VolumeID:   "dummy-volume-id",
+				AccessMode: "ReadWriteOnce",
+			},
+		}
+
+		// Test getPersistentVolumeClaimSpec function directly
+		pvcSpec, err := getPersistentVolumeClaimSpec(ctx, "test-pvc", "test-ns", 1024,
+			"test-storage-class", corev1.ReadWriteOnce, "test-pv", nil, instance)
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(pvcSpec).NotTo(BeNil())
+		Expect(pvcSpec.Labels).NotTo(HaveKey(cnsoperatortypes.LabelVirtualMachineName))
+		Expect(pvcSpec.Labels).NotTo(HaveKey(cnsoperatortypes.LabelStoragePolicyReservationName))
+	})
+
+	It("should not add vm name label when only that label is present on CR", func() {
+		// Test the getPersistentVolumeClaimSpec function directly with only vm name label
+		instance := &cnsregistervolumev1alpha1.CnsRegisterVolume{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      "test-volume-with-vm-label",
+				Namespace: "test-ns",
+				Labels: map[string]string{
+					cnsoperatortypes.LabelVirtualMachineName: "test-vm-name",
+					// Missing storage policy reservation label
+				},
+			},
+			Spec: cnsregistervolumev1alpha1.CnsRegisterVolumeSpec{
+				PvcName:    "test-pvc-with-vm-label",
+				VolumeID:   "dummy-volume-id",
+				AccessMode: "ReadWriteOnce",
+			},
+		}
+
+		// Test getPersistentVolumeClaimSpec function directly
+		pvcSpec, err := getPersistentVolumeClaimSpec(ctx, "test-pvc", "test-ns", 1024,
+			"test-storage-class", corev1.ReadWriteOnce, "test-pv", nil, instance)
+
+		Expect(err).NotTo(HaveOccurred())
+		Expect(pvcSpec).NotTo(BeNil())
+		Expect(pvcSpec.Labels).NotTo(HaveKey(cnsoperatortypes.LabelVirtualMachineName))
+		Expect(pvcSpec.Labels).NotTo(HaveKey(cnsoperatortypes.LabelStoragePolicyReservationName))
+	})
 })
 
 func TestCnsRegisterVolumeController(t *testing.T) {

pkg/syncer/cnsoperator/controller/cnsregistervolume/util.go

@@ -38,6 +38,7 @@ import (
 	cnsstoragepolicyquotasv1alpha2 "sigs.k8s.io/vsphere-csi-driver/v3/pkg/apis/cnsoperator/storagepolicy/v1alpha2"
 	"sigs.k8s.io/vsphere-csi-driver/v3/pkg/common/cns-lib/vsphere"
 	"sigs.k8s.io/vsphere-csi-driver/v3/pkg/csi/service/common"
+	"sigs.k8s.io/vsphere-csi-driver/v3/pkg/csi/service/common/commonco"
 	"sigs.k8s.io/vsphere-csi-driver/v3/pkg/csi/service/logger"
 	cnsoperatortypes "sigs.k8s.io/vsphere-csi-driver/v3/pkg/syncer/cnsoperator/types"
 )
@@ -279,12 +280,15 @@ func getPersistentVolumeSpec(volumeName string, volumeID string, capacity int64,
 // specified storage class.
 func getPersistentVolumeClaimSpec(ctx context.Context, name string, namespace string, capacity int64,
 	storageClassName string, accessMode v1.PersistentVolumeAccessMode, pvName string,
-	datastoreAccessibleTopology []map[string]string) (*v1.PersistentVolumeClaim, error) {
+	datastoreAccessibleTopology []map[string]string,
+	instance *cnsregistervolumev1alpha1.CnsRegisterVolume) (*v1.PersistentVolumeClaim, error) {
 
 	log := logger.GetLogger(ctx)
 	capacityInMb := strconv.FormatInt(capacity, 10) + "Mi"
+
 	var (
 		segmentsArray  []string
+		pvcLabels      = make(map[string]string)
 		topoAnnotation = make(map[string]string)
 	)
 	if datastoreAccessibleTopology != nil {
@@ -299,10 +303,24 @@ func getPersistentVolumeClaimSpec(ctx context.Context, name string, namespace st
 		topoAnnotation[common.AnnVolumeAccessibleTopology] = "[" + strings.Join(segmentsArray, ",") + "]"
 	}
 
+	// TODO: For now this FSS is added in CSI ConfigMap. Once this FSS is available in Capabilities CR, remove
+	// it from CSI ConfigMap and fetch FSS value from Capabilities CR.
+	if commonco.ContainerOrchestratorUtility.IsFSSEnabled(ctx, common.StoragePolicyReservationSupport) {
+		// Check if both labelVirtualMachineName and labelStoragePolicyReservationName are on CnsRegisterVolume CR.
+		// If both are present, add both to PVC
+		if vmName, vmOk := instance.Labels[cnsoperatortypes.LabelVirtualMachineName]; vmOk && vmName != "" {
+			if spName, spOk := instance.Labels[cnsoperatortypes.LabelStoragePolicyReservationName]; spOk && spName != "" {
+				pvcLabels[cnsoperatortypes.LabelVirtualMachineName] = vmName
+				pvcLabels[cnsoperatortypes.LabelStoragePolicyReservationName] = spName
+			}
+		}
+	}
+
 	claim := &v1.PersistentVolumeClaim{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:        name,
 			Namespace:   namespace,
+			Labels:      pvcLabels,
 			Annotations: topoAnnotation,
 		},
 		Spec: v1.PersistentVolumeClaimSpec{

pkg/syncer/cnsoperator/types/types.go

@@ -36,4 +36,9 @@ const (
 
 	// VSphereCSIDriverName is the vsphere CSI driver name
 	VSphereCSIDriverName = "csi.vsphere.vmware.com"
+
+	// Label that points to a VM name. This is added to CNSRegisterVolume CR and PVC.
+	LabelVirtualMachineName = "vm.consumer.storage.com/name"
+	// Label that points to a StoragePolicyReservation CR name. This is added to CNSRegisterVolume CR and PVC.
+	LabelStoragePolicyReservationName = "quota.storage.vmware.com/storagepolicyreservation-name"
 )