support StrategicMergePatchType (#113)

Signed-off-by: Wei Liu <[email protected]>

Author: skeeey

pkg/cloudevents/clients/utils/utils.go

@@ -16,6 +16,7 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/strategicpatch"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/klog/v2"
@@ -24,9 +25,25 @@ import (
 	"open-cluster-management.io/sdk-go/pkg/cloudevents/generic"
 )
 
-// Patch applies the patch to a resource with the patch type.
-func Patch[T generic.ResourceObject](patchType types.PatchType, work T, patchData []byte) (resource T, err error) {
-	workData, err := json.Marshal(work)
+// Patch applies the given patch to a `generic.ResourceObject` using the specified patch type.
+//
+// Parameters:
+// - patchType: The type of patch to apply (JSONPatchType, MergePatchType and StrategicMergePatchType are supported).
+// - original: The resource object to be patched.
+// - patchData: The raw patch data.
+//
+// Returns:
+// - The patched resource object.
+// - An error if the patching fails at any step.
+//
+// Notes on StrategicMergePatch:
+//   - Strategic Merge Patch (SMP) is a Kubernetes-specific patch type.
+//   - It relies on **struct tags** (e.g., `patchStrategy` and `patchMergeKey`) defined in the Go types
+//     of Kubernetes API objects to determine how to merge lists and maps (e.g., merge by key instead of replacing).
+//   - SMP **only works** on known Kubernetes built-in API types (e.g., corev1.Pod) that have these metadata tags.
+//   - It will **fail or behave incorrectly** if used on CRDs or custom types that don’t have the necessary tags.
+func Patch[T generic.ResourceObject](patchType types.PatchType, original T, patchData []byte) (resource T, err error) {
+	originalData, err := json.Marshal(original)
 	if err != nil {
 		return resource, err
 	}
@@ -39,26 +56,30 @@ func Patch[T generic.ResourceObject](patchType types.PatchType, work T, patchDat
 		if err != nil {
 			return resource, err
 		}
-		patchedData, err = patchObj.Apply(workData)
+		patchedData, err = patchObj.Apply(originalData)
 		if err != nil {
 			return resource, err
 		}
-
 	case types.MergePatchType:
-		patchedData, err = jsonpatch.MergePatch(workData, patchData)
+		patchedData, err = jsonpatch.MergePatch(originalData, patchData)
+		if err != nil {
+			return resource, err
+		}
+	case types.StrategicMergePatchType:
+		patchedData, err = strategicpatch.StrategicMergePatch(originalData, patchData, original)
 		if err != nil {
 			return resource, err
 		}
 	default:
 		return resource, fmt.Errorf("unsupported patch type: %s", patchType)
 	}
 
-	patchedWork := new(T)
-	if err := json.Unmarshal(patchedData, patchedWork); err != nil {
+	patchedResource := new(T)
+	if err := json.Unmarshal(patchedData, patchedResource); err != nil {
 		return resource, err
 	}
 
-	return *patchedWork, nil
+	return *patchedResource, nil
 }
 
 // ListResourcesWithOptions retrieves the resources from store which matches the options.

pkg/cloudevents/clients/utils/utils_test.go

@@ -7,6 +7,7 @@ import (
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/strategicpatch"
 	"k8s.io/client-go/tools/cache"
 
 	workv1 "open-cluster-management.io/api/work/v1"
@@ -68,6 +69,47 @@ func TestPatch(t *testing.T) {
 				}
 			},
 		},
+		{
+			name:      "strategic merge patch",
+			patchType: types.StrategicMergePatchType,
+			work: &workv1.ManifestWork{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "test",
+				},
+			},
+			patch: func() []byte {
+				oldData, err := json.Marshal(&workv1.ManifestWork{
+					ObjectMeta: metav1.ObjectMeta{
+						Name: "test",
+					},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				newData, err := json.Marshal(&workv1.ManifestWork{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:      "test",
+						Namespace: "test",
+					},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				data, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, workv1.ManifestWork{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				return data
+			}(),
+			validate: func(t *testing.T, work *workv1.ManifestWork) {
+				if work.Name != "test" {
+					t.Errorf("unexpected work %v", work)
+				}
+				if work.Namespace != "test" {
+					t.Errorf("unexpected work %v", work)
+				}
+			},
+		},
 	}
 
 	for _, c := range cases {