From 9009a386646f1956b841b45835ff5533f231d768 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patryk=20Ma=C5=82ek?= Date: Fri, 7 Apr 2023 12:50:53 +0200 Subject: [PATCH] chore: remove support for netv1beta1.Ingress --- .../generators/controllers/networking/main.go | 22 +- .../configuration/object_references.go | 18 - .../configuration/zz_generated_controllers.go | 196 ---- internal/controllers/utils/conversion.go | 29 - internal/controllers/utils/conversion_test.go | 9 +- internal/dataplane/parser/ingressrules.go | 9 - .../dataplane/parser/ingressrules_test.go | 13 +- internal/dataplane/parser/parser.go | 1 - internal/dataplane/parser/parser_test.go | 899 ++++++++++-------- .../dataplane/parser/translate_ingress.go | 159 ---- .../parser/translate_ingress_test.go | 387 -------- internal/manager/conditions.go | 16 - internal/manager/conditions_test.go | 47 +- internal/manager/config.go | 5 +- internal/manager/controllerdef.go | 19 - internal/store/fake_store.go | 10 - internal/store/fake_store_test.go | 75 +- internal/store/store.go | 40 - internal/store/store_test.go | 52 - internal/util/objectmeta_test.go | 6 +- test/e2e/features_test.go | 4 +- test/e2e/helpers_test.go | 4 +- test/e2e/istio_test.go | 4 +- test/integration/config_error_event_test.go | 6 +- test/integration/consumer_test.go | 32 +- test/integration/helpers_test.go | 37 +- test/integration/ingress_https_test.go | 56 +- test/integration/ingress_test.go | 98 +- test/integration/kongingress_test.go | 4 +- test/integration/plugin_test.go | 56 +- test/internal/helpers/ingress.go | 23 - 31 files changed, 624 insertions(+), 1712 deletions(-) delete mode 100644 test/internal/helpers/ingress.go diff --git a/hack/generators/controllers/networking/main.go b/hack/generators/controllers/networking/main.go index 4773b923f9..111ffaafe8 100644 --- a/hack/generators/controllers/networking/main.go +++ b/hack/generators/controllers/networking/main.go @@ -16,9 +16,8 @@ import ( const ( outputFile = "../../internal/controllers/configuration/zz_generated_controllers.go" - corev1 = "k8s.io/api/core/v1" - netv1 = "k8s.io/api/networking/v1" - netv1beta1 = "k8s.io/api/networking/v1beta1" + corev1 = "k8s.io/api/core/v1" + netv1 = "k8s.io/api/networking/v1" kongv1 = "github.com/kong/kubernetes-ingress-controller/v2/pkg/apis/configuration/v1" kongv1beta1 = "github.com/kong/kubernetes-ingress-controller/v2/api/configuration/v1beta1" @@ -89,22 +88,6 @@ var inputControllersNeeded = &typesNeeded{ AcceptsIngressClassNameSpec: false, RBACVerbs: []string{"get", "list", "watch"}, }, - typeNeeded{ - Group: "networking.k8s.io", - Version: "v1beta1", - Kind: "Ingress", - PackageImportAlias: "netv1beta1", - PackageAlias: "NetV1Beta1", - Package: netv1beta1, - Plural: "ingresses", - CacheType: "IngressV1beta1", - NeedsStatusPermissions: true, - CapableOfStatusUpdates: true, - AcceptsIngressClassNameAnnotation: true, - AcceptsIngressClassNameSpec: true, - NeedsUpdateReferences: true, - RBACVerbs: []string{"get", "list", "watch"}, - }, typeNeeded{ Group: "configuration.konghq.com", Version: "v1", @@ -378,7 +361,6 @@ import ( "github.com/go-logr/logr" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" diff --git a/internal/controllers/configuration/object_references.go b/internal/controllers/configuration/object_references.go index 2b98f64d5d..87bed09448 100644 --- a/internal/controllers/configuration/object_references.go +++ b/internal/controllers/configuration/object_references.go @@ -5,7 +5,6 @@ import ( corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/client" @@ -32,8 +31,6 @@ func updateReferredObjects( referredSecretList = listCoreV1ServiceReferredSecrets(obj) case *netv1.Ingress: referredSecretList = listNetV1IngressReferredSecrets(obj) - case *netv1beta1.Ingress: - referredSecretList = listNetV1beta1IngressReferredSecrets(obj) case *kongv1.KongPlugin: referredSecretList = listKongPluginReferredSecrets(obj) case *kongv1.KongClusterPlugin: @@ -83,21 +80,6 @@ func listNetV1IngressReferredSecrets(ingress *netv1.Ingress) []types.NamespacedN return referredSecretNames } -func listNetV1beta1IngressReferredSecrets(ingress *netv1beta1.Ingress) []types.NamespacedName { - referredSecretNames := make([]types.NamespacedName, 0, len(ingress.Spec.TLS)) - for _, tls := range ingress.Spec.TLS { - if tls.SecretName == "" { - continue - } - nsName := types.NamespacedName{ - Namespace: ingress.Namespace, - Name: tls.SecretName, - } - referredSecretNames = append(referredSecretNames, nsName) - } - return referredSecretNames -} - func listKongPluginReferredSecrets(plugin *kongv1.KongPlugin) []types.NamespacedName { referredSecretNames := make([]types.NamespacedName, 0, 1) if plugin.ConfigFrom != nil { diff --git a/internal/controllers/configuration/zz_generated_controllers.go b/internal/controllers/configuration/zz_generated_controllers.go index 21506815d9..363e532482 100644 --- a/internal/controllers/configuration/zz_generated_controllers.go +++ b/internal/controllers/configuration/zz_generated_controllers.go @@ -26,7 +26,6 @@ import ( "github.com/go-logr/logr" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" @@ -495,201 +494,6 @@ func (r *NetV1IngressClassReconciler) Reconcile(ctx context.Context, req ctrl.Re return ctrl.Result{}, nil } -// ----------------------------------------------------------------------------- -// NetV1Beta1 Ingress - Reconciler -// ----------------------------------------------------------------------------- - -// NetV1Beta1IngressReconciler reconciles Ingress resources -type NetV1Beta1IngressReconciler struct { - client.Client - - Log logr.Logger - Scheme *runtime.Scheme - DataplaneClient *dataplane.KongClient - CacheSyncTimeout time.Duration - - DataplaneAddressFinder *dataplane.AddressFinder - StatusQueue *status.Queue - - IngressClassName string - DisableIngressClassLookups bool - ReferenceIndexers ctrlref.CacheIndexers -} - -// SetupWithManager sets up the controller with the Manager. -func (r *NetV1Beta1IngressReconciler) SetupWithManager(mgr ctrl.Manager) error { - c, err := controller.New("NetV1Beta1Ingress", mgr, controller.Options{ - Reconciler: r, - LogConstructor: func(_ *reconcile.Request) logr.Logger { - return r.Log - }, - CacheSyncTimeout: r.CacheSyncTimeout, - }) - if err != nil { - return err - } - // if configured, start the status updater controller - if r.StatusQueue != nil { - if err := c.Watch( - &source.Channel{Source: r.StatusQueue.Subscribe(schema.GroupVersionKind{ - Group: "networking.k8s.io", - Version: "v1beta1", - Kind: "Ingress", - })}, - &handler.EnqueueRequestForObject{}, - ); err != nil { - return err - } - } - if !r.DisableIngressClassLookups { - err = c.Watch( - &source.Kind{Type: &netv1.IngressClass{}}, - handler.EnqueueRequestsFromMapFunc(r.listClassless), - predicate.NewPredicateFuncs(ctrlutils.IsDefaultIngressClass), - ) - if err != nil { - return err - } - } - preds := ctrlutils.GeneratePredicateFuncsForIngressClassFilter(r.IngressClassName) - return c.Watch( - &source.Kind{Type: &netv1beta1.Ingress{}}, - &handler.EnqueueRequestForObject{}, - preds, - ) -} - -// listClassless finds and reconciles all objects without ingress class information -func (r *NetV1Beta1IngressReconciler) listClassless(obj client.Object) []reconcile.Request { - resourceList := &netv1beta1.IngressList{} - if err := r.Client.List(context.Background(), resourceList); err != nil { - r.Log.Error(err, "failed to list classless ingresses") - return nil - } - var recs []reconcile.Request - for i, resource := range resourceList.Items { - if ctrlutils.IsIngressClassEmpty(&resourceList.Items[i]) { - recs = append(recs, reconcile.Request{ - NamespacedName: types.NamespacedName{ - Namespace: resource.Namespace, - Name: resource.Name, - }, - }) - } - } - return recs -} - -//+kubebuilder:rbac:groups=networking.k8s.io,resources=ingresses,verbs=get;list;watch -//+kubebuilder:rbac:groups=networking.k8s.io,resources=ingresses/status,verbs=get;update;patch - -// Reconcile processes the watched objects -func (r *NetV1Beta1IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := r.Log.WithValues("NetV1Beta1Ingress", req.NamespacedName) - - // get the relevant object - obj := new(netv1beta1.Ingress) - if err := r.Get(ctx, req.NamespacedName, obj); err != nil { - if apierrors.IsNotFound(err) { - obj.Namespace = req.Namespace - obj.Name = req.Name - - // remove reference record where the Ingress is the referrer - if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil { - return ctrl.Result{}, err - } - - return ctrl.Result{}, r.DataplaneClient.DeleteObject(obj) - } - return ctrl.Result{}, err - } - log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name) - - // clean the object up if it's being deleted - if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) { - log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "Ingress", "namespace", req.Namespace, "name", req.Name) - - // remove reference record where the Ingress is the referrer - if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil { - return ctrl.Result{}, err - } - - objectExistsInCache, err := r.DataplaneClient.ObjectExists(obj) - if err != nil { - return ctrl.Result{}, err - } - if objectExistsInCache { - if err := r.DataplaneClient.DeleteObject(obj); err != nil { - return ctrl.Result{}, err - } - return ctrl.Result{Requeue: true}, nil // wait until the object is no longer present in the cache - } - return ctrl.Result{}, nil - } - - class := new(netv1.IngressClass) - if !r.DisableIngressClassLookups { - if err := r.Get(ctx, types.NamespacedName{Name: r.IngressClassName}, class); err != nil { - // we log this without taking action to support legacy configurations that only set ingressClassName or - // used the class annotation and did not create a corresponding IngressClass. We only need this to determine - // if the IngressClass is default or to configure default settings, and can assume no/no additional defaults - // if none exists. - log.V(util.DebugLevel).Info("could not retrieve IngressClass", "ingressclass", r.IngressClassName) - } - } - // if the object is not configured with our ingress.class, then we need to ensure it's removed from the cache - if !ctrlutils.MatchesIngressClass(obj, r.IngressClassName, ctrlutils.IsDefaultIngressClass(class)) { - log.V(util.DebugLevel).Info("object missing ingress class, ensuring it's removed from configuration", - "namespace", req.Namespace, "name", req.Name, "class", r.IngressClassName) - return ctrl.Result{}, r.DataplaneClient.DeleteObject(obj) - } else { - log.V(util.DebugLevel).Info("object has matching ingress class", "namespace", req.Namespace, "name", req.Name, - "class", r.IngressClassName) - } - - // update the kong Admin API with the changes - if err := r.DataplaneClient.UpdateObject(obj); err != nil { - return ctrl.Result{}, err - } - // update reference relationship from the Ingress to other objects. - if err := updateReferredObjects(ctx, r.Client, r.ReferenceIndexers, r.DataplaneClient, obj); err != nil { - if apierrors.IsNotFound(err) { - // reconcile again if the secret does not exist yet - return ctrl.Result{ - Requeue: true, - }, nil - } - return ctrl.Result{}, err - } - // if status updates are enabled report the status for the object - if r.DataplaneClient.AreKubernetesObjectReportsEnabled() { - log.V(util.DebugLevel).Info("determining whether data-plane configuration has succeeded", "namespace", req.Namespace, "name", req.Name) - - if !r.DataplaneClient.KubernetesObjectIsConfigured(obj) { - log.V(util.DebugLevel).Info("resource not yet configured in the data-plane", "namespace", req.Namespace, "name", req.Name) - return ctrl.Result{Requeue: true}, nil // requeue until the object has been properly configured - } - - log.V(util.DebugLevel).Info("determining gateway addresses for object status updates", "namespace", req.Namespace, "name", req.Name) - addrs, err := r.DataplaneAddressFinder.GetLoadBalancerAddresses(ctx) - if err != nil { - return ctrl.Result{}, err - } - - log.V(util.DebugLevel).Info("found addresses for data-plane updating object status", "namespace", req.Namespace, "name", req.Name) - updateNeeded, err := ctrlutils.UpdateLoadBalancerIngress(obj, addrs) - if err != nil { - return ctrl.Result{}, fmt.Errorf("failed to update load balancer address: %w", err) - } - if updateNeeded { - return ctrl.Result{}, r.Status().Update(ctx, obj) - } - log.V(util.DebugLevel).Info("status update not needed", "namespace", req.Namespace, "name", req.Name) - } - - return ctrl.Result{}, nil -} - // ----------------------------------------------------------------------------- // KongV1 KongIngress - Reconciler // ----------------------------------------------------------------------------- diff --git a/internal/controllers/utils/conversion.go b/internal/controllers/utils/conversion.go index daa492f37c..1e74c29b72 100644 --- a/internal/controllers/utils/conversion.go +++ b/internal/controllers/utils/conversion.go @@ -6,7 +6,6 @@ import ( corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" "sigs.k8s.io/controller-runtime/pkg/client" kongv1beta1 "github.com/kong/kubernetes-ingress-controller/v2/pkg/apis/configuration/v1beta1" @@ -36,8 +35,6 @@ func UpdateLoadBalancerIngress( obj.Status.LoadBalancer.Ingress = netV1ToCoreV1LoadBalancerIngress(newAddresses) case *kongv1beta1.UDPIngress: obj.Status.LoadBalancer.Ingress = netV1ToCoreV1LoadBalancerIngress(newAddresses) - case *netv1beta1.Ingress: - obj.Status.LoadBalancer.Ingress = netV1ToV1beta1LoadBalancerIngress(newAddresses) default: return false, fmt.Errorf("unsupported ingress type: %T", obj) } @@ -45,18 +42,6 @@ func UpdateLoadBalancerIngress( return true, nil } -func netV1ToV1beta1LoadBalancerIngress(in []netv1.IngressLoadBalancerIngress) []netv1beta1.IngressLoadBalancerIngress { - out := make([]netv1beta1.IngressLoadBalancerIngress, 0, len(in)) - for _, i := range in { - out = append(out, netv1beta1.IngressLoadBalancerIngress{ - IP: i.IP, - Hostname: i.Hostname, - // consciously omitting ports as we do not populate them - }) - } - return out -} - func netV1ToCoreV1LoadBalancerIngress(in []netv1.IngressLoadBalancerIngress) []corev1.LoadBalancerIngress { out := make([]corev1.LoadBalancerIngress, 0, len(in)) for _, i := range in { @@ -77,25 +62,11 @@ func ingressToNetV1LoadBalancerIngressStatus(in any) ([]netv1.IngressLoadBalance return coreV1ToNetV1LoadBalancerIngress(obj.Status.LoadBalancer.Ingress), nil case *kongv1beta1.UDPIngress: return coreV1ToNetV1LoadBalancerIngress(obj.Status.LoadBalancer.Ingress), nil - case *netv1beta1.Ingress: - return v1beta1ToNetV1LoadBalancerIngress(obj.Status.LoadBalancer.Ingress), nil default: return nil, fmt.Errorf("unsupported ingress type: %T", obj) } } -func v1beta1ToNetV1LoadBalancerIngress(in []netv1beta1.IngressLoadBalancerIngress) []netv1.IngressLoadBalancerIngress { - out := make([]netv1.IngressLoadBalancerIngress, 0, len(in)) - for _, i := range in { - out = append(out, netv1.IngressLoadBalancerIngress{ - IP: i.IP, - Hostname: i.Hostname, - // consciously omitting ports as we do not populate them - }) - } - return out -} - func coreV1ToNetV1LoadBalancerIngress(in []corev1.LoadBalancerIngress) []netv1.IngressLoadBalancerIngress { out := make([]netv1.IngressLoadBalancerIngress, 0, len(in)) for _, i := range in { diff --git a/internal/controllers/utils/conversion_test.go b/internal/controllers/utils/conversion_test.go index 3c63ad7a78..4f6d66c88b 100644 --- a/internal/controllers/utils/conversion_test.go +++ b/internal/controllers/utils/conversion_test.go @@ -8,7 +8,6 @@ import ( "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" "sigs.k8s.io/controller-runtime/pkg/client" kongv1beta1 "github.com/kong/kubernetes-ingress-controller/v2/pkg/apis/configuration/v1beta1" @@ -34,10 +33,10 @@ func TestUpdateLoadBalancerIngress(t *testing.T) { }, }, }, - &netv1beta1.Ingress{ - Status: netv1beta1.IngressStatus{ - LoadBalancer: netv1beta1.IngressLoadBalancerStatus{ - Ingress: []netv1beta1.IngressLoadBalancerIngress{ + &netv1.Ingress{ + Status: netv1.IngressStatus{ + LoadBalancer: netv1.IngressLoadBalancerStatus{ + Ingress: []netv1.IngressLoadBalancerIngress{ { IP: oldIP, Hostname: oldHostname, diff --git a/internal/dataplane/parser/ingressrules.go b/internal/dataplane/parser/ingressrules.go index 216e202746..b89e594133 100644 --- a/internal/dataplane/parser/ingressrules.go +++ b/internal/dataplane/parser/ingressrules.go @@ -8,7 +8,6 @@ import ( "github.com/sirupsen/logrus" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/client" @@ -330,11 +329,3 @@ func servicesAllUseTheSameKongAnnotations( return match } - -func v1beta1toV1TLS(tlsSections []netv1beta1.IngressTLS) []netv1.IngressTLS { - var v1 []netv1.IngressTLS - for _, item := range tlsSections { - v1 = append(v1, netv1.IngressTLS{Hosts: item.Hosts, SecretName: item.SecretName}) - } - return v1 -} diff --git a/internal/dataplane/parser/ingressrules_test.go b/internal/dataplane/parser/ingressrules_test.go index 998033b692..e28b09ab41 100644 --- a/internal/dataplane/parser/ingressrules_test.go +++ b/internal/dataplane/parser/ingressrules_test.go @@ -12,7 +12,6 @@ import ( "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/uuid" "sigs.k8s.io/controller-runtime/pkg/client" @@ -168,11 +167,11 @@ func TestMergeIngressRules(t *testing.T) { } } -func TestAddFromIngressV1beta1TLS(t *testing.T) { - parentIngress := &netv1beta1.Ingress{ObjectMeta: metav1.ObjectMeta{Namespace: "foo"}} +func TestAddFromIngressV1TLS(t *testing.T) { + parentIngress := &netv1.Ingress{ObjectMeta: metav1.ObjectMeta{Namespace: "foo"}} type args struct { - tlsSections []netv1beta1.IngressTLS + tlsSections []netv1.IngressTLS } tests := []struct { name string @@ -182,7 +181,7 @@ func TestAddFromIngressV1beta1TLS(t *testing.T) { { name: "different secrets with no overlapping hosts", args: args{ - tlsSections: []netv1beta1.IngressTLS{ + tlsSections: []netv1.IngressTLS{ { Hosts: []string{ "1.example.com", @@ -207,7 +206,7 @@ func TestAddFromIngressV1beta1TLS(t *testing.T) { { name: "different secrets with one overlapping host", args: args{ - tlsSections: []netv1beta1.IngressTLS{ + tlsSections: []netv1.IngressTLS{ { Hosts: []string{ "1.example.com", @@ -233,7 +232,7 @@ func TestAddFromIngressV1beta1TLS(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { m := newSecretNameToSNIs() - m.addFromIngressV1TLS(v1beta1toV1TLS(tt.args.tlsSections), parentIngress) + m.addFromIngressV1TLS(tt.args.tlsSections, parentIngress) for k, v := range tt.want { assert.ElementsMatch(t, v.parents, m.Parents(k)) diff --git a/internal/dataplane/parser/parser.go b/internal/dataplane/parser/parser.go index 6bb5e7ba51..990e8a743b 100644 --- a/internal/dataplane/parser/parser.go +++ b/internal/dataplane/parser/parser.go @@ -82,7 +82,6 @@ func NewParser( func (p *Parser) Build() (*kongstate.KongState, []failures.ResourceFailure) { // parse and merge all rules together from all Kubernetes API sources ingressRules := mergeIngressRules( - p.ingressRulesFromIngressV1beta1(), p.ingressRulesFromIngressV1(), p.ingressRulesFromTCPIngressV1beta1(), p.ingressRulesFromUDPIngressV1beta1(), diff --git a/internal/dataplane/parser/parser_test.go b/internal/dataplane/parser/parser_test.go index 75cc7750f2..59b82bf9d1 100644 --- a/internal/dataplane/parser/parser_test.go +++ b/internal/dataplane/parser/parser_test.go @@ -14,7 +14,6 @@ import ( "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" @@ -311,7 +310,7 @@ func TestSecretConfigurationPlugin(t *testing.T) { }, }, }, - IngressesV1beta1: []*netv1beta1.Ingress{ + IngressesV1: []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -321,18 +320,22 @@ func TestSecretConfigurationPlugin(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -351,18 +354,22 @@ func TestSecretConfigurationPlugin(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.net", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1015,7 +1022,7 @@ func TestCACertificate(t *testing.T) { func TestServiceClientCertificate(t *testing.T) { assert := assert.New(t) t.Run("valid client-cert annotation", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -1024,18 +1031,22 @@ func TestServiceClientCertificate(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1043,7 +1054,7 @@ func TestServiceClientCertificate(t *testing.T) { }, }, }, - TLS: []netv1beta1.IngressTLS{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -1078,9 +1089,9 @@ func TestServiceClientCertificate(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Secrets: secrets, - Services: services, + IngressesV1: ingresses, + Secrets: secrets, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1097,7 +1108,7 @@ func TestServiceClientCertificate(t *testing.T) { *state.Services[0].ClientCertificate.ID) }) t.Run("client-cert secret doesn't exist", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -1106,18 +1117,22 @@ func TestServiceClientCertificate(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1125,7 +1140,7 @@ func TestServiceClientCertificate(t *testing.T) { }, }, }, - TLS: []netv1beta1.IngressTLS{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -1148,8 +1163,8 @@ func TestServiceClientCertificate(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1167,7 +1182,7 @@ func TestServiceClientCertificate(t *testing.T) { func TestKongRouteAnnotations(t *testing.T) { assert := assert.New(t) t.Run("strip-path annotation is correctly processed (true)", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -1177,18 +1192,22 @@ func TestKongRouteAnnotations(t *testing.T) { annotations.IngressClassKey: "kong", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1209,8 +1228,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1251,7 +1270,7 @@ func TestKongRouteAnnotations(t *testing.T) { }, state.Services[0].Routes[0].Route) }) t.Run("strip-path annotation is correctly processed (false)", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -1261,18 +1280,22 @@ func TestKongRouteAnnotations(t *testing.T) { "konghq.com/strip-path": "false", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1293,8 +1316,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1336,7 +1359,7 @@ func TestKongRouteAnnotations(t *testing.T) { }) t.Run("https-redirect-status-code annotation is correctly processed", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -1346,18 +1369,22 @@ func TestKongRouteAnnotations(t *testing.T) { "konghq.com/https-redirect-status-code": "301", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1378,8 +1405,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1422,7 +1449,7 @@ func TestKongRouteAnnotations(t *testing.T) { }) t.Run("bad https-redirect-status-code annotation is ignored", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -1432,18 +1459,22 @@ func TestKongRouteAnnotations(t *testing.T) { "konghq.com/https-redirect-status-code": "whoops", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1464,8 +1495,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1507,7 +1538,7 @@ func TestKongRouteAnnotations(t *testing.T) { }) t.Run("preserve-host annotation is correctly processed", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -1517,18 +1548,22 @@ func TestKongRouteAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1549,8 +1584,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1592,7 +1627,7 @@ func TestKongRouteAnnotations(t *testing.T) { }) t.Run("preserve-host annotation with random string is correctly processed", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -1602,18 +1637,22 @@ func TestKongRouteAnnotations(t *testing.T) { "konghq.com/preserve-host": "wiggle wiggle wiggle", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1634,8 +1673,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1677,7 +1716,7 @@ func TestKongRouteAnnotations(t *testing.T) { }) t.Run("regex-priority annotation is correctly processed", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -1687,18 +1726,22 @@ func TestKongRouteAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1719,8 +1762,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1762,7 +1805,7 @@ func TestKongRouteAnnotations(t *testing.T) { }) t.Run("non-integer regex-priority annotation is ignored", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -1772,18 +1815,22 @@ func TestKongRouteAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1804,8 +1851,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1846,7 +1893,7 @@ func TestKongRouteAnnotations(t *testing.T) { }, state.Services[0].Routes[0].Route) }) t.Run("route buffering options are processed (true)", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "route-buffering-test", @@ -1857,18 +1904,22 @@ func TestKongRouteAnnotations(t *testing.T) { "konghq.com/response-buffering": "True", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1889,8 +1940,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -1929,7 +1980,7 @@ func TestKongRouteAnnotations(t *testing.T) { }, state.Services[0].Routes[0].Route) }) t.Run("route buffering options are processed (false)", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "route-buffering-test", @@ -1940,18 +1991,22 @@ func TestKongRouteAnnotations(t *testing.T) { "konghq.com/response-buffering": "False", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -1972,8 +2027,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2012,7 +2067,7 @@ func TestKongRouteAnnotations(t *testing.T) { }, state.Services[0].Routes[0].Route) }) t.Run("route buffering options are not processed with bad annotation values", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "route-buffering-test", @@ -2023,18 +2078,22 @@ func TestKongRouteAnnotations(t *testing.T) { "konghq.com/response-buffering": "invalid-value", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -2055,8 +2114,8 @@ func TestKongRouteAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2075,7 +2134,7 @@ func TestKongRouteAnnotations(t *testing.T) { func TestKongProcessClasslessIngress(t *testing.T) { assert := assert.New(t) t.Run("Kong classless ingress evaluated (true)", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -2084,18 +2143,22 @@ func TestKongProcessClasslessIngress(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -2116,8 +2179,8 @@ func TestKongProcessClasslessIngress(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2129,24 +2192,28 @@ func TestKongProcessClasslessIngress(t *testing.T) { "expected one service to be rendered") }) t.Run("Kong classless ingress evaluated (false)", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", Namespace: "default", }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -2167,8 +2234,8 @@ func TestKongProcessClasslessIngress(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2553,7 +2620,7 @@ func TestKnativeIngressAndPlugins(t *testing.T) { func TestKongServiceAnnotations(t *testing.T) { assert := assert.New(t) t.Run("path annotation is correctly processed", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -2562,18 +2629,22 @@ func TestKongServiceAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -2597,8 +2668,8 @@ func TestKongServiceAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2640,7 +2711,7 @@ func TestKongServiceAnnotations(t *testing.T) { }) t.Run("host-header annotation is correctly processed", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -2649,18 +2720,22 @@ func TestKongServiceAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -2684,8 +2759,8 @@ func TestKongServiceAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2737,7 +2812,7 @@ func TestKongServiceAnnotations(t *testing.T) { t.Run("methods annotation is correctly processed", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "bar", @@ -2747,18 +2822,22 @@ func TestKongServiceAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -2779,8 +2858,8 @@ func TestKongServiceAnnotations(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2826,7 +2905,7 @@ func TestKongServiceAnnotations(t *testing.T) { func TestDefaultBackend(t *testing.T) { assert := assert.New(t) t.Run("default backend is processed correctly", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "ing-with-default-backend", @@ -2835,10 +2914,14 @@ func TestDefaultBackend(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Backend: &netv1beta1.IngressBackend{ - ServiceName: "default-svc", - ServicePort: intstr.FromInt(80), + Spec: netv1.IngressSpec{ + DefaultBackend: &netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "default-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -2853,8 +2936,8 @@ func TestDefaultBackend(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2872,7 +2955,7 @@ func TestDefaultBackend(t *testing.T) { }) t.Run("client-cert secret doesn't exist", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -2881,18 +2964,22 @@ func TestDefaultBackend(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -2900,7 +2987,7 @@ func TestDefaultBackend(t *testing.T) { }, }, }, - TLS: []netv1beta1.IngressTLS{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -2923,8 +3010,8 @@ func TestDefaultBackend(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, + IngressesV1: ingresses, + Services: services, }) assert.Nil(err) p := mustNewParser(t, store) @@ -2942,7 +3029,7 @@ func TestDefaultBackend(t *testing.T) { func TestParserSecret(t *testing.T) { assert := assert.New(t) t.Run("invalid TLS secret", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -2951,8 +3038,8 @@ func TestParserSecret(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -2965,8 +3052,8 @@ func TestParserSecret(t *testing.T) { Name: "bar", Namespace: "default", }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"bar.com"}, @@ -2989,8 +3076,8 @@ func TestParserSecret(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Secrets: secrets, + IngressesV1: ingresses, + Secrets: secrets, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3001,7 +3088,7 @@ func TestParserSecret(t *testing.T) { "expected no certificates to be rendered with empty secret") }) t.Run("duplicate certificates order by time", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3010,8 +3097,8 @@ func TestParserSecret(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -3027,8 +3114,8 @@ func TestParserSecret(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret2", Hosts: []string{"bar.com"}, @@ -3071,8 +3158,8 @@ func TestParserSecret(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Secrets: secrets, + IngressesV1: ingresses, + Secrets: secrets, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3098,7 +3185,7 @@ func TestParserSecret(t *testing.T) { }, state.Certificates[0]) }) t.Run("duplicate certificates order by uid", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3107,8 +3194,8 @@ func TestParserSecret(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -3124,8 +3211,8 @@ func TestParserSecret(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret2", Hosts: []string{"bar.com"}, @@ -3141,8 +3228,8 @@ func TestParserSecret(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret3", Hosts: []string{"baz.com"}, @@ -3200,8 +3287,8 @@ func TestParserSecret(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Secrets: secrets, + IngressesV1: ingresses, + Secrets: secrets, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3227,7 +3314,7 @@ func TestParserSecret(t *testing.T) { }, state.Certificates[0]) }) t.Run("duplicate SNIs", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3236,8 +3323,8 @@ func TestParserSecret(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -3250,8 +3337,8 @@ func TestParserSecret(t *testing.T) { Name: "bar", Namespace: "ns1", }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret2", Hosts: []string{"foo.com"}, @@ -3284,8 +3371,8 @@ func TestParserSecret(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Secrets: secrets, + IngressesV1: ingresses, + Secrets: secrets, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3300,7 +3387,7 @@ func TestParserSecret(t *testing.T) { func TestParserSNI(t *testing.T) { assert := assert.New(t) t.Run("route includes SNI when TLS info present, but not for wildcard hostnames", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3309,24 +3396,28 @@ func TestParserSNI(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"example.com", "*.example.com"}, }, }, - Rules: []netv1beta1.IngressRule{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3335,14 +3426,18 @@ func TestParserSNI(t *testing.T) { }, { Host: "*.example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3367,8 +3462,8 @@ func TestParserSNI(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Secrets: secrets, + IngressesV1: ingresses, + Secrets: secrets, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3403,7 +3498,7 @@ func TestParserSNI(t *testing.T) { }, state.Services[0].Routes[1].Route) }) t.Run("route does not include SNI when TLS info absent", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3412,18 +3507,22 @@ func TestParserSNI(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3436,7 +3535,7 @@ func TestParserSNI(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, + IngressesV1: ingresses, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3464,7 +3563,7 @@ func TestParserHostAliases(t *testing.T) { assert := assert.New(t) annHostAliasesKey := annotations.AnnotationPrefix + annotations.HostAliasesKey t.Run("route Hosts includes Host-Aliases when Host-Aliases are present", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3474,18 +3573,22 @@ func TestParserHostAliases(t *testing.T) { annHostAliasesKey: "*.example.com,*.sample.com,*.illustration.com", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3498,7 +3601,7 @@ func TestParserHostAliases(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, + IngressesV1: ingresses, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3520,7 +3623,7 @@ func TestParserHostAliases(t *testing.T) { }, state.Services[0].Routes[0].Route) }) t.Run("route Hosts remain unmodified when Host-Aliases are not present", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3529,18 +3632,22 @@ func TestParserHostAliases(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3553,7 +3660,7 @@ func TestParserHostAliases(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, + IngressesV1: ingresses, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3575,7 +3682,7 @@ func TestParserHostAliases(t *testing.T) { }, state.Services[0].Routes[0].Route) }) t.Run("route Hosts will not contain duplicates when Host-Aliases duplicates the host", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3585,18 +3692,22 @@ func TestParserHostAliases(t *testing.T) { annHostAliasesKey: "example.com,*.example.com", }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3609,7 +3720,7 @@ func TestParserHostAliases(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, + IngressesV1: ingresses, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3644,7 +3755,7 @@ func TestPluginAnnotations(t *testing.T) { }, }, } - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3654,18 +3765,22 @@ func TestPluginAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3699,9 +3814,9 @@ func TestPluginAnnotations(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Services: services, - KongPlugins: plugins, + IngressesV1: ingresses, + Services: services, + KongPlugins: plugins, }) assert.Nil(err) p := mustNewParser(t, store) @@ -3738,7 +3853,7 @@ func TestPluginAnnotations(t *testing.T) { }, }, } - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3748,18 +3863,22 @@ func TestPluginAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3798,7 +3917,7 @@ func TestPluginAnnotations(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, + IngressesV1: ingresses, Services: services, KongPlugins: plugins, KongClusterPlugins: clusterPlugins, @@ -3823,7 +3942,7 @@ func TestPluginAnnotations(t *testing.T) { }, }, } - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3833,18 +3952,22 @@ func TestPluginAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3870,7 +3993,7 @@ func TestPluginAnnotations(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, + IngressesV1: ingresses, Services: services, KongClusterPlugins: clusterPlugins, }) @@ -3885,7 +4008,7 @@ func TestPluginAnnotations(t *testing.T) { assert.Equal("grpc", *state.Plugins[0].Protocols[0]) }) t.Run("missing plugin", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -3895,18 +4018,22 @@ func TestPluginAnnotations(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ + Spec: netv1.IngressSpec{ + Rules: []netv1.IngressRule{ { Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ + IngressRuleValue: netv1.IngressRuleValue{ + HTTP: &netv1.HTTPIngressRuleValue{ + Paths: []netv1.HTTPIngressPath{ { Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), + Backend: netv1.IngressBackend{ + Service: &netv1.IngressServiceBackend{ + Name: "foo-svc", + Port: netv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -3919,7 +4046,7 @@ func TestPluginAnnotations(t *testing.T) { } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, + IngressesV1: ingresses, }) assert.Nil(err) p := mustNewParser(t, store) @@ -4717,7 +4844,7 @@ func TestPickPort(t *testing.T) { func TestCertificate(t *testing.T) { assert := assert.New(t) t.Run("same host with multiple namespace return the first namespace/secret by asc", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo", @@ -4726,8 +4853,8 @@ func TestCertificate(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -4743,8 +4870,8 @@ func TestCertificate(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -4760,8 +4887,8 @@ func TestCertificate(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret1", Hosts: []string{"foo.com"}, @@ -4820,8 +4947,8 @@ func TestCertificate(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Secrets: secrets, + IngressesV1: ingresses, + Secrets: secrets, }) assert.Nil(err) p := mustNewParser(t, store) @@ -4833,7 +4960,7 @@ func TestCertificate(t *testing.T) { assert.Contains(state.Certificates, fooCertificate) }) t.Run("SNIs slice with same certificate should be ordered by asc", func(t *testing.T) { - ingresses := []*netv1beta1.Ingress{ + ingresses := []*netv1.Ingress{ { ObjectMeta: metav1.ObjectMeta{ Name: "foo3", @@ -4842,8 +4969,8 @@ func TestCertificate(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret", Hosts: []string{"foo3.xxx.com"}, @@ -4859,8 +4986,8 @@ func TestCertificate(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret", Hosts: []string{"foo2.xxx.com"}, @@ -4876,8 +5003,8 @@ func TestCertificate(t *testing.T) { annotations.IngressClassKey: annotations.DefaultIngressClass, }, }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ + Spec: netv1.IngressSpec{ + TLS: []netv1.IngressTLS{ { SecretName: "secret", Hosts: []string{"foo1.xxx.com"}, @@ -4913,8 +5040,8 @@ func TestCertificate(t *testing.T) { }, } store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: ingresses, - Secrets: secrets, + IngressesV1: ingresses, + Secrets: secrets, }) assert.Nil(err) p := mustNewParser(t, store) diff --git a/internal/dataplane/parser/translate_ingress.go b/internal/dataplane/parser/translate_ingress.go index e9d901e9fc..7cd5163c98 100644 --- a/internal/dataplane/parser/translate_ingress.go +++ b/internal/dataplane/parser/translate_ingress.go @@ -7,7 +7,6 @@ import ( "github.com/kong/go-kong/kong" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" "github.com/kong/kubernetes-ingress-controller/v2/internal/annotations" "github.com/kong/kubernetes-ingress-controller/v2/internal/dataplane/kongstate" @@ -29,164 +28,6 @@ var priorityForPath = map[netv1.PathType]int{ netv1.PathTypeImplementationSpecific: 100, } -func (p *Parser) ingressRulesFromIngressV1beta1() ingressRules { - result := newIngressRules() - - ingressList := p.storer.ListIngressesV1beta1() - icp, err := getIngressClassParametersOrDefault(p.storer) - if err != nil { - if !errors.As(err, &store.ErrNotFound{}) { - // anything else is unexpected - p.logger.Errorf("could not find IngressClassParameters, using defaults: %s", err) - } - } - - var allDefaultBackends []netv1beta1.Ingress - sort.SliceStable(ingressList, func(i, j int) bool { - return ingressList[i].CreationTimestamp.Before( - &ingressList[j].CreationTimestamp) - }) - - for _, ingress := range ingressList { - regexPrefix := translators.ControllerPathRegexPrefix - if prefix, ok := ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.RegexPrefixKey]; ok { - regexPrefix = prefix - } - ingressSpec := ingress.Spec - - if ingressSpec.Backend != nil { - allDefaultBackends = append(allDefaultBackends, *ingress) - } - - result.SecretNameToSNIs.addFromIngressV1TLS(v1beta1toV1TLS(ingressSpec.TLS), ingress) - - var objectSuccessfullyParsed bool - for i, rule := range ingressSpec.Rules { - host := rule.Host - if rule.HTTP == nil { - continue - } - for j, rule := range rule.HTTP.Paths { - path := rule.Path - path = maybePrependRegexPrefix(path, regexPrefix, icp.EnableLegacyRegexDetection && p.flagEnabledRegexPathPrefix) - if path == "" { - path = "/" - } - r := kongstate.Route{ - Ingress: util.FromK8sObject(ingress), - Route: kong.Route{ - Name: kong.String(fmt.Sprintf("%s.%s.%d%d", ingress.Namespace, ingress.Name, i, j)), - Paths: kong.StringSlice(path), - StripPath: kong.Bool(false), - PreserveHost: kong.Bool(true), - Protocols: kong.StringSlice("http", "https"), - RegexPriority: kong.Int(0), - RequestBuffering: kong.Bool(true), - ResponseBuffering: kong.Bool(true), - Tags: util.GenerateTagsForObject(ingress), - }, - } - if host != "" { - hosts := kong.StringSlice(host) - r.Hosts = hosts - } - - serviceName := ingress.Namespace + "." + - rule.Backend.ServiceName + "." + - rule.Backend.ServicePort.String() - service, ok := result.ServiceNameToServices[serviceName] - if !ok { - service = kongstate.Service{ - Service: kong.Service{ - Name: kong.String(serviceName), - Host: kong.String(rule.Backend.ServiceName + - "." + ingress.Namespace + "." + - rule.Backend.ServicePort.String() + ".svc"), - Port: kong.Int(DefaultHTTPPort), - Protocol: kong.String("http"), - Path: kong.String("/"), - ConnectTimeout: kong.Int(DefaultServiceTimeout), - ReadTimeout: kong.Int(DefaultServiceTimeout), - WriteTimeout: kong.Int(DefaultServiceTimeout), - Retries: kong.Int(DefaultRetries), - }, - Namespace: ingress.Namespace, - Backends: []kongstate.ServiceBackend{{ - Name: rule.Backend.ServiceName, - PortDef: translators.PortDefFromIntStr(rule.Backend.ServicePort), - }}, - Parent: ingress, - } - } - service.Routes = append(service.Routes, r) - result.ServiceNameToServices[serviceName] = service - result.ServiceNameToParent[serviceName] = ingress - objectSuccessfullyParsed = true - } - } - - if objectSuccessfullyParsed { - p.ReportKubernetesObjectUpdate(ingress) - } - } - - sort.SliceStable(allDefaultBackends, func(i, j int) bool { - return allDefaultBackends[i].CreationTimestamp.Before(&allDefaultBackends[j].CreationTimestamp) - }) - - // Process the default backend - if len(allDefaultBackends) > 0 { - ingress := allDefaultBackends[0] - defaultBackend := allDefaultBackends[0].Spec.Backend - serviceName := allDefaultBackends[0].Namespace + "." + - defaultBackend.ServiceName + "." + - defaultBackend.ServicePort.String() - service, ok := result.ServiceNameToServices[serviceName] - if !ok { - service = kongstate.Service{ - Service: kong.Service{ - Name: kong.String(serviceName), - Host: kong.String(defaultBackend.ServiceName + "." + - ingress.Namespace + "." + - defaultBackend.ServicePort.String() + ".svc"), - Port: kong.Int(DefaultHTTPPort), - Protocol: kong.String("http"), - ConnectTimeout: kong.Int(DefaultServiceTimeout), - ReadTimeout: kong.Int(DefaultServiceTimeout), - WriteTimeout: kong.Int(DefaultServiceTimeout), - Retries: kong.Int(DefaultRetries), - Tags: util.GenerateTagsForObject(result.ServiceNameToParent[serviceName]), - }, - Namespace: ingress.Namespace, - Backends: []kongstate.ServiceBackend{{ - Name: defaultBackend.ServiceName, - PortDef: translators.PortDefFromIntStr(defaultBackend.ServicePort), - }}, - Parent: &ingress, - } - } - r := kongstate.Route{ - Ingress: util.FromK8sObject(&ingress), - Route: kong.Route{ - Name: kong.String(ingress.Namespace + "." + ingress.Name), - Paths: kong.StringSlice("/"), - StripPath: kong.Bool(false), - PreserveHost: kong.Bool(true), - Protocols: kong.StringSlice("http", "https"), - RegexPriority: kong.Int(0), - RequestBuffering: kong.Bool(true), - ResponseBuffering: kong.Bool(true), - Tags: util.GenerateTagsForObject(result.ServiceNameToParent[serviceName]), - }, - } - service.Routes = append(service.Routes, r) - result.ServiceNameToServices[serviceName] = service - result.ServiceNameToParent[serviceName] = &ingress - } - - return result -} - func (p *Parser) ingressRulesFromIngressV1() ingressRules { result := newIngressRules() diff --git a/internal/dataplane/parser/translate_ingress_test.go b/internal/dataplane/parser/translate_ingress_test.go index f5a11ce9eb..f1a5c12021 100644 --- a/internal/dataplane/parser/translate_ingress_test.go +++ b/internal/dataplane/parser/translate_ingress_test.go @@ -6,9 +6,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" "sigs.k8s.io/controller-runtime/pkg/client" "github.com/kong/kubernetes-ingress-controller/v2/internal/annotations" @@ -17,391 +15,6 @@ import ( "github.com/kong/kubernetes-ingress-controller/v2/internal/store" ) -func TestFromIngressV1beta1(t *testing.T) { - assert := assert.New(t) - ingressList := []*netv1beta1.Ingress{ - // 0 - { - ObjectMeta: metav1.ObjectMeta{ - Name: "foo", - Namespace: "foo-namespace", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), - }, - }, - }, - }, - }, - }, - }, - }, - }, - // 1 - { - ObjectMeta: metav1.ObjectMeta{ - Name: "ing-with-tls", - Namespace: "bar-namespace", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - TLS: []netv1beta1.IngressTLS{ - { - Hosts: []string{ - "1.example.com", - "2.example.com", - }, - SecretName: "sooper-secret", - }, - { - Hosts: []string{ - "3.example.com", - "4.example.com", - }, - SecretName: "sooper-secret2", - }, - }, - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), - }, - }, - }, - }, - }, - }, - }, - }, - }, - // 2 - { - ObjectMeta: metav1.ObjectMeta{ - Name: "ing-with-default-backend", - Namespace: "bar-namespace", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - Backend: &netv1beta1.IngressBackend{ - ServiceName: "default-svc", - ServicePort: intstr.FromInt(80), - }, - }, - }, - // 3 - { - ObjectMeta: metav1.ObjectMeta{ - Name: "foo", - Namespace: "foo-namespace", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Path: "/.well-known/acme-challenge/yolo", - Backend: netv1beta1.IngressBackend{ - ServiceName: "cert-manager-solver-pod", - ServicePort: intstr.FromInt(80), - }, - }, - }, - }, - }, - }, - }, - }, - }, - // 4 - { - ObjectMeta: metav1.ObjectMeta{ - Name: "foo", - Namespace: "foo-namespace", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), - }, - }, - }, - }, - }, - }, - }, - }, - }, - // 5 - { - ObjectMeta: metav1.ObjectMeta{ - Name: "baz", - Namespace: "foo-namespace", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{}, - }, - }, - }, - }, - // 6 - { - ObjectMeta: metav1.ObjectMeta{ - Name: "foo", - Namespace: "foo-namespace", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), - }, - }, - }, - }, - }, - }, - { - Host: "example.net", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(8000), - }, - }, - }, - }, - }, - }, - }, - }, - }, - // 7 - { - ObjectMeta: metav1.ObjectMeta{ - Name: "regex-prefix", - Namespace: "foo-namespace", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Path: translators.ControllerPathRegexPrefix + "/foo/\\d{3}", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), - }, - }, - }, - }, - }, - }, - }, - }, - }, - } - - t.Run("no ingress returns empty info", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{}, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - parsedInfo := p.ingressRulesFromIngressV1beta1() - assert.Equal(ingressRules{ - ServiceNameToServices: make(map[string]kongstate.Service), - ServiceNameToParent: make(map[string]client.Object), - SecretNameToSNIs: newSecretNameToSNIs(), - }, parsedInfo) - }) - t.Run("simple ingress rule is parsed", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{ - ingressList[0], - }, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - parsedInfo := p.ingressRulesFromIngressV1beta1() - assert.Equal(1, len(parsedInfo.ServiceNameToServices)) - assert.Equal("foo-svc.foo-namespace.80.svc", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Host) - assert.Equal(80, *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Port) - - assert.Equal("/", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Routes[0].Paths[0]) - assert.Equal("example.com", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Routes[0].Hosts[0]) - }) - t.Run("ingress rule with default backend", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{ingressList[0], ingressList[2]}, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - parsedInfo := p.ingressRulesFromIngressV1beta1() - assert.Equal(2, len(parsedInfo.ServiceNameToServices)) - assert.Equal("foo-svc.foo-namespace.80.svc", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Host) - assert.Equal(80, *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Port) - - assert.Equal("/", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Routes[0].Paths[0]) - assert.Equal("example.com", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Routes[0].Hosts[0]) - - assert.Equal(1, len(parsedInfo.ServiceNameToServices["bar-namespace.default-svc.80"].Routes)) - assert.Equal("/", *parsedInfo.ServiceNameToServices["bar-namespace.default-svc.80"].Routes[0].Paths[0]) - assert.Equal(0, len(parsedInfo.ServiceNameToServices["bar-namespace.default-svc.80"].Routes[0].Hosts)) - }) - t.Run("ingress rule with TLS", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{ - ingressList[1], - }, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - parsedInfo := p.ingressRulesFromIngressV1beta1() - assert.Equal(2, len(parsedInfo.SecretNameToSNIs.Hosts("bar-namespace/sooper-secret"))) - assert.Equal(2, len(parsedInfo.SecretNameToSNIs.Hosts("bar-namespace/sooper-secret2"))) - }) - t.Run("ingress rule with ACME like path has strip_path set to false", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{ - ingressList[3], - }, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - parsedInfo := p.ingressRulesFromIngressV1beta1() - assert.Equal(1, len(parsedInfo.ServiceNameToServices)) - assert.Equal("cert-manager-solver-pod.foo-namespace.80.svc", - *parsedInfo.ServiceNameToServices["foo-namespace.cert-manager-solver-pod.80"].Host) - assert.Equal(80, *parsedInfo.ServiceNameToServices["foo-namespace.cert-manager-solver-pod.80"].Port) - - assert.Equal("/.well-known/acme-challenge/yolo", - *parsedInfo.ServiceNameToServices["foo-namespace.cert-manager-solver-pod.80"].Routes[0].Paths[0]) - assert.Equal("example.com", - *parsedInfo.ServiceNameToServices["foo-namespace.cert-manager-solver-pod.80"].Routes[0].Hosts[0]) - assert.False(*parsedInfo.ServiceNameToServices["foo-namespace.cert-manager-solver-pod.80"].Routes[0].StripPath) - }) - t.Run("ingress with empty path is correctly parsed", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{ - ingressList[4], - }, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - parsedInfo := p.ingressRulesFromIngressV1beta1() - assert.Equal("/", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Routes[0].Paths[0]) - assert.Equal("example.com", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Routes[0].Hosts[0]) - }) - t.Run("empty Ingress rule doesn't cause a panic", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{ - ingressList[5], - }, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - assert.NotPanics(func() { - p.ingressRulesFromIngressV1beta1() - }) - }) - t.Run("Ingress rules with multiple ports for one Service use separate hostnames for each port", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{ - ingressList[6], - }, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - parsedInfo := p.ingressRulesFromIngressV1beta1() - assert.Equal("foo-svc.foo-namespace.80.svc", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Host) - assert.Equal("foo-svc.foo-namespace.8000.svc", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.8000"].Host) - }) - t.Run("Ingress rule with regex prefixed path creates route with Kong regex prefix", func(t *testing.T) { - store, err := store.NewFakeStore(store.FakeObjects{ - IngressesV1beta1: []*netv1beta1.Ingress{ - ingressList[7], - }, - }) - require.NoError(t, err) - p := mustNewParser(t, store) - - parsedInfo := p.ingressRulesFromIngressV1beta1() - assert.Equal(translators.KongPathRegexPrefix+"/foo/\\d{3}", *parsedInfo.ServiceNameToServices["foo-namespace.foo-svc.80"].Routes[0].Paths[0]) - }) -} - func TestFromIngressV1(t *testing.T) { assert := assert.New(t) ingressList := []*netv1.Ingress{ diff --git a/internal/manager/conditions.go b/internal/manager/conditions.go index 0678dbbfb3..99e8e31bc8 100644 --- a/internal/manager/conditions.go +++ b/internal/manager/conditions.go @@ -4,7 +4,6 @@ import ( "fmt" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime/schema" ctrl "sigs.k8s.io/controller-runtime" @@ -17,7 +16,6 @@ type IngressAPI int const ( OtherAPI IngressAPI = iota NetworkingV1 - NetworkingV1beta1 ) // IngressControllerConditions negotiates the best Ingress API version supported by both KIC and the k8s apiserver and @@ -37,11 +35,6 @@ func NewIngressControllersConditions(cfg *Config, mapper meta.RESTMapper) (*Ingr return &IngressControllerConditions{chosenVersion: chosenVersion, cfg: cfg}, nil } -// IngressNetV1beta1Enabled returns true if the chosen ingress API version is networking.k8s.io/v1beta1 and it's enabled. -func (s *IngressControllerConditions) IngressNetV1beta1Enabled() bool { - return s.chosenVersion == NetworkingV1beta1 && s.cfg.IngressNetV1beta1Enabled -} - // IngressNetV1Enabled returns true if the chosen ingress API version is networking.k8s.io/v1 and it's enabled. func (s *IngressControllerConditions) IngressNetV1Enabled() bool { return s.chosenVersion == NetworkingV1 && s.cfg.IngressNetV1Enabled @@ -60,11 +53,6 @@ func negotiateIngressAPI(config *Config, mapper meta.RESTMapper) (IngressAPI, er Version: netv1.SchemeGroupVersion.Version, Resource: "ingresses", }, - NetworkingV1beta1: { - Group: netv1beta1.SchemeGroupVersion.Group, - Version: netv1beta1.SchemeGroupVersion.Version, - Resource: "ingresses", - }, } // Please note the order is not arbitrary - the most mature APIs will get picked first. @@ -72,10 +60,6 @@ func negotiateIngressAPI(config *Config, mapper meta.RESTMapper) (IngressAPI, er allowedAPIs = append(allowedAPIs, NetworkingV1) } - if config.IngressNetV1beta1Enabled { - allowedAPIs = append(allowedAPIs, NetworkingV1beta1) - } - for _, candidate := range allowedAPIs { if ctrlutils.CRDExists(mapper, candidateAPIs[candidate]) { return candidate, nil diff --git a/internal/manager/conditions_test.go b/internal/manager/conditions_test.go index f0bf57bc1d..e2d8fe4a35 100644 --- a/internal/manager/conditions_test.go +++ b/internal/manager/conditions_test.go @@ -6,7 +6,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime/schema" @@ -15,18 +14,11 @@ import ( func TestIngressControllerConditions(t *testing.T) { const kind = "Ingress" - var ( - networkingV1 = schema.GroupVersionResource{ - Group: netv1.SchemeGroupVersion.Group, - Version: netv1.SchemeGroupVersion.Version, - Resource: "ingresses", - } - networkingV1beta1 = schema.GroupVersionResource{ - Group: netv1beta1.SchemeGroupVersion.Group, - Version: netv1beta1.SchemeGroupVersion.Version, - Resource: "ingresses", - } - ) + networkingV1 := schema.GroupVersionResource{ + Group: netv1.SchemeGroupVersion.Group, + Version: netv1.SchemeGroupVersion.Version, + Resource: "ingresses", + } type ingressTestOpts struct { enabled bool @@ -38,40 +30,32 @@ func TestIngressControllerConditions(t *testing.T) { ingressNetV1 ingressTestOpts ingressClassNetV1 ingressTestOpts - ingressNetV1beta ingressTestOpts expectIngressNetV1 bool expectIngressClassNetV1 bool - expectIngressNetV1beta bool expectError bool }{ { name: "netV1_takes_precedence_over_all", ingressNetV1: ingressTestOpts{enabled: true, crdInstalled: true}, ingressClassNetV1: ingressTestOpts{enabled: true, crdInstalled: true}, - ingressNetV1beta: ingressTestOpts{enabled: true, crdInstalled: true}, expectIngressNetV1: true, expectIngressClassNetV1: true, }, { - name: "netV1beta_wins_when_netV1_crds_not_installed", - ingressNetV1: ingressTestOpts{enabled: true}, - ingressClassNetV1: ingressTestOpts{enabled: true}, - ingressNetV1beta: ingressTestOpts{enabled: true, crdInstalled: true}, - expectIngressNetV1beta: true, + name: "netV1beta_wins_when_netV1_crds_not_installed", + ingressNetV1: ingressTestOpts{enabled: true}, + ingressClassNetV1: ingressTestOpts{enabled: true}, }, { - name: "netV1_not_picked_when_disabled", - ingressNetV1: ingressTestOpts{crdInstalled: true}, - ingressClassNetV1: ingressTestOpts{enabled: true, crdInstalled: true}, - ingressNetV1beta: ingressTestOpts{enabled: true, crdInstalled: true}, - expectIngressNetV1beta: true, + name: "netV1_not_picked_when_disabled", + ingressNetV1: ingressTestOpts{crdInstalled: true}, + ingressClassNetV1: ingressTestOpts{enabled: true, crdInstalled: true}, }, { name: "no_crds_installed", ingressNetV1: ingressTestOpts{enabled: true}, ingressClassNetV1: ingressTestOpts{enabled: true}, - ingressNetV1beta: ingressTestOpts{enabled: true}, expectError: true, }, } @@ -86,19 +70,11 @@ func TestIngressControllerConditions(t *testing.T) { Kind: kind, }, meta.RESTScopeRoot) } - if tc.ingressNetV1beta.crdInstalled { - restMapper.Add(schema.GroupVersionKind{ - Group: networkingV1beta1.Group, - Version: networkingV1beta1.Version, - Kind: kind, - }, meta.RESTScopeRoot) - } conditions, err := manager.NewIngressControllersConditions( &manager.Config{ IngressNetV1Enabled: tc.ingressNetV1.enabled, IngressClassNetV1Enabled: tc.ingressClassNetV1.enabled, - IngressNetV1beta1Enabled: tc.ingressNetV1beta.enabled, }, restMapper, ) @@ -110,7 +86,6 @@ func TestIngressControllerConditions(t *testing.T) { require.NoError(t, err) assert.Equal(t, tc.expectIngressNetV1, conditions.IngressNetV1Enabled()) assert.Equal(t, tc.expectIngressClassNetV1, conditions.IngressClassNetV1Enabled()) - assert.Equal(t, tc.expectIngressNetV1beta, conditions.IngressNetV1beta1Enabled()) }) } } diff --git a/internal/manager/config.go b/internal/manager/config.go index 5279a8e046..880684008e 100644 --- a/internal/manager/config.go +++ b/internal/manager/config.go @@ -81,7 +81,6 @@ type Config struct { UpdateStatus bool // Kubernetes API toggling - IngressNetV1beta1Enabled bool IngressNetV1Enabled bool IngressClassNetV1Enabled bool IngressClassParametersEnabled bool @@ -202,7 +201,6 @@ func (c *Config) FlagSet() *pflag.FlagSet { flagSet.BoolVar(&c.IngressNetV1Enabled, "enable-controller-ingress-networkingv1", true, "Enable the networking.k8s.io/v1 Ingress controller.") flagSet.BoolVar(&c.IngressClassNetV1Enabled, "enable-controller-ingress-class-networkingv1", true, "Enable the networking.k8s.io/v1 IngressClass controller.") flagSet.BoolVar(&c.IngressClassParametersEnabled, "enable-controller-ingress-class-parameters", true, "Enable the IngressClassParameters controller.") - flagSet.BoolVar(&c.IngressNetV1beta1Enabled, "enable-controller-ingress-networkingv1beta1", true, "Enable the networking.k8s.io/v1beta1 Ingress controller.") flagSet.BoolVar(&c.UDPIngressEnabled, "enable-controller-udpingress", true, "Enable the UDPIngress controller.") flagSet.BoolVar(&c.TCPIngressEnabled, "enable-controller-tcpingress", true, "Enable the TCPIngress controller.") flagSet.BoolVar(&c.KnativeIngressEnabled, "enable-controller-knativeingress", true, "Enable the KnativeIngress controller.") @@ -267,6 +265,9 @@ func (c *Config) FlagSet() *pflag.FlagSet { _ = flagSet.Bool("enable-controller-ingress-extensionsv1beta1", true, "DEPRECATED: Enable the extensions/v1beta1 Ingress controller.") _ = flagSet.MarkDeprecated("enable-controller-ingress-extensionsv1beta1", "DEPRECATED: Enable the extensions/v1beta1 Ingress controller.") + _ = flagSet.Bool("enable-controller-ingress-networkingv1beta1", true, "Enable the networking.k8s.io/v1beta1 Ingress controller.") + _ = flagSet.MarkDeprecated("enable-controller-ingress-networkingv1beta1", "Enable the networking.k8s.io/v1beta1 Ingress controller.") + c.flagSet = flagSet return flagSet } diff --git a/internal/manager/controllerdef.go b/internal/manager/controllerdef.go index 85914c0424..0fac74ffef 100644 --- a/internal/manager/controllerdef.go +++ b/internal/manager/controllerdef.go @@ -129,25 +129,6 @@ func setupControllers( ReferenceIndexers: referenceIndexers, }, }, - { - Enabled: ingressConditions.IngressNetV1beta1Enabled(), - Controller: &configuration.NetV1Beta1IngressReconciler{ - Client: mgr.GetClient(), - Log: ctrl.Log.WithName("controllers").WithName("Ingress").WithName("netv1beta1"), - Scheme: mgr.GetScheme(), - DataplaneClient: dataplaneClient, - IngressClassName: c.IngressClassName, - // this and other resources that support class get an additional watch to account for the default - // IngressClass even if the cluster uses an Ingress version other than networking/v1 (the only version - // we support IngressClass for). we pass the v1 controller disable flag to them to avoid - // https://github.com/Kong/kubernetes-ingress-controller/issues/2563 - DisableIngressClassLookups: !c.IngressClassNetV1Enabled, - StatusQueue: kubernetesStatusQueue, - DataplaneAddressFinder: dataplaneAddressFinder, - CacheSyncTimeout: c.CacheSyncTimeout, - ReferenceIndexers: referenceIndexers, - }, - }, { Enabled: c.ServiceEnabled, Controller: &configuration.CoreV1ServiceReconciler{ diff --git a/internal/store/fake_store.go b/internal/store/fake_store.go index 518117bcc8..1ecb1f39cd 100644 --- a/internal/store/fake_store.go +++ b/internal/store/fake_store.go @@ -6,7 +6,6 @@ import ( "github.com/sirupsen/logrus" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" "k8s.io/client-go/tools/cache" knative "knative.dev/networking/pkg/apis/networking/v1alpha1" gatewayv1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2" @@ -32,7 +31,6 @@ func clusterResourceKeyFunc(obj interface{}) (string, error) { // FakeObjects can be used to populate a fake Store. type FakeObjects struct { - IngressesV1beta1 []*netv1beta1.Ingress IngressesV1 []*netv1.Ingress IngressClassesV1 []*netv1.IngressClass HTTPRoutes []*gatewayv1beta1.HTTPRoute @@ -62,13 +60,6 @@ func NewFakeStore( ) (Storer, error) { var s Storer - ingressV1beta1Store := cache.NewStore(keyFunc) - for _, ingress := range objects.IngressesV1beta1 { - err := ingressV1beta1Store.Add(ingress) - if err != nil { - return nil, err - } - } ingressV1Store := cache.NewStore(keyFunc) for _, ingress := range objects.IngressesV1 { err := ingressV1Store.Add(ingress) @@ -204,7 +195,6 @@ func NewFakeStore( } s = Store{ stores: CacheStores{ - IngressV1beta1: ingressV1beta1Store, IngressV1: ingressV1Store, IngressClassV1: ingressClassV1Store, HTTPRoute: httprouteStore, diff --git a/internal/store/fake_store_test.go b/internal/store/fake_store_test.go index b33d5fcddf..45d56079a9 100644 --- a/internal/store/fake_store_test.go +++ b/internal/store/fake_store_test.go @@ -8,7 +8,6 @@ import ( "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" knative "knative.dev/networking/pkg/apis/networking/v1alpha1" @@ -61,7 +60,7 @@ func TestKeyFunc(t *testing.T) { { want: "default/foo", args: args{ - obj: netv1beta1.Ingress{ + obj: netv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: "foo", Namespace: "default", @@ -91,77 +90,6 @@ func TestFakeStoreEmpty(t *testing.T) { assert.NotNil(store) } -func TestFakeStoreIngressV1beta1(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - - ingresses := []*netv1beta1.Ingress{ - { - ObjectMeta: metav1.ObjectMeta{ - Name: "foo", - Namespace: "default", - Annotations: map[string]string{ - annotations.IngressClassKey: annotations.DefaultIngressClass, - }, - }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Path: "/", - Backend: netv1beta1.IngressBackend{ - ServiceName: "foo-svc", - ServicePort: intstr.FromInt(80), - }, - }, - }, - }, - }, - }, - }, - }, - }, - { - ObjectMeta: metav1.ObjectMeta{ - Name: "bar", - Namespace: "default", - Annotations: map[string]string{ - annotations.IngressClassKey: "not-kong", - }, - }, - Spec: netv1beta1.IngressSpec{ - Rules: []netv1beta1.IngressRule{ - { - Host: "example.com", - IngressRuleValue: netv1beta1.IngressRuleValue{ - HTTP: &netv1beta1.HTTPIngressRuleValue{ - Paths: []netv1beta1.HTTPIngressPath{ - { - Path: "/bar", - Backend: netv1beta1.IngressBackend{ - ServiceName: "bar-svc", - ServicePort: intstr.FromInt(80), - }, - }, - }, - }, - }, - }, - }, - }, - }, - } - store, err := NewFakeStore(FakeObjects{IngressesV1beta1: ingresses}) - require.Nil(err) - require.NotNil(store) - assert.Len(store.ListIngressesV1beta1(), 1) - assert.Len(store.ListIngressesV1(), 0) -} - func TestFakeStoreIngressV1(t *testing.T) { assert := assert.New(t) require := require.New(t) @@ -264,7 +192,6 @@ func TestFakeStoreIngressV1(t *testing.T) { require.Nil(err) require.NotNil(store) assert.Len(store.ListIngressesV1(), 2) - assert.Len(store.ListIngressesV1beta1(), 0) } func TestFakeStoreIngressClassV1(t *testing.T) { diff --git a/internal/store/store.go b/internal/store/store.go index 93b853fc4e..0cd4dd4a61 100644 --- a/internal/store/store.go +++ b/internal/store/store.go @@ -18,7 +18,6 @@ package store import ( "fmt" - "reflect" "sort" "strings" "sync" @@ -26,7 +25,6 @@ import ( "github.com/sirupsen/logrus" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructuredscheme" "k8s.io/apimachinery/pkg/labels" @@ -82,7 +80,6 @@ type Storer interface { GetIngressClassParametersV1Alpha1(ingressClass *netv1.IngressClass) (*kongv1alpha1.IngressClassParameters, error) GetGateway(namespace string, name string) (*gatewayv1beta1.Gateway, error) - ListIngressesV1beta1() []*netv1beta1.Ingress ListIngressesV1() []*netv1.Ingress ListIngressClassesV1() []*netv1.IngressClass ListIngressClassParametersV1Alpha1() []*kongv1alpha1.IngressClassParameters @@ -126,7 +123,6 @@ var _ Storer = Store{} // the Ingress Controller reads. type CacheStores struct { // Core Kubernetes Stores - IngressV1beta1 cache.Store IngressV1 cache.Store IngressClassV1 cache.Store Service cache.Store @@ -161,7 +157,6 @@ type CacheStores struct { func NewCacheStores() CacheStores { return CacheStores{ // Core Kubernetes Stores - IngressV1beta1: cache.NewStore(keyFunc), IngressV1: cache.NewStore(keyFunc), IngressClassV1: cache.NewStore(clusterResourceKeyFunc), Service: cache.NewStore(keyFunc), @@ -241,8 +236,6 @@ func (c CacheStores) Get(obj runtime.Object) (item interface{}, exists bool, err // ---------------------------------------------------------------------------- // Kubernetes Core API Support // ---------------------------------------------------------------------------- - case *netv1beta1.Ingress: - return c.IngressV1beta1.Get(obj) case *netv1.Ingress: return c.IngressV1.Get(obj) case *netv1.IngressClass: @@ -306,8 +299,6 @@ func (c CacheStores) Add(obj runtime.Object) error { // ---------------------------------------------------------------------------- // Kubernetes Core API Support // ---------------------------------------------------------------------------- - case *netv1beta1.Ingress: - return c.IngressV1beta1.Add(obj) case *netv1.Ingress: return c.IngressV1.Add(obj) case *netv1.IngressClass: @@ -372,8 +363,6 @@ func (c CacheStores) Delete(obj runtime.Object) error { // ---------------------------------------------------------------------------- // Kubernetes Core API Support // ---------------------------------------------------------------------------- - case *netv1beta1.Ingress: - return c.IngressV1beta1.Delete(obj) case *netv1.Ingress: return c.IngressV1.Delete(obj) case *netv1.IngressClass: @@ -550,24 +539,6 @@ func (s Store) ListIngressClassParametersV1Alpha1() []*kongv1alpha1.IngressClass return classParams } -// ListIngressesV1beta1 returns the list of Ingresses in the Ingress v1beta1 store. -func (s Store) ListIngressesV1beta1() []*netv1beta1.Ingress { - // filter ingress rules - var ingresses []*netv1beta1.Ingress - for _, item := range s.stores.IngressV1beta1.List() { - ing := s.networkingIngressV1Beta1(item) - if !s.isValidIngressClass(&ing.ObjectMeta, annotations.IngressClassKey, s.ingressClassMatching) { - continue - } - ingresses = append(ingresses, ing) - } - sort.SliceStable(ingresses, func(i, j int) bool { - return strings.Compare(fmt.Sprintf("%s/%s", ingresses[i].Namespace, ingresses[i].Name), - fmt.Sprintf("%s/%s", ingresses[j].Namespace, ingresses[j].Name)) < 0 - }) - return ingresses -} - // ListHTTPRoutes returns the list of HTTPRoutes in the HTTPRoute cache store. func (s Store) ListHTTPRoutes() ([]*gatewayv1beta1.HTTPRoute, error) { var httproutes []*gatewayv1beta1.HTTPRoute @@ -1002,17 +973,6 @@ func (s Store) ListCACerts() ([]*corev1.Secret, error) { return secrets, nil } -func (s Store) networkingIngressV1Beta1(obj interface{}) *netv1beta1.Ingress { - switch obj := obj.(type) { - case *netv1beta1.Ingress: - return obj - - default: - s.logger.Errorf("cannot convert to networking v1beta1 Ingress: unsupported type: %v", reflect.TypeOf(obj)) - return nil - } -} - // getIngressClassHandling returns annotations.ExactOrEmptyClassMatch if an IngressClass is the default class, or // annotations.ExactClassMatch if the IngressClass is not default or does not exist. func (s Store) getIngressClassHandling() annotations.ClassMatching { diff --git a/internal/store/store_test.go b/internal/store/store_test.go index 5f2f179c8b..fb9c2466ec 100644 --- a/internal/store/store_test.go +++ b/internal/store/store_test.go @@ -1,70 +1,19 @@ package store import ( - "reflect" "strings" "testing" - "github.com/sirupsen/logrus" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" appsv1 "k8s.io/api/apps/v1" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" "github.com/kong/kubernetes-ingress-controller/v2/internal/annotations" ) -func TestNetworkingIngressV1Beta1(t *testing.T) { - type args struct { - obj interface{} - } - tests := []struct { - name string - args args - want *netv1beta1.Ingress - }{ - { - name: "networking.Ingress is returned as is", - args: args{ - obj: &netv1beta1.Ingress{}, - }, - want: &netv1beta1.Ingress{}, - }, - { - name: "returns nil if a non-ingress object is passed in", - args: args{ - &corev1.Service{ - Spec: corev1.ServiceSpec{ - Type: corev1.ServiceTypeClusterIP, - ClusterIP: "1.1.1.1", - Ports: []corev1.ServicePort{ - { - Name: "default", - TargetPort: intstr.FromString("port-1"), - }, - }, - }, - }, - }, - want: nil, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - s := Store{ - logger: logrus.New(), - } - if got := s.networkingIngressV1Beta1(tt.args.obj); !reflect.DeepEqual(got, tt.want) { - t.Errorf("networkingIngressV1Beta1() = %v, want %v", got, tt.want) - } - }) - } -} - func TestCacheStoresGet(t *testing.T) { t.Log("configuring some yaml objects to store in the cache") svcYAML := []byte(`--- @@ -119,7 +68,6 @@ spec: t.Log("verifying the integrity of the cache store") assert.Len(t, cs.IngressV1.List(), 1) assert.Len(t, cs.Service.List(), 1) - assert.Len(t, cs.IngressV1beta1.List(), 0) assert.Len(t, cs.KongIngress.List(), 0) _, exists, err = cs.Get(&corev1.Service{ObjectMeta: metav1.ObjectMeta{Namespace: "doesntexist", Name: "doesntexist"}}) assert.NoError(t, err) diff --git a/internal/util/objectmeta_test.go b/internal/util/objectmeta_test.go index 65562d1bce..06b5374deb 100644 --- a/internal/util/objectmeta_test.go +++ b/internal/util/objectmeta_test.go @@ -4,7 +4,7 @@ import ( "testing" "github.com/stretchr/testify/assert" - netv1beta1 "k8s.io/api/networking/v1beta1" + netv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "sigs.k8s.io/controller-runtime/pkg/client" ) @@ -17,7 +17,7 @@ func TestFromK8sObject(t *testing.T) { }{ { name: "empty annotations", - in: &netv1beta1.Ingress{ + in: &netv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: "name", Namespace: "namespace", @@ -31,7 +31,7 @@ func TestFromK8sObject(t *testing.T) { }, { name: "has annotations", - in: &netv1beta1.Ingress{ + in: &netv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: "name", Namespace: "namespace", diff --git a/test/e2e/features_test.go b/test/e2e/features_test.go index 500b178040..f8e2b1fa2a 100644 --- a/test/e2e/features_test.go +++ b/test/e2e/features_test.go @@ -523,9 +523,7 @@ func TestDefaultIngressClass(t *testing.T) { require.NoError(t, err) t.Logf("creating a classless ingress for service %s", service.Name) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/abbosiysaltanati", map[string]string{ + ingress := generators.NewIngressForService("/abbosiysaltanati", map[string]string{ "konghq.com/strip-path": "true", }, service) require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), kongDeployment.Namespace, ingress)) diff --git a/test/e2e/helpers_test.go b/test/e2e/helpers_test.go index 1731e57792..9b4ccead81 100644 --- a/test/e2e/helpers_test.go +++ b/test/e2e/helpers_test.go @@ -351,9 +351,7 @@ func deployIngress(ctx context.Context, t *testing.T, env environments.Environme _, err = c.ConfigurationV1().KongIngresses(corev1.NamespaceDefault).Create(ctx, king, metav1.CreateOptions{}) require.NoError(t, err) t.Logf("creating an ingress for service %s with ingress.class %s", service.Name, ingressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/httpbin", map[string]string{ + ingress := generators.NewIngressForService("/httpbin", map[string]string{ annotations.IngressClassKey: ingressClass, "konghq.com/strip-path": "true", "konghq.com/override": kongIngressName, diff --git a/test/e2e/istio_test.go b/test/e2e/istio_test.go index a259f5dbde..aad7edccb4 100644 --- a/test/e2e/istio_test.go +++ b/test/e2e/istio_test.go @@ -132,9 +132,7 @@ func TestIstioWithKongIngressGateway(t *testing.T) { require.NoError(t, err) t.Logf("creating an ingress resource for service %s with ingress.class %s", service.Name, ingressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/httpbin", map[string]string{ + ingress := generators.NewIngressForService("/httpbin", map[string]string{ annotations.IngressClassKey: ingressClass, "konghq.com/strip-path": "true", }, service) diff --git a/test/integration/config_error_event_test.go b/test/integration/config_error_event_test.go index 3c7ade8972..7c82104de2 100644 --- a/test/integration/config_error_event_test.go +++ b/test/integration/config_error_event_test.go @@ -54,10 +54,8 @@ func TestConfigErrorEventGeneration(t *testing.T) { cleaner.Add(service) t.Logf("creating an ingress for service %s with invalid configuration", service.Name) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) // GRPC routes cannot have methods, only HTTP, and we don't catch this as a translation error - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/bar", map[string]string{ + ingress := generators.NewIngressForService("/bar", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/strip-path": "true", "konghq.com/protocols": "grpcs", @@ -66,7 +64,7 @@ func TestConfigErrorEventGeneration(t *testing.T) { t.Log("deploying ingress") require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress)) - helpers.AddIngressToCleaner(cleaner, ingress) + cleaner.Add(ingress) t.Log("checking ingress event creation") require.Eventually(t, func() bool { diff --git a/test/integration/consumer_test.go b/test/integration/consumer_test.go index 8383452cd9..0cc1604a6b 100644 --- a/test/integration/consumer_test.go +++ b/test/integration/consumer_test.go @@ -17,8 +17,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" - netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "github.com/kong/kubernetes-ingress-controller/v2/internal/annotations" @@ -49,14 +47,12 @@ func TestConsumerCredential(t *testing.T) { cleaner.Add(service) t.Logf("creating an ingress for service %s with ingress.class %s", service.Name, consts.IngressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/test_consumer_credential", map[string]string{ + ingress := generators.NewIngressForService("/test_consumer_credential", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/strip-path": "true", }, service) require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress)) - helpers.AddIngressToCleaner(cleaner, ingress) + cleaner.Add(ingress) t.Log("waiting for routes from Ingress to be operational") assert.Eventually(t, func() bool { @@ -91,25 +87,13 @@ func TestConsumerCredential(t *testing.T) { t.Logf("updating Ingress to use plugin %s", kongplugin.Name) require.Eventually(t, func() bool { - switch obj := ingress.(type) { - case *netv1.Ingress: - ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return false - } - ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongplugin.Name - _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) - return err == nil - case *netv1beta1.Ingress: - ingress, err := env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return false - } - ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongplugin.Name - _, err = env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) - return err == nil + ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, ingress.Name, metav1.GetOptions{}) + if err != nil { + return false } - return false + ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongplugin.Name + _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) + return err == nil }, ingressWait, waitTick) t.Logf("validating that plugin %s was successfully configured", kongplugin.Name) diff --git a/test/integration/helpers_test.go b/test/integration/helpers_test.go index 63d911dd75..117afacb69 100644 --- a/test/integration/helpers_test.go +++ b/test/integration/helpers_test.go @@ -13,10 +13,8 @@ import ( "github.com/samber/lo" "github.com/stretchr/testify/require" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/util/retry" gatewayv1beta1 "sigs.k8s.io/gateway-api/apis/v1beta1" gatewayclient "sigs.k8s.io/gateway-api/pkg/client/clientset/versioned" @@ -389,30 +387,15 @@ func GetVerifyProgrammedConditionCallback(t *testing.T, // setIngressClassNameWithRetry changes Ingress.Spec.IngressClassName to specified value // and retries if update conflict happens. -func setIngressClassNameWithRetry(ctx context.Context, namespace string, obj runtime.Object, ingressClassName *string) error { - switch ingress := obj.(type) { - case *netv1.Ingress: - ingressClient := env.Cluster().Client().NetworkingV1().Ingresses(namespace) - return retry.RetryOnConflict(retry.DefaultRetry, func() error { - ingress, err := ingressClient.Get(ctx, ingress.ObjectMeta.Name, metav1.GetOptions{}) - if err != nil { - return err - } - ingress.Spec.IngressClassName = ingressClassName - _, err = ingressClient.Update(ctx, ingress, metav1.UpdateOptions{}) - return err - }) - case *netv1beta1.Ingress: - ingressClient := env.Cluster().Client().NetworkingV1beta1().Ingresses(namespace) - return retry.RetryOnConflict(retry.DefaultRetry, func() error { - ingress, err := ingressClient.Get(ctx, ingress.ObjectMeta.Name, metav1.GetOptions{}) - if err != nil { - return err - } - ingress.Spec.IngressClassName = ingressClassName - _, err = ingressClient.Update(ctx, ingress, metav1.UpdateOptions{}) +func setIngressClassNameWithRetry(ctx context.Context, namespace string, ingress *netv1.Ingress, ingressClassName *string) error { + ingressClient := env.Cluster().Client().NetworkingV1().Ingresses(namespace) + return retry.RetryOnConflict(retry.DefaultRetry, func() error { + ingress, err := ingressClient.Get(ctx, ingress.Name, metav1.GetOptions{}) + if err != nil { return err - }) - } - return fmt.Errorf("unsupported GroupVersionKind %v", obj.GetObjectKind()) + } + ingress.Spec.IngressClassName = ingressClassName + _, err = ingressClient.Update(ctx, ingress, metav1.UpdateOptions{}) + return err + }) } diff --git a/test/integration/ingress_https_test.go b/test/integration/ingress_https_test.go index b4235533d9..43f856118c 100644 --- a/test/integration/ingress_https_test.go +++ b/test/integration/ingress_https_test.go @@ -20,7 +20,6 @@ import ( "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" @@ -155,15 +154,13 @@ func TestHTTPSRedirect(t *testing.T) { cleaner.Add(service) t.Logf("exposing Service %s via Ingress", service.Name) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/test_https_redirect", map[string]string{ + ingress := generators.NewIngressForService("/test_https_redirect", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/protocols": "https", "konghq.com/https-redirect-status-code": "301", }, service) assert.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress)) - helpers.AddIngressToCleaner(cleaner, ingress) + cleaner.Add(ingress) t.Log("waiting for Ingress to be operational and properly redirect") client := &http.Client{ @@ -226,34 +223,20 @@ func TestHTTPSIngress(t *testing.T) { cleaner.Add(service) t.Logf("creating an ingress for service %s with ingress.class %s", service.Name, consts.IngressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress1 := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/foo", map[string]string{ + ingress1 := generators.NewIngressForService("/foo", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/strip-path": "true", }, service) - ingress2 := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/bar", map[string]string{ + ingress2 := generators.NewIngressForService("/bar", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/strip-path": "true", }, service) t.Log("configuring ingress tls spec") - switch obj := ingress1.(type) { - case *netv1.Ingress: - obj.Spec.TLS = []netv1.IngressTLS{{SecretName: "secret1", Hosts: []string{"foo.example"}}} - obj.ObjectMeta.Name = "ingress1" - case *netv1beta1.Ingress: - obj.Spec.TLS = []netv1beta1.IngressTLS{{SecretName: "secret1", Hosts: []string{"foo.example"}}} - obj.ObjectMeta.Name = "ingress1" - } - switch obj := ingress2.(type) { - case *netv1.Ingress: - obj.Spec.TLS = []netv1.IngressTLS{{SecretName: "secret2", Hosts: []string{"bar.example"}}} - obj.ObjectMeta.Name = "ingress2" - case *netv1beta1.Ingress: - obj.Spec.TLS = []netv1beta1.IngressTLS{{SecretName: "secret2", Hosts: []string{"bar.example"}}} - obj.ObjectMeta.Name = "ingress2" - } + ingress1.Spec.TLS = []netv1.IngressTLS{{SecretName: "secret1", Hosts: []string{"foo.example"}}} + ingress1.ObjectMeta.Name = "ingress1" + ingress2.Spec.TLS = []netv1.IngressTLS{{SecretName: "secret2", Hosts: []string{"bar.example"}}} + ingress2.ObjectMeta.Name = "ingress2" t.Log("configuring secrets") secrets := []*corev1.Secret{ @@ -287,7 +270,7 @@ func TestHTTPSIngress(t *testing.T) { // so here we interleave the creating process of deploying 2 ingresses and secrets. t.Log("deploying secrets and ingresses") require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress1)) - helpers.AddIngressToCleaner(cleaner, ingress1) + cleaner.Add(ingress1) secret1, err := env.Cluster().Client().CoreV1().Secrets(ns.Name).Create(ctx, secrets[0], metav1.CreateOptions{}) assert.NoError(t, err) @@ -298,7 +281,7 @@ func TestHTTPSIngress(t *testing.T) { cleaner.Add(secret2) require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress2)) - helpers.AddIngressToCleaner(cleaner, ingress2) + cleaner.Add(ingress2) t.Log("checking first ingress status readiness") require.Eventually(t, func() bool { @@ -387,20 +370,11 @@ func TestHTTPSIngress(t *testing.T) { return false }, ingressWait, waitTick) - switch obj := ingress2.(type) { - case *netv1.Ingress: - ingress2, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - assert.NoError(t, err) - ingress2.ObjectMeta.Annotations["konghq.com/snis"] = "bar.example" - _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress2, metav1.UpdateOptions{}) - assert.NoError(t, err) - case *netv1beta1.Ingress: - ingress2, err := env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - assert.NoError(t, err) - ingress2.ObjectMeta.Annotations["konghq.com/snis"] = "bar.example" - _, err = env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Update(ctx, ingress2, metav1.UpdateOptions{}) - assert.NoError(t, err) - } + ingress2, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, ingress2.Name, metav1.GetOptions{}) + assert.NoError(t, err) + ingress2.ObjectMeta.Annotations["konghq.com/snis"] = "bar.example" + _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress2, metav1.UpdateOptions{}) + assert.NoError(t, err) t.Log("confirm Ingress no longer routes without matching SNI") assert.Eventually(t, func() bool { diff --git a/test/integration/ingress_test.go b/test/integration/ingress_test.go index aaba2c53e3..89a1de03c9 100644 --- a/test/integration/ingress_test.go +++ b/test/integration/ingress_test.go @@ -21,7 +21,6 @@ import ( "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/util/retry" @@ -63,14 +62,12 @@ func TestIngressEssentials(t *testing.T) { cleaner.Add(service) t.Logf("creating an ingress for service %s with ingress.class %s", service.Name, consts.IngressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/test_ingress_essentials", map[string]string{ + ingress := generators.NewIngressForService("/test_ingress_essentials", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/strip-path": "true", }, service) require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress)) - helpers.AddIngressToCleaner(cleaner, ingress) + cleaner.Add(ingress) t.Log("waiting for updated ingress status to include IP") require.Eventually(t, func() bool { @@ -102,59 +99,31 @@ func TestIngressEssentials(t *testing.T) { }, ingressWait, waitTick) t.Logf("removing the ingress.class annotation %q from ingress", consts.IngressClass) - switch obj := ingress.(type) { - case *netv1.Ingress: - err := retry.RetryOnConflict(retry.DefaultRetry, func() error { - ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return err - } - delete(ingress.ObjectMeta.Annotations, annotations.IngressClassKey) - _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) - return err - }) - require.NoError(t, err) - case *netv1beta1.Ingress: - err := retry.RetryOnConflict(retry.DefaultRetry, func() error { - ingress, err := env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return err - } - delete(ingress.ObjectMeta.Annotations, annotations.IngressClassKey) - _, err = env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) + err = retry.RetryOnConflict(retry.DefaultRetry, func() error { + ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, ingress.Name, metav1.GetOptions{}) + if err != nil { return err - }) - require.NoError(t, err) - } + } + delete(ingress.ObjectMeta.Annotations, annotations.IngressClassKey) + _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) + return err + }) + require.NoError(t, err) t.Logf("verifying that removing the ingress.class annotation %q from ingress causes routes to disconnect", consts.IngressClass) helpers.EventuallyExpectHTTP404WithNoRoute(t, proxyURL, "/test_ingress_essentials", ingressWait, waitTick, nil) t.Logf("putting the ingress.class annotation %q back on ingress", consts.IngressClass) - switch obj := ingress.(type) { - case *netv1.Ingress: - err := retry.RetryOnConflict(retry.DefaultRetry, func() error { - ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return err - } - ingress.ObjectMeta.Annotations[annotations.IngressClassKey] = consts.IngressClass - _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) - return err - }) - require.NoError(t, err) - case *netv1beta1.Ingress: - err := retry.RetryOnConflict(retry.DefaultRetry, func() error { - ingress, err := env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return err - } - ingress.ObjectMeta.Annotations[annotations.IngressClassKey] = consts.IngressClass - _, err = env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) + err = retry.RetryOnConflict(retry.DefaultRetry, func() error { + ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, ingress.Name, metav1.GetOptions{}) + if err != nil { return err - }) - require.NoError(t, err) - } + } + ingress.ObjectMeta.Annotations[annotations.IngressClassKey] = consts.IngressClass + _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) + return err + }) + require.NoError(t, err) t.Log("waiting for routes from Ingress to be operational after reintroducing ingress class annotation") require.Eventually(t, func() bool { @@ -203,15 +172,13 @@ func TestGRPCIngressEssentials(t *testing.T) { cleaner.Add(service) t.Logf("creating an ingress for service %s with ingress.class %s", service.Name, consts.IngressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/", map[string]string{ + ingress := generators.NewIngressForService("/", map[string]string{ annotations.IngressClassKey: consts.IngressClass, annotations.AnnotationPrefix + annotations.ProtocolsKey: "grpc,grpcs", annotations.AnnotationPrefix + annotations.StripPathKey: "false", }, service) require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress)) - helpers.AddIngressToCleaner(cleaner, ingress) + cleaner.Add(ingress) t.Log("waiting for updated ingress status to include IP") require.Eventually(t, func() bool { @@ -259,17 +226,10 @@ func TestIngressClassNameSpec(t *testing.T) { cleaner.Add(service) t.Logf("creating an ingress for service %s with ingress.class %s", service.Name, consts.IngressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/test_ingressclassname_spec/", map[string]string{"konghq.com/strip-path": "true"}, service) - switch obj := ingress.(type) { - case *netv1.Ingress: - obj.Spec.IngressClassName = kong.String(consts.IngressClass) - case *netv1beta1.Ingress: - obj.Spec.IngressClassName = kong.String(consts.IngressClass) - } + ingress := generators.NewIngressForService("/test_ingressclassname_spec/", map[string]string{"konghq.com/strip-path": "true"}, service) + ingress.Spec.IngressClassName = kong.String(consts.IngressClass) require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress)) - helpers.AddIngressToCleaner(cleaner, ingress) + cleaner.Add(ingress) t.Log("waiting for routes from Ingress to be operational") defer func() { @@ -362,14 +322,12 @@ func TestIngressNamespaces(t *testing.T) { cleaner.Add(service) t.Logf("creating an ingress for service %s with ingress.class %s", service.Name, consts.IngressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/elsewhere", map[string]string{ + ingress := generators.NewIngressForService("/elsewhere", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/strip-path": "true", }, service) require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress)) - helpers.AddIngressToCleaner(cleaner, ingress) + cleaner.Add(ingress) t.Log("waiting for routes from Ingress to be operational") require.Eventually(t, func() bool { @@ -490,7 +448,7 @@ func TestIngressStatusUpdatesExtended(t *testing.T) { t.Logf("creating ingress %s and verifying status updates", ing.Name) createdIngress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Create(ctx, ing, metav1.CreateOptions{}) require.NoError(t, err) - helpers.AddIngressToCleaner(cleaner, createdIngress) + cleaner.Add(createdIngress) } t.Log("verifying that an ingress with periods in the name has its status populated") diff --git a/test/integration/kongingress_test.go b/test/integration/kongingress_test.go index c2a9573f13..f1a572946b 100644 --- a/test/integration/kongingress_test.go +++ b/test/integration/kongingress_test.go @@ -58,9 +58,7 @@ func TestKongIngressEssentials(t *testing.T) { }() t.Logf("routing to service %s via Ingress", service.Name) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/test_kongingress_essentials", map[string]string{ + ingress := generators.NewIngressForService("/test_kongingress_essentials", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/strip-path": "true", }, service) diff --git a/test/integration/plugin_test.go b/test/integration/plugin_test.go index d397eea8a9..c1ac36e0fd 100644 --- a/test/integration/plugin_test.go +++ b/test/integration/plugin_test.go @@ -19,8 +19,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" corev1 "k8s.io/api/core/v1" - netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -54,14 +52,12 @@ func TestPluginEssentials(t *testing.T) { cleaner.Add(service) t.Logf("creating an ingress for service %s with ingress.class %s", service.Name, consts.IngressClass) - kubernetesVersion, err := env.Cluster().Version() - require.NoError(t, err) - ingress := generators.NewIngressForServiceWithClusterVersion(kubernetesVersion, "/test_plugin_essentials", map[string]string{ + ingress := generators.NewIngressForService("/test_plugin_essentials", map[string]string{ annotations.IngressClassKey: consts.IngressClass, "konghq.com/strip-path": "true", }, service) require.NoError(t, clusters.DeployIngress(ctx, env.Cluster(), ns.Name, ingress)) - helpers.AddIngressToCleaner(cleaner, ingress) + cleaner.Add(ingress) t.Log("waiting for routes from Ingress to be operational") assert.Eventually(t, func() bool { @@ -116,25 +112,13 @@ func TestPluginEssentials(t *testing.T) { t.Logf("updating Ingress to use plugin %s", kongplugin.Name) require.Eventually(t, func() bool { - switch obj := ingress.(type) { - case *netv1.Ingress: - ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return false - } - ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongplugin.Name - _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) - return err == nil - case *netv1beta1.Ingress: - ingress, err := env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return false - } - ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongplugin.Name - _, err = env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) - return err == nil + ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, ingress.Name, metav1.GetOptions{}) + if err != nil { + return false } - return false + ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongplugin.Name + _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) + return err == nil }, ingressWait, waitTick) t.Logf("validating that plugin %s was successfully configured", kongplugin.Name) @@ -150,25 +134,13 @@ func TestPluginEssentials(t *testing.T) { t.Logf("updating Ingress to use cluster plugin %s", kongclusterplugin.Name) require.Eventually(t, func() bool { - switch obj := ingress.(type) { - case *netv1.Ingress: - ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return false - } - ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongclusterplugin.Name - _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) - return err == nil - case *netv1beta1.Ingress: - ingress, err := env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Get(ctx, obj.Name, metav1.GetOptions{}) - if err != nil { - return false - } - ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongclusterplugin.Name - _, err = env.Cluster().Client().NetworkingV1beta1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) - return err == nil + ingress, err := env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Get(ctx, ingress.Name, metav1.GetOptions{}) + if err != nil { + return false } - return false + ingress.ObjectMeta.Annotations[annotations.AnnotationPrefix+annotations.PluginsKey] = kongclusterplugin.Name + _, err = env.Cluster().Client().NetworkingV1().Ingresses(ns.Name).Update(ctx, ingress, metav1.UpdateOptions{}) + return err == nil }, ingressWait, waitTick) t.Logf("validating that clusterplugin %s was successfully configured", kongclusterplugin.Name) diff --git a/test/internal/helpers/ingress.go b/test/internal/helpers/ingress.go deleted file mode 100644 index 99c2c28b07..0000000000 --- a/test/internal/helpers/ingress.go +++ /dev/null @@ -1,23 +0,0 @@ -package helpers - -import ( - "fmt" - - "github.com/kong/kubernetes-testing-framework/pkg/clusters" - netv1 "k8s.io/api/networking/v1" - netv1beta1 "k8s.io/api/networking/v1beta1" - "k8s.io/apimachinery/pkg/runtime" -) - -// AddIngressToCleaner adds a runtime.Object to the cleanup list if it is a supported version of Ingress. It panics if the -// runtime.Object is something else. -func AddIngressToCleaner(cleaner *clusters.Cleaner, obj runtime.Object) { - switch i := obj.(type) { - case *netv1.Ingress: - cleaner.Add(i) - case *netv1beta1.Ingress: - cleaner.Add(i) - default: - panic(fmt.Sprintf("%s passed to addIngressToCleaner but is not an Ingress", obj.GetObjectKind())) - } -}