documentation, tests

Author: zac-nixon

docs/guide/gateway/gateway.md

@@ -130,4 +130,34 @@ the target group will not be materialized on any ALBs that the route attaches to
 An [503 Fixed Response](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_FixedResponseActionConfig.html)
 will be added to any Listener Rules that would have referenced the invalid backend.
 
+## Specify out-of-band Target Groups
+
+Use an existing AWS Target Group with a Gateway-managed Load Balancer.
+This lets you integrate or migrate legacy applications that are already
+registered with an AWS Target Group outside the controller's lifecycle.
+
+```yaml
+apiVersion: gateway.networking.k8s.io/v1alpha2
+kind: TCPRoute
+metadata:
+  name: tcproute
+  namespace: example-ns
+spec:
+  parentRefs:
+  - group: gateway.networking.k8s.io
+    kind: Gateway
+    name: nlb-gw
+    sectionName: tls
+  rules:
+  - backendRefs:
+    - group: ""
+      kind: TargetGroupName
+      name: test-gw-import123
+      weight: 1
+```
+
+This support exists for all route types managed by the controller.
+
+
+
 

pkg/gateway/model/model_build_target_group_test.go

@@ -1,7 +1,9 @@
 package model
 
 import (
+	"context"
 	awssdk "github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -15,6 +17,7 @@ import (
 	elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"
 	elbv2modelk8s "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2/k8s"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/shared_constants"
+	"sigs.k8s.io/aws-load-balancer-controller/pkg/shared_utils"
 	gwv1 "sigs.k8s.io/gateway-api/apis/v1"
 	"testing"
 )
@@ -2071,6 +2074,30 @@ func Test_buildTargetGroupBindingMultiClusterFlag(t *testing.T) {
 	assert.True(t, builder.buildTargetGroupBindingMultiClusterFlag(props))
 }
 
+func Test_buildTargetGroupFromStaticName(t *testing.T) {
+
+	mockMapper := &shared_utils.MockTargetGroupARNMapper{
+		ARN:   "my-arn",
+		Error: nil,
+	}
+	impl := targetGroupBuilderImpl{
+		targetGroupNameToArnMapper: mockMapper,
+	}
+
+	cfg := routeutils.LiteralTargetGroupConfig{Name: "foo"}
+
+	result, err := impl.buildTargetGroupFromStaticName(cfg)
+	assert.Nil(t, err)
+
+	resultArn, _ := result.Resolve(context.Background())
+	assert.Equal(t, "my-arn", resultArn)
+
+	mockMapper.Error = errors.New("bad")
+
+	_, err = impl.buildTargetGroupFromStaticName(cfg)
+	assert.Error(t, err)
+}
+
 func protocolPtr(protocol elbv2gw.Protocol) *elbv2gw.Protocol {
 	return &protocol
 }

pkg/gateway/referencecounter/service_reference_counter.go

