diff --git a/CHANGELOG.md b/CHANGELOG.md index 36ad1dcda2..9d27b86dec 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -75,7 +75,10 @@ Adding a new version? You'll need three changes: configuration. [#3359](https://github.com/Kong/kubernetes-ingress-controller/pull/3359) - Added `version` command - [#3379](https://github.com/Kong/kubernetes-ingress-controller/pull/3379) + [#3379](https://github.com/Kong/kubernetes-ingress-controller/pull/3379) +- Added `--publish-service-udp` to indicate the Service that handles inbound + UDP traffic. + [#3325](https://github.com/Kong/kubernetes-ingress-controller/pull/3325) - Added possibility to configure multiple Kong Gateways through the `--kong-admin-url` CLI flag (which can be specified multiple times) or through a corresponding environment variable `CONTROLLER_KONG_ADMIN_URL` (which can diff --git a/Makefile b/Makefile index a17cfe554a..e5228ffef7 100644 --- a/Makefile +++ b/Makefile @@ -432,6 +432,7 @@ test.istio: gotestsum KUBECONFIG ?= "${HOME}/.kube/config" KONG_NAMESPACE ?= kong-system KONG_PROXY_SERVICE ?= ingress-controller-kong-proxy +KONG_PROXY_UDP_SERVICE ?= ingress-controller-kong-udp-proxy KONG_ADMIN_SERVICE ?= ingress-controller-kong-admin KONG_ADMIN_PORT ?= 8001 KONG_ADMIN_URL ?= "http://$(shell kubectl -n $(KONG_NAMESPACE) get service $(KONG_ADMIN_SERVICE) -o=go-template='{{range .status.loadBalancer.ingress}}{{.ip}}{{end}}'):$(KONG_ADMIN_PORT)" @@ -446,6 +447,7 @@ debug: install _ensure-namespace --anonymous-reports=false \ --kong-admin-url $(KONG_ADMIN_URL) \ --publish-service $(KONG_NAMESPACE)/$(KONG_PROXY_SERVICE) \ + --publish-service-udp $(KONG_NAMESPACE)/$(KONG_PROXY_UDP_SERVICE) \ --kubeconfig $(KUBECONFIG) \ --feature-gates=$(KONG_CONTROLLER_FEATURE_GATES) @@ -494,6 +496,7 @@ _run: --anonymous-reports=false \ --kong-admin-url $(KONG_ADMIN_URL) \ --publish-service $(KONG_NAMESPACE)/$(KONG_PROXY_SERVICE) \ + --publish-service-udp $(KONG_NAMESPACE)/$(KONG_PROXY_UDP_SERVICE) \ --kubeconfig $(KUBECONFIG) \ --feature-gates=$(KONG_CONTROLLER_FEATURE_GATES) diff --git a/hack/generators/controllers/networking/main.go b/hack/generators/controllers/networking/main.go index 3cec4d78d8..e908a9eb3b 100644 --- a/hack/generators/controllers/networking/main.go +++ b/hack/generators/controllers/networking/main.go @@ -206,6 +206,7 @@ var inputControllersNeeded = &typesNeeded{ Package: kongv1beta1, Plural: "udpingresses", CacheType: "UDPIngress", + IsUDP: true, NeedsStatusPermissions: true, CapableOfStatusUpdates: true, AcceptsIngressClassNameAnnotation: true, @@ -333,6 +334,7 @@ type typeNeeded struct { Plural string CacheType string RBACVerbs []string + IsUDP bool // AcceptsIngressClassNameAnnotation indicates that the object accepts (and the controller will listen to) // the "kubernetes.io/ingress.class" annotation to decide whether or not the object is supported. @@ -627,7 +629,11 @@ func (r *{{.PackageAlias}}{{.Kind}}Reconciler) Reconcile(ctx context.Context, re } log.V(util.DebugLevel).Info("determining gateway addresses for object status updates", "namespace", req.Namespace, "name", req.Name) - addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses() + {{- if .IsUDP }} + addrs, err := r.DataplaneAddressFinder.GetUDPLoadBalancerAddresses(ctx) + {{- else }} + addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses(ctx) + {{- end }} if err != nil { return ctrl.Result{}, err } diff --git a/internal/controllers/configuration/zz_generated_controllers.go b/internal/controllers/configuration/zz_generated_controllers.go index 64e80aa5d2..be6ea73b5e 100644 --- a/internal/controllers/configuration/zz_generated_controllers.go +++ b/internal/controllers/configuration/zz_generated_controllers.go @@ -401,7 +401,7 @@ func (r *NetV1IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request } log.V(util.DebugLevel).Info("determining gateway addresses for object status updates", "namespace", req.Namespace, "name", req.Name) - addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses() + addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses(ctx) if err != nil { return ctrl.Result{}, err } @@ -672,7 +672,7 @@ func (r *NetV1Beta1IngressReconciler) Reconcile(ctx context.Context, req ctrl.Re } log.V(util.DebugLevel).Info("determining gateway addresses for object status updates", "namespace", req.Namespace, "name", req.Name) - addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses() + addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses(ctx) if err != nil { return ctrl.Result{}, err } @@ -867,7 +867,7 @@ func (r *ExtV1Beta1IngressReconciler) Reconcile(ctx context.Context, req ctrl.Re } log.V(util.DebugLevel).Info("determining gateway addresses for object status updates", "namespace", req.Namespace, "name", req.Name) - addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses() + addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses(ctx) if err != nil { return ctrl.Result{}, err } @@ -1545,7 +1545,7 @@ func (r *KongV1Beta1TCPIngressReconciler) Reconcile(ctx context.Context, req ctr } log.V(util.DebugLevel).Info("determining gateway addresses for object status updates", "namespace", req.Namespace, "name", req.Name) - addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses() + addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses(ctx) if err != nil { return ctrl.Result{}, err } @@ -1719,7 +1719,7 @@ func (r *KongV1Beta1UDPIngressReconciler) Reconcile(ctx context.Context, req ctr } log.V(util.DebugLevel).Info("determining gateway addresses for object status updates", "namespace", req.Namespace, "name", req.Name) - addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses() + addrs, err := r.DataplaneAddressFinder.GetUDPLoadBalancerAddresses(ctx) if err != nil { return ctrl.Result{}, err } diff --git a/internal/controllers/knative/knative.go b/internal/controllers/knative/knative.go index c79d65a301..60ea1634f6 100644 --- a/internal/controllers/knative/knative.go +++ b/internal/controllers/knative/knative.go @@ -208,7 +208,7 @@ func (r *Knativev1alpha1IngressReconciler) Reconcile(ctx context.Context, req ct } log.V(util.DebugLevel).Info("determining gateway addresses for object status updates", "namespace", req.Namespace, "name", req.Name) - addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses() + addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses(ctx) if err != nil { return ctrl.Result{}, err } diff --git a/internal/dataplane/address_finder.go b/internal/dataplane/address_finder.go index cf2d802add..f6c0edabbe 100644 --- a/internal/dataplane/address_finder.go +++ b/internal/dataplane/address_finder.go @@ -1,6 +1,7 @@ package dataplane import ( + "context" "fmt" "net" "strings" @@ -16,13 +17,14 @@ import ( // AddressGetter is a function which can dynamically retrieve the list of IPs // that the data-plane is listening on for ingress network traffic. -type AddressGetter func() ([]string, error) +type AddressGetter func(ctx context.Context) ([]string, error) // AddressFinder is a threadsafe metadata object which can provide the current // live addresses in use by the dataplane at any point in time. type AddressFinder struct { - overrideAddresses []string - addressGetter AddressGetter + overrideAddresses []string + overrideAddressesUDP []string + addressGetter AddressGetter lock sync.RWMutex } @@ -54,10 +56,19 @@ func (a *AddressFinder) SetOverrides(addrs []string) { a.overrideAddresses = addrs } +// SetUDPOverrides hard codes a specific list of addresses to be the UDP addresses +// that this finder produces for the data-plane. To disable overrides, call +// this method again with an empty list. +func (a *AddressFinder) SetUDPOverrides(addrs []string) { + a.lock.Lock() + defer a.lock.Unlock() + a.overrideAddressesUDP = addrs +} + // GetAddresses provides a list of the addresses which the data-plane is // listening on for ingress network traffic. Addresses can either be IP // addresses or hostnames. -func (a *AddressFinder) GetAddresses() ([]string, error) { +func (a *AddressFinder) GetAddresses(ctx context.Context) ([]string, error) { a.lock.RLock() defer a.lock.RUnlock() @@ -66,22 +77,50 @@ func (a *AddressFinder) GetAddresses() ([]string, error) { } if a.addressGetter != nil { - return a.addressGetter() + return a.addressGetter(ctx) } return nil, fmt.Errorf("data-plane addresses can't be retrieved: no valid method available") } +// GetUDPAddresses provides a list of the UDP addresses which the data-plane is +// listening on for ingress network traffic. Addresses can either be IP +// addresses or hostnames. If UDP settings are not configured, falls back to GetAddresses(). +func (a *AddressFinder) GetUDPAddresses(ctx context.Context) ([]string, error) { + a.lock.RLock() + defer a.lock.RUnlock() + + if len(a.overrideAddressesUDP) > 0 { + return a.overrideAddressesUDP, nil + } + + if len(a.overrideAddresses) > 0 && a.addressGetter == nil { + return a.overrideAddresses, nil + } + + if a.addressGetter != nil { + return a.addressGetter(ctx) + } + + return a.GetAddresses(ctx) +} + // GetLoadBalancerAddresses provides a list of the addresses which the // data-plane is listening on for ingress network traffic, but provides the // addresses in Kubernetes corev1.LoadBalancerIngress format. Addresses can be // IP addresses or hostnames. -func (a *AddressFinder) GetLoadBalancerAddresses() ([]netv1.IngressLoadBalancerIngress, error) { - addrs, err := a.GetAddresses() +func (a *AddressFinder) GetLoadBalancerAddresses(ctx context.Context) ([]netv1.IngressLoadBalancerIngress, error) { + addrs, err := a.GetAddresses(ctx) if err != nil { return nil, err } + return getAddressHelper(addrs) +} +// getAddressHelper converts a string slice of addresses (IPs or hostnames) into an IngressLoadBalancerIngress +// (https://pkg.go.dev/k8s.io/api/networking/v1#IngressLoadBalancerIngress), or an error if one of the given strings +// is neither a valid IP nor a valid hostname. +func getAddressHelper(addrs []string) ([]netv1.IngressLoadBalancerIngress, error) { var loadBalancerAddresses []netv1.IngressLoadBalancerIngress for _, addr := range addrs { ing := netv1.IngressLoadBalancerIngress{} @@ -99,6 +138,18 @@ func (a *AddressFinder) GetLoadBalancerAddresses() ([]netv1.IngressLoadBalancerI return loadBalancerAddresses, nil } +// GetUDPLoadBalancerAddresses provides a list of the addresses which the +// data-plane is listening on for UDP network traffic, but provides the +// addresses in Kubernetes corev1.LoadBalancerIngress format. Addresses can be +// IP addresses or hostnames. +func (a *AddressFinder) GetUDPLoadBalancerAddresses(ctx context.Context) ([]netv1.IngressLoadBalancerIngress, error) { + addrs, err := a.GetUDPAddresses(ctx) + if err != nil { + return nil, err + } + return getAddressHelper(addrs) +} + // ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- diff --git a/internal/dataplane/address_finder_test.go b/internal/dataplane/address_finder_test.go index 6a87e0f5e7..a13c65aa51 100644 --- a/internal/dataplane/address_finder_test.go +++ b/internal/dataplane/address_finder_test.go @@ -1,6 +1,7 @@ package dataplane import ( + "context" "fmt" "testing" @@ -15,7 +16,8 @@ func TestAddressFinder(t *testing.T) { require.Nil(t, finder.addressGetter) t.Log("verifying that a finder with no overrides or getter produces an error") - addrs, err := finder.GetAddresses() + ctx := context.Background() + addrs, err := finder.GetAddresses(ctx) require.Error(t, err) require.Empty(t, addrs) require.Equal(t, "data-plane addresses can't be retrieved: no valid method available", err.Error()) @@ -23,35 +25,35 @@ func TestAddressFinder(t *testing.T) { t.Log("generating a fake AddressGetter") defaultAddrs := []string{"127.0.0.1", "127.0.0.2"} overrideAddrs := []string{"192.168.1.1", "192.168.1.2", "192.168.1.3"} - fakeGetter := func() ([]string, error) { return defaultAddrs, nil } + fakeGetter := func(ctx context.Context) ([]string, error) { return defaultAddrs, nil } t.Log("verifying getting a list of addresses from the finder after a getter function is provided") finder.SetGetter(fakeGetter) - addrs, err = finder.GetAddresses() + addrs, err = finder.GetAddresses(ctx) require.NoError(t, err) require.Equal(t, defaultAddrs, addrs) t.Log("verifying that overrides take precedent over the getter") finder.SetOverrides(overrideAddrs) - addrs, err = finder.GetAddresses() + addrs, err = finder.GetAddresses(ctx) require.NoError(t, err) require.Equal(t, overrideAddrs, addrs) t.Log("verifying disabling overrides") finder.SetOverrides(nil) - addrs, err = finder.GetAddresses() + addrs, err = finder.GetAddresses(ctx) require.NoError(t, err) require.Equal(t, defaultAddrs, addrs) t.Log("verifying k8s load balancer formatted version of the addresses") - lbs, err := finder.GetLoadBalancerAddresses() + lbs, err := finder.GetLoadBalancerAddresses(ctx) require.NoError(t, err) require.Equal(t, []netv1.IngressLoadBalancerIngress{{IP: defaultAddrs[0]}, {IP: defaultAddrs[1]}}, lbs) t.Log("verifying valid DNS names are formatting properly") dnsAddrs := []string{"127.0.0.1", "example1.konghq.com", "example2.konghq.com"} finder.SetOverrides(dnsAddrs) - lbs, err = finder.GetLoadBalancerAddresses() + lbs, err = finder.GetLoadBalancerAddresses(ctx) require.NoError(t, err) require.Equal(t, []netv1.IngressLoadBalancerIngress{ {IP: dnsAddrs[0]}, @@ -61,7 +63,7 @@ func TestAddressFinder(t *testing.T) { t.Log("verifying empty addresses return an error") finder.SetOverrides([]string{""}) - lbs, err = finder.GetLoadBalancerAddresses() + lbs, err = finder.GetLoadBalancerAddresses(ctx) require.Error(t, err) require.Empty(t, lbs) require.Equal(t, "empty address found", err.Error()) @@ -69,8 +71,47 @@ func TestAddressFinder(t *testing.T) { t.Log("verifying invalid DNS names return an error") invalidDNSAddrs := []string{"support@konghq.com"} finder.SetOverrides(invalidDNSAddrs) - lbs, err = finder.GetLoadBalancerAddresses() + lbs, err = finder.GetLoadBalancerAddresses(ctx) require.Error(t, err) require.Empty(t, lbs) require.Equal(t, fmt.Sprintf("%s is not a valid DNS hostname", invalidDNSAddrs[0]), err.Error()) } + +func TestUDPAddressFinder(t *testing.T) { + t.Log("generating a new AddressFinder") + finder := NewAddressFinder() + require.NotNil(t, finder) + require.Nil(t, finder.addressGetter) + + t.Log("generating fake AddressGetters") + ctx := context.Background() + defaultAddrs := []string{"127.0.0.1", "127.0.0.2"} + overrideAddrs := []string{"192.168.1.1", "192.168.1.2", "192.168.1.3"} + fakeGetter := func(ctx context.Context) ([]string, error) { return defaultAddrs, nil } + + defaultUDPAddrs := []string{"127.1.0.1", "127.1.0.2"} + overrideUDPAddrs := []string{"192.168.2.1", "192.168.2.2", "192.168.2.3"} + fakeUDPGetter := func(ctx context.Context) ([]string, error) { return defaultUDPAddrs, nil } + + t.Log("verifying getting a list of addresses from the finder after a getter function is provided") + finder.SetGetter(fakeGetter) + addrs, err := finder.GetUDPAddresses(ctx) + require.NoError(t, err) + require.Equal(t, defaultAddrs, addrs) + + t.Log("verifying that overrides take precedent over the getter") + finder.SetOverrides(overrideAddrs) + addrs, err = finder.GetAddresses(ctx) + require.NoError(t, err) + require.Equal(t, overrideAddrs, addrs) + + finder.SetGetter(fakeUDPGetter) + addrs, err = finder.GetUDPAddresses(ctx) + require.NoError(t, err) + require.Equal(t, defaultUDPAddrs, addrs) + + finder.SetUDPOverrides(overrideUDPAddrs) + addrs, err = finder.GetUDPAddresses(ctx) + require.NoError(t, err) + require.Equal(t, overrideUDPAddrs, addrs) +} diff --git a/internal/manager/config.go b/internal/manager/config.go index 2da4d9e78b..91da4f0864 100644 --- a/internal/manager/config.go +++ b/internal/manager/config.go @@ -67,9 +67,11 @@ type Config struct { GatewayAPIControllerName string // Ingress status - PublishService types.NamespacedName - PublishStatusAddress []string - UpdateStatus bool + PublishServiceUDP types.NamespacedName + PublishService types.NamespacedName + PublishStatusAddress []string + PublishStatusAddressUDP []string + UpdateStatus bool // Kubernetes API toggling IngressExtV1beta1Enabled bool @@ -180,6 +182,11 @@ func (c *Config) FlagSet() *pflag.FlagSet { flagSet.StringSliceVar(&c.PublishStatusAddress, "publish-status-address", []string{}, `User-provided addresses in comma-separated string format, for use in lieu of "publish-service" `+ `when that Service lacks useful address information (for example, in bare-metal environments).`) + flagSet.Var(NewValidatedValue(&c.PublishServiceUDP, namespacedNameFromFlagValue), "publish-service-udp", `Service fronting UDP routing resources in + "namespace/name" format. The controller will update UDP route status information with this Service's + endpoints. If omitted, the same Service will be used for both TCP and UDP routes.`) + flagSet.StringSliceVar(&c.PublishStatusAddressUDP, "publish-status-address-udp", []string{}, `User-provided + address CSV, for use in lieu of "publish-service-udp" when that Service lacks useful address information.`) flagSet.BoolVar(&c.UpdateStatus, "update-status", true, `Indicates if the ingress controller should update the status of resources (e.g. IP/Hostname for v1.Ingress, e.t.c.)`) diff --git a/internal/manager/controllerdef.go b/internal/manager/controllerdef.go index 58e94ab93d..0ae07f3c7f 100644 --- a/internal/manager/controllerdef.go +++ b/internal/manager/controllerdef.go @@ -59,6 +59,7 @@ func setupControllers( mgr manager.Manager, dataplaneClient *dataplane.KongClient, dataplaneAddressFinder *dataplane.AddressFinder, + udpDataplaneAddressFinder *dataplane.AddressFinder, kubernetesStatusQueue *status.Queue, c *Config, featureGates map[string]bool, @@ -197,7 +198,7 @@ func setupControllers( IngressClassName: c.IngressClassName, DisableIngressClassLookups: !c.IngressClassNetV1Enabled, StatusQueue: kubernetesStatusQueue, - DataplaneAddressFinder: dataplaneAddressFinder, + DataplaneAddressFinder: udpDataplaneAddressFinder, CacheSyncTimeout: c.CacheSyncTimeout, }, }, diff --git a/internal/manager/run.go b/internal/manager/run.go index e3ea783eef..73c7aa0553 100644 --- a/internal/manager/run.go +++ b/internal/manager/run.go @@ -130,7 +130,7 @@ func Run(ctx context.Context, c *Config, diagnostic util.ConfigDumpDiagnostic, d } setupLog.Info("Initializing Dataplane Address Discovery") - dataplaneAddressFinder, err := setupDataplaneAddressFinder(ctx, mgr.GetClient(), c) + dataplaneAddressFinder, udpDataplaneAddressFinder, err := setupDataplaneAddressFinder(mgr.GetClient(), c) if err != nil { return err } @@ -138,7 +138,8 @@ func Run(ctx context.Context, c *Config, diagnostic util.ConfigDumpDiagnostic, d gateway.ControllerName = gatewayv1beta1.GatewayController(c.GatewayAPIControllerName) setupLog.Info("Starting Enabled Controllers") - controllers, err := setupControllers(mgr, dataplaneClient, dataplaneAddressFinder, kubernetesStatusQueue, c, featureGates) + controllers, err := setupControllers(mgr, dataplaneClient, + dataplaneAddressFinder, udpDataplaneAddressFinder, kubernetesStatusQueue, c, featureGates) if err != nil { return fmt.Errorf("unable to setup controller as expected %w", err) } diff --git a/internal/manager/setup.go b/internal/manager/setup.go index ae0749e21d..d279cfd99e 100644 --- a/internal/manager/setup.go +++ b/internal/manager/setup.go @@ -186,14 +186,24 @@ func setupAdmissionServer( return nil } -func setupDataplaneAddressFinder(ctx context.Context, mgrc client.Client, c *Config) (*dataplane.AddressFinder, error) { +// setupDataplaneAddressFinder returns a default and UDP address finder. These finders return the override addresses if +// set or the publish service addresses if no overrides are set. If no UDP overrides or UDP publish service are set, +// the UDP finder will also return the default addresses. If no override or publish service is set, this function +// returns nil finders and an error. +func setupDataplaneAddressFinder( + mgrc client.Client, + c *Config, +) (*dataplane.AddressFinder, *dataplane.AddressFinder, error) { dataplaneAddressFinder := dataplane.NewAddressFinder() + udpDataplaneAddressFinder := dataplane.NewAddressFinder() + var getter func(ctx context.Context) ([]string, error) if c.UpdateStatus { + // Default if overrideAddrs := c.PublishStatusAddress; len(overrideAddrs) > 0 { dataplaneAddressFinder.SetOverrides(overrideAddrs) } else if c.PublishService.String() != "" { publishServiceNn := c.PublishService - dataplaneAddressFinder.SetGetter(func() ([]string, error) { + dataplaneAddressFinder.SetGetter(func(ctx context.Context) ([]string, error) { svc := new(corev1.Service) if err := mgrc.Get(ctx, publishServiceNn, svc); err != nil { return nil, err @@ -221,9 +231,45 @@ func setupDataplaneAddressFinder(ctx context.Context, mgrc client.Client, c *Con return addrs, nil }) } else { - return nil, fmt.Errorf("status updates enabled but no method to determine data-plane addresses, need either --publish-service or --publish-status-address") + return nil, nil, fmt.Errorf("status updates enabled but no method to determine data-plane addresses, need either --publish-service or --publish-status-address") + } + + // UDP. falls back to default if not configured + if udpOverrideAddrs := c.PublishStatusAddressUDP; len(udpOverrideAddrs) > 0 { + udpDataplaneAddressFinder.SetUDPOverrides(udpOverrideAddrs) + } else if c.PublishServiceUDP.String() != "" { + publishServiceNn := c.PublishServiceUDP + udpDataplaneAddressFinder.SetGetter(func(ctx context.Context) ([]string, error) { + svc := new(corev1.Service) + if err := mgrc.Get(ctx, publishServiceNn, svc); err != nil { + return nil, err + } + + var addrs []string + switch svc.Spec.Type { //nolint:exhaustive + case corev1.ServiceTypeLoadBalancer: + for _, lbaddr := range svc.Status.LoadBalancer.Ingress { + if lbaddr.IP != "" { + addrs = append(addrs, lbaddr.IP) + } + if lbaddr.Hostname != "" { + addrs = append(addrs, lbaddr.Hostname) + } + } + default: + addrs = append(addrs, svc.Spec.ClusterIPs...) + } + + if len(addrs) == 0 { + return nil, fmt.Errorf("waiting for addresses to be provisioned for publish service %s", publishServiceNn) + } + + return addrs, nil + }) + } else { + udpDataplaneAddressFinder.SetGetter(getter) } } - return dataplaneAddressFinder, nil + return dataplaneAddressFinder, udpDataplaneAddressFinder, nil } diff --git a/internal/util/test/controller_manager.go b/internal/util/test/controller_manager.go index 93efa616b8..236f6fefa4 100644 --- a/internal/util/test/controller_manager.go +++ b/internal/util/test/controller_manager.go @@ -74,6 +74,7 @@ func DeployControllerManagerForCluster( fmt.Sprintf("--kubeconfig=%s", kubeconfig.Name()), "--election-id=integrationtests.konghq.com", "--publish-service=kong-system/ingress-controller-kong-proxy", + "--publish-service-udp=kong-system/ingress-controller-kong-udp-proxy", "--log-format=text", } controllerManagerFlags = append(controllerManagerFlags, additionalFlags...) diff --git a/test/integration/udpingress_test.go b/test/integration/udpingress_test.go index 9f67b4b0dd..8e1fbc128e 100644 --- a/test/integration/udpingress_test.go +++ b/test/integration/udpingress_test.go @@ -144,8 +144,11 @@ func TestUDPIngressEssentials(t *testing.T) { ingresses := curIng.Status.LoadBalancer.Ingress for _, ingress := range ingresses { if len(ingress.Hostname) > 0 || len(ingress.IP) > 0 { - t.Logf("udpingress hostname %s or ip %s is ready to redirect traffic.", ingress.Hostname, ingress.IP) - return true + proxyUDPIP := strings.Split(proxyUDPURL.Hostname(), ":")[0] + if ingress.IP == proxyUDPIP { + t.Logf("udpingress hostname %s or ip %s is ready to redirect traffic.", ingress.Hostname, ingress.IP) + return true + } } } return false