🐛 Adding "unmanaged" option for the "controller builder"

pkg/builder/controller.go

@@ -36,6 +36,7 @@ import (
 
 // Supporting mocking out functions for testing.
 var newController = controller.New
+var newUnmanagedController = controller.NewUnmanaged
 var getGvk = apiutil.GVKForObject
 
 // project represents other forms that the we can use to
@@ -59,13 +60,20 @@ type Builder struct {
 	ctrl             controller.Controller
 	ctrlOptions      controller.Options
 	name             string
+	unmanaged        bool
 }
 
 // ControllerManagedBy returns a new controller builder that will be started by the provided Manager.
 func ControllerManagedBy(m manager.Manager) *Builder {
 	return &Builder{mgr: m}
 }
 
+// Unmanaged allows to set the controller to be unmanaged.
+func (blder *Builder) Unmanaged(unmanaged bool) *Builder {
+	blder.unmanaged = unmanaged
+	return blder
+}
+
 // ForInput represents the information set by For method.
 type ForInput struct {
 	object           client.Object
@@ -311,6 +319,10 @@ func (blder *Builder) doController(r reconcile.Reconciler) error {
 	ctrlOptions.Log = ctrlOptions.Log.WithValues("reconciler group", gvk.Group, "reconciler kind", gvk.Kind)
 
 	// Build the controller and return.
+	if blder.unmanaged {
+		blder.ctrl, err = newUnmanagedController(blder.getControllerName(gvk), blder.mgr, ctrlOptions)
+		return err
+	}
 	blder.ctrl, err = newController(blder.getControllerName(gvk), blder.mgr, ctrlOptions)
 	return err
 }

pkg/builder/controller_test.go

@@ -75,16 +75,57 @@ func (l *testLogger) WithName(name string) logr.LogSink {
 	return l
 }
 
+type UnmanagedWrapper struct {
+	controller.Controller
+}
+
 var _ = Describe("application", func() {
 	BeforeEach(func() {
 		newController = controller.New
+		newUnmanagedController = func(name string, mgr manager.Manager, options controller.Options) (controller.Controller, error) {
+			ctrl, err := controller.NewUnmanaged(name, mgr, options)
+			if err != nil {
+				return nil, err
+			}
+			return &UnmanagedWrapper{ctrl}, nil
+		}
 	})
 
 	noop := reconcile.Func(func(context.Context, reconcile.Request) (reconcile.Result, error) {
 		return reconcile.Result{}, nil
 	})
 
 	Describe("New", func() {
+
+		It("should return a non-managed controller when unmanaged is set", func() {
+			By("creating a controller manager")
+			m, err := manager.New(cfg, manager.Options{})
+			Expect(err).NotTo(HaveOccurred())
+
+			instance, err := ControllerManagedBy(m).
+				For(&appsv1.ReplicaSet{}).
+				Owns(&appsv1.ReplicaSet{}).
+				Unmanaged(true).
+				Build(noop)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(instance).To(BeAssignableToTypeOf(&UnmanagedWrapper{}))
+			Expect(instance).NotTo(BeNil())
+		})
+
+		It("should not return a non-managed controller when unmanaged is set", func() {
+			By("creating a controller manager")
+			m, err := manager.New(cfg, manager.Options{})
+			Expect(err).NotTo(HaveOccurred())
+
+			instance, err := ControllerManagedBy(m).
+				For(&appsv1.ReplicaSet{}).
+				Owns(&appsv1.ReplicaSet{}).
+				Build(noop)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(instance).NotTo(BeAssignableToTypeOf(&UnmanagedWrapper{}))
+			Expect(instance).NotTo(BeNil())
+		})
+
 		It("should return success if given valid objects", func() {
 			By("creating a controller manager")
 			m, err := manager.New(cfg, manager.Options{})