@@ -67,19 +67,17 @@ func (t *serviceReferenceCounter) updateRefCount(svcs sets.Set[types.NamespacedN
 func (t *serviceReferenceCounter) IsEligibleForRemoval(svcName types.NamespacedName, expectedGateways []types.NamespacedName) bool {
 	t.mutex.RLock()
 	defer t.mutex.RUnlock()
-	v, ok := t.refCount[svcName]
+	_, ok := t.refCount[svcName]
 	// If we have a ref count for this service, we can't remove it.
 	// updateRefCount should always remove 0 entry services.
 	if ok {
-		t.logger.Info("Got a ref count!", "ref", v)
 		return false
 	}
 
 	// Next we check if the Gateway cache is correctly populated. This prevents premature removal of items
 	// when the cache is not warm.
 	for _, gw := range expectedGateways {
 		if _, exists := t.relations[gw]; !exists {
-			t.logger.Info("Missing relation", "gateway", gw)
 			return false
 		}
 	}

pkg/gateway/routeutils/backend_test.go

@@ -403,6 +403,61 @@ func TestCommonBackendLoader_Service(t *testing.T) {
 	}
 }
 
+func TestCommonBackendLoader_TargetGroupName(t *testing.T) {
+	testCases := []struct {
+		name            string
+		expectWarning   bool
+		expectFatal     bool
+		backendRef      gwv1.BackendRef
+		routeIdentifier types.NamespacedName
+		expected        *LiteralTargetGroupConfig
+	}{
+		{
+			name:          "invalid backend kind",
+			expectWarning: true,
+			backendRef: gwv1.BackendRef{
+				BackendObjectReference: gwv1.BackendObjectReference{
+					Kind: (*gwv1.Kind)(awssdk.String("invalid")),
+				},
+			},
+		},
+		{
+			name: "valid name",
+			backendRef: gwv1.BackendRef{
+				BackendObjectReference: gwv1.BackendObjectReference{
+					Kind: (*gwv1.Kind)(awssdk.String(TargetGroupNameBackend)),
+					Name: "foo",
+				},
+			},
+			expected: &LiteralTargetGroupConfig{
+				Name: "foo",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			k8sClient := testutils.GenerateTestClient()
+
+			result, warningErr, fatalErr := commonBackendLoader(context.Background(), k8sClient, tc.backendRef, tc.routeIdentifier, HTTPRouteKind)
+
+			if tc.expectWarning {
+				assert.Error(t, warningErr)
+				assert.NoError(t, fatalErr)
+			} else if tc.expectFatal {
+				assert.Error(t, fatalErr)
+				assert.NoError(t, warningErr)
+			} else {
+				assert.NoError(t, warningErr)
+				assert.NoError(t, fatalErr)
+
+				assert.Nil(t, result.ServiceBackend)
+				assert.Equal(t, tc.expected, result.LiteralTargetGroup)
+			}
+		})
+	}
+}
+
 func Test_lookUpTargetGroupConfiguration(t *testing.T) {
 	testCases := []struct {
 		name                         string

pkg/gateway/routeutils/generic_route_rule.go

@@ -0,0 +1,21 @@
+package shared_utils
+
+import (
+	"context"
+	"k8s.io/apimachinery/pkg/util/cache"
+)
+
+type MockTargetGroupARNMapper struct {
+	ARN   string
+	Error error
+}
+
+func (m *MockTargetGroupARNMapper) GetArnByName(_ context.Context, _ string) (string, error) {
+	return m.ARN, m.Error
+}
+
+func (m *MockTargetGroupARNMapper) GetCache() *cache.Expiring {
+	return nil
+}
+
+var _ TargetGroupARNMapper = &MockTargetGroupARNMapper{}

pkg/gateway/routeutils/tcp_udp_route.go

@@ -0,0 +1,139 @@
+package shared_utils
+
+import (
+	"context"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
+	elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types"
+	"github.com/golang/mock/gomock"
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services"
+	"testing"
+	"time"
+)
+
+func Test_TargetGroupARNMapper(t *testing.T) {
+	type describeTargetGroupCall struct {
+		req  *elbv2sdk.DescribeTargetGroupsInput
+		resp []elbv2types.TargetGroup
+		err  error
+	}
+
+	type cachedItem struct {
+		name string
+		arn  string
+	}
+
+	testCases := []struct {
+		name        string
+		tgName      string
+		calls       []describeTargetGroupCall
+		cachedItems []cachedItem
+		expected    string
+		expectErr   bool
+	}{
+		{
+			name:   "cold cache",
+			tgName: "foo",
+			calls: []describeTargetGroupCall{
+				{
+					req: &elbv2sdk.DescribeTargetGroupsInput{
+						Names: []string{"foo"},
+					},
+					resp: []elbv2types.TargetGroup{
+						{
+							TargetGroupArn: aws.String("my-arn"),
+						},
+					},
+				},
+			},
+			expected: "my-arn",
+		},
+		{
+			name:   "warm cache",
+			tgName: "foo",
+			calls:  []describeTargetGroupCall{},
+			cachedItems: []cachedItem{
+				{
+					name: "foo",
+					arn:  "my-arn",
+				},
+			},
+			expected: "my-arn",
+		},
+		{
+			name:   "warm cache but wrong name",
+			tgName: "foo",
+			calls: []describeTargetGroupCall{
+				{
+					req: &elbv2sdk.DescribeTargetGroupsInput{
+						Names: []string{"foo"},
+					},
+					resp: []elbv2types.TargetGroup{
+						{
+							TargetGroupArn: aws.String("my-arn"),
+						},
+					},
+				},
+			},
+			cachedItems: []cachedItem{
+				{
+					name: "baz",
+					arn:  "other-warn",
+				},
+			},
+			expected: "my-arn",
+		},
+		{
+			name:   "error",
+			tgName: "foo",
+			calls: []describeTargetGroupCall{
+				{
+					req: &elbv2sdk.DescribeTargetGroupsInput{
+						Names: []string{"foo"},
+					},
+					resp: []elbv2types.TargetGroup{
+						{
+							TargetGroupArn: aws.String("my-arn"),
+						},
+					},
+					err: errors.New("error"),
+				},
+			},
+			cachedItems: []cachedItem{
+				{
+					name: "baz",
+					arn:  "other-warn",
+				},
+			},
+			expectErr: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+			elbv2Client := services.NewMockELBV2(ctrl)
+			mapper := NewTargetGroupNameToArnMapper(elbv2Client)
+
+			for _, call := range tc.calls {
+				elbv2Client.EXPECT().DescribeTargetGroupsAsList(gomock.Any(), call.req).Return(call.resp, call.err)
+			}
+
+			for _, ci := range tc.cachedItems {
+				mapper.GetCache().Set(ci.name, ci.arn, time.Minute)
+			}
+
+			result, err := mapper.GetArnByName(context.Background(), tc.tgName)
+
+			if tc.expectErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tc.expected, result)
+			}
+		})
+	}
+}