chore: refactor kubebuilderx Do to a single reconciler (#10153)

Author: leon-ape

pkg/controller/kubebuilderx/controller.go

@@ -50,7 +50,7 @@ type Controller interface {
 	Prepare(TreeLoader) Controller
 
 	// Do is the computation phase. It contains the business logic and modifies the object tree.
-	Do(...Reconciler) Controller
+	Do(Reconciler) Controller
 
 	// Commit is the plan execution phase. It computes the difference between
 	// the old and new object trees, and applies the difference to Kubernetes.
@@ -88,7 +88,7 @@ func (c *controller) Prepare(reader TreeLoader) Controller {
 	return c
 }
 
-func (c *controller) Do(reconcilers ...Reconciler) Controller {
+func (c *controller) Do(reconciler Reconciler) Controller {
 	if c.err != nil {
 		return c
 	}
@@ -99,11 +99,6 @@ func (c *controller) Do(reconcilers ...Reconciler) Controller {
 	if c.res.Next != cntn {
 		return c
 	}
-	if len(reconcilers) == 0 {
-		return c
-	}
-
-	reconciler := reconcilers[0]
 	switch result := reconciler.PreCondition(c.tree); {
 	case result.Err != nil:
 		c.err = result.Err
@@ -112,8 +107,7 @@ func (c *controller) Do(reconcilers ...Reconciler) Controller {
 		return c
 	}
 	c.res, c.err = reconciler.Reconcile(c.tree)
-
-	return c.Do(reconcilers[1:]...)
+	return c
 }
 
 func (c *controller) Commit() (ctrl.Result, error) {

pkg/controller/kubebuilderx/controller_test.go

@@ -49,64 +49,77 @@ var _ = Describe("controller test", func() {
 			cli := fake.NewFakeClient()
 			req := ctrl.Request{}
 			logger := log.FromContext(ctx).WithValues("InstanceSet", "test")
-			var controller Controller
+			var ctrlr Controller
 			tree := NewObjectTree()
 
 			By("Load tree and reconcile it with no error")
-			controller = NewController(ctx, cli, req, nil, logger)
-			res, err := controller.Prepare(&dummyLoader{tree: tree}).Do(&dummyReconciler{res: Commit}).Commit()
+			ctrlr = NewController(ctx, cli, req, nil, logger)
+			res, err := ctrlr.Prepare(&dummyLoader{tree: tree}).Do(&dummyReconciler{res: Commit}).Commit()
 			Expect(err).Should(BeNil())
 			Expect(res.Requeue).Should(BeFalse())
 
 			By("Load tree with error")
-			controller = NewController(ctx, cli, req, nil, logger)
+			ctrlr = NewController(ctx, cli, req, nil, logger)
 			loadErr := fmt.Errorf("load tree failed")
-			res, err = controller.Prepare(&dummyLoader{err: loadErr}).Do(&dummyReconciler{res: Commit}).Commit()
+			res, err = ctrlr.Prepare(&dummyLoader{err: loadErr}).Do(&dummyReconciler{res: Commit}).Commit()
 			Expect(err).Should(Equal(loadErr))
 			Expect(res.Requeue).Should(BeFalse())
 
 			By("Reconcile with pre-condition error")
-			controller = NewController(ctx, cli, req, nil, logger)
+			ctrlr = NewController(ctx, cli, req, nil, logger)
 			reconcileCondErr := fmt.Errorf("reconcile pre-condition failed")
-			res, err = controller.Prepare(&dummyLoader{tree: tree}).Do(&dummyReconciler{preErr: reconcileCondErr, res: Commit}).Commit()
+			res, err = ctrlr.Prepare(&dummyLoader{tree: tree}).Do(&dummyReconciler{preErr: reconcileCondErr, res: Commit}).Commit()
 			Expect(err).Should(Equal(reconcileCondErr))
 			Expect(res.Requeue).Should(BeFalse())
 
 			By("Reconcile with pre-condition unsatisfied")
-			controller = NewController(ctx, cli, req, nil, logger)
+			ctrlr = NewController(ctx, cli, req, nil, logger)
 			root := builder.NewPodBuilder(namespace, name).GetObject()
 			tree.SetRoot(root)
 			Expect(cli.Create(ctx, root)).Should(Succeed())
 			newTree := NewObjectTree()
 			newTree.SetRoot(root)
-			res, err = controller.Prepare(&dummyLoader{tree: newTree}).Do(&dummyReconciler{unsatisfied: true, res: Commit}).Commit()
+			res, err = ctrlr.Prepare(&dummyLoader{tree: newTree}).Do(&dummyReconciler{unsatisfied: true, res: Commit}).Commit()
 			Expect(err).Should(BeNil())
 			Expect(res.Requeue).Should(BeFalse())
 			Expect(newTree).Should(Equal(tree))
 
+			By("Skip current Do but continue later chained Do calls")
+			ctrlr = NewController(ctx, cli, req, nil, logger)
+			newTree = NewObjectTree()
+			Expect(cli.Get(ctx, client.ObjectKeyFromObject(root), root)).Should(Succeed())
+			newTree.SetRoot(root)
+			ctrlr = ctrlr.Prepare(&dummyLoader{tree: newTree}).
+				Do(&dummyReconciler{unsatisfied: true, res: Commit}).
+				Do(&dummyReconciler{res: Continue})
+			ctl, ok := ctrlr.(*controller)
+			Expect(ok).Should(BeTrue())
+			Expect(ctl.err).Should(BeNil())
+			Expect(ctl.tree.GetSecondaryObjects()).Should(HaveLen(1))
+
 			By("Reconcile with error")
-			controller = NewController(ctx, cli, req, nil, logger)
+			ctrlr = NewController(ctx, cli, req, nil, logger)
 			reconcileErr := fmt.Errorf("reconcile with error")
-			res, err = controller.Prepare(&dummyLoader{tree: tree}).Do(&dummyReconciler{err: reconcileErr, res: Commit}).Commit()
+			res, err = ctrlr.Prepare(&dummyLoader{tree: tree}).Do(&dummyReconciler{err: reconcileErr, res: Commit}).Commit()
 			Expect(err).Should(Equal(reconcileErr))
 			Expect(res.Requeue).Should(BeFalse())
 
 			By("Reconcile with Commit method")
-			controller = NewController(ctx, cli, req, nil, logger)
+			ctrlr = NewController(ctx, cli, req, nil, logger)
 			newTree = NewObjectTree()
 			Expect(cli.Get(ctx, client.ObjectKeyFromObject(root), root)).Should(Succeed())
 			newTree.SetRoot(root)
-			res, err = controller.Prepare(&dummyLoader{tree: newTree}).Do(&dummyReconciler{res: Commit}).Commit()
+			res, err = ctrlr.Prepare(&dummyLoader{tree: newTree}).Do(&dummyReconciler{res: Commit}).Commit()
 			Expect(err).Should(BeNil())
 			Expect(res.Requeue).Should(BeFalse())
 			Expect(newTree).Should(Equal(tree))
 
 			By("Reconcile with Retry method")
-			controller = NewController(ctx, cli, req, nil, logger)
+			ctrlr = NewController(ctx, cli, req, nil, logger)
 			newTree = NewObjectTree()
 			Expect(cli.Get(ctx, client.ObjectKeyFromObject(root), root)).Should(Succeed())
 			newTree.SetRoot(root)
-			res, err = controller.Prepare(&dummyLoader{tree: newTree}).Do(&dummyReconciler{res: RetryAfter(time.Second)}).Commit()
+			res, err = ctrlr.Prepare(&dummyLoader{tree: newTree}).Do(&dummyReconciler{res: RetryAfter(time.Second)}).Commit()
 			Expect(err).Should(BeNil())
 			Expect(res.Requeue).Should(BeTrue())
 			Expect(res.RequeueAfter).Should(Equal(time.Second))