f:

Author: dspo

internal/controller/httproute_controller.go

@@ -38,7 +38,6 @@ import (
 	"sigs.k8s.io/gateway-api/apis/v1alpha2"
 
 	"github.com/apache/apisix-ingress-controller/api/v1alpha1"
-	"github.com/apache/apisix-ingress-controller/internal/controller/config"
 	"github.com/apache/apisix-ingress-controller/internal/controller/indexer"
 	"github.com/apache/apisix-ingress-controller/internal/provider"
 )
@@ -210,30 +209,24 @@ func (r *HTTPRouteReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	// TODO: diff the old and new status
 	hr.Status.Parents = make([]gatewayv1.RouteParentStatus, 0, len(gateways))
 	for _, gateway := range gateways {
-		parentStatus := gatewayv1.RouteParentStatus{
-			ParentRef: gatewayv1.ParentReference{
-				Kind:      ptr.To(gatewayv1.Kind(KindGateway)),
-				Group:     ptr.To(gatewayv1.Group(gatewayv1.GroupName)),
-				Name:      gatewayv1.ObjectName(gateway.Gateway.GetName()),
-				Namespace: ptr.To(gatewayv1.Namespace(gateway.Gateway.GetNamespace())),
-			},
-			ControllerName: gatewayv1.GatewayController(config.ControllerConfig.ControllerName),
-		}
+		parentStatus := gatewayv1.RouteParentStatus{}
+		SetRouteParentRef(&parentStatus, gateway.Gateway.Name, gateway.Gateway.Namespace)
 		for _, condition := range gateway.Conditions {
 			parentStatus.Conditions = MergeCondition(parentStatus.Conditions, condition)
 		}
 		if gateway.ListenerName == "" {
 			continue
 		}
 		SetRouteConditionResolvedRefs(&parentStatus, hr.GetGeneration(), resolveRefStatus.status, resolveRefStatus.msg)
-		// if the HTTPRoute is not accepted, the length of .Status.Parents should be 0 or 1. If it is 1, it can only contain a condition with Status="False"
-		if accepted := SetRouteConditionAccepted(&parentStatus, gateway.Gateway, hr, acceptStatus.status, acceptStatus.msg); !accepted {
-			hr.Status.Parents = []gatewayv1.RouteParentStatus{
-				parentStatus,
-			}
-			break
+		SetRouteConditionAccepted(&parentStatus, hr.GetGeneration(), acceptStatus.status, acceptStatus.msg)
+		var accepted = !slices.ContainsFunc(parentStatus.Conditions, func(condition metav1.Condition) bool {
+			return condition.Status == metav1.ConditionFalse
+		})
+		if accepted {
+			hr.Status.Parents = append(hr.Status.Parents, parentStatus)
+		} else {
+			hr.Status.Parents = []gatewayv1.RouteParentStatus{parentStatus}
 		}
-		hr.Status.Parents = append(hr.Status.Parents, parentStatus)
 	}
 	if err := r.Status().Update(ctx, hr); err != nil {
 		return ctrl.Result{}, err

internal/controller/utils.go

@@ -17,6 +17,7 @@ import (
 	"fmt"
 	"path"
 	"reflect"
+	"slices"
 	"strings"
 
 	"github.com/api7/gopkg/pkg/log"
@@ -230,26 +231,21 @@ func ConditionStatus(status bool) metav1.ConditionStatus {
 	return metav1.ConditionFalse
 }
 
-func SetRouteConditionAccepted(routeParentStatus *gatewayv1.RouteParentStatus, gw *gatewayv1.Gateway, hr *gatewayv1.HTTPRoute, acceptedStatus bool, acceptStatusMsg string) (accepted bool) {
+func SetRouteConditionAccepted(routeParentStatus *gatewayv1.RouteParentStatus, generation int64, status bool, message string) {
 	condition := metav1.Condition{
 		Type:               string(gatewayv1.RouteConditionAccepted),
-		Status:             ConditionStatus(acceptedStatus),
-		ObservedGeneration: hr.GetGeneration(),
-		LastTransitionTime: metav1.Now(),
+		Status:             ConditionStatus(status),
 		Reason:             string(gatewayv1.RouteReasonAccepted),
-		Message:            acceptStatusMsg,
-	}
-	// if it is across the namespace between the Gateway and HTTPRoute, set .Status="False"
-	if gw.GetNamespace() != hr.GetNamespace() {
-		condition.Status = metav1.ConditionFalse
-		condition.Reason = string(gatewayv1.RouteReasonNotAllowedByListeners)
-		condition.Message = fmt.Sprintf("A HTTPRoute in the namespace %s failed to attach to a Gateway in another namespace %s",
-			hr.GetNamespace(), gw.GetNamespace())
+		ObservedGeneration: generation,
+		Message:            message,
+		LastTransitionTime: metav1.Now(),
 	}
-	if !IsConditionPresentAndEqual(routeParentStatus.Conditions, condition) {
+
+	if !IsConditionPresentAndEqual(routeParentStatus.Conditions, condition) && !slices.ContainsFunc(routeParentStatus.Conditions, func(item metav1.Condition) bool {
+		return item.Type == condition.Type && item.Status == metav1.ConditionFalse && condition.Status == metav1.ConditionTrue
+	}) {
 		routeParentStatus.Conditions = MergeCondition(routeParentStatus.Conditions, condition)
 	}
-	return condition.Status == metav1.ConditionTrue
 }
 
 func SetRouteConditionResolvedRefs(routeParentStatus *gatewayv1.RouteParentStatus, generation int64, status bool, message string) {
@@ -273,6 +269,19 @@ func SetRouteConditionResolvedRefs(routeParentStatus *gatewayv1.RouteParentStatu
 	}
 }
 
+func SetRouteParentRef(routeParentStatus *gatewayv1.RouteParentStatus, gatewayName string, namespace string) {
+	kind := gatewayv1.Kind(KindGateway)
+	group := gatewayv1.Group(gatewayv1.GroupName)
+	ns := gatewayv1.Namespace(namespace)
+	routeParentStatus.ParentRef = gatewayv1.ParentReference{
+		Kind:      &kind,
+		Group:     &group,
+		Name:      gatewayv1.ObjectName(gatewayName),
+		Namespace: &ns,
+	}
+	routeParentStatus.ControllerName = gatewayv1.GatewayController(config.ControllerConfig.ControllerName)
+}
+
 func ParseRouteParentRefs(
 	ctx context.Context, mgrc client.Client, route client.Object, parentRefs []gatewayv1.ParentReference,
 ) ([]RouteParentRefContext, error) {
@@ -339,19 +348,21 @@ func ParseRouteParentRefs(
 				continue
 			}
 
-			if ok, err := routeMatchesListenerAllowedRoutes(ctx, mgrc, route, listener.AllowedRoutes, gateway.Namespace, parentRef.Namespace); err != nil {
-				return nil, fmt.Errorf("failed matching listener %s to a route %s for gateway %s: %w",
+			listenerName = string(listener.Name)
+			ok, err := routeMatchesListenerAllowedRoutes(ctx, mgrc, route, listener.AllowedRoutes, gateway.Namespace, parentRef.Namespace)
+			if err != nil {
+				log.Warnf("failed matching listener %s to a route %s for gateway %s: %v",
 					listener.Name, route.GetName(), gateway.Name, err,
 				)
-			} else if !ok {
+			}
+			if !ok {
 				reason = gatewayv1.RouteReasonNotAllowedByListeners
 				continue
 			}
 
 			// TODO: check if the listener status is programmed
 
 			matched = true
-			listenerName = string(listener.Name)
 			break
 		}
 
@@ -368,7 +379,8 @@ func ParseRouteParentRefs(
 			})
 		} else {
 			gateways = append(gateways, RouteParentRefContext{
-				Gateway: &gateway,
+				Gateway:      &gateway,
+				ListenerName: listenerName,
 				Conditions: []metav1.Condition{{
 					Type:               string(gatewayv1.RouteConditionAccepted),
 					Status:             metav1.ConditionFalse,

test/conformance/suite_test.go

@@ -22,7 +22,6 @@ import (
 	"github.com/gruntwork-io/terratest/modules/retry"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 
@@ -223,14 +222,6 @@ func patchGatewaysForConformanceTest(ctx context.Context, k8sClient client.Clien
 				},
 			}
 
-			if len(gateway.Spec.Listeners) > 0 {
-				gateway.Spec.Listeners[0].AllowedRoutes = &gatewayv1.AllowedRoutes{
-					Namespaces: &gatewayv1.RouteNamespaces{
-						From: ptr.To(gatewayv1.FromNamespaces("All")),
-					},
-				}
-			}
-
 			if err := k8sClient.Update(ctx, gateway); err != nil {
 				GinkgoT().Logf("Failed to patch Gateway %s: %v", gateway.Name, err)
 				continue