Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

✨ Simplify usage of EnqueueRequestsFromMapFunc #1119

Merged
merged 1 commit into from
Aug 6, 2020
Merged

✨ Simplify usage of EnqueueRequestsFromMapFunc #1119

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
38 changes: 22 additions & 16 deletions pkg/handler/enqueue_mapped.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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 {
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Suggested change
func EnqueueRequestsFromMapFunc(mapFN func(MapObject) []reconcile.Request) EventHandler {
func MapFunc(mapFN func(MapObject) []reconcile.Request) EventHandler {

Do we want to go for something a little simpler? wdyt?

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

All existing mappers are called EnqueueRequestSomething I thought it would be nice to keep that pattern

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It also makes this change easier for existing users

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)
}
Expand All @@ -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
}
Expand All @@ -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)
}
111 changes: 52 additions & 59 deletions pkg/handler/eventhandler_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand All @@ -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,
Expand All @@ -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,
Expand Down Expand Up @@ -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,
Expand Down
27 changes: 13 additions & 14 deletions pkg/handler/example_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
}
Expand Down