Add capability to allow lattice target group name include current vpc and httproute (#230)

* Refactor cache for TG to key on TG-name and routename

* Fix unit test due to using routename as part of key

* Add mode to create tg name includes routename and vpcid

* Make sure the cluster local gateway is associated to VPC

* Populate routename to targets build structure

* Add minor comment

* Add route into structure

* Cleanup logging msgs

* Address CR comments

* Address CR comments

Author: liwenwu-amazon

controllers/eventhandlers/gateway.go

@@ -33,8 +33,8 @@ func NewEnqueueRequestGatewayEvent(client client.Client) handler.EventHandler {
 var ZeroTransitionTime = metav1.NewTime(time.Time{})
 
 func (h *enqueueRequestsForGatewayEvent) Create(e event.CreateEvent, queue workqueue.RateLimitingInterface) {
-	glog.V(6).Info("Gateway Create")
 	gwNew := e.Object.(*gateway_api.Gateway)
+	glog.V(2).Infof("Gateway Create and Spec is %v", gwNew.Spec)
 
 	// initialize transition time
 	gwNew.Status.Conditions[0].LastTransitionTime = ZeroTransitionTime
@@ -48,6 +48,8 @@ func (h *enqueueRequestsForGatewayEvent) Update(e event.UpdateEvent, queue workq
 	gwNew := e.ObjectNew.(*gateway_api.Gateway)
 
 	if !equality.Semantic.DeepEqual(gwOld.Spec, gwNew.Spec) {
+		glog.V(2).Infof("Gateway Update old spec %v to new spec %v",
+			gwOld.Spec, gwNew.Spec)
 		// initialize transition time
 		gwNew.Status.Conditions[0].LastTransitionTime = ZeroTransitionTime
 		h.enqueueImpactedHTTPRoute(queue, gwNew)
@@ -101,7 +103,7 @@ func (h *enqueueRequestsForGatewayEvent) enqueueImpactedHTTPRoute(queue workqueu
 		}
 
 		if gwClass.Spec.ControllerName == config.LatticeGatewayControllerName {
-			glog.V(6).Infof("Trigger HTTPRoute from Gateway event , httpRoute %s", httpRoute.Name)
+			glog.V(2).Infof("Trigger HTTPRoute from Gateway event , httpRoute %s", httpRoute.Name)
 			queue.Add(reconcile.Request{
 				NamespacedName: types.NamespacedName{
 					Namespace: httpRoute.Namespace,

controllers/gateway_controller.go

@@ -238,7 +238,7 @@ func (r *GatewayReconciler) reconcileGatewayResources(ctx context.Context, gw *g
 	glog.V(6).Infof("serviceNetworkStatus : %v for %s  error %v \n", serviceNetworkStatus, gw.Name, err)
 
 	if err = r.updateGatewayStatus(ctx, &serviceNetworkStatus, gw); err != nil {
-		glog.V(2).Infof("Failed to updateGatewayStatus %v err %v\n", gw, err)
+		glog.V(2).Infof("Failed to updateGatewayStatus err %v, gw %v\n", err, gw)
 		return errors.New("failed to update gateway status")
 	}
 	return nil
@@ -273,6 +273,7 @@ func (r *GatewayReconciler) updateGatewayStatus(ctx context.Context, serviceNetw
 	//gw.Annotations["gateway.networking.k8s.io/aws-gateway-id"] = serviceNetworkStatus.ID
 
 	if err := r.Client.Status().Patch(ctx, gw, client.MergeFrom(gwOld)); err != nil {
+		glog.V(2).Infof("Failed to update gateway status %v for gateway %v", err, gw)
 		return errors.Wrapf(err, "failed to update gateway status")
 	}
 
@@ -299,6 +300,7 @@ func (r *GatewayReconciler) updateGatewayAcceptStatus(ctx context.Context, gw *g
 	gw.Status.Conditions[0].Type = string(gateway_api.GatewayConditionAccepted)
 
 	if err := r.Client.Status().Patch(ctx, gw, client.MergeFrom(gwOld)); err != nil {
+		glog.V(2).Infof("Failed to Patch acceptance status, err %v gw %v", err, gw)
 		return errors.Wrapf(err, "failed to update gateway status")
 	}
 
@@ -480,7 +482,7 @@ func UpdateGWListenerStatus(ctx context.Context, k8sclient client.Client, gw *ga
 	glog.V(6).Infof("After update, the snapshot of listener status %v", gw.Status.Listeners)
 
 	if err := k8sclient.Status().Patch(ctx, gw, client.MergeFrom(gwOld)); err != nil {
-		glog.V(2).Infof("liwwu1-failed to update gateway listener status %v, status %v", err, gw.Status.Listeners)
+		glog.V(2).Infof("Failed to update gateway listener err: %v, status: %v", err, gw.Status.Listeners)
 		return errors.Wrapf(err, "failed to update gateway status")
 	}
 

controllers/service_controller.go

@@ -116,32 +116,32 @@ func (r *ServiceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 
 	// TODO also need to check serviceexport object to trigger building TargetGroup
 	tgName := latticestore.TargetGroupName(svc.Name, svc.Namespace)
-	tg, err := ds.GetTargetGroup(tgName, false) // isServiceImport = false
+	TGs := ds.GetTargetGroupsByTG(tgName) // isServiceImport = false
 
-	if err == nil && (tg.ByBackendRef || tg.ByServiceExport) {
-		glog.V(6).Infof("ServiceReconcile: endpoints change trigger target IP list registration %v\n", tgName)
+	for _, tg := range TGs {
 
-		r.reconcileTargetsResource(ctx, svc)
+		glog.V(6).Infof("endpoints change trigger target IP list registration %v and tg %v\n",
+			tgName, tg)
+
+		r.reconcileTargetsResource(ctx, svc, tg.TargetGroupKey.RouteName)
 
-	} else {
-		glog.V(6).Infof("Ignore non-relevant svc %v]\n", svc)
 	}
 
 	return ctrl.Result{}, nil
 }
 
-func (r *ServiceReconciler) reconcileTargetsResource(ctx context.Context, svc *corev1.Service) {
+func (r *ServiceReconciler) reconcileTargetsResource(ctx context.Context, svc *corev1.Service, routename string) {
 
 	if err := r.finalizerManager.AddFinalizers(ctx, svc, serviceFinalizer); err != nil {
 		r.eventRecorder.Event(svc, corev1.EventTypeWarning, k8s.ServiceEventReasonFailedAddFinalizer, fmt.Sprintf("Failed and finalizer due %v", err))
 	}
 
-	r.buildAndDeployModel(ctx, svc)
+	r.buildAndDeployModel(ctx, svc, routename)
 }
 
-func (r *ServiceReconciler) buildAndDeployModel(ctx context.Context, svc *corev1.Service) (core.Stack, *latticemodel.Targets, error) {
+func (r *ServiceReconciler) buildAndDeployModel(ctx context.Context, svc *corev1.Service, routename string) (core.Stack, *latticemodel.Targets, error) {
 	svcLog := log.FromContext(ctx)
-	stack, latticeTargets, err := r.modelBuilder.Build(ctx, svc)
+	stack, latticeTargets, err := r.modelBuilder.Build(ctx, svc, routename)
 
 	if err != nil {
 		r.eventRecorder.Event(svc, corev1.EventTypeWarning,

pkg/config/controller_config.go

@@ -22,6 +22,7 @@ var AccountID = "yyyyyy"
 var Region = "us-west-2"
 var logLevel = defaultLogLevel
 var DefaultServiceNetwork = NoDefaultServiceNetwork
+var UseLongTGName = false
 
 func GetLogLevel() string {
 	logLevel = os.Getenv("GATEWAY_API_CONTROLLER_LOGLEVEL")
@@ -70,6 +71,16 @@ func ConfigInit() {
 		glog.V(2).Infoln("CLUSTER_LOCAL_GATEWAY", DefaultServiceNetwork)
 	}
 
+	tgNameLengthMode := os.Getenv("TARGET_GROUP_NAME_LEN_MODE")
+
+	glog.V(2).Infoln("TARGET_GROUP_NAME_LEN_MODE", tgNameLengthMode)
+
+	if tgNameLengthMode == "long" {
+		UseLongTGName = true
+	} else {
+		UseLongTGName = false
+	}
+
 	sess, _ := session.NewSession()
 	metadata := NewEC2Metadata(sess)
 

pkg/deploy/lattice/rule_manager.go

@@ -183,7 +183,7 @@ func (r *defaultRuleManager) Create(ctx context.Context, rule *latticemodel.Rule
 	for _, tgRule := range rule.Spec.Action.TargetGroups {
 
 		tgName := latticestore.TargetGroupName(tgRule.Name, tgRule.Namespace)
-		tg, err := r.latticeDataStore.GetTargetGroup(tgName, tgRule.IsServiceImport)
+		tg, err := r.latticeDataStore.GetTargetGroup(tgName, tgRule.RouteName, tgRule.IsServiceImport)
 
 		if err != nil {
 			glog.V(2).Infof("Faild to create rule due to unknown tg %v, err %v\n", tgName, err)
@@ -487,7 +487,7 @@ func (r *defaultRuleManager) findMatchingRule(ctx context.Context, rule *lattice
 			for _, k8sTG := range rule.Spec.Action.TargetGroups {
 				// get k8sTG id
 				tgName := latticestore.TargetGroupName(k8sTG.Name, k8sTG.Namespace)
-				k8sTGinStore, err := r.latticeDataStore.GetTargetGroup(tgName, k8sTG.IsServiceImport)
+				k8sTGinStore, err := r.latticeDataStore.GetTargetGroup(tgName, rule.Spec.ServiceName, k8sTG.IsServiceImport)
 
 				if err != nil {
 					glog.V(6).Infof("Failed to find k8s tg %v in store \n", k8sTG)

pkg/deploy/lattice/rule_manager_test.go

@@ -548,7 +548,7 @@ func Test_CreateRule(t *testing.T) {
 		if !tt.noTargetGroupID {
 			for _, tg := range tt.newRule.Spec.Action.TargetGroups {
 				tgName := latticestore.TargetGroupName(tg.Name, tg.Namespace)
-				latticeDataStore.AddTargetGroup(tgName, "vpc", "arn", "tg-id", tg.IsServiceImport)
+				latticeDataStore.AddTargetGroup(tgName, "vpc", "arn", "tg-id", tg.IsServiceImport, "")
 			}
 
 		}

pkg/deploy/lattice/service_network_synthesizer_test.go

@@ -151,7 +151,6 @@ func Test_SynthesizeTriggeredGateways(t *testing.T) {
 				func(ctx context.Context, retGWList *gateway_api.GatewayList, arg3 ...interface{}) error {
 					// return empty gatway
 					for _, gw := range gwList.Items {
-						fmt.Printf("liwwu>>> test append %v\n", gw)
 						retGWList.Items = append(retGWList.Items, gw)
 					}
 					return nil

pkg/deploy/lattice/target_group_manager.go

@@ -10,6 +10,7 @@ import (
 
 	lattice_aws "github.com/aws/aws-application-networking-k8s/pkg/aws"
 	"github.com/aws/aws-application-networking-k8s/pkg/config"
+	"github.com/aws/aws-application-networking-k8s/pkg/latticestore"
 	latticemodel "github.com/aws/aws-application-networking-k8s/pkg/model/lattice"
 )
 
@@ -30,6 +31,18 @@ func NewTargetGroupManager(cloud lattice_aws.Cloud) *defaultTargetGroupManager {
 	}
 }
 
+func getLatticeTGName(targetGroup *latticemodel.TargetGroup) string {
+	var tgName string
+	if config.UseLongTGName {
+		tgName = latticestore.TargetGroupLongName(targetGroup.Spec.Name,
+			targetGroup.Spec.Config.K8SHTTPRouteName, config.VpcID)
+	} else {
+		tgName = targetGroup.Spec.Name
+	}
+
+	return tgName
+}
+
 // Create will try to create a target group
 // return error when:
 //
@@ -50,28 +63,31 @@ func NewTargetGroupManager(cloud lattice_aws.Cloud) *defaultTargetGroupManager {
 func (s *defaultTargetGroupManager) Create(ctx context.Context, targetGroup *latticemodel.TargetGroup) (latticemodel.TargetGroupStatus, error) {
 
 	glog.V(6).Infof("Create Target Group API call for name %s \n", targetGroup.Spec.Name)
+
+	latticeTGName := getLatticeTGName(targetGroup)
 	// check if exists
-	tgSummary, err := s.findTGByName(ctx, targetGroup.Spec.Name)
+	tgSummary, err := s.findTGByName(ctx, latticeTGName)
 	if err != nil {
 		return latticemodel.TargetGroupStatus{TargetGroupARN: "", TargetGroupID: ""}, err
 	}
 	if tgSummary != nil {
 		return latticemodel.TargetGroupStatus{TargetGroupARN: aws.StringValue(tgSummary.Arn), TargetGroupID: aws.StringValue(tgSummary.Id)}, err
 	}
 
-	glog.V(6).Infof("create targetgropu API here %v\n", targetGroup)
+	glog.V(6).Infof("create targetgroup API here %v\n", targetGroup)
 	port := int64(targetGroup.Spec.Config.Port)
-	config := &vpclattice.TargetGroupConfig{
+	tgConfig := &vpclattice.TargetGroupConfig{
 		Port:            &port,
 		Protocol:        &targetGroup.Spec.Config.Protocol,
 		ProtocolVersion: &targetGroup.Spec.Config.ProtocolVersion,
 		VpcIdentifier:   &targetGroup.Spec.Config.VpcID,
 	}
 
 	targetGroupType := string(targetGroup.Spec.Type)
+
 	createTargetGroupInput := vpclattice.CreateTargetGroupInput{
-		Config: config,
-		Name:   &targetGroup.Spec.Name,
+		Config: tgConfig,
+		Name:   &latticeTGName,
 		Type:   &targetGroupType,
 		Tags:   make(map[string]*string),
 	}
@@ -116,8 +132,9 @@ func (s *defaultTargetGroupManager) Create(ctx context.Context, targetGroup *lat
 
 func (s *defaultTargetGroupManager) Get(ctx context.Context, targetGroup *latticemodel.TargetGroup) (latticemodel.TargetGroupStatus, error) {
 	glog.V(6).Infof("Create Lattice Target Group API call for name %s \n", targetGroup.Spec.Name)
+
 	// check if exists
-	tgSummary, err := s.findTGByName(ctx, targetGroup.Spec.Name)
+	tgSummary, err := s.findTGByName(ctx, getLatticeTGName(targetGroup))
 	if err != nil {
 		return latticemodel.TargetGroupStatus{TargetGroupARN: "", TargetGroupID: ""}, err
 	}

pkg/deploy/lattice/target_group_synthesizer.go

@@ -107,8 +107,11 @@ func (t *targetGroupSynthesizer) SynthesizeTriggeredTargetGroup(ctx context.Cont
 				continue
 			}
 
+			// for serviceimport, the httproutename is ""
+
 			t.latticeDataStore.AddTargetGroup(resTargetGroup.Spec.Name,
-				resTargetGroup.Spec.Config.VpcID, tgStatus.TargetGroupARN, tgStatus.TargetGroupID, resTargetGroup.Spec.Config.IsServiceImport)
+				resTargetGroup.Spec.Config.VpcID, tgStatus.TargetGroupARN, tgStatus.TargetGroupID,
+				resTargetGroup.Spec.Config.IsServiceImport, "")
 
 			glog.V(6).Infof("targetGroup Synthesized successfully for %s: %v\n", resTargetGroup.Spec.Name, tgStatus)
 
@@ -121,7 +124,7 @@ func (t *targetGroupSynthesizer) SynthesizeTriggeredTargetGroup(ctx context.Cont
 					continue
 				} else {
 					glog.V(6).Infof("Synthersizing Target Group: successfully deleted target group %v\n", resTargetGroup)
-					t.latticeDataStore.DelTargetGroup(resTargetGroup.Spec.Name, false)
+					t.latticeDataStore.DelTargetGroup(resTargetGroup.Spec.Name, resTargetGroup.Spec.Config.K8SHTTPRouteName, false)
 				}
 
 			} else {
@@ -136,7 +139,9 @@ func (t *targetGroupSynthesizer) SynthesizeTriggeredTargetGroup(ctx context.Cont
 				}
 
 				t.latticeDataStore.AddTargetGroup(resTargetGroup.Spec.Name,
-					resTargetGroup.Spec.Config.VpcID, tgStatus.TargetGroupARN, tgStatus.TargetGroupID, resTargetGroup.Spec.Config.IsServiceImport)
+					resTargetGroup.Spec.Config.VpcID, tgStatus.TargetGroupARN,
+					tgStatus.TargetGroupID, resTargetGroup.Spec.Config.IsServiceImport,
+					resTargetGroup.Spec.Config.K8SHTTPRouteName)
 
 				glog.V(6).Infof("targetGroup Synthesized successfully for %v: %v\n", resTargetGroup.Spec, tgStatus)
 			}
@@ -167,6 +172,7 @@ func (t *targetGroupSynthesizer) SynthesizeSDKTargetGroups(ctx context.Context)
 	glog.V(6).Infof("SynthesizeSDKTargetGroups: here is sdkTGs %v len %v \n", sdkTGs, len(sdkTGs))
 
 	for _, sdkTG := range sdkTGs {
+		tgRouteName := ""
 
 		if *sdkTG.getTargetGroupOutput.Config.VpcIdentifier != config.VpcID {
 			glog.V(6).Infof("Ignore target group ARN %v Name %v for other VPCs",
@@ -235,6 +241,7 @@ func (t *targetGroupSynthesizer) SynthesizeSDKTargetGroups(ctx context.Context)
 				*sdkTG.getTargetGroupOutput.Arn, *sdkTG.getTargetGroupOutput.Name)
 
 			httpName, ok := tgTags.Tags[latticemodel.K8SHTTPRouteNameKey]
+			tgRouteName = *httpName
 
 			if !ok || httpName == nil {
 				glog.V(6).Infof("Ignore TargetGroup(triggered by httpRoute) %v, %v have no httproute name tag",
@@ -279,17 +286,21 @@ func (t *targetGroupSynthesizer) SynthesizeSDKTargetGroups(ctx context.Context)
 
 		}
 
-		if tg, err := t.latticeDataStore.GetTargetGroup(*sdkTG.getTargetGroupOutput.Name, true); err == nil {
+		// the routename for serviceimport is ""
+		if tg, err := t.latticeDataStore.GetTargetGroup(*sdkTG.getTargetGroupOutput.Name, "", true); err == nil {
 			glog.V(6).Infof("Ignore target group created by service import %v\n", tg)
 			continue
 		}
 
-		glog.V(2).Infof("Append stale SDK TG to stale list Name %v, ARN %v",
-			*sdkTG.getTargetGroupOutput.Name, *sdkTG.getTargetGroupOutput.Id)
+		glog.V(2).Infof("Append stale SDK TG to stale list Name %v, routename %v, ARN %v",
+			*sdkTG.getTargetGroupOutput.Name, tgRouteName, *sdkTG.getTargetGroupOutput.Id)
 
 		staleSDKTGs = append(staleSDKTGs, latticemodel.TargetGroup{
 			Spec: latticemodel.TargetGroupSpec{
-				Name:      *sdkTG.getTargetGroupOutput.Name,
+				Name: *sdkTG.getTargetGroupOutput.Name,
+				Config: latticemodel.TargetGroupConfig{
+					K8SHTTPRouteName: tgRouteName,
+				},
 				LatticeID: *sdkTG.getTargetGroupOutput.Id,
 			},
 		})

pkg/deploy/lattice/target_group_synthesizer_test.go

@@ -152,7 +152,7 @@ func Test_SynthesizeTriggeredServiceExport(t *testing.T) {
 
 			assert.Nil(t, err)
 			tgName := latticestore.TargetGroupName(tt.svcExport.Name, tt.svcExport.Namespace)
-			dsTG, err := ds.GetTargetGroup(tgName, false)
+			dsTG, err := ds.GetTargetGroup(tgName, "", false)
 
 			if tg.Spec.IsDeleted {
 				assert.NotNil(t, err)
@@ -290,11 +290,11 @@ func Test_SynthersizeTriggeredByServiceImport(t *testing.T) {
 			// check datastore
 			for _, tgImport := range tt.svcImportList {
 				if tgImport.mgrErr {
-					_, err := ds.GetTargetGroup(tgImport.name, true)
+					_, err := ds.GetTargetGroup(tgImport.name, "", true)
 					assert.NotNil(t, err)
 
 				} else {
-					tg, err := ds.GetTargetGroup(tgImport.name, true)
+					tg, err := ds.GetTargetGroup(tgImport.name, "", true)
 					assert.Nil(t, err)
 					assert.Equal(t, tgImport.tgARN, tg.ARN)
 					assert.Equal(t, tgImport.tgID, tg.ID)
@@ -513,6 +513,9 @@ func Test_SynthesizeSDKTargetGroups(t *testing.T) {
 						LatticeID: sdkTG.id,
 					},
 				}
+				if sdkTG.hasHTTPRouteTypeTag {
+					tgSpec.Spec.Config.K8SHTTPRouteName = routename
+				}
 
 				if sdkTG.HTTPRouteExist {
 
@@ -731,11 +734,13 @@ func Test_SynthesizeTriggeredService(t *testing.T) {
 			// check datastore
 			for _, tg := range tt.svcList {
 				if tg.mgrErr {
-					_, err := ds.GetTargetGroup(tg.name, false)
+					//TODO, test routename
+					_, err := ds.GetTargetGroup(tg.name, "", false)
 					assert.NotNil(t, err)
 
 				} else {
-					dsTG, err := ds.GetTargetGroup(tg.name, false)
+					//TODO, test routename
+					dsTG, err := ds.GetTargetGroup(tg.name, "", false)
 					assert.Nil(t, err)
 					assert.Equal(t, tg.tgARN, dsTG.ARN)
 					assert.Equal(t, tg.tgID, dsTG.ID)