From 19ca30f516f9f1aaf8020297924d3dda61be6235 Mon Sep 17 00:00:00 2001 From: Maskym Vavilov Date: Tue, 7 Nov 2023 18:20:11 +0000 Subject: [PATCH] GH-496 addresses check and small test --- pkg/controllers/dnspolicy/dns_helper.go | 2 +- .../dnspolicy/dnspolicy_dnsrecords.go | 52 ++++---- pkg/controllers/gateway/gateway_controller.go | 19 +-- pkg/dns/fake/service.go | 19 --- pkg/traffic/gateway.go | 124 ------------------ pkg/traffic/traffic.go | 27 ---- pkg/utils/gateway_wrapper.go | 80 +++++++++++ .../dnspolicy_controller_test.go | 55 +++++++- 8 files changed, 167 insertions(+), 211 deletions(-) delete mode 100644 pkg/traffic/gateway.go delete mode 100644 pkg/traffic/traffic.go create mode 100644 pkg/utils/gateway_wrapper.go diff --git a/pkg/controllers/dnspolicy/dns_helper.go b/pkg/controllers/dnspolicy/dns_helper.go index 20931afdf..a08a71565 100644 --- a/pkg/controllers/dnspolicy/dns_helper.go +++ b/pkg/controllers/dnspolicy/dns_helper.go @@ -124,7 +124,7 @@ func (dh *dnsHelper) buildDNSRecordForListener(gateway *gatewayv1beta1.Gateway, } // getDNSRecordForListener returns a v1alpha1.DNSRecord, if one exists, for the given listener in the given v1alpha1.ManagedZone. -// It needs a reference string to enforce DNS record serving a single traffic.Interface owner +// It needs a reference string to enforce DNS record serving a single utils.Interface owner func (dh *dnsHelper) getDNSRecordForListener(ctx context.Context, listener gatewayv1beta1.Listener, owner metav1.Object) (*v1alpha1.DNSRecord, error) { recordName := dnsRecordName(owner.GetName(), string(listener.Name)) dnsRecord := &v1alpha1.DNSRecord{} diff --git a/pkg/controllers/dnspolicy/dnspolicy_dnsrecords.go b/pkg/controllers/dnspolicy/dnspolicy_dnsrecords.go index 2ddff0d97..b84471f24 100644 --- a/pkg/controllers/dnspolicy/dnspolicy_dnsrecords.go +++ b/pkg/controllers/dnspolicy/dnspolicy_dnsrecords.go @@ -16,8 +16,8 @@ import ( "github.com/kuadrant/kuadrant-operator/pkg/reconcilers" "github.com/Kuadrant/multicluster-gateway-controller/pkg/apis/v1alpha1" - "github.com/Kuadrant/multicluster-gateway-controller/pkg/controllers/gateway" "github.com/Kuadrant/multicluster-gateway-controller/pkg/dns" + "github.com/Kuadrant/multicluster-gateway-controller/pkg/utils" ) const ( @@ -45,34 +45,39 @@ func (r *DNSPolicyReconciler) reconcileDNSRecords(ctx context.Context, dnsPolicy return nil } -func (r *DNSPolicyReconciler) reconcileGatewayDNSRecords(ctx context.Context, gateway *gatewayv1beta1.Gateway, dnsPolicy *v1alpha1.DNSPolicy) error { +func (r *DNSPolicyReconciler) reconcileGatewayDNSRecords(ctx context.Context, gw *gatewayv1beta1.Gateway, dnsPolicy *v1alpha1.DNSPolicy) error { log := crlog.FromContext(ctx) - if err := r.dnsHelper.removeDNSForDeletedListeners(ctx, gateway); err != nil { + trafficGateway, err := utils.NewGatewayWrapper(gw) + if err != nil { + return err + } + + if err := r.dnsHelper.removeDNSForDeletedListeners(ctx, trafficGateway.Gateway); err != nil { log.V(3).Info("error removing DNS for deleted listeners") return err } - clusterGatewayAddresses := getClusterGatewayAddresses(gateway) + clusterGatewayAddresses := getClusterGatewayAddresses(trafficGateway) - log.V(3).Info("checking gateway for attached routes ", "gateway", gateway.Name, "clusters", clusterGatewayAddresses) + log.V(3).Info("checking gateway for attached routes ", "gateway", trafficGateway.Name, "clusters", clusterGatewayAddresses) - for _, listener := range gateway.Spec.Listeners { + for _, listener := range trafficGateway.Spec.Listeners { var clusterGateways []dns.ClusterGateway - var mz, err = r.dnsHelper.getManagedZoneForListener(ctx, gateway.Namespace, listener) + var mz, err = r.dnsHelper.getManagedZoneForListener(ctx, trafficGateway.Namespace, listener) if err != nil { return err } listenerHost := *listener.Hostname if listenerHost == "" { - log.Info("skipping listener no hostname assigned", listener.Name, "in ns ", gateway.Namespace) + log.Info("skipping listener no hostname assigned", listener.Name, "in ns ", trafficGateway.Namespace) continue } for clusterName, gatewayAddresses := range clusterGatewayAddresses { // Only consider host for dns if there's at least 1 attached route to the listener for this host in *any* gateway log.V(3).Info("checking downstream", "listener ", listener.Name) - attached := listenerTotalAttachedRoutes(gateway, clusterName, listener, gatewayAddresses) + attached := listenerTotalAttachedRoutes(trafficGateway, clusterName, listener) if attached == 0 { log.V(1).Info("no attached routes for ", "listener", listener, "cluster ", clusterName) @@ -80,7 +85,7 @@ func (r *DNSPolicyReconciler) reconcileGatewayDNSRecords(ctx context.Context, ga } log.V(3).Info("hostHasAttachedRoutes", "host", listener.Name, "hostHasAttachedRoutes", attached) - cg, err := r.buildClusterGateway(ctx, clusterName, gatewayAddresses, gateway) + cg, err := r.buildClusterGateway(ctx, clusterName, gatewayAddresses, trafficGateway.Gateway) if err != nil { return fmt.Errorf("get cluster gateway failed: %s", err) } @@ -91,23 +96,23 @@ func (r *DNSPolicyReconciler) reconcileGatewayDNSRecords(ctx context.Context, ga if len(clusterGateways) == 0 { // delete record log.V(3).Info("no cluster gateways, deleting DNS record", " for listener ", listener.Name) - if err := r.dnsHelper.deleteDNSRecordForListener(ctx, gateway, listener); client.IgnoreNotFound(err) != nil { + if err := r.dnsHelper.deleteDNSRecordForListener(ctx, trafficGateway, listener); client.IgnoreNotFound(err) != nil { return fmt.Errorf("failed to delete dns record for listener %s : %s", listener.Name, err) } return nil } - dnsRecord, err := r.dnsHelper.createDNSRecordForListener(ctx, gateway, dnsPolicy, mz, listener) + dnsRecord, err := r.dnsHelper.createDNSRecordForListener(ctx, trafficGateway.Gateway, dnsPolicy, mz, listener) if err := client.IgnoreAlreadyExists(err); err != nil { return fmt.Errorf("failed to create dns record for listener host %s : %s ", *listener.Hostname, err) } if k8serrors.IsAlreadyExists(err) { - dnsRecord, err = r.dnsHelper.getDNSRecordForListener(ctx, listener, gateway) + dnsRecord, err = r.dnsHelper.getDNSRecordForListener(ctx, listener, trafficGateway) if err != nil { return fmt.Errorf("failed to get dns record for host %s : %s ", listener.Name, err) } } - mcgTarget, err := dns.NewMultiClusterGatewayTarget(gateway, clusterGateways, dnsPolicy.Spec.LoadBalancing) + mcgTarget, err := dns.NewMultiClusterGatewayTarget(trafficGateway.Gateway, clusterGateways, dnsPolicy.Spec.LoadBalancing) if err != nil { return fmt.Errorf("failed to create multi cluster gateway target for listener %s : %s ", listener.Name, err) } @@ -167,12 +172,10 @@ func (r *DNSPolicyReconciler) buildClusterGateway(ctx context.Context, clusterNa } for i, addr := range gatewayAddresses { - addrType := *addr.Type - if addrType == gateway.MultiClusterHostnameAddressType { - addrType = gatewayv1beta1.HostnameAddressType - } - if addrType == gateway.MultiClusterIPAddressType { - addrType = gatewayv1beta1.IPAddressType + addrType, multicluster := utils.AddressTypeToSingleCluster(addr) + + if !multicluster { + addrType = *addr.Type } singleClusterAddresses[i] = gatewayv1beta1.GatewayAddress{ @@ -185,7 +188,7 @@ func (r *DNSPolicyReconciler) buildClusterGateway(ctx context.Context, clusterNa return target, nil } -func getClusterGatewayAddresses(gw *gatewayv1beta1.Gateway) map[string][]gatewayv1beta1.GatewayAddress { +func getClusterGatewayAddresses(gw *utils.GatewayWrapper) map[string][]gatewayv1beta1.GatewayAddress { clusterAddrs := make(map[string][]gatewayv1beta1.GatewayAddress, len(gw.Status.Addresses)) for _, address := range gw.Status.Addresses { @@ -194,7 +197,7 @@ func getClusterGatewayAddresses(gw *gatewayv1beta1.Gateway) map[string][]gateway addressValue := address.Value //Check for Multi Cluster (MGC Gateway Status) - if *address.Type == gateway.MultiClusterIPAddressType || *address.Type == gateway.MultiClusterHostnameAddressType { + if gw.IsMultiCluster() { tmpCluster, tmpAddress, found := strings.Cut(address.Value, "/") //If this fails something is wrong and the value hasn't been set correctly if found { @@ -216,11 +219,10 @@ func getClusterGatewayAddresses(gw *gatewayv1beta1.Gateway) map[string][]gateway return clusterAddrs } -func listenerTotalAttachedRoutes(upstreamGateway *gatewayv1beta1.Gateway, downstreamCluster string, specListener gatewayv1beta1.Listener, addresses []gatewayv1beta1.GatewayAddress) int { +func listenerTotalAttachedRoutes(upstreamGateway *utils.GatewayWrapper, downstreamCluster string, specListener gatewayv1beta1.Listener) int { for _, statusListener := range upstreamGateway.Status.Listeners { - // assuming all adresses of the same type on the gateway // for Multi Cluster (MGC Gateway Status) - if *addresses[0].Type == gateway.MultiClusterIPAddressType || *addresses[0].Type == gateway.MultiClusterHostnameAddressType { + if upstreamGateway.IsMultiCluster() { clusterName, listenerName, found := strings.Cut(string(statusListener.Name), ".") if !found { return 0 diff --git a/pkg/controllers/gateway/gateway_controller.go b/pkg/controllers/gateway/gateway_controller.go index b9a057b9e..4c99ff159 100644 --- a/pkg/controllers/gateway/gateway_controller.go +++ b/pkg/controllers/gateway/gateway_controller.go @@ -51,15 +51,14 @@ import ( "github.com/Kuadrant/multicluster-gateway-controller/pkg/_internal/slice" "github.com/Kuadrant/multicluster-gateway-controller/pkg/dns" "github.com/Kuadrant/multicluster-gateway-controller/pkg/policysync" + "github.com/Kuadrant/multicluster-gateway-controller/pkg/utils" ) const ( - GatewayClusterLabelSelectorAnnotation = "kuadrant.io/gateway-cluster-label-selector" - GatewayClustersAnnotation = "kuadrant.io/gateway-clusters" - GatewayFinalizer = "kuadrant.io/gateway" - ManagedLabel = "kuadrant.io/managed" - MultiClusterIPAddressType gatewayv1beta1.AddressType = "kuadrant.io/MultiClusterIPAddress" - MultiClusterHostnameAddressType gatewayv1beta1.AddressType = "kuadrant.io/MultiClusterHostnameAddress" + GatewayClusterLabelSelectorAnnotation = "kuadrant.io/gateway-cluster-label-selector" + GatewayClustersAnnotation = "kuadrant.io/gateway-clusters" + GatewayFinalizer = "kuadrant.io/gateway" + ManagedLabel = "kuadrant.io/managed" ) type GatewayPlacer interface { @@ -214,12 +213,8 @@ func (r *GatewayReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct } for _, address := range addresses { log.V(3).Info("checking address type for mapping", "address.Type", address.Type) - var addressType gatewayv1beta1.AddressType - if *address.Type == gatewayv1beta1.IPAddressType { - addressType = MultiClusterIPAddressType - } else if *address.Type == gatewayv1beta1.HostnameAddressType { - addressType = MultiClusterHostnameAddressType - } else { + addressType, supported := utils.AddressTypeToMultiCluster(address) + if !supported { continue // ignore address type gatewayv1beta1.NamedAddressType. Unsupported for multi cluster gateway } allAddresses = append(allAddresses, gatewayv1beta1.GatewayAddress{ diff --git a/pkg/dns/fake/service.go b/pkg/dns/fake/service.go index d0f4dc0b6..67f727360 100644 --- a/pkg/dns/fake/service.go +++ b/pkg/dns/fake/service.go @@ -11,7 +11,6 @@ import ( "github.com/Kuadrant/multicluster-gateway-controller/pkg/apis/v1alpha1" . "github.com/Kuadrant/multicluster-gateway-controller/pkg/dns" - "github.com/Kuadrant/multicluster-gateway-controller/pkg/traffic" . "github.com/Kuadrant/multicluster-gateway-controller/test/util" ) @@ -27,14 +26,6 @@ func (h *FakeHostService) SetEndpoints(_ context.Context, _ *MultiClusterGateway return nil } -func (h *FakeHostService) GetDNSRecordsFor(_ context.Context, _ traffic.Interface) ([]*v1alpha1.DNSRecord, error) { - return nil, nil -} - -func (h *FakeHostService) CleanupDNSRecords(_ context.Context, _ traffic.Interface) error { - return nil -} - func (h *FakeHostService) CreateDNSRecord(_ context.Context, subDomain string, _ *v1alpha1.ManagedZone, _ metav1.Object) (*v1alpha1.DNSRecord, error) { if subDomain == Cluster { return nil, fmt.Errorf(FailCreateDNSSubdomain) @@ -59,13 +50,3 @@ func (h *FakeHostService) GetDNSRecord(ctx context.Context, subDomain string, ma } return record, nil } - -func (h *FakeHostService) AddEndpoints(_ context.Context, gateway traffic.Interface, _ *v1alpha1.DNSRecord) error { - hosts := gateway.GetHosts() - for _, host := range hosts { - if host == FailEndpointsHostname { - return fmt.Errorf(FailEndpointsHostname) - } - } - return nil -} diff --git a/pkg/traffic/gateway.go b/pkg/traffic/gateway.go deleted file mode 100644 index f77b4192a..000000000 --- a/pkg/traffic/gateway.go +++ /dev/null @@ -1,124 +0,0 @@ -package traffic - -import ( - "fmt" - - corev1 "k8s.io/api/core/v1" - "k8s.io/apimachinery/pkg/types" - "k8s.io/client-go/tools/cache" - "k8s.io/utils/strings/slices" - gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1" - - "github.com/Kuadrant/multicluster-gateway-controller/pkg/_internal/slice" -) - -type GatewayInterface interface { - Interface - GetListenerByHost(host string) *gatewayv1beta1.Listener -} - -func NewGateway(g *gatewayv1beta1.Gateway) GatewayInterface { - return &Gateway{Gateway: g} -} - -type Gateway struct { - *gatewayv1beta1.Gateway -} - -func (a *Gateway) GetKind() string { - return "Gateway" -} - -func (a *Gateway) GetHosts() []string { - var hosts []string - for _, listener := range a.Spec.Listeners { - host := (*string)(listener.Hostname) - if host == nil { - continue - } - if !slices.Contains(hosts, *host) { - hosts = append(hosts, *host) - } - } - - return hosts -} - -func (a *Gateway) HasTLS() bool { - hasTLS := false - for _, listener := range a.Spec.Listeners { - if listener.TLS != nil { - hasTLS = true - break - } - } - return hasTLS -} - -func (a *Gateway) AddTLS(host string, secret *corev1.Secret) { - listeners := []gatewayv1beta1.Listener{} - - gatewayNS := gatewayv1beta1.Namespace(a.Namespace) - secretKind := gatewayv1beta1.Kind(secret.Kind) - secretGroup := gatewayv1beta1.Group("") - modeTerminate := gatewayv1beta1.TLSModeTerminate - for _, listener := range a.Spec.Listeners { - if *(*string)(listener.Hostname) == host { - listener.TLS = &gatewayv1beta1.GatewayTLSConfig{ - Mode: &modeTerminate, // Ensure terminate mode as we're managing the cert - CertificateRefs: []gatewayv1beta1.SecretObjectReference{ - { - Group: &secretGroup, - Kind: &secretKind, - Name: gatewayv1beta1.ObjectName(secret.Name), - Namespace: &gatewayNS, - }, - }, - } - } - listeners = append(listeners, listener) - } - - a.Spec.Listeners = listeners -} - -func (a *Gateway) RemoveTLS(hosts []string) { - for _, listener := range a.Spec.Listeners { - if slice.ContainsString(hosts, fmt.Sprint(listener.Hostname)) { - listener.TLS = nil - } - } -} - -func (a *Gateway) GetSpec() interface{} { - return a.Spec -} - -func (a *Gateway) GetNamespaceName() types.NamespacedName { - return types.NamespacedName{ - Namespace: a.Namespace, - Name: a.Name, - } -} - -func (a *Gateway) GetCacheKey() string { - key, _ := cache.MetaNamespaceKeyFunc(a) - return key -} - -func (a *Gateway) String() string { - return fmt.Sprintf("kind: %v, namespace/name: %v", a.GetKind(), a.GetNamespaceName()) -} - -func (a *Gateway) GetListenerByHost(host string) *gatewayv1beta1.Listener { - for _, listener := range a.Spec.Listeners { - if *(*string)(listener.Hostname) == host { - return &listener - } - } - return nil -} - -func (a *Gateway) ExposesOwnController() bool { - return false -} diff --git a/pkg/traffic/traffic.go b/pkg/traffic/traffic.go deleted file mode 100644 index 7b921850a..000000000 --- a/pkg/traffic/traffic.go +++ /dev/null @@ -1,27 +0,0 @@ -package traffic - -import ( - "context" - - corev1 "k8s.io/api/core/v1" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/runtime" - "k8s.io/apimachinery/pkg/types" -) - -type CreateOrUpdateTraffic func(ctx context.Context, i Interface) error -type DeleteTraffic func(ctx context.Context, i Interface) error - -type Interface interface { - runtime.Object - metav1.Object - GetKind() string - GetHosts() []string - GetCacheKey() string - GetNamespaceName() types.NamespacedName - AddTLS(host string, secret *corev1.Secret) - HasTLS() bool - RemoveTLS(host []string) - GetSpec() interface{} - ExposesOwnController() bool -} diff --git a/pkg/utils/gateway_wrapper.go b/pkg/utils/gateway_wrapper.go new file mode 100644 index 000000000..9d5416a84 --- /dev/null +++ b/pkg/utils/gateway_wrapper.go @@ -0,0 +1,80 @@ +package utils + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/types" + gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1" +) + +const ( + MultiClusterIPAddressType gatewayv1beta1.AddressType = "kuadrant.io/MultiClusterIPAddress" + MultiClusterHostnameAddressType gatewayv1beta1.AddressType = "kuadrant.io/MultiClusterHostnameAddress" +) + +type GatewayWrapper struct { + *gatewayv1beta1.Gateway + isMultiCluster bool +} + +func NewGatewayWrapper(g *gatewayv1beta1.Gateway) (*GatewayWrapper, error) { + gw := &GatewayWrapper{Gateway: g, isMultiCluster: false} + + for i, address := range gw.Status.Addresses { + if i == 0 { + gw.isMultiCluster = isMultiClusterAddressType(*address.Type) + continue + } + if gw.isMultiCluster == isMultiClusterAddressType(*address.Type) { + continue + } + return nil, fmt.Errorf("gateway is invalid: inconsistent status addresses") + + } + return gw, nil +} + +func isMultiClusterAddressType(addressType gatewayv1beta1.AddressType) bool { + return addressType == MultiClusterIPAddressType || addressType == MultiClusterHostnameAddressType +} + +func (a *GatewayWrapper) GetKind() string { + return "GatewayWrapper" +} + +func (a *GatewayWrapper) IsMultiCluster() bool { + return a.isMultiCluster +} + +func (a *GatewayWrapper) GetNamespaceName() types.NamespacedName { + return types.NamespacedName{ + Namespace: a.Namespace, + Name: a.Name, + } +} + +func (a *GatewayWrapper) String() string { + return fmt.Sprintf("kind: %v, namespace/name: %v", a.GetKind(), a.GetNamespaceName()) +} + +// AddressTypeToMultiCluster returns a multi cluster version of the address type +// and a bool to indicate that provided address has supported type +func AddressTypeToMultiCluster(address gatewayv1beta1.GatewayAddress) (gatewayv1beta1.AddressType, bool) { + if *address.Type == gatewayv1beta1.IPAddressType { + return MultiClusterIPAddressType, true + } else if *address.Type == gatewayv1beta1.HostnameAddressType { + return MultiClusterHostnameAddressType, true + } + return "", false +} + +// AddressTypeToSingleCluster returns a single cluster version of the address type +// and a bool to indicate that provided address was of the multi cluster type +func AddressTypeToSingleCluster(address gatewayv1beta1.GatewayAddress) (gatewayv1beta1.AddressType, bool) { + if *address.Type == MultiClusterIPAddressType { + return gatewayv1beta1.IPAddressType, true + } else if *address.Type == MultiClusterHostnameAddressType { + return gatewayv1beta1.HostnameAddressType, true + } + return "", false +} diff --git a/test/policy_integration/dnspolicy_controller_test.go b/test/policy_integration/dnspolicy_controller_test.go index 17ff19fba..486e9346b 100644 --- a/test/policy_integration/dnspolicy_controller_test.go +++ b/test/policy_integration/dnspolicy_controller_test.go @@ -26,8 +26,8 @@ import ( "github.com/Kuadrant/multicluster-gateway-controller/pkg/_internal/metadata" "github.com/Kuadrant/multicluster-gateway-controller/pkg/apis/v1alpha1" . "github.com/Kuadrant/multicluster-gateway-controller/pkg/controllers/dnspolicy" - mgcgateway "github.com/Kuadrant/multicluster-gateway-controller/pkg/controllers/gateway" "github.com/Kuadrant/multicluster-gateway-controller/pkg/dns" + "github.com/Kuadrant/multicluster-gateway-controller/pkg/utils" testutil "github.com/Kuadrant/multicluster-gateway-controller/test/util" ) @@ -181,6 +181,55 @@ var _ = Describe("DNSPolicy", Ordered, func() { }, TestTimeoutMedium, TestRetryIntervalMedium).Should(BeTrue()) }) + It("should not process gateway with inconsistent addresses", func() { + // build invalid gateway + gateway = testutil.NewGatewayBuilder("test-gateway", gatewayClass.Name, testNamespace). + WithHTTPListener(TestListenerNameOne, TestHostOne).Gateway + Expect(k8sClient.Create(ctx, gateway)).To(BeNil()) + + // ensure gateway exists + Eventually(func() error { + return k8sClient.Get(ctx, client.ObjectKey{Name: gateway.Name, Namespace: gateway.Namespace}, gateway) + }, TestTimeoutMedium, TestRetryIntervalMedium).ShouldNot(HaveOccurred()) + + // invalidate gateway by setting inconsistent addresses + Eventually(func() error { + gateway.Status.Addresses = []gatewayv1beta1.GatewayAddress{ + { + Type: testutil.Pointer(gatewayv1beta1.IPAddressType), + Value: TestClusterNameOne + "/" + TestIPAddressOne, + }, + { + Type: testutil.Pointer(utils.MultiClusterIPAddressType), + Value: TestIPAddressTwo, + }, + } + gateway.Status.Listeners = []gatewayv1beta1.ListenerStatus{ + { + Name: TestClusterNameOne + "." + TestListenerNameOne, + SupportedKinds: []gatewayv1beta1.RouteGroupKind{}, + AttachedRoutes: 1, + Conditions: []metav1.Condition{}, + }, + { + Name: TestListenerNameOne, + SupportedKinds: []gatewayv1beta1.RouteGroupKind{}, + AttachedRoutes: 1, + Conditions: []metav1.Condition{}, + }, + } + return k8sClient.Status().Update(ctx, gateway) + }, TestTimeoutMedium, TestRetryIntervalMedium).ShouldNot(HaveOccurred()) + + // expect no dns records + Consistently(func() []v1alpha1.DNSRecord { + dnsRecords := v1alpha1.DNSRecordList{} + err := k8sClient.List(ctx, &dnsRecords, client.InNamespace(dnsPolicy.GetNamespace())) + Expect(err).ToNot(HaveOccurred()) + return dnsRecords.Items + }, time.Second*15, time.Second).Should(BeEmpty()) + }) + }) Context("valid target with no gateway status", func() { @@ -306,11 +355,11 @@ var _ = Describe("DNSPolicy", Ordered, func() { } gateway.Status.Addresses = []gatewayv1beta1.GatewayAddress{ { - Type: testutil.Pointer(mgcgateway.MultiClusterIPAddressType), + Type: testutil.Pointer(utils.MultiClusterIPAddressType), Value: TestClusterNameOne + "/" + TestIPAddressOne, }, { - Type: testutil.Pointer(mgcgateway.MultiClusterIPAddressType), + Type: testutil.Pointer(utils.MultiClusterIPAddressType), Value: TestClusterNameTwo + "/" + TestIPAddressTwo, }, }