Move operator package under patterns/

Author: pwittrock

pkg/operator/doc.go renamed to pkg/patterns/operator/doc.go

@@ -22,13 +22,11 @@ limitations under the License.
 // An Operator is a Controller that implements the operational logic for an Application.  It is often used
 // to take off-the-shelf OSS applications, and make them Kubernetes native.
 //
-//	// Create an Operator
-//	op, err := operator.New(config.GetConfigOrDie())
+//	op, err := operator.New(&appsv1.ReplicaSet{}, &corev1.Pod{})
 //	if err != nil {
 //		log.Fatal(err)
 //	}
 //
-//
 //	// Implement the Operator logic for a single type - e.g. ReplicaSet
 //	rsRecFn := reconcile.Func(func(req reconcile.Request) (reconcile.Result, error) {
 //		// Read the ReplicaSet
@@ -43,9 +41,5 @@ limitations under the License.
 //		return reconcile.Result{}, nil
 //	})
 //
-//	// Handle events (e.g. create, update, delete operations) for a type and owned types - e.g. ReplicaSets and Pods
-//	err = op.HandleType(rsRecFn, &appsv1.ReplicaSet{}, &corev1.Pod{})
-//	if err != nil {
-//		log.Fatal(err)
-//	}
+//	log.Fatal(op.Start(rsRecFn))
 package operator

pkg/operator/example_test.go renamed to pkg/patterns/operator/example_test.go

@@ -18,13 +18,11 @@ package operator_test
 
 import (
 	"context"
-	"log"
-
 	"fmt"
+	"log"
 
 	"github.com/kubernetes-sigs/controller-runtime/pkg/client"
-	"github.com/kubernetes-sigs/controller-runtime/pkg/client/config"
-	"github.com/kubernetes-sigs/controller-runtime/pkg/operator"
+	"github.com/kubernetes-sigs/controller-runtime/pkg/patterns/operator"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/reconcile"
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
@@ -33,24 +31,21 @@ import (
 
 // This example creates a simple Operator that is configured for Deployments and ReplicaSets.
 //
-// * Create a new Operator
+// * Create a new Operator for ReplicaSets.  Watch Pods owned by ReplicaSets and Reconcile the ReplicaSet.
 //
-// * Setup ReplicaSet handling
-//
-// * Setup Deployment handling
-//
-// * Start the Operator
+// * Start the Operator with the Reconcile function.
 func ExampleOperator() {
-	// Create a new Operator
-	op, err := operator.New(config.GetConfigOrDie())
+	// Create a new Operator for ReplicaSet
+
+	op, err := operator.New(&appsv1.ReplicaSet{}, &corev1.Pod{})
 	if err != nil {
 		log.Fatal(err)
 	}
 
+	// Implement the business logic:
 	// This function will be called when there is a change to a ReplicaSet or a Pod with an OwnerReference
-	// to a ReplicaSet.  It will contain the Namespace / Name of the ReplicaSet.
+	// to a ReplicaSet.
 	//
-	// Reconcile performs the following actions
 	// * Read the ReplicaSet
 	// * Read the Pods
 	// * Set a Label on the ReplicaSet with the Pod count
@@ -80,35 +75,10 @@ func ExampleOperator() {
 			return reconcile.Result{}, err
 		}
 
+		// Done
 		return reconcile.Result{}, nil
 	})
 
-	// Watch ReplicaSets and Pods owned by ReplicaSets and call recFn with the Namespace / Name of the ReplicaSet
-	err = op.HandleType(rsRecFn, &appsv1.ReplicaSet{}, &corev1.Pod{})
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// This function will be called when there is a change to a Deployment or a ReplicaSet with an OwnerReference
-	// to a Deployment.  It will contain the Namespace / Name of the Deployment.
-	depRecFn := reconcile.Func(func(req reconcile.Request) (reconcile.Result, error) {
-		dep := &appsv1.Deployment{}
-		err := op.GetClient().Get(context.TODO(), req.NamespacedName, dep)
-		if err != nil {
-			return reconcile.Result{}, err
-		}
-
-		log.Printf("TODO: Implement Deployment Reconcile here.")
-		return reconcile.Result{}, nil
-	})
-
-	// Watch Deployments and ReplicaSets owned by Deployments and call recFn with the Namespace / Name of the
-	// Deployment
-	err = op.HandleType(depRecFn, &appsv1.Deployment{}, &appsv1.ReplicaSet{})
-	if err != nil {
-		log.Fatal(err)
-	}
-
 	// Start the Operator
-	log.Fatal(op.Start())
+	log.Fatal(op.Start(rsRecFn))
 }

