MAJOR: add a feedback to the listeners Programmed condition

The feedback status is received from Hug when the haproxy.cfg is applied with success or failure

Author: hdurand0710

hug/haproxy/main.go

@@ -102,9 +102,6 @@ func (h *AppManagerImpl) Run() {
 						logging.LogAttrError(err),
 					)
 				}
-				if haproxyCfg.Done != nil {
-					close(haproxyCfg.Done)
-				}
 			}
 		}
 	})
@@ -396,6 +393,27 @@ func (h *AppManagerImpl) confUpdateProcessed(haproxyCfgDiffs diffs.HaproxyConfDi
 
 	h.logger.LogAttrs(context.Background(), slog.LevelInfo, "Haproxy configuration update result",
 		slog.Any("result", result))
+
+	if haproxyCfgDiffs.Done != nil {
+		h.logger.LogAttrs(context.Background(), slog.LevelInfo, "[sending] HUG => CONTROLLER: DIFFS (Done)")
+		close(haproxyCfgDiffs.Done)
+	}
+
+	if haproxyCfgDiffs.ResultCh != nil {
+		confResult := diffs.HaproxyConfResult{
+			Err:                        err,
+			GatewayObservedGenerations: haproxyCfgDiffs.GatewayObservedGenerations(),
+		}
+		h.logger.LogAttrs(context.Background(), slog.LevelInfo, "[sending] HUG => CONTROLLER: haproxy conf update result", slog.Any("result", confResult))
+		select {
+		case haproxyCfgDiffs.ResultCh <- confResult:
+		default:
+			// TODO: check with the team
+			h.logger.LogAttrs(context.Background(), slog.LevelError,
+				"dropping haproxy conf result: ResultCh is full",
+			)
+		}
+	}
 }
 
 func addFrontendMetadataToResult(meta map[string]any, fe *models.Frontend) {

k8s/gate/conditions/gateway.go

@@ -62,14 +62,25 @@ func NewGatewayAcceptedInvalidConditions(msg string) generic.Conditions {
 func NewGatewayAcceptedInvalidParameters(err *field.Error) generic.Conditions {
 	return generic.Conditions{
 		generic.ConditionType(gatewayv1.GatewayConditionAccepted): {
-			Type:    generic.ConditionType(gatewayv1.GatewayReasonInvalidParameters),
+			Type:    generic.ConditionType(gatewayv1.GatewayConditionAccepted),
 			Status:  metav1.ConditionFalse,
 			Reason:  string(gatewayv1.GatewayReasonInvalidParameters),
 			Message: fmt.Sprintf("invalid parametersRef: %s", err),
 		},
 	}
 }
 
+func NewGatewayAcceptedListenersNotValid(msg string) generic.Conditions {
+	return generic.Conditions{
+		generic.ConditionType(gatewayv1.GatewayConditionAccepted): {
+			Type:    generic.ConditionType(gatewayv1.GatewayConditionAccepted),
+			Status:  metav1.ConditionFalse,
+			Reason:  string(gatewayv1.GatewayReasonListenersNotValid),
+			Message: msg,
+		},
+	}
+}
+
 func NewGatewayAcceptedListenerNotValidAtLeast1Valid() generic.Conditions {
 	return generic.Conditions{
 		generic.ConditionType(gatewayv1.GatewayConditionAccepted): {
@@ -116,3 +127,14 @@ func NewGatewayProgrammedInvalidParameters(msg string) generic.Conditions {
 		},
 	}
 }
+
+func NewGatewayProgrammedListenersNotValid(msg string) generic.Conditions {
+	return generic.Conditions{
+		generic.ConditionType(gatewayv1.GatewayConditionProgrammed): {
+			Type:    generic.ConditionType(gatewayv1.GatewayConditionProgrammed),
+			Status:  metav1.ConditionFalse,
+			Reason:  string(gatewayv1.GatewayReasonListenersNotValid),
+			Message: msg,
+		},
+	}
+}

k8s/gate/conditions/gateway_listener.go

@@ -61,13 +61,10 @@ func NewListenerResolvedRefOK() generic.Conditions {
 func NewListenerProgrammedPending() generic.Conditions {
 	return generic.Conditions{
 		generic.ConditionType(gatewayv1.ListenerConditionProgrammed): {
-			Type: generic.ConditionType(gatewayv1.ListenerConditionProgrammed),
-			//	Status:  metav1.ConditionUnknown,
-			Status: metav1.ConditionTrue,
-			// Reason:  string(gatewayv1.ListenerReasonPending),
-			// Message: "Listener is pending Haproxy programmation",
-			Reason:  string(gatewayv1.ListenerReasonProgrammed),
-			Message: "Listener is programmed in Haproxy",
+			Type:    generic.ConditionType(gatewayv1.ListenerConditionProgrammed),
+			Status:  metav1.ConditionUnknown,
+			Reason:  string(gatewayv1.ListenerReasonPending),
+			Message: "Listener is pending Haproxy programmation",
 		},
 	}
 }

k8s/gate/handler/batch.go

@@ -194,17 +194,6 @@ func (h *eventHandlerImpl) HandleEventBatch(ctx context.Context, batch events.Ev
 	}
 	haproxyConfDiffs := h.haproxyConfBuilder.GetDiffs()
 	h.recordDiffMetrics(haproxyConfDiffs)
-	if !haproxyConfDiffs.IsEmpty() || haproxyConfDiffs.ReloadNeed {
-		if h.config.TransferHaproxyConfChannel != nil {
-			h.logger.LogAttrs(context.Background(), slog.LevelInfo, "DIFFS CONTROLLER => HUG")
-			haproxyConfDiffs.Done = make(chan struct{})
-			transferStart := time.Now()
-			h.config.TransferHaproxyConfChannel <- haproxyConfDiffs
-			<-haproxyConfDiffs.Done
-			metrics.ConfigTransferDuration.Observe(time.Since(transferStart).Seconds())
-			h.logger.LogAttrs(context.Background(), slog.LevelInfo, "DIFFS HUG => CONTROLLER")
-		}
-	}
 
 	// -------------
 	// Status updates
@@ -218,6 +207,22 @@ func (h *eventHandlerImpl) HandleEventBatch(ctx context.Context, batch events.Ev
 	// Now process them
 	h.statusUpdater.UpdateStatus(ctx, statusUpdates)
 
+	if !haproxyConfDiffs.IsEmpty() || haproxyConfDiffs.ReloadNeed {
+		if h.config.TransferHaproxyConfChannel != nil {
+			h.logger.LogAttrs(context.Background(), slog.LevelInfo, "[sending] CONTROLLER => HUG: DIFFS")
+			haproxyConfDiffs.Done = make(chan struct{})
+			haproxyConfDiffs.ResultCh = make(chan diffs.HaproxyConfResult, 1)
+			transferStart := time.Now()
+			h.config.TransferHaproxyConfChannel <- haproxyConfDiffs
+			h.waitDone(haproxyConfDiffs.Done)
+			metrics.ConfigTransferDuration.Observe(time.Since(transferStart).Seconds())
+			h.logger.LogAttrs(context.Background(), slog.LevelInfo, "[received] HUG => CONTROLLER: DIFFS (Done)")
+
+			// Forward the HUG result back as status feedback to the relevant Gateway/Route objects.
+			h.forwardFeedback(ctx, haproxyConfDiffs.ResultCh)
+		}
+	}
+
 	// Reconcile Hug service Ports
 	h.hugServiceReconciler.ReconcilePorts(ctx, gatetree.VirtualListeners)
 }
@@ -256,6 +261,50 @@ func (h *eventHandlerImpl) updateClusterStore(event any) {
 	}
 }
 
+// waitDoneTimeout is the maximum time to wait for Done to be closed after
+// sending diffs to HUG.
+const waitDoneTimeout = 30 * time.Second
+
+// waitDone blocks until done is closed or waitDoneTimeout elapses, logging a
+// warning in the latter case.
+func (h *eventHandlerImpl) waitDone(done <-chan struct{}) {
+	select {
+	case <-done:
+	case <-time.After(waitDoneTimeout):
+		h.logger.LogAttrs(context.Background(), slog.LevelWarn,
+			"timed out waiting for Done signal from HUG",
+		)
+	}
+}
+
+// forwardFeedbackTimeout is the maximum time to wait for a result on ResultCh
+// after Done has been closed. The result may arrive slightly after Done in some
+// implementations, so we give a short grace period before giving up.
+const forwardFeedbackTimeout = 5 * time.Second
+
+// forwardFeedback waits up to forwardFeedbackTimeout for a result on resultCh,
+// prepares the feedback status updates, and dispatches them through the shared
+// statusUpdater channel.
+func (h *eventHandlerImpl) forwardFeedback(ctx context.Context, resultCh chan diffs.HaproxyConfResult) {
+	select {
+	case result := <-resultCh:
+		h.logger.LogAttrs(ctx, slog.LevelInfo, "[received] HUG => CONTROLLER: haproxy conf update result ", slog.Any("result", result))
+		gatetree := h.treeBuilder.GetTree()
+		for gwKey, gen := range result.GatewayObservedGenerations {
+			gatetree.UpdateListenerProgrammedCondition(gwKey, gen, result.Err)
+		}
+		gateways := gatetree.RLockGateways()
+		updates := h.statusUpdater.PrepareFeedbackStatusUpdate(result, gateways)
+		gatetree.RUnlockGateways()
+		h.statusUpdater.UpdateStatus(ctx, updates)
+	case <-time.After(forwardFeedbackTimeout):
+		// TODO: check with the team
+		h.logger.LogAttrs(context.Background(), slog.LevelWarn,
+			"timed out waiting for result from HUG on ResultCh",
+		)
+	}
+}
+
 func (*eventHandlerImpl) recordDiffMetrics(d diffs.HaproxyConfDiffs) {
 	metrics.ConfigDiffs.WithLabelValues("created", "frontend").Add(float64(len(d.Created.Frontends)))
 	metrics.ConfigDiffs.WithLabelValues("updated", "frontend").Add(float64(len(d.Updated.Frontends)))

k8s/gate/handler/monitor.go

@@ -15,6 +15,7 @@ package handler
 
 import (
 	"context"
+	"fmt"
 	"log/slog"
 	"sync"
 	"time"
@@ -191,14 +192,17 @@ func (el *EventLoop) stopTimer() {
 
 func (el *EventLoop) logEvent(e any) {
 	var o client.Object
+	eventType := ""
 	switch obj := e.(type) {
 	case *events.UpsertEvent:
 		o = obj.Resource
+		eventType = "UpsertEvent"
 	case *events.DeleteEvent:
 		o = obj.Type
+		eventType = "DeleteEvent"
 	}
 	el.logger.LogAttrs(context.Background(), slog.LevelDebug,
-		"added an event to the batch",
+		fmt.Sprintf("added an event to the batch %s", eventType),
 		logging.LogAttrBatch(el.nextBatch.BatchID, len(el.nextBatch.Events)),
 		logging.LogAttrResource(o, el.extractGVK(o)),
 	)

k8s/gate/handler/programmed-feedback.go

@@ -0,0 +1,14 @@
+// Copyright 2025 HAProxy Technologies LLC
+//
+// 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 handler

k8s/gate/haproxy/configuration.go

@@ -48,23 +48,24 @@ func (c *Configuration) resetDiffs() {
 	}
 }
 
-func (c *Configuration) upsertFrontend(logger *slog.Logger, fe *models.Frontend) error {
+func (c *Configuration) upsertFrontend(logger *slog.Logger, fe *models.Frontend, reprogramm bool) error {
 	if fe == nil {
 		logger.LogAttrs(context.Background(), slog.LevelError, "nil frontend")
 		return errors.New("nil frontend")
 	}
 
 	if previousFe, ok := c.structured.Frontends[fe.Name]; ok {
 		// Check if they are the same
-		if previousFe.Equal(*fe) {
+		if previousFe.Equal(*fe) && !reprogramm {
 			logger.LogAttrs(context.Background(), slog.LevelDebug, "Frontend [same]",
 				logging.LogAttrFrontendName(fe.Name),
 			)
 			return nil
 		}
 
 		// Update existing frontend
-		logger.LogAttrs(context.Background(), slog.LevelInfo, "Frontend [UPDATE]",
+		msg := fmt.Sprintf("Frontend [UPDATE] (%t)", reprogramm)
+		logger.LogAttrs(context.Background(), slog.LevelInfo, msg,
 			logging.LogAttrFrontendName(fe.Name),
 		)
 

k8s/gate/haproxy/diffs/diffs.go

@@ -14,16 +14,32 @@
 package diffs
 
 import (
+	"encoding/json"
 	"fmt"
+	"strings"
 
+	"github.com/haproxytech/client-native/v6/models"
+	"github.com/haproxytech/haproxy-unified-gateway/k8s/gate/haproxy/metadata"
 	"github.com/haproxytech/haproxy-unified-gateway/k8s/gate/haproxy/structured"
+	"k8s.io/apimachinery/pkg/types"
 )
 
 type MergeStrategies struct {
 	Global   string // override or append
 	Defaults string // override or append
 }
 
+// GatewayObservedGenerations maps each gateway (namespace/name) to the highest
+// observed generation seen in the processed frontends' metadata.
+type GatewayObservedGenerations map[types.NamespacedName]int64
+
+// HaproxyConfResult is the outcome of a single HaproxyConfDiffs processing
+// cycle, sent back to the controller via HaproxyConfDiffs.ResultCh.
+type HaproxyConfResult struct {
+	Err                        error
+	GatewayObservedGenerations GatewayObservedGenerations
+}
+
 type HaproxyConfDiffs struct {
 	Created structured.Structured
 	Updated structured.Structured
@@ -36,6 +52,9 @@ type HaproxyConfDiffs struct {
 	//  close(haproxyCfg.Done)
 	// }
 	Done chan struct{}
+	// ResultCh, when non-nil, receives exactly one HaproxyConfResult after
+	// the diffs have been applied. The channel must be buffered (size >= 1).
+	ResultCh chan HaproxyConfResult
 
 	MergeStrategies MergeStrategies
 	ReloadNeed      bool
@@ -45,6 +64,77 @@ func (c HaproxyConfDiffs) IsEmpty() bool {
 	return c.Created.IsEmpty() && c.Updated.IsEmpty() && c.Deleted.IsEmpty()
 }
 
+// GatewayObservedGenerations builds a map of gateway → max generation from
+// the metadata of all Created and Updated frontends. Deleted frontends are
+// excluded because their config is no longer active.
+func (c HaproxyConfDiffs) GatewayObservedGenerations() GatewayObservedGenerations {
+	result := make(GatewayObservedGenerations)
+	for _, fe := range c.Created.Frontends {
+		for key, gen := range extractGatewayGenerationsFromFrontend(fe) {
+			if existing, ok := result[key]; !ok || gen > existing {
+				result[key] = gen
+			}
+		}
+	}
+	for _, fe := range c.Updated.Frontends {
+		for key, gen := range extractGatewayGenerationsFromFrontend(fe) {
+			if existing, ok := result[key]; !ok || gen > existing {
+				result[key] = gen
+			}
+		}
+	}
+	return result
+}
+
+func extractGatewayGenerationsFromFrontend(fe *models.Frontend) map[types.NamespacedName]int64 {
+	result := make(map[types.NamespacedName]int64)
+	if fe == nil || fe.Metadata == nil {
+		return result
+	}
+	hugI, ok := fe.Metadata[metadata.UnifiedGatewayMetaDataKey]
+	if !ok {
+		return result
+	}
+	by, err := json.Marshal(hugI)
+	if err != nil {
+		return result
+	}
+	// After the JSON round-trip in FrontendMetadata(), the structure is:
+	// { "Gateway": { "namespace/name": { "Generation": float64, "LinkID": string } } }
+	var hugMeta map[string]map[string]map[string]any
+	if err := json.Unmarshal(by, &hugMeta); err != nil {
+		return result
+	}
+	gatewayMeta, ok := hugMeta["Gateway"]
+	if !ok {
+		return result
+	}
+	for nsName, info := range gatewayMeta {
+		genAny, ok := info["Generation"]
+		if !ok {
+			continue
+		}
+		genFloat, ok := genAny.(float64)
+		if !ok {
+			continue
+		}
+		nn := parseNamespacedName(nsName)
+		if nn == (types.NamespacedName{}) {
+			continue
+		}
+		result[nn] = int64(genFloat)
+	}
+	return result
+}
+
+func parseNamespacedName(s string) types.NamespacedName {
+	parts := strings.SplitN(s, "/", 2)
+	if len(parts) != 2 {
+		return types.NamespacedName{}
+	}
+	return types.NamespacedName{Namespace: parts[0], Name: parts[1]}
+}
+
 func (c HaproxyConfDiffs) Stats() string {
 	return fmt.Sprintf("Created/Updated/Deleted FE:[%d/%d/%d] BE[%d/%d/%d] Global[%d/%d/%d] Defaults[%d/%d/%d] Reload[%t]",
 		len(c.Created.Frontends), len(c.Updated.Frontends), len(c.Deleted.Frontends),