From 0f6c191773556874f2950b1c2e8be81a3a4220f9 Mon Sep 17 00:00:00 2001 From: Alvaro Aleman Date: Wed, 5 Aug 2020 20:59:01 -0400 Subject: [PATCH] :warning: Simplify usage of EnqueueRequestsFromMapFunc --- pkg/handler/enqueue_mapped.go | 38 ++++++----- pkg/handler/eventhandler_test.go | 111 +++++++++++++++---------------- pkg/handler/example_test.go | 27 ++++---- 3 files changed, 87 insertions(+), 89 deletions(-) diff --git a/pkg/handler/enqueue_mapped.go b/pkg/handler/enqueue_mapped.go index 43738cc46c..c83a796259 100644 --- a/pkg/handler/enqueue_mapped.go +++ b/pkg/handler/enqueue_mapped.go @@ -24,8 +24,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/runtime/inject" ) -var _ EventHandler = &EnqueueRequestsFromMapFunc{} - // EnqueueRequestsFromMapFunc enqueues Requests by running a transformation function that outputs a collection // of reconcile.Requests on each Event. The reconcile.Requests may be for an arbitrary set of objects // defined by some user specified transformation of the source Event. (e.g. trigger Reconciler for a set of objects @@ -36,33 +34,41 @@ var _ EventHandler = &EnqueueRequestsFromMapFunc{} // // For UpdateEvents which contain both a new and old object, the transformation function is run on both // objects and both sets of Requests are enqueue. -type EnqueueRequestsFromMapFunc struct { +func EnqueueRequestsFromMapFunc(mapFN func(MapObject) []reconcile.Request) EventHandler { + return &enqueueRequestsFromMapFunc{ + ToRequests: toRequestsFunc(mapFN), + } +} + +var _ EventHandler = &enqueueRequestsFromMapFunc{} + +type enqueueRequestsFromMapFunc struct { // Mapper transforms the argument into a slice of keys to be reconciled - ToRequests Mapper + ToRequests mapper } // Create implements EventHandler -func (e *EnqueueRequestsFromMapFunc) Create(evt event.CreateEvent, q workqueue.RateLimitingInterface) { +func (e *enqueueRequestsFromMapFunc) Create(evt event.CreateEvent, q workqueue.RateLimitingInterface) { e.mapAndEnqueue(q, MapObject{Object: evt.Object}) } // Update implements EventHandler -func (e *EnqueueRequestsFromMapFunc) Update(evt event.UpdateEvent, q workqueue.RateLimitingInterface) { +func (e *enqueueRequestsFromMapFunc) Update(evt event.UpdateEvent, q workqueue.RateLimitingInterface) { e.mapAndEnqueue(q, MapObject{Object: evt.ObjectOld}) e.mapAndEnqueue(q, MapObject{Object: evt.ObjectNew}) } // Delete implements EventHandler -func (e *EnqueueRequestsFromMapFunc) Delete(evt event.DeleteEvent, q workqueue.RateLimitingInterface) { +func (e *enqueueRequestsFromMapFunc) Delete(evt event.DeleteEvent, q workqueue.RateLimitingInterface) { e.mapAndEnqueue(q, MapObject{Object: evt.Object}) } // Generic implements EventHandler -func (e *EnqueueRequestsFromMapFunc) Generic(evt event.GenericEvent, q workqueue.RateLimitingInterface) { +func (e *enqueueRequestsFromMapFunc) Generic(evt event.GenericEvent, q workqueue.RateLimitingInterface) { e.mapAndEnqueue(q, MapObject{Object: evt.Object}) } -func (e *EnqueueRequestsFromMapFunc) mapAndEnqueue(q workqueue.RateLimitingInterface, object MapObject) { +func (e *enqueueRequestsFromMapFunc) mapAndEnqueue(q workqueue.RateLimitingInterface, object MapObject) { for _, req := range e.ToRequests.Map(object) { q.Add(req) } @@ -71,15 +77,15 @@ func (e *EnqueueRequestsFromMapFunc) mapAndEnqueue(q workqueue.RateLimitingInter // EnqueueRequestsFromMapFunc can inject fields into the mapper. // InjectFunc implements inject.Injector. -func (e *EnqueueRequestsFromMapFunc) InjectFunc(f inject.Func) error { +func (e *enqueueRequestsFromMapFunc) InjectFunc(f inject.Func) error { if f == nil { return nil } return f(e.ToRequests) } -// Mapper maps an object to a collection of keys to be enqueued -type Mapper interface { +// mapper maps an object to a collection of keys to be enqueued +type mapper interface { // Map maps an object Map(MapObject) []reconcile.Request } @@ -89,12 +95,12 @@ type MapObject struct { Object controllerutil.Object } -var _ Mapper = ToRequestsFunc(nil) +var _ mapper = toRequestsFunc(nil) -// ToRequestsFunc implements Mapper using a function. -type ToRequestsFunc func(MapObject) []reconcile.Request +// toRequestsFunc implements Mapper using a function. +type toRequestsFunc func(MapObject) []reconcile.Request // Map implements Mapper -func (m ToRequestsFunc) Map(i MapObject) []reconcile.Request { +func (m toRequestsFunc) Map(i MapObject) []reconcile.Request { return m(i) } diff --git a/pkg/handler/eventhandler_test.go b/pkg/handler/eventhandler_test.go index 25fbc8e236..af2e5e54b0 100644 --- a/pkg/handler/eventhandler_test.go +++ b/pkg/handler/eventhandler_test.go @@ -191,21 +191,19 @@ var _ = Describe("Eventhandler", func() { Describe("EnqueueRequestsFromMapFunc", func() { It("should enqueue a Request with the function applied to the CreateEvent.", func() { req := []reconcile.Request{} - instance := handler.EnqueueRequestsFromMapFunc{ - ToRequests: handler.ToRequestsFunc(func(a handler.MapObject) []reconcile.Request { - defer GinkgoRecover() - Expect(a.Object).To(Equal(pod)) - req = []reconcile.Request{ - { - NamespacedName: types.NamespacedName{Namespace: "foo", Name: "bar"}, - }, - { - NamespacedName: types.NamespacedName{Namespace: "biz", Name: "baz"}, - }, - } - return req - }), - } + instance := handler.EnqueueRequestsFromMapFunc(func(a handler.MapObject) []reconcile.Request { + defer GinkgoRecover() + Expect(a.Object).To(Equal(pod)) + req = []reconcile.Request{ + { + NamespacedName: types.NamespacedName{Namespace: "foo", Name: "bar"}, + }, + { + NamespacedName: types.NamespacedName{Namespace: "biz", Name: "baz"}, + }, + } + return req + }) evt := event.CreateEvent{ Object: pod, @@ -224,21 +222,19 @@ var _ = Describe("Eventhandler", func() { It("should enqueue a Request with the function applied to the DeleteEvent.", func() { req := []reconcile.Request{} - instance := handler.EnqueueRequestsFromMapFunc{ - ToRequests: handler.ToRequestsFunc(func(a handler.MapObject) []reconcile.Request { - defer GinkgoRecover() - Expect(a.Object).To(Equal(pod)) - req = []reconcile.Request{ - { - NamespacedName: types.NamespacedName{Namespace: "foo", Name: "bar"}, - }, - { - NamespacedName: types.NamespacedName{Namespace: "biz", Name: "baz"}, - }, - } - return req - }), - } + instance := handler.EnqueueRequestsFromMapFunc(func(a handler.MapObject) []reconcile.Request { + defer GinkgoRecover() + Expect(a.Object).To(Equal(pod)) + req = []reconcile.Request{ + { + NamespacedName: types.NamespacedName{Namespace: "foo", Name: "bar"}, + }, + { + NamespacedName: types.NamespacedName{Namespace: "biz", Name: "baz"}, + }, + } + return req + }) evt := event.DeleteEvent{ Object: pod, @@ -262,20 +258,19 @@ var _ = Describe("Eventhandler", func() { newPod.Namespace = pod.Namespace + "2" req := []reconcile.Request{} - instance := handler.EnqueueRequestsFromMapFunc{ - ToRequests: handler.ToRequestsFunc(func(a handler.MapObject) []reconcile.Request { - defer GinkgoRecover() - req = []reconcile.Request{ - { - NamespacedName: types.NamespacedName{Namespace: "foo", Name: a.Object.GetName() + "-bar"}, - }, - { - NamespacedName: types.NamespacedName{Namespace: "biz", Name: a.Object.GetName() + "-baz"}, - }, - } - return req - }), - } + + instance := handler.EnqueueRequestsFromMapFunc(func(a handler.MapObject) []reconcile.Request { + defer GinkgoRecover() + req = []reconcile.Request{ + { + NamespacedName: types.NamespacedName{Namespace: "foo", Name: a.Object.GetName() + "-bar"}, + }, + { + NamespacedName: types.NamespacedName{Namespace: "biz", Name: a.Object.GetName() + "-baz"}, + }, + } + return req + }) evt := event.UpdateEvent{ ObjectOld: pod, @@ -303,21 +298,19 @@ var _ = Describe("Eventhandler", func() { It("should enqueue a Request with the function applied to the GenericEvent.", func() { req := []reconcile.Request{} - instance := handler.EnqueueRequestsFromMapFunc{ - ToRequests: handler.ToRequestsFunc(func(a handler.MapObject) []reconcile.Request { - defer GinkgoRecover() - Expect(a.Object).To(Equal(pod)) - req = []reconcile.Request{ - { - NamespacedName: types.NamespacedName{Namespace: "foo", Name: "bar"}, - }, - { - NamespacedName: types.NamespacedName{Namespace: "biz", Name: "baz"}, - }, - } - return req - }), - } + instance := handler.EnqueueRequestsFromMapFunc(func(a handler.MapObject) []reconcile.Request { + defer GinkgoRecover() + Expect(a.Object).To(Equal(pod)) + req = []reconcile.Request{ + { + NamespacedName: types.NamespacedName{Namespace: "foo", Name: "bar"}, + }, + { + NamespacedName: types.NamespacedName{Namespace: "biz", Name: "baz"}, + }, + } + return req + }) evt := event.GenericEvent{ Object: pod, diff --git a/pkg/handler/example_test.go b/pkg/handler/example_test.go index b6d96ea2ff..c2f32e5d8f 100644 --- a/pkg/handler/example_test.go +++ b/pkg/handler/example_test.go @@ -65,20 +65,19 @@ func ExampleEnqueueRequestsFromMapFunc() { // controller is a controller.controller err := c.Watch( &source.Kind{Type: &appsv1.Deployment{}}, - &handler.EnqueueRequestsFromMapFunc{ - ToRequests: handler.ToRequestsFunc(func(a handler.MapObject) []reconcile.Request { - return []reconcile.Request{ - {NamespacedName: types.NamespacedName{ - Name: a.Object.GetName() + "-1", - Namespace: a.Object.GetNamespace(), - }}, - {NamespacedName: types.NamespacedName{ - Name: a.Object.GetName() + "-2", - Namespace: a.Object.GetNamespace(), - }}, - } - }), - }) + handler.EnqueueRequestsFromMapFunc(func(a handler.MapObject) []reconcile.Request { + return []reconcile.Request{ + {NamespacedName: types.NamespacedName{ + Name: a.Object.GetName() + "-1", + Namespace: a.Object.GetNamespace(), + }}, + {NamespacedName: types.NamespacedName{ + Name: a.Object.GetName() + "-2", + Namespace: a.Object.GetNamespace(), + }}, + } + }), + ) if err != nil { // handle it }