pkg/operator/operator.go renamed to pkg/patterns/operator/operator.go

@@ -22,93 +22,97 @@ import (
 
 	"github.com/kubernetes-sigs/controller-runtime/pkg/client"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/client/apiutil"
+	"github.com/kubernetes-sigs/controller-runtime/pkg/client/config"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/controller"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/handler"
+	internalcontroller "github.com/kubernetes-sigs/controller-runtime/pkg/internal/controller"
 	"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"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/source"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/rest"
 )
 
 // Operator is a very simple Controller that embeds a Manager.
 type Operator struct {
 	mrg    manager.Manager
 	stopFn func() <-chan struct{}
-
-	// Allow deps to be mocked out for testing
-	newController func(name string, mrg manager.Manager, options controller.Options) (controller.Controller, error)
-	getGvk        func(obj runtime.Object, scheme *runtime.Scheme) (schema.GroupVersionKind, error)
+	ctrl   *internalcontroller.Controller
 }
 
-// New returns a new Operator
-func New(config *rest.Config) (*Operator, error) {
-	mrg, err := manager.New(config, manager.Options{})
-	if err != nil {
-		return nil, err
-	}
+var noop = reconcile.Func(func(reconcile.Request) (reconcile.Result, error) {
+	return reconcile.Result{}, nil
+})
 
-	o := &Operator{
-		mrg:           mrg,
-		stopFn:        signals.SetupSignalHandler,
-		newController: controller.New,
-		getGvk:        apiutil.GVKForObject,
-	}
-	return o, nil
-}
+var getConfig = config.GetConfig
+var newController = controller.New
+var newManager = manager.New
+var getGvk = apiutil.GVKForObject
 
-// HandleType configures the Operator for a Kubernetes Resource type.
+// New returns a new Operator for a Kubernetes Resource type.
 //
 // * Watch for changes (e.g. create,update,delete operations) to objects of the Resource type
 //
 // * Watch for changes to objects created or managed by the Resource type.
 //
 // * Reconcile the object that was changed or that owns the changed objects.
 //
-// impl: the Reconcile implementation.  reconcile.Reconcile is a function that may be called at anytime with the
-// name / Namespace of an object.  When called, it will ensure that the state of the system matches what is
-// specified in the object at the time reconcile is called.
-//
 // reconcileObject: the type of the Kubernetes object that will be Watched and Reconciled - e.g. &v1.ReplicaSet{}
 //
 // ownedTypes: list of types of objects that may be created or managed by the reconcileObject.  These
 // objects must have the OwnersReference set to the owning object in the ObjectMeta - e.g. &v1.Pod{}
