Rename NeedWarmup to EnableWarmup.

Author: godwinpang

pkg/config/controller.go

@@ -60,18 +60,18 @@ type Controller struct {
 	// Defaults to true, which means the controller will use leader election.
 	NeedLeaderElection *bool
 
-	// NeedWarmup specifies whether the controller should start its sources when the manager is not
+	// EnableWarmup specifies whether the controller should start its sources when the manager is not
 	// the leader. This is useful for cases where sources take a long time to start, as it allows
 	// for the controller to warm up its caches even before it is elected as the leader. This
 	// improves leadership failover time, as the caches will be prepopulated before the controller
 	// transitions to be leader.
 	//
-	// Setting NeedWarmup to true and NeedLeaderElection to true means the controller will start its
+	// Setting EnableWarmup to true and NeedLeaderElection to true means the controller will start its
 	// sources without waiting to become leader.
-	// Setting NeedWarmup to true and NeedLeaderElection is false is a no-op as controllers without
+	// Setting EnableWarmup to true and NeedLeaderElection is false is a no-op as controllers without
 	// leader election do not wait on leader election to start their sources.
 	// Defaults to false.
-	NeedWarmup *bool
+	EnableWarmup *bool
 
 	// UsePriorityQueue configures the controllers queue to use the controller-runtime provided
 	// priority queue.

pkg/controller/controller.go

@@ -94,15 +94,15 @@ type TypedOptions[request comparable] struct {
 	// Note: This flag is disabled by default until a future version. It's currently in beta.
 	UsePriorityQueue *bool
 
-	// NeedWarmup specifies whether the controller should start its sources when the manager is not
+	// EnableWarmup specifies whether the controller should start its sources when the manager is not
 	// the leader. This is useful for cases where sources take a long time to start, as it allows
 	// for the controller to warm up its caches even before it is elected as the leader. This
 	// improves leadership failover time, as the caches will be prepopulated before the controller
 	// transitions to be leader.
 	//
 	// When set to true, the controller will start its sources without transitioning to be leader.
 	// Defaults to false.
-	NeedWarmup *bool
+	EnableWarmup *bool
 }
 
 // DefaultFromConfig defaults the config from a config.Controller
@@ -135,8 +135,8 @@ func (options *TypedOptions[request]) DefaultFromConfig(config config.Controller
 		options.NeedLeaderElection = config.NeedLeaderElection
 	}
 
-	if options.NeedWarmup == nil {
-		options.NeedWarmup = config.NeedWarmup
+	if options.EnableWarmup == nil {
+		options.EnableWarmup = config.EnableWarmup
 	}
 }
 
@@ -267,7 +267,7 @@ func NewTypedUnmanaged[request comparable](name string, options TypedOptions[req
 		LogConstructor:          options.LogConstructor,
 		RecoverPanic:            options.RecoverPanic,
 		LeaderElected:           options.NeedLeaderElection,
-		NeedWarmup:              options.NeedWarmup,
+		EnableWarmup:            options.EnableWarmup,
 	}, nil
 }
 

pkg/controller/controller_test.go

@@ -475,48 +475,48 @@ var _ = Describe("controller.Controller", func() {
 			Expect(ok).To(BeFalse())
 		})
 
-		It("should set NeedWarmup correctly", func() {
+		It("should set EnableWarmup correctly", func() {
 			m, err := manager.New(cfg, manager.Options{})
 			Expect(err).NotTo(HaveOccurred())
 
-			// Test with NeedWarmup set to true
+			// Test with EnableWarmup set to true
 			ctrlWithWarmup, err := controller.New("warmup-enabled-ctrl", m, controller.Options{
-				Reconciler: reconcile.Func(nil),
-				NeedWarmup: ptr.To(true),
+				Reconciler:   reconcile.Func(nil),
+				EnableWarmup: ptr.To(true),
 			})
 			Expect(err).NotTo(HaveOccurred())
 
 			internalCtrlWithWarmup, ok := ctrlWithWarmup.(*internalcontroller.Controller[reconcile.Request])
 			Expect(ok).To(BeTrue())
-			Expect(internalCtrlWithWarmup.NeedWarmup).To(HaveValue(BeTrue()))
+			Expect(internalCtrlWithWarmup.EnableWarmup).To(HaveValue(BeTrue()))
 
-			// Test with NeedWarmup set to false
+			// Test with EnableWarmup set to false
 			ctrlWithoutWarmup, err := controller.New("warmup-disabled-ctrl", m, controller.Options{
-				Reconciler: reconcile.Func(nil),
-				NeedWarmup: ptr.To(false),
+				Reconciler:   reconcile.Func(nil),
+				EnableWarmup: ptr.To(false),
 			})
 			Expect(err).NotTo(HaveOccurred())
 
 			internalCtrlWithoutWarmup, ok := ctrlWithoutWarmup.(*internalcontroller.Controller[reconcile.Request])
 			Expect(ok).To(BeTrue())
-			Expect(internalCtrlWithoutWarmup.NeedWarmup).To(HaveValue(BeFalse()))
+			Expect(internalCtrlWithoutWarmup.EnableWarmup).To(HaveValue(BeFalse()))
 
-			// Test with NeedWarmup not set (should default to nil)
+			// Test with EnableWarmup not set (should default to nil)
 			ctrlWithDefaultWarmup, err := controller.New("warmup-default-ctrl", m, controller.Options{
 				Reconciler: reconcile.Func(nil),
 			})
 			Expect(err).NotTo(HaveOccurred())
 
 			internalCtrlWithDefaultWarmup, ok := ctrlWithDefaultWarmup.(*internalcontroller.Controller[reconcile.Request])
 			Expect(ok).To(BeTrue())
-			Expect(internalCtrlWithDefaultWarmup.NeedWarmup).To(BeNil())
+			Expect(internalCtrlWithDefaultWarmup.EnableWarmup).To(BeNil())
 		})
 
-		It("should inherit NeedWarmup from manager config", func() {
-			// Test with manager default setting NeedWarmup to true
+		It("should inherit EnableWarmup from manager config", func() {
+			// Test with manager default setting EnableWarmup to true
 			managerWithWarmup, err := manager.New(cfg, manager.Options{
 				Controller: config.Controller{
-					NeedWarmup: ptr.To(true),
+					EnableWarmup: ptr.To(true),
 				},
 			})
 			Expect(err).NotTo(HaveOccurred())
@@ -527,18 +527,18 @@ var _ = Describe("controller.Controller", func() {
 
 			internalCtrlInheritingWarmup, ok := ctrlInheritingWarmup.(*internalcontroller.Controller[reconcile.Request])
 			Expect(ok).To(BeTrue())
-			Expect(internalCtrlInheritingWarmup.NeedWarmup).To(HaveValue(BeTrue()))
+			Expect(internalCtrlInheritingWarmup.EnableWarmup).To(HaveValue(BeTrue()))
 
 			// Test that explicit controller setting overrides manager setting
 			ctrlOverridingWarmup, err := controller.New("override-warmup-disabled", managerWithWarmup, controller.Options{
-				Reconciler: reconcile.Func(nil),
-				NeedWarmup: ptr.To(false),
+				Reconciler:   reconcile.Func(nil),
+				EnableWarmup: ptr.To(false),
 			})
 			Expect(err).NotTo(HaveOccurred())
 
 			internalCtrlOverridingWarmup, ok := ctrlOverridingWarmup.(*internalcontroller.Controller[reconcile.Request])
 			Expect(ok).To(BeTrue())
-			Expect(internalCtrlOverridingWarmup.NeedWarmup).To(HaveValue(BeFalse()))
+			Expect(internalCtrlOverridingWarmup.EnableWarmup).To(HaveValue(BeFalse()))
 		})
 	})
 })

pkg/internal/controller/controller.go

@@ -112,11 +112,11 @@ type Controller[request comparable] struct {
 	// LeaderElected indicates whether the controller is leader elected or always running.
 	LeaderElected *bool
 
-	// NeedWarmup specifies whether the controller should start its sources
+	// EnableWarmup specifies whether the controller should start its sources
 	// when the manager is not the leader.
 	// Defaults to false, which means that the controller will wait for leader election to start
 	// before starting sources.
-	NeedWarmup *bool
+	EnableWarmup *bool
 }
 
 // Reconcile implements reconcile.Reconciler.
@@ -168,7 +168,7 @@ func (c *Controller[request]) NeedLeaderElection() bool {
 
 // Warmup implements the manager.WarmupRunnable interface.
 func (c *Controller[request]) Warmup(ctx context.Context) error {
-	if c.NeedWarmup == nil || !*c.NeedWarmup {
+	if c.EnableWarmup == nil || !*c.EnableWarmup {
 		return nil
 	}
 
@@ -183,7 +183,7 @@ func (c *Controller[request]) Warmup(ctx context.Context) error {
 // WaitForWarmupComplete returns true if warmup has completed without error, and false if there was
 // an error during warmup. If context is cancelled, it returns true.
 func (c *Controller[request]) WaitForWarmupComplete(ctx context.Context) bool {
-	if c.NeedWarmup == nil || !*c.NeedWarmup {
+	if c.EnableWarmup == nil || !*c.EnableWarmup {
 		return true
 	}
 

pkg/internal/controller/controller_test.go

@@ -1051,7 +1051,7 @@ var _ = Describe("controller", func() {
 
 	Describe("Warmup", func() {
 		JustBeforeEach(func() {
-			ctrl.NeedWarmup = ptr.To(true)
+			ctrl.EnableWarmup = ptr.To(true)
 		})
 
 		It("should track warmup status correctly with successful sync", func() {
@@ -1165,7 +1165,7 @@ var _ = Describe("controller", func() {
 					return log.RuntimeLog.WithName("controller").WithName("test")
 				},
 				CacheSyncTimeout: time.Second,
-				NeedWarmup:       ptr.To(false),
+				EnableWarmup:     ptr.To(false),
 				LeaderElected:    ptr.To(true),
 				startWatches: []source.TypedSource[reconcile.Request]{
 					source.Func(func(ctx context.Context, _ workqueue.TypedRateLimitingInterface[reconcile.Request]) error {
@@ -1206,7 +1206,7 @@ var _ = Describe("controller", func() {
 
 	Describe("Warmup with warmup disabled", func() {
 		JustBeforeEach(func() {
-			ctrl.NeedWarmup = ptr.To(false)
+			ctrl.EnableWarmup = ptr.To(false)
 		})
 
 		It("should not start sources when Warmup is called if warmup is disabled but start it when Start is called.", func() {
@@ -1224,12 +1224,12 @@ var _ = Describe("controller", func() {
 				}),
 			}
 
-			By("Calling Warmup when NeedWarmup is false")
+			By("Calling Warmup when EnableWarmup is false")
 			err := ctrl.Warmup(ctx)
 			Expect(err).NotTo(HaveOccurred())
 			Expect(isSourceStarted.Load()).To(BeFalse())
 
-			By("Calling Start when NeedWarmup is false")
+			By("Calling Start when EnableWarmup is false")
 			// Now call Start
 			go func() {
 				defer GinkgoRecover()
@@ -1241,7 +1241,7 @@ var _ = Describe("controller", func() {
 
 	Describe("WaitForWarmupComplete", func() {
 		It("should short circuit without blocking if warmup is disabled", func() {
-			ctrl.NeedWarmup = ptr.To(false)
+			ctrl.EnableWarmup = ptr.To(false)
 
 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()
@@ -1252,7 +1252,7 @@ var _ = Describe("controller", func() {
 		})
 
 		It("should block until warmup is complete if warmup is enabled", func() {
-			ctrl.NeedWarmup = ptr.To(true)
+			ctrl.EnableWarmup = ptr.To(true)
 			// Setup controller with sources that complete successfully
 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()