MEDIUM: add multi listeners matching per gateway with a single parent reference from HTTPRoute

Author: ivanmatmati

k8s/gate/haproxy/routes-maps.go

@@ -50,56 +50,60 @@ func (b *RouteMgrImpl) fillMaps() {
 			continue
 		}
 		route = route.TreeStatus.OldTreeResource
-		for _, listener := range route.Listeners.Iterate {
-			frontendName, err := b.topManager.getFrontendName(listener.Owner, listener.K8sResource)
-			if err != nil {
-				b.topManager.logger.LogAttrs(context.Background(), slog.LevelError, "Failed to get frontend name",
-					logging.LogAttrError(err),
-				)
-			}
+		for _, listeners := range route.Listeners.Iterate {
+			for _, listener := range listeners {
+				frontendName, err := b.topManager.getFrontendName(listener.Owner, listener.K8sResource)
+				if err != nil {
+					b.topManager.logger.LogAttrs(context.Background(), slog.LevelError, "Failed to get frontend name",
+						logging.LogAttrError(err),
+					)
+				}
 
-			pathExactMap := mapsStorage.MapPath(frontendName, storage.PATH_EXACT_MAP)
-			pathPrefixMap := mapsStorage.MapPath(frontendName, storage.PATH_PREFIX_MAP)
-			pathDomainWPathExactMap := mapsStorage.MapPath(frontendName, storage.PATH_EXACT_DOMAIN_WILDCARD_MAP)
-			pathregexMap := mapsStorage.MapPath(frontendName, storage.PATH_REGEX_MAP)
-			mapExact := mapsStorage.GetMapData(pathExactMap)
-			mapPrefix := mapsStorage.GetMapData(pathPrefixMap)
-			mapRegex := mapsStorage.GetMapData(pathregexMap)
-			mapDomainWPathExact := mapsStorage.GetMapData(pathDomainWPathExactMap)
-			err = b.onDeletedHTTPRoute(routeKey, route, mapExact, mapPrefix, mapRegex, mapDomainWPathExact)
-			// errs.Add(err)
-			_ = err // TODO ignore error for now
+				pathExactMap := mapsStorage.MapPath(frontendName, storage.PATH_EXACT_MAP)
+				pathPrefixMap := mapsStorage.MapPath(frontendName, storage.PATH_PREFIX_MAP)
+				pathDomainWPathExactMap := mapsStorage.MapPath(frontendName, storage.PATH_EXACT_DOMAIN_WILDCARD_MAP)
+				pathregexMap := mapsStorage.MapPath(frontendName, storage.PATH_REGEX_MAP)
+				mapExact := mapsStorage.GetMapData(pathExactMap)
+				mapPrefix := mapsStorage.GetMapData(pathPrefixMap)
+				mapRegex := mapsStorage.GetMapData(pathregexMap)
+				mapDomainWPathExact := mapsStorage.GetMapData(pathDomainWPathExactMap)
+				err = b.onDeletedHTTPRoute(routeKey, route, mapExact, mapPrefix, mapRegex, mapDomainWPathExact)
+				// errs.Add(err)
+				_ = err // TODO ignore error for now
+			}
 		}
 	}
 
 	// Managed HTTPRoutes => Create / update/ delete backends
 	for routeKey, route := range controllerStore.GateTree.HTTPRoutes {
 		for _, listener := range route.Listeners.Iterate {
-			frontendName, err := b.topManager.getFrontendName(listener.Owner, listener.K8sResource)
-			if err != nil {
-				b.topManager.logger.LogAttrs(context.Background(), slog.LevelError, "Failed to get frontend name",
-					logging.LogAttrError(err),
-				)
-			}
+			for _, listener := range listener {
+				frontendName, err := b.topManager.getFrontendName(listener.Owner, listener.K8sResource)
+				if err != nil {
+					b.topManager.logger.LogAttrs(context.Background(), slog.LevelError, "Failed to get frontend name",
+						logging.LogAttrError(err),
+					)
+				}
 
-			pathExactMap := mapsStorage.MapPath(frontendName, storage.PATH_EXACT_MAP)
-			pathPrefixMap := mapsStorage.MapPath(frontendName, storage.PATH_PREFIX_MAP)
-			pathDomainWPathExactMap := mapsStorage.MapPath(frontendName, storage.PATH_EXACT_DOMAIN_WILDCARD_MAP)
-			pathRegexMap := mapsStorage.MapPath(frontendName, storage.PATH_REGEX_MAP)
-			mapExact := mapsStorage.GetMapData(pathExactMap)
-			mapPrefix := mapsStorage.GetMapData(pathPrefixMap)
-			mapRegex := mapsStorage.GetMapData(pathRegexMap)
-			mapDomainWPathExact := mapsStorage.GetMapData(pathDomainWPathExactMap)
-
-			switch route.TreeStatus.Status {
-			case store.StatusUnchanged:
-				continue
-			case store.StatusUpserted:
-				err := b.onUpsertedHTTPRoute(routeKey, route, mapExact, mapPrefix, mapRegex, mapDomainWPathExact)
-				errs.Add(err)
-			case store.StatusDeleted:
-				err := b.onDeletedHTTPRoute(routeKey, route, mapExact, mapPrefix, mapRegex, mapDomainWPathExact)
-				errs.Add(err)
+				pathExactMap := mapsStorage.MapPath(frontendName, storage.PATH_EXACT_MAP)
+				pathPrefixMap := mapsStorage.MapPath(frontendName, storage.PATH_PREFIX_MAP)
+				pathDomainWPathExactMap := mapsStorage.MapPath(frontendName, storage.PATH_EXACT_DOMAIN_WILDCARD_MAP)
+				pathRegexMap := mapsStorage.MapPath(frontendName, storage.PATH_REGEX_MAP)
+				mapExact := mapsStorage.GetMapData(pathExactMap)
+				mapPrefix := mapsStorage.GetMapData(pathPrefixMap)
+				mapRegex := mapsStorage.GetMapData(pathRegexMap)
+				mapDomainWPathExact := mapsStorage.GetMapData(pathDomainWPathExactMap)
+
+				switch route.TreeStatus.Status {
+				case store.StatusUnchanged:
+					continue
+				case store.StatusUpserted:
+					err := b.onUpsertedHTTPRoute(routeKey, route, mapExact, mapPrefix, mapRegex, mapDomainWPathExact)
+					errs.Add(err)
+				case store.StatusDeleted:
+					err := b.onDeletedHTTPRoute(routeKey, route, mapExact, mapPrefix, mapRegex, mapDomainWPathExact)
+					errs.Add(err)
+				}
 			}
 		}
 	}

k8s/gate/tree/HTTPRoute-builder.go

@@ -177,11 +177,12 @@ func (b *HTTPRouteBuilderImpl) computeTreeGatewayUpdate(gwKey client.ObjectKey,
 	case store.StatusDeleted:
 		if treeHTTPRoute != nil {
 			// Iterate over the listeners of the deleted route and remove the route from each listener
-			treeHTTPRoute.Listeners.Iterate(func(_ string, listener *Listener) bool {
-				// This impact the Gateway object (listener status AttachedRoute), so it needs to be done, even so the HTTPRoute by itself is deleted
-				listener.deleteAttachedRoute(client.ObjectKeyFromObject(treeHTTPRoute.K8sResource), b.ControllerStore)
-				return true
-			})
+			for _, listeners := range treeHTTPRoute.Listeners.Iterate {
+				for _, listener := range listeners {
+					// This impact the Gateway object (listener status AttachedRoute), so it needs to be done, even so the HTTPRoute by itself is deleted
+					listener.deleteAttachedRoute(client.ObjectKeyFromObject(treeHTTPRoute.K8sResource), b.ControllerStore)
+				}
+			}
 			treeHTTPRoute.SetAsDeleted(b.Logger)
 			treeHTTPRoute.ResetChecks()
 		}

k8s/gate/tree/HTTPRoute.go

@@ -34,7 +34,7 @@ type HTTPRoute struct {
 	// K8sResource is the source resource.
 	K8sResource *gatewayv1.HTTPRoute
 	// selected listener
-	Listeners utils.KeyMap[gatewayv1.ParentReference, *Listener] // map[parentRef]
+	Listeners utils.KeyMap[gatewayv1.ParentReference, []*Listener] // map[parentRef]
 	// Rules
 	Rules []*HTTPRouteRule
 	// Final Conditions
@@ -70,7 +70,7 @@ func NewRoute(k8sObject *gatewayv1.HTTPRoute, controllerName string) *HTTPRoute
 			Status:          store.StatusUpserted,
 			OldTreeResource: nil,
 		},
-		Listeners: utils.NewKeyMap[gatewayv1.ParentReference, *Listener](utils.ParentRefToKey),
+		Listeners: utils.NewKeyMap[gatewayv1.ParentReference, []*Listener](utils.ParentRefToKey),
 		CheckParentRefs: CheckResultRoute{
 			Valid: false,
 			Conditions: rc.RouteConditions{
@@ -176,20 +176,17 @@ func (r *HTTPRoute) checkParentRefs(controllerStore ControllerStore) {
 			continue
 		}
 
+		routeConditions.MergeOverrideConditionsForParentRef(parentRef, result.Conditions)
 		// From now on, parentRef is a managed Gateway
 
 		// 1- The parentRef is not Valid
 		if !result.Valid {
 			// do not add the parentREf in Listener or check result
-			routeConditions.MergeOverrideConditionsForParentRef(parentRef, result.Conditions)
 			continue
 		}
 
 		// 2- The parentRef is Valid
 		atLeastOneValidParentRef = true
-		routeConditions.MergeOverrideConditionsForParentRef(parentRef, result.Conditions)
-		// no specific conditions
-		r.Listeners.Set(parentRef, result.Listener)
 	}
 
 	// Gather all Conditions for all parentRefs in the result
@@ -207,8 +204,6 @@ type checkParentRefResult struct {
 	// Conditions has a set of failing conditions
 	// It is set only if Managed is true
 	Conditions generic.Conditions
-	// Listener is the selected Listener
-	Listener *Listener
 	// Managed is true if the Gateway is managed by our controller
 	Managed bool
 	// Valid is set only if Managed is true
@@ -218,6 +213,7 @@ type checkParentRefResult struct {
 // checkParentRef checks 1 parentRef and returns:
 // - a bool indicating if the parentRef is valid, and if it's not, a set of conditions detailing why
 func (r *HTTPRoute) checkParentRef(parentRef gatewayv1.ParentReference, controllerStore ControllerStore) checkParentRefResult {
+	// Vérifie si le type de parentRef est supporté
 	if !isParentRefGroupKindSupported(parentRef, controllerStore.ExtractGVK) {
 		return checkParentRefResult{
 			Managed:    false,
@@ -226,34 +222,27 @@ func (r *HTTPRoute) checkParentRef(parentRef gatewayv1.ParentReference, controll
 		}
 	}
 
+	// Récupère le Gateway correspondant
 	gwKey := GetParentRefNamespacedName(parentRef, r.K8sResource)
-
 	treeGw, ok := controllerStore.GateTree.Gateways[gwKey]
 	if ok && treeGw.TreeStatus.Status == store.StatusDeleted {
-		// gateway exists, but it was deleted
 		return checkParentRefResult{
 			Managed:    true,
 			Valid:      false,
 			Conditions: rc.ConditionNotAcceptedNoMatchingParent(),
 		}
 	}
 	if !ok {
-		// It's a whole different story, it means the Gateway does not exists,
-		// we can not know if it's managed by our controller or not
 		return checkParentRefResult{
 			Managed:    false,
 			Valid:      false,
 			Conditions: generic.Conditions{},
 		}
 	}
 
-	// From now on, the parent references an exising Gateway managed by our controller
-	// SectionName is optional
-	// 1- if set, the only attachable listener is the one references by the sectionName
-	// 2- if not set, all listeners from the Gateway are attachable
+	// Collecte les listeners attachables
 	attachableListeners := make([]*Listener, 0)
 	if parentRef.SectionName != nil {
-		// Check if the Gateway has this listener
 		listener, ok := treeGw.Listeners[string(*parentRef.SectionName)]
 		if !ok {
 			return checkParentRefResult{
@@ -262,94 +251,59 @@ func (r *HTTPRoute) checkParentRef(parentRef gatewayv1.ParentReference, controll
 				Conditions: rc.ConditionNotAcceptedNoMatchingParent(),
 			}
 		}
-		// We found the listener, it does exists
 		attachableListeners = append(attachableListeners, listener)
 	} else {
 		for _, listener := range treeGw.Listeners {
 			attachableListeners = append(attachableListeners, listener)
 		}
 	}
 
-	// If we have only 1 attache listener, just check the hostnames
-	if len(attachableListeners) == 1 {
-		listener := attachableListeners[0]
-		if !listener.Valid {
-			return checkParentRefResult{
-				Managed:    true,
-				Valid:      false,
-				Conditions: rc.ConditionNotAcceptedNoMatchingParent(),
-			}
-		}
-		if matched := matchHostname(r.K8sResource.Spec.Hostnames, listener.K8sResource.Hostname); matched {
-			// AllowedRouteKind ???
-			allowedRouteKind := r.isAllowedRouteKind(listener, controllerStore.ExtractGVK)
-			if !allowedRouteKind {
-				return checkParentRefResult{
-					Managed:    true,
-					Valid:      false,
-					Conditions: rc.ConditionNotAcceptedRouteReasonNotAllowedByListeners(),
-				}
-			}
-
-			// Set the Listener attached Route
-			listener.addAttachedRoute(client.ObjectKeyFromObject(r.K8sResource), controllerStore)
-
-			return checkParentRefResult{
-				Managed:    true,
-				Valid:      true,
-				Listener:   listener,
-				Conditions: rc.ConditionAccepted(),
-			}
-		}
-		return checkParentRefResult{
-			Managed:    true,
-			Valid:      false,
-			Conditions: rc.ConditionNotAcceptedNoMatchingHostname(),
-		}
-	}
+	validListeners := make([]*Listener, 0)
+	conds := generic.Conditions{}
 
-	// Now, case where we need to find a listener among the list
-	var matched bool
-	var matchedListener *Listener
 	for _, listener := range attachableListeners {
+		// Vérifie la validité du listener
 		if !listener.Valid {
+			conds.MergeOverrideConditions(rc.ConditionNotAcceptedNoMatchingParent())
 			continue
 		}
 
-		// Match Hostname ?
-		if matchHostname(r.K8sResource.Spec.Hostnames, listener.K8sResource.Hostname) {
-			matched = true
-			matchedListener = listener
-			break
+		// Vérifie le hostname
+		if !matchHostname(r.K8sResource.Spec.Hostnames, listener.K8sResource.Hostname) {
+			conds.MergeOverrideConditions(rc.ConditionNotAcceptedNoMatchingHostname())
+			continue
 		}
-	}
-	if !matched {
-		return checkParentRefResult{
-			Managed:    true,
-			Valid:      false,
-			Conditions: rc.ConditionNotAcceptedNoMatchingParent(),
+
+		// Vérifie le type de route autorisé
+		if !r.isAllowedRouteKind(listener, controllerStore.ExtractGVK) {
+			conds.MergeOverrideConditions(rc.ConditionNotAcceptedRouteReasonNotAllowedByListeners())
+			continue
 		}
-	}
 
-	// We have found a listener
-	// Allowed RouteKind ??
-	allowedRouteKind := r.isAllowedRouteKind(matchedListener, controllerStore.ExtractGVK)
-	// Set the Listener attached Route
-	matchedListener.addAttachedRoute(client.ObjectKeyFromObject(r.K8sResource), controllerStore)
+		// Listener valide, attache la route
+		listener.addAttachedRoute(client.ObjectKeyFromObject(r.K8sResource), controllerStore)
+		validListeners = append(validListeners, listener)
+
+		// Met à jour la KeyMap r.Listeners
+		existing, _ := r.Listeners.Get(parentRef)
+		existing = append(existing, listener)
+		r.Listeners.Set(parentRef, existing)
+	}
 
-	if !allowedRouteKind {
+	// Si aucun listener valide, retourne les conditions cumulées
+	if len(validListeners) == 0 {
 		return checkParentRefResult{
 			Managed:    true,
 			Valid:      false,
-			Conditions: rc.ConditionNotAcceptedRouteReasonNotAllowedByListeners(),
+			Conditions: conds,
 		}
 	}
 
+	// Au moins un listener valide
 	return checkParentRefResult{
 		Managed:    true,
 		Valid:      true,
-		Listener:   matchedListener,
-		Conditions: generic.Conditions{},
+		Conditions: rc.ConditionAccepted(),
 	}
 }
 

test/integration/base/base.go

@@ -19,8 +19,10 @@ import (
 	"context"
 	"os"
 	"path"
+	"path/filepath"
 	"sort"
 	"strconv"
+	"strings"
 	"syscall"
 	"time"
 
@@ -352,6 +354,28 @@ func (b *BaseSuite) BackendFromManifest(manifestPath, manifestName string) *mode
 	return &be
 }
 
+func (b *BaseSuite) GetMapFileFrom(mapFileRelativePath string) ([]string, error) {
+	var mapFile []byte
+	mapFile, err := os.ReadFile(filepath.Join(b.test.HaproxyCfgDir, "maps", mapFileRelativePath))
+	if err != nil {
+		return nil, err
+	}
+	return strings.Split(string(mapFile), "\n"), nil
+}
+
+func (b *BaseSuite) CheckEntryInMapFile(mapFileRelativePath, key, value string) bool {
+	mapFile, err := b.GetMapFileFrom(mapFileRelativePath)
+	if err != nil {
+		return false
+	}
+	for _, line := range mapFile {
+		if line == key+" "+value {
+			return true
+		}
+	}
+	return false
+}
+
 // func (b *BaseSuite) exportFrontend(fe *models.Frontend) {
 // 	// Marshal the Go struct into a YAML byte slice.
 // 	// This process converts the Go data structure into its YAML representation.

test/integration/base/inttest.go

@@ -87,6 +87,7 @@ type IntTest struct {
 	TestEnv       *envtest.Environment
 	cancel        context.CancelFunc
 	Namespace     string
+	HaproxyCfgDir string
 }
 
 func NewIntTest(t *testing.T) (test IntTest, err error) {
@@ -210,7 +211,7 @@ func (test *IntTest) StartTestEnv(t *testing.T) { //revive:disable:function-leng
 	// // ----------------
 	// // Start Haproxy App manager
 	var wg sync.WaitGroup
-
+	test.HaproxyCfgDir = gateconfig.HaproxyParams.CfgDir
 	haproxyClient, err := hapapi.New(gateconfig.Logger, gateconfig.HaproxyParams.CfgDir,
 		gateconfig.HaproxyParams.MainCfgFile, gateconfig.HaproxyParams.HaproxyBinary, gateconfig.HaproxyParams.RuntimeSocket)
 	if err != nil {