Merge pull request #4241 from shuqz/shuqz-httproute

[feat gw-api]implement httproute matching and weighted target group

Author: k8s-ci-robot

pkg/gateway/model/model_build_listener.go

@@ -14,7 +14,6 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services"
 	certs "sigs.k8s.io/aws-load-balancer-controller/pkg/certs"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/routeutils"
-	"sigs.k8s.io/aws-load-balancer-controller/pkg/ingress"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/model/core"
 	elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"
@@ -164,63 +163,53 @@ func (l listenerBuilderImpl) buildL4ListenerSpec(ctx context.Context, stack core
 	return listenerSpec, nil
 }
 
+// this is only for L7 ALB
 func (l listenerBuilderImpl) buildListenerRules(stack core.Stack, ls *elbv2model.Listener, lb *elbv2model.LoadBalancer, securityGroups securityGroupOutput, gw *gwv1.Gateway, port int32, lbCfg elbv2gw.LoadBalancerConfiguration, routes map[int32][]routeutils.RouteDescriptor) error {
-
-	// add hostname handling (sort by precedence order)
-	sortRoutesByHostnamePrecedence(routes[port])
-
-	// TODO for L7 Gateway Implementation
-	// This is throw away code
-	// This is temporary implementation for supporting basic multiple HTTPRoute for simple backend refs. We will create default forward action for all the backend refs for all HTTPRoutes for this listener
-	var rules []ingress.Rule
-	for _, descriptors := range routes {
-		for _, descriptor := range descriptors {
-			for _, rule := range descriptor.GetAttachedRules() {
-				for _, backend := range rule.GetBackends() {
-					targetGroup, tgErr := l.tgBuilder.buildTargetGroup(stack, gw, lbCfg, lb.Spec.IPAddressType, descriptor, backend, securityGroups.backendSecurityGroupToken)
-					if tgErr != nil {
-						return tgErr
-					}
-					// Basic condition
-					conditions := []elbv2model.RuleCondition{{
-						Field: elbv2model.RuleConditionFieldPathPattern,
-						PathPatternConfig: &elbv2model.PathPatternConditionConfig{
-							Values: []string{"/*"},
-						},
-					},
-					}
-
-					// add host header condition
-					if hostnames := descriptor.GetHostnames(); len(hostnames) > 0 {
-						hostnamesStringList := make([]string, len(descriptor.GetHostnames()))
-						for i, j := range descriptor.GetHostnames() {
-							hostnamesStringList[i] = string(j)
-						}
-						conditions = append(conditions, elbv2model.RuleCondition{
-							Field: elbv2model.RuleConditionFieldHostHeader,
-							HostHeaderConfig: &elbv2model.HostHeaderConditionConfig{
-								Values: hostnamesStringList,
-							},
-						})
-					}
-
-					actions := buildL4ListenerDefaultActions(targetGroup)
-					tags, tagsErr := l.tagHelper.getGatewayTags(lbCfg)
-					if tagsErr != nil {
-						return tagsErr
-					}
-					rules = append(rules, ingress.Rule{
-						Conditions: conditions,
-						Actions:    actions,
-						Tags:       tags,
-					})
-				}
+	// sort all rules based on precedence
+	rulesWithPrecedenceOrder := routeutils.SortAllRulesByPrecedence(routes[port])
+
+	var albRules []elbv2model.Rule
+	for _, ruleWithPrecedence := range rulesWithPrecedenceOrder {
+		route := ruleWithPrecedence.RouteDescriptor
+		rule := ruleWithPrecedence.Rule
+
+		var conditionsList []elbv2model.RuleCondition
+		var err error
+		switch route.GetRouteKind() {
+		case routeutils.HTTPRouteKind:
+			conditionsList, err = routeutils.BuildHttpRuleConditions(ruleWithPrecedence)
+			if err != nil {
+				return err
 			}
+			// TODO: add case for GRPC
 		}
+		tags, tagsErr := l.tagHelper.getGatewayTags(lbCfg)
+		if tagsErr != nil {
+			return tagsErr
+		}
+		targetGroupTuples := make([]elbv2model.TargetGroupTuple, 0, len(rule.GetBackends()))
+		for _, backend := range rule.GetBackends() {
+			targetGroup, tgErr := l.tgBuilder.buildTargetGroup(stack, gw, lbCfg, lb.Spec.IPAddressType, route, backend, securityGroups.backendSecurityGroupToken)
+			if tgErr != nil {
+				return tgErr
+			}
+			// weighted target group support
+			weight := int32(backend.Weight)
+			targetGroupTuples = append(targetGroupTuples, elbv2model.TargetGroupTuple{
+				TargetGroupARN: targetGroup.TargetGroupARN(),
+				Weight:         &weight,
+			})
+		}
+		actions := buildL7ListenerActions(targetGroupTuples)
+		albRules = append(albRules, elbv2model.Rule{
+			Conditions: conditionsList,
+			Actions:    actions,
+			Tags:       tags,
+		})
 	}
 
 	priority := int32(1)
-	for _, rule := range rules {
+	for _, rule := range albRules {
 		ruleResID := fmt.Sprintf("%v:%v", port, priority)
 		_ = elbv2model.NewListenerRule(stack, ruleResID, elbv2model.ListenerRuleSpec{
 			ListenerARN: ls.ListenerARN(),
@@ -336,6 +325,17 @@ func buildL4ListenerDefaultActions(targetGroup *elbv2model.TargetGroup) []elbv2m
 	}
 }
 
+func buildL7ListenerActions(targetGroupTuple []elbv2model.TargetGroupTuple) []elbv2model.Action {
+	return []elbv2model.Action{
+		{
+			Type: elbv2model.ActionTypeForward,
+			ForwardConfig: &elbv2model.ForwardActionConfig{
+				TargetGroups: targetGroupTuple,
+			},
+		},
+	}
+}
+
 func buildMutualAuthenticationAttributes(gwLsCfg *gwListenerConfig, lbLsCfg *elbv2gw.ListenerConfiguration) (*elbv2model.MutualAuthenticationAttributes, error) {
 	// TODO for L7 gateway
 	return nil, nil

pkg/gateway/model/utilities.go

@@ -1,10 +1,7 @@
 package model
 
 import (
-	"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/routeutils"
 	elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"
-	v1 "sigs.k8s.io/gateway-api/apis/v1"
-	"sort"
 	"strings"
 )
 
@@ -21,44 +18,3 @@ func isIPv6Supported(ipAddressType elbv2model.IPAddressType) bool {
 func isIPv6CIDR(cidr string) bool {
 	return strings.Contains(cidr, ":")
 }
-
-func getHighestPrecedenceHostname(hostnames []v1.Hostname) string {
-	if len(hostnames) == 0 {
-		return ""
-	}
-
-	highestHostname := hostnames[0]
-	for _, hostname := range hostnames {
-		if routeutils.GetHostnamePrecedenceOrder(string(hostname), string(highestHostname)) < 0 {
-			highestHostname = hostname
-		}
-	}
-	return string(highestHostname)
-}
-
-func sortRoutesByHostnamePrecedence(routes []routeutils.RouteDescriptor) {
-	// sort routes based on their highest precedence hostname
-	sort.SliceStable(routes, func(i, j int) bool {
-		hostnameOne := routes[i].GetHostnames()
-		hostnameTwo := routes[j].GetHostnames()
-
-		if len(hostnameOne) == 0 && len(hostnameTwo) == 0 {
-			return false
-		}
-		if len(hostnameOne) == 0 {
-			return false
-		}
-		if len(hostnameTwo) == 0 {
-			return true
-		}
-
-		highestPrecedenceHostnameOne := getHighestPrecedenceHostname(hostnameOne)
-		highestPrecedenceHostnameTwo := getHighestPrecedenceHostname(hostnameTwo)
-
-		precedence := routeutils.GetHostnamePrecedenceOrder(highestPrecedenceHostnameOne, highestPrecedenceHostnameTwo)
-		if precedence != 0 {
-			return precedence < 0 // -1 means higher precedence
-		}
-		return false
-	})
-}

pkg/gateway/model/utilities_test.go

@@ -2,7 +2,6 @@ package model
 
 import (
 	"github.com/stretchr/testify/assert"
-	"sigs.k8s.io/aws-load-balancer-controller/pkg/gateway/routeutils"
 	elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"
 	"testing"
 )
@@ -48,116 +47,3 @@ func Test_IsIPv6Supported(t *testing.T) {
 		})
 	}
 }
-
-// Test SortRoutesByHostnamePrecedence
-func Test_SortRoutesByHostnamePrecedence(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    []routeutils.RouteDescriptor
-		expected []routeutils.RouteDescriptor
-	}{
-		{
-			name:     "empty routes",
-			input:    []routeutils.RouteDescriptor{},
-			expected: []routeutils.RouteDescriptor{},
-		},
-		{
-			name: "routes with no hostnames",
-			input: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-			},
-			expected: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-			},
-		},
-		{
-			name: "mix of empty and non-empty hostnames",
-			input: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{}},
-				&routeutils.MockRoute{Hostnames: []string{"example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"test.com"}},
-			},
-			expected: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"test.com"}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-			},
-		},
-		{
-			name: "with and without wildcard hostnames",
-			input: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"*.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"test.example.com"}},
-			},
-			expected: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"test.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"*.example.com"}},
-			},
-		},
-		{
-			name: "complex mixed hostnames",
-			input: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"*.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-				&routeutils.MockRoute{Hostnames: []string{"test.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"another.example.com"}},
-			},
-			expected: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"another.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"test.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"*.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-			},
-		},
-		{
-			name: "complex mixed hostnames with multiple hostnames in each port",
-			input: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"*.example.com", "test.details.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-				&routeutils.MockRoute{Hostnames: []string{"test.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"another.example.com"}},
-			},
-			expected: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"*.example.com", "test.details.example.com"}}, // since test.details.example.com has the highest precedence order here
-				&routeutils.MockRoute{Hostnames: []string{"another.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"test.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-			},
-		},
-		{
-			name: "shorter hostname with more dots should have higher precedence ",
-			input: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"another.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"a.b.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-				&routeutils.MockRoute{Hostnames: []string{"*.example.com"}},
-			},
-			expected: []routeutils.RouteDescriptor{
-				&routeutils.MockRoute{Hostnames: []string{"a.b.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"another.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{"*.example.com"}},
-				&routeutils.MockRoute{Hostnames: []string{}},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Create a copy of input to avoid modifying the test case data
-			actual := make([]routeutils.RouteDescriptor, len(tt.input))
-			copy(actual, tt.input)
-
-			// Execute the sort
-			sortRoutesByHostnamePrecedence(actual)
-
-			// Verify the result
-			assert.Equal(t, tt.expected, actual, "sorted routes should match expected order")
-
-			// Verify stability of sort
-			sortRoutesByHostnamePrecedence(actual)
-			assert.Equal(t, tt.expected, actual, "second sort should maintain the same order (stable sort)")
-		})
-	}
-}

