✨ Add client.StrategicMergeFrom

Author: timebertt

pkg/client/client_test.go

@@ -3240,7 +3240,7 @@ var _ = Describe("DelegatingClient", func() {
 })
 
 var _ = Describe("Patch", func() {
-	Describe("CreateMergePatch", func() {
+	Describe("MergeFrom", func() {
 		var cm *corev1.ConfigMap
 
 		BeforeEach(func() {
@@ -3303,6 +3303,98 @@ var _ = Describe("Patch", func() {
 			Expect(data).To(Equal([]byte(fmt.Sprintf(`{"metadata":{"annotations":{"%s":"%s"},"resourceVersion":"%s"}}`, annotationKey, annotationValue, cm.ResourceVersion))))
 		})
 	})
+
+	Describe("StrategicMergeFrom", func() {
+		var dep *appsv1.Deployment
+
+		BeforeEach(func() {
+			dep = &appsv1.Deployment{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace:       metav1.NamespaceDefault,
+					Name:            "dep",
+					ResourceVersion: "10",
+				},
+				Spec: appsv1.DeploymentSpec{
+					Template: corev1.PodTemplateSpec{
+						Spec: corev1.PodSpec{Containers: []corev1.Container{{
+							Name:  "main",
+							Image: "foo:v1",
+						}, {
+							Name:  "sidecar",
+							Image: "bar:v1",
+						}}},
+					},
+				},
+			}
+		})
+
+		It("creates a strategic merge patch with the modifications applied during the mutation", func() {
+			By("creating a strategic merge patch")
+			patch := client.StrategicMergeFrom(dep.DeepCopy())
+
+			By("returning a patch with type StrategicMergePatchType")
+			Expect(patch.Type()).To(Equal(types.StrategicMergePatchType))
+
+			By("updating the main container's image")
+			for i, c := range dep.Spec.Template.Spec.Containers {
+				if c.Name == "main" {
+					c.Image = "foo:v2"
+				}
+				dep.Spec.Template.Spec.Containers[i] = c
+			}
+
+			By("computing the patch data")
+			data, err := patch.Data(dep)
+
+			By("returning no error")
+			Expect(err).NotTo(HaveOccurred())
+
+			By("returning a patch with data only containing the image change")
+			Expect(data).To(Equal([]byte(`{"spec":{"template":{"spec":{"$setElementOrder/containers":[{"name":"main"},` +
+				`{"name":"sidecar"}],"containers":[{"image":"foo:v2","name":"main"}]}}}}`)))
+		})
+
+		It("creates a strategic merge patch with the modifications applied during the mutation, using optimistic locking", func() {
+			By("creating a strategic merge patch")
+			patch := client.StrategicMergeFromWithOptions(dep.DeepCopy(), client.MergeFromWithOptimisticLock{})
+
+			By("returning a patch with type StrategicMergePatchType")
+			Expect(patch.Type()).To(Equal(types.StrategicMergePatchType))
+
+			By("updating the main container's image")
+			for i, c := range dep.Spec.Template.Spec.Containers {
+				if c.Name == "main" {
+					c.Image = "foo:v2"
+				}
+				dep.Spec.Template.Spec.Containers[i] = c
+			}
+
+			By("computing the patch data")
+			data, err := patch.Data(dep)
+
+			By("returning no error")
+			Expect(err).NotTo(HaveOccurred())
+
+			By("returning a patch with data containing the image change and the resourceVersion change")
+			Expect(data).To(Equal([]byte(fmt.Sprintf(`{"metadata":{"resourceVersion":"%s"},`+
+				`"spec":{"template":{"spec":{"$setElementOrder/containers":[{"name":"main"},{"name":"sidecar"}],"containers":[{"image":"foo:v2","name":"main"}]}}}}`,
+				dep.ResourceVersion))))
+		})
+
+		It("fails if the resourceVersion was changed", func() {
+			By("creating a strategic merge patch")
+			patch := client.StrategicMergeFromWithOptions(dep.DeepCopy(), client.MergeFromWithOptimisticLock{})
+
+			By("updating the resourceVersion")
+			dep.SetResourceVersion("42")
+
+			By("computing the patch data")
+			_, err := patch.Data(dep)
+
+			By("returning no error")
+			Expect(err).To(MatchError(ContainSubstring("precondition failed")))
+		})
+	})
 })
 
 var _ = Describe("IgnoreNotFound", func() {

pkg/client/patch.go

@@ -25,6 +25,8 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/json"
+	"k8s.io/apimachinery/pkg/util/mergepatch"
+	"k8s.io/apimachinery/pkg/util/strategicpatch"
 )
 
 var (
@@ -87,13 +89,15 @@ type MergeFromOptions struct {
 }
 
 type mergeFromPatch struct {
-	from runtime.Object
-	opts MergeFromOptions
+	patchType   types.PatchType
+	createPatch func(originalJSON, modifiedJSON []byte, dataStruct interface{}) ([]byte, error)
+	from        runtime.Object
+	opts        MergeFromOptions
 }
 
 // Type implements patch.
 func (s *mergeFromPatch) Type() types.PatchType {
-	return types.MergePatchType
+	return s.patchType
 }
 
 // Data implements Patch.
@@ -108,7 +112,7 @@ func (s *mergeFromPatch) Data(obj runtime.Object) ([]byte, error) {
 		return nil, err
 	}
 
-	data, err := jsonpatch.CreateMergePatch(originalJSON, modifiedJSON)
+	data, err := s.createPatch(originalJSON, modifiedJSON, obj)
 	if err != nil {
 		return nil, err
 	}
@@ -137,9 +141,21 @@ func (s *mergeFromPatch) Data(obj runtime.Object) ([]byte, error) {
 	return data, nil
 }
 
+func createMergePatch(originalJSON, modifiedJSON []byte, _ interface{}) ([]byte, error) {
+	return jsonpatch.CreateMergePatch(originalJSON, modifiedJSON)
+}
+
+func createStrategicMergePatch(originalJSON, modifiedJSON []byte, dataStruct interface{}) ([]byte, error) {
+	preconditions := []mergepatch.PreconditionFunc{
+		mergepatch.RequireMetadataKeyUnchanged("resourceVersion"),
+	}
+
+	return strategicpatch.CreateTwoWayMergePatch(originalJSON, modifiedJSON, dataStruct, preconditions...)
+}
+
 // MergeFrom creates a Patch that patches using the merge-patch strategy with the given object as base.
 func MergeFrom(obj runtime.Object) Patch {
-	return &mergeFromPatch{from: obj}
+	return &mergeFromPatch{patchType: types.MergePatchType, createPatch: createMergePatch, from: obj}
 }
 
 // MergeFromWithOptions creates a Patch that patches using the merge-patch strategy with the given object as base.
@@ -148,7 +164,21 @@ func MergeFromWithOptions(obj runtime.Object, opts ...MergeFromOption) Patch {
 	for _, opt := range opts {
 		opt.ApplyToMergeFrom(options)
 	}
-	return &mergeFromPatch{from: obj, opts: *options}
+	return &mergeFromPatch{patchType: types.MergePatchType, createPatch: createMergePatch, from: obj, opts: *options}
+}
+
+// StrategicMergeFrom creates a Patch that patches using the strategic-merge-patch strategy with the given object as base.
+func StrategicMergeFrom(obj runtime.Object) Patch {
+	return &mergeFromPatch{patchType: types.StrategicMergePatchType, createPatch: createStrategicMergePatch, from: obj}
+}
+
+// StrategicMergeFromWithOptions creates a Patch that patches using the strategic-merge-patch strategy with the given object as base.
+func StrategicMergeFromWithOptions(obj runtime.Object, opts ...MergeFromOption) Patch {
+	options := &MergeFromOptions{}
+	for _, opt := range opts {
+		opt.ApplyToMergeFrom(options)
+	}
+	return &mergeFromPatch{patchType: types.StrategicMergePatchType, createPatch: createStrategicMergePatch, from: obj, opts: *options}
 }
 
 // mergePatch uses a raw merge strategy to patch the object.