Add predicates for handling objects

Author: pwittrock

pkg/controller/controller.go

@@ -99,6 +99,12 @@ func (gc *GenericController) WatchAndMapToController(obj metav1.Object, gvks ...
 	return gc.queue.watchForAndMapToController(obj, gvks...)
 }
 
+func (gc *GenericController) WatchAndMapToControllerIf(obj metav1.Object,
+	p handlefunctions.Predicate, gvks ...metav1.GroupVersionKind) error {
+	gc.once.Do(gc.init)
+	return gc.queue.watchForAndMapToControllerIf(obj, p, gvks...)
+}
+
 // WatchAndMap watches objects matching obj's type and enqueues the key returned by mapFn.
 func (gc *GenericController) WatchAndMap(obj metav1.Object, mapFn handlefunctions.ObjToKey) error {
 	gc.once.Do(gc.init)

pkg/controller/handlefunctions/handlerfuncs.go

@@ -26,8 +26,13 @@ import (
 	"k8s.io/client-go/util/workqueue"
 )
 
+var (
+	ResourceVersionChanged = ResourceVersionChangedPredicate{}
+)
+
 // MappingEnqueuingFnProvider provides Fns to map objects to name/namespace keys and enqueue them as messages
 type MappingEnqueuingFnProvider struct {
+	Predicate Predicate
 	// Map maps an object to a key that can be enqueued
 	Map func(interface{}) string
 }
@@ -109,3 +114,64 @@ func MapToSelf(obj interface{}) string {
 
 // ObjToKey returns a string namespace/name key for an object
 type ObjToKey func(interface{}) string
+
+type Predicate interface {
+	HandleUpdate(old, new interface{}) bool
+	HandleDelete(obj interface{}) bool
+	HandleCreate(obj interface{}) bool
+}
+
+type TrueMixin struct{}
+
+func (TrueMixin) HandleUpdate(old, new interface{}) bool {
+	return true
+}
+
+func (TrueMixin) HandleDelete(obj interface{}) bool {
+	return true
+}
+
+func (TrueMixin) HandleCreate(obj interface{}) bool {
+	return true
+}
+
+type FalseMixin struct{}
+
+func (FalseMixin) HandleUpdate(old, new interface{}) bool {
+	return false
+}
+
+func (FalseMixin) HandleDelete(obj interface{}) bool {
+	return false
+}
+
+func (FalseMixin) HandleCreate(obj interface{}) bool {
+	return false
+}
+
+type ConditionalMappingHandler struct {
+	MappingEnqueuingFnProvider
+}
+
+type ResourceVersionChangedPredicate struct {
+	TrueMixin
+}
+
+func (ResourceVersionChangedPredicate) HandleUpdate(old, new interface{}) bool {
+	oldObject, ok := old.(metav1.Object)
+	if !ok {
+		fmt.Errorf("Cannot handle %T because old is not an Object: %v\n", oldObject, oldObject)
+		return false
+	}
+	newObject, ok := new.(metav1.Object)
+	if !ok {
+		fmt.Errorf("Cannot handle %T because new is not an Object: %v\n", newObject, newObject)
+		return false
+	}
+
+	if oldObject.GetResourceVersion() == newObject.GetResourceVersion() {
+		// Periodic resync will send update events for all resources Deployments.
+		return false
+	}
+	return true
+}

pkg/controller/listeningqueue.go

@@ -43,21 +43,30 @@ type listeningQueue struct {
 
 // watchFor watches objects matching obj's type and enqueues their keys.
 func (q *listeningQueue) watchFor(obj metav1.Object) error {
-	return q.addEventHandler(obj, handlefunctions.MappingEnqueuingFnProvider{handlefunctions.MapToSelf})
+	return q.addEventHandler(obj, handlefunctions.MappingEnqueuingFnProvider{Map: handlefunctions.MapToSelf})
 }
 
 // watchForAndMapToController watches objects matching obj's type and enqueues the keys of their controllers.
 func (q *listeningQueue) watchForAndMapToController(obj metav1.Object, gvks ...metav1.GroupVersionKind) error {
 	return q.addEventHandler(obj, handlefunctions.MappingEnqueuingFnProvider{
-		handlefunctions.MapToController{GVK: gvks}.Map,
+		Map: handlefunctions.MapToController{GVK: gvks}.Map,
+	})
+}
+
+// watchForAndMapToControllerIf watches objects matching obj's type and enqueues the keys of their controllers.
+func (q *listeningQueue) watchForAndMapToControllerIf(obj metav1.Object, predicate handlefunctions.Predicate,
+	gvks ...metav1.GroupVersionKind) error {
+	return q.addEventHandler(obj, handlefunctions.MappingEnqueuingFnProvider{
+		Map:       handlefunctions.MapToController{GVK: gvks}.Map,
+		Predicate: predicate,
 	})
 }
 
 // WatchAndMap watches objects matching obj's type and maps them to keys that it then enqueues.
 func (q *listeningQueue) watchForAndMapToNewObjectKey(
 	obj metav1.Object, mappingFn handlefunctions.ObjToKey) error {
 
-	return q.addEventHandler(obj, handlefunctions.MappingEnqueuingFnProvider{mappingFn})
+	return q.addEventHandler(obj, handlefunctions.MappingEnqueuingFnProvider{Map: mappingFn})
 }
 
 // watchForAndHandleEvent watches objects matching obj's type and uses the functions from provider to handle events.