add httproutes

Change-Id: I25ceffb1871e0ca73106236fa0eb4770228f949d

Author: aojea

pkg/controller/controller.go

@@ -280,6 +280,7 @@ func startCloudControllerManager(ctx context.Context, clusterName string, config
 		clusterName,
 		gwClient,
 		sharedInformers.Core().V1().Namespaces(),
+		sharedInformers.Core().V1().Services(),
 		sharedGwInformers.Gateway().V1().Gateways(),
 		sharedGwInformers.Gateway().V1().HTTPRoutes(),
 		sharedGwInformers.Gateway().V1().GRPCRoutes(),

pkg/gateway/backendref.go

@@ -0,0 +1 @@
+package gateway

pkg/gateway/controller.go

@@ -64,6 +64,9 @@ type Controller struct {
 	namespaceLister       corev1listers.NamespaceLister
 	namespaceListerSynced cache.InformerSynced
 
+	serviceLister       corev1listers.ServiceLister
+	serviceListerSynced cache.InformerSynced
+
 	gatewayLister       gatewaylisters.GatewayLister
 	gatewayListerSynced cache.InformerSynced
 	gatewayqueue        workqueue.TypedRateLimitingInterface[string]
@@ -88,6 +91,7 @@ func New(
 	clusterName string,
 	gwClient *gatewayclient.Clientset,
 	namespaceInformer corev1informers.NamespaceInformer,
+	serviceInformer corev1informers.ServiceInformer,
 	gatewayInformer gatewayinformers.GatewayInformer,
 	httprouteInformer gatewayinformers.HTTPRouteInformer,
 	grpcrouteInformer gatewayinformers.GRPCRouteInformer,
@@ -96,6 +100,8 @@ func New(
 		clusterName:           clusterName,
 		namespaceLister:       namespaceInformer.Lister(),
 		namespaceListerSynced: namespaceInformer.Informer().HasSynced,
+		serviceLister:         serviceInformer.Lister(),
+		serviceListerSynced:   serviceInformer.Informer().HasSynced,
 		gwClient:              gwClient,
 		gatewayLister:         gatewayInformer.Lister(),
 		gatewayListerSynced:   gatewayInformer.Informer().HasSynced,
@@ -326,7 +332,13 @@ func (c *Controller) Run(ctx context.Context) error {
 	klog.Info("Starting Gateway API controller")
 
 	// Wait for all involved caches to be synced, before processing items from the queue is started
-	if !cache.WaitForNamedCacheSync(controllerName, ctx.Done(), c.gatewayListerSynced, c.httprouteListerSynced, c.grpcrouteListerSynced, c.namespaceListerSynced) {
+	if !cache.WaitForNamedCacheSync(controllerName, ctx.Done(),
+		c.gatewayListerSynced,
+		c.httprouteListerSynced,
+		c.grpcrouteListerSynced,
+		c.namespaceListerSynced,
+		c.serviceListerSynced,
+	) {
 		return fmt.Errorf("timed out waiting for caches to sync")
 	}
 

pkg/gateway/gateway.go

@@ -22,6 +22,8 @@ import (
 	"sigs.k8s.io/cloud-provider-kind/pkg/config"
 	"sigs.k8s.io/cloud-provider-kind/pkg/container"
 
+	"strings"
+
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 )
 
@@ -117,33 +119,20 @@ func (c *Controller) syncGateway(key string) error {
 		for _, route := range c.getHTTPRoutesForListener(gw, listener) {
 			klog.V(2).Infof("Processing http route %s/%s for gw %s/%s", route.Namespace, route.Name, gw.Namespace, gw.Name)
 			// Check hostnames between listener and route
-			for _, hostname := range route.Spec.Hostnames {
-				if hostname != *listener.Hostname {
-
-				}
+			if !hostnamesIntersect(listener.Hostname, route.Spec.Hostnames) {
+				klog.V(4).Infof("HTTPRoute %s/%s hostnames do not intersect with Gateway %s/%s Listener %s hostname, skipping", route.Namespace, route.Name, gw.Namespace, gw.Name, listener.Name)
+				continue // Skip this route for this listener if hostnames don't intersect
 			}
-			// Process rules
-			for _, rule := range route.Spec.Rules {
-				for _, match := range rule.Matches {
-					klog.Infof("match %#v", match)
-				}
-				for _, filter := range rule.Filters {
-					klog.Infof("match %#v", filter)
-				}
-				for _, backend := range rule.BackendRefs {
-					klog.Infof("match %#v", backend)
-					for _, filter := range backend.Filters {
-						klog.Infof("match %#v", filter)
-					}
-				}
-
-				// TODO Timeouts
-				// TODO Retry
-				// TODO SessionPersistence
+
+			routeEnvoyResources, err := translateHTTPRouteToEnvoyResources(c.serviceLister, route)
+			if err != nil {
+				klog.Errorf("Error translating HTTPRoute %s/%s: %v", route.Namespace, route.Name, err)
+				continue // Skip this route if translation fails
 			}
 
-			resources[resourcev3.RouteType] = append(resources[resourcev3.RouteType], &routev3.Route{})
-			resources[resourcev3.ClusterType] = append(resources[resourcev3.ClusterType], &clusterv3.Cluster{})
+			// Merge the translated resources into the main map
+			mergeEnvoyResources(resources, routeEnvoyResources)
+
 		}
 
 		for _, route := range c.getGRPCRoutesForListener(gw, listener) {
@@ -277,3 +266,77 @@ func (c *Controller) getGRPCRoutesForListener(gw *gatewayv1.Gateway, listener ga
 
 	return matchingRoutes
 }
+
+// mergeEnvoyResources merges resources generated for a specific route (source)
+// into the main resource map (target).
+func mergeEnvoyResources(target map[resourcev3.Type][]envoyproxytypes.Resource, source map[resourcev3.Type][]interface{}) {
+	for resType, resList := range source {
+		if _, ok := target[resType]; !ok {
+			target[resType] = []envoyproxytypes.Resource{}
+		}
+		// Convert []interface{} to []envoyproxytypes.Resource
+		for _, res := range resList {
+			if envoyRes, ok := res.(envoyproxytypes.Resource); ok {
+				target[resType] = append(target[resType], envoyRes)
+			} else {
+				klog.Warningf("Translated resource is not of type envoyproxytypes.Resource: %T", res)
+			}
+		}
+	}
+}
+
+// hostnameMatches checks if a route hostname matches a listener hostname according to Gateway API rules.
+func hostnameMatches(listenerHostname, routeHostname gatewayv1.Hostname) bool {
+	lh := string(listenerHostname)
+	rh := string(routeHostname)
+
+	// Exact match
+	if lh == rh {
+		return true
+	}
+
+	// Wildcard listener
+	if strings.HasPrefix(lh, "*.") {
+		listenerDomain := lh[1:] // .example.com
+		if strings.HasPrefix(rh, "*.") {
+			// Both are wildcards, check if domains suffix match each other
+			routeDomain := rh[1:]
+			return strings.HasSuffix(listenerDomain, routeDomain) || strings.HasSuffix(routeDomain, listenerDomain)
+		}
+		// Route is not wildcard, check if it's a suffix and not the domain itself (e.g., *.com does not match com)
+		return strings.HasSuffix(rh, listenerDomain) && rh != listenerDomain[1:]
+	}
+
+	// Wildcard route
+	if strings.HasPrefix(rh, "*.") {
+		// Listener is not wildcard, check if it's a suffix and not the domain itself
+		routeDomain := rh[1:] // .example.com
+		return strings.HasSuffix(lh, routeDomain) && lh != routeDomain[1:]
+	}
+
+	// No wildcards involved, and not an exact match
+	return false
+}
+
+// hostnamesIntersect checks if any route hostname intersects with the listener hostname.
+func hostnamesIntersect(listenerHostname *gatewayv1.Hostname, routeHostnames []gatewayv1.Hostname) bool {
+	// If the route specifies no hostnames, it implicitly matches any listener hostname.
+	if len(routeHostnames) == 0 {
+		return true
+	}
+
+	// If the listener specifies no hostname, it implicitly matches any route hostname.
+	if listenerHostname == nil || *listenerHostname == "" {
+		return true
+	}
+
+	lh := *listenerHostname
+	for _, rh := range routeHostnames {
+		if hostnameMatches(lh, rh) {
+			return true // Found an intersection
+		}
+	}
+
+	// No intersection found
+	return false
+}

pkg/gateway/gateway_test.go

@@ -0,0 +1,139 @@
+package gateway
+
+import (
+	"testing"
+
+	"k8s.io/utils/ptr"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
+)
+
+func TestHostnameMatches(t *testing.T) {
+	tests := []struct {
+		name             string
+		listenerHostname gatewayv1.Hostname
+		routeHostname    gatewayv1.Hostname
+		want             bool
+	}{
+		{"exact match", "foo.example.com", "foo.example.com", true},
+		{"listener wildcard, route exact match", "*.example.com", "foo.example.com", true},
+		{"listener wildcard, route exact non-match (diff domain)", "*.example.com", "foo.example.net", false},
+		{"listener wildcard, route exact non-match (domain itself)", "*.example.com", "example.com", false},
+		{"listener wildcard, route wildcard match (subdomain)", "*.foo.example.com", "*.example.com", true},
+		{"listener wildcard, route wildcard match (same)", "*.example.com", "*.example.com", true},
+		{"listener wildcard, route wildcard non-match", "*.example.com", "*.example.net", false},
+		{"listener exact, route wildcard match", "foo.example.com", "*.example.com", true},
+		{"listener exact, route wildcard non-match (diff domain)", "foo.example.net", "*.example.com", false},
+		{"listener exact, route wildcard non-match (domain itself)", "example.com", "*.example.com", false},
+		{"no wildcard, non-match", "foo.example.com", "bar.example.com", false},
+		{"no wildcard, non-match diff domain", "foo.example.com", "foo.example.net", false},
+		{"empty listener", "", "foo.example.com", false}, // Exact match fails
+		{"empty route", "foo.example.com", "", false},    // Exact match fails
+		{"both empty", "", "", true}, // Exact match
+		{"listener wildcard, route empty", "*.example.com", "", false},
+		{"listener empty, route wildcard", "", "*.example.com", false},
+		{"complex wildcard listener match", "*.apps.example.com", "foo.bar.apps.example.com", true},
+		{"complex wildcard route match", "foo.bar.apps.example.com", "*.apps.example.com", true},
+		{"wildcard vs non-wildcard TLD", "*.com", "example.com", true}, // *.com matches example.com
+		{"non-wildcard TLD vs wildcard", "example.com", "*.com", true}, // *.com matches example.com
+		{"wildcard TLD vs TLD", "*.com", "com", false},                 // *.com does not match com
+		{"TLD vs wildcard TLD", "com", "*.com", false},                 // *.com does not match com
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := hostnameMatches(tt.listenerHostname, tt.routeHostname); got != tt.want {
+				t.Errorf("hostnameMatches(%q, %q) = %v, want %v", tt.listenerHostname, tt.routeHostname, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestHostnamesIntersect(t *testing.T) {
+	tests := []struct {
+		name             string
+		listenerHostname *gatewayv1.Hostname
+		routeHostnames   []gatewayv1.Hostname
+		want             bool
+	}{
+		{
+			name:             "empty route hostnames",
+			listenerHostname: ptr.To(gatewayv1.Hostname("foo.example.com")),
+			routeHostnames:   []gatewayv1.Hostname{},
+			want:             true,
+		},
+		{
+			name:             "nil listener hostname",
+			listenerHostname: nil,
+			routeHostnames:   []gatewayv1.Hostname{"foo.example.com"},
+			want:             true,
+		},
+		{
+			name:             "empty listener hostname",
+			listenerHostname: ptr.To(gatewayv1.Hostname("")),
+			routeHostnames:   []gatewayv1.Hostname{"foo.example.com"},
+			want:             true,
+		},
+		{
+			name:             "exact match intersection",
+			listenerHostname: ptr.To(gatewayv1.Hostname("foo.example.com")),
+			routeHostnames:   []gatewayv1.Hostname{"bar.example.com", "foo.example.com"},
+			want:             true,
+		},
+		{
+			name:             "wildcard listener intersection",
+			listenerHostname: ptr.To(gatewayv1.Hostname("*.example.com")),
+			routeHostnames:   []gatewayv1.Hostname{"bar.example.net", "foo.example.com"},
+			want:             true,
+		},
+		{
+			name:             "wildcard route intersection",
+			listenerHostname: ptr.To(gatewayv1.Hostname("foo.example.com")),
+			routeHostnames:   []gatewayv1.Hostname{"bar.example.net", "*.example.com"},
+			want:             true,
+		},
+		{
+			name:             "wildcard both intersection",
+			listenerHostname: ptr.To(gatewayv1.Hostname("*.example.com")),
+			routeHostnames:   []gatewayv1.Hostname{"bar.example.net", "*.apps.example.com"},
+			want:             true,
+		},
+		{
+			name:             "no intersection",
+			listenerHostname: ptr.To(gatewayv1.Hostname("foo.example.com")),
+			routeHostnames:   []gatewayv1.Hostname{"bar.example.com", "baz.example.com"},
+			want:             false,
+		},
+		{
+			name:             "no intersection with wildcards",
+			listenerHostname: ptr.To(gatewayv1.Hostname("*.example.net")),
+			routeHostnames:   []gatewayv1.Hostname{"bar.example.com", "*.apps.example.com"},
+			want:             false,
+		},
+		{
+			name:             "listener wildcard, route domain itself (no intersection)",
+			listenerHostname: ptr.To(gatewayv1.Hostname("*.example.com")),
+			routeHostnames:   []gatewayv1.Hostname{"example.com", "foo.example.net"},
+			want:             false,
+		},
+		{
+			name:             "listener exact, route wildcard domain itself (no intersection)",
+			listenerHostname: ptr.To(gatewayv1.Hostname("example.com")),
+			routeHostnames:   []gatewayv1.Hostname{"*.example.com", "foo.example.net"},
+			want:             false,
+		},
+		{
+			name:             "both nil/empty",
+			listenerHostname: nil,
+			routeHostnames:   []gatewayv1.Hostname{},
+			want:             true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := hostnamesIntersect(tt.listenerHostname, tt.routeHostnames); got != tt.want {
+				t.Errorf("hostnamesIntersect() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}