Enable GRPCRoute Traffic + Remaining GRPCRoute Event Handling

cmd/aws-application-networking-k8s/main.go

@@ -162,20 +162,14 @@ func main() {
 		setupLog.Fatalf("route controller setup failed: %s", err)
 	}
 
-	serviceImportReconciler := controllers.NewServceImportReconciler(mgr.GetClient(), mgr.GetScheme(),
-		mgr.GetEventRecorderFor("ServiceImport"), finalizerManager, latticeDataStore)
-
-	if err = serviceImportReconciler.SetupWithManager(mgr); err != nil {
-		setupLog.Error(err, "unable to create controller", "controller", "ServiceImport")
-		os.Exit(1)
+	err = controllers.RegisterServiceImportController(ctrlLog.Named("service-import"), mgr, latticeDataStore, finalizerManager)
+	if err != nil {
+		setupLog.Fatalf("serviceimport controller setup failed: %s", err)
 	}
 
-	serviceExportReconciler := controllers.NewServiceExportReconciler(cloud, mgr.GetClient(),
-		mgr.GetScheme(), mgr.GetEventRecorderFor("serviceExport"), finalizerManager, latticeDataStore)
-
-	if err = serviceExportReconciler.SetupWithManager(ctrlLog.Named("service-export"), mgr); err != nil {
-		setupLog.Error(err, "unable to create controller", "controller", "serviceExport")
-		os.Exit(1)
+	err = controllers.RegisterServiceExportController(ctrlLog.Named("service-export"), cloud, latticeDataStore, finalizerManager, mgr)
+	if err != nil {
+		setupLog.Fatalf("serviceexport controller setup failed: %s", err)
 	}
 
 	go latticestore.GetDefaultLatticeDataStore().ServeIntrospection()

controllers/eventhandlers/endpoints.go

@@ -2,8 +2,7 @@ package eventhandlers
 
 import (
 	"context"
-
-	"github.com/golang/glog"
+	"github.com/aws/aws-application-networking-k8s/pkg/utils/gwlog"
 
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/equality"
@@ -17,24 +16,26 @@ import (
 )
 
 type enqueueRequestsForEndpointsEvent struct {
+	log    gwlog.Logger
 	client client.Client
 }
 
-func NewEnqueueRequestEndpointEvent(client client.Client) handler.EventHandler {
+func NewEnqueueRequestEndpointEvent(log gwlog.Logger, client client.Client) handler.EventHandler {
 	return &enqueueRequestsForEndpointsEvent{
+		log:    log,
 		client: client,
 	}
 }
 
 func (h *enqueueRequestsForEndpointsEvent) Create(e event.CreateEvent, queue workqueue.RateLimitingInterface) {
-	glog.V(6).Info("Event: endpoint create")
+	h.log.Info("Event: endpoint create")
 
 	epNew := e.Object.(*corev1.Endpoints)
 	h.enqueueImpactedService(queue, epNew)
 }
 
 func (h *enqueueRequestsForEndpointsEvent) Update(e event.UpdateEvent, queue workqueue.RateLimitingInterface) {
-	glog.V(6).Info("Event: endpoints update")
+	h.log.Info("Event: endpoints update")
 	epOld := e.ObjectOld.(*corev1.Endpoints)
 	epNew := e.ObjectNew.(*corev1.Endpoints)
 	if !equality.Semantic.DeepEqual(epOld.Subsets, epNew.Subsets) {
@@ -43,7 +44,7 @@ func (h *enqueueRequestsForEndpointsEvent) Update(e event.UpdateEvent, queue wor
 }
 
 func (h *enqueueRequestsForEndpointsEvent) Delete(e event.DeleteEvent, queue workqueue.RateLimitingInterface) {
-	glog.V(6).Infof("Event: endpoints delete")
+	h.log.Infof("Event: endpoints delete")
 	// service event handler handles this event here
 }
 
@@ -52,18 +53,13 @@ func (h *enqueueRequestsForEndpointsEvent) Generic(e event.GenericEvent, queue w
 }
 
 func (h *enqueueRequestsForEndpointsEvent) enqueueImpactedService(queue workqueue.RateLimitingInterface, ep *corev1.Endpoints) {
-	glog.V(6).Infof("Event: enqueueImpactedService [%v]", ep)
+	h.log.Infof("Event: enqueueImpactedService for service name %s, namespace %s", ep.Name, ep.Namespace)
 
 	var targetIPList []string
-
-	// building a IP list
 	for _, endPoint := range ep.Subsets {
-
 		for _, address := range endPoint.Addresses {
-
 			targetIPList = append(targetIPList, address.IP)
 		}
-
 	}
 
 	svc := &corev1.Service{}
@@ -73,14 +69,14 @@ func (h *enqueueRequestsForEndpointsEvent) enqueueImpactedService(queue workqueu
 	}
 
 	if err := h.client.Get(context.TODO(), namespaceName, svc); err != nil {
-		glog.V(6).Infof("Event: enqueueImpactedService, service not found %v\n", err)
+		h.log.Infof("Event: enqueueImpactedService, service not found %v\n", err)
 		return
 	}
 
 	queue.Add(reconcile.Request{
 		NamespacedName: namespaceName,
 	})
 
-	glog.V(6).Infof("Finished enqueueImpactedService [%v] targetIPLIST[%v]\n", ep, targetIPList)
-
+	h.log.Infof("Finished enqueueImpactedService for service name %s, namespace %s targetIPLIST[%v]",
+		ep.Name, ep.Namespace, targetIPList)
 }

controllers/eventhandlers/gateway.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"time"
 
+	"github.com/aws/aws-application-networking-k8s/pkg/model/core"
+	"github.com/aws/aws-application-networking-k8s/pkg/utils/gwlog"
+
 	"github.com/golang/glog"
 
 	"k8s.io/apimachinery/pkg/api/equality"
@@ -21,11 +24,13 @@ import (
 )
 
 type enqueueRequestsForGatewayEvent struct {
+	log    gwlog.Logger
 	client client.Client
 }
 
-func NewEnqueueRequestGatewayEvent(client client.Client) handler.EventHandler {
+func NewEnqueueRequestGatewayEvent(log gwlog.Logger, client client.Client) handler.EventHandler {
 	return &enqueueRequestsForGatewayEvent{
+		log:    log,
 		client: client,
 	}
 }
@@ -38,11 +43,11 @@ func (h *enqueueRequestsForGatewayEvent) Create(e event.CreateEvent, queue workq
 
 	// initialize transition time
 	gwNew.Status.Conditions[0].LastTransitionTime = ZeroTransitionTime
-	h.enqueueImpactedHTTPRoute(queue, gwNew)
+	h.enqueueImpactedRoutes(queue)
 }
 
 func (h *enqueueRequestsForGatewayEvent) Update(e event.UpdateEvent, queue workqueue.RateLimitingInterface) {
-	glog.V(6).Info("Gateway Update ")
+	h.log.Info("Gateway Update ")
 
 	gwOld := e.ObjectOld.(*gateway_api.Gateway)
 	gwNew := e.ObjectNew.(*gateway_api.Gateway)
@@ -52,7 +57,7 @@ func (h *enqueueRequestsForGatewayEvent) Update(e event.UpdateEvent, queue workq
 			gwOld.Spec, gwNew.Spec)
 		// initialize transition time
 		gwNew.Status.Conditions[0].LastTransitionTime = ZeroTransitionTime
-		h.enqueueImpactedHTTPRoute(queue, gwNew)
+		h.enqueueImpactedRoutes(queue)
 	}
 }
 
@@ -64,32 +69,33 @@ func (h *enqueueRequestsForGatewayEvent) Generic(e event.GenericEvent, queue wor
 
 }
 
-func (h *enqueueRequestsForGatewayEvent) enqueueImpactedHTTPRoute(queue workqueue.RateLimitingInterface, gw *gateway_api.Gateway) {
-	httpRouteList := &gateway_api.HTTPRouteList{}
-
-	h.client.List(context.TODO(), httpRouteList)
-
-	for _, httpRoute := range httpRouteList.Items {
+func (h *enqueueRequestsForGatewayEvent) enqueueImpactedRoutes(queue workqueue.RateLimitingInterface) {
+	routes, err := core.ListAllRoutes(context.TODO(), h.client)
+	if err != nil {
+		h.log.Errorf("Failed to list all routes, %s", err)
+		return
+	}
+	for _, route := range routes {
 
-		if len(httpRoute.Spec.ParentRefs) <= 0 {
-			glog.V(6).Infof("Ignore httpRoute no parentRefs %s", httpRoute.Name)
+		if len(route.Spec().ParentRefs()) <= 0 {
+			h.log.Infof("Ignore route no parentRefs %s", route.Name())
 			continue
 		}
 
 		// find the parent gw object
-		var gwNamespace = httpRoute.Namespace
-		if httpRoute.Spec.ParentRefs[0].Namespace != nil {
-			gwNamespace = string(*httpRoute.Spec.ParentRefs[0].Namespace)
+		var gwNamespace = route.Namespace()
+		if route.Spec().ParentRefs()[0].Namespace != nil {
+			gwNamespace = string(*route.Spec().ParentRefs()[0].Namespace)
 		}
+
 		gwName := types.NamespacedName{
 			Namespace: gwNamespace,
-			Name:      string(httpRoute.Spec.ParentRefs[0].Name),
+			Name:      string(route.Spec().ParentRefs()[0].Name),
 		}
 
 		gw := &gateway_api.Gateway{}
-
 		if err := h.client.Get(context.TODO(), gwName, gw); err != nil {
-			glog.V(6).Infof("Ignore HTTPRoute with unknown parentRef %s\n", httpRoute.Name)
+			h.log.Infof("Ignore Route with unknown parentRef %s", route.Name())
 			continue
 		}
 
@@ -101,16 +107,16 @@ func (h *enqueueRequestsForGatewayEvent) enqueueImpactedHTTPRoute(queue workqueu
 		}
 
 		if err := h.client.Get(context.TODO(), gwClassName, gwClass); err != nil {
-			glog.V(6).Infof("Ignore HTTPRoute with unknown Gateway %s \n", httpRoute.Name)
+			h.log.Infof("Ignore Route with unknown Gateway %s", route.Name())
 			continue
 		}
 
 		if gwClass.Spec.ControllerName == config.LatticeGatewayControllerName {
-			glog.V(2).Infof("Trigger HTTPRoute from Gateway event , httpRoute %s", httpRoute.Name)
+			glog.V(2).Infof("Trigger Route from Gateway event, route %s", route.Name())
 			queue.Add(reconcile.Request{
 				NamespacedName: types.NamespacedName{
-					Namespace: httpRoute.Namespace,
-					Name:      httpRoute.Name,
+					Namespace: route.Namespace(),
+					Name:      route.Name(),
 				},
 			})
 		}