optimize PatchResponseFromRaw

pkg/webhook/admission/defaulter_test.go

@@ -2,12 +2,18 @@ package admission
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"net/http"
+	"testing"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 
 	admissionv1 "k8s.io/api/admission/v1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
@@ -66,3 +72,153 @@ func (d *TestDefaulter) Default() {
 		d.Replica = 2
 	}
 }
+
+/*
+*
+BEFORE (without isByteArrayEqual)
+goos: darwin
+goarch: arm64
+pkg: sigs.k8s.io/controller-runtime/pkg/webhook/admission
+BenchmarkHandle
+BenchmarkHandle/benchmark_handle_function_w/o_update
+BenchmarkHandle/benchmark_handle_function_w/o_update-10         	   22690	     50916 ns/op
+BenchmarkHandle/benchmark_handle_function_with_update
+BenchmarkHandle/benchmark_handle_function_with_update-10        	   23100	     51933 ns/op
+
+AFTER (with isByteArrayEqual)
+goos: darwin
+goarch: arm64
+pkg: sigs.k8s.io/controller-runtime/pkg/webhook/admission
+BenchmarkHandle
+BenchmarkHandle/benchmark_handle_function_w/o_update
+BenchmarkHandle/benchmark_handle_function_w/o_update-10         	   43891	     26766 ns/op
+BenchmarkHandle/benchmark_handle_function_with_update
+BenchmarkHandle/benchmark_handle_function_with_update-10        	   23234	     50426 ns/op
+*/
+func BenchmarkHandle(b *testing.B) {
+	pod := createPodForBenchmark()
+
+	byteArray, err := json.Marshal(pod)
+	if err != nil {
+		fmt.Printf("error marshalling pod, %v. \n", err)
+	}
+
+	pa := &podAnnotator{}
+	handler := WithCustomDefaulter(admissionScheme, pod, pa)
+
+	b.Run("benchmark handle function w/o update", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			// handler.Handle invokes PatchResponseFromRaw function, which is the func to be benchmarked.
+			handler.Handle(context.TODO(), Request{
+				AdmissionRequest: admissionv1.AdmissionRequest{
+					Operation: admissionv1.Update,
+					Object: runtime.RawExtension{
+						Raw: byteArray,
+					},
+				},
+			})
+		}
+	})
+
+	psw := &podSchedulerWebhook{}
+	pswHandler := WithCustomDefaulter(admissionScheme, pod, psw)
+
+	b.Run("benchmark handle function with update", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			// handler.Handle invokes PatchResponseFromRaw function, which is the func to be benchmarked.
+			pswHandler.Handle(context.TODO(), Request{
+				AdmissionRequest: admissionv1.AdmissionRequest{
+					Operation: admissionv1.Update,
+					Object: runtime.RawExtension{
+						Raw: byteArray,
+					},
+				},
+			})
+		}
+	})
+}
+
+// podAnnotator does nothing to a pod.
+// it tries to imitate the behavior that pod is unchanged after going through mutating webhook.
+type podAnnotator struct{}
+
+func (a *podAnnotator) Default(ctx context.Context, obj runtime.Object) error {
+	pod, ok := obj.(*corev1.Pod)
+	if !ok {
+		return fmt.Errorf("expected a Pod but got a %T", obj)
+	}
+	if pod.Annotations == nil {
+		pod.Annotations = map[string]string{}
+	}
+	return nil
+}
+
+// podSchedulerWebhook update a pod's scheduler name.
+type podSchedulerWebhook struct{}
+
+func (a *podSchedulerWebhook) Default(ctx context.Context, obj runtime.Object) error {
+	pod, ok := obj.(*corev1.Pod)
+	if !ok {
+		return fmt.Errorf("expected a Pod but got a %T", obj)
+	}
+	pod.Spec.SchedulerName = "new-scheduler"
+	return nil
+}
+
+// Create a dummy pod for benchmarking patch
+func createPodForBenchmark() *corev1.Pod {
+	pod := &corev1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "test-pod-name",
+			Labels: map[string]string{
+				"appname0": "app-name",
+				"appname1": "app-name",
+				"appname2": "app-name",
+				"appname3": "app-name",
+				"appname4": "app-name",
+				"appname5": "app-name",
+				"appname6": "app-name",
+			},
+			Annotations: map[string]string{
+				"annoKey":  "annoValue",
+				"annoKey1": "annoValue",
+				"annoKey2": "annoValue",
+				"annoKey3": "annoValue",
+				"annoKey4": "annoValue",
+				"annoKey5": "annoValue",
+				"annoKey6": "annoValue",
+			},
+		},
+		Spec: corev1.PodSpec{
+			Containers: []corev1.Container{
+				{
+					Name: "main",
+					Resources: corev1.ResourceRequirements{
+						Limits: corev1.ResourceList{
+							corev1.ResourceCPU:              resource.MustParse("4"),
+							corev1.ResourceMemory:           resource.MustParse("8Gi"),
+							corev1.ResourceEphemeralStorage: resource.MustParse("25Gi"),
+						},
+					},
+				},
+				{
+					Name: "sidecar",
+					Env:  []corev1.EnvVar{{Name: "sampleEnv", Value: "true"}},
+					Resources: corev1.ResourceRequirements{
+						Requests: corev1.ResourceList{
+							corev1.ResourceCPU: resource.MustParse("100m"),
+						},
+						Limits: corev1.ResourceList{
+							corev1.ResourceCPU:    resource.MustParse("4"),
+							corev1.ResourceMemory: resource.MustParse("2Gi"),
+						},
+					},
+				},
+			},
+		},
+	}
+	return pod
+}

