Drop "Source" and "Handler" from source and handler implementations.

Author: pwittrock

example/main.go

@@ -24,7 +24,7 @@ import (
 	"github.com/kubernetes-sigs/controller-runtime/pkg/client"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/client/config"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/controller"
-	"github.com/kubernetes-sigs/controller-runtime/pkg/eventhandler"
+	"github.com/kubernetes-sigs/controller-runtime/pkg/handler"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/manager"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/reconcile"
 	logf "github.com/kubernetes-sigs/controller-runtime/pkg/runtime/log"
@@ -47,29 +47,21 @@ func main() {
 	}
 
 	// Setup a new controller to Reconcile ReplicaSets
-	c, err := controller.New(
-		"foo-controller",
-		mrg,
-		controller.Options{Reconcile: &reconcileReplicaSet{client: mrg.GetClient()}})
+	c, err := controller.New("foo-controller", mrg, controller.Options{
+		Reconcile: &reconcileReplicaSet{client: mrg.GetClient()},
+	})
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	err = c.Watch(
-		// Watch ReplicaSets
-		&source.KindSource{Type: &appsv1.ReplicaSet{}},
-		// Enqueue ReplicaSet object key
-		&eventhandler.EnqueueHandler{})
-	if err != nil {
+	// Watch ReplicaSets and enqueue ReplicaSet object key
+	if err := c.Watch(&source.Kind{Type: &appsv1.ReplicaSet{}}, &handler.Enqueue{}); err != nil {
 		log.Fatal(err)
 	}
 
-	err = c.Watch(
-		// Watch Pods
-		&source.KindSource{Type: &corev1.Pod{}},
-		// Enqueue Owning ReplicaSet object key
-		&eventhandler.EnqueueOwnerHandler{OwnerType: &appsv1.ReplicaSet{}, IsController: true})
-	if err != nil {
+	// Watch Pods and enqueue owning ReplicaSet key
+	if err := c.Watch(&source.Kind{Type: &corev1.Pod{}},
+		&handler.EnqueueOwner{OwnerType: &appsv1.ReplicaSet{}, IsController: true}); err != nil {
 		log.Fatal(err)
 	}
 

pkg/controller/controller.go

@@ -19,7 +19,7 @@ package controller
 import (
 	"fmt"
 
-	"github.com/kubernetes-sigs/controller-runtime/pkg/eventhandler"
+	"github.com/kubernetes-sigs/controller-runtime/pkg/handler"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/internal/controller"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/manager"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/predicate"
@@ -48,7 +48,7 @@ type Controller interface {
 	//
 	// Watch may be provided one or more Predicates to filter events before they are given to the EventHandler.
 	// Events will be passed to the EventHandler iff all provided Predicates evaluate to true.
-	Watch(src source.Source, evthdler eventhandler.EventHandler, prct ...predicate.Predicate) error
+	Watch(src source.Source, evthdler handler.EventHandler, prct ...predicate.Predicate) error
 
 	// Start starts the controller.  Start blocks until stop is closed or a controller has an error starting.
 	Start(stop <-chan struct{}) error

pkg/controller/controller_integration_test.go

@@ -18,7 +18,7 @@ package controller_test
 
 import (
 	"github.com/kubernetes-sigs/controller-runtime/pkg/controller"
-	"github.com/kubernetes-sigs/controller-runtime/pkg/eventhandler"
+	"github.com/kubernetes-sigs/controller-runtime/pkg/handler"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/reconcile"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/source"
 	appsv1 "k8s.io/api/apps/v1"
@@ -65,12 +65,12 @@ var _ = Describe("controller", func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			By("Watching Resources")
-			err = instance.Watch(&source.KindSource{Type: &appsv1.ReplicaSet{}}, &eventhandler.EnqueueOwnerHandler{
+			err = instance.Watch(&source.Kind{Type: &appsv1.ReplicaSet{}}, &handler.EnqueueOwner{
 				OwnerType: &appsv1.Deployment{},
 			})
 			Expect(err).NotTo(HaveOccurred())
 
-			err = instance.Watch(&source.KindSource{Type: &appsv1.Deployment{}}, &eventhandler.EnqueueHandler{})
+			err = instance.Watch(&source.Kind{Type: &appsv1.Deployment{}}, &handler.Enqueue{})
 			Expect(err).NotTo(HaveOccurred())
 
 			By("Starting the Manager")

pkg/controller/example_test.go

@@ -20,7 +20,7 @@ import (
 	"log"
 
 	"github.com/kubernetes-sigs/controller-runtime/pkg/controller"
-	"github.com/kubernetes-sigs/controller-runtime/pkg/eventhandler"
+	"github.com/kubernetes-sigs/controller-runtime/pkg/handler"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/manager"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/reconcile"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/runtime/signals"
@@ -57,7 +57,7 @@ func ExampleController_Watch() {
 		log.Fatal(err)
 	}
 
-	err = c.Watch(&source.KindSource{Type: &v1.Pod{}}, &eventhandler.EnqueueHandler{})
+	err = c.Watch(&source.Kind{Type: &v1.Pod{}}, &handler.Enqueue{})
 	if err != nil {
 		log.Fatal(err)
 	}

pkg/eventhandler/doc.go renamed to pkg/handler/doc.go

@@ -20,11 +20,11 @@ observed from Watching Kubernetes APIs.
 
 EventHandlers
 
-EnqueueHandler - Enqueues a reconcile.equest containing the Name and Namespace of the object in the Event.
+Enqueue - Enqueues a reconcile.Request containing the Name and Namespace of the object in the Event.
 
-EnqueueOwnerHandler - Enqueues a reconcile.Request containing the Name and Namespace of the Owner of the object in the Event.
+EnqueueOwner - Enqueues a reconcile.Request containing the Name and Namespace of the Owner of the object in the Event.
 
-EnqueueMappedHander - Enqueues Rreconcile.Requests resulting from a user provided transformation function run against the
+EnqueueMapped - Enqueues Reconcile.Requests resulting from a user provided transformation function run against the
 object in the Event.
 */
-package eventhandler
+package handler

pkg/eventhandler/enqueue.go renamed to pkg/handler/enqueue.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package eventhandler
+package handler
 
 import (
 	"github.com/kubernetes-sigs/controller-runtime/pkg/event"
@@ -24,15 +24,15 @@ import (
 	"k8s.io/client-go/util/workqueue"
 )
 
-var enqueueLog = logf.KBLog.WithName("eventhandler").WithName("EnqueueHandler")
+var enqueueLog = logf.KBLog.WithName("eventhandler").WithName("Enqueue")
 
-var _ EventHandler = &EnqueueHandler{}
+var _ EventHandler = &Enqueue{}
 
-// EnqueueHandler enqueues a Request containing the Name and Namespace of the object for each event.
-type EnqueueHandler struct{}
+// Enqueue enqueues a Request containing the Name and Namespace of the object for each event.
+type Enqueue struct{}
 
 // Create implements EventHandler
-func (e *EnqueueHandler) Create(q workqueue.RateLimitingInterface, evt event.CreateEvent) {
+func (e *Enqueue) Create(q workqueue.RateLimitingInterface, evt event.CreateEvent) {
 	if evt.Meta == nil {
 		enqueueLog.Error(nil, "CreateEvent received with no metadata", "CreateEvent", evt)
 		return
@@ -44,7 +44,7 @@ func (e *EnqueueHandler) Create(q workqueue.RateLimitingInterface, evt event.Cre
 }
 
 // Update implements EventHandler
-func (e *EnqueueHandler) Update(q workqueue.RateLimitingInterface, evt event.UpdateEvent) {
+func (e *Enqueue) Update(q workqueue.RateLimitingInterface, evt event.UpdateEvent) {
 	if evt.MetaOld != nil {
 		q.AddRateLimited(reconcile.Request{NamespacedName: types.NamespacedName{
 			Name:      evt.MetaOld.GetName(),
@@ -65,7 +65,7 @@ func (e *EnqueueHandler) Update(q workqueue.RateLimitingInterface, evt event.Upd
 }
 
 // Delete implements EventHandler
-func (e *EnqueueHandler) Delete(q workqueue.RateLimitingInterface, evt event.DeleteEvent) {
+func (e *Enqueue) Delete(q workqueue.RateLimitingInterface, evt event.DeleteEvent) {
 	if evt.Meta == nil {
 		enqueueLog.Error(nil, "DeleteEvent received with no metadata", "DeleteEvent", evt)
 		return
@@ -77,7 +77,7 @@ func (e *EnqueueHandler) Delete(q workqueue.RateLimitingInterface, evt event.Del
 }
 
 // Generic implements EventHandler
-func (e *EnqueueHandler) Generic(q workqueue.RateLimitingInterface, evt event.GenericEvent) {
+func (e *Enqueue) Generic(q workqueue.RateLimitingInterface, evt event.GenericEvent) {
 	if evt.Meta == nil {
 		enqueueLog.Error(nil, "GenericEvent received with no metadata", "GenericEvent", evt)
 		return

pkg/eventhandler/enqueue_mapped.go renamed to pkg/handler/enqueue_mapped.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package eventhandler
+package handler
 
 import (
 	"github.com/kubernetes-sigs/controller-runtime/pkg/event"
@@ -24,39 +24,39 @@ import (
 	"k8s.io/client-go/util/workqueue"
 )
 
-var _ EventHandler = &EnqueueMappedHandler{}
+var _ EventHandler = &EnqueueMapped{}
 
-// EnqueueMappedHandler enqueues Requests by running a transformation function on each Event.
+// EnqueueMapped enqueues Requests by running a transformation function on each Event.
 //
 // 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 EnqueueMappedHandler struct {
+type EnqueueMapped struct {
 	// Mapper transforms the argument into a slice of keys to be reconciled
 	ToRequests Mapper
 }
 
 // Create implements EventHandler
-func (e *EnqueueMappedHandler) Create(q workqueue.RateLimitingInterface, evt event.CreateEvent) {
+func (e *EnqueueMapped) Create(q workqueue.RateLimitingInterface, evt event.CreateEvent) {
 	e.mapAndEnqueue(q, MapObject{Meta: evt.Meta, Object: evt.Object})
 }
 
 // Update implements EventHandler
-func (e *EnqueueMappedHandler) Update(q workqueue.RateLimitingInterface, evt event.UpdateEvent) {
+func (e *EnqueueMapped) Update(q workqueue.RateLimitingInterface, evt event.UpdateEvent) {
 	e.mapAndEnqueue(q, MapObject{Meta: evt.MetaOld, Object: evt.ObjectOld})
 	e.mapAndEnqueue(q, MapObject{Meta: evt.MetaNew, Object: evt.ObjectNew})
 }
 
 // Delete implements EventHandler
-func (e *EnqueueMappedHandler) Delete(q workqueue.RateLimitingInterface, evt event.DeleteEvent) {
+func (e *EnqueueMapped) Delete(q workqueue.RateLimitingInterface, evt event.DeleteEvent) {
 	e.mapAndEnqueue(q, MapObject{Meta: evt.Meta, Object: evt.Object})
 }
 
 // Generic implements EventHandler
-func (e *EnqueueMappedHandler) Generic(q workqueue.RateLimitingInterface, evt event.GenericEvent) {
+func (e *EnqueueMapped) Generic(q workqueue.RateLimitingInterface, evt event.GenericEvent) {
 	e.mapAndEnqueue(q, MapObject{Meta: evt.Meta, Object: evt.Object})
 }
 
-func (e *EnqueueMappedHandler) mapAndEnqueue(q workqueue.RateLimitingInterface, object MapObject) {
+func (e *EnqueueMapped) mapAndEnqueue(q workqueue.RateLimitingInterface, object MapObject) {
 	for _, req := range e.ToRequests.Map(object) {
 		q.AddRateLimited(req)
 	}

pkg/eventhandler/enqueue_owner.go renamed to pkg/handler/enqueue_owner.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package eventhandler
+package handler
 
 import (
 	"fmt"
@@ -30,19 +30,19 @@ import (
 	"k8s.io/client-go/util/workqueue"
 )
 
-var _ EventHandler = &EnqueueOwnerHandler{}
+var _ EventHandler = &EnqueueOwner{}
 
-var log = logf.KBLog.WithName("eventhandler").WithName("EnqueueOwnerHandler")
+var log = logf.KBLog.WithName("eventhandler").WithName("EnqueueOwner")
 
-// EnqueueOwnerHandler enqueues Requests for the Owners of an object.  E.g. an object that created
+// EnqueueOwner enqueues Requests for the Owners of an object.  E.g. an object that created
 // another object.
 //
 // If a ReplicaSet creates Pods, reconcile the ReplicaSet in response to events on Pods that it created using:
 //
 // - a KindSource with Type Pod.
 //
-// - a EnqueueOwnerHandler with OwnerType ReplicaSet.
-type EnqueueOwnerHandler struct {
+// - a EnqueueOwner with OwnerType ReplicaSet.
+type EnqueueOwner struct {
 	// OwnerType is the type of the Owner object to look for in OwnerReferences.  Only Group and Kind are compared.
 	OwnerType runtime.Object
 
@@ -53,22 +53,22 @@ type EnqueueOwnerHandler struct {
 	groupKind schema.GroupKind
 }
 
-var _ inject.Scheme = &EnqueueOwnerHandler{}
+var _ inject.Scheme = &EnqueueOwner{}
 
-// InjectScheme is called by the Controller to provide a singleton scheme to the EnqueueOwnerHandler.
-func (e *EnqueueOwnerHandler) InjectScheme(s *runtime.Scheme) error {
+// InjectScheme is called by the Controller to provide a singleton scheme to the EnqueueOwner.
+func (e *EnqueueOwner) InjectScheme(s *runtime.Scheme) error {
 	return e.parseOwnerTypeGroupKind(s)
 }
 
 // Create implements EventHandler
-func (e *EnqueueOwnerHandler) Create(q workqueue.RateLimitingInterface, evt event.CreateEvent) {
+func (e *EnqueueOwner) Create(q workqueue.RateLimitingInterface, evt event.CreateEvent) {
 	for _, req := range e.getOwnerReconcileRequest(evt.Meta) {
 		q.AddRateLimited(req)
 	}
 }
 
 // Update implements EventHandler
-func (e *EnqueueOwnerHandler) Update(q workqueue.RateLimitingInterface, evt event.UpdateEvent) {
+func (e *EnqueueOwner) Update(q workqueue.RateLimitingInterface, evt event.UpdateEvent) {
 	for _, req := range e.getOwnerReconcileRequest(evt.MetaOld) {
 		q.AddRateLimited(req)
 	}
@@ -78,22 +78,22 @@ func (e *EnqueueOwnerHandler) Update(q workqueue.RateLimitingInterface, evt even
 }
 
 // Delete implements EventHandler
-func (e *EnqueueOwnerHandler) Delete(q workqueue.RateLimitingInterface, evt event.DeleteEvent) {
+func (e *EnqueueOwner) Delete(q workqueue.RateLimitingInterface, evt event.DeleteEvent) {
 	for _, req := range e.getOwnerReconcileRequest(evt.Meta) {
 		q.AddRateLimited(req)
 	}
 }
 
 // Generic implements EventHandler
-func (e *EnqueueOwnerHandler) Generic(q workqueue.RateLimitingInterface, evt event.GenericEvent) {
+func (e *EnqueueOwner) Generic(q workqueue.RateLimitingInterface, evt event.GenericEvent) {
 	for _, req := range e.getOwnerReconcileRequest(evt.Meta) {
 		q.AddRateLimited(req)
 	}
 }
 
 // parseOwnerTypeGroupKind parses the OwnerType into a Group and Kind and caches the result.  Returns false
 // if the OwnerType could not be parsed using the scheme.
-func (e *EnqueueOwnerHandler) parseOwnerTypeGroupKind(scheme *runtime.Scheme) error {
+func (e *EnqueueOwner) parseOwnerTypeGroupKind(scheme *runtime.Scheme) error {
 	// Get the kinds of the type
 	kinds, _, err := scheme.ObjectKinds(e.OwnerType)
 	if err != nil {
@@ -114,7 +114,7 @@ func (e *EnqueueOwnerHandler) parseOwnerTypeGroupKind(scheme *runtime.Scheme) er
 
 // getOwnerReconcileRequest looks at object and returns a slice of reconcile.Request to reconcile
 // owners of object that match e.OwnerType.
-func (e *EnqueueOwnerHandler) getOwnerReconcileRequest(object metav1.Object) []reconcile.Request {
+func (e *EnqueueOwner) getOwnerReconcileRequest(object metav1.Object) []reconcile.Request {
 	// Iterate through the OwnerReferences looking for a match on Group and Kind against what was requested
 	// by the user
 	var result []reconcile.Request
@@ -144,10 +144,10 @@ func (e *EnqueueOwnerHandler) getOwnerReconcileRequest(object metav1.Object) []r
 	return result
 }
 
-// getOwnersReferences returns the OwnerReferences for an object as specified by the EnqueueOwnerHandler
+// getOwnersReferences returns the OwnerReferences for an object as specified by the EnqueueOwner
 // - if IsController is true: only take the Controller OwnerReference (if found)
 // - if IsController is false: take all OwnerReferences
-func (e *EnqueueOwnerHandler) getOwnersReferences(object metav1.Object) []metav1.OwnerReference {
+func (e *EnqueueOwner) getOwnersReferences(object metav1.Object) []metav1.OwnerReference {
 	if object == nil {
 		return nil
 	}

pkg/eventhandler/eventhandler.go renamed to pkg/handler/eventhandler.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package eventhandler
+package handler
 
 import (
 	"github.com/kubernetes-sigs/controller-runtime/pkg/event"
@@ -27,10 +27,10 @@ import (
 //
 // Identical reconcile.Requests will be batched together through the queuing mechanism before reconcile is called.
 //
-// * Use EnqueueHandler to reconcile the object the event is for
+// * Use Enqueue to reconcile the object the event is for
 // - do this for events for the type the Controller Reconciles. (e.g. Deployment for a Deployment Controller)
 //
-// * Use EnqueueOwnerHandler to reconcile the owner of the object the event is for
+// * Use EnqueueOwner to reconcile the owner of the object the event is for
 // - do this for events for the types the Controller creates.  (e.g. ReplicaSets created by a Deployment Controller)
 //
 // * Use EnqueueMappendHandler to transform an event for an object to a reconcile of an object

pkg/eventhandler/eventhandler_suite_test.go renamed to pkg/handler/eventhandler_suite_test.go

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