Implement predicate

Author: fanzhangio

pkg/predicate/predicate.go

@@ -16,7 +16,12 @@ limitations under the License.
 
 package predicate
 
-import "sigs.k8s.io/controller-runtime/pkg/event"
+import (
+	"sigs.k8s.io/controller-runtime/pkg/event"
+	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
+)
+
+var predicateLog = logf.KBLog.WithName("predicate").WithName("eventFilters")
 
 // Predicate filters events before enqueuing the keys.
 type Predicate interface {
@@ -35,6 +40,16 @@ type Predicate interface {
 
 var _ Predicate = Funcs{}
 
+// DefaultPredicate returns a set of default predicate functions
+func DefaultPredicate() Funcs {
+	return Funcs{
+		CreateFunc:  defaultCreateFunc,
+		DeleteFunc:  defaultDeleteFunc,
+		UpdateFunc:  defaultUpdateFunc,
+		GenericFunc: defaultGeneric,
+	}
+}
+
 // Funcs is a function that implements Predicate.
 type Funcs struct {
 	// Create returns true if the Create event should be processed
@@ -81,3 +96,55 @@ func (p Funcs) Generic(e event.GenericEvent) bool {
 	}
 	return true
 }
+
+func defaultCreateFunc(e event.CreateEvent) bool {
+	if e.Meta == nil {
+		predicateLog.Error(nil, "CreateEvent has no metadata", "CreateEvent", e)
+		return false
+	}
+	if e.Object == nil {
+		predicateLog.Error(nil, "CreateEvent has no runtime object", "CreateEvent", e)
+		return false
+	}
+	return true
+}
+
+func defaultDeleteFunc(e event.DeleteEvent) bool {
+	if e.Meta == nil {
+		predicateLog.Error(nil, "CreateEvent has no object", "CreateEvent", e)
+		return false
+	}
+	return true
+}
+
+func defaultUpdateFunc(e event.UpdateEvent) bool {
+	if e.MetaOld == nil {
+		predicateLog.Error(nil, "UpdateEvent has no old metadata", "UpdateEvent", e)
+		return false
+	}
+	if e.ObjectOld == nil {
+		predicateLog.Error(nil, "GenericEvent has no old runtime object to update", "GenericEvent", e)
+		return false
+	}
+	if e.ObjectNew == nil {
+		predicateLog.Error(nil, "GenericEvent has no new runtime object for update", "GenericEvent", e)
+		return false
+	}
+	if e.MetaNew == nil {
+		predicateLog.Error(nil, "UpdateEvent has no new metadata", "UpdateEvent", e)
+		return false
+	}
+	return true
+}
+
+func defaultGeneric(e event.GenericEvent) bool {
+	if e.Meta == nil {
+		predicateLog.Error(nil, "GenericEvent has no metadata", "GenericEvent", e)
+		return false
+	}
+	if e.Object == nil {
+		predicateLog.Error(nil, "GenericEvent has no runtime object", "GenericEvent", e)
+		return false
+	}
+	return true
+}

pkg/predicate/predicate_suite_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package predicate
+package predicate_test
 
 import (
 	"testing"

pkg/predicate/predicate_test.go

@@ -175,4 +175,78 @@ var _ = Describe("Predicate", func() {
 			close(done)
 		})
 	})
+
+	Describe("Default predicate funcs", func() {
+
+		defaultFuncs := predicate.DefaultPredicate()
+
+		It("should call defaultCreateFunc", func() {
+			By("Return true if the create event should be proccessed")
+			passEvt := event.CreateEvent{
+				Meta:   pod.GetObjectMeta(),
+				Object: pod,
+			}
+			Expect(defaultFuncs.Create(passEvt)).To(BeTrue())
+
+			By("Return false if the create event should not be proccessed")
+			failEvt1 := event.CreateEvent{Meta: pod.GetObjectMeta()}
+			Expect(defaultFuncs.Create(failEvt1)).To(BeFalse())
+			failEvt2 := event.CreateEvent{Object: pod}
+			Expect(defaultFuncs.Create(failEvt2)).To(BeFalse())
+		})
+
+		It("should call defaultDeleteFunc", func() {
+			By("Return true if the delete event should be proccessed")
+			passEvt := event.DeleteEvent{
+				Meta:   pod.GetObjectMeta(),
+				Object: pod,
+			}
+			Expect(defaultFuncs.Delete(passEvt)).To(BeTrue())
+			By("Return false if the delete event should not be proccessed")
+			failEvt := event.DeleteEvent{}
+			Expect(defaultFuncs.Delete(failEvt)).To(BeFalse())
+
+		})
+
+		It("should call defaultUpdateFunc", func() {
+			newPod := pod.DeepCopy()
+			newPod.Name = "baz2"
+			newPod.Namespace = "biz2"
+
+			By("Return true if the update event should be proccessed")
+			passEvt := event.UpdateEvent{
+				MetaOld:   pod.GetObjectMeta(),
+				ObjectOld: pod,
+				MetaNew:   newPod.GetObjectMeta(),
+				ObjectNew: newPod,
+			}
+			Expect(defaultFuncs.Update(passEvt)).To(BeTrue())
+			By("Return false if the udpate event should not be proccessed")
+			failEvt1 := event.UpdateEvent{}
+			failEvt2 := event.UpdateEvent{MetaOld: pod.GetObjectMeta()}
+			failEvt3 := event.UpdateEvent{MetaOld: pod.GetObjectMeta(), ObjectOld: pod}
+			failEvt4 := event.UpdateEvent{MetaOld: pod.GetObjectMeta(), ObjectOld: pod, MetaNew: newPod.GetObjectMeta()}
+			failEvt5 := event.UpdateEvent{MetaOld: pod.GetObjectMeta(), ObjectOld: pod, ObjectNew: newPod}
+			Expect(defaultFuncs.Update(failEvt1)).To(BeFalse())
+			Expect(defaultFuncs.Update(failEvt2)).To(BeFalse())
+			Expect(defaultFuncs.Update(failEvt3)).To(BeFalse())
+			Expect(defaultFuncs.Update(failEvt4)).To(BeFalse())
+			Expect(defaultFuncs.Update(failEvt5)).To(BeFalse())
+		})
+
+		It("should call defaultGeneric", func() {
+			By("Return true if the generic event should be proccessed")
+			passEvt := event.GenericEvent{
+				Meta:   pod.GetObjectMeta(),
+				Object: pod,
+			}
+			Expect(defaultFuncs.Generic(passEvt)).To(BeTrue())
+			By("Return false if the generic event should not be proccessed")
+			failEvt1 := event.GenericEvent{Meta: pod.GetObjectMeta()}
+			Expect(defaultFuncs.Generic(failEvt1)).To(BeFalse())
+			failEvt2 := event.GenericEvent{Object: pod}
+			Expect(defaultFuncs.Generic(failEvt2)).To(BeFalse())
+		})
+	})
+
 })