pkg/webhook/admission/response.go

@@ -86,6 +86,17 @@ func ValidationResponse(allowed bool, message string) Response {
 // The original object should be passed in as raw bytes to avoid the roundtripping problem
 // described in https://github.com/kubernetes-sigs/kubebuilder/issues/510.
 func PatchResponseFromRaw(original, current []byte) Response {
+	if isByteArrayEqual(original, current) {
+		return Response{
+			Patches: []jsonpatch.JsonPatchOperation{},
+			AdmissionResponse: admissionv1.AdmissionResponse{
+				Allowed: true,
+				PatchType: func() *admissionv1.PatchType {
+					return nil
+				}(),
+			},
+		}
+	}
 	patches, err := jsonpatch.CreatePatch(original, current)
 	if err != nil {
 		return Errored(http.StatusInternalServerError, err)
@@ -105,6 +116,19 @@ func PatchResponseFromRaw(original, current []byte) Response {
 	}
 }
 
+// isByteArrayEqual takes 2 byte arrays and returns if they are equal.
+func isByteArrayEqual(a, b []byte) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i, _ := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
 // validationResponseFromStatus returns a response for admitting a request with provided Status object.
 func validationResponseFromStatus(allowed bool, status metav1.Status) Response {
 	resp := Response{

pkg/webhook/admission/response_test.go

@@ -17,8 +17,11 @@ limitations under the License.
 package admission
 
 import (
+	"encoding/json"
 	"errors"
+	"fmt"
 	"net/http"
+	"testing"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -247,3 +250,48 @@ var _ = Describe("Admission Webhook Response Helpers", func() {
 		})
 	})
 })
+
+/*
+*
+BEFORE (without isByteArrayEqual)
+goos: darwin
+goarch: arm64
+pkg: sigs.k8s.io/controller-runtime/pkg/webhook/admission
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual/benchmark_PatchResponseFromRaw_function
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual/benchmark_PatchResponseFromRaw_function-10         	   52774	     22749 ns/op
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual/benchmark_isByteArrayEqual_function
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual/benchmark_isByteArrayEqual_function-10             	 5252599	       230.7 ns/op
+
+AFTER (with isByteArrayEqual)
+goos: darwin
+goarch: arm64
+pkg: sigs.k8s.io/controller-runtime/pkg/webhook/admission
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual/benchmark_PatchResponseFromRaw_function
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual/benchmark_PatchResponseFromRaw_function-10         	 4915736	       244.7 ns/op
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual/benchmark_isByteArrayEqual_function
+BenchmarkPatchResponseFromRawAndIsByteArrayEqual/benchmark_isByteArrayEqual_function-10             	 4981567	       239.0 ns/op
+*/
+func BenchmarkPatchResponseFromRawAndIsByteArrayEqual(b *testing.B) {
+	pod := createPodForBenchmark()
+
+	byteArray, err := json.Marshal(pod)
+	if err != nil {
+		fmt.Println("error marshalling pod")
+	}
+
+	b.Run("benchmark PatchResponseFromRaw function", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			PatchResponseFromRaw(byteArray, byteArray)
+		}
+	})
+
+	b.Run("benchmark isByteArrayEqual function", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			isByteArrayEqual(byteArray, byteArray)
+		}
+	})
+}