-func (o *Operator) HandleType(impl reconcile.Reconcile,
-	reconcileObject runtime.Object, ownedTypes ...runtime.Object) error {
+func New(reconcileObject runtime.Object, ownedTypes ...runtime.Object) (*Operator, error) {
+	c, err := getConfig()
+	if err != nil {
+		return nil, err
+	}
+	mrg, err := newManager(c, manager.Options{})
+	if err != nil {
+		return nil, err
+	}
 
-	gvk, err := o.getGvk(reconcileObject, o.mrg.GetScheme())
+	o := &Operator{
+		mrg:    mrg,
+		stopFn: signals.SetupSignalHandler,
+	}
+
+	gvk, err := getGvk(reconcileObject, o.mrg.GetScheme())
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// Create the controller
 	name := fmt.Sprintf("%s-operator", strings.ToLower(gvk.Kind))
-	c, err := o.newController(name, o.mrg, controller.Options{Reconcile: impl})
+	ctrl, err := newController(name, mrg, controller.Options{Reconcile: noop})
 	if err != nil {
-		return err
+		return nil, err
 	}
+	o.ctrl = ctrl.(*internalcontroller.Controller)
 
 	// Reconcile type
-	err = c.Watch(&source.Kind{Type: reconcileObject}, &handler.Enqueue{})
+	err = o.ctrl.Watch(&source.Kind{Type: reconcileObject}, &handler.Enqueue{})
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// Watch the managed types
 	for _, t := range ownedTypes {
-		err = c.Watch(&source.Kind{Type: t}, &handler.EnqueueOwner{OwnerType: reconcileObject, IsController: true})
+		err = o.ctrl.Watch(&source.Kind{Type: t}, &handler.EnqueueOwner{OwnerType: reconcileObject, IsController: true})
 		if err != nil {
-			return err
+			return nil, err
 		}
 	}
 
-	return err
+	return o, nil
 }
 
 // Start starts the Operator and blocks until the program is shutdown.
-func (o *Operator) Start() error {
+//
+// call: the Reconcile implementation.  reconcile.Reconcile is a function that may be called at anytime with the
+// name / Namespace of an object.  When called, it will ensure that the state of the system matches what is
+// specified in the object at the time reconcile is called.
+func (o *Operator) Start(call reconcile.Reconcile) error {
+	o.ctrl.Do = call
 	return o.mrg.Start(o.stopFn())
 }
 

pkg/operator/operator_suite_test.go renamed to pkg/patterns/operator/operator_suite_test.go

@@ -5,6 +5,7 @@ import (
 
 	"context"
 
+	"github.com/kubernetes-sigs/controller-runtime/pkg/client/apiutil"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/controller"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/manager"
 	"github.com/kubernetes-sigs/controller-runtime/pkg/reconcile"
@@ -16,80 +17,90 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/rest"
 )
 
 var _ = Describe("Operator", func() {
 	var stop chan struct{}
-	var r reconcile.Func
 
 	BeforeEach(func() {
 		stop = make(chan struct{})
-		r = reconcile.Func(func(reconcile.Request) (reconcile.Result, error) { return reconcile.Result{}, nil })
+		getConfig = func() (*rest.Config, error) { return cfg, nil }
+		newController = controller.New
+		newManager = manager.New
+		getGvk = apiutil.GVKForObject
 	})
 
 	AfterEach(func() {
 		close(stop)
 	})
 
-	Describe("New", func() {
-		It("should fail if the Config is invalid", func() {
-			instance, err := New(nil)
-			Expect(err).To(HaveOccurred())
-			Expect(instance).To(BeNil())
+	Describe("noop", func() {
+		It("should return run", func() {
+			_, err := noop.Reconcile(reconcile.Request{})
+			Expect(err).NotTo(HaveOccurred())
 		})
 	})
 
-	Describe("HandleType", func() {
+	Describe("New", func() {
 		It("should return success if given valid objects", func() {
-			instance, err := New(cfg)
+			instance, err := New(&appsv1.ReplicaSet{}, &appsv1.ReplicaSet{})
 			Expect(err).NotTo(HaveOccurred())
+			Expect(instance).NotTo(BeNil())
+		})
 
-			err = instance.HandleType(r, &appsv1.ReplicaSet{}, &appsv1.ReplicaSet{})
-			Expect(err).NotTo(HaveOccurred())
+		It("should return an error if the Config is invalid", func() {
+			getConfig = func() (*rest.Config, error) { return cfg, fmt.Errorf("expected error") }
+			instance, err := New(&appsv1.ReplicaSet{}, &appsv1.ReplicaSet{})
+			Expect(err).To(HaveOccurred())
+			Expect(instance).To(BeNil())
 		})
 
 		It("should return an error if there is no GVK for an object", func() {
-			instance, err := New(cfg)
-			Expect(err).NotTo(HaveOccurred())
+			instance, err := New(fakeType(""), &appsv1.ReplicaSet{})
+			Expect(err).To(HaveOccurred())
+			Expect(instance).To(BeNil())
 
-			err = instance.HandleType(r, fakeType(""), &appsv1.ReplicaSet{})
+			instance, err = New(&appsv1.ReplicaSet{}, fakeType(""))
 			Expect(err).To(HaveOccurred())
+			Expect(instance).To(BeNil())
+		})
 
-			err = instance.HandleType(r, &appsv1.ReplicaSet{}, fakeType(""))
+		It("should return an error if it cannot create the manager", func() {
+			newManager = func(config *rest.Config, options manager.Options) (manager.Manager, error) {
+				return nil, fmt.Errorf("expected error")
+			}
+			instance, err := New(&appsv1.ReplicaSet{}, &appsv1.ReplicaSet{})
 			Expect(err).To(HaveOccurred())
+			Expect(instance).To(BeNil())
 		})
 
 		It("should return an error if it cannot create the controller", func() {
-			instance, err := New(cfg)
-			Expect(err).NotTo(HaveOccurred())
-
-			instance.newController = func(name string, mrg manager.Manager, options controller.Options) (
+			newController = func(name string, mrg manager.Manager, options controller.Options) (
 				controller.Controller, error) {
 
 				return nil, fmt.Errorf("expected error")
 			}
-			err = instance.HandleType(r, &appsv1.ReplicaSet{}, &appsv1.ReplicaSet{})
+			instance, err := New(&appsv1.ReplicaSet{}, &appsv1.ReplicaSet{})
 			Expect(err).To(HaveOccurred())
+			Expect(instance).To(BeNil())
 		})
 
 		It("should return an error if it cannot call handle", func() {
-			instance, err := New(cfg)
-			Expect(err).NotTo(HaveOccurred())
-
 			// Prevent getGVK from failing so watch fails
-			instance.getGvk = func(obj runtime.Object, scheme *runtime.Scheme) (schema.GroupVersionKind, error) {
+			getGvk = func(obj runtime.Object, scheme *runtime.Scheme) (schema.GroupVersionKind, error) {
 				return schema.GroupVersionKind{Kind: "foo"}, nil
 			}
-			err = instance.HandleType(r, fakeType(""), &appsv1.ReplicaSet{})
+			instance, err := New(fakeType(""), &appsv1.ReplicaSet{})
 			Expect(err).To(HaveOccurred())
+			Expect(instance).To(BeNil())
 		})
 	})
 
-	Describe("Running", func() {
-
+	Describe("Start", func() {
 		It("should Reconcile objects", func(done Done) {
 			By("Creating the Operator")
-			instance, err := New(cfg)
+			instance, err := New(&appsv1.Deployment{}, &appsv1.ReplicaSet{})
 			Expect(err).NotTo(HaveOccurred())
 
 			// set the stopFn so we shutdown at the end of the test instead of waiting for a signal
@@ -103,13 +114,12 @@ var _ = Describe("Operator", func() {
 				ch <- r
 				return reconcile.Result{}, nil
 			})
-			err = instance.HandleType(fn, &appsv1.Deployment{}, &appsv1.ReplicaSet{})
 			Expect(err).NotTo(HaveOccurred())
 
 			By("Starting the Operator")
 			go func() {
 				defer GinkgoRecover()
-				Expect(instance.Start()).NotTo(HaveOccurred())
+				Expect(instance.Start(fn)).NotTo(HaveOccurred())
 				By("Stopping the Operator")
 			}()