pkg/gateway/routeutils/descriptor.go

@@ -5,6 +5,7 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gwv1 "sigs.k8s.io/gateway-api/apis/v1"
+	"time"
 )
 
 // routeMetadataDescriptor a common set of functions that will describe a route.
@@ -18,6 +19,7 @@ type routeMetadataDescriptor interface {
 	GetRawRoute() interface{}
 	GetBackendRefs() []gwv1.BackendRef
 	GetRouteGeneration() int64
+	GetRouteCreateTimestamp() time.Time
 }
 
 // preLoadRouteDescriptor this object is used to represent a route description that has not loaded its child data (services, tg config)

pkg/gateway/routeutils/grpc.go

@@ -6,6 +6,7 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gwv1 "sigs.k8s.io/gateway-api/apis/v1"
+	"time"
 )
 
 /*
@@ -115,6 +116,10 @@ func (grpcRoute *grpcRouteDescription) GetRouteGeneration() int64 {
 	return grpcRoute.route.Generation
 }
 
+func (grpcRoute *grpcRouteDescription) GetRouteCreateTimestamp() time.Time {
+	return grpcRoute.route.CreationTimestamp.Time
+}
+
 var _ RouteDescriptor = &grpcRouteDescription{}
 
 // Can we use an indexer here to query more efficiently?

pkg/gateway/routeutils/http.go

@@ -6,6 +6,7 @@ import (
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gwv1 "sigs.k8s.io/gateway-api/apis/v1"
+	"time"
 )
 
 /*
@@ -107,6 +108,10 @@ func (httpRoute *httpRouteDescription) GetBackendRefs() []gwv1.BackendRef {
 	return backendRefs
 }
 
+func (httpRoute *httpRouteDescription) GetRouteCreateTimestamp() time.Time {
+	return httpRoute.route.CreationTimestamp.Time
+}
+
 func convertHTTPRoute(r gwv1.HTTPRoute) *httpRouteDescription {
 	return &httpRouteDescription{route: &r, backendLoader: commonBackendLoader}
 }

pkg/gateway/routeutils/loader_test.go

@@ -9,6 +9,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gwv1 "sigs.k8s.io/gateway-api/apis/v1"
 	"testing"
+	"time"
 )
 
 type mockMapper struct {
@@ -71,6 +72,10 @@ func (m *mockRoute) GetAttachedRules() []RouteRule {
 	panic("implement me")
 }
 
+func (m *mockRoute) GetRouteCreateTimestamp() time.Time {
+	panic("implement me")
+}
+
 func TestLoadRoutesForGateway(t *testing.T) {
 	preLoadHTTPRoutes := []preLoadRouteDescriptor{
 		&mockRoute{