From 88a402632ca599302fefe121aa219a5057cb3d96 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Sun, 29 Jan 2023 21:04:44 -0800 Subject: [PATCH 01/42] Annotation limit check --- pkg/controllers/work/apply_controller.go | 32 +++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 4ab75bc6d..ef4910f01 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -49,7 +49,10 @@ import ( ) const ( - workFieldManagerName = "work-api-agent" + workFieldManagerName = "work-api-agent" + TotalAnnotationSizeLimitB int = 256 * (1 << 10) // 256 kB + // The manifest hash of 32 bytes when converted a string becomes 64 characters in length + manifestHashLength int = 64 ) // ApplyWorkReconciler reconciles a Work object @@ -89,6 +92,9 @@ const ( // ManifestUpdatedAction indicates that we updated the manifest. ManifestUpdatedAction applyAction = "ManifestUpdated" + // ManifestAppliedAction indicates that we applied the manifest. + ManifestAppliedAction applyAction = "ManifestApplied" + // ManifestNoChangeAction indicates that we don't need to change the manifest. ManifestNoChangeAction applyAction = "ManifestNoChange" ) @@ -340,6 +346,16 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. Name: manifestObj.GetName(), Namespace: manifestObj.GetNamespace(), } + // Marshaling adds about 100-200 bytes to the object's actual size + marshaledObj, marshalErr := json.Marshal(manifestObj) + if marshalErr != nil { + return nil, ManifestNoChangeAction, marshalErr + } + if len(marshaledObj) > (TotalAnnotationSizeLimitB - len(manifestHashAnnotation) - len(lastAppliedConfigAnnotation) - manifestHashLength) { + klog.V(2).InfoS("Size of manifest object is greater than 262,013 bytes", "Name", manifestObj.GetName(), "size of marshaled object", len(marshaledObj), "kind", manifestObj.GetKind()) + return r.applyObject(ctx, gvr, manifestObj) + } + // compute the hash without taking into consider the last applied annotation if err := setManifestHashAnnotation(manifestObj); err != nil { return nil, ManifestNoChangeAction, err @@ -390,6 +406,20 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. return curObj, ManifestNoChangeAction, nil } +func (r *ApplyWorkReconciler) applyObject(ctx context.Context, gvr schema.GroupVersionResource, + manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { + manifestRef := klog.ObjectRef{ + Name: manifestObj.GetName(), + Namespace: manifestObj.GetNamespace(), + } + manifestObj, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Apply(ctx, manifestObj.GetName(), manifestObj, metav1.ApplyOptions{FieldManager: workFieldManagerName}) + if err != nil { + klog.ErrorS(err, "failed to apply object", "gvr", gvr, "manifest", manifestRef) + return nil, ManifestNoChangeAction, err + } + return manifestObj, ManifestAppliedAction, nil +} + // patchCurrentResource uses three way merge to patch the current resource with the new manifest we get from the work. func (r *ApplyWorkReconciler) patchCurrentResource(ctx context.Context, gvr schema.GroupVersionResource, manifestObj, curObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { From 9ae7b1c224135babd7cbcdd8088c9f0c23c7bca5 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Thu, 2 Feb 2023 16:24:19 -0800 Subject: [PATCH 02/42] unit tests --- pkg/controllers/work/apply_controller_test.go | 24 ++++++++++++++ pkg/utils/test_util.go | 32 +++++++++++++++++++ .../resources/test-large-secret.yaml | 12 +++++++ 3 files changed, 68 insertions(+) create mode 100644 test/integration/manifests/resources/test-large-secret.yaml diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index f91976cd6..c17af0072 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -30,6 +30,7 @@ import ( "github.com/stretchr/testify/assert" "go.uber.org/atomic" appsv1 "k8s.io/api/apps/v1" + corev1 "k8s.io/api/core/v1" v1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" @@ -80,6 +81,7 @@ var ( testManifest = workv1alpha1.Manifest{RawExtension: runtime.RawExtension{ Raw: rawTestDeployment, }} + largeSecret corev1.Secret ) // This interface is needed for testMapper abstract class. @@ -346,6 +348,17 @@ func TestApplyUnstructured(t *testing.T) { specHashFailObj := correctObj.DeepCopy() specHashFailObj.Object["test"] = math.Inf(1) + utils.GetObjectFromManifest("../../../test/integration/manifests/resources/test-large-secret.yaml", &largeSecret) + rawSecret, _ := json.Marshal(largeSecret) + var largeObj unstructured.Unstructured + largeObj.UnmarshalJSON(rawSecret) + + // add check to see if we cannot retrieve object + applyDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) + applyDynamicClient.PrependReactor("apply", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return true, largeObj.DeepCopy(), nil + }) + testCases := map[string]struct { reconciler ApplyWorkReconciler workObj *unstructured.Unstructured @@ -433,6 +446,17 @@ func TestApplyUnstructured(t *testing.T) { resultAction: ManifestUpdatedAction, resultErr: nil, }, + "apply large manifest": { + reconciler: ApplyWorkReconciler{ + spokeDynamicClient: applyDynamicClient, + restMapper: testMapper{}, + recorder: utils.NewFakeRecorder(1), + }, + workObj: &largeObj, + resultSpecHash: "", + resultAction: ManifestAppliedAction, + resultErr: nil, + }, } for testName, testCase := range testCases { diff --git a/pkg/utils/test_util.go b/pkg/utils/test_util.go index f644ed292..1685025ae 100644 --- a/pkg/utils/test_util.go +++ b/pkg/utils/test_util.go @@ -7,6 +7,10 @@ package utils import ( "fmt" + "k8s.io/apimachinery/pkg/runtime/serializer" + "k8s.io/apimachinery/pkg/util/yaml" + "k8s.io/client-go/kubernetes/scheme" + "os" "strings" "github.com/onsi/gomega/format" @@ -18,6 +22,11 @@ import ( "k8s.io/client-go/tools/record" ) +var ( + genericCodecs = serializer.NewCodecFactory(scheme.Scheme) + genericCodec = genericCodecs.UniversalDeserializer() +) + const ( // TestCaseMsg is used in the table driven test TestCaseMsg string = "\nTest case: %s" @@ -37,6 +46,29 @@ func GetEventString(object runtime.Object, eventtype, reason, messageFmt string, object.GetObjectKind().GroupVersionKind().Kind, object.GetObjectKind().GroupVersionKind().GroupVersion()) } +// GetObjectFromRawExtension returns an object decoded from the raw byte array +func GetObjectFromRawExtension(rawByte []byte, obj runtime.Object) { + json, err := yaml.ToJSON(rawByte) + if err != nil { + return + } + err = runtime.DecodeInto(genericCodec, json, obj) + if err != nil { + return + } +} + +// GetObjectFromManifest returns a runtime object decoded from the file +func GetObjectFromManifest(relativeFilePath string, obj runtime.Object) { + // Read files, create manifest + fileRaw, err := os.ReadFile(relativeFilePath) + if err != nil { + return + } + + GetObjectFromRawExtension(fileRaw, obj) +} + // NewResourceList returns a resource list for test purpose. func NewResourceList() v1.ResourceList { return v1.ResourceList{ diff --git a/test/integration/manifests/resources/test-large-secret.yaml b/test/integration/manifests/resources/test-large-secret.yaml new file mode 100644 index 000000000..d6961a1b4 --- /dev/null +++ b/test/integration/manifests/resources/test-large-secret.yaml @@ -0,0 +1,12 @@ +apiVersion: v1 +data: + release: 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 +kind: Secret +metadata: + labels: + name: test-secret + owner: helm + status: deployed + version: "1" + name: sh.helm.release.v1.test +type: helm.sh/release.v1 From ff481059561ba05afd96376ed96a9a1d9a14c670 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Thu, 2 Feb 2023 18:56:44 -0800 Subject: [PATCH 03/42] fix UT --- pkg/controllers/work/apply_controller_test.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index c17af0072..dd51ce86a 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -349,13 +349,18 @@ func TestApplyUnstructured(t *testing.T) { specHashFailObj.Object["test"] = math.Inf(1) utils.GetObjectFromManifest("../../../test/integration/manifests/resources/test-large-secret.yaml", &largeSecret) + largeSecret.ObjectMeta = metav1.ObjectMeta{ + OwnerReferences: []metav1.OwnerReference{ + ownerRef, + }, + } rawSecret, _ := json.Marshal(largeSecret) var largeObj unstructured.Unstructured largeObj.UnmarshalJSON(rawSecret) // add check to see if we cannot retrieve object applyDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) - applyDynamicClient.PrependReactor("apply", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + applyDynamicClient.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, largeObj.DeepCopy(), nil }) From 8b10d12fb3a0f80f26c2b1e78218ada6139fd4f0 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Fri, 3 Feb 2023 10:48:38 -0800 Subject: [PATCH 04/42] fix lint --- pkg/controllers/work/apply_controller_test.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index dd51ce86a..29108e3fc 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -30,7 +30,6 @@ import ( "github.com/stretchr/testify/assert" "go.uber.org/atomic" appsv1 "k8s.io/api/apps/v1" - corev1 "k8s.io/api/core/v1" v1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" @@ -81,7 +80,7 @@ var ( testManifest = workv1alpha1.Manifest{RawExtension: runtime.RawExtension{ Raw: rawTestDeployment, }} - largeSecret corev1.Secret + largeSecret v1.Secret ) // This interface is needed for testMapper abstract class. @@ -356,7 +355,7 @@ func TestApplyUnstructured(t *testing.T) { } rawSecret, _ := json.Marshal(largeSecret) var largeObj unstructured.Unstructured - largeObj.UnmarshalJSON(rawSecret) + _ = largeObj.UnmarshalJSON(rawSecret) // add check to see if we cannot retrieve object applyDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) From 16de59e1b704658af09486a40c114af0639e1384 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Sat, 4 Feb 2023 19:26:04 -0800 Subject: [PATCH 05/42] Address comments --- pkg/controllers/work/apply_controller.go | 50 +++++++++++-------- pkg/controllers/work/apply_controller_test.go | 8 ++- pkg/controllers/work/patch_util.go | 24 +++++---- 3 files changed, 50 insertions(+), 32 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index ef4910f01..b78221309 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -346,15 +346,6 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. Name: manifestObj.GetName(), Namespace: manifestObj.GetNamespace(), } - // Marshaling adds about 100-200 bytes to the object's actual size - marshaledObj, marshalErr := json.Marshal(manifestObj) - if marshalErr != nil { - return nil, ManifestNoChangeAction, marshalErr - } - if len(marshaledObj) > (TotalAnnotationSizeLimitB - len(manifestHashAnnotation) - len(lastAppliedConfigAnnotation) - manifestHashLength) { - klog.V(2).InfoS("Size of manifest object is greater than 262,013 bytes", "Name", manifestObj.GetName(), "size of marshaled object", len(marshaledObj), "kind", manifestObj.GetKind()) - return r.applyObject(ctx, gvr, manifestObj) - } // compute the hash without taking into consider the last applied annotation if err := setManifestHashAnnotation(manifestObj); err != nil { @@ -363,10 +354,21 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // extract the common create procedure to reuse var createFunc = func() (*unstructured.Unstructured, applyAction, error) { - // record the raw manifest with the hash annotation in the manifest - if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { + lastAppliedConfig, err := getModifiedConfigurationAnnotation(manifestObj) + if err != nil { return nil, ManifestNoChangeAction, err } + // length of lastAppliedConfiguration accounts for the length of manifest hash and the length of the manifest hash annotation key + // since we added the annotation to the object. + if len(lastAppliedConfig) > (TotalAnnotationSizeLimitB - len(lastAppliedConfigAnnotation)) { + // Add log stating the object doesn't have the last applied configuration. + return r.applyObject(ctx, gvr, manifestObj) + } else { + // record the raw manifest with the hash annotation in the manifest + if err := setModifiedConfigurationAnnotation(manifestObj, lastAppliedConfig); err != nil { + return nil, ManifestNoChangeAction, err + } + } actual, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Create( ctx, manifestObj, metav1.CreateOptions{FieldManager: workFieldManagerName}) if err == nil { @@ -400,7 +402,23 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // We only try to update the object if its spec hash value has changed. if manifestObj.GetAnnotations()[manifestHashAnnotation] != curObj.GetAnnotations()[manifestHashAnnotation] { - return r.patchCurrentResource(ctx, gvr, manifestObj, curObj) + // we need to merge the owner reference between the current and the manifest since we support one manifest + // belong to multiple work so it contains the union of all the appliedWork + manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) + lastAppliedConfig, err := getModifiedConfigurationAnnotation(manifestObj) + if err == nil { + return nil, ManifestNoChangeAction, err + } + if len(lastAppliedConfig) > (TotalAnnotationSizeLimitB - len(lastAppliedConfigAnnotation)) { + // Add log stating the object doesn't have the last applied configuration. + return r.applyObject(ctx, gvr, manifestObj) + } else { + // record the raw manifest with the hash annotation in the manifest + if err := setModifiedConfigurationAnnotation(manifestObj, lastAppliedConfig); err != nil { + return nil, ManifestNoChangeAction, err + } + return r.patchCurrentResource(ctx, gvr, manifestObj, curObj) + } } return curObj, ManifestNoChangeAction, nil @@ -430,14 +448,6 @@ func (r *ApplyWorkReconciler) patchCurrentResource(ctx context.Context, gvr sche klog.V(2).InfoS("manifest is modified", "gvr", gvr, "manifest", manifestRef, "new hash", manifestObj.GetAnnotations()[manifestHashAnnotation], "existing hash", curObj.GetAnnotations()[manifestHashAnnotation]) - - // we need to merge the owner reference between the current and the manifest since we support one manifest - // belong to multiple work so it contains the union of all the appliedWork - manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) - // record the raw manifest with the hash annotation in the manifest - if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { - return nil, ManifestNoChangeAction, err - } // create the three-way merge patch between the current, original and manifest similar to how kubectl apply does patch, err := threeWayMergePatch(curObj, manifestObj) if err != nil { diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index 29108e3fc..edb071f30 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -357,6 +357,9 @@ func TestApplyUnstructured(t *testing.T) { var largeObj unstructured.Unstructured _ = largeObj.UnmarshalJSON(rawSecret) + largeObjSpecHash, _ := computeManifestHash(&largeObj) + largeObj.SetAnnotations(map[string]string{manifestHashAnnotation: largeObjSpecHash}) + // add check to see if we cannot retrieve object applyDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) applyDynamicClient.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { @@ -457,7 +460,7 @@ func TestApplyUnstructured(t *testing.T) { recorder: utils.NewFakeRecorder(1), }, workObj: &largeObj, - resultSpecHash: "", + resultSpecHash: largeObjSpecHash, resultAction: ManifestAppliedAction, resultErr: nil, }, @@ -925,7 +928,8 @@ func createObjAndDynamicClient(rawManifest []byte) (*unstructured.Unstructured, _ = uObj.UnmarshalJSON(rawManifest) validSpecHash, _ := computeManifestHash(&uObj) uObj.SetAnnotations(map[string]string{manifestHashAnnotation: validSpecHash}) - _ = setModifiedConfigurationAnnotation(&uObj) + lastAppliedConfig, _ := getModifiedConfigurationAnnotation(&uObj) + _ = setModifiedConfigurationAnnotation(&uObj, lastAppliedConfig) dynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) dynamicClient.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, uObj.DeepCopy(), nil diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index 6964d731a..5b1951014 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -76,11 +76,22 @@ func threeWayMergePatch(currentObj, manifestObj client.Object) (client.Patch, er return client.RawPatch(patchType, patchData), nil } +func getModifiedConfigurationAnnotation(obj runtime.Object) (string, error) { + //TODO: see if we should use something like json.ConfigCompatibleWithStandardLibrary.Marshal to make sure that + // the produced json format is more three way merge friendly + + // Marshaling adds about 100-200 bytes to the object's actual size + lastAppliedConfiguration, err := json.Marshal(obj) + if err != nil { + return "", err + } + return string(lastAppliedConfiguration), nil +} + // setModifiedConfigurationAnnotation serializes the object into byte stream. // If `updateAnnotation` is true, it embeds the result as an annotation in the // modified configuration. -func setModifiedConfigurationAnnotation(obj runtime.Object) error { - var modified []byte +func setModifiedConfigurationAnnotation(obj runtime.Object, lastAppliedConfig string) error { annotations, err := metadataAccessor.Annotations(obj) if err != nil { return fmt.Errorf("cannot access metadata.annotations: %w", err) @@ -97,15 +108,8 @@ func setModifiedConfigurationAnnotation(obj runtime.Object) error { } else { _ = metadataAccessor.SetAnnotations(obj, annotations) } - - //TODO: see if we should use something like json.ConfigCompatibleWithStandardLibrary.Marshal to make sure that - // the produced json format is more three way merge friendly - modified, err = json.Marshal(obj) - if err != nil { - return err - } // set the last applied annotation back - annotations[lastAppliedConfigAnnotation] = string(modified) + annotations[lastAppliedConfigAnnotation] = lastAppliedConfig return metadataAccessor.SetAnnotations(obj, annotations) } From 377e696ebe14e348f76ba56ba267cdaf34cb7b91 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Sat, 4 Feb 2023 19:52:42 -0800 Subject: [PATCH 06/42] fix UT, add comments --- pkg/controllers/work/apply_controller.go | 16 ++++++++++------ pkg/controllers/work/apply_controller_test.go | 2 +- pkg/controllers/work/patch_util.go | 7 ++++--- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index b78221309..44eaa223c 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -339,7 +339,7 @@ func (r *ApplyWorkReconciler) decodeManifest(manifest workv1alpha1.Manifest) (sc return mapping.Resource, unstructuredObj, nil } -// Determines if an unstructured manifest object can & should be applied. If so, it applies (creates) the resource on the cluster. +// applyUnstructured determines if an unstructured manifest object can & should be applied. If so, it applies/creates the resource on the cluster based on it's size. func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { manifestRef := klog.ObjectRef{ @@ -354,14 +354,15 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // extract the common create procedure to reuse var createFunc = func() (*unstructured.Unstructured, applyAction, error) { - lastAppliedConfig, err := getModifiedConfigurationAnnotation(manifestObj) + lastAppliedConfig, err := computeModifiedConfigurationAnnotation(manifestObj) if err != nil { return nil, ManifestNoChangeAction, err } // length of lastAppliedConfiguration accounts for the length of manifest hash and the length of the manifest hash annotation key // since we added the annotation to the object. if len(lastAppliedConfig) > (TotalAnnotationSizeLimitB - len(lastAppliedConfigAnnotation)) { - // Add log stating the object doesn't have the last applied configuration. + klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence it doesn't have the last applied configuration annotation", + "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", len(lastAppliedConfig)) return r.applyObject(ctx, gvr, manifestObj) } else { // record the raw manifest with the hash annotation in the manifest @@ -405,12 +406,13 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // we need to merge the owner reference between the current and the manifest since we support one manifest // belong to multiple work so it contains the union of all the appliedWork manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) - lastAppliedConfig, err := getModifiedConfigurationAnnotation(manifestObj) - if err == nil { + lastAppliedConfig, err := computeModifiedConfigurationAnnotation(manifestObj) + if err != nil { return nil, ManifestNoChangeAction, err } if len(lastAppliedConfig) > (TotalAnnotationSizeLimitB - len(lastAppliedConfigAnnotation)) { - // Add log stating the object doesn't have the last applied configuration. + klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence it doesn't have the last applied configuration annotation", + "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", len(lastAppliedConfig)) return r.applyObject(ctx, gvr, manifestObj) } else { // record the raw manifest with the hash annotation in the manifest @@ -424,6 +426,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. return curObj, ManifestNoChangeAction, nil } +// applyObject uses dynamic client's apply to apply the manifest. func (r *ApplyWorkReconciler) applyObject(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { manifestRef := klog.ObjectRef{ @@ -435,6 +438,7 @@ func (r *ApplyWorkReconciler) applyObject(ctx context.Context, gvr schema.GroupV klog.ErrorS(err, "failed to apply object", "gvr", gvr, "manifest", manifestRef) return nil, ManifestNoChangeAction, err } + klog.V(2).InfoS("manifest apply succeeded", "gvr", gvr, "manifest", manifestRef) return manifestObj, ManifestAppliedAction, nil } diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index edb071f30..7e009ea14 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -928,7 +928,7 @@ func createObjAndDynamicClient(rawManifest []byte) (*unstructured.Unstructured, _ = uObj.UnmarshalJSON(rawManifest) validSpecHash, _ := computeManifestHash(&uObj) uObj.SetAnnotations(map[string]string{manifestHashAnnotation: validSpecHash}) - lastAppliedConfig, _ := getModifiedConfigurationAnnotation(&uObj) + lastAppliedConfig, _ := computeModifiedConfigurationAnnotation(&uObj) _ = setModifiedConfigurationAnnotation(&uObj, lastAppliedConfig) dynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) dynamicClient.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index 5b1951014..4084df488 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -76,7 +76,8 @@ func threeWayMergePatch(currentObj, manifestObj client.Object) (client.Patch, er return client.RawPatch(patchType, patchData), nil } -func getModifiedConfigurationAnnotation(obj runtime.Object) (string, error) { +// computeModifiedConfigurationAnnotation is used to serialize the object into a byte stream. +func computeModifiedConfigurationAnnotation(obj runtime.Object) (string, error) { //TODO: see if we should use something like json.ConfigCompatibleWithStandardLibrary.Marshal to make sure that // the produced json format is more three way merge friendly @@ -88,8 +89,8 @@ func getModifiedConfigurationAnnotation(obj runtime.Object) (string, error) { return string(lastAppliedConfiguration), nil } -// setModifiedConfigurationAnnotation serializes the object into byte stream. -// If `updateAnnotation` is true, it embeds the result as an annotation in the +// setModifiedConfigurationAnnotation is used to set the serialized object as a byte stream as the last applied +//configuration annotation. If `updateAnnotation` is true, it embeds the result as an annotation in the // modified configuration. func setModifiedConfigurationAnnotation(obj runtime.Object, lastAppliedConfig string) error { annotations, err := metadataAccessor.Annotations(obj) From f88d400b6d4e3eb9ad5e0a0b13dbd16faa6bfe35 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Sat, 4 Feb 2023 20:12:57 -0800 Subject: [PATCH 07/42] lint fix --- pkg/controllers/work/apply_controller.go | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 44eaa223c..ed8f2e8c2 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -51,8 +51,6 @@ import ( const ( workFieldManagerName = "work-api-agent" TotalAnnotationSizeLimitB int = 256 * (1 << 10) // 256 kB - // The manifest hash of 32 bytes when converted a string becomes 64 characters in length - manifestHashLength int = 64 ) // ApplyWorkReconciler reconciles a Work object @@ -364,11 +362,10 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence it doesn't have the last applied configuration annotation", "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", len(lastAppliedConfig)) return r.applyObject(ctx, gvr, manifestObj) - } else { - // record the raw manifest with the hash annotation in the manifest - if err := setModifiedConfigurationAnnotation(manifestObj, lastAppliedConfig); err != nil { - return nil, ManifestNoChangeAction, err - } + } + // record the raw manifest with the hash annotation in the manifest + if err := setModifiedConfigurationAnnotation(manifestObj, lastAppliedConfig); err != nil { + return nil, ManifestNoChangeAction, err } actual, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Create( ctx, manifestObj, metav1.CreateOptions{FieldManager: workFieldManagerName}) @@ -414,13 +411,12 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence it doesn't have the last applied configuration annotation", "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", len(lastAppliedConfig)) return r.applyObject(ctx, gvr, manifestObj) - } else { - // record the raw manifest with the hash annotation in the manifest - if err := setModifiedConfigurationAnnotation(manifestObj, lastAppliedConfig); err != nil { - return nil, ManifestNoChangeAction, err - } - return r.patchCurrentResource(ctx, gvr, manifestObj, curObj) } + // record the raw manifest with the hash annotation in the manifest + if err := setModifiedConfigurationAnnotation(manifestObj, lastAppliedConfig); err != nil { + return nil, ManifestNoChangeAction, err + } + return r.patchCurrentResource(ctx, gvr, manifestObj, curObj) } return curObj, ManifestNoChangeAction, nil From 332e78a239c168ca103ced642504a834e1251de8 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Sat, 4 Feb 2023 20:18:15 -0800 Subject: [PATCH 08/42] make reviewable --- pkg/controllers/work/patch_util.go | 2 +- pkg/utils/test_util.go | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index 4084df488..965475f5d 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -90,7 +90,7 @@ func computeModifiedConfigurationAnnotation(obj runtime.Object) (string, error) } // setModifiedConfigurationAnnotation is used to set the serialized object as a byte stream as the last applied -//configuration annotation. If `updateAnnotation` is true, it embeds the result as an annotation in the +// configuration annotation. If `updateAnnotation` is true, it embeds the result as an annotation in the // modified configuration. func setModifiedConfigurationAnnotation(obj runtime.Object, lastAppliedConfig string) error { annotations, err := metadataAccessor.Annotations(obj) diff --git a/pkg/utils/test_util.go b/pkg/utils/test_util.go index 1685025ae..dfa32d395 100644 --- a/pkg/utils/test_util.go +++ b/pkg/utils/test_util.go @@ -7,11 +7,12 @@ package utils import ( "fmt" + "os" + "strings" + "k8s.io/apimachinery/pkg/runtime/serializer" "k8s.io/apimachinery/pkg/util/yaml" "k8s.io/client-go/kubernetes/scheme" - "os" - "strings" "github.com/onsi/gomega/format" v1 "k8s.io/api/core/v1" From 2d90e425e8aaf900f0111f87420afaa9f6595a09 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Sun, 5 Feb 2023 16:34:50 -0800 Subject: [PATCH 09/42] add UT for update path --- pkg/controllers/work/apply_controller_test.go | 42 ++++++++++++++++--- 1 file changed, 37 insertions(+), 5 deletions(-) diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index 7e009ea14..d65e48481 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -356,15 +356,36 @@ func TestApplyUnstructured(t *testing.T) { rawSecret, _ := json.Marshal(largeSecret) var largeObj unstructured.Unstructured _ = largeObj.UnmarshalJSON(rawSecret) + updatedLargeObj := largeObj.DeepCopy() largeObjSpecHash, _ := computeManifestHash(&largeObj) largeObj.SetAnnotations(map[string]string{manifestHashAnnotation: largeObjSpecHash}) - // add check to see if we cannot retrieve object - applyDynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) - applyDynamicClient.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + applyDynamicClientNotFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) + applyDynamicClientNotFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return false, + nil, + &apierrors.StatusError{ + ErrStatus: metav1.Status{ + Status: metav1.StatusFailure, + Reason: metav1.StatusReasonNotFound, + }} + }) + applyDynamicClientNotFound.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return true, largeObj.DeepCopy(), nil + }) + + updatedLargeObj.SetLabels(map[string]string{"test-label-key": "test-label"}) + updatedLargeObjSpecHash, _ := computeManifestHash(updatedLargeObj) + updatedLargeObj.SetAnnotations(map[string]string{manifestHashAnnotation: updatedLargeObjSpecHash}) + + applyDynamicClientFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) + applyDynamicClientFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, largeObj.DeepCopy(), nil }) + applyDynamicClientFound.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return true, updatedLargeObj.DeepCopy(), nil + }) testCases := map[string]struct { reconciler ApplyWorkReconciler @@ -453,9 +474,9 @@ func TestApplyUnstructured(t *testing.T) { resultAction: ManifestUpdatedAction, resultErr: nil, }, - "apply large manifest": { + "test apply succeeds for large manifest when object does not exist": { reconciler: ApplyWorkReconciler{ - spokeDynamicClient: applyDynamicClient, + spokeDynamicClient: applyDynamicClientNotFound, restMapper: testMapper{}, recorder: utils.NewFakeRecorder(1), }, @@ -464,6 +485,17 @@ func TestApplyUnstructured(t *testing.T) { resultAction: ManifestAppliedAction, resultErr: nil, }, + "test apply succeeds on update for large manifest when object exists": { + reconciler: ApplyWorkReconciler{ + spokeDynamicClient: applyDynamicClientFound, + restMapper: testMapper{}, + recorder: utils.NewFakeRecorder(1), + }, + workObj: updatedLargeObj, + resultSpecHash: updatedLargeObjSpecHash, + resultAction: ManifestAppliedAction, + resultErr: nil, + }, } for testName, testCase := range testCases { From 9fcb66647b2ad75fd2d2d382d99aa22f14ab5ecd Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Sun, 5 Feb 2023 16:38:11 -0800 Subject: [PATCH 10/42] fix log --- pkg/controllers/work/apply_controller.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index ed8f2e8c2..99626204c 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -359,7 +359,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // length of lastAppliedConfiguration accounts for the length of manifest hash and the length of the manifest hash annotation key // since we added the annotation to the object. if len(lastAppliedConfig) > (TotalAnnotationSizeLimitB - len(lastAppliedConfigAnnotation)) { - klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence it doesn't have the last applied configuration annotation", + klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence we don't add the last applied configuration annotation to do the three way merge", "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", len(lastAppliedConfig)) return r.applyObject(ctx, gvr, manifestObj) } @@ -408,7 +408,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. return nil, ManifestNoChangeAction, err } if len(lastAppliedConfig) > (TotalAnnotationSizeLimitB - len(lastAppliedConfigAnnotation)) { - klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence it doesn't have the last applied configuration annotation", + klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence we don't add the last applied configuration annotation to do the three way merge", "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", len(lastAppliedConfig)) return r.applyObject(ctx, gvr, manifestObj) } From c245a3600b5cee42d96c8662874d10ebd1335240 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 7 Feb 2023 16:40:26 -0800 Subject: [PATCH 11/42] Remove dup util methods in integration pkg --- test/integration/cluster_placement_test.go | 22 +++++------ .../manifests/placement/select-namespace.yaml | 4 +- test/integration/utils_test.go | 38 +++++-------------- 3 files changed, 21 insertions(+), 43 deletions(-) diff --git a/test/integration/cluster_placement_test.go b/test/integration/cluster_placement_test.go index ef490a445..52a76573a 100644 --- a/test/integration/cluster_placement_test.go +++ b/test/integration/cluster_placement_test.go @@ -490,10 +490,10 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster A", i)) var uObj unstructured.Unstructured - GetObjectFromRawExtension(manifest.Raw, &uObj) + utils.GetObjectFromRawExtension(manifest.Raw, &uObj) if uObj.GroupVersionKind().Kind == "Role" && uObj.GroupVersionKind().Group == rbacv1.GroupName { var selectedRole rbacv1.Role - GetObjectFromRawExtension(manifest.Raw, &selectedRole) + utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(1)) if reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) { findRole = true @@ -523,10 +523,10 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster A", i)) var uObj unstructured.Unstructured - GetObjectFromRawExtension(manifest.Raw, &uObj) + utils.GetObjectFromRawExtension(manifest.Raw, &uObj) if uObj.GroupVersionKind().Kind == "Role" && uObj.GroupVersionKind().Group == rbacv1.GroupName { var selectedRole rbacv1.Role - GetObjectFromRawExtension(manifest.Raw, &selectedRole) + utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(2)) if reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) && reflect.DeepEqual(selectedRole.Rules[1], utils.WorkRule) { @@ -667,10 +667,10 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster A", i)) var uObj unstructured.Unstructured - GetObjectFromRawExtension(manifest.Raw, &uObj) + utils.GetObjectFromRawExtension(manifest.Raw, &uObj) if uObj.GroupVersionKind().Kind == ClusterRoleKind && uObj.GroupVersionKind().Group == rbacv1.GroupName { var selectedRole rbacv1.ClusterRole - GetObjectFromRawExtension(manifest.Raw, &selectedRole) + utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(1)) if reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) { findClusterRole = true @@ -697,10 +697,10 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster A", i)) var uObj unstructured.Unstructured - GetObjectFromRawExtension(manifest.Raw, &uObj) + utils.GetObjectFromRawExtension(manifest.Raw, &uObj) if uObj.GroupVersionKind().Kind == ClusterRoleKind && uObj.GroupVersionKind().Group == rbacv1.GroupName { var selectedRole rbacv1.ClusterRole - GetObjectFromRawExtension(manifest.Raw, &selectedRole) + utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(2)) if reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) && reflect.DeepEqual(selectedRole.Rules[1], utils.WorkRule) { @@ -1234,7 +1234,7 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { Expect(len(clusterWork.Spec.Workload.Manifests)).Should(BeIdenticalTo(1)) manifest := clusterWork.Spec.Workload.Manifests[0] var selectedRole rbacv1.ClusterRole - GetObjectFromRawExtension(manifest.Raw, &selectedRole) + utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(2)) Expect(reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) && reflect.DeepEqual(selectedRole.Rules[1], utils.WorkRule)).Should(BeTrue()) @@ -1247,7 +1247,7 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { }, &clusterWork)).Should(Succeed()) Expect(len(clusterWork.Spec.Workload.Manifests)).Should(BeIdenticalTo(1)) manifest = clusterWork.Spec.Workload.Manifests[0] - GetObjectFromRawExtension(manifest.Raw, &selectedRole) + utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(2)) Expect(reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) && reflect.DeepEqual(selectedRole.Rules[1], utils.WorkRule)).Should(BeTrue()) @@ -1373,7 +1373,7 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { }, &clusterWork)).Should(Succeed()) Expect(len(clusterWork.Spec.Workload.Manifests)).Should(Equal(1)) var uObj unstructured.Unstructured - GetObjectFromRawExtension(clusterWork.Spec.Workload.Manifests[0].Raw, &uObj) + utils.GetObjectFromRawExtension(clusterWork.Spec.Workload.Manifests[0].Raw, &uObj) Expect(uObj.GroupVersionKind().Kind).Should(Equal("MutatingWebhookConfiguration")) By("Delete the webhook resources") diff --git a/test/integration/manifests/placement/select-namespace.yaml b/test/integration/manifests/placement/select-namespace.yaml index 74a836431..f976db76c 100644 --- a/test/integration/manifests/placement/select-namespace.yaml +++ b/test/integration/manifests/placement/select-namespace.yaml @@ -7,6 +7,4 @@ spec: - group: "" version: v1 kind: Namespace - labelSelector: - matchLabels: - fleet.azure.com/name: test \ No newline at end of file + name: test-redis \ No newline at end of file diff --git a/test/integration/utils_test.go b/test/integration/utils_test.go index 3dd563582..9809e1781 100644 --- a/test/integration/utils_test.go +++ b/test/integration/utils_test.go @@ -8,7 +8,6 @@ package integration import ( "context" "fmt" - "os" "time" . "github.com/onsi/ginkgo/v2" @@ -24,7 +23,6 @@ import ( "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/yaml" "k8s.io/client-go/rest" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" @@ -59,24 +57,6 @@ var ( testPdb policyv1.PodDisruptionBudget ) -// GetObjectFromRawExtension returns an object decoded from the raw byte array -func GetObjectFromRawExtension(rawByte []byte, obj runtime.Object) { - json, err := yaml.ToJSON(rawByte) - Expect(err).ToNot(HaveOccurred()) - - err = runtime.DecodeInto(genericCodec, json, obj) - Expect(err).ToNot(HaveOccurred()) -} - -// GetObjectFromManifest returns a runtime object decoded from the file -func GetObjectFromManifest(relativeFilePath string, obj runtime.Object) { - // Read files, create manifest - fileRaw, err := os.ReadFile(relativeFilePath) - Expect(err).ToNot(HaveOccurred()) - - GetObjectFromRawExtension(fileRaw, obj) -} - // applyTestManifests creates the test manifests in the hub cluster. // Here is the list, please do NOT change this list unless you know what you are doing. // ClusterScoped resource: @@ -85,36 +65,36 @@ func GetObjectFromManifest(relativeFilePath string, obj runtime.Object) { // Cloneset CR, Pdb, Configmap, Secret, Service. func applyTestManifests() { By("Create testCloneset CRD") - GetObjectFromManifest("manifests/resources/test_clonesets_crd.yaml", &testClonesetCRD) + utils.GetObjectFromManifest("manifests/resources/test_clonesets_crd.yaml", &testClonesetCRD) Expect(k8sClient.Create(ctx, &testClonesetCRD)).Should(Succeed()) // TODO: replace the rest objects with programmatic definition By("Create testClusterRole resource") - GetObjectFromManifest("manifests/resources/test_clusterrole.yaml", &testClusterRole) + utils.GetObjectFromManifest("manifests/resources/test_clusterrole.yaml", &testClusterRole) Expect(k8sClient.Create(ctx, &testClusterRole)).Should(Succeed()) By("Create namespace") - GetObjectFromManifest("manifests/resources/test_namespace.yaml", &testNameSpace) + utils.GetObjectFromManifest("manifests/resources/test_namespace.yaml", &testNameSpace) Expect(k8sClient.Create(ctx, &testNameSpace)).Should(Succeed()) By("Create PodDisruptionBudget") - GetObjectFromManifest("manifests/resources/test_pdb.yaml", &testPdb) + utils.GetObjectFromManifest("manifests/resources/test_pdb.yaml", &testPdb) Expect(k8sClient.Create(ctx, &testPdb)).Should(Succeed()) By("Create the testConfigMap resources") - GetObjectFromManifest("manifests/resources/test-configmap.yaml", &testConfigMap) + utils.GetObjectFromManifest("manifests/resources/test-configmap.yaml", &testConfigMap) Expect(k8sClient.Create(ctx, &testConfigMap)).Should(Succeed()) By("Create testSecret resource") - GetObjectFromManifest("manifests/resources/test-secret.yaml", &testSecret) + utils.GetObjectFromManifest("manifests/resources/test-secret.yaml", &testSecret) Expect(k8sClient.Create(ctx, &testSecret)).Should(Succeed()) By("Create testService resource") - GetObjectFromManifest("manifests/resources/test-service.yaml", &testService) + utils.GetObjectFromManifest("manifests/resources/test-service.yaml", &testService) Expect(k8sClient.Create(ctx, &testService)).Should(Succeed()) By("Create testCloneset resource") - GetObjectFromManifest("manifests/resources/test-cloneset.yaml", &testCloneset) + utils.GetObjectFromManifest("manifests/resources/test-cloneset.yaml", &testCloneset) Expect(k8sClient.Create(ctx, &testCloneset)).Should(Succeed()) } @@ -272,7 +252,7 @@ func verifyPartialWorkObjects(crp *fleetv1alpha1.ClusterResourcePlacement, expec for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster %s", i, cluster.Name)) var uObj unstructured.Unstructured - GetObjectFromRawExtension(manifest.Raw, &uObj) + utils.GetObjectFromRawExtension(manifest.Raw, &uObj) kind := uObj.GroupVersionKind().Kind if preciseMatch { Expect(kind).Should(SatisfyAny(expectedKindMatchers...)) From fde8553a5512141395395f0c99dd46ed7d04b3ea Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 7 Feb 2023 16:42:30 -0800 Subject: [PATCH 12/42] revert test changes --- test/integration/manifests/placement/select-namespace.yaml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/integration/manifests/placement/select-namespace.yaml b/test/integration/manifests/placement/select-namespace.yaml index f976db76c..6f031b74a 100644 --- a/test/integration/manifests/placement/select-namespace.yaml +++ b/test/integration/manifests/placement/select-namespace.yaml @@ -7,4 +7,6 @@ spec: - group: "" version: v1 kind: Namespace - name: test-redis \ No newline at end of file + labelSelector: + matchLabels: + fleet.azure.com/name: test From 3c8794959d00393c5ac25dab40ee435bea0f4176 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 14 Feb 2023 17:11:03 -0800 Subject: [PATCH 13/42] fix logic --- pkg/controllers/work/apply_controller.go | 46 +++++++++++-------- pkg/controllers/work/apply_controller_test.go | 3 +- pkg/controllers/work/patch_util.go | 31 ++++++------- 3 files changed, 40 insertions(+), 40 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 99626204c..30043554f 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -352,21 +352,16 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // extract the common create procedure to reuse var createFunc = func() (*unstructured.Unstructured, applyAction, error) { - lastAppliedConfig, err := computeModifiedConfigurationAnnotation(manifestObj) - if err != nil { + // record the raw manifest with the hash annotation in the manifest + if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { return nil, ManifestNoChangeAction, err } - // length of lastAppliedConfiguration accounts for the length of manifest hash and the length of the manifest hash annotation key - // since we added the annotation to the object. - if len(lastAppliedConfig) > (TotalAnnotationSizeLimitB - len(lastAppliedConfigAnnotation)) { - klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence we don't add the last applied configuration annotation to do the three way merge", - "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", len(lastAppliedConfig)) + annotations := manifestObj.GetAnnotations() + if !isAnnotationsSizeValid(gvr, manifestRef, annotations) { + delete(annotations, lastAppliedConfigAnnotation) + manifestObj.SetAnnotations(annotations) return r.applyObject(ctx, gvr, manifestObj) } - // record the raw manifest with the hash annotation in the manifest - if err := setModifiedConfigurationAnnotation(manifestObj, lastAppliedConfig); err != nil { - return nil, ManifestNoChangeAction, err - } actual, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Create( ctx, manifestObj, metav1.CreateOptions{FieldManager: workFieldManagerName}) if err == nil { @@ -403,25 +398,36 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // we need to merge the owner reference between the current and the manifest since we support one manifest // belong to multiple work so it contains the union of all the appliedWork manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) - lastAppliedConfig, err := computeModifiedConfigurationAnnotation(manifestObj) - if err != nil { + // record the raw manifest with the hash annotation in the manifest + if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { return nil, ManifestNoChangeAction, err } - if len(lastAppliedConfig) > (TotalAnnotationSizeLimitB - len(lastAppliedConfigAnnotation)) { - klog.V(2).InfoS("Size of last applied configuration is greater than 262,102 bytes hence we don't add the last applied configuration annotation to do the three way merge", - "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", len(lastAppliedConfig)) + annotations := manifestObj.GetAnnotations() + if !isAnnotationsSizeValid(gvr, manifestRef, annotations) { + delete(annotations, lastAppliedConfigAnnotation) + manifestObj.SetAnnotations(annotations) return r.applyObject(ctx, gvr, manifestObj) } - // record the raw manifest with the hash annotation in the manifest - if err := setModifiedConfigurationAnnotation(manifestObj, lastAppliedConfig); err != nil { - return nil, ManifestNoChangeAction, err - } return r.patchCurrentResource(ctx, gvr, manifestObj, curObj) } return curObj, ManifestNoChangeAction, nil } +// isAnnotationSizeValid returns true if the total size of the annotations for a manifest is less than 256KB. +func isAnnotationsSizeValid(gvr schema.GroupVersionResource, manifestRef klog.ObjectRef, annotations map[string]string) bool { + var totalSize int64 + for k, v := range annotations { + totalSize += (int64)(len(k)) + (int64)(len(v)) + } + if totalSize > (int64)(TotalAnnotationSizeLimitB) { + klog.V(2).InfoS("Size of annotations is greater than 262,144 bytes hence we don't add the last applied configuration annotation to do the three way merge", + "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", totalSize) + return false + } + return true +} + // applyObject uses dynamic client's apply to apply the manifest. func (r *ApplyWorkReconciler) applyObject(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index d65e48481..9adf741af 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -960,8 +960,7 @@ func createObjAndDynamicClient(rawManifest []byte) (*unstructured.Unstructured, _ = uObj.UnmarshalJSON(rawManifest) validSpecHash, _ := computeManifestHash(&uObj) uObj.SetAnnotations(map[string]string{manifestHashAnnotation: validSpecHash}) - lastAppliedConfig, _ := computeModifiedConfigurationAnnotation(&uObj) - _ = setModifiedConfigurationAnnotation(&uObj, lastAppliedConfig) + _ = setModifiedConfigurationAnnotation(&uObj) dynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) dynamicClient.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, uObj.DeepCopy(), nil diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index 965475f5d..acdedb993 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -75,24 +75,12 @@ func threeWayMergePatch(currentObj, manifestObj client.Object) (client.Patch, er } return client.RawPatch(patchType, patchData), nil } - -// computeModifiedConfigurationAnnotation is used to serialize the object into a byte stream. -func computeModifiedConfigurationAnnotation(obj runtime.Object) (string, error) { - //TODO: see if we should use something like json.ConfigCompatibleWithStandardLibrary.Marshal to make sure that - // the produced json format is more three way merge friendly - - // Marshaling adds about 100-200 bytes to the object's actual size - lastAppliedConfiguration, err := json.Marshal(obj) - if err != nil { - return "", err - } - return string(lastAppliedConfiguration), nil -} - -// setModifiedConfigurationAnnotation is used to set the serialized object as a byte stream as the last applied -// configuration annotation. If `updateAnnotation` is true, it embeds the result as an annotation in the +q +// setModifiedConfigurationAnnotation serializes the object into byte stream. +// If `updateAnnotation` is true, it embeds the result as an annotation in the // modified configuration. -func setModifiedConfigurationAnnotation(obj runtime.Object, lastAppliedConfig string) error { +func setModifiedConfigurationAnnotation(obj runtime.Object) error { + var modified []byte annotations, err := metadataAccessor.Annotations(obj) if err != nil { return fmt.Errorf("cannot access metadata.annotations: %w", err) @@ -109,8 +97,15 @@ func setModifiedConfigurationAnnotation(obj runtime.Object, lastAppliedConfig st } else { _ = metadataAccessor.SetAnnotations(obj, annotations) } + + //TODO: see if we should use something like json.ConfigCompatibleWithStandardLibrary.Marshal to make sure that + // the produced json format is more three way merge friendly + modified, err = json.Marshal(obj) + if err != nil { + return err + } // set the last applied annotation back - annotations[lastAppliedConfigAnnotation] = lastAppliedConfig + annotations[lastAppliedConfigAnnotation] = string(modified) return metadataAccessor.SetAnnotations(obj, annotations) } From 607f2b522698bed6e79fbf8a8e3b9bf79ddce7a2 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 14 Feb 2023 17:14:52 -0800 Subject: [PATCH 14/42] fix --- pkg/controllers/work/patch_util.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index acdedb993..6964d731a 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -75,7 +75,7 @@ func threeWayMergePatch(currentObj, manifestObj client.Object) (client.Patch, er } return client.RawPatch(patchType, patchData), nil } -q + // setModifiedConfigurationAnnotation serializes the object into byte stream. // If `updateAnnotation` is true, it embeds the result as an annotation in the // modified configuration. From 77c2377e197a5bcd53c114720daef31c5a2fa551 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Fri, 17 Feb 2023 09:26:06 -0800 Subject: [PATCH 15/42] addresse review comments --- pkg/controllers/work/apply_controller.go | 3 +-- pkg/controllers/work/apply_controller_test.go | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 30043554f..7abb1cee3 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -360,7 +360,6 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. if !isAnnotationsSizeValid(gvr, manifestRef, annotations) { delete(annotations, lastAppliedConfigAnnotation) manifestObj.SetAnnotations(annotations) - return r.applyObject(ctx, gvr, manifestObj) } actual, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Create( ctx, manifestObj, metav1.CreateOptions{FieldManager: workFieldManagerName}) @@ -422,7 +421,7 @@ func isAnnotationsSizeValid(gvr schema.GroupVersionResource, manifestRef klog.Ob } if totalSize > (int64)(TotalAnnotationSizeLimitB) { klog.V(2).InfoS("Size of annotations is greater than 262,144 bytes hence we don't add the last applied configuration annotation to do the three way merge", - "gvr", gvr, "manifest", manifestRef, "length of last applied configuration", totalSize) + "gvr", gvr, "manifest", manifestRef, "size of annotations", totalSize) return false } return true diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index 9adf741af..3e05343f4 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -482,7 +482,7 @@ func TestApplyUnstructured(t *testing.T) { }, workObj: &largeObj, resultSpecHash: largeObjSpecHash, - resultAction: ManifestAppliedAction, + resultAction: ManifestCreatedAction, resultErr: nil, }, "test apply succeeds on update for large manifest when object exists": { From 6fa558ad7af4307c7a13b454cb3371da444bccec Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Sun, 9 Apr 2023 14:48:57 -0700 Subject: [PATCH 16/42] reuse ValidateAnnotationSize from apimachinery --- pkg/controllers/work/apply_controller.go | 32 +++++++++++------------- 1 file changed, 14 insertions(+), 18 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 7abb1cee3..d3df43ed3 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -27,6 +27,7 @@ import ( v1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" + "k8s.io/apimachinery/pkg/api/validation" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime/schema" @@ -49,8 +50,7 @@ import ( ) const ( - workFieldManagerName = "work-api-agent" - TotalAnnotationSizeLimitB int = 256 * (1 << 10) // 256 kB + workFieldManagerName = "work-api-agent" ) // ApplyWorkReconciler reconciles a Work object @@ -357,7 +357,12 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. return nil, ManifestNoChangeAction, err } annotations := manifestObj.GetAnnotations() - if !isAnnotationsSizeValid(gvr, manifestRef, annotations) { + klog.V(2).InfoS("validating annotation size for manifest", + "gvr", gvr, "manifest", manifestRef) + err := validation.ValidateAnnotationsSize(annotations) + if err != nil { + klog.ErrorS(err, "not using three way merge for manifest removing last applied config annotation", + "gvr", gvr, "obj", manifestRef) delete(annotations, lastAppliedConfigAnnotation) manifestObj.SetAnnotations(annotations) } @@ -402,7 +407,12 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. return nil, ManifestNoChangeAction, err } annotations := manifestObj.GetAnnotations() - if !isAnnotationsSizeValid(gvr, manifestRef, annotations) { + klog.V(2).InfoS("validating annotation size for manifest", + "gvr", gvr, "manifest", manifestRef) + err := validation.ValidateAnnotationsSize(annotations) + if err != nil { + klog.ErrorS(err, "not using three way merge for manifest removing last applied config annotation", + "gvr", gvr, "obj", manifestRef) delete(annotations, lastAppliedConfigAnnotation) manifestObj.SetAnnotations(annotations) return r.applyObject(ctx, gvr, manifestObj) @@ -413,20 +423,6 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. return curObj, ManifestNoChangeAction, nil } -// isAnnotationSizeValid returns true if the total size of the annotations for a manifest is less than 256KB. -func isAnnotationsSizeValid(gvr schema.GroupVersionResource, manifestRef klog.ObjectRef, annotations map[string]string) bool { - var totalSize int64 - for k, v := range annotations { - totalSize += (int64)(len(k)) + (int64)(len(v)) - } - if totalSize > (int64)(TotalAnnotationSizeLimitB) { - klog.V(2).InfoS("Size of annotations is greater than 262,144 bytes hence we don't add the last applied configuration annotation to do the three way merge", - "gvr", gvr, "manifest", manifestRef, "size of annotations", totalSize) - return false - } - return true -} - // applyObject uses dynamic client's apply to apply the manifest. func (r *ApplyWorkReconciler) applyObject(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { From 5cba06599b0ec04c11b1002aebd08b72dce4cdd8 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 24 Apr 2023 14:39:38 -0700 Subject: [PATCH 17/42] address comments --- pkg/controllers/work/apply_controller.go | 5 +-- pkg/controllers/work/apply_controller_test.go | 17 +++++++--- pkg/utils/test_util.go | 17 +++++----- test/integration/cluster_placement_test.go | 33 ++++++++++++------- test/integration/utils_test.go | 27 ++++++++++----- 5 files changed, 65 insertions(+), 34 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index d3df43ed3..01f72128d 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -337,7 +337,8 @@ func (r *ApplyWorkReconciler) decodeManifest(manifest workv1alpha1.Manifest) (sc return mapping.Resource, unstructuredObj, nil } -// applyUnstructured determines if an unstructured manifest object can & should be applied. If so, it applies/creates the resource on the cluster based on it's size. +// applyUnstructured determines if an unstructured manifest object can & should be applied. If so, it either uses server side apply or +// creates the resource on the cluster based on the object's annotation size. func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { manifestRef := klog.ObjectRef{ @@ -361,7 +362,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. "gvr", gvr, "manifest", manifestRef) err := validation.ValidateAnnotationsSize(annotations) if err != nil { - klog.ErrorS(err, "not using three way merge for manifest removing last applied config annotation", + klog.InfoS(fmt.Sprintf("not using three way merge for manifest removing last applied config annotation, %s", err), "gvr", gvr, "obj", manifestRef) delete(annotations, lastAppliedConfigAnnotation) manifestObj.SetAnnotations(annotations) diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index 3e05343f4..5cd643094 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -80,7 +80,6 @@ var ( testManifest = workv1alpha1.Manifest{RawExtension: runtime.RawExtension{ Raw: rawTestDeployment, }} - largeSecret v1.Secret ) // This interface is needed for testMapper abstract class. @@ -347,15 +346,25 @@ func TestApplyUnstructured(t *testing.T) { specHashFailObj := correctObj.DeepCopy() specHashFailObj.Object["test"] = math.Inf(1) - utils.GetObjectFromManifest("../../../test/integration/manifests/resources/test-large-secret.yaml", &largeSecret) + var largeSecret v1.Secret + err := utils.GetObjectFromManifest("../../../test/integration/manifests/resources/test-large-secret.yaml", &largeSecret) + if err != nil { + t.Errorf("failed to get object from manifest: %s", err) + } largeSecret.ObjectMeta = metav1.ObjectMeta{ OwnerReferences: []metav1.OwnerReference{ ownerRef, }, } - rawSecret, _ := json.Marshal(largeSecret) + rawSecret, err := json.Marshal(largeSecret) + if err != nil { + t.Errorf("failed to marshal secret: %s", err) + } var largeObj unstructured.Unstructured - _ = largeObj.UnmarshalJSON(rawSecret) + err = largeObj.UnmarshalJSON(rawSecret) + if err != nil { + t.Errorf("failed to unmarshal JSON: %s", err) + } updatedLargeObj := largeObj.DeepCopy() largeObjSpecHash, _ := computeManifestHash(&largeObj) diff --git a/pkg/utils/test_util.go b/pkg/utils/test_util.go index dfa32d395..03fbe8f6a 100644 --- a/pkg/utils/test_util.go +++ b/pkg/utils/test_util.go @@ -47,27 +47,28 @@ func GetEventString(object runtime.Object, eventtype, reason, messageFmt string, object.GetObjectKind().GroupVersionKind().Kind, object.GetObjectKind().GroupVersionKind().GroupVersion()) } -// GetObjectFromRawExtension returns an object decoded from the raw byte array -func GetObjectFromRawExtension(rawByte []byte, obj runtime.Object) { +// GetObjectFromRawExtension returns an object decoded from the raw byte array. +func GetObjectFromRawExtension(rawByte []byte, obj runtime.Object) error { json, err := yaml.ToJSON(rawByte) if err != nil { - return + return err } err = runtime.DecodeInto(genericCodec, json, obj) if err != nil { - return + return err } + return nil } -// GetObjectFromManifest returns a runtime object decoded from the file -func GetObjectFromManifest(relativeFilePath string, obj runtime.Object) { +// GetObjectFromManifest returns a runtime object decoded from the file. +func GetObjectFromManifest(relativeFilePath string, obj runtime.Object) error { // Read files, create manifest fileRaw, err := os.ReadFile(relativeFilePath) if err != nil { - return + return err } - GetObjectFromRawExtension(fileRaw, obj) + return GetObjectFromRawExtension(fileRaw, obj) } // NewResourceList returns a resource list for test purpose. diff --git a/test/integration/cluster_placement_test.go b/test/integration/cluster_placement_test.go index 52a76573a..af2a36c5d 100644 --- a/test/integration/cluster_placement_test.go +++ b/test/integration/cluster_placement_test.go @@ -490,10 +490,12 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster A", i)) var uObj unstructured.Unstructured - utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + err := utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + Expect(err).Should(Succeed()) if uObj.GroupVersionKind().Kind == "Role" && uObj.GroupVersionKind().Group == rbacv1.GroupName { var selectedRole rbacv1.Role - utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + err := utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + Expect(err).Should(Succeed()) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(1)) if reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) { findRole = true @@ -523,10 +525,12 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster A", i)) var uObj unstructured.Unstructured - utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + err := utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + Expect(err).Should(Succeed()) if uObj.GroupVersionKind().Kind == "Role" && uObj.GroupVersionKind().Group == rbacv1.GroupName { var selectedRole rbacv1.Role - utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + err := utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + Expect(err).Should(Succeed()) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(2)) if reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) && reflect.DeepEqual(selectedRole.Rules[1], utils.WorkRule) { @@ -667,10 +671,12 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster A", i)) var uObj unstructured.Unstructured - utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + err := utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + Expect(err).Should(Succeed()) if uObj.GroupVersionKind().Kind == ClusterRoleKind && uObj.GroupVersionKind().Group == rbacv1.GroupName { var selectedRole rbacv1.ClusterRole - utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + err := utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + Expect(err).Should(Succeed()) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(1)) if reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) { findClusterRole = true @@ -697,10 +703,12 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster A", i)) var uObj unstructured.Unstructured - utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + err := utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + Expect(err).Should(Succeed()) if uObj.GroupVersionKind().Kind == ClusterRoleKind && uObj.GroupVersionKind().Group == rbacv1.GroupName { var selectedRole rbacv1.ClusterRole - utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + err := utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + Expect(err).Should(Succeed()) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(2)) if reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) && reflect.DeepEqual(selectedRole.Rules[1], utils.WorkRule) { @@ -1234,7 +1242,8 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { Expect(len(clusterWork.Spec.Workload.Manifests)).Should(BeIdenticalTo(1)) manifest := clusterWork.Spec.Workload.Manifests[0] var selectedRole rbacv1.ClusterRole - utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + err := utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + Expect(err).Should(Succeed()) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(2)) Expect(reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) && reflect.DeepEqual(selectedRole.Rules[1], utils.WorkRule)).Should(BeTrue()) @@ -1247,7 +1256,8 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { }, &clusterWork)).Should(Succeed()) Expect(len(clusterWork.Spec.Workload.Manifests)).Should(BeIdenticalTo(1)) manifest = clusterWork.Spec.Workload.Manifests[0] - utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + err = utils.GetObjectFromRawExtension(manifest.Raw, &selectedRole) + Expect(err).Should(Succeed()) Expect(len(selectedRole.Rules)).Should(BeEquivalentTo(2)) Expect(reflect.DeepEqual(selectedRole.Rules[0], utils.FleetRule) && reflect.DeepEqual(selectedRole.Rules[1], utils.WorkRule)).Should(BeTrue()) @@ -1373,7 +1383,8 @@ var _ = Describe("Test Cluster Resource Placement Controller", func() { }, &clusterWork)).Should(Succeed()) Expect(len(clusterWork.Spec.Workload.Manifests)).Should(Equal(1)) var uObj unstructured.Unstructured - utils.GetObjectFromRawExtension(clusterWork.Spec.Workload.Manifests[0].Raw, &uObj) + err := utils.GetObjectFromRawExtension(clusterWork.Spec.Workload.Manifests[0].Raw, &uObj) + Expect(err).Should(Succeed()) Expect(uObj.GroupVersionKind().Kind).Should(Equal("MutatingWebhookConfiguration")) By("Delete the webhook resources") diff --git a/test/integration/utils_test.go b/test/integration/utils_test.go index 9809e1781..4ac3fd3b1 100644 --- a/test/integration/utils_test.go +++ b/test/integration/utils_test.go @@ -65,36 +65,44 @@ var ( // Cloneset CR, Pdb, Configmap, Secret, Service. func applyTestManifests() { By("Create testCloneset CRD") - utils.GetObjectFromManifest("manifests/resources/test_clonesets_crd.yaml", &testClonesetCRD) + err := utils.GetObjectFromManifest("manifests/resources/test_clonesets_crd.yaml", &testClonesetCRD) + Expect(err).Should(Succeed()) Expect(k8sClient.Create(ctx, &testClonesetCRD)).Should(Succeed()) // TODO: replace the rest objects with programmatic definition By("Create testClusterRole resource") - utils.GetObjectFromManifest("manifests/resources/test_clusterrole.yaml", &testClusterRole) + err = utils.GetObjectFromManifest("manifests/resources/test_clusterrole.yaml", &testClusterRole) + Expect(err).Should(Succeed()) Expect(k8sClient.Create(ctx, &testClusterRole)).Should(Succeed()) By("Create namespace") - utils.GetObjectFromManifest("manifests/resources/test_namespace.yaml", &testNameSpace) + err = utils.GetObjectFromManifest("manifests/resources/test_namespace.yaml", &testNameSpace) + Expect(err).Should(Succeed()) Expect(k8sClient.Create(ctx, &testNameSpace)).Should(Succeed()) By("Create PodDisruptionBudget") - utils.GetObjectFromManifest("manifests/resources/test_pdb.yaml", &testPdb) + err = utils.GetObjectFromManifest("manifests/resources/test_pdb.yaml", &testPdb) + Expect(err).Should(Succeed()) Expect(k8sClient.Create(ctx, &testPdb)).Should(Succeed()) By("Create the testConfigMap resources") - utils.GetObjectFromManifest("manifests/resources/test-configmap.yaml", &testConfigMap) + err = utils.GetObjectFromManifest("manifests/resources/test-configmap.yaml", &testConfigMap) + Expect(err).Should(Succeed()) Expect(k8sClient.Create(ctx, &testConfigMap)).Should(Succeed()) By("Create testSecret resource") - utils.GetObjectFromManifest("manifests/resources/test-secret.yaml", &testSecret) + err = utils.GetObjectFromManifest("manifests/resources/test-secret.yaml", &testSecret) + Expect(err).Should(Succeed()) Expect(k8sClient.Create(ctx, &testSecret)).Should(Succeed()) By("Create testService resource") - utils.GetObjectFromManifest("manifests/resources/test-service.yaml", &testService) + err = utils.GetObjectFromManifest("manifests/resources/test-service.yaml", &testService) + Expect(err).Should(Succeed()) Expect(k8sClient.Create(ctx, &testService)).Should(Succeed()) By("Create testCloneset resource") - utils.GetObjectFromManifest("manifests/resources/test-cloneset.yaml", &testCloneset) + err = utils.GetObjectFromManifest("manifests/resources/test-cloneset.yaml", &testCloneset) + Expect(err).Should(Succeed()) Expect(k8sClient.Create(ctx, &testCloneset)).Should(Succeed()) } @@ -252,7 +260,8 @@ func verifyPartialWorkObjects(crp *fleetv1alpha1.ClusterResourcePlacement, expec for i, manifest := range clusterWork.Spec.Workload.Manifests { By(fmt.Sprintf("validate the %d uObj in the work resource in cluster %s", i, cluster.Name)) var uObj unstructured.Unstructured - utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + err := utils.GetObjectFromRawExtension(manifest.Raw, &uObj) + Expect(err).Should(Succeed()) kind := uObj.GroupVersionKind().Kind if preciseMatch { Expect(kind).Should(SatisfyAny(expectedKindMatchers...)) From 7146886870a6f404403b7a5090ef6f57450fbfe5 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 24 Apr 2023 14:46:07 -0700 Subject: [PATCH 18/42] refactor err check --- pkg/controllers/work/apply_controller.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 01f72128d..fc91e1dd5 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -360,8 +360,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. annotations := manifestObj.GetAnnotations() klog.V(2).InfoS("validating annotation size for manifest", "gvr", gvr, "manifest", manifestRef) - err := validation.ValidateAnnotationsSize(annotations) - if err != nil { + if err := validation.ValidateAnnotationsSize(annotations); err != nil { klog.InfoS(fmt.Sprintf("not using three way merge for manifest removing last applied config annotation, %s", err), "gvr", gvr, "obj", manifestRef) delete(annotations, lastAppliedConfigAnnotation) From 41d297ea95aed208f7530460bae7201a8ba1e141 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 24 Apr 2023 14:57:46 -0700 Subject: [PATCH 19/42] refactor err checks --- pkg/controllers/work/apply_controller_test.go | 6 ++---- pkg/utils/test_util.go | 3 +-- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index 5cd643094..f31413618 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -347,8 +347,7 @@ func TestApplyUnstructured(t *testing.T) { specHashFailObj.Object["test"] = math.Inf(1) var largeSecret v1.Secret - err := utils.GetObjectFromManifest("../../../test/integration/manifests/resources/test-large-secret.yaml", &largeSecret) - if err != nil { + if err := utils.GetObjectFromManifest("../../../test/integration/manifests/resources/test-large-secret.yaml", &largeSecret); err != nil { t.Errorf("failed to get object from manifest: %s", err) } largeSecret.ObjectMeta = metav1.ObjectMeta{ @@ -361,8 +360,7 @@ func TestApplyUnstructured(t *testing.T) { t.Errorf("failed to marshal secret: %s", err) } var largeObj unstructured.Unstructured - err = largeObj.UnmarshalJSON(rawSecret) - if err != nil { + if err = largeObj.UnmarshalJSON(rawSecret); err != nil { t.Errorf("failed to unmarshal JSON: %s", err) } updatedLargeObj := largeObj.DeepCopy() diff --git a/pkg/utils/test_util.go b/pkg/utils/test_util.go index 03fbe8f6a..23156a70d 100644 --- a/pkg/utils/test_util.go +++ b/pkg/utils/test_util.go @@ -53,8 +53,7 @@ func GetObjectFromRawExtension(rawByte []byte, obj runtime.Object) error { if err != nil { return err } - err = runtime.DecodeInto(genericCodec, json, obj) - if err != nil { + if err = runtime.DecodeInto(genericCodec, json, obj); err != nil { return err } return nil From 9bbe03418688fd371acaf1534f364d4d929b7004 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 24 Apr 2023 15:20:28 -0700 Subject: [PATCH 20/42] fix comment --- pkg/controllers/work/apply_controller.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index fc91e1dd5..8565a5ed0 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -337,8 +337,9 @@ func (r *ApplyWorkReconciler) decodeManifest(manifest workv1alpha1.Manifest) (sc return mapping.Resource, unstructuredObj, nil } -// applyUnstructured determines if an unstructured manifest object can & should be applied. If so, it either uses server side apply or -// creates the resource on the cluster based on the object's annotation size. +// applyUnstructured determines if an unstructured manifest object can & should be applied. It first validates +// the size of the last modified annotation of the manifest, it removes the annotation if the size crosses the annotation size threshold +// and then creates/updates the resource on the cluster func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { manifestRef := klog.ObjectRef{ From 4382ba522e77951a901d426ad5497d974cbdafbb Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 24 Apr 2023 15:21:35 -0700 Subject: [PATCH 21/42] fix comment --- pkg/controllers/work/apply_controller.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 8565a5ed0..4dd738b84 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -339,7 +339,7 @@ func (r *ApplyWorkReconciler) decodeManifest(manifest workv1alpha1.Manifest) (sc // applyUnstructured determines if an unstructured manifest object can & should be applied. It first validates // the size of the last modified annotation of the manifest, it removes the annotation if the size crosses the annotation size threshold -// and then creates/updates the resource on the cluster +// and then creates/updates the resource on the cluster using server side apply instead of three way merge patch. func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { manifestRef := klog.ObjectRef{ From 70532f04de59e0b3eea05da2dbf5eb00493e08d1 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 24 Apr 2023 16:35:23 -0700 Subject: [PATCH 22/42] refactor err check --- pkg/controllers/work/apply_controller.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 4dd738b84..fb53c35d1 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -404,14 +404,13 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // belong to multiple work so it contains the union of all the appliedWork manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) // record the raw manifest with the hash annotation in the manifest - if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { + if err = setModifiedConfigurationAnnotation(manifestObj); err != nil { return nil, ManifestNoChangeAction, err } annotations := manifestObj.GetAnnotations() klog.V(2).InfoS("validating annotation size for manifest", "gvr", gvr, "manifest", manifestRef) - err := validation.ValidateAnnotationsSize(annotations) - if err != nil { + if err = validation.ValidateAnnotationsSize(annotations); err != nil { klog.ErrorS(err, "not using three way merge for manifest removing last applied config annotation", "gvr", gvr, "obj", manifestRef) delete(annotations, lastAppliedConfigAnnotation) From d90245c4f433b5dacc75cc02e766d90d960c45d4 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 24 Apr 2023 16:43:30 -0700 Subject: [PATCH 23/42] update comment --- pkg/controllers/work/apply_controller.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index fb53c35d1..5a6937cd9 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -423,7 +423,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. return curObj, ManifestNoChangeAction, nil } -// applyObject uses dynamic client's apply to apply the manifest. +// applyObject uses server side apply to apply the manifest. func (r *ApplyWorkReconciler) applyObject(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { manifestRef := klog.ObjectRef{ From 6054be2f5e19b4d7657dd7813a2efd5830a04428 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 24 Apr 2023 18:25:25 -0700 Subject: [PATCH 24/42] force conflicts on apply --- pkg/controllers/work/apply_controller.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 5a6937cd9..288156ceb 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -430,7 +430,11 @@ func (r *ApplyWorkReconciler) applyObject(ctx context.Context, gvr schema.GroupV Name: manifestObj.GetName(), Namespace: manifestObj.GetNamespace(), } - manifestObj, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Apply(ctx, manifestObj.GetName(), manifestObj, metav1.ApplyOptions{FieldManager: workFieldManagerName}) + options := metav1.ApplyOptions{ + FieldManager: workFieldManagerName, + Force: true, + } + manifestObj, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Apply(ctx, manifestObj.GetName(), manifestObj, options) if err != nil { klog.ErrorS(err, "failed to apply object", "gvr", gvr, "manifest", manifestRef) return nil, ManifestNoChangeAction, err From 7ec1f95be7bad4d621c73c2cfeb086c90905423a Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Fri, 5 May 2023 14:04:47 -0700 Subject: [PATCH 25/42] set last applied config to empty string --- pkg/controllers/work/apply_controller.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 288156ceb..72bc6404f 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -364,7 +364,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. if err := validation.ValidateAnnotationsSize(annotations); err != nil { klog.InfoS(fmt.Sprintf("not using three way merge for manifest removing last applied config annotation, %s", err), "gvr", gvr, "obj", manifestRef) - delete(annotations, lastAppliedConfigAnnotation) + annotations[lastAppliedConfigAnnotation] = "" manifestObj.SetAnnotations(annotations) } actual, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Create( @@ -413,7 +413,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. if err = validation.ValidateAnnotationsSize(annotations); err != nil { klog.ErrorS(err, "not using three way merge for manifest removing last applied config annotation", "gvr", gvr, "obj", manifestRef) - delete(annotations, lastAppliedConfigAnnotation) + annotations[lastAppliedConfigAnnotation] = "" manifestObj.SetAnnotations(annotations) return r.applyObject(ctx, gvr, manifestObj) } From 6922a6a5aa817cddc179d085a200add9c65cedb8 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 9 May 2023 00:37:05 -0700 Subject: [PATCH 26/42] Working E2E --- pkg/controllers/work/apply_controller.go | 16 +-- .../work/apply_controller_helper_test.go | 4 +- pkg/controllers/work/manager.go | 4 +- pkg/controllers/work/patch_util.go | 6 +- test/e2e/utils/workload_test_utils.go | 15 ++ test/e2e/work_load_test.go | 135 +++++++++++++++++- .../resources/test-large-secret.yaml | 10 +- .../resources/test-small-secret.yaml | 8 ++ 8 files changed, 172 insertions(+), 26 deletions(-) create mode 100644 test/integration/manifests/resources/test-small-secret.yaml diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 72bc6404f..a27805dea 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -364,7 +364,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. if err := validation.ValidateAnnotationsSize(annotations); err != nil { klog.InfoS(fmt.Sprintf("not using three way merge for manifest removing last applied config annotation, %s", err), "gvr", gvr, "obj", manifestRef) - annotations[lastAppliedConfigAnnotation] = "" + annotations[LastAppliedConfigAnnotation] = "" manifestObj.SetAnnotations(annotations) } actual, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Create( @@ -399,7 +399,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. } // We only try to update the object if its spec hash value has changed. - if manifestObj.GetAnnotations()[manifestHashAnnotation] != curObj.GetAnnotations()[manifestHashAnnotation] { + if manifestObj.GetAnnotations()[ManifestHashAnnotation] != curObj.GetAnnotations()[ManifestHashAnnotation] { // we need to merge the owner reference between the current and the manifest since we support one manifest // belong to multiple work so it contains the union of all the appliedWork manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) @@ -413,7 +413,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. if err = validation.ValidateAnnotationsSize(annotations); err != nil { klog.ErrorS(err, "not using three way merge for manifest removing last applied config annotation", "gvr", gvr, "obj", manifestRef) - annotations[lastAppliedConfigAnnotation] = "" + annotations[LastAppliedConfigAnnotation] = "" manifestObj.SetAnnotations(annotations) return r.applyObject(ctx, gvr, manifestObj) } @@ -451,8 +451,8 @@ func (r *ApplyWorkReconciler) patchCurrentResource(ctx context.Context, gvr sche Namespace: manifestObj.GetNamespace(), } klog.V(2).InfoS("manifest is modified", "gvr", gvr, "manifest", manifestRef, - "new hash", manifestObj.GetAnnotations()[manifestHashAnnotation], - "existing hash", curObj.GetAnnotations()[manifestHashAnnotation]) + "new hash", manifestObj.GetAnnotations()[ManifestHashAnnotation], + "existing hash", curObj.GetAnnotations()[ManifestHashAnnotation]) // create the three-way merge patch between the current, original and manifest similar to how kubectl apply does patch, err := threeWayMergePatch(curObj, manifestObj) if err != nil { @@ -561,8 +561,8 @@ func computeManifestHash(obj *unstructured.Unstructured) (string, error) { // remove the last applied Annotation to avoid unlimited recursion annotation := manifest.GetAnnotations() if annotation != nil { - delete(annotation, manifestHashAnnotation) - delete(annotation, lastAppliedConfigAnnotation) + delete(annotation, ManifestHashAnnotation) + delete(annotation, LastAppliedConfigAnnotation) if len(annotation) == 0 { manifest.SetAnnotations(nil) } else { @@ -634,7 +634,7 @@ func setManifestHashAnnotation(manifestObj *unstructured.Unstructured) error { if annotation == nil { annotation = map[string]string{} } - annotation[manifestHashAnnotation] = manifestHash + annotation[ManifestHashAnnotation] = manifestHash manifestObj.SetAnnotations(annotation) return nil } diff --git a/pkg/controllers/work/apply_controller_helper_test.go b/pkg/controllers/work/apply_controller_helper_test.go index e0cd3f935..4185e2da9 100644 --- a/pkg/controllers/work/apply_controller_helper_test.go +++ b/pkg/controllers/work/apply_controller_helper_test.go @@ -51,8 +51,8 @@ func verifyAppliedConfigMap(cm *corev1.ConfigMap) *corev1.ConfigMap { for key := range cm.Annotations { Expect(appliedCM.Annotations[key]).Should(Equal(cm.Annotations[key])) } - Expect(appliedCM.Annotations[manifestHashAnnotation]).ShouldNot(BeEmpty()) - Expect(appliedCM.Annotations[lastAppliedConfigAnnotation]).ShouldNot(BeEmpty()) + Expect(appliedCM.Annotations[ManifestHashAnnotation]).ShouldNot(BeEmpty()) + Expect(appliedCM.Annotations[LastAppliedConfigAnnotation]).ShouldNot(BeEmpty()) By("Check the config map data") Expect(cmp.Diff(appliedCM.Data, cm.Data)).Should(BeEmpty()) diff --git a/pkg/controllers/work/manager.go b/pkg/controllers/work/manager.go index 067471bc7..5bb03a3fb 100644 --- a/pkg/controllers/work/manager.go +++ b/pkg/controllers/work/manager.go @@ -32,9 +32,9 @@ import ( const ( workFinalizer = "fleet.azure.com/work-cleanup" - manifestHashAnnotation = "fleet.azure.com/spec-hash" + ManifestHashAnnotation = "fleet.azure.com/spec-hash" - lastAppliedConfigAnnotation = "fleet.azure.com/last-applied-configuration" + LastAppliedConfigAnnotation = "fleet.azure.com/last-applied-configuration" ConditionTypeApplied = "Applied" ConditionTypeAvailable = "Available" diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index 6964d731a..3742a283f 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -90,7 +90,7 @@ func setModifiedConfigurationAnnotation(obj runtime.Object) error { } // remove the annotation to avoid recursion - delete(annotations, lastAppliedConfigAnnotation) + delete(annotations, LastAppliedConfigAnnotation) // do not include an empty map if len(annotations) == 0 { _ = metadataAccessor.SetAnnotations(obj, nil) @@ -105,7 +105,7 @@ func setModifiedConfigurationAnnotation(obj runtime.Object) error { return err } // set the last applied annotation back - annotations[lastAppliedConfigAnnotation] = string(modified) + annotations[LastAppliedConfigAnnotation] = string(modified) return metadataAccessor.SetAnnotations(obj, annotations) } @@ -122,7 +122,7 @@ func getOriginalConfiguration(obj runtime.Object) ([]byte, error) { klog.Warning("object does not have annotation", "obj", obj) return nil, nil } - original, ok := annots[lastAppliedConfigAnnotation] + original, ok := annots[LastAppliedConfigAnnotation] if !ok { klog.Warning("object does not have lastAppliedConfigAnnotation", "obj", obj) return nil, nil diff --git a/test/e2e/utils/workload_test_utils.go b/test/e2e/utils/workload_test_utils.go index 3c4fe84c7..a38aadd4d 100644 --- a/test/e2e/utils/workload_test_utils.go +++ b/test/e2e/utils/workload_test_utils.go @@ -78,6 +78,21 @@ func CmpRoleBinding(ctx context.Context, cluster framework.Cluster, objectKey *t }, PollTimeout, PollInterval).Should(gomega.Succeed(), "Failed to compare actual and expected role bindings in %s cluster", cluster.ClusterName) } +// CmpSecret compares actual secret with expected secret and returns actual secret. +func CmpSecret(ctx context.Context, cluster framework.Cluster, objectKey *types.NamespacedName, wantSecret *corev1.Secret, cmpOptions []cmp.Option) *corev1.Secret { + gotSecret := &corev1.Secret{} + gomega.Eventually(func() error { + if err := cluster.KubeClient.Get(ctx, types.NamespacedName{Name: objectKey.Name, Namespace: objectKey.Namespace}, gotSecret); err != nil { + return err + } + if diff := cmp.Diff(wantSecret, gotSecret, cmpOptions...); diff != "" { + return fmt.Errorf("secret binding(%s) mismatch (-want +got):\n%s", gotSecret.Name, diff) + } + return nil + }, PollTimeout, PollInterval).Should(gomega.Succeed(), "Failed to compare actual and expected secret in %s cluster", cluster.ClusterName) + return gotSecret +} + // WaitCreateClusterResourcePlacementStatus waits for ClusterResourcePlacement to present on th hub cluster with a specific status. func WaitCreateClusterResourcePlacementStatus(ctx context.Context, cluster framework.Cluster, objectKey *types.NamespacedName, wantCRPStatus fleetv1alpha1.ClusterResourcePlacementStatus, crpStatusCmpOptions []cmp.Option, customTimeout time.Duration) { gotCRP := &fleetv1alpha1.ClusterResourcePlacement{} diff --git a/test/e2e/work_load_test.go b/test/e2e/work_load_test.go index bbb5c4af2..b8b1dbd59 100644 --- a/test/e2e/work_load_test.go +++ b/test/e2e/work_load_test.go @@ -19,16 +19,19 @@ import ( workapi "sigs.k8s.io/work-api/pkg/apis/v1alpha1" "go.goms.io/fleet/apis/v1alpha1" + workcontroller "go.goms.io/fleet/pkg/controllers/work" + pkgutils "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/test/e2e/utils" ) var _ = Describe("workload orchestration testing", func() { var ( - crp *v1alpha1.ClusterResourcePlacement - labelKey = "fleet.azure.com/name" - labelValue = "test" + crp *v1alpha1.ClusterResourcePlacement + labelKey = "fleet.azure.com/name" + labelValue = "test" + // Ignoring typeMeta to get the tests to pass, not sure why. resourceIgnoreOptions = []cmp.Option{cmpopts.IgnoreFields(metav1.ObjectMeta{}, "ResourceVersion", "UID", "Annotations", "CreationTimestamp", "ManagedFields"), - cmpopts.IgnoreFields(metav1.OwnerReference{}, "UID")} + cmpopts.IgnoreFields(metav1.OwnerReference{}, "UID"), cmpopts.IgnoreFields(metav1.TypeMeta{}, "Kind", "APIVersion")} ) Context("Test Workload Orchestration", func() { @@ -320,5 +323,129 @@ var _ = Describe("workload orchestration testing", func() { By("delete cluster resource placement on hub cluster") utils.DeleteClusterResourcePlacement(ctx, *HubCluster, crp) }) + + It("Apply CRP select namespace propagate small secret, then update secret to be large to handle annotation limitation", func() { + By("create the resources to be propagated") + namespace := &corev1.Namespace{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-namespace", + Labels: map[string]string{labelKey: labelValue}, + }, + } + Expect(HubCluster.KubeClient.Create(ctx, namespace)).Should(Succeed(), "Failed to create namespace %s in %s cluster", namespace.Name, HubCluster.ClusterName) + var testSmallSecret corev1.Secret + err := pkgutils.GetObjectFromManifest("./test/integration/manifests/resources/test-small-secret.yaml", &testSmallSecret) + Expect(err).Should(Succeed()) + Expect(HubCluster.KubeClient.Create(ctx, &testSmallSecret)).Should(Succeed(), "Failed to create small secret %s in %s cluster", testSmallSecret.Name, HubCluster.ClusterName) + + By("create the cluster resource placement in the hub cluster") + crp = &v1alpha1.ClusterResourcePlacement{ + ObjectMeta: metav1.ObjectMeta{Name: "test-crp"}, + Spec: v1alpha1.ClusterResourcePlacementSpec{ + ResourceSelectors: []v1alpha1.ClusterResourceSelector{ + { + Group: "", + Version: "v1", + Kind: "Namespace", + Name: namespace.Name, + }, + }, + }, + } + + Expect(HubCluster.KubeClient.Create(ctx, crp)).Should(Succeed(), "Failed to create cluster resource placement %s in %s cluster", crp.Name, HubCluster.ClusterName) + + By("check if work gets created for cluster resource placement") + utils.WaitWork(ctx, *HubCluster, crp.Name, memberNamespace.Name) + + By("check if cluster resource placement status is updated") + crpStatus := v1alpha1.ClusterResourcePlacementStatus{ + Conditions: []metav1.Condition{ + { + Reason: "ScheduleSucceeded", + Status: metav1.ConditionTrue, + Type: string(v1alpha1.ResourcePlacementConditionTypeScheduled), + }, + { + Reason: "ApplySucceeded", + Status: metav1.ConditionTrue, + Type: string(v1alpha1.ResourcePlacementStatusConditionTypeApplied), + }, + }, + SelectedResources: []v1alpha1.ResourceIdentifier{ + { + Version: "v1", + Kind: "Secret", + Name: testSmallSecret.Name, + Namespace: testSmallSecret.Namespace, + }, + { + Version: "v1", + Kind: "Namespace", + Name: namespace.Name, + }, + }, + TargetClusters: []string{"kind-member-testing"}, + } + utils.WaitCreateClusterResourcePlacementStatus(ctx, *HubCluster, &types.NamespacedName{Name: crp.Name}, crpStatus, crpStatusCmpOptions, 3*utils.PollTimeout) + + By("check if resources in namespace are propagated to member cluster") + ownerReferences := []metav1.OwnerReference{ + { + APIVersion: workapi.GroupVersion.String(), + BlockOwnerDeletion: pointer.Bool(false), + Kind: "AppliedWork", + Name: crp.Name, + }, + } + expectedNamespace := namespace + expectedSecret := &testSmallSecret + expectedNamespace.OwnerReferences = ownerReferences + expectedSecret.OwnerReferences = ownerReferences + + utils.CmpNamespace(ctx, *MemberCluster, &types.NamespacedName{Name: namespace.Name}, expectedNamespace, resourceIgnoreOptions) + // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. + gotSecret := utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testSmallSecret.Name, Namespace: testSmallSecret.Namespace}, expectedSecret, resourceIgnoreOptions) + Expect(gotSecret.Annotations[workcontroller.LastAppliedConfigAnnotation]).To(Not(BeEmpty())) + testSmallSecretSpecHash := gotSecret.Annotations[workcontroller.ManifestHashAnnotation] + + By("update secret so that annotation limit crosses threshold of 256KB") + var testLargeSecret corev1.Secret + err = pkgutils.GetObjectFromManifest("./test/integration/manifests/resources/test-large-secret.yaml", &testLargeSecret) + Expect(err).Should(Succeed()) + // testLargeSecret has the same name as testSmallSecret + Expect(HubCluster.KubeClient.Update(ctx, &testLargeSecret)).Should(Succeed(), "Failed to update secret %s to be large in %s cluster", testLargeSecret.Name, HubCluster.ClusterName) + expectedSecret = &testLargeSecret + expectedSecret.OwnerReferences = ownerReferences + + // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. + gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testLargeSecret.Name, Namespace: testLargeSecret.Namespace}, expectedSecret, resourceIgnoreOptions) + Expect(gotSecret.Annotations[workcontroller.LastAppliedConfigAnnotation]).To(BeEmpty()) + Expect(gotSecret.Annotations[workcontroller.ManifestHashAnnotation]).ToNot(Equal(testSmallSecretSpecHash)) + + By("update secret so that it's small again") + // Using a new variable to prevent failure, leads to 409 if not. + var smallSecret corev1.Secret + err = pkgutils.GetObjectFromManifest("./test/integration/manifests/resources/test-small-secret.yaml", &smallSecret) + Expect(err).Should(Succeed()) + Eventually(func() error { + if err := HubCluster.KubeClient.Update(ctx, &smallSecret); err != nil { + return err + } + return nil + }, utils.PollTimeout, utils.PollInterval).Should(Succeed(), "Failed to update secret to be small in %s cluster", HubCluster.ClusterName) + expectedSecret = &smallSecret + expectedSecret.OwnerReferences = ownerReferences + + // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. + gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: smallSecret.Name, Namespace: smallSecret.Namespace}, expectedSecret, resourceIgnoreOptions) + Expect(gotSecret.Annotations[workcontroller.LastAppliedConfigAnnotation]).ToNot(BeEmpty()) + Expect(gotSecret.Annotations[workcontroller.ManifestHashAnnotation]).To(Equal(testSmallSecretSpecHash)) + + By("delete namespaces") + utils.DeleteNamespace(ctx, *HubCluster, namespace) + By("delete cluster resource placement on hub cluster") + utils.DeleteClusterResourcePlacement(ctx, *HubCluster, crp) + }) }) }) diff --git a/test/integration/manifests/resources/test-large-secret.yaml b/test/integration/manifests/resources/test-large-secret.yaml index d6961a1b4..420102118 100644 --- a/test/integration/manifests/resources/test-large-secret.yaml +++ b/test/integration/manifests/resources/test-large-secret.yaml @@ -3,10 +3,6 @@ data: release: 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 kind: Secret metadata: - labels: - name: test-secret - owner: helm - status: deployed - version: "1" - name: sh.helm.release.v1.test -type: helm.sh/release.v1 + name: test-secret + namespace: test-namespace +type: default diff --git a/test/integration/manifests/resources/test-small-secret.yaml b/test/integration/manifests/resources/test-small-secret.yaml new file mode 100644 index 000000000..5baf4b873 --- /dev/null +++ b/test/integration/manifests/resources/test-small-secret.yaml @@ -0,0 +1,8 @@ +apiVersion: v1 +data: + release: YXBpVmVyc2lvbjogY29vcmRpbmF0aW9uLms4cy5pby92MQpraW5kOiBMZWFzZQptZXRhZGF0YToKICBuYW1lOiBjb250cm9sbGVyLW1hbmFnZXIKICBuYW1lc3BhY2U6IGFwcApzcGVjOgogIGFjcXVpcmVUaW1lOiAiMjAyMi0wOC0wMVQwNzowOTowNC41MDgxNTFaIgogIGhvbGRlcklkZW50aXR5OiBjb250cm9sbGVyLW1hbmFnZXItdjItNTc5YzRiZjlkYi03NzU3Ml80NjA0ZDUyZC0wNGE4LTRmODEtODkyYi1lNTQ2N2U2YWMyOWQKICBsZWFzZUR1cmF0aW9uU2Vjb25kczogMTUKICBsZWFzZVRyYW5zaXRpb25zOiA1MwogIHJlbmV3VGltZTogIjIwMjItMDgtMDJUMTk6NDg6MTEuOTI1NzMwWiI= +kind: Secret +metadata: + name: test-secret + namespace: test-namespace +type: default From 65af7f7e9f02667e421a7749b3bf9e9e7cd5b6b6 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 9 May 2023 00:44:44 -0700 Subject: [PATCH 27/42] fix UT --- pkg/controllers/work/apply_controller_test.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index f31413618..844d2ad8e 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -155,7 +155,7 @@ func TestSetManifestHashAnnotation(t *testing.T) { "manifest's has hashAnnotation, same": { manifestObj: func() *appsv1.Deployment { alterObj := manifestObj.DeepCopy() - alterObj.Annotations[manifestHashAnnotation] = utilrand.String(10) + alterObj.Annotations[ManifestHashAnnotation] = utilrand.String(10) return alterObj }(), isSame: true, @@ -222,7 +222,7 @@ func TestSetManifestHashAnnotation(t *testing.T) { if err != nil { t.Error("failed to marshall the manifest", err.Error()) } - manifestHash := uManifestObj.GetAnnotations()[manifestHashAnnotation] + manifestHash := uManifestObj.GetAnnotations()[ManifestHashAnnotation] if tt.isSame != (manifestHash == preHash) { t.Errorf("testcase %s failed: manifestObj = (%+v)", name, tt.manifestObj) } @@ -366,7 +366,7 @@ func TestApplyUnstructured(t *testing.T) { updatedLargeObj := largeObj.DeepCopy() largeObjSpecHash, _ := computeManifestHash(&largeObj) - largeObj.SetAnnotations(map[string]string{manifestHashAnnotation: largeObjSpecHash}) + largeObj.SetAnnotations(map[string]string{ManifestHashAnnotation: largeObjSpecHash}) applyDynamicClientNotFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) applyDynamicClientNotFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { @@ -384,7 +384,7 @@ func TestApplyUnstructured(t *testing.T) { updatedLargeObj.SetLabels(map[string]string{"test-label-key": "test-label"}) updatedLargeObjSpecHash, _ := computeManifestHash(updatedLargeObj) - updatedLargeObj.SetAnnotations(map[string]string{manifestHashAnnotation: updatedLargeObjSpecHash}) + updatedLargeObj.SetAnnotations(map[string]string{ManifestHashAnnotation: updatedLargeObjSpecHash}) applyDynamicClientFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) applyDynamicClientFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { @@ -514,7 +514,7 @@ func TestApplyUnstructured(t *testing.T) { } else { assert.Truef(t, err == nil, "err is not nil for Testcase %s", testName) assert.Truef(t, applyResult != nil, "applyResult is not nil for Testcase %s", testName) - assert.Equalf(t, testCase.resultSpecHash, applyResult.GetAnnotations()[manifestHashAnnotation], + assert.Equalf(t, testCase.resultSpecHash, applyResult.GetAnnotations()[ManifestHashAnnotation], "specHash not matching for Testcase %s", testName) assert.Equalf(t, ownerRef, applyResult.GetOwnerReferences()[0], "ownerRef not matching for Testcase %s", testName) } @@ -966,7 +966,7 @@ func createObjAndDynamicClient(rawManifest []byte) (*unstructured.Unstructured, uObj := unstructured.Unstructured{} _ = uObj.UnmarshalJSON(rawManifest) validSpecHash, _ := computeManifestHash(&uObj) - uObj.SetAnnotations(map[string]string{manifestHashAnnotation: validSpecHash}) + uObj.SetAnnotations(map[string]string{ManifestHashAnnotation: validSpecHash}) _ = setModifiedConfigurationAnnotation(&uObj) dynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) dynamicClient.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { From 7dfff4a9a8522be6016ed3b17a26cb28e1083afb Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 9 May 2023 09:29:33 -0700 Subject: [PATCH 28/42] fix integration --- pkg/controllers/work/apply_controller_integration_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/controllers/work/apply_controller_integration_test.go b/pkg/controllers/work/apply_controller_integration_test.go index 195d10f28..c21db5564 100644 --- a/pkg/controllers/work/apply_controller_integration_test.go +++ b/pkg/controllers/work/apply_controller_integration_test.go @@ -509,13 +509,13 @@ var _ = Describe("Work Controller", func() { appliedCM := verifyAppliedConfigMap(cm) By("Delete the last applied annotation from the current resource") - delete(appliedCM.Annotations, lastAppliedConfigAnnotation) + delete(appliedCM.Annotations, LastAppliedConfigAnnotation) Expect(k8sClient.Update(ctx, appliedCM)).Should(Succeed()) By("Get the last applied config map and verify it does not have the last applied annotation") var modifiedCM corev1.ConfigMap Expect(k8sClient.Get(ctx, types.NamespacedName{Name: cm.GetName(), Namespace: cm.GetNamespace()}, &modifiedCM)).Should(Succeed()) - Expect(modifiedCM.Annotations[lastAppliedConfigAnnotation]).Should(BeEmpty()) + Expect(modifiedCM.Annotations[LastAppliedConfigAnnotation]).Should(BeEmpty()) By("Modify the manifest") // modify one data From f70588d91fb07acb2c842540c889b6ed220882e2 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 9 May 2023 10:04:30 -0700 Subject: [PATCH 29/42] update comment --- test/e2e/work_load_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/e2e/work_load_test.go b/test/e2e/work_load_test.go index b8b1dbd59..c90ec1384 100644 --- a/test/e2e/work_load_test.go +++ b/test/e2e/work_load_test.go @@ -29,7 +29,7 @@ var _ = Describe("workload orchestration testing", func() { crp *v1alpha1.ClusterResourcePlacement labelKey = "fleet.azure.com/name" labelValue = "test" - // Ignoring typeMeta to get the tests to pass, not sure why. + // Ignoring typeMeta to get the tests to pass, it because on Create and Get Type Meta is not populated but it gets populated on Update. resourceIgnoreOptions = []cmp.Option{cmpopts.IgnoreFields(metav1.ObjectMeta{}, "ResourceVersion", "UID", "Annotations", "CreationTimestamp", "ManagedFields"), cmpopts.IgnoreFields(metav1.OwnerReference{}, "UID"), cmpopts.IgnoreFields(metav1.TypeMeta{}, "Kind", "APIVersion")} ) From b4924d376655936dbd65f98c93a144c387903b57 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 16 May 2023 17:55:49 -0700 Subject: [PATCH 30/42] improve comment --- test/e2e/work_load_test.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/test/e2e/work_load_test.go b/test/e2e/work_load_test.go index c90ec1384..5eb125e72 100644 --- a/test/e2e/work_load_test.go +++ b/test/e2e/work_load_test.go @@ -29,7 +29,7 @@ var _ = Describe("workload orchestration testing", func() { crp *v1alpha1.ClusterResourcePlacement labelKey = "fleet.azure.com/name" labelValue = "test" - // Ignoring typeMeta to get the tests to pass, it because on Create and Get Type Meta is not populated but it gets populated on Update. + // Ignoring typeMeta to get the tests to pass, because on Create and Get Type Meta is not populated but it gets populated on Update. Known issue: https://github.com/kubernetes-sigs/controller-runtime/issues/1735 resourceIgnoreOptions = []cmp.Option{cmpopts.IgnoreFields(metav1.ObjectMeta{}, "ResourceVersion", "UID", "Annotations", "CreationTimestamp", "ManagedFields"), cmpopts.IgnoreFields(metav1.OwnerReference{}, "UID"), cmpopts.IgnoreFields(metav1.TypeMeta{}, "Kind", "APIVersion")} ) @@ -425,20 +425,20 @@ var _ = Describe("workload orchestration testing", func() { By("update secret so that it's small again") // Using a new variable to prevent failure, leads to 409 if not. - var smallSecret corev1.Secret - err = pkgutils.GetObjectFromManifest("./test/integration/manifests/resources/test-small-secret.yaml", &smallSecret) + var initialSmallSecret corev1.Secret + err = pkgutils.GetObjectFromManifest("./test/integration/manifests/resources/test-small-secret.yaml", &initialSmallSecret) Expect(err).Should(Succeed()) Eventually(func() error { - if err := HubCluster.KubeClient.Update(ctx, &smallSecret); err != nil { + if err := HubCluster.KubeClient.Update(ctx, &initialSmallSecret); err != nil { return err } return nil }, utils.PollTimeout, utils.PollInterval).Should(Succeed(), "Failed to update secret to be small in %s cluster", HubCluster.ClusterName) - expectedSecret = &smallSecret + expectedSecret = &initialSmallSecret expectedSecret.OwnerReferences = ownerReferences // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. - gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: smallSecret.Name, Namespace: smallSecret.Namespace}, expectedSecret, resourceIgnoreOptions) + gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: initialSmallSecret.Name, Namespace: initialSmallSecret.Namespace}, expectedSecret, resourceIgnoreOptions) Expect(gotSecret.Annotations[workcontroller.LastAppliedConfigAnnotation]).ToNot(BeEmpty()) Expect(gotSecret.Annotations[workcontroller.ManifestHashAnnotation]).To(Equal(testSmallSecretSpecHash)) From 103556a10e1e3d66fec2ab3b3f82bcb0c9677273 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Tue, 16 May 2023 18:02:30 -0700 Subject: [PATCH 31/42] add period for comments --- pkg/controllers/work/apply_controller.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index a27805dea..ef45fe17b 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -401,9 +401,9 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // We only try to update the object if its spec hash value has changed. if manifestObj.GetAnnotations()[ManifestHashAnnotation] != curObj.GetAnnotations()[ManifestHashAnnotation] { // we need to merge the owner reference between the current and the manifest since we support one manifest - // belong to multiple work so it contains the union of all the appliedWork + // belong to multiple work so it contains the union of all the appliedWork. manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) - // record the raw manifest with the hash annotation in the manifest + // record the raw manifest with the hash annotation in the manifest. if err = setModifiedConfigurationAnnotation(manifestObj); err != nil { return nil, ManifestNoChangeAction, err } From d8a8436b648b3aaa3eff199c0cd81a87e281991a Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 29 May 2023 16:41:28 -0700 Subject: [PATCH 32/42] address comments --- pkg/controllers/work/apply_controller.go | 23 ++------ pkg/controllers/work/patch_util.go | 17 +++++- test/e2e/work_load_test.go | 75 +++++++++++++----------- 3 files changed, 61 insertions(+), 54 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index ef45fe17b..162e00244 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -27,7 +27,6 @@ import ( v1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" - "k8s.io/apimachinery/pkg/api/validation" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime/schema" @@ -358,15 +357,6 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { return nil, ManifestNoChangeAction, err } - annotations := manifestObj.GetAnnotations() - klog.V(2).InfoS("validating annotation size for manifest", - "gvr", gvr, "manifest", manifestRef) - if err := validation.ValidateAnnotationsSize(annotations); err != nil { - klog.InfoS(fmt.Sprintf("not using three way merge for manifest removing last applied config annotation, %s", err), - "gvr", gvr, "obj", manifestRef) - annotations[LastAppliedConfigAnnotation] = "" - manifestObj.SetAnnotations(annotations) - } actual, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Create( ctx, manifestObj, metav1.CreateOptions{FieldManager: workFieldManagerName}) if err == nil { @@ -408,15 +398,11 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. return nil, ManifestNoChangeAction, err } annotations := manifestObj.GetAnnotations() - klog.V(2).InfoS("validating annotation size for manifest", - "gvr", gvr, "manifest", manifestRef) - if err = validation.ValidateAnnotationsSize(annotations); err != nil { - klog.ErrorS(err, "not using three way merge for manifest removing last applied config annotation", - "gvr", gvr, "obj", manifestRef) - annotations[LastAppliedConfigAnnotation] = "" - manifestObj.SetAnnotations(annotations) - return r.applyObject(ctx, gvr, manifestObj) + if annotations[LastAppliedConfigAnnotation] == "" { + klog.V(2).InfoS("using server side apply for manifest", "gvr", gvr, "manifest", manifestRef) + r.applyObject(ctx, gvr, manifestObj) } + klog.V(2).InfoS("using three way merge for manifest", "gvr", gvr, "manifest", manifestRef) return r.patchCurrentResource(ctx, gvr, manifestObj, curObj) } @@ -576,6 +562,7 @@ func computeManifestHash(obj *unstructured.Unstructured) (string, error) { manifest.SetSelfLink("") manifest.SetDeletionTimestamp(nil) manifest.SetManagedFields(nil) + manifest.SetOwnerReferences(nil) unstructured.RemoveNestedField(manifest.Object, "metadata", "creationTimestamp") unstructured.RemoveNestedField(manifest.Object, "status") // compute the sha256 hash of the remaining data diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index 3742a283f..c810bca04 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -5,6 +5,7 @@ import ( "fmt" "k8s.io/apimachinery/pkg/api/meta" + "k8s.io/apimachinery/pkg/api/validation" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/jsonmergepatch" @@ -106,7 +107,21 @@ func setModifiedConfigurationAnnotation(obj runtime.Object) error { } // set the last applied annotation back annotations[LastAppliedConfigAnnotation] = string(modified) - return metadataAccessor.SetAnnotations(obj, annotations) + if err = metadataAccessor.SetAnnotations(obj, annotations); err != nil { + return err + } + annotations, err = metadataAccessor.Annotations(obj) + if err != nil { + return err + } + if err := validation.ValidateAnnotationsSize(annotations); err != nil { + klog.InfoS(fmt.Sprintf("setting last applied config annotation to empty, %s", err)) + annotations[LastAppliedConfigAnnotation] = "" + if err = metadataAccessor.SetAnnotations(obj, annotations); err != nil { + return err + } + } + return nil } // getOriginalConfiguration gets original configuration of the object diff --git a/test/e2e/work_load_test.go b/test/e2e/work_load_test.go index 5eb125e72..2b9830aae 100644 --- a/test/e2e/work_load_test.go +++ b/test/e2e/work_load_test.go @@ -19,7 +19,7 @@ import ( workapi "sigs.k8s.io/work-api/pkg/apis/v1alpha1" "go.goms.io/fleet/apis/v1alpha1" - workcontroller "go.goms.io/fleet/pkg/controllers/work" + pkgwork "go.goms.io/fleet/pkg/controllers/work" pkgutils "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/test/e2e/utils" ) @@ -34,6 +34,11 @@ var _ = Describe("workload orchestration testing", func() { cmpopts.IgnoreFields(metav1.OwnerReference{}, "UID"), cmpopts.IgnoreFields(metav1.TypeMeta{}, "Kind", "APIVersion")} ) + const ( + smallSecretSpecHash = "16b6e8df987984815959a61a429a20de6c5271cf3d8cf0e5450bc621768be4cf" + largeSecretSpecHash = "c984ffbb45374f70ae42d74aa12ce9667b5284feda69378350cea64d1fd4c5ab" + ) + Context("Test Workload Orchestration", func() { It("Apply CRP and check if cluster role gets propagated, update cluster role", func() { By("create the resources to be propagated") @@ -108,9 +113,9 @@ var _ = Describe("workload orchestration testing", func() { Name: crp.Name, }, } - expectedClusterRole := clusterRole - expectedClusterRole.OwnerReferences = ownerReferences - utils.CmpClusterRole(ctx, *MemberCluster, &types.NamespacedName{Name: clusterRole.Name}, expectedClusterRole, resourceIgnoreOptions) + wantClusterRole := clusterRole + wantClusterRole.OwnerReferences = ownerReferences + utils.CmpClusterRole(ctx, *MemberCluster, &types.NamespacedName{Name: clusterRole.Name}, wantClusterRole, resourceIgnoreOptions) By("update cluster role in Hub cluster") rules := []rbacv1.PolicyRule{ @@ -130,7 +135,7 @@ var _ = Describe("workload orchestration testing", func() { Expect(HubCluster.KubeClient.Update(ctx, updatedClusterRole)).Should(Succeed(), "Failed to update cluster role %s in %s cluster", updatedClusterRole.Name, HubCluster.ClusterName) By("check if cluster role got updated in member cluster") - expectedClusterRole = &rbacv1.ClusterRole{ + wantClusterRole = &rbacv1.ClusterRole{ ObjectMeta: metav1.ObjectMeta{ Name: "test-cluster-role", Labels: updatedClusterRole.Labels, @@ -138,7 +143,7 @@ var _ = Describe("workload orchestration testing", func() { }, Rules: rules, } - utils.CmpClusterRole(ctx, *MemberCluster, &types.NamespacedName{Name: clusterRole.Name}, expectedClusterRole, resourceIgnoreOptions) + utils.CmpClusterRole(ctx, *MemberCluster, &types.NamespacedName{Name: clusterRole.Name}, wantClusterRole, resourceIgnoreOptions) By("delete cluster role on hub cluster") Expect(HubCluster.KubeClient.Delete(ctx, clusterRole)).Should(Succeed(), "Failed to delete cluster role %s in %s cluster", clusterRole.Name, HubCluster.ClusterName) @@ -275,15 +280,15 @@ var _ = Describe("workload orchestration testing", func() { Name: crp.Name, }, } - expectedNamespace := namespace1 - expectedRole := role - expectedRoleBinding := roleBinding - expectedNamespace.OwnerReferences = ownerReferences - expectedRole.OwnerReferences = ownerReferences - expectedRoleBinding.OwnerReferences = ownerReferences - utils.CmpNamespace(ctx, *MemberCluster, &types.NamespacedName{Name: namespace1.Name}, expectedNamespace, resourceIgnoreOptions) - utils.CmpRole(ctx, *MemberCluster, &types.NamespacedName{Name: role.Name, Namespace: role.Namespace}, expectedRole, resourceIgnoreOptions) - utils.CmpRoleBinding(ctx, *MemberCluster, &types.NamespacedName{Name: roleBinding.Name, Namespace: roleBinding.Namespace}, expectedRoleBinding, resourceIgnoreOptions) + wantNamespace := namespace1 + wantRole := role + wantRoleBinding := roleBinding + wantNamespace.OwnerReferences = ownerReferences + wantRole.OwnerReferences = ownerReferences + wantRoleBinding.OwnerReferences = ownerReferences + utils.CmpNamespace(ctx, *MemberCluster, &types.NamespacedName{Name: namespace1.Name}, wantNamespace, resourceIgnoreOptions) + utils.CmpRole(ctx, *MemberCluster, &types.NamespacedName{Name: role.Name, Namespace: role.Namespace}, wantRole, resourceIgnoreOptions) + utils.CmpRoleBinding(ctx, *MemberCluster, &types.NamespacedName{Name: roleBinding.Name, Namespace: roleBinding.Namespace}, wantRoleBinding, resourceIgnoreOptions) By("check if namespace not selected by CRP doesn't exist on member cluster") Consistently(func() bool { @@ -306,10 +311,10 @@ var _ = Describe("workload orchestration testing", func() { Rules: rules, } Expect(HubCluster.KubeClient.Update(ctx, updatedRole)).Should(Succeed(), "Failed to update role %s in %s cluster", updatedRole.Name, HubCluster.ClusterName) - expectedRole.Rules = rules + wantRole.Rules = rules By("check if role got updated in member cluster") - utils.CmpRole(ctx, *MemberCluster, &types.NamespacedName{Name: role.Name, Namespace: role.Namespace}, expectedRole, resourceIgnoreOptions) + utils.CmpRole(ctx, *MemberCluster, &types.NamespacedName{Name: role.Name, Namespace: role.Namespace}, wantRole, resourceIgnoreOptions) By("delete namespaces") utils.DeleteNamespace(ctx, *HubCluster, namespace1) @@ -398,16 +403,16 @@ var _ = Describe("workload orchestration testing", func() { Name: crp.Name, }, } - expectedNamespace := namespace - expectedSecret := &testSmallSecret - expectedNamespace.OwnerReferences = ownerReferences - expectedSecret.OwnerReferences = ownerReferences + wantNamespace := namespace + wantSecret := &testSmallSecret + wantNamespace.OwnerReferences = ownerReferences + wantSecret.OwnerReferences = ownerReferences - utils.CmpNamespace(ctx, *MemberCluster, &types.NamespacedName{Name: namespace.Name}, expectedNamespace, resourceIgnoreOptions) + utils.CmpNamespace(ctx, *MemberCluster, &types.NamespacedName{Name: namespace.Name}, wantNamespace, resourceIgnoreOptions) // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. - gotSecret := utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testSmallSecret.Name, Namespace: testSmallSecret.Namespace}, expectedSecret, resourceIgnoreOptions) - Expect(gotSecret.Annotations[workcontroller.LastAppliedConfigAnnotation]).To(Not(BeEmpty())) - testSmallSecretSpecHash := gotSecret.Annotations[workcontroller.ManifestHashAnnotation] + gotSecret := utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testSmallSecret.Name, Namespace: testSmallSecret.Namespace}, wantSecret, resourceIgnoreOptions) + Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).To(Not(BeEmpty())) + Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).To(Equal(smallSecretSpecHash)) By("update secret so that annotation limit crosses threshold of 256KB") var testLargeSecret corev1.Secret @@ -415,13 +420,13 @@ var _ = Describe("workload orchestration testing", func() { Expect(err).Should(Succeed()) // testLargeSecret has the same name as testSmallSecret Expect(HubCluster.KubeClient.Update(ctx, &testLargeSecret)).Should(Succeed(), "Failed to update secret %s to be large in %s cluster", testLargeSecret.Name, HubCluster.ClusterName) - expectedSecret = &testLargeSecret - expectedSecret.OwnerReferences = ownerReferences + wantSecret = &testLargeSecret + wantSecret.OwnerReferences = ownerReferences // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. - gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testLargeSecret.Name, Namespace: testLargeSecret.Namespace}, expectedSecret, resourceIgnoreOptions) - Expect(gotSecret.Annotations[workcontroller.LastAppliedConfigAnnotation]).To(BeEmpty()) - Expect(gotSecret.Annotations[workcontroller.ManifestHashAnnotation]).ToNot(Equal(testSmallSecretSpecHash)) + gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testLargeSecret.Name, Namespace: testLargeSecret.Namespace}, wantSecret, resourceIgnoreOptions) + Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).To(BeEmpty()) + Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).To(Equal(largeSecretSpecHash)) By("update secret so that it's small again") // Using a new variable to prevent failure, leads to 409 if not. @@ -434,13 +439,13 @@ var _ = Describe("workload orchestration testing", func() { } return nil }, utils.PollTimeout, utils.PollInterval).Should(Succeed(), "Failed to update secret to be small in %s cluster", HubCluster.ClusterName) - expectedSecret = &initialSmallSecret - expectedSecret.OwnerReferences = ownerReferences + wantSecret = &initialSmallSecret + wantSecret.OwnerReferences = ownerReferences // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. - gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: initialSmallSecret.Name, Namespace: initialSmallSecret.Namespace}, expectedSecret, resourceIgnoreOptions) - Expect(gotSecret.Annotations[workcontroller.LastAppliedConfigAnnotation]).ToNot(BeEmpty()) - Expect(gotSecret.Annotations[workcontroller.ManifestHashAnnotation]).To(Equal(testSmallSecretSpecHash)) + gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: initialSmallSecret.Name, Namespace: initialSmallSecret.Namespace}, wantSecret, resourceIgnoreOptions) + Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).ToNot(BeEmpty()) + Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).To(Equal(smallSecretSpecHash)) By("delete namespaces") utils.DeleteNamespace(ctx, *HubCluster, namespace) From f2bede544811f49905a12dcf3446d9a26a312192 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 29 May 2023 19:46:18 -0700 Subject: [PATCH 33/42] fix UT, add comment --- pkg/controllers/work/apply_controller.go | 3 +-- pkg/controllers/work/apply_controller_test.go | 1 + test/e2e/work_load_test.go | 20 ++++++++----------- 3 files changed, 10 insertions(+), 14 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 162e00244..e969020ac 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -400,7 +400,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. annotations := manifestObj.GetAnnotations() if annotations[LastAppliedConfigAnnotation] == "" { klog.V(2).InfoS("using server side apply for manifest", "gvr", gvr, "manifest", manifestRef) - r.applyObject(ctx, gvr, manifestObj) + return r.applyObject(ctx, gvr, manifestObj) } klog.V(2).InfoS("using three way merge for manifest", "gvr", gvr, "manifest", manifestRef) return r.patchCurrentResource(ctx, gvr, manifestObj, curObj) @@ -562,7 +562,6 @@ func computeManifestHash(obj *unstructured.Unstructured) (string, error) { manifest.SetSelfLink("") manifest.SetDeletionTimestamp(nil) manifest.SetManagedFields(nil) - manifest.SetOwnerReferences(nil) unstructured.RemoveNestedField(manifest.Object, "metadata", "creationTimestamp") unstructured.RemoveNestedField(manifest.Object, "status") // compute the sha256 hash of the remaining data diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index 844d2ad8e..de1fd830c 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -514,6 +514,7 @@ func TestApplyUnstructured(t *testing.T) { } else { assert.Truef(t, err == nil, "err is not nil for Testcase %s", testName) assert.Truef(t, applyResult != nil, "applyResult is not nil for Testcase %s", testName) + // Not checking last applied config because it has live fields. assert.Equalf(t, testCase.resultSpecHash, applyResult.GetAnnotations()[ManifestHashAnnotation], "specHash not matching for Testcase %s", testName) assert.Equalf(t, ownerRef, applyResult.GetOwnerReferences()[0], "ownerRef not matching for Testcase %s", testName) diff --git a/test/e2e/work_load_test.go b/test/e2e/work_load_test.go index 2b9830aae..28463f37f 100644 --- a/test/e2e/work_load_test.go +++ b/test/e2e/work_load_test.go @@ -16,7 +16,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/utils/pointer" - workapi "sigs.k8s.io/work-api/pkg/apis/v1alpha1" + workapiv1alpha1 "sigs.k8s.io/work-api/pkg/apis/v1alpha1" "go.goms.io/fleet/apis/v1alpha1" pkgwork "go.goms.io/fleet/pkg/controllers/work" @@ -34,11 +34,6 @@ var _ = Describe("workload orchestration testing", func() { cmpopts.IgnoreFields(metav1.OwnerReference{}, "UID"), cmpopts.IgnoreFields(metav1.TypeMeta{}, "Kind", "APIVersion")} ) - const ( - smallSecretSpecHash = "16b6e8df987984815959a61a429a20de6c5271cf3d8cf0e5450bc621768be4cf" - largeSecretSpecHash = "c984ffbb45374f70ae42d74aa12ce9667b5284feda69378350cea64d1fd4c5ab" - ) - Context("Test Workload Orchestration", func() { It("Apply CRP and check if cluster role gets propagated, update cluster role", func() { By("create the resources to be propagated") @@ -107,7 +102,7 @@ var _ = Describe("workload orchestration testing", func() { By("check if cluster role is propagated to member cluster") ownerReferences := []metav1.OwnerReference{ { - APIVersion: workapi.GroupVersion.String(), + APIVersion: workapiv1alpha1.GroupVersion.String(), BlockOwnerDeletion: pointer.Bool(false), Kind: "AppliedWork", Name: crp.Name, @@ -274,7 +269,7 @@ var _ = Describe("workload orchestration testing", func() { By("check if resources in namespace are propagated to member cluster") ownerReferences := []metav1.OwnerReference{ { - APIVersion: workapi.GroupVersion.String(), + APIVersion: workapiv1alpha1.GroupVersion.String(), BlockOwnerDeletion: pointer.Bool(false), Kind: "AppliedWork", Name: crp.Name, @@ -397,7 +392,7 @@ var _ = Describe("workload orchestration testing", func() { By("check if resources in namespace are propagated to member cluster") ownerReferences := []metav1.OwnerReference{ { - APIVersion: workapi.GroupVersion.String(), + APIVersion: workapiv1alpha1.GroupVersion.String(), BlockOwnerDeletion: pointer.Bool(false), Kind: "AppliedWork", Name: crp.Name, @@ -412,7 +407,8 @@ var _ = Describe("workload orchestration testing", func() { // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. gotSecret := utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testSmallSecret.Name, Namespace: testSmallSecret.Namespace}, wantSecret, resourceIgnoreOptions) Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).To(Not(BeEmpty())) - Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).To(Equal(smallSecretSpecHash)) + // Not checking spec hash equals some value because ObjectMeta.OwnerReferences has some live fields. + testSmallSecretSpecHash := gotSecret.Annotations[pkgwork.ManifestHashAnnotation] By("update secret so that annotation limit crosses threshold of 256KB") var testLargeSecret corev1.Secret @@ -426,7 +422,7 @@ var _ = Describe("workload orchestration testing", func() { // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testLargeSecret.Name, Namespace: testLargeSecret.Namespace}, wantSecret, resourceIgnoreOptions) Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).To(BeEmpty()) - Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).To(Equal(largeSecretSpecHash)) + Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).ToNot(Equal(testSmallSecretSpecHash)) By("update secret so that it's small again") // Using a new variable to prevent failure, leads to 409 if not. @@ -445,7 +441,7 @@ var _ = Describe("workload orchestration testing", func() { // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: initialSmallSecret.Name, Namespace: initialSmallSecret.Namespace}, wantSecret, resourceIgnoreOptions) Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).ToNot(BeEmpty()) - Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).To(Equal(smallSecretSpecHash)) + Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).To(Equal(testSmallSecretSpecHash)) By("delete namespaces") utils.DeleteNamespace(ctx, *HubCluster, namespace) From 4d436f9d7ab31ed955e33920b46f64aaf44ac8f2 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 29 May 2023 19:53:02 -0700 Subject: [PATCH 34/42] add period --- test/e2e/work_load_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/e2e/work_load_test.go b/test/e2e/work_load_test.go index 28463f37f..319263b0e 100644 --- a/test/e2e/work_load_test.go +++ b/test/e2e/work_load_test.go @@ -414,7 +414,7 @@ var _ = Describe("workload orchestration testing", func() { var testLargeSecret corev1.Secret err = pkgutils.GetObjectFromManifest("./test/integration/manifests/resources/test-large-secret.yaml", &testLargeSecret) Expect(err).Should(Succeed()) - // testLargeSecret has the same name as testSmallSecret + // testLargeSecret has the same name as testSmallSecret. Expect(HubCluster.KubeClient.Update(ctx, &testLargeSecret)).Should(Succeed(), "Failed to update secret %s to be large in %s cluster", testLargeSecret.Name, HubCluster.ClusterName) wantSecret = &testLargeSecret wantSecret.OwnerReferences = ownerReferences From 38fdab3c1994c759044f551502160e814cf114c6 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Wed, 31 May 2023 13:15:50 -0700 Subject: [PATCH 35/42] add UTs --- pkg/controllers/work/apply_controller_test.go | 64 +++++++++++++++---- 1 file changed, 53 insertions(+), 11 deletions(-) diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index de1fd830c..1d2d1f2e1 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -307,7 +307,7 @@ func TestApplyUnstructured(t *testing.T) { dynamicClientNotFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) dynamicClientNotFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { - return false, + return true, nil, &apierrors.StatusError{ ErrStatus: metav1.Status{ @@ -368,9 +368,9 @@ func TestApplyUnstructured(t *testing.T) { largeObjSpecHash, _ := computeManifestHash(&largeObj) largeObj.SetAnnotations(map[string]string{ManifestHashAnnotation: largeObjSpecHash}) - applyDynamicClientNotFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) - applyDynamicClientNotFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { - return false, + dynamicClientLargeObjNotFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) + dynamicClientLargeObjNotFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return true, nil, &apierrors.StatusError{ ErrStatus: metav1.Status{ @@ -378,7 +378,7 @@ func TestApplyUnstructured(t *testing.T) { Reason: metav1.StatusReasonNotFound, }} }) - applyDynamicClientNotFound.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + dynamicClientLargeObjNotFound.PrependReactor("create", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, largeObj.DeepCopy(), nil }) @@ -386,14 +386,36 @@ func TestApplyUnstructured(t *testing.T) { updatedLargeObjSpecHash, _ := computeManifestHash(updatedLargeObj) updatedLargeObj.SetAnnotations(map[string]string{ManifestHashAnnotation: updatedLargeObjSpecHash}) - applyDynamicClientFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) - applyDynamicClientFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + dynamicClientLargeObjFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) + dynamicClientLargeObjFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, largeObj.DeepCopy(), nil }) - applyDynamicClientFound.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + dynamicClientLargeObjFound.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, updatedLargeObj.DeepCopy(), nil }) + dynamicClientLargeObjCreateFail := fake.NewSimpleDynamicClient(runtime.NewScheme()) + dynamicClientLargeObjCreateFail.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return true, + nil, + &apierrors.StatusError{ + ErrStatus: metav1.Status{ + Status: metav1.StatusFailure, + Reason: metav1.StatusReasonNotFound, + }} + }) + dynamicClientLargeObjCreateFail.PrependReactor("create", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return true, nil, errors.New("create error") + }) + + dynamicClientLargeObjApplyFail := fake.NewSimpleDynamicClient(runtime.NewScheme()) + dynamicClientLargeObjApplyFail.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return true, largeObj.DeepCopy(), nil + }) + dynamicClientLargeObjApplyFail.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + return true, nil, errors.New("apply error") + }) + testCases := map[string]struct { reconciler ApplyWorkReconciler workObj *unstructured.Unstructured @@ -481,9 +503,9 @@ func TestApplyUnstructured(t *testing.T) { resultAction: ManifestUpdatedAction, resultErr: nil, }, - "test apply succeeds for large manifest when object does not exist": { + "test create succeeds for large manifest when object does not exist": { reconciler: ApplyWorkReconciler{ - spokeDynamicClient: applyDynamicClientNotFound, + spokeDynamicClient: dynamicClientLargeObjNotFound, restMapper: testMapper{}, recorder: utils.NewFakeRecorder(1), }, @@ -494,7 +516,7 @@ func TestApplyUnstructured(t *testing.T) { }, "test apply succeeds on update for large manifest when object exists": { reconciler: ApplyWorkReconciler{ - spokeDynamicClient: applyDynamicClientFound, + spokeDynamicClient: dynamicClientLargeObjFound, restMapper: testMapper{}, recorder: utils.NewFakeRecorder(1), }, @@ -503,6 +525,26 @@ func TestApplyUnstructured(t *testing.T) { resultAction: ManifestAppliedAction, resultErr: nil, }, + "test create fails for large manifest when object does not exist": { + reconciler: ApplyWorkReconciler{ + spokeDynamicClient: dynamicClientLargeObjCreateFail, + restMapper: testMapper{}, + recorder: utils.NewFakeRecorder(1), + }, + workObj: &largeObj, + resultAction: ManifestNoChangeAction, + resultErr: errors.New("create error"), + }, + "test apply fails for large manifest when object exists": { + reconciler: ApplyWorkReconciler{ + spokeDynamicClient: dynamicClientLargeObjApplyFail, + restMapper: testMapper{}, + recorder: utils.NewFakeRecorder(1), + }, + workObj: updatedLargeObj, + resultAction: ManifestNoChangeAction, + resultErr: errors.New("apply error"), + }, } for testName, testCase := range testCases { From d7b29e0846586fcbbce4cc1a171a33cbb7d8c452 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Wed, 31 May 2023 13:49:00 -0700 Subject: [PATCH 36/42] address comments --- pkg/controllers/work/apply_controller.go | 2 +- pkg/controllers/work/apply_controller_test.go | 12 +++++++++--- pkg/controllers/work/patch_util.go | 15 ++++----------- 3 files changed, 14 insertions(+), 15 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index e969020ac..b7244d28d 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -394,7 +394,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // belong to multiple work so it contains the union of all the appliedWork. manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) // record the raw manifest with the hash annotation in the manifest. - if err = setModifiedConfigurationAnnotation(manifestObj); err != nil { + if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { return nil, ManifestNoChangeAction, err } annotations := manifestObj.GetAnnotations() diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index 1d2d1f2e1..6c8902c56 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -360,12 +360,15 @@ func TestApplyUnstructured(t *testing.T) { t.Errorf("failed to marshal secret: %s", err) } var largeObj unstructured.Unstructured - if err = largeObj.UnmarshalJSON(rawSecret); err != nil { + if err := largeObj.UnmarshalJSON(rawSecret); err != nil { t.Errorf("failed to unmarshal JSON: %s", err) } updatedLargeObj := largeObj.DeepCopy() - largeObjSpecHash, _ := computeManifestHash(&largeObj) + largeObjSpecHash, err := computeManifestHash(&largeObj) + if err != nil { + t.Errorf("failed to compute manifest hash: %s", err) + } largeObj.SetAnnotations(map[string]string{ManifestHashAnnotation: largeObjSpecHash}) dynamicClientLargeObjNotFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) @@ -383,7 +386,10 @@ func TestApplyUnstructured(t *testing.T) { }) updatedLargeObj.SetLabels(map[string]string{"test-label-key": "test-label"}) - updatedLargeObjSpecHash, _ := computeManifestHash(updatedLargeObj) + updatedLargeObjSpecHash, err := computeManifestHash(updatedLargeObj) + if err != nil { + t.Errorf("failed to compute manifest hash: %s", err) + } updatedLargeObj.SetAnnotations(map[string]string{ManifestHashAnnotation: updatedLargeObjSpecHash}) dynamicClientLargeObjFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index c810bca04..9915a252c 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -107,19 +107,12 @@ func setModifiedConfigurationAnnotation(obj runtime.Object) error { } // set the last applied annotation back annotations[LastAppliedConfigAnnotation] = string(modified) - if err = metadataAccessor.SetAnnotations(obj, annotations); err != nil { - return err - } - annotations, err = metadataAccessor.Annotations(obj) - if err != nil { - return err - } if err := validation.ValidateAnnotationsSize(annotations); err != nil { - klog.InfoS(fmt.Sprintf("setting last applied config annotation to empty, %s", err)) + klog.V(2).InfoS(fmt.Sprintf("setting last applied config annotation to empty, %s", err)) annotations[LastAppliedConfigAnnotation] = "" - if err = metadataAccessor.SetAnnotations(obj, annotations); err != nil { - return err - } + } + if err = metadataAccessor.SetAnnotations(obj, annotations); err != nil { + return err } return nil } From 32a51c830a5844027ddc330eee6279344e06854d Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Wed, 31 May 2023 13:59:37 -0700 Subject: [PATCH 37/42] fix comment --- pkg/controllers/work/patch_util.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index 9915a252c..d3904d39a 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -79,7 +79,8 @@ func threeWayMergePatch(currentObj, manifestObj client.Object) (client.Patch, er // setModifiedConfigurationAnnotation serializes the object into byte stream. // If `updateAnnotation` is true, it embeds the result as an annotation in the -// modified configuration. +// modified configuration. If the annotation size is greater than 256 kB it sets +// to empty string. func setModifiedConfigurationAnnotation(obj runtime.Object) error { var modified []byte annotations, err := metadataAccessor.Annotations(obj) From cf063fd408a0d8e726a41c4cfaa436e3166c3d85 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Wed, 31 May 2023 14:08:42 -0700 Subject: [PATCH 38/42] fix comment --- pkg/controllers/work/patch_util.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index d3904d39a..4c22bbb75 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -79,7 +79,7 @@ func threeWayMergePatch(currentObj, manifestObj client.Object) (client.Patch, er // setModifiedConfigurationAnnotation serializes the object into byte stream. // If `updateAnnotation` is true, it embeds the result as an annotation in the -// modified configuration. If the annotation size is greater than 256 kB it sets +// modified configuration. If annotations size is greater than 256 kB it sets // to empty string. func setModifiedConfigurationAnnotation(obj runtime.Object) error { var modified []byte From d19b99dd6696cb61982560ebdb4ddb237cb8b000 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Wed, 7 Jun 2023 09:45:10 -0700 Subject: [PATCH 39/42] address comments --- pkg/controllers/work/apply_controller.go | 2 +- pkg/controllers/work/patch_util.go | 5 +---- pkg/utils/test_util.go | 5 +---- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index b7244d28d..58552a348 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -391,7 +391,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // We only try to update the object if its spec hash value has changed. if manifestObj.GetAnnotations()[ManifestHashAnnotation] != curObj.GetAnnotations()[ManifestHashAnnotation] { // we need to merge the owner reference between the current and the manifest since we support one manifest - // belong to multiple work so it contains the union of all the appliedWork. + // belong to multiple work, so it contains the union of all the appliedWork. manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) // record the raw manifest with the hash annotation in the manifest. if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index 4c22bbb75..b30d552e4 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -112,10 +112,7 @@ func setModifiedConfigurationAnnotation(obj runtime.Object) error { klog.V(2).InfoS(fmt.Sprintf("setting last applied config annotation to empty, %s", err)) annotations[LastAppliedConfigAnnotation] = "" } - if err = metadataAccessor.SetAnnotations(obj, annotations); err != nil { - return err - } - return nil + return metadataAccessor.SetAnnotations(obj, annotations) } // getOriginalConfiguration gets original configuration of the object diff --git a/pkg/utils/test_util.go b/pkg/utils/test_util.go index 23156a70d..4adb45093 100644 --- a/pkg/utils/test_util.go +++ b/pkg/utils/test_util.go @@ -53,10 +53,7 @@ func GetObjectFromRawExtension(rawByte []byte, obj runtime.Object) error { if err != nil { return err } - if err = runtime.DecodeInto(genericCodec, json, obj); err != nil { - return err - } - return nil + return runtime.DecodeInto(genericCodec, json, obj) } // GetObjectFromManifest returns a runtime object decoded from the file. From 5f8ddf01b1c641971f63e575b4c66238377c9e7e Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Thu, 8 Jun 2023 11:56:16 -0700 Subject: [PATCH 40/42] address comments --- pkg/controllers/work/apply_controller.go | 36 +++--- .../work/apply_controller_helper_test.go | 4 +- .../work/apply_controller_integration_test.go | 4 +- pkg/controllers/work/apply_controller_test.go | 111 ++++++++++++------ pkg/controllers/work/manager.go | 4 +- pkg/controllers/work/patch_util.go | 20 ++-- pkg/controllers/work/patch_util_test.go | 45 +++++++ test/e2e/work_api_e2e_test.go | 4 +- test/e2e/work_load_test.go | 23 ++-- 9 files changed, 162 insertions(+), 89 deletions(-) create mode 100644 pkg/controllers/work/patch_util_test.go diff --git a/pkg/controllers/work/apply_controller.go b/pkg/controllers/work/apply_controller.go index 58552a348..f6c590901 100644 --- a/pkg/controllers/work/apply_controller.go +++ b/pkg/controllers/work/apply_controller.go @@ -86,11 +86,11 @@ const ( // ManifestCreatedAction indicates that we created the manifest for the first time. ManifestCreatedAction applyAction = "ManifestCreated" - // ManifestUpdatedAction indicates that we updated the manifest. - ManifestUpdatedAction applyAction = "ManifestUpdated" + // ManifestThreeWayMergePatchAction indicates that we updated the manifest using three-way merge patch. + ManifestThreeWayMergePatchAction applyAction = "ManifestThreeWayMergePatched" - // ManifestAppliedAction indicates that we applied the manifest. - ManifestAppliedAction applyAction = "ManifestApplied" + // ManifestServerSideAppliedAction indicates that we updated the manifest using server side apply. + ManifestServerSideAppliedAction applyAction = "ManifestServerSideApplied" // ManifestNoChangeAction indicates that we don't need to change the manifest. ManifestNoChangeAction applyAction = "ManifestNoChange" @@ -338,7 +338,7 @@ func (r *ApplyWorkReconciler) decodeManifest(manifest workv1alpha1.Manifest) (sc // applyUnstructured determines if an unstructured manifest object can & should be applied. It first validates // the size of the last modified annotation of the manifest, it removes the annotation if the size crosses the annotation size threshold -// and then creates/updates the resource on the cluster using server side apply instead of three way merge patch. +// and then creates/updates the resource on the cluster using server side apply instead of three-way merge patch. func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema.GroupVersionResource, manifestObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { manifestRef := klog.ObjectRef{ @@ -354,7 +354,7 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. // extract the common create procedure to reuse var createFunc = func() (*unstructured.Unstructured, applyAction, error) { // record the raw manifest with the hash annotation in the manifest - if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { + if _, err := setModifiedConfigurationAnnotation(manifestObj); err != nil { return nil, ManifestNoChangeAction, err } actual, err := r.spokeDynamicClient.Resource(gvr).Namespace(manifestObj.GetNamespace()).Create( @@ -389,16 +389,16 @@ func (r *ApplyWorkReconciler) applyUnstructured(ctx context.Context, gvr schema. } // We only try to update the object if its spec hash value has changed. - if manifestObj.GetAnnotations()[ManifestHashAnnotation] != curObj.GetAnnotations()[ManifestHashAnnotation] { + if manifestObj.GetAnnotations()[manifestHashAnnotation] != curObj.GetAnnotations()[manifestHashAnnotation] { // we need to merge the owner reference between the current and the manifest since we support one manifest // belong to multiple work, so it contains the union of all the appliedWork. manifestObj.SetOwnerReferences(mergeOwnerReference(curObj.GetOwnerReferences(), manifestObj.GetOwnerReferences())) // record the raw manifest with the hash annotation in the manifest. - if err := setModifiedConfigurationAnnotation(manifestObj); err != nil { + isModifiedConfigAnnotationNotEmpty, err := setModifiedConfigurationAnnotation(manifestObj) + if err != nil { return nil, ManifestNoChangeAction, err } - annotations := manifestObj.GetAnnotations() - if annotations[LastAppliedConfigAnnotation] == "" { + if !isModifiedConfigAnnotationNotEmpty { klog.V(2).InfoS("using server side apply for manifest", "gvr", gvr, "manifest", manifestRef) return r.applyObject(ctx, gvr, manifestObj) } @@ -426,10 +426,10 @@ func (r *ApplyWorkReconciler) applyObject(ctx context.Context, gvr schema.GroupV return nil, ManifestNoChangeAction, err } klog.V(2).InfoS("manifest apply succeeded", "gvr", gvr, "manifest", manifestRef) - return manifestObj, ManifestAppliedAction, nil + return manifestObj, ManifestServerSideAppliedAction, nil } -// patchCurrentResource uses three way merge to patch the current resource with the new manifest we get from the work. +// patchCurrentResource uses three-way merge to patch the current resource with the new manifest we get from the work. func (r *ApplyWorkReconciler) patchCurrentResource(ctx context.Context, gvr schema.GroupVersionResource, manifestObj, curObj *unstructured.Unstructured) (*unstructured.Unstructured, applyAction, error) { manifestRef := klog.ObjectRef{ @@ -437,8 +437,8 @@ func (r *ApplyWorkReconciler) patchCurrentResource(ctx context.Context, gvr sche Namespace: manifestObj.GetNamespace(), } klog.V(2).InfoS("manifest is modified", "gvr", gvr, "manifest", manifestRef, - "new hash", manifestObj.GetAnnotations()[ManifestHashAnnotation], - "existing hash", curObj.GetAnnotations()[ManifestHashAnnotation]) + "new hash", manifestObj.GetAnnotations()[manifestHashAnnotation], + "existing hash", curObj.GetAnnotations()[manifestHashAnnotation]) // create the three-way merge patch between the current, original and manifest similar to how kubectl apply does patch, err := threeWayMergePatch(curObj, manifestObj) if err != nil { @@ -458,7 +458,7 @@ func (r *ApplyWorkReconciler) patchCurrentResource(ctx context.Context, gvr sche return nil, ManifestNoChangeAction, patchErr } klog.V(2).InfoS("manifest patch succeeded", "gvr", gvr, "manifest", manifestRef) - return manifestObj, ManifestUpdatedAction, nil + return manifestObj, ManifestThreeWayMergePatchAction, nil } // generateWorkCondition constructs the work condition based on the apply result @@ -547,8 +547,8 @@ func computeManifestHash(obj *unstructured.Unstructured) (string, error) { // remove the last applied Annotation to avoid unlimited recursion annotation := manifest.GetAnnotations() if annotation != nil { - delete(annotation, ManifestHashAnnotation) - delete(annotation, LastAppliedConfigAnnotation) + delete(annotation, manifestHashAnnotation) + delete(annotation, lastAppliedConfigAnnotation) if len(annotation) == 0 { manifest.SetAnnotations(nil) } else { @@ -620,7 +620,7 @@ func setManifestHashAnnotation(manifestObj *unstructured.Unstructured) error { if annotation == nil { annotation = map[string]string{} } - annotation[ManifestHashAnnotation] = manifestHash + annotation[manifestHashAnnotation] = manifestHash manifestObj.SetAnnotations(annotation) return nil } diff --git a/pkg/controllers/work/apply_controller_helper_test.go b/pkg/controllers/work/apply_controller_helper_test.go index 4185e2da9..e0cd3f935 100644 --- a/pkg/controllers/work/apply_controller_helper_test.go +++ b/pkg/controllers/work/apply_controller_helper_test.go @@ -51,8 +51,8 @@ func verifyAppliedConfigMap(cm *corev1.ConfigMap) *corev1.ConfigMap { for key := range cm.Annotations { Expect(appliedCM.Annotations[key]).Should(Equal(cm.Annotations[key])) } - Expect(appliedCM.Annotations[ManifestHashAnnotation]).ShouldNot(BeEmpty()) - Expect(appliedCM.Annotations[LastAppliedConfigAnnotation]).ShouldNot(BeEmpty()) + Expect(appliedCM.Annotations[manifestHashAnnotation]).ShouldNot(BeEmpty()) + Expect(appliedCM.Annotations[lastAppliedConfigAnnotation]).ShouldNot(BeEmpty()) By("Check the config map data") Expect(cmp.Diff(appliedCM.Data, cm.Data)).Should(BeEmpty()) diff --git a/pkg/controllers/work/apply_controller_integration_test.go b/pkg/controllers/work/apply_controller_integration_test.go index c21db5564..195d10f28 100644 --- a/pkg/controllers/work/apply_controller_integration_test.go +++ b/pkg/controllers/work/apply_controller_integration_test.go @@ -509,13 +509,13 @@ var _ = Describe("Work Controller", func() { appliedCM := verifyAppliedConfigMap(cm) By("Delete the last applied annotation from the current resource") - delete(appliedCM.Annotations, LastAppliedConfigAnnotation) + delete(appliedCM.Annotations, lastAppliedConfigAnnotation) Expect(k8sClient.Update(ctx, appliedCM)).Should(Succeed()) By("Get the last applied config map and verify it does not have the last applied annotation") var modifiedCM corev1.ConfigMap Expect(k8sClient.Get(ctx, types.NamespacedName{Name: cm.GetName(), Namespace: cm.GetNamespace()}, &modifiedCM)).Should(Succeed()) - Expect(modifiedCM.Annotations[LastAppliedConfigAnnotation]).Should(BeEmpty()) + Expect(modifiedCM.Annotations[lastAppliedConfigAnnotation]).Should(BeEmpty()) By("Modify the manifest") // modify one data diff --git a/pkg/controllers/work/apply_controller_test.go b/pkg/controllers/work/apply_controller_test.go index 6c8902c56..f9d70132b 100644 --- a/pkg/controllers/work/apply_controller_test.go +++ b/pkg/controllers/work/apply_controller_test.go @@ -155,7 +155,7 @@ func TestSetManifestHashAnnotation(t *testing.T) { "manifest's has hashAnnotation, same": { manifestObj: func() *appsv1.Deployment { alterObj := manifestObj.DeepCopy() - alterObj.Annotations[ManifestHashAnnotation] = utilrand.String(10) + alterObj.Annotations[manifestHashAnnotation] = utilrand.String(10) return alterObj }(), isSame: true, @@ -222,7 +222,7 @@ func TestSetManifestHashAnnotation(t *testing.T) { if err != nil { t.Error("failed to marshall the manifest", err.Error()) } - manifestHash := uManifestObj.GetAnnotations()[ManifestHashAnnotation] + manifestHash := uManifestObj.GetAnnotations()[manifestHashAnnotation] if tt.isSame != (manifestHash == preHash) { t.Errorf("testcase %s failed: manifestObj = (%+v)", name, tt.manifestObj) } @@ -284,18 +284,27 @@ func TestIsManifestManagedByWork(t *testing.T) { } func TestApplyUnstructured(t *testing.T) { - correctObj, correctDynamicClient, correctSpecHash := createObjAndDynamicClient(testManifest.Raw) + correctObj, correctDynamicClient, correctSpecHash, err := createObjAndDynamicClient(testManifest.Raw) + if err != nil { + t.Errorf("failed to create obj and dynamic client: %s", err) + } testDeploymentGenerated := testDeployment.DeepCopy() testDeploymentGenerated.Name = "" testDeploymentGenerated.GenerateName = utilrand.String(10) rawGenerated, _ := json.Marshal(testDeploymentGenerated) - generatedSpecObj, generatedSpecDynamicClient, generatedSpecHash := createObjAndDynamicClient(rawGenerated) + generatedSpecObj, generatedSpecDynamicClient, generatedSpecHash, err := createObjAndDynamicClient(rawGenerated) + if err != nil { + t.Errorf("failed to create obj and dynamic client: %s", err) + } testDeploymentDiffSpec := testDeployment.DeepCopy() testDeploymentDiffSpec.Spec.MinReadySeconds = 0 rawDiffSpec, _ := json.Marshal(testDeploymentDiffSpec) - diffSpecObj, diffSpecDynamicClient, diffSpecHash := createObjAndDynamicClient(rawDiffSpec) + diffSpecObj, diffSpecDynamicClient, diffSpecHash, err := createObjAndDynamicClient(rawDiffSpec) + if err != nil { + t.Errorf("failed to create obj and dynamic client: %s", err) + } patchFailClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) patchFailClient.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { @@ -341,36 +350,26 @@ func TestApplyUnstructured(t *testing.T) { }, } rawTestDeploymentWithDifferentOwner, _ := json.Marshal(testDeploymentWithDifferentOwner) - _, diffOwnerDynamicClient, _ := createObjAndDynamicClient(rawTestDeploymentWithDifferentOwner) + _, diffOwnerDynamicClient, _, err := createObjAndDynamicClient(rawTestDeploymentWithDifferentOwner) + if err != nil { + t.Errorf("failed to create obj and dynamic client: %s", err) + } specHashFailObj := correctObj.DeepCopy() specHashFailObj.Object["test"] = math.Inf(1) - var largeSecret v1.Secret - if err := utils.GetObjectFromManifest("../../../test/integration/manifests/resources/test-large-secret.yaml", &largeSecret); err != nil { - t.Errorf("failed to get object from manifest: %s", err) - } - largeSecret.ObjectMeta = metav1.ObjectMeta{ - OwnerReferences: []metav1.OwnerReference{ - ownerRef, - }, - } - rawSecret, err := json.Marshal(largeSecret) + largeObj, err := createLargeObj() if err != nil { - t.Errorf("failed to marshal secret: %s", err) - } - var largeObj unstructured.Unstructured - if err := largeObj.UnmarshalJSON(rawSecret); err != nil { - t.Errorf("failed to unmarshal JSON: %s", err) + t.Errorf("failed to create large obj: %s", err) } updatedLargeObj := largeObj.DeepCopy() - largeObjSpecHash, err := computeManifestHash(&largeObj) + largeObjSpecHash, err := computeManifestHash(largeObj) if err != nil { t.Errorf("failed to compute manifest hash: %s", err) } - largeObj.SetAnnotations(map[string]string{ManifestHashAnnotation: largeObjSpecHash}) + // Not mocking create for dynamicClientLargeObjNotFound because by default it somehow deep copies the object as the test runs and returns it. dynamicClientLargeObjNotFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) dynamicClientLargeObjNotFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, @@ -381,22 +380,23 @@ func TestApplyUnstructured(t *testing.T) { Reason: metav1.StatusReasonNotFound, }} }) - dynamicClientLargeObjNotFound.PrependReactor("create", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { - return true, largeObj.DeepCopy(), nil - }) updatedLargeObj.SetLabels(map[string]string{"test-label-key": "test-label"}) updatedLargeObjSpecHash, err := computeManifestHash(updatedLargeObj) if err != nil { t.Errorf("failed to compute manifest hash: %s", err) } - updatedLargeObj.SetAnnotations(map[string]string{ManifestHashAnnotation: updatedLargeObjSpecHash}) + // Need to mock patch because apply return error if not. dynamicClientLargeObjFound := fake.NewSimpleDynamicClient(runtime.NewScheme()) + // Need to set annotation to ensure on comparison between curObj and manifestObj is different. + largeObj.SetAnnotations(map[string]string{manifestHashAnnotation: largeObjSpecHash}) dynamicClientLargeObjFound.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, largeObj.DeepCopy(), nil }) dynamicClientLargeObjFound.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { + // updatedLargeObj.DeepCopy() is executed when the test runs meaning the deep copy is computed as the test runs and since we pass updatedLargeObj as reference + // in the test case input all changes made by the controller will be included when DeepCopy is computed. return true, updatedLargeObj.DeepCopy(), nil }) @@ -506,7 +506,7 @@ func TestApplyUnstructured(t *testing.T) { }, workObj: correctObj, resultSpecHash: diffSpecHash, - resultAction: ManifestUpdatedAction, + resultAction: ManifestThreeWayMergePatchAction, resultErr: nil, }, "test create succeeds for large manifest when object does not exist": { @@ -515,7 +515,7 @@ func TestApplyUnstructured(t *testing.T) { restMapper: testMapper{}, recorder: utils.NewFakeRecorder(1), }, - workObj: &largeObj, + workObj: largeObj, resultSpecHash: largeObjSpecHash, resultAction: ManifestCreatedAction, resultErr: nil, @@ -528,7 +528,7 @@ func TestApplyUnstructured(t *testing.T) { }, workObj: updatedLargeObj, resultSpecHash: updatedLargeObjSpecHash, - resultAction: ManifestAppliedAction, + resultAction: ManifestServerSideAppliedAction, resultErr: nil, }, "test create fails for large manifest when object does not exist": { @@ -537,7 +537,7 @@ func TestApplyUnstructured(t *testing.T) { restMapper: testMapper{}, recorder: utils.NewFakeRecorder(1), }, - workObj: &largeObj, + workObj: largeObj, resultAction: ManifestNoChangeAction, resultErr: errors.New("create error"), }, @@ -563,7 +563,7 @@ func TestApplyUnstructured(t *testing.T) { assert.Truef(t, err == nil, "err is not nil for Testcase %s", testName) assert.Truef(t, applyResult != nil, "applyResult is not nil for Testcase %s", testName) // Not checking last applied config because it has live fields. - assert.Equalf(t, testCase.resultSpecHash, applyResult.GetAnnotations()[ManifestHashAnnotation], + assert.Equalf(t, testCase.resultSpecHash, applyResult.GetAnnotations()[manifestHashAnnotation], "specHash not matching for Testcase %s", testName) assert.Equalf(t, ownerRef, applyResult.GetOwnerReferences()[0], "ownerRef not matching for Testcase %s", testName) } @@ -758,7 +758,10 @@ func TestReconcile(t *testing.T) { happyManifest := workv1alpha1.Manifest{RawExtension: runtime.RawExtension{ Raw: rawHappyDeployment, }} - _, happyDynamicClient, _ := createObjAndDynamicClient(happyManifest.Raw) + _, happyDynamicClient, _, err := createObjAndDynamicClient(happyManifest.Raw) + if err != nil { + t.Errorf("failed to create obj and dynamic client: %s", err) + } getMockAppliedWork := func(ctx context.Context, key client.ObjectKey, obj client.Object) error { if key.Name != workName { @@ -1011,12 +1014,21 @@ func TestReconcile(t *testing.T) { } } -func createObjAndDynamicClient(rawManifest []byte) (*unstructured.Unstructured, dynamic.Interface, string) { +func createObjAndDynamicClient(rawManifest []byte) (*unstructured.Unstructured, dynamic.Interface, string, error) { uObj := unstructured.Unstructured{} - _ = uObj.UnmarshalJSON(rawManifest) - validSpecHash, _ := computeManifestHash(&uObj) - uObj.SetAnnotations(map[string]string{ManifestHashAnnotation: validSpecHash}) - _ = setModifiedConfigurationAnnotation(&uObj) + err := uObj.UnmarshalJSON(rawManifest) + if err != nil { + return nil, nil, "", err + } + validSpecHash, err := computeManifestHash(&uObj) + if err != nil { + return nil, nil, "", err + } + uObj.SetAnnotations(map[string]string{manifestHashAnnotation: validSpecHash}) + _, err = setModifiedConfigurationAnnotation(&uObj) + if err != nil { + return nil, nil, "", err + } dynamicClient := fake.NewSimpleDynamicClient(runtime.NewScheme()) dynamicClient.PrependReactor("get", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, uObj.DeepCopy(), nil @@ -1024,5 +1036,26 @@ func createObjAndDynamicClient(rawManifest []byte) (*unstructured.Unstructured, dynamicClient.PrependReactor("patch", "*", func(action testingclient.Action) (handled bool, ret runtime.Object, err error) { return true, uObj.DeepCopy(), nil }) - return &uObj, dynamicClient, validSpecHash + return &uObj, dynamicClient, validSpecHash, nil +} + +func createLargeObj() (*unstructured.Unstructured, error) { + var largeSecret v1.Secret + if err := utils.GetObjectFromManifest("../../../test/integration/manifests/resources/test-large-secret.yaml", &largeSecret); err != nil { + return nil, err + } + largeSecret.ObjectMeta = metav1.ObjectMeta{ + OwnerReferences: []metav1.OwnerReference{ + ownerRef, + }, + } + rawSecret, err := json.Marshal(largeSecret) + if err != nil { + return nil, err + } + var largeObj unstructured.Unstructured + if err := largeObj.UnmarshalJSON(rawSecret); err != nil { + return nil, err + } + return &largeObj, nil } diff --git a/pkg/controllers/work/manager.go b/pkg/controllers/work/manager.go index 5bb03a3fb..067471bc7 100644 --- a/pkg/controllers/work/manager.go +++ b/pkg/controllers/work/manager.go @@ -32,9 +32,9 @@ import ( const ( workFinalizer = "fleet.azure.com/work-cleanup" - ManifestHashAnnotation = "fleet.azure.com/spec-hash" + manifestHashAnnotation = "fleet.azure.com/spec-hash" - LastAppliedConfigAnnotation = "fleet.azure.com/last-applied-configuration" + lastAppliedConfigAnnotation = "fleet.azure.com/last-applied-configuration" ConditionTypeApplied = "Applied" ConditionTypeAvailable = "Available" diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index b30d552e4..d4b71370c 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -80,19 +80,20 @@ func threeWayMergePatch(currentObj, manifestObj client.Object) (client.Patch, er // setModifiedConfigurationAnnotation serializes the object into byte stream. // If `updateAnnotation` is true, it embeds the result as an annotation in the // modified configuration. If annotations size is greater than 256 kB it sets -// to empty string. -func setModifiedConfigurationAnnotation(obj runtime.Object) error { +// to empty string. it returns true if the annotation is set returns false if +// the annotation is set to an empty string. +func setModifiedConfigurationAnnotation(obj runtime.Object) (bool, error) { var modified []byte annotations, err := metadataAccessor.Annotations(obj) if err != nil { - return fmt.Errorf("cannot access metadata.annotations: %w", err) + return false, fmt.Errorf("cannot access metadata.annotations: %w", err) } if annotations == nil { annotations = make(map[string]string) } // remove the annotation to avoid recursion - delete(annotations, LastAppliedConfigAnnotation) + delete(annotations, lastAppliedConfigAnnotation) // do not include an empty map if len(annotations) == 0 { _ = metadataAccessor.SetAnnotations(obj, nil) @@ -104,15 +105,16 @@ func setModifiedConfigurationAnnotation(obj runtime.Object) error { // the produced json format is more three way merge friendly modified, err = json.Marshal(obj) if err != nil { - return err + return false, err } // set the last applied annotation back - annotations[LastAppliedConfigAnnotation] = string(modified) + annotations[lastAppliedConfigAnnotation] = string(modified) if err := validation.ValidateAnnotationsSize(annotations); err != nil { klog.V(2).InfoS(fmt.Sprintf("setting last applied config annotation to empty, %s", err)) - annotations[LastAppliedConfigAnnotation] = "" + annotations[lastAppliedConfigAnnotation] = "" + return false, metadataAccessor.SetAnnotations(obj, annotations) } - return metadataAccessor.SetAnnotations(obj, annotations) + return true, metadataAccessor.SetAnnotations(obj, annotations) } // getOriginalConfiguration gets original configuration of the object @@ -128,7 +130,7 @@ func getOriginalConfiguration(obj runtime.Object) ([]byte, error) { klog.Warning("object does not have annotation", "obj", obj) return nil, nil } - original, ok := annots[LastAppliedConfigAnnotation] + original, ok := annots[lastAppliedConfigAnnotation] if !ok { klog.Warning("object does not have lastAppliedConfigAnnotation", "obj", obj) return nil, nil diff --git a/pkg/controllers/work/patch_util_test.go b/pkg/controllers/work/patch_util_test.go new file mode 100644 index 000000000..1528c2613 --- /dev/null +++ b/pkg/controllers/work/patch_util_test.go @@ -0,0 +1,45 @@ +package controllers + +import ( + "testing" + + "k8s.io/apimachinery/pkg/runtime" + + "github.com/stretchr/testify/assert" +) + +func TestSetModifiedConfigurationAnnotation(t *testing.T) { + smallObj, _, _, err := createObjAndDynamicClient(testManifest.Raw) + if err != nil { + t.Errorf("failed to create obj and dynamic client: %s", err) + } + largeObj, err := createLargeObj() + if err != nil { + t.Errorf("failed to create large obj: %s", err) + } + + tests := map[string]struct { + obj runtime.Object + wantBool bool + wantErr error + }{ + "last applied config annotation is set": { + obj: smallObj, + wantBool: true, + wantErr: nil, + }, + "last applied config annotation is set to an empty string": { + obj: largeObj, + wantBool: false, + wantErr: nil, + }, + } + + for testName, testCase := range tests { + t.Run(testName, func(t *testing.T) { + gotBool, gotErr := setModifiedConfigurationAnnotation(testCase.obj) + assert.Equalf(t, testCase.wantBool, gotBool, "got bool not matching for Testcase %s", testName) + assert.Equalf(t, testCase.wantErr, gotErr, "got error not matching for Testcase %s", testName) + }) + } +} diff --git a/test/e2e/work_api_e2e_test.go b/test/e2e/work_api_e2e_test.go index e8449df8c..e0677fa1c 100644 --- a/test/e2e/work_api_e2e_test.go +++ b/test/e2e/work_api_e2e_test.go @@ -305,8 +305,8 @@ var _ = Describe("Work API Controller test", func() { By(fmt.Sprintf("Verify that either works %s and %s condition reason should be updated", namespaceTypeOne, namespaceTypeTwo)) Expect(workOne.Status.ManifestConditions[0].Conditions[0].Reason == string(workcontroller.ManifestCreatedAction) || workTwo.Status.ManifestConditions[0].Conditions[0].Reason == string(workcontroller.ManifestCreatedAction)).Should(BeTrue()) - Expect(workOne.Status.ManifestConditions[0].Conditions[0].Reason == string(workcontroller.ManifestUpdatedAction) || - workTwo.Status.ManifestConditions[0].Conditions[0].Reason == string(workcontroller.ManifestUpdatedAction)).Should(BeTrue()) + Expect(workOne.Status.ManifestConditions[0].Conditions[0].Reason == string(workcontroller.ManifestThreeWayMergePatchAction) || + workTwo.Status.ManifestConditions[0].Conditions[0].Reason == string(workcontroller.ManifestThreeWayMergePatchAction)).Should(BeTrue()) By(fmt.Sprintf("AppliedWorkStatus for both works %s and %s should contain the meta for the resource %s", namespaceTypeOne, namespaceTypeTwo, manifestSecretName)) wantAppliedStatus := workapi.AppliedtWorkStatus{ diff --git a/test/e2e/work_load_test.go b/test/e2e/work_load_test.go index 319263b0e..0a355b064 100644 --- a/test/e2e/work_load_test.go +++ b/test/e2e/work_load_test.go @@ -19,7 +19,6 @@ import ( workapiv1alpha1 "sigs.k8s.io/work-api/pkg/apis/v1alpha1" "go.goms.io/fleet/apis/v1alpha1" - pkgwork "go.goms.io/fleet/pkg/controllers/work" pkgutils "go.goms.io/fleet/pkg/utils" "go.goms.io/fleet/test/e2e/utils" ) @@ -405,10 +404,7 @@ var _ = Describe("workload orchestration testing", func() { utils.CmpNamespace(ctx, *MemberCluster, &types.NamespacedName{Name: namespace.Name}, wantNamespace, resourceIgnoreOptions) // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. - gotSecret := utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testSmallSecret.Name, Namespace: testSmallSecret.Namespace}, wantSecret, resourceIgnoreOptions) - Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).To(Not(BeEmpty())) - // Not checking spec hash equals some value because ObjectMeta.OwnerReferences has some live fields. - testSmallSecretSpecHash := gotSecret.Annotations[pkgwork.ManifestHashAnnotation] + gotSmallSecret := utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testSmallSecret.Name, Namespace: testSmallSecret.Namespace}, wantSecret, resourceIgnoreOptions) By("update secret so that annotation limit crosses threshold of 256KB") var testLargeSecret corev1.Secret @@ -420,9 +416,9 @@ var _ = Describe("workload orchestration testing", func() { wantSecret.OwnerReferences = ownerReferences // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. - gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testLargeSecret.Name, Namespace: testLargeSecret.Namespace}, wantSecret, resourceIgnoreOptions) - Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).To(BeEmpty()) - Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).ToNot(Equal(testSmallSecretSpecHash)) + gotLargeSecret := utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: testLargeSecret.Name, Namespace: testLargeSecret.Namespace}, wantSecret, resourceIgnoreOptions) + diff := cmp.Diff(gotSmallSecret, gotLargeSecret, resourceIgnoreOptions...) + Expect(diff).To(Not(Equal(""))) By("update secret so that it's small again") // Using a new variable to prevent failure, leads to 409 if not. @@ -430,18 +426,15 @@ var _ = Describe("workload orchestration testing", func() { err = pkgutils.GetObjectFromManifest("./test/integration/manifests/resources/test-small-secret.yaml", &initialSmallSecret) Expect(err).Should(Succeed()) Eventually(func() error { - if err := HubCluster.KubeClient.Update(ctx, &initialSmallSecret); err != nil { - return err - } - return nil + return HubCluster.KubeClient.Update(ctx, &initialSmallSecret) }, utils.PollTimeout, utils.PollInterval).Should(Succeed(), "Failed to update secret to be small in %s cluster", HubCluster.ClusterName) wantSecret = &initialSmallSecret wantSecret.OwnerReferences = ownerReferences // Ignoring Annotations here because fleet.azure.com/last-applied-configuration has live fields, checking to see if it's not empty instead. - gotSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: initialSmallSecret.Name, Namespace: initialSmallSecret.Namespace}, wantSecret, resourceIgnoreOptions) - Expect(gotSecret.Annotations[pkgwork.LastAppliedConfigAnnotation]).ToNot(BeEmpty()) - Expect(gotSecret.Annotations[pkgwork.ManifestHashAnnotation]).To(Equal(testSmallSecretSpecHash)) + gotSmallSecret = utils.CmpSecret(ctx, *MemberCluster, &types.NamespacedName{Name: initialSmallSecret.Name, Namespace: initialSmallSecret.Namespace}, wantSecret, resourceIgnoreOptions) + diff = cmp.Diff(gotLargeSecret, gotSmallSecret, resourceIgnoreOptions...) + Expect(diff).To(Not(Equal(""))) By("delete namespaces") utils.DeleteNamespace(ctx, *HubCluster, namespace) From 1f28abd80ad330c885777bfc1aae88a72d827485 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Thu, 8 Jun 2023 12:03:32 -0700 Subject: [PATCH 41/42] fix comment --- pkg/controllers/work/patch_util.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/controllers/work/patch_util.go b/pkg/controllers/work/patch_util.go index d4b71370c..cffdd4696 100644 --- a/pkg/controllers/work/patch_util.go +++ b/pkg/controllers/work/patch_util.go @@ -80,8 +80,8 @@ func threeWayMergePatch(currentObj, manifestObj client.Object) (client.Patch, er // setModifiedConfigurationAnnotation serializes the object into byte stream. // If `updateAnnotation` is true, it embeds the result as an annotation in the // modified configuration. If annotations size is greater than 256 kB it sets -// to empty string. it returns true if the annotation is set returns false if -// the annotation is set to an empty string. +// to empty string. It returns true if the annotation contains a value, returns +// false if the annotation is set to an empty string. func setModifiedConfigurationAnnotation(obj runtime.Object) (bool, error) { var modified []byte annotations, err := metadataAccessor.Annotations(obj) From eee4cd27c68c5b13dd03b9e9c4805b1a50120ee4 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Thu, 8 Jun 2023 12:04:47 -0700 Subject: [PATCH 42/42] fix import order --- pkg/controllers/work/patch_util_test.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pkg/controllers/work/patch_util_test.go b/pkg/controllers/work/patch_util_test.go index 1528c2613..ec44c9a6b 100644 --- a/pkg/controllers/work/patch_util_test.go +++ b/pkg/controllers/work/patch_util_test.go @@ -3,9 +3,8 @@ package controllers import ( "testing" - "k8s.io/apimachinery/pkg/runtime" - "github.com/stretchr/testify/assert" + "k8s.io/apimachinery/pkg/runtime" ) func TestSetModifiedConfigurationAnnotation(t *testing.T) {