Use Patch operation for CnsVolumeMetadata and CnsFileAccessConfig updates

Author: chethanv28

pkg/kubernetes/kubernetes.go

@@ -19,13 +19,15 @@ package kubernetes
 import (
 	"context"
 	"embed"
+	"encoding/json"
 	"flag"
 	"fmt"
 	"net"
 	"os"
 	"strconv"
 	"time"
 
+	jsonpatch "github.com/evanphx/json-patch/v5"
 	vmoperatorv1alpha1 "github.com/vmware-tanzu/vm-operator/api/v1alpha1"
 	vmoperatortypes "github.com/vmware-tanzu/vm-operator/api/v1alpha2"
 	v1 "k8s.io/api/core/v1"
@@ -37,6 +39,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
+	apitypes "k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/wait"
 	utilyaml "k8s.io/apimachinery/pkg/util/yaml"
 	clientset "k8s.io/client-go/kubernetes"
@@ -827,3 +830,46 @@ func RemoveFinalizer(ctx context.Context, c client.Client, obj client.Object, fi
 	log.Info("Removing finalizer from object.")
 	return c.Update(ctx, obj)
 }
+
+// PatchObject patches a Kubernetes object using strategic merge patch.
+// This function creates a patch between the original and modified objects and applies it using the client.
+// It returns an error if the patch operation fails.
+func PatchObject(ctx context.Context, k8sClient client.Client, original, modified client.Object) error {
+	log := logger.GetLogger(ctx)
+
+	// Marshal the original object
+	oldData, err := json.Marshal(original)
+	if err != nil {
+		log.Errorf("PatchObject: Failed to marshal original object %s/%s: %v",
+			original.GetNamespace(), original.GetName(), err)
+		return err
+	}
+
+	// Marshal the modified object
+	newData, err := json.Marshal(modified)
+	if err != nil {
+		log.Errorf("PatchObject: Failed to marshal modified object %s/%s: %v",
+			modified.GetNamespace(), modified.GetName(), err)
+		return err
+	}
+
+	// Create merge patch (compatible with both native K8s resources and CRDs)
+	patchBytes, err := jsonpatch.CreateMergePatch(oldData, newData)
+	if err != nil {
+		log.Errorf("PatchObject: Error creating merge patch for object %s/%s: %v",
+			original.GetNamespace(), original.GetName(), err)
+		return err
+	}
+
+	// Apply the patch
+	patch := client.RawPatch(apitypes.MergePatchType, patchBytes)
+	if err := k8sClient.Patch(ctx, original, patch); err != nil {
+		log.Errorf("PatchObject: Failed to patch object %s/%s: %v",
+			original.GetNamespace(), original.GetName(), err)
+		return err
+	}
+
+	log.Debugf("PatchObject: Successfully patched object %s/%s",
+		original.GetNamespace(), original.GetName())
+	return nil
+}

pkg/syncer/cnsoperator/controller/cnsfileaccessconfig/cnsfileaccessconfig_controller.go

@@ -526,12 +526,13 @@ func addPvcFinalizer(ctx context.Context,
 		return nil
 	}
 
+	original := pvc.DeepCopy()
 	if !controllerutil.AddFinalizer(pvc, cnsoperatortypes.CNSPvcFinalizer) {
 		return fmt.Errorf("failed to add CNS finalizer to PVC %s in namespace %s", pvc.Name,
 			pvc.Namespace)
 	}
 
-	err = client.Update(ctx, pvc)
+	err = k8s.PatchObject(ctx, client, original, pvc)
 	if err != nil {
 		return fmt.Errorf("failed to add finalizer %s on PVC %s in namespace %s", cnsoperatortypes.CNSPvcFinalizer,
 			instance.Spec.PvcName, instance.Namespace)
@@ -597,14 +598,15 @@ func removeFinalizerFromPVC(ctx context.Context, client client.Client,
 		return nil
 	}
 
+	original := pvc.DeepCopy()
 	if !controllerutil.RemoveFinalizer(pvc, cnsoperatortypes.CNSPvcFinalizer) {
 		err := fmt.Errorf("failed to remove finalizer %s from PVC %s in namespace %s",
 			cnsoperatortypes.CNSPvcFinalizer, pvcName, pvc.Namespace)
 		log.Errorf("failed to remove finalizer from PVC. Err: %+v", err)
 		return err
 	}
 
-	err = client.Update(ctx, pvc)
+	err = k8s.PatchObject(ctx, client, original, pvc)
 	if err != nil {
 		return fmt.Errorf("failed to remove finalizer %s from PVC %s in namespace %s",
 			cnsoperatortypes.CNSPvcFinalizer, pvcName, pvc.Namespace)
@@ -872,9 +874,10 @@ func setInstanceError(ctx context.Context, r *ReconcileCnsFileAccessConfig,
 func updateCnsFileAccessConfig(ctx context.Context, client client.Client,
 	instance *v1a1.CnsFileAccessConfig) error {
 	log := logger.GetLogger(ctx)
-	err := client.Update(ctx, instance)
+	original := instance.DeepCopy()
+	err := k8s.PatchObject(ctx, client, original, instance)
 	if err != nil {
-		log.Errorf("failed to update CnsFileAccessConfig instance: %q on namespace: %q. Error: %+v",
+		log.Errorf("failed to patch CnsFileAccessConfig instance: %q on namespace: %q. Error: %+v",
 			instance.Name, instance.Namespace, err)
 	}
 	return err

pkg/syncer/cnsoperator/controller/cnsvolumemetadata/cnsvolumemetadata_controller.go

@@ -28,7 +28,8 @@ import (
 	"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"
-	"sigs.k8s.io/vsphere-csi-driver/v3/pkg/syncer/cnsoperator/util"
+	k8s "sigs.k8s.io/vsphere-csi-driver/v3/pkg/kubernetes"
+	cnsoperatorutil "sigs.k8s.io/vsphere-csi-driver/v3/pkg/syncer/cnsoperator/util"
 
 	"github.com/davecgh/go-spew/spew"
 	v1 "k8s.io/api/core/v1"
@@ -55,7 +56,6 @@ import (
 	volumes "sigs.k8s.io/vsphere-csi-driver/v3/pkg/common/cns-lib/volume"
 	cnsvsphere "sigs.k8s.io/vsphere-csi-driver/v3/pkg/common/cns-lib/vsphere"
 	csitypes "sigs.k8s.io/vsphere-csi-driver/v3/pkg/csi/types"
-	k8s "sigs.k8s.io/vsphere-csi-driver/v3/pkg/kubernetes"
 	cnsoperatortypes "sigs.k8s.io/vsphere-csi-driver/v3/pkg/syncer/cnsoperator/types"
 )
 
@@ -113,7 +113,7 @@ func newReconciler(mgr manager.Manager, configInfo *commonconfig.ConfigurationIn
 // add adds a new Controller to mgr with r as the reconcile.Reconciler.
 func add(mgr manager.Manager, r reconcile.Reconciler) error {
 	ctx, log := logger.GetNewContextWithLogger()
-	maxWorkerThreads := util.GetMaxWorkerThreads(ctx,
+	maxWorkerThreads := cnsoperatorutil.GetMaxWorkerThreads(ctx,
 		workerThreadsEnvVar, defaultMaxWorkerThreads)
 	// Create a new controller.
 	c, err := controller.New("cnsvolumemetadata-controller", mgr,
@@ -233,8 +233,9 @@ func (r *ReconcileCnsVolumeMetadata) Reconcile(ctx context.Context,
 				instance.Spec.EntityName, instance.Spec.EntityType, instance.Spec.GuestClusterID)
 			recordEvent(ctx, r, instance, v1.EventTypeWarning, msg)
 			// Update instance.status fields with the errors per volume.
-			if err = r.client.Update(ctx, instance); err != nil {
-				msg := fmt.Sprintf("ReconcileCnsVolumeMetadata: Failed to update status for %q. "+
+			original := instance.DeepCopy()
+			if err = k8s.PatchObject(ctx, r.client, original, instance); err != nil {
+				msg := fmt.Sprintf("ReconcileCnsVolumeMetadata: Failed to patch status for %q. "+
 					"Err: %v.", instance.Name, err)
 				recordEvent(ctx, r, instance, v1.EventTypeWarning, msg)
 			}
@@ -246,8 +247,9 @@ func (r *ReconcileCnsVolumeMetadata) Reconcile(ctx context.Context,
 		for index, finalizer := range instance.Finalizers {
 			if finalizer == cnsoperatortypes.CNSFinalizer {
 				log.Debugf("ReconcileCnsVolumeMetadata: Removing finalizer %q for instance %q", finalizer, instance.Name)
+				original := instance.DeepCopy()
 				instance.Finalizers = append(instance.Finalizers[:index], instance.Finalizers[index+1:]...)
-				if err = r.client.Update(ctx, instance); err != nil {
+				if err = k8s.PatchObject(ctx, r.client, original, instance); err != nil {
 					msg := fmt.Sprintf("ReconcileCnsVolumeMetadata: Failed to remove finalizer %q for %q. "+
 						"Err: %v. Requeueing request.", finalizer, instance.Name, err)
 					recordEvent(ctx, r, instance, v1.EventTypeWarning, msg)
@@ -276,8 +278,9 @@ func (r *ReconcileCnsVolumeMetadata) Reconcile(ctx context.Context,
 
 	// Set finalizer if it was not set already on this instance.
 	if !isFinalizerSet {
+		original := instance.DeepCopy()
 		instance.Finalizers = append(instance.Finalizers, cnsoperatortypes.CNSFinalizer)
-		if err = r.client.Update(ctx, instance); err != nil {
+		if err = k8s.PatchObject(ctx, r.client, original, instance); err != nil {
 			msg := fmt.Sprintf("ReconcileCnsVolumeMetadata: Failed to add finalizer %q for %q. "+
 				"Err: %v. Requeueing request.", cnsoperatortypes.CNSFinalizer, instance.Name, err)
 			recordEvent(ctx, r, instance, v1.EventTypeWarning, msg)
@@ -293,7 +296,8 @@ func (r *ReconcileCnsVolumeMetadata) Reconcile(ctx context.Context,
 			recordEvent(ctx, r, instance, v1.EventTypeWarning, msg)
 			// Update instance.status fields on supervisor API server and requeue
 			// the request.
-			_ = r.client.Update(ctx, instance)
+			original := instance.DeepCopy()
+			_ = k8s.PatchObject(ctx, r.client, original, instance)
 			return reconcile.Result{RequeueAfter: timeout}, nil
 		}
 		// Successfully updated CNS.
@@ -302,8 +306,9 @@ func (r *ReconcileCnsVolumeMetadata) Reconcile(ctx context.Context,
 			instance.Spec.EntityName, instance.Spec.EntityType, instance.Spec.GuestClusterID)
 		recordEvent(ctx, r, instance, v1.EventTypeNormal, msg)
 		// Update instance.status fields on supervisor API server.
-		if err = r.client.Update(ctx, instance); err != nil {
-			msg := fmt.Sprintf("ReconcileCnsVolumeMetadata: Failed to update status for %q. "+
+		original := instance.DeepCopy()
+		if err = k8s.PatchObject(ctx, r.client, original, instance); err != nil {
+			msg := fmt.Sprintf("ReconcileCnsVolumeMetadata: Failed to patch status for %q. "+
 				"Err: %v. Requeueing request.", instance.Name, err)
 			recordEvent(ctx, r, instance, v1.EventTypeWarning, msg)
 			return reconcile.Result{RequeueAfter: timeout}, err