🐛 manager: fix infinite CPU spin in runnableGroup.Start on context cancellation

pkg/manager/runnable_group.go

@@ -167,8 +167,6 @@ func (r *runnableGroup) Start(ctx context.Context) error {
 	var retErr error
 
 	r.startOnce.Do(func() {
-		defer close(r.startReadyCh)
-
 		// Start the internal reconciler.
 		go r.reconcile()
 
@@ -194,6 +192,12 @@ func (r *runnableGroup) Start(ctx context.Context) error {
 				if err := ctx.Err(); !errors.Is(err, context.Canceled) {
 					retErr = err
 				}
+				return
+			case <-r.ctx.Done():
+				// The group's internal context was cancelled (by StopAndWait).
+				// This unblocks readiness waiting when senders have exited via
+				// r.ctx.Done() and will no longer send to startReadyCh.
+				return
 			case rn := <-r.startReadyCh:
 				for i, existing := range r.startQueue {
 					if existing == rn {
@@ -202,8 +206,10 @@ func (r *runnableGroup) Start(ctx context.Context) error {
 						break
 					}
 				}
-				// We're done waiting if the queue is empty, return.
+				// We're done waiting if the queue is empty.
+				// All senders have already sent, so it is safe to close.
 				if len(r.startQueue) == 0 {
+					close(r.startReadyCh)
 					return
 				}
 			}
@@ -245,7 +251,14 @@ func (r *runnableGroup) reconcile() {
 			go func() {
 				if rn.Check(r.ctx) {
 					if rn.signalReady {
-						r.startReadyCh <- rn
+						// Use select to avoid sending after Start() has returned.
+						// When ctx is cancelled, Start() exits and is no longer
+						// receiving from startReadyCh. Without this select, we'd
+						// either block forever or panic if the channel were closed.
+						select {
+						case <-r.ctx.Done():
+						case r.startReadyCh <- rn:
+						}
 					}
 				}
 			}()

pkg/manager/runnable_group_test.go

@@ -363,6 +363,54 @@ func (r leaderElectionAndWarmupRunnable) NeedLeaderElection() bool {
 	return r.needLeaderElection
 }
 
+// TestStartReturnsWhenContextCancelledWithPendingReadinessCheck verifies that
+// runnableGroup.Start() returns promptly when the context is cancelled, even if
+// some runnables have not signaled readiness. This is a regression test for a bug
+// where Start() would spin indefinitely on ctx.Done() without returning.
+func TestStartReturnsWhenContextCancelledWithPendingReadinessCheck(t *testing.T) {
+	t.Parallel()
+
+	g := NewWithT(t)
+	rg := newRunnableGroup(defaultBaseContext, make(chan error, 1))
+
+	// Add a runnable with a readiness check that never completes.
+	// This simulates a cache sync that hangs or fails.
+	g.Expect(rg.Add(
+		RunnableFunc(func(c context.Context) error {
+			<-c.Done()
+			return nil
+		}),
+		func(ctx context.Context) bool {
+			// Block forever - never signal ready
+			<-ctx.Done()
+			return false
+		},
+	)).To(Succeed())
+
+	ctx, cancel := context.WithCancel(t.Context())
+
+	// Start the group in a goroutine
+	startReturned := make(chan struct{})
+	go func() {
+		defer close(startReturned)
+		_ = rg.Start(ctx)
+	}()
+
+	// Cancel the context
+	cancel()
+
+	// Start() should return promptly after context cancellation, not hang or spin
+	select {
+	case <-startReturned:
+		// Success: Start() returned after context cancellation
+	case <-time.After(5 * time.Second):
+		t.Fatal("Start() did not return after context was cancelled - likely spinning on ctx.Done()")
+	}
+
+	// Cleanup
+	rg.StopAndWait(t.Context())
+}
+
 func TestWarmupFunctionIsExecutedWhenWarmupGroupIsStarted(t *testing.T) {
 	t.Parallel()
 	synctest.Test(t, func(t *testing.T) {