Add StatusTracker for intermediate status updates

Provides immediate status visibility during long-running reconciliation
operations by flushing updates at key checkpoints. Updates only when
status changes and retries on conflict with exponential backoff.

Author: creydr

internal/controller/function_controller.go

@@ -91,15 +91,17 @@ func (r *FunctionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 	}
 
 	function := original.DeepCopy()
+
+	// Create tracker and add to context
+	statusTracker := NewStatusTracker(r.Client, function)
+	ctx = WithStatusTracker(ctx, statusTracker)
+
 	reconcileErr := r.reconcile(ctx, function)
-	function.CalculateReadyCondition()
 
-	// update status if required
-	if !equality.Semantic.DeepEqual(original.Status, function.Status) {
-		if err := r.Status().Update(ctx, function); err != nil {
-			logger.Error(err, "Unable to update Function status")
-			return ctrl.Result{}, err
-		}
+	// Final flush at the end (handles ready condition calculation)
+	if err := statusTracker.Flush(ctx, function); err != nil {
+		logger.Error(err, "Unable to update Function status")
+		return ctrl.Result{}, err
 	}
 
 	if reconcileErr != nil {
@@ -122,12 +124,18 @@ func (r *FunctionReconciler) reconcile(ctx context.Context, function *v1alpha1.F
 	defer repo.Cleanup()
 
 	r.updateFunctionStatusGit(function, repo)
+	if err := FlushStatus(ctx, function); err != nil {
+		return fmt.Errorf("failed to update status: %w", err)
+	}
 
 	if err := r.ensureDeployment(ctx, function, repo, metadata); err != nil {
 		return fmt.Errorf("deploying function failed: %w", err)
 	}
 
 	r.updateFunctionStatus(function, metadata)
+	if err := FlushStatus(ctx, function); err != nil {
+		return fmt.Errorf("failed to update status: %w", err)
+	}
 
 	return nil
 }
@@ -199,6 +207,12 @@ func (r *FunctionReconciler) handleMiddlewareUpdate(ctx context.Context, functio
 	if !isOnLatestMiddleware {
 		logger.Info("Function is not on latest middleware. Will redeploy")
 		function.MarkMiddlewareNotUpToDate("MiddlewareOutdated", "Middleware is outdated, redeploying")
+
+		// Checkpoint 2: Flush status before long deploy operation
+		if err := FlushStatus(ctx, function); err != nil {
+			logger.Error(err, "Failed to update status before redeployment")
+		}
+
 		if err := r.deploy(ctx, function, repo); err != nil {
 			function.MarkDeployNotReady("DeployFailed", "Redeployment failed: %s", err.Error())
 			return fmt.Errorf("failed to redeploy function: %w", err)

internal/controller/status_tracker.go

@@ -0,0 +1,104 @@
+/*
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package controller
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/functions-dev/func-operator/api/v1alpha1"
+	"k8s.io/apimachinery/pkg/api/equality"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/util/retry"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+// StatusTracker manages incremental status updates during reconciliation
+type StatusTracker struct {
+	client   client.Client
+	original *v1alpha1.Function
+}
+
+// NewStatusTracker creates a new status tracker with a snapshot of the current function state
+func NewStatusTracker(client client.Client, function *v1alpha1.Function) *StatusTracker {
+	return &StatusTracker{
+		client:   client,
+		original: function.DeepCopy(),
+	}
+}
+
+// Flush updates the function status if it has changed since the last flush
+func (t *StatusTracker) Flush(ctx context.Context, current *v1alpha1.Function) error {
+	// Always calculate ready condition before comparing
+	current.CalculateReadyCondition()
+
+	// Compare and update if changed
+	if !equality.Semantic.DeepEqual(t.original.Status, current.Status) {
+		// Retry on conflict with exponential backoff
+		err := retry.RetryOnConflict(retry.DefaultRetry, func() error {
+			// Get the latest version to ensure we have the most recent resourceVersion
+			latest := &v1alpha1.Function{}
+			if err := t.client.Get(ctx, types.NamespacedName{
+				Name:      current.Name,
+				Namespace: current.Namespace,
+			}, latest); err != nil {
+				return err
+			}
+
+			// Apply our status changes to the latest version
+			latest.Status = current.Status
+
+			// Attempt the update
+			return t.client.Status().Update(ctx, latest)
+		})
+
+		if err != nil {
+			return fmt.Errorf("failed to update status: %w", err)
+		}
+
+		// Update our snapshot to the new state
+		t.original = current.DeepCopy()
+	}
+
+	return nil
+}
+
+// statusTrackerKey is the context key for the status tracker
+type statusTrackerKey struct{}
+
+// WithStatusTracker adds a status tracker to the context
+func WithStatusTracker(ctx context.Context, tracker *StatusTracker) context.Context {
+	return context.WithValue(ctx, statusTrackerKey{}, tracker)
+}
+
+// GetStatusTracker retrieves the tracker from context
+func GetStatusTracker(ctx context.Context) *StatusTracker {
+	tracker, ok := ctx.Value(statusTrackerKey{}).(*StatusTracker)
+	if !ok {
+		return nil
+	}
+	return tracker
+}
+
+// FlushStatus is a convenience helper that gets tracker from context and flushes
+func FlushStatus(ctx context.Context, function *v1alpha1.Function) error {
+	tracker := GetStatusTracker(ctx)
+	if tracker == nil {
+		return nil // gracefully handle missing tracker
+	}
+	return tracker.Flush(ctx, function)
+}