From 7f0c0098d3be8d3ddf54d751a8c39c60a53867f1 Mon Sep 17 00:00:00 2001 From: Gaston Festari Date: Fri, 13 Nov 2026 16:41:45 -0300 Subject: [PATCH 1/2] fix: Patch to avoid failed updates Avoid optimistic concurrency conflicts when another controller modifies an unrelated field on the HTTPRoute while the external call is being processed. --- controllers/httproute_controller.go | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/controllers/httproute_controller.go b/controllers/httproute_controller.go index 2884cff..4581538 100644 --- a/controllers/httproute_controller.go +++ b/controllers/httproute_controller.go @@ -42,6 +42,8 @@ func (r *HTTPRouteWatcher) Reconcile(ctx context.Context, req ctrl.Request) (ctr return ctrl.Result{}, client.IgnoreNotFound(err) } + base := route.DeepCopy() + // Delete if !route.DeletionTimestamp.IsZero() { if controllerutil.ContainsFinalizer(&route, finalizerName) { @@ -57,7 +59,7 @@ func (r *HTTPRouteWatcher) Reconcile(ctx context.Context, req ctrl.Request) (ctr // Remove finalizer so k8s can complete deletion controllerutil.RemoveFinalizer(&route, finalizerName) - if err := r.Update(ctx, &route); err != nil { + if err := r.Patch(ctx, &route, client.MergeFrom(base)); err != nil { return ctrl.Result{}, err } } @@ -68,7 +70,7 @@ func (r *HTTPRouteWatcher) Reconcile(ctx context.Context, req ctrl.Request) (ctr if route.Annotations[triggerAnnotation] != "true" { if controllerutil.ContainsFinalizer(&route, finalizerName) { controllerutil.RemoveFinalizer(&route, finalizerName) - return ctrl.Result{}, r.Update(ctx, &route) + return ctrl.Result{}, r.Patch(ctx, &route, client.MergeFrom(base)) } return ctrl.Result{}, nil } @@ -76,7 +78,7 @@ func (r *HTTPRouteWatcher) Reconcile(ctx context.Context, req ctrl.Request) (ctr // Ensure finalizer is registered before syncing if !controllerutil.ContainsFinalizer(&route, finalizerName) { controllerutil.AddFinalizer(&route, finalizerName) - if err := r.Update(ctx, &route); err != nil { + if err := r.Patch(ctx, &route, client.MergeFrom(base)); err != nil { return ctrl.Result{}, err } return ctrl.Result{}, nil @@ -114,7 +116,7 @@ func (r *HTTPRouteWatcher) Reconcile(ctx context.Context, req ctrl.Request) (ctr route.Annotations = make(map[string]string) } route.Annotations[checksumAnnotation] = currentHash - if err := r.Update(ctx, &route); err != nil { + if err := r.Patch(ctx, &route, client.MergeFrom(base)); err != nil { return ctrl.Result{}, err } From 4a68218e99f65a5ae874adc73d95f114a7691dac Mon Sep 17 00:00:00 2001 From: Gaston Festari Date: Fri, 13 Nov 2026 17:09:39 -0300 Subject: [PATCH 2/2] feat: skip reconcile on status-only updates Add a custom predicate filter to Manager to stop reconcile from being triggered by status-only updates or out of scope HTTPRoute resources. --- controllers/httproute_controller.go | 56 ++++++++++++ controllers/httproute_controller_test.go | 109 +++++++++++++++++++++++ 2 files changed, 165 insertions(+) diff --git a/controllers/httproute_controller.go b/controllers/httproute_controller.go index 4581538..7e78f9c 100644 --- a/controllers/httproute_controller.go +++ b/controllers/httproute_controller.go @@ -13,6 +13,8 @@ import ( ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" + "sigs.k8s.io/controller-runtime/pkg/event" + "sigs.k8s.io/controller-runtime/pkg/predicate" gatewayv1 "sigs.k8s.io/gateway-api/apis/v1" ) @@ -171,5 +173,59 @@ func computeSpecHash(spec gatewayv1.HTTPRouteSpec) (string, error) { func (r *HTTPRouteWatcher) SetupWithManager(mgr ctrl.Manager) error { return ctrl.NewControllerManagedBy(mgr). For(&gatewayv1.HTTPRoute{}). + WithEventFilter(routeEventFilter()). Complete(r) } + +func routeEventFilter() predicate.Predicate { + isTracked := func(obj client.Object) bool { + if obj == nil { + return false + } + return obj.GetAnnotations()[triggerAnnotation] == "true" || + controllerutil.ContainsFinalizer(obj, finalizerName) + } + + return predicate.Funcs{ + + CreateFunc: func(e event.CreateEvent) bool { + return isTracked(e.Object) + }, + UpdateFunc: func(e event.UpdateEvent) bool { + // ignore routes without the annotation/finalizer + if !isTracked(e.ObjectOld) && !isTracked(e.ObjectNew) { + return false + } + + // reconcile if deletion started + if e.ObjectNew.GetDeletionTimestamp() != nil && e.ObjectOld.GetDeletionTimestamp() == nil { + return true + } + + // reconcile if spec changed (generation incremented on spec updates) + if e.ObjectNew.GetGeneration() != e.ObjectOld.GetGeneration() { + return true + } + + oldTrigger := e.ObjectOld.GetAnnotations()[triggerAnnotation] + newTrigger := e.ObjectNew.GetAnnotations()[triggerAnnotation] + if oldTrigger != newTrigger { + return true + } + + oldHasFin := controllerutil.ContainsFinalizer(e.ObjectOld, finalizerName) + newHasFin := controllerutil.ContainsFinalizer(e.ObjectNew, finalizerName) + return oldHasFin != newHasFin + }, + DeleteFunc: func(e event.DeleteEvent) bool { + // finalizer deletion is handled via UpdateEvent when + // DeletionTimestamp is set. + // This is a placeholder in case fallback cleanup is needed. + return false + }, + GenericFunc: func(e event.GenericEvent) bool { + return isTracked(e.Object) + }, + } + +} diff --git a/controllers/httproute_controller_test.go b/controllers/httproute_controller_test.go index 0a836ec..faa9f4d 100644 --- a/controllers/httproute_controller_test.go +++ b/controllers/httproute_controller_test.go @@ -8,6 +8,7 @@ import ( "sync" "testing" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" clientgoscheme "k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/rest" @@ -15,6 +16,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/client/fake" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" + "sigs.k8s.io/controller-runtime/pkg/event" metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" gatewayv1 "sigs.k8s.io/gateway-api/apis/v1" ) @@ -383,3 +385,110 @@ func TestHTTPRouteWatcher_SetupWithManager(t *testing.T) { t.Fatalf("SetupWithManager() unexpected error = %v", err) } } + +func TestRouteEventFilter(t *testing.T) { + pred := routeEventFilter() + now := metav1.Now() + + untracked := &gatewayv1.HTTPRoute{ + Name: "untracked", + Generation: 1, + } + untrackedUpdated := untracked.DeepCopy() + untrackedUpdated.Generation = 2 + + tracked := &gatewayv1.HTTPRoute{ + Name: "tracked", + Generation: 1, + Annotations: map[string]string{triggerAnnotation: "true"}, + } + + trackedStatusOnly := tracked.DeepCopy() + trackedStatusOnly.Status.Parents = []gatewayv1.RouteParentStatus{ + {ParentRef: gatewayv1.ParentReference{Name: "gw"}}, + } + + trackedDeleting := tracked.DeepCopy() + trackedDeleting.DeletionTimestamp = &now + + trackedGenBumped := tracked.DeepCopy() + trackedGenBumped.Generation = 2 + + trackedAnnotationRemoved := tracked.DeepCopy() + delete(trackedAnnotationRemoved.Annotations, triggerAnnotation) + + trackedWithFinalizer := tracked.DeepCopy() + trackedWithFinalizer.Finalizers = []string{finalizerName} + + if pred.Create(event.CreateEvent{Object: nil}) { + t.Error("expected nil CreateEvent to be filtered out") + } + if pred.Create(event.CreateEvent{Object: untracked}) { + t.Error("expected untracked CreateEvent to be filtered out") + } + if !pred.Create(event.CreateEvent{Object: tracked}) { + t.Error("expected tracked CreateEvent to pass") + } + if pred.Delete(event.DeleteEvent{Object: tracked}) { + t.Error("expected DeleteEvent to be skipped") + } + if !pred.Generic(event.GenericEvent{Object: tracked}) { + t.Error("expected tracked GenericEvent to pass") + } + + updateTests := []struct { + name string + oldObj *gatewayv1.HTTPRoute + newObj *gatewayv1.HTTPRoute + want bool + }{ + { + name: "ignores untracked route changes", + oldObj: untracked, + newObj: untrackedUpdated, + want: false, + }, + { + name: "ignores status-only update on tracked route", + oldObj: tracked, + newObj: trackedStatusOnly, + want: false, + }, + { + name: "passes when deletion timestamp is set", + oldObj: tracked, + newObj: trackedDeleting, + want: true, + }, + { + name: "passes when generation increments", + oldObj: tracked, + newObj: trackedGenBumped, + want: true, + }, + { + name: "passes when trigger annotation is removed", + oldObj: tracked, + newObj: trackedAnnotationRemoved, + want: true, + }, + { + name: "passes when finalizer is added", + oldObj: tracked, + newObj: trackedWithFinalizer, + want: true, + }, + } + + for _, tc := range updateTests { + t.Run(tc.name, func(t *testing.T) { + got := pred.Update(event.UpdateEvent{ + ObjectOld: tc.oldObj, + ObjectNew: tc.newObj, + }) + if got != tc.want { + t.Errorf("Update() = %v, want %v", got, tc.want) + } + }) + } +}