fix: Fix route-indexer in the StaticService controller

Author: rg0now

internal/controllers/udproute.go

@@ -2,6 +2,8 @@ package controllers
 
 import (
 	"context"
+	"fmt"
+
 	// "errors"
 	// "fmt"
 
@@ -364,24 +366,26 @@ func (r *udpRouteReconciler) Reconcile(ctx context.Context, req reconcile.Reques
 }
 
 func (r *udpRouteReconciler) validateBackendServiceForReconcile(svc *v1.Service) bool {
-	return r.validateBackendForReconcile(store.GetObjectKey(svc))
+	return r.validateBackendForReconcile(store.GetObjectKey(svc), serviceUDPRouteIndex, serviceUDPRouteIndexV1A2)
 }
 
-func (r *udpRouteReconciler) validateStaticServiceForReconcile(svc *stnrgwv1.StaticService) bool {
-	return r.validateBackendForReconcile(store.GetObjectKey(svc))
+func (r *udpRouteReconciler) validateStaticServiceForReconcile(staticSvc *stnrgwv1.StaticService) bool {
+	return r.validateBackendForReconcile(store.GetObjectKey(staticSvc),
+		staticServiceUDPRouteIndex, staticServiceUDPRouteIndexV1A2)
 }
 
 //nolint:staticcheck
 func (r *udpRouteReconciler) validateBackendEndpointsForReconcile(e *v1.Endpoints) bool {
-	return r.validateBackendForReconcile(store.GetObjectKey(e))
+	return r.validateBackendForReconcile(store.GetObjectKey(e), serviceUDPRouteIndex, serviceUDPRouteIndexV1A2)
 }
 
-// validateBackendForReconcile checks whether the Service belongs to a valid UDPRoute.
-func (r *udpRouteReconciler) validateBackendForReconcile(key string) bool {
+// validateBackendForReconcile checks whether the Service or StaticService belongs to a valid
+// UDPRoute. Uses the indexers in the argument.
+func (r *udpRouteReconciler) validateBackendForReconcile(key, index, indexV1A2 string) bool {
 	// find the routes referring to this service
 	routeList := &stnrgwv1.UDPRouteList{}
 	if err := r.List(context.Background(), routeList, &client.ListOptions{
-		FieldSelector: fields.OneTermEqualSelector(serviceUDPRouteIndex, key),
+		FieldSelector: fields.OneTermEqualSelector(index, key),
 	}); err != nil {
 		r.log.Error(err, "Unable to find associated UDPRoute", "service", key)
 		return false
@@ -390,19 +394,22 @@ func (r *udpRouteReconciler) validateBackendForReconcile(key string) bool {
 	// find V1A2 routes referring to this service
 	routeListV1A2 := &gwapiv1a2.UDPRouteList{}
 	if err := r.List(context.Background(), routeListV1A2, &client.ListOptions{
-		FieldSelector: fields.OneTermEqualSelector(serviceUDPRouteIndexV1A2, key),
+		FieldSelector: fields.OneTermEqualSelector(indexV1A2, key),
 	}); err != nil {
 		r.log.Error(err, "Unable to find associated UDPRouteV1A2", "service", key)
 		return false
 	}
 
-	if len(routeList.Items) == 0 && len(routeListV1A2.Items) == 0 {
-		r.log.Info("Validating backend", "udproute", "not found")
-		return false
+	routeNum := len(routeList.Items) + len(routeListV1A2.Items)
+	resStr := "not found"
+	if routeNum > 0 {
+		resStr = fmt.Sprintf("found %d routes", routeNum)
 	}
 
-	r.log.Info("Validate backend", "udproute", "found")
-	return true
+	r.log.Info("Validating backend", "key", key, "index", fmt.Sprintf("%s/%s", index, indexV1A2),
+		"udproute", resStr)
+
+	return routeNum != 0
 }
 
 // validateEndpointSliceForReconcile checks whether an EndpointSlice belongs to a Service that

test/managed_mode_test.go

@@ -1380,7 +1380,7 @@ func testManagedMode() {
 			}, timeout, interval).Should(BeTrue())
 		})
 
-		It("should survive converting the route to a StaticService backend", func() {
+		It("should survive adding a StaticService backend", func() {
 			ctrl.Log.Info("adding static service")
 			createOrUpdateStaticService(ctx, k8sClient, testStaticSvc, nil)
 
@@ -1612,6 +1612,68 @@ func testManagedMode() {
 			Expect(s.Status).Should(Equal(metav1.ConditionTrue))
 		})
 
+		It("should handle a StaticService endpoint being changed", func() {
+			ctrl.Log.Info("updating static service")
+			updatedStaticSvc := testStaticSvc.DeepCopy()
+			updatedStaticSvc.Spec = stnrgwv1.StaticServiceSpec{
+				Prefixes: []string{"10.11.12.13", "10.11.12.14", "10.11.12.16"},
+			}
+			createOrUpdateStaticService(ctx, k8sClient, updatedStaticSvc, nil)
+
+			ctrl.Log.Info("trying to load STUNner config")
+			Eventually(checkConfig(ch, func(c *stnrv1.StunnerConfig) bool {
+				if len(c.Clusters) == 1 && contains(c.Clusters[0].Endpoints, "10.11.12.16") {
+					conf = c
+					return true
+				}
+				return false
+			}), timeout, interval).Should(BeTrue())
+		})
+
+		It("should render a correct STUNner config", func() {
+			Expect(conf.Listeners).To(HaveLen(2))
+
+			// not sure about the order
+			l := conf.Listeners[0]
+			if l.Name != "testnamespace/gateway-1/gateway-1-listener-udp" {
+				l = conf.Listeners[1]
+			}
+
+			Expect(l.Name).Should(Equal("testnamespace/gateway-1/gateway-1-listener-udp"))
+			Expect(l.Protocol).Should(Equal("TURN-UDP"))
+			Expect(l.Port).Should(Equal(1))
+			Expect(l.Routes).To(HaveLen(1))
+			Expect(l.Routes[0]).Should(Equal("testnamespace/udproute-ok"))
+
+			l = conf.Listeners[1]
+			if l.Name != "testnamespace/gateway-1/gateway-1-listener-dtls" {
+				l = conf.Listeners[0]
+			}
+
+			Expect(l.Name).Should(Equal("testnamespace/gateway-1/gateway-1-listener-dtls"))
+			Expect(l.Protocol).Should(Equal("TURN-DTLS"))
+			Expect(l.Port).Should(Equal(2))
+			Expect(l.Routes).To(HaveLen(1))
+			Expect(l.Key).NotTo(Equal(""))
+			Expect(l.Cert).NotTo(Equal(""))
+			Expect(l.Routes[0]).Should(Equal("testnamespace/udproute-ok"))
+
+			Expect(conf.Clusters).To(HaveLen(1))
+
+			c := conf.Clusters[0]
+
+			Expect(c.Name).Should(Equal("testnamespace/udproute-ok"))
+			Expect(c.Type).Should(Equal("STATIC"))
+			Expect(c.Endpoints).To(HaveLen(8))
+			Expect(c.Endpoints).Should(ContainElement("10.11.12.13"))
+			Expect(c.Endpoints).Should(ContainElement("10.11.12.14"))
+			Expect(c.Endpoints).Should(ContainElement("10.11.12.16"))
+			Expect(c.Endpoints).Should(ContainElement("1.2.3.4"))
+			Expect(c.Endpoints).Should(ContainElement("1.2.3.5"))
+			Expect(c.Endpoints).Should(ContainElement("1.2.3.6"))
+			Expect(c.Endpoints).Should(ContainElement("1.2.3.7"))
+		})
+
 		It("should survive converting the route to v1a2 route", func() {
 			ctrl.Log.Info("reseting gateway")
 			createOrUpdateGateway(ctx, k8sClient, testGw, func(current *gwapiv1.Gateway) {
@@ -1736,7 +1798,7 @@ func testManagedMode() {
 				Equal(string(gwapiv1.GatewayConditionProgrammed)))
 			Expect(s.Status).Should(Equal(metav1.ConditionTrue))
 
-			// stragely recreating the gateway lets api-server to find the public ip
+			// strangely recreating the gateway lets api-server to find the public ip
 			// for the gw so Ready status becomes true (should investigate this)
 			Expect(gw.Status.Listeners).To(HaveLen(2))