expose builder api for stripping managedfields, annotations

Author: Alexander Zielenski

pkg/builder/controller.go

@@ -71,6 +71,7 @@ type ForInput struct {
 	object           client.Object
 	predicates       []predicate.Predicate
 	objectProjection objectProjection
+	metadataFilter   manager.MetadataFilter
 	err              error
 }
 
@@ -97,6 +98,7 @@ type OwnsInput struct {
 	object           client.Object
 	predicates       []predicate.Predicate
 	objectProjection objectProjection
+	metadataFilter   manager.MetadataFilter
 }
 
 // Owns defines types of Objects being *generated* by the ControllerManagedBy, and configures the ControllerManagedBy to respond to
@@ -118,6 +120,7 @@ type WatchesInput struct {
 	eventhandler     handler.EventHandler
 	predicates       []predicate.Predicate
 	objectProjection objectProjection
+	metadataFilter   manager.MetadataFilter
 }
 
 // Watches exposes the lower-level ControllerManagedBy Watches functions through the builder.  Consider using
@@ -216,6 +219,23 @@ func (blder *Builder) project(obj client.Object, proj objectProjection) (client.
 	}
 }
 
+// Finds the SharedIndexInformer used for the given source, and installs
+// an object preprocessor to strip specified fields before objects are stored
+// in the Store, or broadcasted to listeners.
+func (blder *Builder) installMetadataFilterForKindSource(kind *source.Kind, filter manager.MetadataFilter) error {
+	gvk, err := apiutil.GVKForObject(kind.Type, blder.mgr.GetScheme())
+	if err != nil {
+		return fmt.Errorf("failed to find gvk for object: %v", kind.Type)
+	}
+
+	// Set the configuration onto the manager.
+	// Manager is then responsible for applying it to the cache before starting
+	// any informers.
+	blder.mgr.AddMetadataFilterForKind(gvk, filter)
+
+	return nil
+}
+
 func (blder *Builder) doWatch() error {
 	// Reconcile type
 	typeForSrc, err := blder.project(blder.forInput.object, blder.forInput.objectProjection)
@@ -229,6 +249,12 @@ func (blder *Builder) doWatch() error {
 		return err
 	}
 
+	// Must be called after Watch which populates the source's cache
+	if err := blder.installMetadataFilterForKindSource(
+		src, blder.forInput.metadataFilter); err != nil {
+		return err
+	}
+
 	// Watches the managed types
 	for _, own := range blder.ownsInput {
 		typeForSrc, err := blder.project(own.object, own.objectProjection)
@@ -245,6 +271,12 @@ func (blder *Builder) doWatch() error {
 		if err := blder.ctrl.Watch(src, hdler, allPredicates...); err != nil {
 			return err
 		}
+
+		// Must be called after Watch which populates the source's cache
+		if err := blder.installMetadataFilterForKindSource(
+			src, own.metadataFilter); err != nil {
+			return err
+		}
 	}
 
 	// Do the watch requests
@@ -264,6 +296,16 @@ func (blder *Builder) doWatch() error {
 		if err := blder.ctrl.Watch(w.src, w.eventhandler, allPredicates...); err != nil {
 			return err
 		}
+
+		if srckind, ok := w.src.(*source.Kind); ok {
+			// We can only apply projections to source.Kind types
+			// Must be called after Watch which populates the source's cache
+			if err := blder.installMetadataFilterForKindSource(
+				srckind, w.metadataFilter); err != nil {
+				return err
+			}
+		}
+
 	}
 	return nil
 }

pkg/builder/controller_test.go

@@ -75,6 +75,139 @@ func (l *testLogger) WithName(name string) logr.LogSink {
 	return l
 }
 
+func doStripMetadataTestWithOptions(mgr manager.Manager, suffix string, opts ...*metadataFilterInjectorFunc) {
+	statefulSetMaps := make(chan *metav1.PartialObjectMetadata)
+	forOpts := []ForOption{OnlyMetadata}
+	ownOpts := []OwnsOption{OnlyMetadata}
+	watchOpts := []WatchesOption{OnlyMetadata}
+
+	expectManagedFields := true
+	expectAnnotations := true
+
+	for _, v := range opts {
+		forOpts = append(forOpts, *v)
+		ownOpts = append(ownOpts, *v)
+		watchOpts = append(watchOpts, *v)
+
+		expectManagedFields = expectManagedFields && v != &WithoutManagedFields
+		expectAnnotations = expectAnnotations && v != &WithoutAnnotations
+	}
+
+	testObject := func(o metav1.Object) bool {
+		// Validate that ManagedFields is nil
+		if expectAnnotations {
+			Expect(o.GetAnnotations()).ToNot(BeNil())
+		} else {
+			Expect((o.GetAnnotations())).To(BeNil())
+		}
+		if expectManagedFields {
+			Expect((o.GetManagedFields())).ToNot(BeNil())
+		} else {
+			Expect((o.GetManagedFields())).To(BeNil())
+		}
+		return true
+	}
+
+	set := &appsv1.StatefulSet{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: "default",
+			Name:      "test1-" + suffix,
+			Labels: map[string]string{
+				"foo": "bar",
+			},
+			Annotations: map[string]string{
+				"foo": "bar",
+			},
+		},
+		Spec: appsv1.StatefulSetSpec{
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{"foo": "bar"},
+			},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"foo": "bar"}},
+				Spec: corev1.PodSpec{
+					Containers: []corev1.Container{
+						{
+							Name:  "nginx",
+							Image: "nginx",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	bldr := ControllerManagedBy(mgr).
+		For(&appsv1.Deployment{}, forOpts...).
+		Owns(&appsv1.ReplicaSet{}, ownOpts...).
+		Watches(&source.Kind{Type: &appsv1.StatefulSet{}},
+			handler.EnqueueRequestsFromMapFunc(func(o client.Object) []reconcile.Request {
+				defer GinkgoRecover()
+
+				if o.GetName() != set.Name {
+					// I suppose the objects in the test cluster are not reset
+					// in-between tests?
+					return nil
+				}
+
+				ometa := o.(*metav1.PartialObjectMetadata)
+				Expect(ometa.Name).To(Equal(set.Name))
+				Expect(ometa.Namespace).To(Equal(set.Namespace))
+				Expect(ometa.Labels).To(Equal(set.Labels))
+				statefulSetMaps <- ometa
+
+				// Validate that the GVK is not empty when dealing with PartialObjectMetadata objects.
+				Expect(o.GetObjectKind().GroupVersionKind()).To(Equal(schema.GroupVersionKind{
+					Group:   "apps",
+					Version: "v1",
+					Kind:    "StatefulSet",
+				}))
+
+				testObject(o)
+				return nil
+			}),
+			watchOpts...)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	doReconcileTest(ctx, suffix, mgr, true, bldr)
+
+	By("Creating a new stateful set")
+
+	err := mgr.GetClient().Create(context.TODO(), set)
+	Expect(err).NotTo(HaveOccurred())
+
+	By("Checking that 'Owns' Deployments have correct projection")
+	deployment, err := bldr.project(&appsv1.Deployment{}, projectAsMetadata)
+	Expect(err).NotTo(HaveOccurred())
+	err = mgr.GetCache().Get(ctx, types.NamespacedName{
+		Namespace: "default",
+		Name:      "deploy-name-" + suffix,
+	}, deployment)
+	Expect(err).NotTo(HaveOccurred())
+	testObject(deployment)
+
+	By("Checking that 'For' ReplicaSets have correct projection")
+	rs, err := bldr.project(&appsv1.ReplicaSet{}, projectAsMetadata)
+	Expect(err).NotTo(HaveOccurred())
+	err = mgr.GetCache().Get(ctx, types.NamespacedName{
+		Namespace: "default",
+		Name:      "rs-name-" + suffix,
+	}, rs)
+	Expect(err).NotTo(HaveOccurred())
+	testObject(rs)
+
+	By("Checking that the mapping function has been called")
+	Eventually(func() bool {
+		metaSet := <-statefulSetMaps
+		Expect(metaSet.Name).To(Equal(set.Name))
+		Expect(metaSet.Namespace).To(Equal(set.Namespace))
+		Expect(metaSet.Labels).To(Equal(set.Labels))
+		return true
+	}).Should(BeTrue())
+}
+
 var _ = Describe("application", func() {
 	BeforeEach(func() {
 		newController = controller.New
@@ -417,6 +550,38 @@ var _ = Describe("application", func() {
 			doReconcileTest(ctx, "6", mgr, true, bldr1, bldr2)
 		})
 
+		It("should support keeping metadata fields if not all controllers agree to strip them", func() {
+			bldr1 := ControllerManagedBy(mgr).For(&appsv1.Deployment{}, OnlyMetadata, WithoutManagedFields)
+			bldr2 := ControllerManagedBy(mgr).For(&appsv1.Deployment{}, OnlyMetadata)
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+
+			doReconcileTest(ctx, "7-0", mgr, true, bldr1, bldr2)
+
+			By("Checking that Deployments metadata still has managed fields")
+			deployment, err := bldr1.project(&appsv1.Deployment{}, projectAsMetadata)
+			Expect(err).NotTo(HaveOccurred())
+			err = mgr.GetCache().Get(ctx, types.NamespacedName{
+				Namespace: "default",
+				Name:      "deploy-name-" + "7-0",
+			}, deployment)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(deployment.GetManagedFields()).ToNot(BeNil())
+		})
+
+		It("should support stripping annoatations for metadata projections", func() {
+			doStripMetadataTestWithOptions(mgr, "7-1", &WithoutAnnotations)
+		})
+
+		It("should support stripping managed fields options for metadata projections", func() {
+			doStripMetadataTestWithOptions(mgr, "7-2", &WithoutManagedFields)
+		})
+
+		It("should support all stripping options for metadata projections", func() {
+			doStripMetadataTestWithOptions(mgr, "7-3", &WithoutAnnotations, &WithoutManagedFields)
+		})
+
 		It("should support watching For, Owns, and Watch as metadata", func() {
 			statefulSetMaps := make(chan *metav1.PartialObjectMetadata)
 
@@ -427,15 +592,17 @@ var _ = Describe("application", func() {
 					handler.EnqueueRequestsFromMapFunc(func(o client.Object) []reconcile.Request {
 						defer GinkgoRecover()
 
-						ometa := o.(*metav1.PartialObjectMetadata)
-						statefulSetMaps <- ometa
-
-						// Validate that the GVK is not empty when dealing with PartialObjectMetadata objects.
-						Expect(o.GetObjectKind().GroupVersionKind()).To(Equal(schema.GroupVersionKind{
-							Group:   "apps",
-							Version: "v1",
-							Kind:    "StatefulSet",
-						}))
+						if o.GetName() == "test1" {
+							ometa := o.(*metav1.PartialObjectMetadata)
+							statefulSetMaps <- ometa
+
+							// Validate that the GVK is not empty when dealing with PartialObjectMetadata objects.
+							Expect(o.GetObjectKind().GroupVersionKind()).To(Equal(schema.GroupVersionKind{
+								Group:   "apps",
+								Version: "v1",
+								Kind:    "StatefulSet",
+							}))
+						}
 						return nil
 					}),
 					OnlyMetadata)
@@ -559,6 +726,9 @@ func doReconcileTest(ctx context.Context, nameSuffix string, mgr manager.Manager
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace: "default",
 			Name:      deployName,
+			Annotations: map[string]string{
+				"foo": "bar",
+			},
 		},
 		Spec: appsv1.DeploymentSpec{
 			Selector: &metav1.LabelSelector{
@@ -601,6 +771,9 @@ func doReconcileTest(ctx context.Context, nameSuffix string, mgr manager.Manager
 					UID:        dep.UID,
 				},
 			},
+			Annotations: map[string]string{
+				"foo": "bar",
+			},
 		},
 		Spec: appsv1.ReplicaSetSpec{
 			Selector: dep.Spec.Selector,

pkg/builder/options.go

@@ -17,6 +17,7 @@ limitations under the License.
 package builder
 
 import (
+	"sigs.k8s.io/controller-runtime/pkg/manager"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 )
 
@@ -115,3 +116,50 @@ var (
 )
 
 // }}}
+
+// {{{ Metadata Filter Options
+
+type metadataFilterInjectorFunc func(*manager.MetadataFilter)
+
+// ApplyToFor applies this configuration to the given ForInput options.
+func (p metadataFilterInjectorFunc) ApplyToFor(opts *ForInput) {
+	p(&opts.metadataFilter)
+}
+
+// ApplyToOwns applies this configuration to the given OwnsInput options.
+func (p metadataFilterInjectorFunc) ApplyToOwns(opts *OwnsInput) {
+	p(&opts.metadataFilter)
+}
+
+// ApplyToWatches applies this configuration to the given WatchesInput options.
+func (p metadataFilterInjectorFunc) ApplyToWatches(opts *WatchesInput) {
+	p(&opts.metadataFilter)
+}
+
+var (
+	// WithoutManagedFields informs the cache that managedFields are not required
+	// to be stored, so they will be removed before being stored in the cache.
+	// If multiple controllers watch the same GVK with the same source type,
+	// then managedFields are stripped if the last constructed controller
+	// requested it.
+	WithoutManagedFields = metadataFilterInjectorFunc(func(filter *manager.MetadataFilter) { filter.RemoveManagedFields = true })
+
+	// WithoutAnnotations informs the cache that annotations metadata are not
+	// required to be stored, so they will be removed before being stored in
+	// the cache.
+	//
+	// If multiple controllers watch the same GVK with the same source type,
+	// then annotations are stripped if the last constructed controller
+	// requested it.
+	WithoutAnnotations = metadataFilterInjectorFunc(func(filter *manager.MetadataFilter) { filter.RemoveAnnotations = true })
+
+	_ ForOption     = WithoutManagedFields
+	_ OwnsOption    = WithoutManagedFields
+	_ WatchesOption = WithoutManagedFields
+
+	_ ForOption     = WithoutAnnotations
+	_ OwnsOption    = WithoutAnnotations
+	_ WatchesOption = WithoutAnnotations
+)
+
+// }}}