From 958a68ef9bb97acef7e4f56372c177b147065528 Mon Sep 17 00:00:00 2001 From: Swetha Repakula Date: Mon, 26 Apr 2021 12:39:10 -0700 Subject: [PATCH 1/4] Use v1.ServiceBackendPort instead of IntOrString --- cmd/glbc/app/init.go | 10 ++++----- pkg/controller/translator/utils.go | 17 +++++++-------- pkg/controller/translator/utils_test.go | 12 +++++------ pkg/neg/controller.go | 28 ++++++++++++------------- 4 files changed, 31 insertions(+), 36 deletions(-) diff --git a/cmd/glbc/app/init.go b/cmd/glbc/app/init.go index 224ec81ec5..05a0df47cf 100644 --- a/cmd/glbc/app/init.go +++ b/cmd/glbc/app/init.go @@ -24,7 +24,6 @@ import ( v1 "k8s.io/api/core/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/kubernetes" "k8s.io/ingress-gce/pkg/flags" @@ -53,8 +52,7 @@ func DefaultBackendServicePort(kubeClient kubernetes.Interface) utils.ServicePor klog.Fatalf("Failed to verify default backend service: %v", err) } - backendPort := intstr.FromString(flags.F.DefaultSvcPortName) - svcPort := servicePortForDefaultService(svc, backendPort, name) + svcPort := servicePortForDefaultService(svc, flags.F.DefaultSvcPortName, name) if svcPort == nil { klog.Fatalf("could not derive service port for default service: %v", err) } @@ -91,14 +89,14 @@ func IngressClassEnabled(client kubernetes.Interface) bool { } // servicePortForDefaultService returns the service port for the default service; returns nil if not found. -func servicePortForDefaultService(svc *v1.Service, svcPort intstr.IntOrString, name types.NamespacedName) *utils.ServicePort { +func servicePortForDefaultService(svc *v1.Service, svcPortName string, name types.NamespacedName) *utils.ServicePort { // Lookup TargetPort for service port for _, port := range svc.Spec.Ports { - if port.Name == svcPort.String() { + if port.Name == svcPortName { return &utils.ServicePort{ ID: utils.ServicePortID{ Service: name, - Port: svcPort, + Port: networkingv1.ServiceBackendPort{Name: svcPortName}, }, TargetPort: port.TargetPort.StrVal, Port: port.Port, diff --git a/pkg/controller/translator/utils.go b/pkg/controller/translator/utils.go index 3ee011f1ab..f864edd123 100644 --- a/pkg/controller/translator/utils.go +++ b/pkg/controller/translator/utils.go @@ -15,26 +15,23 @@ package translator import ( api_v1 "k8s.io/api/core/v1" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" ) // ServicePort is a helper function that retrieves a port of a Service. -func ServicePort(svc api_v1.Service, port intstr.IntOrString) *api_v1.ServicePort { +func ServicePort(svc api_v1.Service, port v1.ServiceBackendPort) *api_v1.ServicePort { var svcPort *api_v1.ServicePort PortLoop: for _, p := range svc.Spec.Ports { np := p - switch port.Type { - case intstr.Int: - if p.Port == port.IntVal { - svcPort = &np - break PortLoop - } - default: - if p.Name == port.StrVal { + if port.Name != "" { + if p.Name == port.Name { svcPort = &np break PortLoop } + } else if p.Port == port.Number { + svcPort = &np + break PortLoop } } return svcPort diff --git a/pkg/controller/translator/utils_test.go b/pkg/controller/translator/utils_test.go index 3effcb365a..a2ac1e3962 100644 --- a/pkg/controller/translator/utils_test.go +++ b/pkg/controller/translator/utils_test.go @@ -18,7 +18,7 @@ import ( "testing" api_v1 "k8s.io/api/core/v1" - "k8s.io/apimachinery/pkg/util/intstr" + networkingv1 "k8s.io/api/networking/v1" ) var ( @@ -49,12 +49,12 @@ var ( func TestServicePort(t *testing.T) { testCases := []struct { desc string - port intstr.IntOrString + port networkingv1.ServiceBackendPort expected *api_v1.ServicePort }{ { desc: "match on port number", - port: intstr.FromInt(1000), + port: networkingv1.ServiceBackendPort{Number: 1000}, expected: &api_v1.ServicePort{ Name: "foo", Port: 1000, @@ -62,7 +62,7 @@ func TestServicePort(t *testing.T) { }, { desc: "match on port name", - port: intstr.FromString("foo"), + port: networkingv1.ServiceBackendPort{Name: "foo"}, expected: &api_v1.ServicePort{ Name: "foo", Port: 1000, @@ -70,7 +70,7 @@ func TestServicePort(t *testing.T) { }, { desc: "match on last port number", - port: intstr.FromInt(1003), + port: networkingv1.ServiceBackendPort{Number: 1003}, expected: &api_v1.ServicePort{ Name: "qux", Port: 1003, @@ -78,7 +78,7 @@ func TestServicePort(t *testing.T) { }, { desc: "no match", - port: intstr.FromInt(3000), + port: networkingv1.ServiceBackendPort{Number: 3000}, expected: nil, }, } diff --git a/pkg/neg/controller.go b/pkg/neg/controller.go index 695235a945..75b27c1277 100644 --- a/pkg/neg/controller.go +++ b/pkg/neg/controller.go @@ -23,7 +23,7 @@ import ( istioV1alpha3 "istio.io/api/networking/v1alpha3" apiv1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" @@ -202,7 +202,7 @@ func NewController( if runIngress { ingressInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{ AddFunc: func(obj interface{}) { - addIng := obj.(*v1beta1.Ingress) + addIng := obj.(*v1.Ingress) if !utils.IsGLBCIngress(addIng) { klog.V(4).Infof("Ignoring add for ingress %v based on annotation %v", common.NamespacedName(addIng), annotations.IngressClassKey) return @@ -210,7 +210,7 @@ func NewController( negController.enqueueIngressServices(addIng) }, DeleteFunc: func(obj interface{}) { - delIng := obj.(*v1beta1.Ingress) + delIng := obj.(*v1.Ingress) if !utils.IsGLBCIngress(delIng) { klog.V(4).Infof("Ignoring delete for ingress %v based on annotation %v", common.NamespacedName(delIng), annotations.IngressClassKey) return @@ -218,8 +218,8 @@ func NewController( negController.enqueueIngressServices(delIng) }, UpdateFunc: func(old, cur interface{}) { - oldIng := cur.(*v1beta1.Ingress) - curIng := cur.(*v1beta1.Ingress) + oldIng := cur.(*v1.Ingress) + curIng := cur.(*v1.Ingress) if !utils.IsGLBCIngress(curIng) { klog.V(4).Infof("Ignoring update for ingress %v based on annotation %v", common.NamespacedName(curIng), annotations.IngressClassKey) return @@ -572,13 +572,13 @@ func (c *Controller) mergeDefaultBackendServicePortInfoMap(key string, service * return nil } - scanIngress := func(qualify func(*v1beta1.Ingress) bool) error { + scanIngress := func(qualify func(*v1.Ingress) bool) error { for _, m := range c.ingressLister.List() { - ing := *m.(*v1beta1.Ingress) - if qualify(&ing) && ing.Spec.Backend == nil { + ing := *m.(*v1.Ingress) + if qualify(&ing) && ing.Spec.DefaultBackend == nil { svcPortTupleSet := make(negtypes.SvcPortTupleSet) svcPortTupleSet.Insert(negtypes.SvcPortTuple{ - Name: c.defaultBackendService.ID.Port.String(), + Name: c.defaultBackendService.ID.Port.Name, Port: c.defaultBackendService.Port, TargetPort: c.defaultBackendService.TargetPort, }) @@ -772,7 +772,7 @@ func (c *Controller) enqueueService(obj interface{}) { c.serviceQueue.Add(key) } -func (c *Controller) enqueueIngressServices(ing *v1beta1.Ingress) { +func (c *Controller) enqueueIngressServices(ing *v1.Ingress) { // enqueue services referenced by ingress keys := gatherIngressServiceKeys(ing) for key := range keys { @@ -809,7 +809,7 @@ func (c *Controller) gc() { // gatherPortMappingUsedByIngress returns a map containing port:targetport // of all service ports of the service that are referenced by ingresses -func gatherPortMappingUsedByIngress(ings []v1beta1.Ingress, svc *apiv1.Service) negtypes.SvcPortTupleSet { +func gatherPortMappingUsedByIngress(ings []v1.Ingress, svc *apiv1.Service) negtypes.SvcPortTupleSet { ingressSvcPortTuples := make(negtypes.SvcPortTupleSet) for _, ing := range ings { if utils.IsGLBCIngress(&ing) { @@ -834,7 +834,7 @@ func gatherPortMappingUsedByIngress(ings []v1beta1.Ingress, svc *apiv1.Service) } // gatherIngressServiceKeys returns all service key (formatted as namespace/name) referenced in the ingress -func gatherIngressServiceKeys(ing *v1beta1.Ingress) sets.String { +func gatherIngressServiceKeys(ing *v1.Ingress) sets.String { set := sets.NewString() if ing == nil { return set @@ -846,9 +846,9 @@ func gatherIngressServiceKeys(ing *v1beta1.Ingress) sets.String { return set } -func getIngressServicesFromStore(store cache.Store, svc *apiv1.Service) (ings []v1beta1.Ingress) { +func getIngressServicesFromStore(store cache.Store, svc *apiv1.Service) (ings []v1.Ingress) { for _, m := range store.List() { - ing := *m.(*v1beta1.Ingress) + ing := *m.(*v1.Ingress) if ing.Namespace != svc.Namespace { continue } From 7cb7e39406bc2d8642d5d365e45fae5a6a00b25a Mon Sep 17 00:00:00 2001 From: Swetha Repakula Date: Mon, 26 Apr 2021 12:09:01 -0700 Subject: [PATCH 2/4] Update test adapter client to networking.k8s.io/v1 - falls back to the v1beta1 API if V1 is not available --- pkg/e2e/adapter/conversion.go | 81 ++++ pkg/e2e/adapter/ingress.go | 174 +++++---- pkg/e2e/adapter/ingress_test.go | 44 ++- pkg/e2e/adapter/zz_generated.conversion.go | 417 +++++++++++++++++++++ 4 files changed, 621 insertions(+), 95 deletions(-) create mode 100644 pkg/e2e/adapter/conversion.go create mode 100644 pkg/e2e/adapter/zz_generated.conversion.go diff --git a/pkg/e2e/adapter/conversion.go b/pkg/e2e/adapter/conversion.go new file mode 100644 index 0000000000..c527b5dee5 --- /dev/null +++ b/pkg/e2e/adapter/conversion.go @@ -0,0 +1,81 @@ +/* +Copyright 2021 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package adapter + +// **NOTE** These conversion functions have been copied from kubernetes/kubernetes v1.19.0 +// The only changes made were to convert between v1beta1.Ingress and v1.Ingress instead of +// internal ingress structure + +import ( + networking "k8s.io/api/networking/v1" + v1beta1 "k8s.io/api/networking/v1beta1" + conversion "k8s.io/apimachinery/pkg/conversion" + "k8s.io/apimachinery/pkg/util/intstr" +) + +func Convert_v1beta1_IngressBackend_To_networking_IngressBackend(in *v1beta1.IngressBackend, out *networking.IngressBackend, s conversion.Scope) error { + if err := autoConvert_v1beta1_IngressBackend_To_networking_IngressBackend(in, out, s); err != nil { + return err + } + if len(in.ServiceName) > 0 || in.ServicePort.IntVal != 0 || in.ServicePort.StrVal != "" || in.ServicePort.Type == intstr.String { + out.Service = &networking.IngressServiceBackend{} + out.Service.Name = in.ServiceName + out.Service.Port.Name = in.ServicePort.StrVal + out.Service.Port.Number = in.ServicePort.IntVal + } + return nil +} + +func Convert_networking_IngressBackend_To_v1beta1_IngressBackend(in *networking.IngressBackend, out *v1beta1.IngressBackend, s conversion.Scope) error { + if err := autoConvert_networking_IngressBackend_To_v1beta1_IngressBackend(in, out, s); err != nil { + return err + } + if in.Service != nil { + out.ServiceName = in.Service.Name + if len(in.Service.Port.Name) > 0 { + out.ServicePort = intstr.FromString(in.Service.Port.Name) + } else { + out.ServicePort = intstr.FromInt(int(in.Service.Port.Number)) + } + } + return nil +} +func Convert_v1beta1_IngressSpec_To_networking_IngressSpec(in *v1beta1.IngressSpec, out *networking.IngressSpec, s conversion.Scope) error { + if err := autoConvert_v1beta1_IngressSpec_To_networking_IngressSpec(in, out, s); err != nil { + return nil + } + if in.Backend != nil { + out.DefaultBackend = &networking.IngressBackend{} + if err := Convert_v1beta1_IngressBackend_To_networking_IngressBackend(in.Backend, out.DefaultBackend, s); err != nil { + return err + } + } + return nil +} + +func Convert_networking_IngressSpec_To_v1beta1_IngressSpec(in *networking.IngressSpec, out *v1beta1.IngressSpec, s conversion.Scope) error { + if err := autoConvert_networking_IngressSpec_To_v1beta1_IngressSpec(in, out, s); err != nil { + return nil + } + if in.DefaultBackend != nil { + out.Backend = &v1beta1.IngressBackend{} + if err := Convert_networking_IngressBackend_To_v1beta1_IngressBackend(in.DefaultBackend, out.Backend, s); err != nil { + return err + } + } + return nil +} diff --git a/pkg/e2e/adapter/ingress.go b/pkg/e2e/adapter/ingress.go index 8f6d11e412..666dd7eac3 100644 --- a/pkg/e2e/adapter/ingress.go +++ b/pkg/e2e/adapter/ingress.go @@ -3,13 +3,12 @@ package adapter // Legacy conversion code for the old extensions v1beta1 API group. import ( - "bytes" "context" "encoding/json" "errors" "fmt" - extv1beta1 "k8s.io/api/extensions/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" @@ -18,61 +17,107 @@ import ( "k8s.io/klog" ) +const ( + v1GroupVersion = "networking.k8s.io/v1" + v1beta1GroupVersion = "networking.k8s.io/v1beta1" +) + +//TODO(srepakula) Remove adapter client once v1beta1 is no longer supported + // IngressCRUD wraps basic CRUD to allow use of old and new APIs. type IngressCRUD struct { C *kubernetes.Clientset } // Get Ingress resource. -func (crud *IngressCRUD) Get(ns, name string) (*v1beta1.Ingress, error) { - new, err := crud.supportsNewAPI() +func (crud *IngressCRUD) Get(ns, name string) (*v1.Ingress, error) { + useV1, err := crud.supportsV1API() if err != nil { return nil, err } klog.Infof("Get %s/%s", ns, name) - if new { - return crud.C.NetworkingV1beta1().Ingresses(ns).Get(context.TODO(), name, metav1.GetOptions{}) + if useV1 { + return crud.C.NetworkingV1().Ingresses(ns).Get(context.TODO(), name, metav1.GetOptions{}) } - klog.Warning("Using legacy API") - ing, err := crud.C.ExtensionsV1beta1().Ingresses(ns).Get(context.TODO(), name, metav1.GetOptions{}) - return toIngressNetworkingGroup(ing), err + klog.Warning("Using v1beta1 API") + ing, err := crud.C.NetworkingV1beta1().Ingresses(ns).Get(context.TODO(), name, metav1.GetOptions{}) + if err != nil { + return nil, err + } + return toIngressV1(ing) } // Create Ingress resource. -func (crud *IngressCRUD) Create(ing *v1beta1.Ingress) (*v1beta1.Ingress, error) { - new, err := crud.supportsNewAPI() +func (crud *IngressCRUD) Create(ing *v1.Ingress) (*v1.Ingress, error) { + useV1, err := crud.supportsV1API() if err != nil { return nil, err } klog.Infof("Create %s/%s", ing.Namespace, ing.Name) - if new { - return crud.C.NetworkingV1beta1().Ingresses(ing.Namespace).Create(context.TODO(), ing, metav1.CreateOptions{}) + if useV1 { + return crud.C.NetworkingV1().Ingresses(ing.Namespace).Create(context.TODO(), ing, metav1.CreateOptions{}) } - klog.Warning("Using legacy API") - legacyIng := toIngressExtensionsGroup(ing) - legacyIng, err = crud.C.ExtensionsV1beta1().Ingresses(ing.Namespace).Create(context.TODO(), legacyIng, metav1.CreateOptions{}) - return toIngressNetworkingGroup(legacyIng), err + + klog.Warning("Using v1beta1 API") + legacyIng, err := toIngressV1beta1(ing) + if err != nil { + return nil, err + } + + legacyIng, err = crud.C.NetworkingV1beta1().Ingresses(ing.Namespace).Create(context.TODO(), legacyIng, metav1.CreateOptions{}) + if err != nil { + return nil, err + } + return toIngressV1(legacyIng) } // Update Ingress resource. -func (crud *IngressCRUD) Update(ing *v1beta1.Ingress) (*v1beta1.Ingress, error) { - new, err := crud.supportsNewAPI() +func (crud *IngressCRUD) Update(ing *v1.Ingress) (*v1.Ingress, error) { + useV1, err := crud.supportsV1API() if err != nil { return nil, err } klog.Infof("Update %s/%s", ing.Namespace, ing.Name) - if new { - return crud.C.NetworkingV1beta1().Ingresses(ing.Namespace).Update(context.TODO(), ing, metav1.UpdateOptions{}) + if useV1 { + return crud.C.NetworkingV1().Ingresses(ing.Namespace).Update(context.TODO(), ing, metav1.UpdateOptions{}) } + klog.Warning("Using legacy API") - legacyIng := toIngressExtensionsGroup(ing) - legacyIng, err = crud.C.ExtensionsV1beta1().Ingresses(ing.Namespace).Update(context.TODO(), legacyIng, metav1.UpdateOptions{}) - return toIngressNetworkingGroup(legacyIng), err + legacyIng, err := toIngressV1beta1(ing) + if err != nil { + return nil, err + } + + legacyIng, err = crud.C.NetworkingV1beta1().Ingresses(ing.Namespace).Update(context.TODO(), legacyIng, metav1.UpdateOptions{}) + if err != nil { + return nil, err + } + return toIngressV1(legacyIng) } // Patch Ingress resource. -func (crud *IngressCRUD) Patch(oldIng, newIng *v1beta1.Ingress) (*v1beta1.Ingress, error) { - ingKey := fmt.Sprintf("%s/%s", oldIng.Namespace, oldIng.Name) +func (crud *IngressCRUD) Patch(oldV1Ing, newV1Ing *v1.Ingress) (*v1.Ingress, error) { + useV1, err := crud.supportsV1API() + if err != nil { + return nil, err + } + + var oldIng, newIng, dataStruct interface{} + if useV1 { + oldIng = oldV1Ing + newIng = newV1Ing + dataStruct = v1.Ingress{} + } else { + if oldIng, err = toIngressV1beta1(oldV1Ing); err != nil { + return nil, err + } + if newIng, err = toIngressV1beta1(oldV1Ing); err != nil { + return nil, err + } + dataStruct = v1beta1.Ingress{} + } + + ingKey := fmt.Sprintf("%s/%s", oldV1Ing.Namespace, oldV1Ing.Name) oldData, err := json.Marshal(oldIng) if err != nil { return nil, fmt.Errorf("failed to marshal ingress %+v: %v", oldIng, err) @@ -81,47 +126,47 @@ func (crud *IngressCRUD) Patch(oldIng, newIng *v1beta1.Ingress) (*v1beta1.Ingres if err != nil { return nil, fmt.Errorf("failed to marshal ingress %+v: %v", newIng, err) } - patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, v1beta1.Ingress{}) + patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, dataStruct) if err != nil { return nil, fmt.Errorf("failed to create TwoWayMergePatch for ingress %s: %v, old ingress: %+v new ingress: %+v", ingKey, err, oldIng, newIng) } - new, err := crud.supportsNewAPI() + klog.Infof("Patch %s/%s", oldV1Ing.Namespace, oldV1Ing.Name) + if useV1 { + return crud.C.NetworkingV1().Ingresses(oldV1Ing.Namespace).Patch(context.TODO(), oldV1Ing.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}) + } + + klog.Warning("Using v1beta1 API") + legacyIng, err := crud.C.NetworkingV1beta1().Ingresses(oldV1Ing.Namespace).Patch(context.TODO(), oldV1Ing.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}) if err != nil { return nil, err } - klog.Infof("Patch %s/%s", oldIng.Namespace, oldIng.Name) - if new { - return crud.C.NetworkingV1beta1().Ingresses(oldIng.Namespace).Patch(context.TODO(), oldIng.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}) - } - klog.Warning("Using legacy API") - legacyIng, err := crud.C.ExtensionsV1beta1().Ingresses(oldIng.Namespace).Patch(context.TODO(), oldIng.Name, types.StrategicMergePatchType, patchBytes, metav1.PatchOptions{}) - return toIngressNetworkingGroup(legacyIng), err + return toIngressV1(legacyIng) } // Delete Ingress resource. func (crud *IngressCRUD) Delete(ns, name string) error { - new, err := crud.supportsNewAPI() + new, err := crud.supportsV1API() if err != nil { return err } klog.Infof("Delete %s/%s", ns, name) if new { - return crud.C.NetworkingV1beta1().Ingresses(ns).Delete(context.TODO(), name, metav1.DeleteOptions{}) + return crud.C.NetworkingV1().Ingresses(ns).Delete(context.TODO(), name, metav1.DeleteOptions{}) } - klog.Warning("Using legacy API") - return crud.C.ExtensionsV1beta1().Ingresses(ns).Delete(context.TODO(), name, metav1.DeleteOptions{}) + klog.Warning("Using v1beta1 API") + return crud.C.NetworkingV1beta1().Ingresses(ns).Delete(context.TODO(), name, metav1.DeleteOptions{}) } -func (crud *IngressCRUD) supportsNewAPI() (bool, error) { - if apiList, err := crud.C.Discovery().ServerResourcesForGroupVersion("networking.k8s.io/v1beta1"); err == nil { +func (crud *IngressCRUD) supportsV1API() (bool, error) { + if apiList, err := crud.C.Discovery().ServerResourcesForGroupVersion(v1GroupVersion); err == nil { for _, r := range apiList.APIResources { if r.Kind == "Ingress" { return true, nil } } } - if apiList, err := crud.C.Discovery().ServerResourcesForGroupVersion("extensions/v1beta1"); err == nil { + if apiList, err := crud.C.Discovery().ServerResourcesForGroupVersion(v1beta1GroupVersion); err == nil { for _, r := range apiList.APIResources { if r.Kind == "Ingress" { return false, nil @@ -131,41 +176,16 @@ func (crud *IngressCRUD) supportsNewAPI() (bool, error) { return false, errors.New("no Ingress resource found") } -func toIngressExtensionsGroup(ing *v1beta1.Ingress) *extv1beta1.Ingress { - b := &bytes.Buffer{} - e := json.NewEncoder(b) - // This is used by test cases from test data, so we assume no issues with - // conversion. - if err := e.Encode(ing); err != nil { - panic(err) - } - - ret := &extv1beta1.Ingress{} - d := json.NewDecoder(b) - if err := d.Decode(ret); err != nil { - panic(err) - } - - ret.APIVersion = "extensions/v1beta1" - - return ret +func toIngressV1(ing *v1beta1.Ingress) (*v1.Ingress, error) { + v1Ing := &v1.Ingress{} + err := Convert_v1beta1_Ingress_To_networking_Ingress(ing, v1Ing, nil) + v1Ing.APIVersion = v1GroupVersion + return v1Ing, err } -func toIngressNetworkingGroup(ing *extv1beta1.Ingress) *v1beta1.Ingress { - b := &bytes.Buffer{} - e := json.NewEncoder(b) - // This is used by test cases from test data, so we assume no issues with - // conversion. - if err := e.Encode(ing); err != nil { - panic(err) - } - - ret := &v1beta1.Ingress{} - d := json.NewDecoder(b) - if err := d.Decode(ret); err != nil { - panic(err) - } - - ret.APIVersion = "networking.k8s.io/v1beta1" - return ret +func toIngressV1beta1(ing *v1.Ingress) (*v1beta1.Ingress, error) { + v1beta1Ing := &v1beta1.Ingress{} + err := Convert_networking_Ingress_To_v1beta1_Ingress(ing, v1beta1Ing, nil) + v1beta1Ing.APIVersion = v1beta1GroupVersion + return v1beta1Ing, err } diff --git a/pkg/e2e/adapter/ingress_test.go b/pkg/e2e/adapter/ingress_test.go index f19acc7296..581a82e487 100644 --- a/pkg/e2e/adapter/ingress_test.go +++ b/pkg/e2e/adapter/ingress_test.go @@ -5,45 +5,53 @@ import ( "testing" "github.com/kr/pretty" - extv1beta1 "k8s.io/api/extensions/v1beta1" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/api/networking/v1beta1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) func TestLegacyConversions(t *testing.T) { for _, tc := range []struct { - ext *extv1beta1.Ingress - net *v1beta1.Ingress + netV1beta1 *v1beta1.Ingress + netV1 *networkingv1.Ingress }{ { - ext: &extv1beta1.Ingress{ - TypeMeta: v1.TypeMeta{APIVersion: "extensions/v1beta1"}, + netV1beta1: &v1beta1.Ingress{ + TypeMeta: v1.TypeMeta{APIVersion: v1beta1GroupVersion}, ObjectMeta: v1.ObjectMeta{Namespace: "ns1", Name: "foo"}, - Spec: extv1beta1.IngressSpec{ - Backend: &extv1beta1.IngressBackend{ + Spec: v1beta1.IngressSpec{ + Backend: &v1beta1.IngressBackend{ ServiceName: "svc1", }, }, }, - net: &v1beta1.Ingress{ - TypeMeta: v1.TypeMeta{APIVersion: "networking.k8s.io/v1beta1"}, + netV1: &networkingv1.Ingress{ + TypeMeta: v1.TypeMeta{APIVersion: v1GroupVersion}, ObjectMeta: v1.ObjectMeta{Namespace: "ns1", Name: "foo"}, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "svc1", + Spec: networkingv1.IngressSpec{ + DefaultBackend: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "svc1", + }, }, }, }, }, } { - gotExt := toIngressExtensionsGroup(tc.net) - gotNet := toIngressNetworkingGroup(tc.ext) + gotV1, err := toIngressV1(tc.netV1beta1) + if err != nil { + t.Errorf("got error in conversion from v1 to v1beta1: %q", err) + } + gotV1beta1, err := toIngressV1beta1(tc.netV1) + if err != nil { + t.Errorf("got error in conversion from v1beta1 to v1: %q", err) + } - if !reflect.DeepEqual(gotExt, tc.ext) { - t.Errorf("Got\n%s\nwant\n%s", pretty.Sprint(gotExt), pretty.Sprint(tc.ext)) + if !reflect.DeepEqual(gotV1beta1, tc.netV1beta1) { + t.Errorf("Got\n%s\nwant\n%s", pretty.Sprint(gotV1beta1), pretty.Sprint(tc.netV1beta1)) } - if !reflect.DeepEqual(gotNet, tc.net) { - t.Errorf("Got%s\nwant\n%s", pretty.Sprint(gotNet), pretty.Sprint(tc.net)) + if !reflect.DeepEqual(gotV1, tc.netV1) { + t.Errorf("Got\n%s\nwant\n%s", pretty.Sprint(gotV1), pretty.Sprint(tc.netV1)) } } } diff --git a/pkg/e2e/adapter/zz_generated.conversion.go b/pkg/e2e/adapter/zz_generated.conversion.go new file mode 100644 index 0000000000..da4ad6075e --- /dev/null +++ b/pkg/e2e/adapter/zz_generated.conversion.go @@ -0,0 +1,417 @@ +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// **NOTE** These auto generated conversion functions have been copied from kubernetes/kubernetes v1.19.0 +// The only changes made were to convert between v1beta1.Ingress and v1.Ingress instead of internal +// ingress structure + +package adapter + +import ( + unsafe "unsafe" + + corev1 "k8s.io/api/core/v1" + v1 "k8s.io/api/core/v1" + networking "k8s.io/api/networking/v1" + v1beta1 "k8s.io/api/networking/v1beta1" + conversion "k8s.io/apimachinery/pkg/conversion" +) + +func autoConvert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(in *v1beta1.HTTPIngressPath, out *networking.HTTPIngressPath, s conversion.Scope) error { + out.Path = in.Path + out.PathType = (*networking.PathType)(unsafe.Pointer(in.PathType)) + if err := Convert_v1beta1_IngressBackend_To_networking_IngressBackend(&in.Backend, &out.Backend, s); err != nil { + return err + } + return nil +} + +// Convert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath is an autogenerated conversion function. +func Convert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(in *v1beta1.HTTPIngressPath, out *networking.HTTPIngressPath, s conversion.Scope) error { + return autoConvert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(in, out, s) +} + +func autoConvert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in *networking.HTTPIngressPath, out *v1beta1.HTTPIngressPath, s conversion.Scope) error { + out.Path = in.Path + out.PathType = (*v1beta1.PathType)(unsafe.Pointer(in.PathType)) + if err := Convert_networking_IngressBackend_To_v1beta1_IngressBackend(&in.Backend, &out.Backend, s); err != nil { + return err + } + return nil +} + +// Convert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath is an autogenerated conversion function. +func Convert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in *networking.HTTPIngressPath, out *v1beta1.HTTPIngressPath, s conversion.Scope) error { + return autoConvert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in, out, s) +} + +func autoConvert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(in *v1beta1.HTTPIngressRuleValue, out *networking.HTTPIngressRuleValue, s conversion.Scope) error { + if in.Paths != nil { + in, out := &in.Paths, &out.Paths + *out = make([]networking.HTTPIngressPath, len(*in)) + for i := range *in { + if err := Convert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Paths = nil + } + return nil +} + +// Convert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue is an autogenerated conversion function. +func Convert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(in *v1beta1.HTTPIngressRuleValue, out *networking.HTTPIngressRuleValue, s conversion.Scope) error { + return autoConvert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(in, out, s) +} + +func autoConvert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in *networking.HTTPIngressRuleValue, out *v1beta1.HTTPIngressRuleValue, s conversion.Scope) error { + if in.Paths != nil { + in, out := &in.Paths, &out.Paths + *out = make([]v1beta1.HTTPIngressPath, len(*in)) + for i := range *in { + if err := Convert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Paths = nil + } + return nil +} + +// Convert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue is an autogenerated conversion function. +func Convert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in *networking.HTTPIngressRuleValue, out *v1beta1.HTTPIngressRuleValue, s conversion.Scope) error { + return autoConvert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in, out, s) +} + +func autoConvert_v1beta1_Ingress_To_networking_Ingress(in *v1beta1.Ingress, out *networking.Ingress, s conversion.Scope) error { + out.ObjectMeta = in.ObjectMeta + if err := Convert_v1beta1_IngressSpec_To_networking_IngressSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_v1beta1_IngressStatus_To_networking_IngressStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_v1beta1_Ingress_To_networking_Ingress is an autogenerated conversion function. +func Convert_v1beta1_Ingress_To_networking_Ingress(in *v1beta1.Ingress, out *networking.Ingress, s conversion.Scope) error { + return autoConvert_v1beta1_Ingress_To_networking_Ingress(in, out, s) +} + +func autoConvert_networking_Ingress_To_v1beta1_Ingress(in *networking.Ingress, out *v1beta1.Ingress, s conversion.Scope) error { + out.ObjectMeta = in.ObjectMeta + if err := Convert_networking_IngressSpec_To_v1beta1_IngressSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + if err := Convert_networking_IngressStatus_To_v1beta1_IngressStatus(&in.Status, &out.Status, s); err != nil { + return err + } + return nil +} + +// Convert_networking_Ingress_To_v1beta1_Ingress is an autogenerated conversion function. +func Convert_networking_Ingress_To_v1beta1_Ingress(in *networking.Ingress, out *v1beta1.Ingress, s conversion.Scope) error { + return autoConvert_networking_Ingress_To_v1beta1_Ingress(in, out, s) +} + +func autoConvert_v1beta1_IngressBackend_To_networking_IngressBackend(in *v1beta1.IngressBackend, out *networking.IngressBackend, s conversion.Scope) error { + // WARNING: in.ServiceName requires manual conversion: does not exist in peer-type + // WARNING: in.ServicePort requires manual conversion: does not exist in peer-type + out.Resource = (*corev1.TypedLocalObjectReference)(unsafe.Pointer(in.Resource)) + return nil +} + +func autoConvert_networking_IngressBackend_To_v1beta1_IngressBackend(in *networking.IngressBackend, out *v1beta1.IngressBackend, s conversion.Scope) error { + // WARNING: in.Service requires manual conversion: does not exist in peer-type + out.Resource = (*v1.TypedLocalObjectReference)(unsafe.Pointer(in.Resource)) + return nil +} + +func autoConvert_v1beta1_IngressClass_To_networking_IngressClass(in *v1beta1.IngressClass, out *networking.IngressClass, s conversion.Scope) error { + out.ObjectMeta = in.ObjectMeta + if err := Convert_v1beta1_IngressClassSpec_To_networking_IngressClassSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + return nil +} + +// Convert_v1beta1_IngressClass_To_networking_IngressClass is an autogenerated conversion function. +func Convert_v1beta1_IngressClass_To_networking_IngressClass(in *v1beta1.IngressClass, out *networking.IngressClass, s conversion.Scope) error { + return autoConvert_v1beta1_IngressClass_To_networking_IngressClass(in, out, s) +} + +func autoConvert_networking_IngressClass_To_v1beta1_IngressClass(in *networking.IngressClass, out *v1beta1.IngressClass, s conversion.Scope) error { + out.ObjectMeta = in.ObjectMeta + if err := Convert_networking_IngressClassSpec_To_v1beta1_IngressClassSpec(&in.Spec, &out.Spec, s); err != nil { + return err + } + return nil +} + +// Convert_networking_IngressClass_To_v1beta1_IngressClass is an autogenerated conversion function. +func Convert_networking_IngressClass_To_v1beta1_IngressClass(in *networking.IngressClass, out *v1beta1.IngressClass, s conversion.Scope) error { + return autoConvert_networking_IngressClass_To_v1beta1_IngressClass(in, out, s) +} + +func autoConvert_v1beta1_IngressClassList_To_networking_IngressClassList(in *v1beta1.IngressClassList, out *networking.IngressClassList, s conversion.Scope) error { + out.ListMeta = in.ListMeta + out.Items = *(*[]networking.IngressClass)(unsafe.Pointer(&in.Items)) + return nil +} + +// Convert_v1beta1_IngressClassList_To_networking_IngressClassList is an autogenerated conversion function. +func Convert_v1beta1_IngressClassList_To_networking_IngressClassList(in *v1beta1.IngressClassList, out *networking.IngressClassList, s conversion.Scope) error { + return autoConvert_v1beta1_IngressClassList_To_networking_IngressClassList(in, out, s) +} + +func autoConvert_networking_IngressClassList_To_v1beta1_IngressClassList(in *networking.IngressClassList, out *v1beta1.IngressClassList, s conversion.Scope) error { + out.ListMeta = in.ListMeta + out.Items = *(*[]v1beta1.IngressClass)(unsafe.Pointer(&in.Items)) + return nil +} + +// Convert_networking_IngressClassList_To_v1beta1_IngressClassList is an autogenerated conversion function. +func Convert_networking_IngressClassList_To_v1beta1_IngressClassList(in *networking.IngressClassList, out *v1beta1.IngressClassList, s conversion.Scope) error { + return autoConvert_networking_IngressClassList_To_v1beta1_IngressClassList(in, out, s) +} + +func autoConvert_v1beta1_IngressClassSpec_To_networking_IngressClassSpec(in *v1beta1.IngressClassSpec, out *networking.IngressClassSpec, s conversion.Scope) error { + out.Controller = in.Controller + out.Parameters = (*corev1.TypedLocalObjectReference)(unsafe.Pointer(in.Parameters)) + return nil +} + +// Convert_v1beta1_IngressClassSpec_To_networking_IngressClassSpec is an autogenerated conversion function. +func Convert_v1beta1_IngressClassSpec_To_networking_IngressClassSpec(in *v1beta1.IngressClassSpec, out *networking.IngressClassSpec, s conversion.Scope) error { + return autoConvert_v1beta1_IngressClassSpec_To_networking_IngressClassSpec(in, out, s) +} + +func autoConvert_networking_IngressClassSpec_To_v1beta1_IngressClassSpec(in *networking.IngressClassSpec, out *v1beta1.IngressClassSpec, s conversion.Scope) error { + out.Controller = in.Controller + out.Parameters = (*v1.TypedLocalObjectReference)(unsafe.Pointer(in.Parameters)) + return nil +} + +// Convert_networking_IngressClassSpec_To_v1beta1_IngressClassSpec is an autogenerated conversion function. +func Convert_networking_IngressClassSpec_To_v1beta1_IngressClassSpec(in *networking.IngressClassSpec, out *v1beta1.IngressClassSpec, s conversion.Scope) error { + return autoConvert_networking_IngressClassSpec_To_v1beta1_IngressClassSpec(in, out, s) +} + +func autoConvert_v1beta1_IngressList_To_networking_IngressList(in *v1beta1.IngressList, out *networking.IngressList, s conversion.Scope) error { + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]networking.Ingress, len(*in)) + for i := range *in { + if err := Convert_v1beta1_Ingress_To_networking_Ingress(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +// Convert_v1beta1_IngressList_To_networking_IngressList is an autogenerated conversion function. +func Convert_v1beta1_IngressList_To_networking_IngressList(in *v1beta1.IngressList, out *networking.IngressList, s conversion.Scope) error { + return autoConvert_v1beta1_IngressList_To_networking_IngressList(in, out, s) +} + +func autoConvert_networking_IngressList_To_v1beta1_IngressList(in *networking.IngressList, out *v1beta1.IngressList, s conversion.Scope) error { + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]v1beta1.Ingress, len(*in)) + for i := range *in { + if err := Convert_networking_Ingress_To_v1beta1_Ingress(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +// Convert_networking_IngressList_To_v1beta1_IngressList is an autogenerated conversion function. +func Convert_networking_IngressList_To_v1beta1_IngressList(in *networking.IngressList, out *v1beta1.IngressList, s conversion.Scope) error { + return autoConvert_networking_IngressList_To_v1beta1_IngressList(in, out, s) +} + +func autoConvert_v1beta1_IngressRule_To_networking_IngressRule(in *v1beta1.IngressRule, out *networking.IngressRule, s conversion.Scope) error { + out.Host = in.Host + if err := Convert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil { + return err + } + return nil +} + +// Convert_v1beta1_IngressRule_To_networking_IngressRule is an autogenerated conversion function. +func Convert_v1beta1_IngressRule_To_networking_IngressRule(in *v1beta1.IngressRule, out *networking.IngressRule, s conversion.Scope) error { + return autoConvert_v1beta1_IngressRule_To_networking_IngressRule(in, out, s) +} + +func autoConvert_networking_IngressRule_To_v1beta1_IngressRule(in *networking.IngressRule, out *v1beta1.IngressRule, s conversion.Scope) error { + out.Host = in.Host + if err := Convert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil { + return err + } + return nil +} + +// Convert_networking_IngressRule_To_v1beta1_IngressRule is an autogenerated conversion function. +func Convert_networking_IngressRule_To_v1beta1_IngressRule(in *networking.IngressRule, out *v1beta1.IngressRule, s conversion.Scope) error { + return autoConvert_networking_IngressRule_To_v1beta1_IngressRule(in, out, s) +} + +func autoConvert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(in *v1beta1.IngressRuleValue, out *networking.IngressRuleValue, s conversion.Scope) error { + if in.HTTP != nil { + in, out := &in.HTTP, &out.HTTP + *out = new(networking.HTTPIngressRuleValue) + if err := Convert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(*in, *out, s); err != nil { + return err + } + } else { + out.HTTP = nil + } + return nil +} + +// Convert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue is an autogenerated conversion function. +func Convert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(in *v1beta1.IngressRuleValue, out *networking.IngressRuleValue, s conversion.Scope) error { + return autoConvert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(in, out, s) +} + +func autoConvert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(in *networking.IngressRuleValue, out *v1beta1.IngressRuleValue, s conversion.Scope) error { + if in.HTTP != nil { + in, out := &in.HTTP, &out.HTTP + *out = new(v1beta1.HTTPIngressRuleValue) + if err := Convert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(*in, *out, s); err != nil { + return err + } + } else { + out.HTTP = nil + } + return nil +} + +// Convert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue is an autogenerated conversion function. +func Convert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(in *networking.IngressRuleValue, out *v1beta1.IngressRuleValue, s conversion.Scope) error { + return autoConvert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(in, out, s) +} + +func autoConvert_v1beta1_IngressSpec_To_networking_IngressSpec(in *v1beta1.IngressSpec, out *networking.IngressSpec, s conversion.Scope) error { + out.IngressClassName = (*string)(unsafe.Pointer(in.IngressClassName)) + // WARNING: in.Backend requires manual conversion: does not exist in peer-type + out.TLS = *(*[]networking.IngressTLS)(unsafe.Pointer(&in.TLS)) + if in.Rules != nil { + in, out := &in.Rules, &out.Rules + *out = make([]networking.IngressRule, len(*in)) + for i := range *in { + if err := Convert_v1beta1_IngressRule_To_networking_IngressRule(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Rules = nil + } + return nil +} + +func autoConvert_networking_IngressSpec_To_v1beta1_IngressSpec(in *networking.IngressSpec, out *v1beta1.IngressSpec, s conversion.Scope) error { + out.IngressClassName = (*string)(unsafe.Pointer(in.IngressClassName)) + // WARNING: in.DefaultBackend requires manual conversion: does not exist in peer-type + out.TLS = *(*[]v1beta1.IngressTLS)(unsafe.Pointer(&in.TLS)) + if in.Rules != nil { + in, out := &in.Rules, &out.Rules + *out = make([]v1beta1.IngressRule, len(*in)) + for i := range *in { + if err := Convert_networking_IngressRule_To_v1beta1_IngressRule(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Rules = nil + } + return nil +} + +func autoConvert_v1beta1_IngressStatus_To_networking_IngressStatus(in *v1beta1.IngressStatus, out *networking.IngressStatus, s conversion.Scope) error { + if err := Convert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil { + return err + } + return nil +} + +// Convert_v1beta1_IngressStatus_To_networking_IngressStatus is an autogenerated conversion function. +func Convert_v1beta1_IngressStatus_To_networking_IngressStatus(in *v1beta1.IngressStatus, out *networking.IngressStatus, s conversion.Scope) error { + return autoConvert_v1beta1_IngressStatus_To_networking_IngressStatus(in, out, s) +} + +func autoConvert_networking_IngressStatus_To_v1beta1_IngressStatus(in *networking.IngressStatus, out *v1beta1.IngressStatus, s conversion.Scope) error { + if err := Convert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil { + return err + } + return nil +} + +// Convert_networking_IngressStatus_To_v1beta1_IngressStatus is an autogenerated conversion function. +func Convert_networking_IngressStatus_To_v1beta1_IngressStatus(in *networking.IngressStatus, out *v1beta1.IngressStatus, s conversion.Scope) error { + return autoConvert_networking_IngressStatus_To_v1beta1_IngressStatus(in, out, s) +} + +func autoConvert_v1beta1_IngressTLS_To_networking_IngressTLS(in *v1beta1.IngressTLS, out *networking.IngressTLS, s conversion.Scope) error { + out.Hosts = *(*[]string)(unsafe.Pointer(&in.Hosts)) + out.SecretName = in.SecretName + return nil +} + +// Convert_v1beta1_IngressTLS_To_networking_IngressTLS is an autogenerated conversion function. +func Convert_v1beta1_IngressTLS_To_networking_IngressTLS(in *v1beta1.IngressTLS, out *networking.IngressTLS, s conversion.Scope) error { + return autoConvert_v1beta1_IngressTLS_To_networking_IngressTLS(in, out, s) +} + +func autoConvert_networking_IngressTLS_To_v1beta1_IngressTLS(in *networking.IngressTLS, out *v1beta1.IngressTLS, s conversion.Scope) error { + out.Hosts = *(*[]string)(unsafe.Pointer(&in.Hosts)) + out.SecretName = in.SecretName + return nil +} + +// Convert_networking_IngressTLS_To_v1beta1_IngressTLS is an autogenerated conversion function. +func Convert_networking_IngressTLS_To_v1beta1_IngressTLS(in *networking.IngressTLS, out *v1beta1.IngressTLS, s conversion.Scope) error { + return autoConvert_networking_IngressTLS_To_v1beta1_IngressTLS(in, out, s) +} + +// The following functions were copied from +// Copied from k8s.io.kubernetes/apis/core/v1/conversion.go + +// Convert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus is defined outside the autogenerated file for use by other API packages +func Convert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus(in *corev1.LoadBalancerStatus, out *v1.LoadBalancerStatus, s conversion.Scope) error { + out.Ingress = *(*[]v1.LoadBalancerIngress)(unsafe.Pointer(&in.Ingress)) + return nil +} + +// Convert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus is defined outside the autogenerated file for use by other API packages +func Convert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus(in *v1.LoadBalancerStatus, out *corev1.LoadBalancerStatus, s conversion.Scope) error { + out.Ingress = *(*[]corev1.LoadBalancerIngress)(unsafe.Pointer(&in.Ingress)) + return nil +} From d06cb4252a492076571425106eb95df806553cd2 Mon Sep 17 00:00:00 2001 From: Swetha Repakula Date: Mon, 26 Apr 2021 12:13:29 -0700 Subject: [PATCH 3/4] Use networking.k8s.io/v1 API - cmd/fuzzer was converted to use the V1 API solely --- cmd/e2e-test/affinity_beta_test.go | 4 +- cmd/e2e-test/affinity_test.go | 6 +- cmd/e2e-test/app_protocols_test.go | 10 +- cmd/e2e-test/backend_config_test.go | 4 +- cmd/e2e-test/basic_https_test.go | 4 +- cmd/e2e-test/basic_test.go | 17 +- cmd/e2e-test/cdn_test.go | 4 +- cmd/e2e-test/customrequestheaders_test.go | 10 +- cmd/e2e-test/draining_test.go | 4 +- cmd/e2e-test/finalizer_test.go | 8 +- cmd/e2e-test/healthcheck_test.go | 4 +- cmd/e2e-test/iap_test.go | 4 +- cmd/e2e-test/ilb_test.go | 53 +-- cmd/e2e-test/logging_test.go | 4 +- cmd/e2e-test/neg_test.go | 60 +-- cmd/e2e-test/redirects_test.go | 7 +- cmd/e2e-test/security_policy_test.go | 6 +- cmd/e2e-test/sslpolicy_test.go | 7 +- cmd/e2e-test/timeout_test.go | 6 +- cmd/e2e-test/upgrade/basic_http.go | 7 +- cmd/e2e-test/upgrade/finalizer.go | 4 +- cmd/e2e-test/upgrade/v2frontendnamer.go | 4 +- cmd/e2e-test/v2frontendnamer_test.go | 17 +- cmd/fuzzer/app/validate.go | 2 +- cmd/glbc/app/init.go | 1 + cmd/glbc/app/namer.go | 2 +- go.sum | 1 + pkg/annotations/ingress.go | 4 +- pkg/annotations/ingress_test.go | 10 +- pkg/annotations/service.go | 5 +- pkg/backends/features/features_test.go | 4 +- pkg/backends/syncer_test.go | 15 +- pkg/common/operator/frontendconfig.go | 6 +- pkg/common/operator/frontendconfig_test.go | 4 +- pkg/common/operator/ingress.go | 24 +- pkg/common/operator/service.go | 6 +- pkg/common/typed/ingress.go | 24 +- pkg/context/context.go | 6 +- pkg/controller/controller.go | 46 +-- pkg/controller/controller_test.go | 161 ++++---- .../testdata/ingress-missing-multi-svc.json | 4 +- .../testdata/ingress-missing-multi-svc.yaml | 14 +- .../testdata/ingress-missing-rule-svc.json | 8 +- .../testdata/ingress-missing-rule-svc.yaml | 14 +- .../testdata/ingress-multi-empty.json | 8 +- .../testdata/ingress-multi-empty.yaml | 14 +- .../testdata/ingress-multi-paths.json | 12 +- .../testdata/ingress-multi-paths.yaml | 14 +- .../translator/testdata/ingress-no-host.json | 8 +- .../translator/testdata/ingress-no-host.yaml | 8 +- .../testdata/ingress-single-host.json | 8 +- .../testdata/ingress-single-host.yaml | 8 +- .../testdata/ingress-two-hosts.json | 12 +- .../testdata/ingress-two-hosts.yaml | 14 +- pkg/controller/translator/translator.go | 24 +- pkg/controller/translator/translator_test.go | 95 ++--- pkg/controller/types.go | 4 +- pkg/controller/utils.go | 4 +- pkg/controller/utils_test.go | 8 +- pkg/e2e/fixtures.go | 4 +- pkg/e2e/helpers.go | 22 +- pkg/firewalls/controller.go | 16 +- pkg/firewalls/controller_test.go | 8 +- pkg/frontendconfig/frontendconfig.go | 4 +- pkg/frontendconfig/frontendconfig_test.go | 4 +- pkg/fuzz/feature.go | 6 +- pkg/fuzz/features/affinity.go | 6 +- pkg/fuzz/features/allow_http.go | 4 +- pkg/fuzz/features/app_protocol.go | 6 +- pkg/fuzz/features/backendconfig_example.go | 10 +- pkg/fuzz/features/cdn.go | 6 +- pkg/fuzz/features/https_redirects.go | 4 +- pkg/fuzz/features/iap.go | 6 +- pkg/fuzz/features/ilb.go | 9 +- pkg/fuzz/features/neg.go | 8 +- pkg/fuzz/features/preshared_cert.go | 4 +- pkg/fuzz/features/security_policy.go | 6 +- pkg/fuzz/features/static_ip.go | 6 +- pkg/fuzz/helpers.go | 72 ++-- pkg/fuzz/helpers_test.go | 68 ++-- pkg/fuzz/validator.go | 14 +- pkg/fuzz/validator_test.go | 23 +- pkg/fuzz/whitebox.go | 4 +- pkg/fuzz/whitebox/num_backend_services.go | 6 +- pkg/fuzz/whitebox/num_forwarding_rules.go | 4 +- pkg/fuzz/whitebox/num_target_proxies.go | 4 +- pkg/fuzz/whitebox/redirect_url_map.go | 4 +- pkg/loadbalancers/addresses_test.go | 4 +- pkg/loadbalancers/features/features.go | 8 +- pkg/loadbalancers/features/features_test.go | 11 +- pkg/loadbalancers/interfaces.go | 10 +- pkg/loadbalancers/l7.go | 8 +- pkg/loadbalancers/l7s.go | 12 +- pkg/loadbalancers/l7s_test.go | 62 +-- pkg/loadbalancers/loadbalancers_test.go | 18 +- pkg/metrics/features.go | 6 +- pkg/metrics/metrics.go | 4 +- pkg/metrics/metrics_test.go | 366 +++++++++++------- pkg/metrics/types.go | 4 +- pkg/neg/controller.go | 2 +- pkg/neg/controller_test.go | 190 +++++---- pkg/neg/syncers/syncer_test.go | 4 +- pkg/neg/types/testing.go | 4 +- pkg/sync/interfaces.go | 14 +- pkg/sync/sync.go | 8 +- pkg/test/frontendconfig.go | 10 +- pkg/test/utils.go | 25 +- pkg/translator/translator.go | 6 +- pkg/translator/translator_test.go | 40 +- pkg/utils/common/common.go | 18 +- pkg/utils/common/common_test.go | 55 +-- pkg/utils/common/finalizer.go | 8 +- pkg/utils/gceurlmap_test.go | 26 +- pkg/utils/namer/frontendnamer.go | 12 +- pkg/utils/namer/frontendnamer_test.go | 6 +- pkg/utils/namer/interfaces.go | 6 +- pkg/utils/namer/utils.go | 4 +- pkg/utils/patch/patch_test.go | 20 +- pkg/utils/serviceport.go | 13 +- pkg/utils/utils.go | 22 +- pkg/utils/utils_test.go | 261 ++++++++----- 121 files changed, 1356 insertions(+), 1105 deletions(-) diff --git a/cmd/e2e-test/affinity_beta_test.go b/cmd/e2e-test/affinity_beta_test.go index 099b1a5bd6..ecd6ad0422 100644 --- a/cmd/e2e-test/affinity_beta_test.go +++ b/cmd/e2e-test/affinity_beta_test.go @@ -21,8 +21,8 @@ import ( "fmt" "testing" + networkingv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/util/retry" "k8s.io/ingress-gce/pkg/annotations" @@ -78,7 +78,7 @@ func TestAffinityBeta(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, svcName) ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", svcName, intstr.FromInt(80)). + AddPath("test.com", "/", svcName, networkingv1.ServiceBackendPort{Number: 80}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { diff --git a/cmd/e2e-test/affinity_test.go b/cmd/e2e-test/affinity_test.go index cd2739bfa9..d004696ed9 100644 --- a/cmd/e2e-test/affinity_test.go +++ b/cmd/e2e-test/affinity_test.go @@ -22,7 +22,7 @@ import ( "testing" "time" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/util/retry" "k8s.io/ingress-gce/pkg/annotations" @@ -103,7 +103,7 @@ func TestAffinity(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", "service-1", intstr.FromInt(80)). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Number: 80}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { @@ -241,7 +241,7 @@ func TestILBSA(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", "service-1", intstr.FromInt(80)). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Number: 80}). ConfigureForILB(). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} diff --git a/cmd/e2e-test/app_protocols_test.go b/cmd/e2e-test/app_protocols_test.go index b80f79ad58..fa398c2ce2 100644 --- a/cmd/e2e-test/app_protocols_test.go +++ b/cmd/e2e-test/app_protocols_test.go @@ -20,7 +20,7 @@ import ( "context" "testing" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" @@ -60,8 +60,8 @@ func TestAppProtocol(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - DefaultBackend("service-1", intstr.FromString("https-port")). - AddPath("test.com", "/", "service-1", intstr.FromString("https-port")). + DefaultBackend("service-1", v1.ServiceBackendPort{Name: "https-port"}). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Name: "https-port"}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { @@ -130,8 +130,8 @@ func TestAppProtocolTransition(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - DefaultBackend("service-1", intstr.FromString("https-port")). - AddPath("test.com", "/", "service-1", intstr.FromString("https-port")). + DefaultBackend("service-1", v1.ServiceBackendPort{Name: "https-port"}). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Name: "https-port"}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { diff --git a/cmd/e2e-test/backend_config_test.go b/cmd/e2e-test/backend_config_test.go index 9721b711cd..a3a7850a8f 100644 --- a/cmd/e2e-test/backend_config_test.go +++ b/cmd/e2e-test/backend_config_test.go @@ -25,10 +25,10 @@ import ( v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/ingress-gce/pkg/e2e/adapter" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" backendconfigv1 "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" "k8s.io/ingress-gce/pkg/e2e" @@ -104,7 +104,7 @@ func TestBackendConfigNegatives(t *testing.T) { t.Fatalf("e2e.CreateEchoService(s, service-1, %q) = _, _, %v, want _, _, nil", tc.svcAnnotations, err) } - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} testIng := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). AddPath("test.com", "/", "service-1", port80). Build() diff --git a/cmd/e2e-test/basic_https_test.go b/cmd/e2e-test/basic_https_test.go index 603dafb1cf..9f60c2e2b9 100644 --- a/cmd/e2e-test/basic_https_test.go +++ b/cmd/e2e-test/basic_https_test.go @@ -21,7 +21,7 @@ import ( "fmt" "testing" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" @@ -30,7 +30,7 @@ import ( func TestBasicHTTPS(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string diff --git a/cmd/e2e-test/basic_test.go b/cmd/e2e-test/basic_test.go index 045bde71f5..3ac8368f08 100644 --- a/cmd/e2e-test/basic_test.go +++ b/cmd/e2e-test/basic_test.go @@ -21,8 +21,7 @@ import ( "fmt" "testing" - "k8s.io/api/networking/v1beta1" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" @@ -41,11 +40,11 @@ func TestBasic(t *testing.T) { func testBasicOS(t *testing.T, os e2e.OS) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress }{ { desc: "http default backend", @@ -126,7 +125,7 @@ func TestBasicStaticIP(t *testing.T) { defer e2e.DeleteGCPAddress(s, addrName, "") testIng := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - DefaultBackend("service-1", intstr.FromInt(80)). + DefaultBackend("service-1", v1.ServiceBackendPort{Number: 80}). AddStaticIP(addrName, false). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} @@ -166,11 +165,11 @@ func TestBasicStaticIP(t *testing.T) { func TestEdge(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress }{ { desc: "long ingress name", @@ -223,7 +222,7 @@ func TestEdge(t *testing.T) { // deleted. This also tests that necessary GCP frontend resources exist. func TestFrontendResourceDeletion(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} svcName := "service-1" host := "foo.com" @@ -319,7 +318,7 @@ func TestFrontendResourceDeletion(t *testing.T) { ingBuilder = ingBuilder.SetAllowHttp(true) } if tc.disableHTTPS { - ingBuilder.SetTLS([]v1beta1.IngressTLS{ + ingBuilder.SetTLS([]v1.IngressTLS{ { Hosts: []string{}, SecretName: cert.Name, diff --git a/cmd/e2e-test/cdn_test.go b/cmd/e2e-test/cdn_test.go index 219852d8e9..26279a8973 100644 --- a/cmd/e2e-test/cdn_test.go +++ b/cmd/e2e-test/cdn_test.go @@ -22,7 +22,7 @@ import ( "reflect" "testing" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" backendconfig "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" "k8s.io/ingress-gce/pkg/e2e" @@ -90,7 +90,7 @@ func TestCDN(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", "service-1", intstr.FromInt(80)). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Number: 80}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { diff --git a/cmd/e2e-test/customrequestheaders_test.go b/cmd/e2e-test/customrequestheaders_test.go index 2cd4264b17..a1e7a63a1b 100644 --- a/cmd/e2e-test/customrequestheaders_test.go +++ b/cmd/e2e-test/customrequestheaders_test.go @@ -22,8 +22,7 @@ import ( "reflect" "testing" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" backendconfig "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" "k8s.io/ingress-gce/pkg/e2e" @@ -39,7 +38,7 @@ func TestCustomRequestHeaders(t *testing.T) { t.Parallel() ing := fuzz.NewIngressBuilder("", "ingress-1", ""). - AddPath("test.com", "/", "service-1", intstr.FromInt(80)). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Number: 80}). Build() for _, tc := range []struct { @@ -74,7 +73,8 @@ func TestCustomRequestHeaders(t *testing.T) { } t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") - if _, err := Framework.Clientset.NetworkingV1beta1().Ingresses(s.Namespace).Create(context.TODO(), ing, metav1.CreateOptions{}); err != nil { + crud := adapter.IngressCRUD{C: Framework.Clientset} + if _, err := crud.Create(ing); err != nil { t.Fatalf("error creating Ingress spec: %v", err) } t.Logf("Ingress created (%s/%s)", s.Namespace, ing.Name) @@ -98,7 +98,7 @@ func TestCustomRequestHeaders(t *testing.T) { } // Wait for GCLB resources to be deleted. - if err := Framework.Clientset.NetworkingV1beta1().Ingresses(s.Namespace).Delete(context.TODO(), ing.Name, metav1.DeleteOptions{}); err != nil { + if err := crud.Delete(ing.Namespace, ing.Name); err != nil { t.Errorf("Delete(%q) = %v, want nil", ing.Name, err) } diff --git a/cmd/e2e-test/draining_test.go b/cmd/e2e-test/draining_test.go index 22a7830124..442bc51e50 100644 --- a/cmd/e2e-test/draining_test.go +++ b/cmd/e2e-test/draining_test.go @@ -22,7 +22,7 @@ import ( "testing" "time" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/util/retry" "k8s.io/ingress-gce/pkg/annotations" @@ -85,7 +85,7 @@ func TestDraining(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", "service-1", intstr.FromInt(80)). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Number: 80}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { diff --git a/cmd/e2e-test/finalizer_test.go b/cmd/e2e-test/finalizer_test.go index 1d63e795a8..c4fcff70dd 100644 --- a/cmd/e2e-test/finalizer_test.go +++ b/cmd/e2e-test/finalizer_test.go @@ -20,7 +20,7 @@ import ( "context" "testing" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" @@ -32,7 +32,7 @@ import ( func TestFinalizer(t *testing.T) { t.Parallel() ctx := context.Background() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} svcName := "service-1" ing := fuzz.NewIngressBuilder("", "ingress-1", ""). AddPath("foo.com", "/", svcName, port80). @@ -83,7 +83,7 @@ func TestFinalizer(t *testing.T) { func TestFinalizerIngressClassChange(t *testing.T) { t.Parallel() ctx := context.Background() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} svcName := "service-1" ing := fuzz.NewIngressBuilder("", "ingress-1", ""). AddPath("foo.com", "/", svcName, port80). @@ -143,7 +143,7 @@ func TestFinalizerIngressClassChange(t *testing.T) { func TestFinalizerIngressesWithSharedResources(t *testing.T) { t.Parallel() ctx := context.Background() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} svcName := "service-1" ing := fuzz.NewIngressBuilder("", "ingress-1", ""). AddPath("foo.com", "/", svcName, port80). diff --git a/cmd/e2e-test/healthcheck_test.go b/cmd/e2e-test/healthcheck_test.go index 78f6637abe..7bf4dbea70 100644 --- a/cmd/e2e-test/healthcheck_test.go +++ b/cmd/e2e-test/healthcheck_test.go @@ -22,8 +22,8 @@ import ( "testing" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud" + networkingv1 "k8s.io/api/networking/v1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/util/retry" "k8s.io/ingress-gce/pkg/annotations" @@ -98,7 +98,7 @@ func TestHealthCheck(t *testing.T) { } ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - DefaultBackend("service-1", intstr.FromInt(80)). + DefaultBackend("service-1", networkingv1.ServiceBackendPort{Number: 80}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { diff --git a/cmd/e2e-test/iap_test.go b/cmd/e2e-test/iap_test.go index 90704e6e5b..d722dd828e 100644 --- a/cmd/e2e-test/iap_test.go +++ b/cmd/e2e-test/iap_test.go @@ -20,7 +20,7 @@ import ( "context" "testing" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" backendconfig "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" "k8s.io/ingress-gce/pkg/e2e" @@ -71,7 +71,7 @@ func TestIAP(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", "service-1", intstr.FromInt(80)). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Number: 80}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { diff --git a/cmd/e2e-test/ilb_test.go b/cmd/e2e-test/ilb_test.go index 6e21f8da1f..2dd199b5a5 100644 --- a/cmd/e2e-test/ilb_test.go +++ b/cmd/e2e-test/ilb_test.go @@ -19,16 +19,16 @@ package main import ( "context" "fmt" - "k8s.io/api/networking/v1beta1" + "testing" + + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" "k8s.io/ingress-gce/pkg/fuzz/features" "k8s.io/ingress-gce/pkg/utils" - "testing" ) var ( @@ -44,11 +44,11 @@ func TestILB(t *testing.T) { ingressPrefix := "ing1-" serviceName := "svc-1" - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress numForwardingRules int numBackendServices int @@ -86,6 +86,7 @@ func TestILB(t *testing.T) { Framework.RunWithSandbox(tc.desc, t, func(t *testing.T, s *e2e.Sandbox) { t.Parallel() t.Logf("Ingress = %s", tc.ing.String()) + crud := adapter.IngressCRUD{C: Framework.Clientset} if Framework.CreateILBSubnet { if err := e2e.CreateILBSubnet(s); err != nil && err != e2e.ErrSubnetExists { @@ -99,7 +100,7 @@ func TestILB(t *testing.T) { } t.Logf("Echo service created (%s/%s)", s.Namespace, serviceName) - if _, err := Framework.Clientset.NetworkingV1beta1().Ingresses(s.Namespace).Create(context.TODO(), tc.ing, metav1.CreateOptions{}); err != nil { + if _, err := crud.Create(tc.ing); err != nil { t.Fatalf("error creating Ingress spec: %v", err) } t.Logf("Ingress created (%s/%s)", s.Namespace, tc.ing.Name) @@ -169,12 +170,12 @@ func TestILBStaticIP(t *testing.T) { defer e2e.DeleteGCPAddress(s, addrName, Framework.Region) testIngEnabled := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - DefaultBackend("service-1", intstr.FromInt(80)). + DefaultBackend("service-1", v1.ServiceBackendPort{Number: 80}). ConfigureForILB(). AddStaticIP(addrName, true). Build() testIngDisabled := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - DefaultBackend("service-1", intstr.FromInt(80)). + DefaultBackend("service-1", v1.ServiceBackendPort{Number: 80}). ConfigureForILB(). Build() @@ -187,7 +188,7 @@ func TestILBStaticIP(t *testing.T) { t.Logf("Ingress %s/%s created", s.Namespace, ing.Name) var gclb *fuzz.GCLB - for i, testIng := range []*v1beta1.Ingress{testIngDisabled, testIngEnabled, testIngDisabled} { + for i, testIng := range []*v1.Ingress{testIngDisabled, testIngEnabled, testIngDisabled} { t.Run(fmt.Sprintf("Transition-%d", i), func(t *testing.T) { newIng := ing.DeepCopy() newIng.Spec = testIng.Spec @@ -227,7 +228,7 @@ func TestILBHttps(t *testing.T) { ingressPrefix := "ing2-" serviceName := "svc-2" - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string @@ -289,6 +290,7 @@ func TestILBHttps(t *testing.T) { Framework.RunWithSandbox(tc.desc, t, func(t *testing.T, s *e2e.Sandbox) { t.Parallel() + crud := adapter.IngressCRUD{C: Framework.Clientset} if Framework.CreateILBSubnet { if err := e2e.CreateILBSubnet(s); err != nil && err != e2e.ErrSubnetExists { t.Fatalf("e2e.CreateILBSubnet(%+v) = %v", s, err) @@ -323,7 +325,7 @@ func TestILBHttps(t *testing.T) { } t.Logf("Echo service created (%s/%s)", s.Namespace, serviceName) - if _, err := Framework.Clientset.NetworkingV1beta1().Ingresses(s.Namespace).Create(context.TODO(), ing, metav1.CreateOptions{}); err != nil { + if _, err := crud.Create(ing); err != nil { t.Fatalf("error creating Ingress spec: %v", err) } t.Logf("Ingress created (%s/%s)", s.Namespace, ing.Name) @@ -373,12 +375,12 @@ func TestILBUpdate(t *testing.T) { ingressPrefix := "ing3-" serviceName := "svc-3" - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string - ing *v1beta1.Ingress - ingUpdate *v1beta1.Ingress + ing *v1.Ingress + ingUpdate *v1.Ingress numForwardingRules int numBackendServices int @@ -462,7 +464,8 @@ func TestILBUpdate(t *testing.T) { } t.Logf("Echo service created (%s/%s)", s.Namespace, serviceName) - if _, err := Framework.Clientset.NetworkingV1beta1().Ingresses(s.Namespace).Create(context.TODO(), tc.ing, metav1.CreateOptions{}); err != nil { + crud := adapter.IngressCRUD{C: Framework.Clientset} + if _, err := crud.Create(tc.ing); err != nil { t.Fatalf("error creating Ingress spec: %v", err) } t.Logf("Ingress created (%s/%s)", s.Namespace, tc.ing.Name) @@ -496,7 +499,7 @@ func TestILBUpdate(t *testing.T) { } // Perform update - if _, err := Framework.Clientset.NetworkingV1beta1().Ingresses(s.Namespace).Update(context.TODO(), tc.ingUpdate, metav1.UpdateOptions{}); err != nil { + if _, err := crud.Update(tc.ingUpdate); err != nil { t.Fatalf("error updating ingress spec: %v", err) } @@ -536,11 +539,11 @@ func TestILBError(t *testing.T) { ingressPrefix := "ing4-" serviceName := "svc-4" - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress svcAnnotations map[string]string }{ { @@ -570,7 +573,8 @@ func TestILBError(t *testing.T) { } t.Logf("Echo service created (%s/%s)", s.Namespace, serviceName) - if _, err := Framework.Clientset.NetworkingV1beta1().Ingresses(s.Namespace).Create(context.TODO(), tc.ing, metav1.CreateOptions{}); err != nil { + crud := adapter.IngressCRUD{C: Framework.Clientset} + if _, err := crud.Create(tc.ing); err != nil { t.Fatalf("error creating Ingress spec: %v", err) } t.Logf("Ingress created (%s/%s)", s.Namespace, tc.ing.Name) @@ -615,12 +619,12 @@ func TestILBShared(t *testing.T) { ingressPrefix := "ing5-" serviceName := "svc-5" - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string - ilbIng *v1beta1.Ingress - elbIng *v1beta1.Ingress + ilbIng *v1.Ingress + elbIng *v1.Ingress numForwardingRules int numBackendServices int }{ @@ -680,11 +684,12 @@ func TestILBShared(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, serviceName) var gclb *fuzz.GCLB - for _, ing := range []*v1beta1.Ingress{tc.ilbIng, tc.elbIng} { + for _, ing := range []*v1.Ingress{tc.ilbIng, tc.elbIng} { t.Logf("Ingress = %s", ing.String()) - if _, err := Framework.Clientset.NetworkingV1beta1().Ingresses(s.Namespace).Create(context.TODO(), ing, metav1.CreateOptions{}); err != nil { + crud := adapter.IngressCRUD{C: Framework.Clientset} + if _, err := crud.Create(ing); err != nil { t.Fatalf("error creating Ingress spec: %v", err) } t.Logf("Ingress created (%s/%s)", s.Namespace, ing.Name) diff --git a/cmd/e2e-test/logging_test.go b/cmd/e2e-test/logging_test.go index c7bdcaaaae..23a805cfd7 100644 --- a/cmd/e2e-test/logging_test.go +++ b/cmd/e2e-test/logging_test.go @@ -21,7 +21,7 @@ import ( "fmt" "testing" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/util/retry" "k8s.io/ingress-gce/pkg/annotations" @@ -118,7 +118,7 @@ func TestLogging(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, svcName) ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", svcName, intstr.FromInt(80)). + AddPath("test.com", "/", svcName, v1.ServiceBackendPort{Number: 80}). Build() ingKey := common.NamespacedName(ing) crud := adapter.IngressCRUD{C: Framework.Clientset} diff --git a/cmd/e2e-test/neg_test.go b/cmd/e2e-test/neg_test.go index 2ff285b705..f54de04153 100644 --- a/cmd/e2e-test/neg_test.go +++ b/cmd/e2e-test/neg_test.go @@ -19,12 +19,12 @@ package main import ( "context" "fmt" + "strconv" "testing" apps "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" - "k8s.io/apimachinery/pkg/util/intstr" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/e2e" @@ -41,7 +41,7 @@ func TestNEG(t *testing.T) { ingressName = "neg-ingress1" replicas = int32(2) ) - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} type serviceAttr struct { annotations annotations.NegAnnotation @@ -50,7 +50,7 @@ func TestNEG(t *testing.T) { for _, tc := range []struct { desc string - ingress *v1beta1.Ingress + ingress *networkingv1.Ingress services map[string]serviceAttr expectNegBackend bool expectIgBackend bool @@ -140,7 +140,7 @@ func TestNEG(t *testing.T) { func TestNEGTransition(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} ctx := context.Background() @@ -239,7 +239,7 @@ func TestNEGTransition(t *testing.T) { func TestNEGSyncEndpoints(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} svcName := "service-1" for _, tc := range []struct { @@ -390,8 +390,8 @@ func TestReadinessReflector(t *testing.T) { func TestNegCRDTransitions(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) - port443 := intstr.FromInt(443) + port80 := networkingv1.ServiceBackendPort{Number: 80} + port443 := networkingv1.ServiceBackendPort{Number: 443} serviceName := "neg-service" ctx := context.Background() @@ -410,40 +410,40 @@ func TestNegCRDTransitions(t *testing.T) { annotations: annotations.NegAnnotation{ Ingress: false, ExposedPorts: map[int32]annotations.NegAttributes{ - int32(port80.IntValue()): annotations.NegAttributes{Name: expectedNEGName}, - int32(port443.IntValue()): annotations.NegAttributes{}, + port80.Number: annotations.NegAttributes{Name: expectedNEGName}, + port443.Number: annotations.NegAttributes{}, }}, replicas: 2, - expectedNegAttrs: map[string]string{port80.String(): expectedNEGName, port443.String(): ""}, + expectedNegAttrs: map[string]string{strconv.Itoa(int(port80.Number)): expectedNEGName, strconv.Itoa(int(port443.Number)): ""}, }, {desc: "remove custom name", annotations: annotations.NegAnnotation{ Ingress: false, ExposedPorts: map[int32]annotations.NegAttributes{ - int32(port80.IntValue()): annotations.NegAttributes{}, - int32(port443.IntValue()): annotations.NegAttributes{}, + port80.Number: annotations.NegAttributes{}, + port443.Number: annotations.NegAttributes{}, }}, replicas: 2, - expectedNegAttrs: map[string]string{port80.String(): "", port443.String(): ""}, - expectedGCNegPorts: []string{port80.String()}, + expectedNegAttrs: map[string]string{strconv.Itoa(int(port80.Number)): "", strconv.Itoa(int(port443.Number)): ""}, + expectedGCNegPorts: []string{strconv.Itoa(int(port80.Number))}, }, {desc: "add custom name", annotations: annotations.NegAnnotation{ Ingress: false, ExposedPorts: map[int32]annotations.NegAttributes{ - int32(port80.IntValue()): annotations.NegAttributes{}, - int32(port443.IntValue()): annotations.NegAttributes{Name: expectedNEGName}, + port80.Number: annotations.NegAttributes{}, + port443.Number: annotations.NegAttributes{Name: expectedNEGName}, }}, replicas: 2, - expectedNegAttrs: map[string]string{port80.String(): "", port443.String(): expectedNEGName}, - expectedGCNegPorts: []string{port443.String()}, + expectedNegAttrs: map[string]string{strconv.Itoa(int(port80.Number)): "", strconv.Itoa(int(port443.Number)): expectedNEGName}, + expectedGCNegPorts: []string{strconv.Itoa(int(port443.Number))}, }, {desc: "no NEGs", annotations: annotations.NegAnnotation{ Ingress: false, ExposedPorts: map[int32]annotations.NegAttributes{}}, replicas: 2, - expectedGCNegPorts: []string{port80.String(), port443.String()}, + expectedGCNegPorts: []string{strconv.Itoa(int(port80.Number)), strconv.Itoa(int(port443.Number))}, }, } { t.Run(tc.desc, func(t *testing.T) { @@ -481,7 +481,7 @@ func TestNegCRDTransitions(t *testing.T) { func TestNegCRDErrorEvents(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} svc1 := "svc1" svc2 := "svc2" replicas := int32(2) @@ -492,7 +492,7 @@ func TestNegCRDErrorEvents(t *testing.T) { annotation := annotations.NegAnnotation{ Ingress: true, ExposedPorts: map[int32]annotations.NegAttributes{ - int32(port80.IntValue()): annotations.NegAttributes{Name: expectedNEGName}, + port80.Number: annotations.NegAttributes{Name: expectedNEGName}, }, } @@ -516,7 +516,7 @@ func TestNegCRDErrorEvents(t *testing.T) { } t.Logf("Echo service ensured (%s/%s)", s.Namespace, svc1) - expectedNegAttrs := map[string]string{port80.String(): expectedNEGName} + expectedNegAttrs := map[string]string{strconv.Itoa(int(port80.Number)): expectedNEGName} negStatus, err := e2e.WaitForNegCRs(s, svc1, expectedNegAttrs) if err != nil { t.Fatalf("Error: e2e.WaitForNegCRs(%s,%+v) = %s, want nil", svc1, expectedNegAttrs, err) @@ -552,13 +552,13 @@ func TestNegCRDErrorEvents(t *testing.T) { t.Fatalf("error ensuring echo service: %v", err) } - e2e.WaitForStandaloneNegDeletion(ctx, Framework.Cloud, s, port80.String(), negStatus) + e2e.WaitForStandaloneNegDeletion(ctx, Framework.Cloud, s, strconv.Itoa(int(port80.Number)), negStatus) }) } func TestNegDisruptive(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} replicas := int32(2) serviceName := "disruptive-neg-service" // gcSvcName is the name of the service used to determine if GC has finished @@ -567,7 +567,7 @@ func TestNegDisruptive(t *testing.T) { annotation := annotations.NegAnnotation{ ExposedPorts: map[int32]annotations.NegAttributes{ - int32(port80.IntValue()): annotations.NegAttributes{}, + port80.Number: annotations.NegAttributes{}, }, } @@ -580,7 +580,7 @@ func TestNegDisruptive(t *testing.T) { } t.Logf("GC service ensured (%s/%s)", s.Namespace, gcSvcName) - expectedNegAttrs := map[string]string{port80.String(): ""} + expectedNegAttrs := map[string]string{strconv.Itoa(int(port80.Number)): ""} negStatus, err := e2e.WaitForNegCRs(s, gcSvcName, expectedNegAttrs) if err != nil { t.Fatalf("Error: e2e.WaitForNegCRs(%s,%+v) = %s, want nil", gcSvcName, expectedNegAttrs, err) @@ -600,7 +600,7 @@ func TestNegDisruptive(t *testing.T) { } t.Logf("GC service deleted (%s/%s)", s.Namespace, gcSvcName) - if err := e2e.WaitForStandaloneNegDeletion(ctx, s.ValidatorEnv.Cloud(), s, port80.String(), negStatus); err != nil { + if err := e2e.WaitForStandaloneNegDeletion(ctx, s.ValidatorEnv.Cloud(), s, strconv.Itoa(int(port80.Number)), negStatus); err != nil { t.Fatalf("Error waiting for NEGDeletion: %v", err) } } @@ -718,7 +718,7 @@ func TestNegDisruptive(t *testing.T) { } if tc.waitForNeg { - expectedNegAttrs := map[string]string{port80.String(): ""} + expectedNegAttrs := map[string]string{strconv.Itoa(int(port80.Number)): ""} negStatus, err := e2e.WaitForNegCRs(s, serviceName, expectedNegAttrs) if err != nil { t.Fatalf("Error: e2e.WaitForNegCRs(%s,%+v) = %s, want nil", serviceName, expectedNegAttrs, err) @@ -747,7 +747,7 @@ func TestNegDisruptive(t *testing.T) { } if tc.waitForNegGC { - if err := e2e.WaitForStandaloneNegDeletion(ctx, s.ValidatorEnv.Cloud(), s, port80.String(), previousNegStatus); err != nil { + if err := e2e.WaitForStandaloneNegDeletion(ctx, s.ValidatorEnv.Cloud(), s, strconv.Itoa(int(port80.Number)), previousNegStatus); err != nil { t.Fatalf("Error waiting for NEGDeletion: %v", err) } } diff --git a/cmd/e2e-test/redirects_test.go b/cmd/e2e-test/redirects_test.go index 0161fb4e33..a88f41c95d 100644 --- a/cmd/e2e-test/redirects_test.go +++ b/cmd/e2e-test/redirects_test.go @@ -21,10 +21,9 @@ import ( "fmt" "testing" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" frontendconfig "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" @@ -34,7 +33,7 @@ import ( // Does not run in parallel since this is a transition test func TestHttpsRedirects(t *testing.T) { ctx := context.Background() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} // Run all test cases in the same sandbox to share certs Framework.RunWithSandbox("https redirects transition_e2e", t, func(t *testing.T, s *e2e.Sandbox) { @@ -57,7 +56,7 @@ func TestHttpsRedirects(t *testing.T) { // Each test is a transition on the original ingress var gclb *fuzz.GCLB - var ing *v1beta1.Ingress + var ing *v1.Ingress for _, tc := range []struct { desc string ingBuilder *fuzz.IngressBuilder diff --git a/cmd/e2e-test/security_policy_test.go b/cmd/e2e-test/security_policy_test.go index 9c9c7339e0..4f2a02a2fe 100644 --- a/cmd/e2e-test/security_policy_test.go +++ b/cmd/e2e-test/security_policy_test.go @@ -24,11 +24,11 @@ import ( "time" computebeta "google.golang.org/api/compute/v0.beta" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/e2e/adapter" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/ingress-gce/pkg/annotations" @@ -107,7 +107,7 @@ func TestSecurityPolicyEnable(t *testing.T) { } t.Logf("Backend config %s/%s created", s.Namespace, testBackendConfig.Name) - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} testIng := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). DefaultBackend("service-1", port80). AddPath("test.com", "/", "service-1", port80). @@ -185,7 +185,7 @@ func TestSecurityPolicyTransition(t *testing.T) { } t.Logf("Backend config %s/%s created", s.Namespace, testBackendConfig.Name) - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} testIng := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). DefaultBackend("service-1", port80). AddPath("test.com", "/", "service-1", port80). diff --git a/cmd/e2e-test/sslpolicy_test.go b/cmd/e2e-test/sslpolicy_test.go index ce6483aa6e..4b1a25f4b7 100644 --- a/cmd/e2e-test/sslpolicy_test.go +++ b/cmd/e2e-test/sslpolicy_test.go @@ -25,9 +25,8 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" "google.golang.org/api/compute/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/api/errors" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" @@ -39,7 +38,7 @@ const policyName = "e2e-ssl-policy" // TestSSLPolicy is a transition test func TestSSLPolicy(t *testing.T) { ctx := context.Background() - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} // Run all test cases in the same sandbox to share certs Framework.RunWithSandbox("sslpolicy_e2e", t, func(t *testing.T, s *e2e.Sandbox) { @@ -67,7 +66,7 @@ func TestSSLPolicy(t *testing.T) { } var gclb *fuzz.GCLB - var ing *v1beta1.Ingress + var ing *networkingv1.Ingress for _, tc := range []struct { desc string configPolicyName string diff --git a/cmd/e2e-test/timeout_test.go b/cmd/e2e-test/timeout_test.go index 8a1e16ca21..113bb88801 100644 --- a/cmd/e2e-test/timeout_test.go +++ b/cmd/e2e-test/timeout_test.go @@ -21,7 +21,7 @@ import ( "fmt" "testing" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" backendconfig "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" "k8s.io/ingress-gce/pkg/e2e" @@ -76,7 +76,7 @@ func TestTimeout(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", "service-1", intstr.FromInt(80)). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Number: 80}). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} if _, err := crud.Create(ing); err != nil { @@ -166,7 +166,7 @@ func TestILBCT(t *testing.T) { t.Logf("Echo service created (%s/%s)", s.Namespace, "service-1") ing := fuzz.NewIngressBuilder(s.Namespace, "ingress-1", ""). - AddPath("test.com", "/", "service-1", intstr.FromInt(80)). + AddPath("test.com", "/", "service-1", v1.ServiceBackendPort{Number: 80}). ConfigureForILB(). Build() crud := adapter.IngressCRUD{C: Framework.Clientset} diff --git a/cmd/e2e-test/upgrade/basic_http.go b/cmd/e2e-test/upgrade/basic_http.go index 60e9cbead2..b1b269f1cc 100644 --- a/cmd/e2e-test/upgrade/basic_http.go +++ b/cmd/e2e-test/upgrade/basic_http.go @@ -20,8 +20,7 @@ import ( "context" "testing" - "k8s.io/api/networking/v1beta1" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" @@ -29,7 +28,7 @@ import ( ) var ( - port80 = intstr.FromInt(80) + port80 = v1.ServiceBackendPort{Number: 80} ingName = "ing1" ) @@ -39,7 +38,7 @@ type BasicHTTP struct { s *e2e.Sandbox framework *e2e.Framework crud adapter.IngressCRUD - ing *v1beta1.Ingress + ing *v1.Ingress } // NewBasicHTTPUpgradeTest returns an upgrade test that tests the basic behavior diff --git a/cmd/e2e-test/upgrade/finalizer.go b/cmd/e2e-test/upgrade/finalizer.go index b7d179488f..d681ed7c68 100644 --- a/cmd/e2e-test/upgrade/finalizer.go +++ b/cmd/e2e-test/upgrade/finalizer.go @@ -20,7 +20,7 @@ import ( "context" "testing" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" @@ -33,7 +33,7 @@ type Finalizer struct { s *e2e.Sandbox framework *e2e.Framework crud adapter.IngressCRUD - ing *v1beta1.Ingress + ing *v1.Ingress } // NewFinalizerUpgradeTest returns an upgrade test that asserts that finalizer diff --git a/cmd/e2e-test/upgrade/v2frontendnamer.go b/cmd/e2e-test/upgrade/v2frontendnamer.go index 7b3372c07d..2cc68fff6b 100644 --- a/cmd/e2e-test/upgrade/v2frontendnamer.go +++ b/cmd/e2e-test/upgrade/v2frontendnamer.go @@ -20,7 +20,7 @@ import ( "context" "testing" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" @@ -33,7 +33,7 @@ type V2FrontendNamer struct { s *e2e.Sandbox framework *e2e.Framework crud adapter.IngressCRUD - ing *v1beta1.Ingress + ing *v1.Ingress } // NewV2FrontendNamerTest returns upgrade test for v2 frontend namer. diff --git a/cmd/e2e-test/v2frontendnamer_test.go b/cmd/e2e-test/v2frontendnamer_test.go index 4092469821..d1712a38b5 100644 --- a/cmd/e2e-test/v2frontendnamer_test.go +++ b/cmd/e2e-test/v2frontendnamer_test.go @@ -21,8 +21,7 @@ import ( "fmt" "testing" - "k8s.io/api/networking/v1beta1" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/e2e" "k8s.io/ingress-gce/pkg/e2e/adapter" "k8s.io/ingress-gce/pkg/fuzz" @@ -34,7 +33,7 @@ import ( // with v1 naming scheme. func TestV2FrontendNamer(t *testing.T) { t.Parallel() - port80 := intstr.FromInt(80) + port80 := v1.ServiceBackendPort{Number: 80} svcName := "service-1" v1Ing := fuzz.NewIngressBuilder("", "ing-v1", ""). AddPath("foo.com", "/", svcName, port80). @@ -46,18 +45,18 @@ func TestV2FrontendNamer(t *testing.T) { for _, tc := range []struct { desc string - ings []*v1beta1.Ingress + ings []*v1.Ingress }{ - {"v2 only", []*v1beta1.Ingress{v2Ing}}, - {"v1 only", []*v1beta1.Ingress{v1Ing}}, + {"v2 only", []*v1.Ingress{v2Ing}}, + {"v1 only", []*v1.Ingress{v1Ing}}, // The following test cases create ingresses with both naming schemes. These // test cases assert that GC of v1 naming scheme does not affect ingress with // v2 naming scheme and vice-versa. // Note that the first element in the list of ingresses is deleted first, // which tests that GC of the naming scheme for first ingress does not affect // other naming scheme. - {"both v1 and v2, delete v1 first", []*v1beta1.Ingress{v1Ing, v2Ing}}, - {"both v1 and v2, delete v2 first", []*v1beta1.Ingress{v2Ing, v1Ing}}, + {"both v1 and v2, delete v1 first", []*v1.Ingress{v1Ing, v2Ing}}, + {"both v1 and v2, delete v2 first", []*v1.Ingress{v2Ing, v1Ing}}, } { tc := tc desc := fmt.Sprintf("v2 frontend namer %s", tc.desc) @@ -72,7 +71,7 @@ func TestV2FrontendNamer(t *testing.T) { crud := adapter.IngressCRUD{C: Framework.Clientset} var gclbs []*fuzz.GCLB - var updatedIngs []*v1beta1.Ingress + var updatedIngs []*v1.Ingress // Create Ingresses. for _, ing := range tc.ings { diff --git a/cmd/fuzzer/app/validate.go b/cmd/fuzzer/app/validate.go index 4807d90469..9910f2e1e6 100644 --- a/cmd/fuzzer/app/validate.go +++ b/cmd/fuzzer/app/validate.go @@ -127,7 +127,7 @@ func Validate() { fmt.Printf("Features = %v\n\n", fsNames) k8s := k8sClientSet(config) - ing, err := k8s.NetworkingV1beta1().Ingresses(validateOptions.ns).Get(context.TODO(), validateOptions.name, metav1.GetOptions{}) + ing, err := k8s.NetworkingV1().Ingresses(validateOptions.ns).Get(context.TODO(), validateOptions.name, metav1.GetOptions{}) if err != nil { panic(err) } diff --git a/cmd/glbc/app/init.go b/cmd/glbc/app/init.go index 05a0df47cf..8b4c4764b9 100644 --- a/cmd/glbc/app/init.go +++ b/cmd/glbc/app/init.go @@ -22,6 +22,7 @@ import ( "time" v1 "k8s.io/api/core/v1" + networkingv1 "k8s.io/api/networking/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/wait" diff --git a/cmd/glbc/app/namer.go b/cmd/glbc/app/namer.go index d8d8912f08..b263f9900d 100644 --- a/cmd/glbc/app/namer.go +++ b/cmd/glbc/app/namer.go @@ -161,7 +161,7 @@ func getClusterUID(kubeClient kubernetes.Interface, name string) (string, error) } // Check if the cluster has an Ingress with ip - ings, err := kubeClient.ExtensionsV1beta1().Ingresses(metav1.NamespaceAll).List(context.TODO(), metav1.ListOptions{ + ings, err := kubeClient.NetworkingV1().Ingresses(metav1.NamespaceAll).List(context.TODO(), metav1.ListOptions{ LabelSelector: labels.Everything().String(), }) if err != nil { diff --git a/go.sum b/go.sum index f9b2705686..b13d3e13bb 100644 --- a/go.sum +++ b/go.sum @@ -675,6 +675,7 @@ google.golang.org/api v0.15.1-0.20200106000736-b8fc810ca6b5/go.mod h1:iLdEw5Ide6 google.golang.org/api v0.15.1/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= google.golang.org/api v0.35.0 h1:TBCmTTxUrRDA1iTctnK/fIeitxIZ+TQuaf0j29fmCGo= google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.45.0 h1:pqMffJFLBVUDIoYsHcqtxgQVTsmxMDpYLOc5MT4Jrww= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= diff --git a/pkg/annotations/ingress.go b/pkg/annotations/ingress.go index 9479bfd83f..e54023c573 100644 --- a/pkg/annotations/ingress.go +++ b/pkg/annotations/ingress.go @@ -20,7 +20,7 @@ import ( "errors" "strconv" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" ) const ( @@ -114,7 +114,7 @@ type Ingress struct { } // FromIngress extracts the annotations from an Ingress definition. -func FromIngress(ing *v1beta1.Ingress) *Ingress { +func FromIngress(ing *v1.Ingress) *Ingress { result := &Ingress{} if ing != nil { result.v = ing.Annotations diff --git a/pkg/annotations/ingress_test.go b/pkg/annotations/ingress_test.go index 9828fbd822..b06cf0b366 100644 --- a/pkg/annotations/ingress_test.go +++ b/pkg/annotations/ingress_test.go @@ -19,14 +19,14 @@ package annotations import ( "testing" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) func TestIngress(t *testing.T) { for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress allowHTTP bool useNamedTLS string staticIPName string @@ -35,12 +35,12 @@ func TestIngress(t *testing.T) { }{ { desc: "Empty ingress", - ing: &v1beta1.Ingress{}, + ing: &v1.Ingress{}, allowHTTP: true, // defaults to true. }, { desc: "Global and Regional StaticIP Specified", - ing: &v1beta1.Ingress{ + ing: &v1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ GlobalStaticIPNameKey: "1.2.3.4", @@ -56,7 +56,7 @@ func TestIngress(t *testing.T) { }, { desc: "Test most annotations", - ing: &v1beta1.Ingress{ + ing: &v1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ AllowHTTPKey: "false", diff --git a/pkg/annotations/service.go b/pkg/annotations/service.go index f104af5cef..66dfee08ef 100644 --- a/pkg/annotations/service.go +++ b/pkg/annotations/service.go @@ -20,9 +20,10 @@ import ( "encoding/json" "errors" "fmt" - "k8s.io/api/core/v1" - "k8s.io/legacy-cloud-providers/gce" "strings" + + v1 "k8s.io/api/core/v1" + "k8s.io/legacy-cloud-providers/gce" ) const ( diff --git a/pkg/backends/features/features_test.go b/pkg/backends/features/features_test.go index 86f8261210..8b7b884d58 100644 --- a/pkg/backends/features/features_test.go +++ b/pkg/backends/features/features_test.go @@ -20,8 +20,8 @@ import ( "testing" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/ingress-gce/pkg/annotations" @@ -35,7 +35,7 @@ var ( Namespace: "testNS", Name: "testName", }, - Port: intstr.IntOrString{IntVal: 80}, + Port: v1.ServiceBackendPort{Number: 80}, } svcPortDefault = utils.ServicePort{ diff --git a/pkg/backends/syncer_test.go b/pkg/backends/syncer_test.go index 48a9bdb6b5..f2ae25a1ad 100644 --- a/pkg/backends/syncer_test.go +++ b/pkg/backends/syncer_test.go @@ -30,6 +30,7 @@ import ( "google.golang.org/api/compute/v1" "google.golang.org/api/googleapi" api_v1 "k8s.io/api/core/v1" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/ingress-gce/pkg/annotations" @@ -575,9 +576,9 @@ func TestEnsureBackendServiceProtocol(t *testing.T) { syncer := newTestSyncer(fakeGCE) svcPorts := []utils.ServicePort{ - {NodePort: 80, Protocol: annotations.ProtocolHTTP, ID: utils.ServicePortID{Port: intstr.FromInt(1)}, BackendNamer: defaultNamer}, - {NodePort: 443, Protocol: annotations.ProtocolHTTPS, ID: utils.ServicePortID{Port: intstr.FromInt(2)}, BackendNamer: defaultNamer}, - {NodePort: 3000, Protocol: annotations.ProtocolHTTP2, ID: utils.ServicePortID{Port: intstr.FromInt(3)}, BackendNamer: defaultNamer}, + {NodePort: 80, Protocol: annotations.ProtocolHTTP, ID: utils.ServicePortID{Port: networkingv1.ServiceBackendPort{Number: 1}}, BackendNamer: defaultNamer}, + {NodePort: 443, Protocol: annotations.ProtocolHTTPS, ID: utils.ServicePortID{Port: networkingv1.ServiceBackendPort{Number: 2}}, BackendNamer: defaultNamer}, + {NodePort: 3000, Protocol: annotations.ProtocolHTTP2, ID: utils.ServicePortID{Port: networkingv1.ServiceBackendPort{Number: 3}}, BackendNamer: defaultNamer}, } for _, oldPort := range svcPorts { @@ -619,9 +620,9 @@ func TestEnsureBackendServiceDescription(t *testing.T) { syncer := newTestSyncer(fakeGCE) svcPorts := []utils.ServicePort{ - {NodePort: 80, Protocol: annotations.ProtocolHTTP, ID: utils.ServicePortID{Port: intstr.FromInt(1)}, BackendNamer: defaultNamer}, - {NodePort: 443, Protocol: annotations.ProtocolHTTPS, ID: utils.ServicePortID{Port: intstr.FromInt(2)}, BackendNamer: defaultNamer}, - {NodePort: 3000, Protocol: annotations.ProtocolHTTP2, ID: utils.ServicePortID{Port: intstr.FromInt(3)}, BackendNamer: defaultNamer}, + {NodePort: 80, Protocol: annotations.ProtocolHTTP, ID: utils.ServicePortID{Port: networkingv1.ServiceBackendPort{Number: 1}}, BackendNamer: defaultNamer}, + {NodePort: 443, Protocol: annotations.ProtocolHTTPS, ID: utils.ServicePortID{Port: networkingv1.ServiceBackendPort{Number: 2}}, BackendNamer: defaultNamer}, + {NodePort: 3000, Protocol: annotations.ProtocolHTTP2, ID: utils.ServicePortID{Port: networkingv1.ServiceBackendPort{Number: 3}}, BackendNamer: defaultNamer}, } for _, oldPort := range svcPorts { @@ -656,7 +657,7 @@ func TestEnsureBackendServiceHealthCheckLink(t *testing.T) { fakeGCE := gce.NewFakeGCECloud(gce.DefaultTestClusterValues()) syncer := newTestSyncer(fakeGCE) - p := utils.ServicePort{NodePort: 80, Protocol: annotations.ProtocolHTTP, ID: utils.ServicePortID{Port: intstr.FromInt(1)}, BackendNamer: defaultNamer} + p := utils.ServicePort{NodePort: 80, Protocol: annotations.ProtocolHTTP, ID: utils.ServicePortID{Port: networkingv1.ServiceBackendPort{Number: 1}}, BackendNamer: defaultNamer} syncer.Sync([]utils.ServicePort{p}) be, err := syncer.backendPool.Get(p.BackendName(), features.VersionFromServicePort(&p), features.ScopeFromServicePort(&p)) if err != nil { diff --git a/pkg/common/operator/frontendconfig.go b/pkg/common/operator/frontendconfig.go index 154cca1a06..36163eeba7 100644 --- a/pkg/common/operator/frontendconfig.go +++ b/pkg/common/operator/frontendconfig.go @@ -3,7 +3,7 @@ package operator import ( "fmt" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" ) @@ -27,7 +27,7 @@ func (op *FrontendConfigsOperator) AsList() []*frontendconfigv1beta1.FrontendCon } // ReferencedByIngress returns the FrontendConfigs that are referenced by the passed in Ingress. -func (op *FrontendConfigsOperator) ReferencedByIngress(ing *v1beta1.Ingress) *FrontendConfigsOperator { +func (op *FrontendConfigsOperator) ReferencedByIngress(ing *v1.Ingress) *FrontendConfigsOperator { dupes := map[string]bool{} var f []*frontendconfigv1beta1.FrontendConfig @@ -43,7 +43,7 @@ func (op *FrontendConfigsOperator) ReferencedByIngress(ing *v1beta1.Ingress) *Fr // doesIngressReferenceFrontendConfig returns true if the passed in Ingress directly references // the passed in FrontendConfig. -func doesIngressReferenceFrontendConfig(ing *v1beta1.Ingress, feConfig *frontendconfigv1beta1.FrontendConfig) bool { +func doesIngressReferenceFrontendConfig(ing *v1.Ingress, feConfig *frontendconfigv1beta1.FrontendConfig) bool { if ing.Namespace != feConfig.Namespace { return false } diff --git a/pkg/common/operator/frontendconfig_test.go b/pkg/common/operator/frontendconfig_test.go index e4af26e314..30effab252 100644 --- a/pkg/common/operator/frontendconfig_test.go +++ b/pkg/common/operator/frontendconfig_test.go @@ -3,7 +3,7 @@ package operator import ( "testing" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/test" ) @@ -12,7 +12,7 @@ func TestDoesIngressReferenceFrontendConfig(t *testing.T) { testCases := []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress expected bool }{ { diff --git a/pkg/common/operator/ingress.go b/pkg/common/operator/ingress.go index 9b73249f88..2c66935a18 100644 --- a/pkg/common/operator/ingress.go +++ b/pkg/common/operator/ingress.go @@ -7,30 +7,30 @@ import ( frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" ) // Ingresses returns the wrapper -func Ingresses(i []*v1beta1.Ingress) *IngressesOperator { +func Ingresses(i []*v1.Ingress) *IngressesOperator { return &IngressesOperator{i: i} } // IngressesOperator is an operator wrapper for a list of Ingresses. type IngressesOperator struct { - i []*v1beta1.Ingress + i []*v1.Ingress } // AsList returns the underlying list of Ingresses. -func (op *IngressesOperator) AsList() []*v1beta1.Ingress { +func (op *IngressesOperator) AsList() []*v1.Ingress { if op.i == nil { - return []*v1beta1.Ingress{} + return []*v1.Ingress{} } return op.i } // Filter the list of Ingresses based on a predicate. -func (op *IngressesOperator) Filter(f func(*v1beta1.Ingress) bool) *IngressesOperator { - var i []*v1beta1.Ingress +func (op *IngressesOperator) Filter(f func(*v1.Ingress) bool) *IngressesOperator { + var i []*v1.Ingress for _, ing := range op.i { if f(ing) { i = append(i, ing) @@ -40,9 +40,9 @@ func (op *IngressesOperator) Filter(f func(*v1beta1.Ingress) bool) *IngressesOpe } // Partition partitions the list of Ingresses into two: Ingresses that match given predicate and those that don't. -func (op *IngressesOperator) Partition(f func(*v1beta1.Ingress) bool) (*IngressesOperator, *IngressesOperator) { +func (op *IngressesOperator) Partition(f func(*v1.Ingress) bool) (*IngressesOperator, *IngressesOperator) { // A list of ingresses that satisfy the predicate condition and it's complement - var i, ci []*v1beta1.Ingress + var i, ci []*v1.Ingress for _, ing := range op.i { if f(ing) { i = append(i, ing) @@ -57,7 +57,7 @@ func (op *IngressesOperator) Partition(f func(*v1beta1.Ingress) bool) (*Ingresse func (op *IngressesOperator) ReferencesService(svc *api_v1.Service) *IngressesOperator { dupes := map[string]bool{} - var i []*v1beta1.Ingress + var i []*v1.Ingress for _, ing := range op.i { key := fmt.Sprintf("%s/%s", ing.Namespace, ing.Name) if doesIngressReferenceService(ing, svc) && !dupes[key] { @@ -72,7 +72,7 @@ func (op *IngressesOperator) ReferencesService(svc *api_v1.Service) *IngressesOp func (op *IngressesOperator) ReferencesBackendConfig(beConfig *backendconfigv1.BackendConfig, svcsOp *ServicesOperator) *IngressesOperator { dupes := map[string]bool{} - var i []*v1beta1.Ingress + var i []*v1.Ingress svcs := svcsOp.ReferencesBackendConfig(beConfig).AsList() for _, ing := range op.i { for _, svc := range svcs { @@ -90,7 +90,7 @@ func (op *IngressesOperator) ReferencesBackendConfig(beConfig *backendconfigv1.B func (op *IngressesOperator) ReferencesFrontendConfig(feConfig *frontendconfigv1beta1.FrontendConfig) *IngressesOperator { dupes := map[string]bool{} - var i []*v1beta1.Ingress + var i []*v1.Ingress for _, ing := range op.i { key := fmt.Sprintf("%s/%s", ing.Namespace, ing.Name) if doesIngressReferenceFrontendConfig(ing, feConfig) && !dupes[key] { diff --git a/pkg/common/operator/service.go b/pkg/common/operator/service.go index 853dcffd46..174d02c92a 100644 --- a/pkg/common/operator/service.go +++ b/pkg/common/operator/service.go @@ -7,7 +7,7 @@ import ( "k8s.io/ingress-gce/pkg/utils" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" ) // Services returns the wrapper @@ -44,7 +44,7 @@ func (op *ServicesOperator) ReferencesBackendConfig(beConfig *backendconfigv1.Ba } // ReferencedByIngress returns the Services that are referenced by the passed in Ingress. -func (op *ServicesOperator) ReferencedByIngress(ing *v1beta1.Ingress) *ServicesOperator { +func (op *ServicesOperator) ReferencedByIngress(ing *v1.Ingress) *ServicesOperator { dupes := map[string]bool{} var s []*api_v1.Service @@ -60,7 +60,7 @@ func (op *ServicesOperator) ReferencedByIngress(ing *v1beta1.Ingress) *ServicesO // doesIngressReferenceService returns true if the passed in Ingress directly references // the passed in Service. -func doesIngressReferenceService(ing *v1beta1.Ingress, svc *api_v1.Service) bool { +func doesIngressReferenceService(ing *v1.Ingress, svc *api_v1.Service) bool { if ing.Namespace != svc.Namespace { return false } diff --git a/pkg/common/typed/ingress.go b/pkg/common/typed/ingress.go index 7f8e9a87ba..1ad47d35f4 100644 --- a/pkg/common/typed/ingress.go +++ b/pkg/common/typed/ingress.go @@ -1,7 +1,7 @@ package typed import ( - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/client-go/tools/cache" ) @@ -16,19 +16,19 @@ type IngressStore struct { } // Add implements Store. -func (s *IngressStore) Add(i *v1beta1.Ingress) error { return s.store.Add(i) } +func (s *IngressStore) Add(i *v1.Ingress) error { return s.store.Add(i) } // Update implements Store. -func (s *IngressStore) Update(i *v1beta1.Ingress) error { return s.store.Update(i) } +func (s *IngressStore) Update(i *v1.Ingress) error { return s.store.Update(i) } // Delete implements Store. -func (s *IngressStore) Delete(i *v1beta1.Ingress) error { return s.store.Delete(i) } +func (s *IngressStore) Delete(i *v1.Ingress) error { return s.store.Delete(i) } // List implements Store. -func (s *IngressStore) List() []*v1beta1.Ingress { - var ret []*v1beta1.Ingress +func (s *IngressStore) List() []*v1.Ingress { + var ret []*v1.Ingress for _, obj := range s.store.List() { - ret = append(ret, obj.(*v1beta1.Ingress)) + ret = append(ret, obj.(*v1.Ingress)) } return ret } @@ -37,25 +37,25 @@ func (s *IngressStore) List() []*v1beta1.Ingress { func (s *IngressStore) ListKeys() []string { return s.store.ListKeys() } // Get implements Store. -func (s *IngressStore) Get(i *v1beta1.Ingress) (*v1beta1.Ingress, bool, error) { +func (s *IngressStore) Get(i *v1.Ingress) (*v1.Ingress, bool, error) { item, exists, err := s.store.Get(i) if item == nil { return nil, exists, err } - return item.(*v1beta1.Ingress), exists, err + return item.(*v1.Ingress), exists, err } // GetByKey implements Store. -func (s *IngressStore) GetByKey(key string) (*v1beta1.Ingress, bool, error) { +func (s *IngressStore) GetByKey(key string) (*v1.Ingress, bool, error) { item, exists, err := s.store.GetByKey(key) if item == nil { return nil, exists, err } - return item.(*v1beta1.Ingress), exists, err + return item.(*v1.Ingress), exists, err } // Resync implements Store. func (s *IngressStore) Resync() error { return s.store.Resync() } // This function is mostly likely not useful for ordinary consumers. -// func (s *IngressStore) Replace(items []*v1beta1.Ingress, string) error {} +// func (s *IngressStore) Replace(items []*v1.Ingress, string) error {} diff --git a/pkg/context/context.go b/pkg/context/context.go index 928d8c9439..dd760e5849 100644 --- a/pkg/context/context.go +++ b/pkg/context/context.go @@ -29,7 +29,7 @@ import ( "k8s.io/client-go/dynamic" "k8s.io/client-go/dynamic/dynamicinformer" informerv1 "k8s.io/client-go/informers/core/v1" - informerv1beta1 "k8s.io/client-go/informers/networking/v1beta1" + informernetworking "k8s.io/client-go/informers/networking/v1" "k8s.io/client-go/kubernetes" "k8s.io/client-go/kubernetes/scheme" corev1 "k8s.io/client-go/kubernetes/typed/core/v1" @@ -141,7 +141,7 @@ func NewControllerContext( KubeSystemUID: kubeSystemUID, ControllerMetrics: metrics.NewControllerMetrics(), ControllerContextConfig: config, - IngressInformer: informerv1beta1.NewIngressInformer(kubeClient, config.Namespace, config.ResyncPeriod, utils.NewNamespaceIndexer()), + IngressInformer: informernetworking.NewIngressInformer(kubeClient, config.Namespace, config.ResyncPeriod, utils.NewNamespaceIndexer()), ServiceInformer: informerv1.NewServiceInformer(kubeClient, config.Namespace, config.ResyncPeriod, utils.NewNamespaceIndexer()), BackendConfigInformer: informerbackendconfig.NewBackendConfigInformer(backendConfigClient, config.Namespace, config.ResyncPeriod, utils.NewNamespaceIndexer()), EndpointInformer: informerv1.NewEndpointsInformer(kubeClient, config.Namespace, config.ResyncPeriod, utils.NewNamespaceIndexer()), @@ -157,7 +157,7 @@ func NewControllerContext( } if ingParamsClient != nil { - context.IngClassInformer = informerv1beta1.NewIngressClassInformer(kubeClient, config.ResyncPeriod, utils.NewNamespaceIndexer()) + context.IngClassInformer = informernetworking.NewIngressClassInformer(kubeClient, config.ResyncPeriod, utils.NewNamespaceIndexer()) context.IngParamsInformer = informeringparams.NewGCPIngressParamsInformer(ingParamsClient, config.ResyncPeriod, utils.NewNamespaceIndexer()) } diff --git a/pkg/controller/controller.go b/pkg/controller/controller.go index b36e1312c7..acd17a0899 100644 --- a/pkg/controller/controller.go +++ b/pkg/controller/controller.go @@ -25,7 +25,7 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" apiv1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/client-go/kubernetes" unversionedcore "k8s.io/client-go/kubernetes/typed/core/v1" @@ -139,7 +139,7 @@ func NewLoadBalancerController( // Ingress event handlers. ctx.IngressInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{ AddFunc: func(obj interface{}) { - addIng := obj.(*v1beta1.Ingress) + addIng := obj.(*v1.Ingress) if !utils.IsGLBCIngress(addIng) { klog.V(4).Infof("Ignoring add for ingress %v based on annotation %v", common.NamespacedName(addIng), annotations.IngressClassKey) return @@ -150,7 +150,7 @@ func NewLoadBalancerController( lbc.ingQueue.Enqueue(obj) }, DeleteFunc: func(obj interface{}) { - delIng := obj.(*v1beta1.Ingress) + delIng := obj.(*v1.Ingress) if delIng == nil { klog.Errorf("Invalid object type: %T", obj) return @@ -169,7 +169,7 @@ func NewLoadBalancerController( lbc.ingQueue.Enqueue(obj) }, UpdateFunc: func(old, cur interface{}) { - curIng := cur.(*v1beta1.Ingress) + curIng := cur.(*v1.Ingress) if !utils.IsGLBCIngress(curIng) { // Ingress needs to be enqueued if a ingress finalizer exists. // An existing finalizer means that @@ -412,7 +412,7 @@ func (lbc *LoadBalancerController) SyncBackends(state interface{}) error { } // syncInstanceGroup creates instance groups, syncs instances, sets named ports and updates instance group annotation -func (lbc *LoadBalancerController) syncInstanceGroup(ing *v1beta1.Ingress, ingSvcPorts []utils.ServicePort) error { +func (lbc *LoadBalancerController) syncInstanceGroup(ing *v1.Ingress, ingSvcPorts []utils.ServicePort) error { nodePorts := nodePorts(ingSvcPorts) klog.V(2).Infof("Syncing Instance Group for ingress %v/%v with nodeports %v", ing.Namespace, ing.Name, nodePorts) igs, err := lbc.instancePool.EnsureInstanceGroupsAndPorts(lbc.ctx.ClusterNamer.InstanceGroup(), nodePorts) @@ -450,7 +450,7 @@ func (lbc *LoadBalancerController) syncInstanceGroup(ing *v1beta1.Ingress, ingSv } // GCBackends implements Controller. -func (lbc *LoadBalancerController) GCBackends(toKeep []*v1beta1.Ingress) error { +func (lbc *LoadBalancerController) GCBackends(toKeep []*v1.Ingress) error { // Only GCE ingress associated resources are managed by this controller. GCEIngresses := operator.Ingresses(toKeep).Filter(utils.IsGCEIngress).AsList() svcPortsToKeep := lbc.ToSvcPorts(GCEIngresses) @@ -493,23 +493,23 @@ func (lbc *LoadBalancerController) SyncLoadBalancer(state interface{}) error { } // GCv1LoadBalancers implements Controller. -func (lbc *LoadBalancerController) GCv1LoadBalancers(toKeep []*v1beta1.Ingress) error { +func (lbc *LoadBalancerController) GCv1LoadBalancers(toKeep []*v1.Ingress) error { return lbc.l7Pool.GCv1(common.ToIngressKeys(toKeep)) } // GCv2LoadBalancer implements Controller. -func (lbc *LoadBalancerController) GCv2LoadBalancer(ing *v1beta1.Ingress, scope meta.KeyType) error { +func (lbc *LoadBalancerController) GCv2LoadBalancer(ing *v1.Ingress, scope meta.KeyType) error { return lbc.l7Pool.GCv2(ing, scope) } // EnsureDeleteV1Finalizers implements Controller. -func (lbc *LoadBalancerController) EnsureDeleteV1Finalizers(toCleanup []*v1beta1.Ingress) error { +func (lbc *LoadBalancerController) EnsureDeleteV1Finalizers(toCleanup []*v1.Ingress) error { if !flags.F.FinalizerRemove { klog.V(4).Infof("Removing finalizers not enabled") return nil } for _, ing := range toCleanup { - ingClient := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace) + ingClient := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace) if err := common.EnsureDeleteFinalizer(ing, ingClient, common.FinalizerKey); err != nil { klog.Errorf("Failed to ensure delete finalizer %s for ingress %s: %v", common.FinalizerKey, common.NamespacedName(ing), err) return err @@ -519,12 +519,12 @@ func (lbc *LoadBalancerController) EnsureDeleteV1Finalizers(toCleanup []*v1beta1 } // EnsureDeleteV2Finalizer implements Controller. -func (lbc *LoadBalancerController) EnsureDeleteV2Finalizer(ing *v1beta1.Ingress) error { +func (lbc *LoadBalancerController) EnsureDeleteV2Finalizer(ing *v1.Ingress) error { if !flags.F.FinalizerRemove { klog.V(4).Infof("Removing finalizers not enabled") return nil } - ingClient := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace) + ingClient := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace) if err := common.EnsureDeleteFinalizer(ing, ingClient, common.FinalizerKeyV2); err != nil { klog.Errorf("Failed to ensure delete finalizer %s for ingress %s: %v", common.FinalizerKeyV2, common.NamespacedName(ing), err) return err @@ -635,12 +635,12 @@ func (lbc *LoadBalancerController) sync(key string) error { // updateIngressStatus updates the IP and annotations of a loadbalancer. // The annotations are parsed by kubectl describe. -func (lbc *LoadBalancerController) updateIngressStatus(l7 *loadbalancers.L7, ing *v1beta1.Ingress) error { - ingClient := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace) +func (lbc *LoadBalancerController) updateIngressStatus(l7 *loadbalancers.L7, ing *v1.Ingress) error { + ingClient := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace) // Update IP through update/status endpoint ip := l7.GetIP() - updatedIngStatus := v1beta1.IngressStatus{ + updatedIngStatus := v1.IngressStatus{ LoadBalancer: apiv1.LoadBalancerStatus{ Ingress: []apiv1.LoadBalancerIngress{ {IP: ip}, @@ -671,7 +671,7 @@ func (lbc *LoadBalancerController) updateIngressStatus(l7 *loadbalancers.L7, ing } // toRuntimeInfo returns L7RuntimeInfo for the given ingress. -func (lbc *LoadBalancerController) toRuntimeInfo(ing *v1beta1.Ingress, urlMap *utils.GCEURLMap) (*loadbalancers.L7RuntimeInfo, error) { +func (lbc *LoadBalancerController) toRuntimeInfo(ing *v1.Ingress, urlMap *utils.GCEURLMap) (*loadbalancers.L7RuntimeInfo, error) { annotations := annotations.FromIngress(ing) env, err := translator.NewEnv(ing, lbc.ctx.KubeClient, "", "", "") if err != nil { @@ -724,11 +724,11 @@ func (lbc *LoadBalancerController) toRuntimeInfo(ing *v1beta1.Ingress, urlMap *u }, nil } -func updateAnnotations(client kubernetes.Interface, ing *v1beta1.Ingress, newAnnotations map[string]string) error { +func updateAnnotations(client kubernetes.Interface, ing *v1.Ingress, newAnnotations map[string]string) error { if reflect.DeepEqual(ing.Annotations, newAnnotations) { return nil } - ingClient := client.NetworkingV1beta1().Ingresses(ing.Namespace) + ingClient := client.NetworkingV1().Ingresses(ing.Namespace) newObjectMeta := ing.ObjectMeta.DeepCopy() newObjectMeta.Annotations = newAnnotations if _, err := common.PatchIngressObjectMetadata(ingClient, ing, *newObjectMeta); err != nil { @@ -740,7 +740,7 @@ func updateAnnotations(client kubernetes.Interface, ing *v1beta1.Ingress, newAnn // ToSvcPorts returns a list of SVC ports given a list of ingresses. // Note: This method is used for GC. -func (lbc *LoadBalancerController) ToSvcPorts(ings []*v1beta1.Ingress) []utils.ServicePort { +func (lbc *LoadBalancerController) ToSvcPorts(ings []*v1.Ingress) []utils.ServicePort { var knownPorts []utils.ServicePort for _, ing := range ings { urlMap, _ := lbc.Translator.TranslateIngress(ing, lbc.ctx.DefaultBackendSvcPort.ID, lbc.ctx.ClusterNamer) @@ -751,7 +751,7 @@ func (lbc *LoadBalancerController) ToSvcPorts(ings []*v1beta1.Ingress) []utils.S // defaultFrontendNamingScheme returns frontend naming scheme for an ingress without finalizer. // This is used for adding an appropriate finalizer on the ingress. -func (lbc *LoadBalancerController) defaultFrontendNamingScheme(ing *v1beta1.Ingress) (namer.Scheme, error) { +func (lbc *LoadBalancerController) defaultFrontendNamingScheme(ing *v1.Ingress) (namer.Scheme, error) { // Ingress frontend naming scheme is determined based on the following logic, // V2 frontend namer is disabled : v1 frontend naming scheme // V2 frontend namer is enabled @@ -776,7 +776,7 @@ func (lbc *LoadBalancerController) defaultFrontendNamingScheme(ing *v1beta1.Ingr } // ensureFinalizer ensures that a finalizer is attached. -func (lbc *LoadBalancerController) ensureFinalizer(ing *v1beta1.Ingress) (*v1beta1.Ingress, error) { +func (lbc *LoadBalancerController) ensureFinalizer(ing *v1.Ingress) (*v1.Ingress, error) { ingKey := common.NamespacedName(ing) if common.HasFinalizer(ing.ObjectMeta) { klog.V(4).Infof("Finalizer exists for ingress %s", ingKey) @@ -790,7 +790,7 @@ func (lbc *LoadBalancerController) ensureFinalizer(ing *v1beta1.Ingress) (*v1bet if err != nil { return nil, err } - ingClient := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace) + ingClient := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace) // Update ingress with finalizer so that load-balancer pool uses correct naming scheme // while ensuring frontend resources. Note that this updates only the finalizer annotation // which may be inconsistent with ingress store for a short period. @@ -814,7 +814,7 @@ func (lbc *LoadBalancerController) ensureFinalizer(ing *v1beta1.Ingress) (*v1bet // - Finalizer enabled : all backends // - Finalizer disabled : v1 frontends and all backends // - Scope changed : v2 frontends for all scope -func frontendGCAlgorithm(ingExists bool, scopeChange bool, ing *v1beta1.Ingress) utils.FrontendGCAlgorithm { +func frontendGCAlgorithm(ingExists bool, scopeChange bool, ing *v1.Ingress) utils.FrontendGCAlgorithm { // If ingress does not exist, that means its pre-finalizer era. // Run GC via v1 naming scheme. if !ingExists { diff --git a/pkg/controller/controller_test.go b/pkg/controller/controller_test.go index de71957dc4..bf742fd37a 100644 --- a/pkg/controller/controller_test.go +++ b/pkg/controller/controller_test.go @@ -30,10 +30,9 @@ import ( "github.com/google/go-cmp/cmp" "google.golang.org/api/compute/v1" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/client-go/kubernetes/fake" "k8s.io/ingress-gce/pkg/annotations" @@ -112,35 +111,35 @@ func addService(lbc *LoadBalancerController, svc *api_v1.Service) { lbc.ctx.ServiceInformer.GetIndexer().Add(svc) } -func addIngress(lbc *LoadBalancerController, ing *v1beta1.Ingress) { - lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Create(context2.TODO(), ing, meta_v1.CreateOptions{}) +func addIngress(lbc *LoadBalancerController, ing *networkingv1.Ingress) { + lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Create(context2.TODO(), ing, meta_v1.CreateOptions{}) lbc.ctx.IngressInformer.GetIndexer().Add(ing) } -func updateIngress(lbc *LoadBalancerController, ing *v1beta1.Ingress) { - lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Update(context2.TODO(), ing, meta_v1.UpdateOptions{}) +func updateIngress(lbc *LoadBalancerController, ing *networkingv1.Ingress) { + lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Update(context2.TODO(), ing, meta_v1.UpdateOptions{}) lbc.ctx.IngressInformer.GetIndexer().Update(ing) } -func setDeletionTimestamp(lbc *LoadBalancerController, ing *v1beta1.Ingress) { +func setDeletionTimestamp(lbc *LoadBalancerController, ing *networkingv1.Ingress) { ts := meta_v1.NewTime(time.Now()) ing.SetDeletionTimestamp(&ts) updateIngress(lbc, ing) } -func deleteIngress(lbc *LoadBalancerController, ing *v1beta1.Ingress) { +func deleteIngress(lbc *LoadBalancerController, ing *networkingv1.Ingress) { if len(ing.GetFinalizers()) == 0 { deleteIngressWithFinalizer(lbc, ing) } } -func deleteIngressWithFinalizer(lbc *LoadBalancerController, ing *v1beta1.Ingress) { - lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Delete(context2.TODO(), ing.Name, meta_v1.DeleteOptions{}) +func deleteIngressWithFinalizer(lbc *LoadBalancerController, ing *networkingv1.Ingress) { + lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Delete(context2.TODO(), ing.Name, meta_v1.DeleteOptions{}) lbc.ctx.IngressInformer.GetIndexer().Delete(ing) } // getKey returns the key for an ingress. -func getKey(ing *v1beta1.Ingress, t *testing.T) string { +func getKey(ing *networkingv1.Ingress, t *testing.T) string { key, err := common.KeyFunc(ing) if err != nil { t.Fatalf("Unexpected error getting key for Ingress %v: %v", ing.Name, err) @@ -148,10 +147,12 @@ func getKey(ing *v1beta1.Ingress, t *testing.T) string { return key } -func backend(name string, port intstr.IntOrString) v1beta1.IngressBackend { - return v1beta1.IngressBackend{ - ServiceName: name, - ServicePort: port, +func backend(name string, port networkingv1.ServiceBackendPort) networkingv1.IngressBackend { + return networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: name, + Port: port, + }, } } @@ -160,10 +161,10 @@ func backend(name string, port intstr.IntOrString) v1beta1.IngressBackend { func TestIngressSyncError(t *testing.T) { lbc := newLoadBalancerController() - someBackend := backend("my-service", intstr.FromInt(80)) + someBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &someBackend, + networkingv1.IngressSpec{ + DefaultBackend: &someBackend, }) addIngress(lbc, ing) @@ -173,8 +174,8 @@ func TestIngressSyncError(t *testing.T) { t.Fatalf("lbc.sync(%v) = nil, want error", ingStoreKey) } - if !strings.Contains(err.Error(), someBackend.ServiceName) { - t.Errorf("lbc.sync(%v) = %v, want error containing %q", ingStoreKey, err, someBackend.ServiceName) + if !strings.Contains(err.Error(), someBackend.Service.Name) { + t.Errorf("lbc.sync(%v) = %v, want error containing %q", ingStoreKey, err, someBackend.Service.Name) } } @@ -191,10 +192,10 @@ func TestNEGOnlyIngress(t *testing.T) { annotations.NEGAnnotationKey: negAnnotation.String(), } addService(lbc, svc) - someBackend := backend("my-service", intstr.FromInt(80)) + someBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &someBackend, + networkingv1.IngressSpec{ + DefaultBackend: &someBackend, }) addIngress(lbc, ing) @@ -259,12 +260,12 @@ func TestIngressCreateDeleteFinalizer(t *testing.T) { Ports: []api_v1.ServicePort{{Port: 80}}, }) addService(lbc, svc) - defaultBackend := backend("my-service", intstr.FromInt(80)) + defaultBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) for _, name := range tc.ingNames { ing := test.NewIngress(types.NamespacedName{Name: name, Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) addIngress(lbc, ing) @@ -273,7 +274,7 @@ func TestIngressCreateDeleteFinalizer(t *testing.T) { t.Fatalf("lbc.sync(%v) = %v, want nil", ingStoreKey, err) } - updatedIng, _ := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) + updatedIng, _ := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) // Check Ingress status has IP. if len(updatedIng.Status.LoadBalancer.Ingress) != 1 || updatedIng.Status.LoadBalancer.Ingress[0].IP == "" { @@ -292,7 +293,7 @@ func TestIngressCreateDeleteFinalizer(t *testing.T) { } for i, name := range tc.ingNames { - ing, _ := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses("default").Get(context2.TODO(), name, meta_v1.GetOptions{}) + ing, _ := lbc.ctx.KubeClient.NetworkingV1().Ingresses("default").Get(context2.TODO(), name, meta_v1.GetOptions{}) setDeletionTimestamp(lbc, ing) ingStoreKey := getKey(ing, t) @@ -300,10 +301,10 @@ func TestIngressCreateDeleteFinalizer(t *testing.T) { t.Fatalf("lbc.sync(%v) = %v, want nil", ingStoreKey, err) } - updatedIng, _ := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses("default").Get(context2.TODO(), name, meta_v1.GetOptions{}) + updatedIng, _ := lbc.ctx.KubeClient.NetworkingV1().Ingresses("default").Get(context2.TODO(), name, meta_v1.GetOptions{}) deleteIngress(lbc, updatedIng) - updatedIng, _ = lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses("default").Get(context2.TODO(), name, meta_v1.GetOptions{}) + updatedIng, _ = lbc.ctx.KubeClient.NetworkingV1().Ingresses("default").Get(context2.TODO(), name, meta_v1.GetOptions{}) if tc.enableFinalizerAdd && !tc.enableFinalizerRemove { if updatedIng == nil { t.Fatalf("Expected Ingress not to be deleted") @@ -319,7 +320,7 @@ func TestIngressCreateDeleteFinalizer(t *testing.T) { t.Fatalf("Ingress was not deleted, got: %+v", updatedIng) } - remainingIngresses, err := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses("default").List(context2.TODO(), meta_v1.ListOptions{}) + remainingIngresses, err := lbc.ctx.KubeClient.NetworkingV1().Ingresses("default").List(context2.TODO(), meta_v1.ListOptions{}) if err != nil { t.Fatalf("List() = %v, want nil", err) } @@ -352,10 +353,10 @@ func TestIngressClassChangeWithFinalizer(t *testing.T) { }) anns := map[string]string{annotations.IngressClassKey: "gce"} addService(lbc, svc) - defaultBackend := backend("my-service", intstr.FromInt(80)) + defaultBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) ing.ObjectMeta.Annotations = anns addIngress(lbc, ing) @@ -365,7 +366,7 @@ func TestIngressClassChangeWithFinalizer(t *testing.T) { t.Fatalf("lbc.sync(%v) = %v, want nil", ingStoreKey, err) } // Check if finalizer is added when an Ingress resource is created with finalizer enabled. - updatedIng, err := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) + updatedIng, err := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) if err != nil { t.Fatalf("Get(%v) = %v, want nil", ingStoreKey, err) } @@ -382,7 +383,7 @@ func TestIngressClassChangeWithFinalizer(t *testing.T) { t.Fatalf("lbc.sync(%v) = %v, want nil", ingStoreKey, err) } // Check if finalizer is removed after class changes. - updatedIng, err = lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) + updatedIng, err = lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) if err != nil { t.Fatalf("Get(%v) = %v, want nil", ingStoreKey, err) } @@ -408,14 +409,14 @@ func TestIngressesWithSharedResourcesWithFinalizer(t *testing.T) { Ports: []api_v1.ServicePort{{Port: 80}}, }) addService(lbc, svc) - defaultBackend := backend("my-service", intstr.FromInt(80)) + defaultBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) otherIng := test.NewIngress(types.NamespacedName{Name: "my-other-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) addIngress(lbc, ing) addIngress(lbc, otherIng) @@ -431,8 +432,8 @@ func TestIngressesWithSharedResourcesWithFinalizer(t *testing.T) { } // Assert service ports are being shared. - ingSvcPorts := lbc.ToSvcPorts([]*v1beta1.Ingress{ing}) - otherIngSvcPorts := lbc.ToSvcPorts([]*v1beta1.Ingress{otherIng}) + ingSvcPorts := lbc.ToSvcPorts([]*networkingv1.Ingress{ing}) + otherIngSvcPorts := lbc.ToSvcPorts([]*networkingv1.Ingress{otherIng}) comparer := cmp.Comparer(func(a, b utils.ServicePort) bool { return reflect.DeepEqual(a, b) }) @@ -451,7 +452,7 @@ func TestIngressesWithSharedResourcesWithFinalizer(t *testing.T) { } } - remainingIngresses, err := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses("default").List(context2.TODO(), meta_v1.ListOptions{}) + remainingIngresses, err := lbc.ctx.KubeClient.NetworkingV1().Ingresses("default").List(context2.TODO(), meta_v1.ListOptions{}) if err != nil { t.Fatalf("List() = %v, want nil", err) } @@ -475,10 +476,10 @@ func TestEnableFinalizer(t *testing.T) { Ports: []api_v1.ServicePort{{Port: 80}}, }) addService(lbc, svc) - defaultBackend := backend("my-service", intstr.FromInt(80)) + defaultBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "namespace1"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) addIngress(lbc, ing) @@ -488,7 +489,7 @@ func TestEnableFinalizer(t *testing.T) { } // Ensure that no finalizer is added. - updatedIng, err := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) + updatedIng, err := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) if err != nil { t.Fatalf("Get(%v) = %v, want nil", ingStoreKey, err) } @@ -504,7 +505,7 @@ func TestEnableFinalizer(t *testing.T) { } // Check if finalizer is added after finalizer is enabled. - updatedIng, err = lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) + updatedIng, err = lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) if err != nil { t.Fatalf("Get(%v) = %v, want nil", ingStoreKey, err) } @@ -523,10 +524,10 @@ func TestIngressClassChange(t *testing.T) { Ports: []api_v1.ServicePort{{Port: 80}}, }) addService(lbc, svc) - defaultBackend := backend("my-service", intstr.FromInt(80)) + defaultBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) ing.ObjectMeta.Annotations = map[string]string{"kubernetes.io/ingress.class": "gce"} addIngress(lbc, ing) @@ -543,7 +544,7 @@ func TestIngressClassChange(t *testing.T) { } // Check status of LoadBalancer is updated after class changes - updatedIng, _ := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) + updatedIng, _ := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) if len(updatedIng.Status.LoadBalancer.Ingress) != 0 { t.Error("Ingress status wasn't updated after class changed") } @@ -559,10 +560,10 @@ func TestEnsureMCIngress(t *testing.T) { }) addService(lbc, svc) - defaultBackend := backend("my-service", intstr.FromInt(80)) + defaultBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) ing.ObjectMeta.Annotations = map[string]string{"kubernetes.io/ingress.class": "gce-multi-cluster"} addIngress(lbc, ing) @@ -573,7 +574,7 @@ func TestEnsureMCIngress(t *testing.T) { } // Check Ingress has annotations noting the instance group name. - updatedIng, _ := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) + updatedIng, _ := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) igAnnotationKey := "ingress.gcp.kubernetes.io/instance-groups" wantVal := `[{"Name":"k8s-ig--aaaaa","Zone":"zone-a"}]` if val, ok := updatedIng.GetAnnotations()[igAnnotationKey]; !ok { @@ -593,14 +594,14 @@ func TestMCIngressIG(t *testing.T) { }) addService(lbc, svc) - defaultBackend := backend("my-service", intstr.FromInt(80)) + defaultBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) mcIng := test.NewIngress(types.NamespacedName{Name: "my-mc-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) mcIng.ObjectMeta.Annotations = map[string]string{"kubernetes.io/ingress.class": "gce-multi-cluster"} addIngress(lbc, ing) @@ -617,7 +618,7 @@ func TestMCIngressIG(t *testing.T) { } // Check multi-cluster Ingress has annotations noting the instance group name. - updatedMcIng, err := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(mcIng.Namespace).Get(context2.TODO(), mcIng.Name, meta_v1.GetOptions{}) + updatedMcIng, err := lbc.ctx.KubeClient.NetworkingV1().Ingresses(mcIng.Namespace).Get(context2.TODO(), mcIng.Name, meta_v1.GetOptions{}) if err != nil { t.Fatalf("Get(%v) = %v, want nil", mcIngStoreKey, err) } @@ -693,12 +694,12 @@ func TestToRuntimeInfoCerts(t *testing.T) { } presharedCertName := "preSharedCert" - ing := &v1beta1.Ingress{ + ing := &networkingv1.Ingress{ ObjectMeta: meta_v1.ObjectMeta{ Annotations: map[string]string{annotations.PreSharedCertKey: presharedCertName}, }, - Spec: v1beta1.IngressSpec{ - TLS: []v1beta1.IngressTLS{ + Spec: networkingv1.IngressSpec{ + TLS: []networkingv1.IngressTLS{ { SecretName: tlsCerts[0].Name, }, @@ -765,10 +766,10 @@ func TestIngressTagging(t *testing.T) { }) addService(lbc, svc) - defaultBackend := backend("my-service", intstr.FromInt(80)) + defaultBackend := backend("my-service", networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) if tc.vipExists { ing.Status.LoadBalancer.Ingress = []api_v1.LoadBalancerIngress{{IP: "0.0.0.0"}} @@ -785,7 +786,7 @@ func TestIngressTagging(t *testing.T) { t.Fatalf("lbc.sync(%v) = %v, want nil", ingStoreKey, err) } - updatedIng, err := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) + updatedIng, err := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) if err != nil { t.Fatalf("Get(%v) = %v, want nil", ingStoreKey, err) } @@ -827,7 +828,7 @@ func TestGCMultiple(t *testing.T) { } lbc := newLoadBalancerController() // Create ingresses and run sync on them. - var updatedIngs []*v1beta1.Ingress + var updatedIngs []*networkingv1.Ingress for _, ing := range ings { updatedIngs = append(updatedIngs, ensureIngress(t, lbc, namespace, ing, namer_util.V1NamingScheme)) } @@ -861,7 +862,7 @@ func TestGCMultiple(t *testing.T) { // Assert that controller returns same ingresses as expected ingresses. // Controller sync removes finalizers from all deletion candidates. // Filter ingresses with finalizer for un-deleted ingresses. - allIngresses := operator.Ingresses(lbc.ctx.Ingresses().List()).Filter(func(ing *v1beta1.Ingress) bool { + allIngresses := operator.Ingresses(lbc.ctx.Ingresses().List()).Filter(func(ing *networkingv1.Ingress) bool { return common.HasFinalizer(ing.ObjectMeta) }).AsList() allIngressKeys = common.ToIngressKeys(allIngresses) @@ -926,7 +927,7 @@ func TestGC(t *testing.T) { } lbc := newLoadBalancerController() // Create ingresses and run sync on them. - var v1Ingresses, v2Ingresses []*v1beta1.Ingress + var v1Ingresses, v2Ingresses []*networkingv1.Ingress for _, ing := range tc.v1IngressNames { v1Ingresses = append(v1Ingresses, ensureIngress(t, lbc, namespace, ing, namer_util.V1NamingScheme)) } @@ -976,7 +977,7 @@ func TestGC(t *testing.T) { // Assert that controller returns same ingresses as expected ingresses. // Controller sync removes finalizers from all deletion candidates. // Filter ingresses with finalizer for un-deleted ingresses. - allIngresses := operator.Ingresses(lbc.ctx.Ingresses().List()).Filter(func(ing *v1beta1.Ingress) bool { + allIngresses := operator.Ingresses(lbc.ctx.Ingresses().List()).Filter(func(ing *networkingv1.Ingress) bool { return common.HasFinalizer(ing.ObjectMeta) }).AsList() allIngressKeys = common.ToIngressKeys(allIngresses) @@ -990,7 +991,7 @@ func TestGC(t *testing.T) { // ensureIngress creates an ingress and syncs it with ingress controller. // This returns updated ingress after sync. -func ensureIngress(t *testing.T, lbc *LoadBalancerController, namespace, name string, scheme namer_util.Scheme) *v1beta1.Ingress { +func ensureIngress(t *testing.T, lbc *LoadBalancerController, namespace, name string, scheme namer_util.Scheme) *networkingv1.Ingress { serviceName := fmt.Sprintf("service-for-%s", name) svc := test.NewService(types.NamespacedName{Name: serviceName, Namespace: namespace}, api_v1.ServiceSpec{ Type: api_v1.ServiceTypeNodePort, @@ -998,10 +999,10 @@ func ensureIngress(t *testing.T, lbc *LoadBalancerController, namespace, name st }) addService(lbc, svc) - defaultBackend := backend(serviceName, intstr.FromInt(80)) + defaultBackend := backend(serviceName, networkingv1.ServiceBackendPort{Number: 80}) ing := test.NewIngress(types.NamespacedName{Name: name, Namespace: namespace}, - v1beta1.IngressSpec{ - Backend: &defaultBackend, + networkingv1.IngressSpec{ + DefaultBackend: &defaultBackend, }) if scheme == namer_util.V1NamingScheme { ing.ObjectMeta.Finalizers = []string{common.FinalizerKey} @@ -1018,8 +1019,8 @@ func ensureIngress(t *testing.T, lbc *LoadBalancerController, namespace, name st return getUpdatedIngress(t, lbc, ing) } -func getUpdatedIngress(t *testing.T, lbc *LoadBalancerController, ing *v1beta1.Ingress) *v1beta1.Ingress { - updatedIng, err := lbc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) +func getUpdatedIngress(t *testing.T, lbc *LoadBalancerController, ing *networkingv1.Ingress) *networkingv1.Ingress { + updatedIng, err := lbc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Get(context2.TODO(), ing.Name, meta_v1.GetOptions{}) if err != nil { t.Fatalf("lbc.ctx.KubeClient...Get(%v) = %v, want nil", getKey(ing, t), err) } diff --git a/pkg/controller/translator/testdata/ingress-missing-multi-svc.json b/pkg/controller/translator/testdata/ingress-missing-multi-svc.json index 4ff70f878b..35513ad4ba 100644 --- a/pkg/controller/translator/testdata/ingress-missing-multi-svc.json +++ b/pkg/controller/translator/testdata/ingress-missing-multi-svc.json @@ -5,7 +5,9 @@ "Namespace": "kube-system", "Name": "default-http-backend" }, - "Port": "http" + "Port": { + "Name": "http" + } } }, "HostRules": [ diff --git a/pkg/controller/translator/testdata/ingress-missing-multi-svc.yaml b/pkg/controller/translator/testdata/ingress-missing-multi-svc.yaml index b304ca0a97..a59a341ec5 100644 --- a/pkg/controller/translator/testdata/ingress-missing-multi-svc.yaml +++ b/pkg/controller/translator/testdata/ingress-missing-multi-svc.yaml @@ -1,4 +1,4 @@ -apiVersion: networking.k8s.io/v1beta1 +apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: test-ingress @@ -10,12 +10,16 @@ spec: paths: - path: /testpath backend: - serviceName: some-service - servicePort: 80 + service: + name: some-service + port: + number: 80 - host: abc.com http: paths: - path: /* backend: - serviceName: other-service - servicePort: 80 + service: + name: other-service + port: + number: 80 diff --git a/pkg/controller/translator/testdata/ingress-missing-rule-svc.json b/pkg/controller/translator/testdata/ingress-missing-rule-svc.json index 72c3ac017b..a45452b385 100644 --- a/pkg/controller/translator/testdata/ingress-missing-rule-svc.json +++ b/pkg/controller/translator/testdata/ingress-missing-rule-svc.json @@ -5,7 +5,9 @@ "Namespace": "kube-system", "Name": "default-http-backend" }, - "Port": "http" + "Port": { + "Name": "http" + } } }, "HostRules": [ @@ -20,7 +22,9 @@ "Namespace": "default", "Name": "first-service" }, - "Port": 80 + "Port": { + "Number": 80 + } } } } diff --git a/pkg/controller/translator/testdata/ingress-missing-rule-svc.yaml b/pkg/controller/translator/testdata/ingress-missing-rule-svc.yaml index 137f509790..19a168dab5 100644 --- a/pkg/controller/translator/testdata/ingress-missing-rule-svc.yaml +++ b/pkg/controller/translator/testdata/ingress-missing-rule-svc.yaml @@ -1,4 +1,4 @@ -apiVersion: networking.k8s.io/v1beta1 +apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: test-ingress @@ -10,12 +10,16 @@ spec: paths: - path: /testpath backend: - serviceName: first-service - servicePort: 80 + service: + name: first-service + port: + number: 80 - host: abc.com http: paths: - path: /* backend: - serviceName: other-service - servicePort: 80 + service: + name: other-service + port: + number: 80 diff --git a/pkg/controller/translator/testdata/ingress-multi-empty.json b/pkg/controller/translator/testdata/ingress-multi-empty.json index bcc6a4a277..c2ff4a8ff2 100644 --- a/pkg/controller/translator/testdata/ingress-multi-empty.json +++ b/pkg/controller/translator/testdata/ingress-multi-empty.json @@ -5,7 +5,9 @@ "Namespace": "kube-system", "Name": "default-http-backend" }, - "Port": "http" + "Port": { + "Name": "http" + } } }, "HostRules": [ @@ -19,7 +21,9 @@ "Namespace": "default", "Name": "second-service" }, - "Port": 80 + "Port": { + "Number": 80 + } } } }] diff --git a/pkg/controller/translator/testdata/ingress-multi-empty.yaml b/pkg/controller/translator/testdata/ingress-multi-empty.yaml index fe0411b93d..817530e0e9 100644 --- a/pkg/controller/translator/testdata/ingress-multi-empty.yaml +++ b/pkg/controller/translator/testdata/ingress-multi-empty.yaml @@ -1,4 +1,4 @@ -apiVersion: networking.k8s.io/v1beta1 +apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: test-ingress @@ -10,9 +10,13 @@ spec: paths: - path: backend: - serviceName: first-service - servicePort: 80 + service: + name: first-service + port: + number: 80 - path: backend: - serviceName: second-service - servicePort: 80 + service: + name: second-service + port: + number: 80 diff --git a/pkg/controller/translator/testdata/ingress-multi-paths.json b/pkg/controller/translator/testdata/ingress-multi-paths.json index 7be179c59a..17592ba8a4 100644 --- a/pkg/controller/translator/testdata/ingress-multi-paths.json +++ b/pkg/controller/translator/testdata/ingress-multi-paths.json @@ -5,7 +5,9 @@ "Namespace": "kube-system", "Name": "default-http-backend" }, - "Port": "http" + "Port": { + "Name": "http" + } } }, "HostRules": [ @@ -20,7 +22,9 @@ "Namespace": "default", "Name": "first-service" }, - "Port": 80 + "Port": { + "Number": 80 + } } } }, @@ -32,7 +36,9 @@ "Namespace": "default", "Name": "second-service" }, - "Port": 80 + "Port": { + "Number": 80 + } } } } diff --git a/pkg/controller/translator/testdata/ingress-multi-paths.yaml b/pkg/controller/translator/testdata/ingress-multi-paths.yaml index 7a5bc5c4bb..e22a53493e 100644 --- a/pkg/controller/translator/testdata/ingress-multi-paths.yaml +++ b/pkg/controller/translator/testdata/ingress-multi-paths.yaml @@ -1,4 +1,4 @@ -apiVersion: networking.k8s.io/v1beta1 +apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: test-ingress @@ -10,9 +10,13 @@ spec: paths: - path: /testpath backend: - serviceName: first-service - servicePort: 80 + service: + name: first-service + port: + number: 80 - path: /otherpath backend: - serviceName: second-service - servicePort: 80 + service: + name: second-service + port: + number: 80 diff --git a/pkg/controller/translator/testdata/ingress-no-host.json b/pkg/controller/translator/testdata/ingress-no-host.json index 7beb03c3dd..e82513d15c 100644 --- a/pkg/controller/translator/testdata/ingress-no-host.json +++ b/pkg/controller/translator/testdata/ingress-no-host.json @@ -5,7 +5,9 @@ "Namespace": "kube-system", "Name": "default-http-backend" }, - "Port": "http" + "Port": { + "Name":"http" + } } }, "HostRules": [ @@ -20,7 +22,9 @@ "Namespace": "default", "Name": "first-service" }, - "Port": 80 + "Port": { + "Number" : 80 + } } } } diff --git a/pkg/controller/translator/testdata/ingress-no-host.yaml b/pkg/controller/translator/testdata/ingress-no-host.yaml index 3e564fa93e..9e8bb6930e 100644 --- a/pkg/controller/translator/testdata/ingress-no-host.yaml +++ b/pkg/controller/translator/testdata/ingress-no-host.yaml @@ -1,4 +1,4 @@ -apiVersion: networking.k8s.io/v1beta1 +apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: test-ingress @@ -9,5 +9,7 @@ spec: paths: - path: /testpath backend: - serviceName: first-service - servicePort: 80 + service: + name: first-service + port: + number: 80 diff --git a/pkg/controller/translator/testdata/ingress-single-host.json b/pkg/controller/translator/testdata/ingress-single-host.json index d04693aaed..ab30ba7c60 100644 --- a/pkg/controller/translator/testdata/ingress-single-host.json +++ b/pkg/controller/translator/testdata/ingress-single-host.json @@ -5,7 +5,9 @@ "Namespace": "kube-system", "Name": "default-http-backend" }, - "Port": "http" + "Port": { + "Name": "http" + } } }, "HostRules": [ @@ -20,7 +22,9 @@ "Namespace": "default", "Name": "first-service" }, - "Port": 80 + "Port": { + "Number": 80 + } } } } diff --git a/pkg/controller/translator/testdata/ingress-single-host.yaml b/pkg/controller/translator/testdata/ingress-single-host.yaml index ee8713446f..9d70a25fad 100644 --- a/pkg/controller/translator/testdata/ingress-single-host.yaml +++ b/pkg/controller/translator/testdata/ingress-single-host.yaml @@ -1,4 +1,4 @@ -apiVersion: networking.k8s.io/v1beta1 +apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: test-ingress @@ -10,5 +10,7 @@ spec: paths: - path: /testpath backend: - serviceName: first-service - servicePort: 80 + service: + name: first-service + port: + number: 80 diff --git a/pkg/controller/translator/testdata/ingress-two-hosts.json b/pkg/controller/translator/testdata/ingress-two-hosts.json index b6e2d1eaa3..df641e0f66 100644 --- a/pkg/controller/translator/testdata/ingress-two-hosts.json +++ b/pkg/controller/translator/testdata/ingress-two-hosts.json @@ -5,7 +5,9 @@ "Namespace": "kube-system", "Name": "default-http-backend" }, - "Port": "http" + "Port": { + "Name": "http" + } } }, "HostRules": [ @@ -20,7 +22,9 @@ "Namespace": "default", "Name": "first-service" }, - "Port": 80 + "Port": { + "Number" : 80 + } } } } @@ -37,7 +41,9 @@ "Namespace": "default", "Name": "second-service" }, - "Port": 80 + "Port": { + "Number" : 80 + } } } } diff --git a/pkg/controller/translator/testdata/ingress-two-hosts.yaml b/pkg/controller/translator/testdata/ingress-two-hosts.yaml index a8d08f8821..ce94a7a0b6 100644 --- a/pkg/controller/translator/testdata/ingress-two-hosts.yaml +++ b/pkg/controller/translator/testdata/ingress-two-hosts.yaml @@ -1,4 +1,4 @@ -apiVersion: networking.k8s.io/v1beta1 +apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: test-ingress @@ -9,11 +9,15 @@ spec: http: paths: - backend: - serviceName: first-service - servicePort: 80 + service: + name: first-service + port: + number: 80 - host: abc.com http: paths: - backend: - serviceName: second-service - servicePort: 80 + service: + name: second-service + port: + number: 80 diff --git a/pkg/controller/translator/translator.go b/pkg/controller/translator/translator.go index 1cbb6a9972..7a47f12a70 100644 --- a/pkg/controller/translator/translator.go +++ b/pkg/controller/translator/translator.go @@ -24,7 +24,7 @@ import ( "k8s.io/klog" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/api/meta" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/labels" @@ -193,7 +193,7 @@ func (t *Translator) getServicePort(id utils.ServicePortID, params *getServicePo } // TranslateIngress converts an Ingress into our internal UrlMap representation. -func (t *Translator) TranslateIngress(ing *v1beta1.Ingress, systemDefaultBackend utils.ServicePortID, namer namer_util.BackendNamer) (*utils.GCEURLMap, []error) { +func (t *Translator) TranslateIngress(ing *v1.Ingress, systemDefaultBackend utils.ServicePortID, namer namer_util.BackendNamer) (*utils.GCEURLMap, []error) { var errs []error urlMap := utils.NewGCEURLMap() @@ -237,8 +237,8 @@ func (t *Translator) TranslateIngress(ing *v1beta1.Ingress, systemDefaultBackend urlMap.PutPathRulesForHost(host, pathRules) } - if ing.Spec.Backend != nil { - svcPort, err := t.getServicePort(utils.BackendToServicePortID(*ing.Spec.Backend, ing.Namespace), params, namer) + if ing.Spec.DefaultBackend != nil { + svcPort, err := t.getServicePort(utils.BackendToServicePortID(*ing.Spec.DefaultBackend, ing.Namespace), params, namer) if err == nil { urlMap.DefaultBackend = svcPort return urlMap, errs @@ -261,23 +261,23 @@ func (t *Translator) TranslateIngress(ing *v1beta1.Ingress, systemDefaultBackend // validateAndGetPaths will validate the path based on the specifed path type and will return the // the path rules that should be used. If no path type is provided, the path type will be assumed // to be ImplementationSpecific. If a non existent path type is provided, an error will be returned. -func validateAndGetPaths(path v1beta1.HTTPIngressPath) ([]string, error) { - pathType := v1beta1.PathTypeImplementationSpecific +func validateAndGetPaths(path v1.HTTPIngressPath) ([]string, error) { + pathType := v1.PathTypeImplementationSpecific if path.PathType != nil { - if !flags.F.EnableIngressGAFields && *path.PathType != v1beta1.PathTypeImplementationSpecific { + if !flags.F.EnableIngressGAFields && *path.PathType != v1.PathTypeImplementationSpecific { return nil, fmt.Errorf("only \"ImplementationSpecific\" path type is supported") } pathType = *path.PathType } switch pathType { - case v1beta1.PathTypeImplementationSpecific: + case v1.PathTypeImplementationSpecific: // ImplementationSpecific will have no validation to continue backwards compatibility return []string{path.Path}, nil - case v1beta1.PathTypeExact: + case v1.PathTypeExact: return validateExactPathType(path) - case v1beta1.PathTypePrefix: + case v1.PathTypePrefix: return validateAndModifyPrefixPathType(path) default: return nil, fmt.Errorf("unsupported path type: %s", pathType) @@ -286,7 +286,7 @@ func validateAndGetPaths(path v1beta1.HTTPIngressPath) ([]string, error) { // validateExactPathType will validate the path provided does not have any wildcards and will // return the path unmodified. If the path is in valid, an empty list and error is returned. -func validateExactPathType(path v1beta1.HTTPIngressPath) ([]string, error) { +func validateExactPathType(path v1.HTTPIngressPath) ([]string, error) { if path.Path == "" { return nil, fmt.Errorf("failed to validate exact path type due to empty path") } @@ -300,7 +300,7 @@ func validateExactPathType(path v1beta1.HTTPIngressPath) ([]string, error) { // validateAndModifyPrefixPathType will validate the path provided does not have any wildcards // and will return the path unmodified. If the path is in valid, an empty list and error is // returned. -func validateAndModifyPrefixPathType(path v1beta1.HTTPIngressPath) ([]string, error) { +func validateAndModifyPrefixPathType(path v1.HTTPIngressPath) ([]string, error) { if path.Path == "" { return nil, fmt.Errorf("failed to validate prefix path type due to empty path") } diff --git a/pkg/controller/translator/translator_test.go b/pkg/controller/translator/translator_test.go index eb63744dd1..69c50679f3 100644 --- a/pkg/controller/translator/translator_test.go +++ b/pkg/controller/translator/translator_test.go @@ -24,7 +24,7 @@ import ( "time" apiv1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/intstr" @@ -48,11 +48,12 @@ var ( Name: "default-http-backend", Namespace: "kube-system", }, - Port: intstr.FromString("http"), + Port: v1.ServiceBackendPort{Name: "http"}, }, TargetPort: "9376", } defaultNamer = namer_util.NewNamer("uid1", "") + port80 = v1.ServiceBackendPort{Number: 80} ) func fakeTranslator() *Translator { @@ -99,24 +100,24 @@ func TestTranslateIngress(t *testing.T) { cases := []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress wantErrCount int wantGCEURLMap *utils.GCEURLMap }{ { desc: "default backend only", ing: test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: test.Backend("first-service", intstr.FromInt(80)), + v1.IngressSpec{ + DefaultBackend: test.Backend("first-service", port80), }), wantErrCount: 0, - wantGCEURLMap: &utils.GCEURLMap{DefaultBackend: &utils.ServicePort{ID: utils.ServicePortID{Service: types.NamespacedName{Name: "first-service", Namespace: "default"}, Port: intstr.FromInt(80)}}}, + wantGCEURLMap: &utils.GCEURLMap{DefaultBackend: &utils.ServicePort{ID: utils.ServicePortID{Service: types.NamespacedName{Name: "first-service", Namespace: "default"}, Port: port80}}}, }, { desc: "no backend", - ing: test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, v1beta1.IngressSpec{}), + ing: test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, v1.IngressSpec{}), wantErrCount: 0, - wantGCEURLMap: &utils.GCEURLMap{DefaultBackend: &utils.ServicePort{ID: utils.ServicePortID{Service: types.NamespacedName{Name: "default-http-backend", Namespace: "kube-system"}, Port: intstr.FromString("http")}}}, + wantGCEURLMap: &utils.GCEURLMap{DefaultBackend: &utils.ServicePort{ID: utils.ServicePortID{Service: types.NamespacedName{Name: "default-http-backend", Namespace: "kube-system"}, Port: v1.ServiceBackendPort{Name: "http"}}}}, }, { desc: "no host", @@ -163,8 +164,8 @@ func TestTranslateIngress(t *testing.T) { { desc: "missing default service", ing: test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, - v1beta1.IngressSpec{ - Backend: test.Backend("random-service", intstr.FromInt(80)), + v1.IngressSpec{ + DefaultBackend: test.Backend("random-service", port80), }), wantErrCount: 1, wantGCEURLMap: utils.NewGCEURLMap(), @@ -202,7 +203,7 @@ func TestGetServicePort(t *testing.T) { Type: apiv1.ServiceTypeClusterIP, Ports: []apiv1.ServicePort{{Name: "http", Port: 80}}, }, - id: utils.ServicePortID{Port: intstr.FromString("http")}, + id: utils.ServicePortID{Port: v1.ServiceBackendPort{Name: "http"}}, wantErr: true, wantPort: false, }, @@ -212,7 +213,7 @@ func TestGetServicePort(t *testing.T) { Type: apiv1.ServiceTypeNodePort, Ports: []apiv1.ServicePort{{Name: "http", Port: 80}}, }, - id: utils.ServicePortID{Port: intstr.FromString("badport")}, + id: utils.ServicePortID{Port: v1.ServiceBackendPort{Name: "badport"}}, wantErr: true, wantPort: false, }, @@ -225,7 +226,7 @@ func TestGetServicePort(t *testing.T) { annotations: map[string]string{ "service.alpha.kubernetes.io/app-protocols": "bad-string", }, - id: utils.ServicePortID{Port: intstr.FromString("http")}, + id: utils.ServicePortID{Port: v1.ServiceBackendPort{Name: "http"}}, wantErr: true, wantPort: true, }, @@ -272,14 +273,14 @@ func TestGetServicePortWithBackendConfigEnabled(t *testing.T) { annotations: map[string]string{ annotations.BackendConfigKey: `{"ports":{"https":"config-https"}}`, }, - id: utils.ServicePortID{Port: intstr.FromString("https")}, + id: utils.ServicePortID{Port: v1.ServiceBackendPort{Name: "https"}}, wantErr: true, wantPort: true, }, { desc: "no backend config annotation", annotations: nil, - id: utils.ServicePortID{Port: intstr.FromString("http")}, + id: utils.ServicePortID{Port: v1.ServiceBackendPort{Name: "http"}}, wantErr: false, wantPort: true, }, @@ -288,7 +289,7 @@ func TestGetServicePortWithBackendConfigEnabled(t *testing.T) { annotations: map[string]string{ annotations.BackendConfigKey: `{"ports":{"https":"config-https"}}`, }, - id: utils.ServicePortID{Port: intstr.FromString("http")}, + id: utils.ServicePortID{Port: v1.ServiceBackendPort{Name: "http"}}, wantErr: false, wantPort: true, }, @@ -297,7 +298,7 @@ func TestGetServicePortWithBackendConfigEnabled(t *testing.T) { annotations: map[string]string{ annotations.BackendConfigKey: `{"ports":{"http":"config-http"}}`, }, - id: utils.ServicePortID{Port: intstr.FromString("http")}, + id: utils.ServicePortID{Port: v1.ServiceBackendPort{Name: "http"}}, wantErr: false, wantPort: true, }, @@ -455,12 +456,12 @@ func TestPathValidation(t *testing.T) { expectedBackend := &utils.ServicePort{ ID: utils.ServicePortID{ Service: types.NamespacedName{Name: "my-service", Namespace: "default"}, - Port: intstr.FromInt(80), + Port: port80, }} testcases := []struct { desc string - pathType v1beta1.PathType + pathType v1.PathType path string expectValid bool expectedPaths []string @@ -468,66 +469,66 @@ func TestPathValidation(t *testing.T) { }{ { desc: "Valid path for exact path type", - pathType: v1beta1.PathTypeExact, + pathType: v1.PathTypeExact, path: "/test", expectValid: true, expectedPaths: []string{"/test"}, }, { desc: "Valid path for exact path type with trailing '/'", - pathType: v1beta1.PathTypeExact, + pathType: v1.PathTypeExact, path: "/test/", expectValid: true, expectedPaths: []string{"/test/"}, }, { desc: "Invalid Exact Path includes a wildcard", - pathType: v1beta1.PathTypeExact, + pathType: v1.PathTypeExact, path: "/test/*", expectValid: false, }, { desc: "Invalid empty Exact Path", - pathType: v1beta1.PathTypeExact, + pathType: v1.PathTypeExact, path: "", expectValid: false, }, { desc: "Valid Prefix path without wildcard", - pathType: v1beta1.PathTypePrefix, + pathType: v1.PathTypePrefix, path: "/test", expectValid: true, expectedPaths: []string{"/test", "/test/*"}, }, { desc: "Valid Prefix path with trailing /", - pathType: v1beta1.PathTypePrefix, + pathType: v1.PathTypePrefix, path: "/test/", expectValid: true, expectedPaths: []string{"/test", "/test/*"}, }, { desc: "Valid Prefix path /", - pathType: v1beta1.PathTypePrefix, + pathType: v1.PathTypePrefix, path: "/", expectValid: true, expectedPaths: []string{"/*"}, }, { desc: "Invalid Prefix path with a wildcard", - pathType: v1beta1.PathTypePrefix, + pathType: v1.PathTypePrefix, path: "/test/*", expectValid: false, }, { desc: "Invalid Prefix empty path", - pathType: v1beta1.PathTypePrefix, + pathType: v1.PathTypePrefix, path: "", expectValid: false, }, { desc: "Valid ImplementationSpecific path", - pathType: v1beta1.PathTypeImplementationSpecific, + pathType: v1.PathTypeImplementationSpecific, path: "/test", expectValid: true, expectedPaths: []string{"/test"}, @@ -562,7 +563,7 @@ func TestPathValidation(t *testing.T) { }, { desc: "Invalid Path Type", - pathType: v1beta1.PathType("InvalidType"), + pathType: v1.PathType("InvalidType"), path: "/test/*", expectValid: false, }, @@ -576,7 +577,7 @@ func TestPathValidation(t *testing.T) { }, { desc: "IngressGA Disabled, ImplementationSpecific path type", - pathType: v1beta1.PathTypeImplementationSpecific, + pathType: v1.PathTypeImplementationSpecific, path: "/test", expectValid: true, expectedPaths: []string{"/test"}, @@ -584,7 +585,7 @@ func TestPathValidation(t *testing.T) { }, { desc: "Invalid IngressGA Disabled, non ImplementationSpecific path type", - pathType: v1beta1.PathTypePrefix, + pathType: v1.PathTypePrefix, path: "/test", expectValid: false, expectedPaths: []string{"/test"}, @@ -595,26 +596,30 @@ func TestPathValidation(t *testing.T) { for _, tc := range testcases { flags.F.EnableIngressGAFields = !tc.ingressGADisabled - path := v1beta1.HTTPIngressPath{ + path := v1.HTTPIngressPath{ Path: tc.path, - Backend: v1beta1.IngressBackend{ - ServiceName: "my-service", - ServicePort: intstr.FromInt(80), + Backend: v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "my-service", + Port: v1.ServiceBackendPort{ + Number: 80, + }, + }, }, } // Empty Path Types should be nil, not an empty string in the spec - if tc.pathType != v1beta1.PathType("") { + if tc.pathType != v1.PathType("") { path.PathType = &tc.pathType } - spec := v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + spec := v1.IngressSpec{ + Rules: []v1.IngressRule{ { Host: hostname, - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{path}, + IngressRuleValue: v1.IngressRuleValue{ + HTTP: &v1.HTTPIngressRuleValue{ + Paths: []v1.HTTPIngressPath{path}, }, }, }, @@ -624,7 +629,7 @@ func TestPathValidation(t *testing.T) { expectedGCEURLMap := &utils.GCEURLMap{ DefaultBackend: &utils.ServicePort{ - ID: utils.ServicePortID{Service: types.NamespacedName{Name: "default-http-backend", Namespace: "kube-system"}, Port: intstr.FromString("http")}, + ID: utils.ServicePortID{Service: types.NamespacedName{Name: "default-http-backend", Namespace: "kube-system"}, Port: v1.ServiceBackendPort{Name: "http"}}, }, } @@ -637,7 +642,7 @@ func TestPathValidation(t *testing.T) { gotGCEURLMap, gotErrs := translator.TranslateIngress(ing, defaultBackend.ID, defaultNamer) if tc.expectValid && len(gotErrs) > 0 { - t.Errorf("%s: TranslateIngress() = _, %+v, want no errs", tc.desc, gotErrs) + t.Fatalf("%s: TranslateIngress() = _, %+v, want no errs", tc.desc, gotErrs) } else if !tc.expectValid && len(gotErrs) == 0 { t.Errorf("%s: TranslateIngress() should result in errors but got none", tc.desc) } @@ -810,7 +815,7 @@ func newDefaultEndpoint(name string) *apiv1.Endpoints { } } -func ingressFromFile(t *testing.T, filename string) *v1beta1.Ingress { +func ingressFromFile(t *testing.T, filename string) *v1.Ingress { t.Helper() data, err := ioutil.ReadFile("testdata/" + filename) diff --git a/pkg/controller/types.go b/pkg/controller/types.go index f47c26516d..80f05bffda 100644 --- a/pkg/controller/types.go +++ b/pkg/controller/types.go @@ -17,7 +17,7 @@ limitations under the License. package controller import ( - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/loadbalancers" "k8s.io/ingress-gce/pkg/utils" ) @@ -25,6 +25,6 @@ import ( // syncState is used by the controller to maintain state for routines that sync GCP resources of an Ingress. type syncState struct { urlMap *utils.GCEURLMap - ing *v1beta1.Ingress + ing *v1.Ingress l7 *loadbalancers.L7 } diff --git a/pkg/controller/utils.go b/pkg/controller/utils.go index b6f4556f8f..d5e6acc17e 100644 --- a/pkg/controller/utils.go +++ b/pkg/controller/utils.go @@ -22,7 +22,7 @@ import ( compute "google.golang.org/api/compute/v1" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/utils" ) @@ -68,7 +68,7 @@ func nodeStatusChanged(old, cur *api_v1.Node) bool { return false } -func convert(ings []*v1beta1.Ingress) (retVal []interface{}) { +func convert(ings []*v1.Ingress) (retVal []interface{}) { for _, ing := range ings { retVal = append(retVal, ing) } diff --git a/pkg/controller/utils_test.go b/pkg/controller/utils_test.go index fc556cc292..25451747a9 100644 --- a/pkg/controller/utils_test.go +++ b/pkg/controller/utils_test.go @@ -23,14 +23,16 @@ import ( "google.golang.org/api/compute/v1" api_v1 "k8s.io/api/core/v1" + networkingv1 "k8s.io/api/networking/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" + //"k8s.io/apimachinery/pkg/util/sets" - "k8s.io/apimachinery/pkg/util/intstr" + "reflect" + "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/utils" - "reflect" ) // Pods created in loops start from this time, for routines that @@ -399,7 +401,7 @@ func testServicePort(namespace, name, port string, servicePort, nodePort int, en Namespace: namespace, Name: name, }, - Port: intstr.FromString(port), + Port: networkingv1.ServiceBackendPort{Name: port}, }, Port: int32(servicePort), NodePort: int64(nodePort), diff --git a/pkg/e2e/fixtures.go b/pkg/e2e/fixtures.go index bfe2a4856b..4a824c3e64 100644 --- a/pkg/e2e/fixtures.go +++ b/pkg/e2e/fixtures.go @@ -42,7 +42,7 @@ import ( "google.golang.org/api/compute/v1" apps "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/util/intstr" @@ -277,7 +277,7 @@ func DeleteSecret(s *Sandbox, name string) error { } // EnsureIngress creates a new Ingress or updates an existing one. -func EnsureIngress(s *Sandbox, ing *v1beta1.Ingress) (*v1beta1.Ingress, error) { +func EnsureIngress(s *Sandbox, ing *networkingv1.Ingress) (*networkingv1.Ingress, error) { crud := &adapter.IngressCRUD{C: s.f.Clientset} currentIng, err := crud.Get(ing.ObjectMeta.Namespace, ing.ObjectMeta.Name) if currentIng == nil || err != nil { diff --git a/pkg/e2e/helpers.go b/pkg/e2e/helpers.go index 1ad8792bdb..f774eb717c 100644 --- a/pkg/e2e/helpers.go +++ b/pkg/e2e/helpers.go @@ -32,7 +32,7 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" apps "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" apiextensionsclient "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset" apierrors "k8s.io/apimachinery/pkg/api/errors" @@ -128,7 +128,7 @@ func IsRfc1918Addr(addr string) bool { // UpgradeTestWaitForIngress waits for ingress to stabilize and set sandbox status to stable. // Note that this is used only for upgrade tests. -func UpgradeTestWaitForIngress(s *Sandbox, ing *v1beta1.Ingress, options *WaitForIngressOptions) (*v1beta1.Ingress, error) { +func UpgradeTestWaitForIngress(s *Sandbox, ing *networkingv1.Ingress, options *WaitForIngressOptions) (*networkingv1.Ingress, error) { ing, err := WaitForIngress(s, ing, nil, options) if err != nil { return nil, err @@ -140,7 +140,7 @@ func UpgradeTestWaitForIngress(s *Sandbox, ing *v1beta1.Ingress, options *WaitFo // WaitForIngress to stabilize. // We expect the ingress to be unreachable at first as LB is // still programming itself (i.e 404's / 502's) -func WaitForIngress(s *Sandbox, ing *v1beta1.Ingress, fc *frontendconfigv1beta1.FrontendConfig, options *WaitForIngressOptions) (*v1beta1.Ingress, error) { +func WaitForIngress(s *Sandbox, ing *networkingv1.Ingress, fc *frontendconfigv1beta1.FrontendConfig, options *WaitForIngressOptions) (*networkingv1.Ingress, error) { err := wait.Poll(ingressPollInterval, ingressPollTimeout, func() (bool, error) { var err error crud := adapter.IngressCRUD{C: s.f.Clientset} @@ -174,7 +174,7 @@ func WaitForIngress(s *Sandbox, ing *v1beta1.Ingress, fc *frontendconfigv1beta1. // validator thinks that http load balancer is configured when https only // configuration exists. // TODO(smatti): Remove this when the above issue is fixed. -func WaitForHTTPResourceAnnotations(s *Sandbox, ing *v1beta1.Ingress) (*v1beta1.Ingress, error) { +func WaitForHTTPResourceAnnotations(s *Sandbox, ing *networkingv1.Ingress) (*networkingv1.Ingress, error) { ingKey := fmt.Sprintf("%s/%s", s.Namespace, ing.Name) klog.Infof("Waiting for HTTP annotations to be added on Ingress %s", ingKey) var err error @@ -200,7 +200,7 @@ func WaitForHTTPResourceAnnotations(s *Sandbox, ing *v1beta1.Ingress) (*v1beta1. // WaitForFinalizer waits for Finalizer to be added. // Note that this is used only for upgrade tests. -func WaitForFinalizer(s *Sandbox, ing *v1beta1.Ingress) (*v1beta1.Ingress, error) { +func WaitForFinalizer(s *Sandbox, ing *networkingv1.Ingress) (*networkingv1.Ingress, error) { ingKey := fmt.Sprintf("%s/%s", s.Namespace, ing.Name) klog.Infof("Waiting for Finalizer to be added for Ingress %s", ingKey) err := wait.Poll(k8sApiPoolInterval, k8sApiPollTimeout, func() (bool, error) { @@ -227,7 +227,7 @@ func WaitForFinalizer(s *Sandbox, ing *v1beta1.Ingress) (*v1beta1.Ingress, error } // WhiteboxTest retrieves GCP load-balancer for Ingress VIP and runs the whitebox tests. -func WhiteboxTest(ing *v1beta1.Ingress, fc *frontendconfigv1beta1.FrontendConfig, cloud cloud.Cloud, region string, s *Sandbox) (*fuzz.GCLB, error) { +func WhiteboxTest(ing *networkingv1.Ingress, fc *frontendconfigv1beta1.FrontendConfig, cloud cloud.Cloud, region string, s *Sandbox) (*fuzz.GCLB, error) { if len(ing.Status.LoadBalancer.Ingress) < 1 { return nil, fmt.Errorf("ingress does not have an IP: %+v", ing.Status) } @@ -251,7 +251,7 @@ func WhiteboxTest(ing *v1beta1.Ingress, fc *frontendconfigv1beta1.FrontendConfig } // performWhiteboxTests runs the whitebox tests against the Ingress. -func performWhiteboxTests(s *Sandbox, ing *v1beta1.Ingress, fc *frontendconfigv1beta1.FrontendConfig, gclb *fuzz.GCLB) error { +func performWhiteboxTests(s *Sandbox, ing *networkingv1.Ingress, fc *frontendconfigv1beta1.FrontendConfig, gclb *fuzz.GCLB) error { validator, err := fuzz.NewIngressValidator(s.ValidatorEnv, ing, fc, whitebox.AllTests, nil, []fuzz.Feature{}) if err != nil { return err @@ -264,7 +264,7 @@ func performWhiteboxTests(s *Sandbox, ing *v1beta1.Ingress, fc *frontendconfigv1 // WaitForIngressDeletion deletes the given ingress and waits for the // resources associated with it to be deleted. -func WaitForIngressDeletion(ctx context.Context, g *fuzz.GCLB, s *Sandbox, ing *v1beta1.Ingress, options *fuzz.GCLBDeleteOptions) error { +func WaitForIngressDeletion(ctx context.Context, g *fuzz.GCLB, s *Sandbox, ing *networkingv1.Ingress, options *fuzz.GCLBDeleteOptions) error { crud := adapter.IngressCRUD{C: s.f.Clientset} if err := crud.Delete(ing.Namespace, ing.Name); err != nil { return fmt.Errorf("delete(%q) = %v, want nil", ing.Name, err) @@ -637,7 +637,7 @@ func CheckNameInNegStatus(svc *v1.Service, expectedNegAttrs map[string]string) ( } // CheckForAnyFinalizer asserts that an ingress finalizer exists on Ingress. -func CheckForAnyFinalizer(ing *v1beta1.Ingress) error { +func CheckForAnyFinalizer(ing *networkingv1.Ingress) error { ingFinalizers := ing.GetFinalizers() if l := len(ingFinalizers); l != 1 { return fmt.Errorf("expected 1 Finalizer but got %d", l) @@ -649,7 +649,7 @@ func CheckForAnyFinalizer(ing *v1beta1.Ingress) error { } // CheckV1Finalizer asserts that only v1 finalizer exists on Ingress. -func CheckV1Finalizer(ing *v1beta1.Ingress) error { +func CheckV1Finalizer(ing *networkingv1.Ingress) error { ingFinalizers := ing.GetFinalizers() if l := len(ingFinalizers); l != 1 { return fmt.Errorf("expected 1 Finalizer but got %d", l) @@ -661,7 +661,7 @@ func CheckV1Finalizer(ing *v1beta1.Ingress) error { } // CheckV2Finalizer asserts that only v2 finalizer exists on Ingress. -func CheckV2Finalizer(ing *v1beta1.Ingress) error { +func CheckV2Finalizer(ing *networkingv1.Ingress) error { ingFinalizers := ing.GetFinalizers() if l := len(ingFinalizers); l != 1 { return fmt.Errorf("expected 1 Finalizer but got %d", l) diff --git a/pkg/firewalls/controller.go b/pkg/firewalls/controller.go index ee25a27bdb..7f5def8fbb 100644 --- a/pkg/firewalls/controller.go +++ b/pkg/firewalls/controller.go @@ -24,7 +24,7 @@ import ( "time" apiv1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" listers "k8s.io/client-go/listers/core/v1" "k8s.io/client-go/tools/cache" @@ -41,7 +41,7 @@ import ( var ( // queueKey is a "fake" key which can be enqueued to a task queue. - queueKey = &v1beta1.Ingress{ + queueKey = &v1.Ingress{ ObjectMeta: metav1.ObjectMeta{Name: "queueKey"}, } @@ -77,21 +77,21 @@ func NewFirewallController( // Ingress event handlers. ctx.IngressInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{ AddFunc: func(obj interface{}) { - addIng := obj.(*v1beta1.Ingress) + addIng := obj.(*v1.Ingress) if !utils.IsGCEIngress(addIng) && !utils.IsGCEMultiClusterIngress(addIng) { return } fwc.queue.Enqueue(queueKey) }, DeleteFunc: func(obj interface{}) { - delIng := obj.(*v1beta1.Ingress) + delIng := obj.(*v1.Ingress) if !utils.IsGCEIngress(delIng) && !utils.IsGCEMultiClusterIngress(delIng) { return } fwc.queue.Enqueue(queueKey) }, UpdateFunc: func(old, cur interface{}) { - curIng := cur.(*v1beta1.Ingress) + curIng := cur.(*v1.Ingress) if !utils.IsGCEIngress(curIng) && !utils.IsGCEMultiClusterIngress(curIng) { return } @@ -125,7 +125,7 @@ func NewFirewallController( // ToSvcPorts is a helper method over translator.TranslateIngress to process a list of ingresses. // TODO(rramkumar): This is a copy of code in controller.go. Extract this into // something shared. -func (fwc *FirewallController) ToSvcPorts(ings []*v1beta1.Ingress) []utils.ServicePort { +func (fwc *FirewallController) ToSvcPorts(ings []*v1.Ingress) []utils.ServicePort { var knownPorts []utils.ServicePort for _, ing := range ings { urlMap, _ := fwc.translator.TranslateIngress(ing, fwc.ctx.DefaultBackendSvcPort.ID, fwc.ctx.ClusterNamer) @@ -152,7 +152,7 @@ func (fwc *FirewallController) sync(key string) error { } klog.V(3).Infof("Syncing firewall") - gceIngresses := operator.Ingresses(fwc.ctx.Ingresses().List()).Filter(func(ing *v1beta1.Ingress) bool { + gceIngresses := operator.Ingresses(fwc.ctx.Ingresses().List()).Filter(func(ing *v1.Ingress) bool { return utils.IsGCEIngress(ing) }).AsList() @@ -214,7 +214,7 @@ func (fwc *FirewallController) sync(key string) error { return nil } -func (fwc *FirewallController) ilbFirewallSrcRange(gceIngresses []*v1beta1.Ingress) (string, error) { +func (fwc *FirewallController) ilbFirewallSrcRange(gceIngresses []*v1.Ingress) (string, error) { ilbEnabled := false for _, ing := range gceIngresses { if utils.IsGCEL7ILBIngress(ing) { diff --git a/pkg/firewalls/controller_test.go b/pkg/firewalls/controller_test.go index 2963fcee42..f5c99815c2 100644 --- a/pkg/firewalls/controller_test.go +++ b/pkg/firewalls/controller_test.go @@ -23,7 +23,7 @@ import ( "github.com/google/go-cmp/cmp" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/kubernetes/fake" v1 "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" @@ -77,8 +77,8 @@ func TestFirewallCreateDelete(t *testing.T) { fwc.ctx.KubeClient.CoreV1().Services(defaultSvc.Namespace).Create(context2.TODO(), defaultSvc, meta_v1.CreateOptions{}) fwc.ctx.ServiceInformer.GetIndexer().Add(defaultSvc) - ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, v1beta1.IngressSpec{}) - fwc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Create(context2.TODO(), ing, meta_v1.CreateOptions{}) + ing := test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, networkingv1.IngressSpec{}) + fwc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Create(context2.TODO(), ing, meta_v1.CreateOptions{}) fwc.ctx.IngressInformer.GetIndexer().Add(ing) key, _ := common.KeyFunc(queueKey) @@ -92,7 +92,7 @@ func TestFirewallCreateDelete(t *testing.T) { t.Fatalf("cloud.GetFirewall(%v) = _, %v, want _, nil", ruleName, err) } - fwc.ctx.KubeClient.NetworkingV1beta1().Ingresses(ing.Namespace).Delete(context2.TODO(), ing.Name, meta_v1.DeleteOptions{}) + fwc.ctx.KubeClient.NetworkingV1().Ingresses(ing.Namespace).Delete(context2.TODO(), ing.Name, meta_v1.DeleteOptions{}) fwc.ctx.IngressInformer.GetIndexer().Delete(ing) if err := fwc.sync(key); err != nil { diff --git a/pkg/frontendconfig/frontendconfig.go b/pkg/frontendconfig/frontendconfig.go index 9903ad2de8..8ea12064a3 100644 --- a/pkg/frontendconfig/frontendconfig.go +++ b/pkg/frontendconfig/frontendconfig.go @@ -19,7 +19,7 @@ package frontendconfig import ( "errors" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" apisfrontendconfig "k8s.io/ingress-gce/pkg/apis/frontendconfig" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" @@ -46,7 +46,7 @@ func CRDMeta() *crd.CRDMeta { } // FrontendConfigForIngress returns the corresponding FrontendConfig for the given Ingress if one was specified. -func FrontendConfigForIngress(feConfigs []*frontendconfigv1beta1.FrontendConfig, ing *v1beta1.Ingress) (*frontendconfigv1beta1.FrontendConfig, error) { +func FrontendConfigForIngress(feConfigs []*frontendconfigv1beta1.FrontendConfig, ing *v1.Ingress) (*frontendconfigv1beta1.FrontendConfig, error) { frontendConfigName := annotations.FromIngress(ing).FrontendConfig() if frontendConfigName == "" { // If the user did not provide the annotation at all, then we diff --git a/pkg/frontendconfig/frontendconfig_test.go b/pkg/frontendconfig/frontendconfig_test.go index d2725e66e6..6b5fade3fb 100644 --- a/pkg/frontendconfig/frontendconfig_test.go +++ b/pkg/frontendconfig/frontendconfig_test.go @@ -3,7 +3,7 @@ package frontendconfig import ( "testing" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/test" ) @@ -13,7 +13,7 @@ func TestFrontendConfigForIngress(t *testing.T) { testCases := []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress expected *frontendconfigv1beta1.FrontendConfig err error }{ diff --git a/pkg/fuzz/feature.go b/pkg/fuzz/feature.go index 23002ba6df..40fa17fc78 100644 --- a/pkg/fuzz/feature.go +++ b/pkg/fuzz/feature.go @@ -19,7 +19,7 @@ package fuzz import ( "net/http" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" ) // Feature represents an extension to the "vanilla" behavior of Ingress. @@ -57,7 +57,7 @@ type FeatureValidator interface { Name() string // ConfigureAttributes of the validation for given the environment and // the Ingress object. - ConfigureAttributes(env ValidatorEnv, ing *v1beta1.Ingress, a *IngressValidatorAttributes) error + ConfigureAttributes(env ValidatorEnv, ing *v1.Ingress, a *IngressValidatorAttributes) error // ModifyRequest adds the appropriate headers for testing the feature, if // necessary. ModifyRequest(host, path string, req *http.Request) @@ -81,7 +81,7 @@ type NullValidator struct { } // ConfigureAttributes implements Feature. -func (*NullValidator) ConfigureAttributes(env ValidatorEnv, ing *v1beta1.Ingress, a *IngressValidatorAttributes) error { +func (*NullValidator) ConfigureAttributes(env ValidatorEnv, ing *v1.Ingress, a *IngressValidatorAttributes) error { return nil } diff --git a/pkg/fuzz/features/affinity.go b/pkg/fuzz/features/affinity.go index 9550f561bb..5f9ac171f0 100644 --- a/pkg/fuzz/features/affinity.go +++ b/pkg/fuzz/features/affinity.go @@ -21,7 +21,7 @@ import ( "net/http" "strings" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" ) @@ -47,7 +47,7 @@ type affinityValidator struct { fuzz.NullValidator env fuzz.ValidatorEnv - ing *v1beta1.Ingress + ing *v1.Ingress } // Name implements fuzz.FeatureValidator. @@ -56,7 +56,7 @@ func (*affinityValidator) Name() string { } // ConfigureAttributes implements fuzz.FeatureValidator. -func (v *affinityValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *affinityValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse. v.ing = ing v.env = env diff --git a/pkg/fuzz/features/allow_http.go b/pkg/fuzz/features/allow_http.go index 945f6d6f00..5200a222a1 100644 --- a/pkg/fuzz/features/allow_http.go +++ b/pkg/fuzz/features/allow_http.go @@ -17,7 +17,7 @@ limitations under the License. package features import ( - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" ) @@ -42,7 +42,7 @@ func (f *AllowHTTPFeature) NewValidator() fuzz.FeatureValidator { } // ConfigureAttributes implements fuzz.Feature. -func (*AllowHTTPFeature) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (*AllowHTTPFeature) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { an := annotations.FromIngress(ing) if !an.AllowHTTP() { a.CheckHTTP = false diff --git a/pkg/fuzz/features/app_protocol.go b/pkg/fuzz/features/app_protocol.go index 53549db1b3..7ef8a93a8f 100644 --- a/pkg/fuzz/features/app_protocol.go +++ b/pkg/fuzz/features/app_protocol.go @@ -22,7 +22,7 @@ import ( "net/http" "strings" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" echo "k8s.io/ingress-gce/cmd/echo/app" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" @@ -49,7 +49,7 @@ type appProtocolValidator struct { fuzz.NullValidator env fuzz.ValidatorEnv - ing *v1beta1.Ingress + ing *v1.Ingress } // Name implements fuzz.FeatureValidator @@ -58,7 +58,7 @@ func (*appProtocolValidator) Name() string { } // ConfigureAttributes implements fuzz.FeatureValidator. -func (v *appProtocolValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *appProtocolValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse v.ing = ing v.env = env diff --git a/pkg/fuzz/features/backendconfig_example.go b/pkg/fuzz/features/backendconfig_example.go index 71c9e82614..64b0b76009 100644 --- a/pkg/fuzz/features/backendconfig_example.go +++ b/pkg/fuzz/features/backendconfig_example.go @@ -20,7 +20,7 @@ import ( "fmt" "net/http" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" "k8s.io/klog" @@ -48,7 +48,7 @@ type backendConfigExampleValidator struct { fuzz.NullValidator env fuzz.ValidatorEnv - ing *v1beta1.Ingress + ing *v1.Ingress } // Name implements fuzz.FeatureValidator. @@ -57,7 +57,7 @@ func (*backendConfigExampleValidator) Name() string { } // ConfigureAttributes implements fuzz.FeatureValidator. -func (v *backendConfigExampleValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *backendConfigExampleValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse. v.ing = ing v.env = env @@ -78,9 +78,9 @@ func (v *backendConfigExampleValidator) CheckResponse(host, path string, resp *h return fuzz.CheckResponseContinue, err } - service, ok := serviceMap[b.ServiceName] + service, ok := serviceMap[b.Service.Name] if !ok { - return fuzz.CheckResponseContinue, fmt.Errorf("service %q not found in environment", b.ServiceName) + return fuzz.CheckResponseContinue, fmt.Errorf("service %q not found in environment", b.Service.Name) } anno := annotations.FromService(service) diff --git a/pkg/fuzz/features/cdn.go b/pkg/fuzz/features/cdn.go index a09ff25c46..c2d7efa9d4 100644 --- a/pkg/fuzz/features/cdn.go +++ b/pkg/fuzz/features/cdn.go @@ -20,7 +20,7 @@ import ( "fmt" "net/http" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" ) @@ -46,7 +46,7 @@ type cdnValidator struct { fuzz.NullValidator env fuzz.ValidatorEnv - ing *v1beta1.Ingress + ing *v1.Ingress } // Name implements fuzz.FeatureValidator. @@ -55,7 +55,7 @@ func (*cdnValidator) Name() string { } // ConfigureAttributes implements fuzz.FeatureValidator. -func (v *cdnValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *cdnValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse. v.ing = ing v.env = env diff --git a/pkg/fuzz/features/https_redirects.go b/pkg/fuzz/features/https_redirects.go index ed68264653..8628a7cca9 100644 --- a/pkg/fuzz/features/https_redirects.go +++ b/pkg/fuzz/features/https_redirects.go @@ -20,7 +20,7 @@ import ( "fmt" "net/http" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/fuzz" ) @@ -53,7 +53,7 @@ func (f *HTTPSRedirectsFeature) NewValidator() fuzz.FeatureValidator { } // ConfigureAttributes implements fuzz.Feature. -func (v *HTTPSRedirectsFeature) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *HTTPSRedirectsFeature) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { fc, err := fuzz.FrontendConfigForIngress(ing, env) if err != nil { return err diff --git a/pkg/fuzz/features/iap.go b/pkg/fuzz/features/iap.go index 186bca4190..1938f30d00 100644 --- a/pkg/fuzz/features/iap.go +++ b/pkg/fuzz/features/iap.go @@ -20,7 +20,7 @@ import ( "fmt" "net/http" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" "k8s.io/klog" @@ -47,7 +47,7 @@ type iapValidator struct { fuzz.NullValidator env fuzz.ValidatorEnv - ing *v1beta1.Ingress + ing *v1.Ingress } // Name implements fuzz.FeatureValidator. @@ -56,7 +56,7 @@ func (*iapValidator) Name() string { } // ConfigureAttributes implements fuzz.FeatureValidator. -func (v *iapValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *iapValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse. v.ing = ing v.env = env diff --git a/pkg/fuzz/features/ilb.go b/pkg/fuzz/features/ilb.go index 0e54644772..7ad8c0c3a1 100644 --- a/pkg/fuzz/features/ilb.go +++ b/pkg/fuzz/features/ilb.go @@ -17,9 +17,10 @@ limitations under the License. package features import ( - "k8s.io/api/networking/v1beta1" - "k8s.io/ingress-gce/pkg/fuzz" "net/http" + + v1 "k8s.io/api/networking/v1" + "k8s.io/ingress-gce/pkg/fuzz" ) // ILB is an internal load balancer @@ -42,7 +43,7 @@ func (*ILBFeature) Name() string { type ILBValidator struct { fuzz.NullValidator - ing *v1beta1.Ingress + ing *v1.Ingress env fuzz.ValidatorEnv } @@ -52,7 +53,7 @@ func (*ILBValidator) Name() string { } // ConfigureAttributes implements fuzz.FeatureValidator. -func (v *ILBValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *ILBValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse. v.ing = ing v.env = env diff --git a/pkg/fuzz/features/neg.go b/pkg/fuzz/features/neg.go index 575ba5ae46..58a4660478 100644 --- a/pkg/fuzz/features/neg.go +++ b/pkg/fuzz/features/neg.go @@ -30,8 +30,8 @@ import ( "k8s.io/klog" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/core/v1" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" "k8s.io/ingress-gce/pkg/utils" @@ -57,7 +57,7 @@ func (*NegFeature) Name() string { type negValidator struct { fuzz.NullValidator - ing *v1beta1.Ingress + ing *networkingv1.Ingress env fuzz.ValidatorEnv region string } @@ -68,7 +68,7 @@ func (*negValidator) Name() string { } // ConfigureAttributes implements fuzz.FeatureValidator. -func (v *negValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *negValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *networkingv1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse. v.ing = ing v.env = env diff --git a/pkg/fuzz/features/preshared_cert.go b/pkg/fuzz/features/preshared_cert.go index 60476d8d5c..65ddb0387b 100644 --- a/pkg/fuzz/features/preshared_cert.go +++ b/pkg/fuzz/features/preshared_cert.go @@ -17,7 +17,7 @@ limitations under the License. package features import ( - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" ) @@ -41,7 +41,7 @@ func (f *PresharedCertFeature) NewValidator() fuzz.FeatureValidator { } // ConfigureAttributes implements fuzz.Feature. -func (*PresharedCertFeature) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (*PresharedCertFeature) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { an := annotations.FromIngress(ing) // If the annotation is set, then check each HTTPS path. if an.UseNamedTLS() != "" { diff --git a/pkg/fuzz/features/security_policy.go b/pkg/fuzz/features/security_policy.go index a3f73dd2bb..cd2ed5f9dc 100644 --- a/pkg/fuzz/features/security_policy.go +++ b/pkg/fuzz/features/security_policy.go @@ -22,7 +22,7 @@ import ( "net/http" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" ) @@ -49,7 +49,7 @@ type securityPolicyValidator struct { fuzz.NullValidator env fuzz.ValidatorEnv - ing *v1beta1.Ingress + ing *v1.Ingress } // Name implements fuzz.FeatureValidator. @@ -58,7 +58,7 @@ func (*securityPolicyValidator) Name() string { } // ConfigureAttributes implements fuzz.FeatureValidator. -func (v *securityPolicyValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *securityPolicyValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse. v.ing = ing v.env = env diff --git a/pkg/fuzz/features/static_ip.go b/pkg/fuzz/features/static_ip.go index 86a32a33c1..257b6dca2b 100644 --- a/pkg/fuzz/features/static_ip.go +++ b/pkg/fuzz/features/static_ip.go @@ -22,7 +22,7 @@ import ( "net/http" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/fuzz" ) @@ -50,7 +50,7 @@ type staticIPValidator struct { fuzz.NullValidator env fuzz.ValidatorEnv - ing *v1beta1.Ingress + ing *v1.Ingress } // Name implements fuzz.FeatureValidator @@ -59,7 +59,7 @@ func (*staticIPValidator) Name() string { } // ConfigureAttributes implements fuzz.Feature. -func (v *staticIPValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1beta1.Ingress, a *fuzz.IngressValidatorAttributes) error { +func (v *staticIPValidator) ConfigureAttributes(env fuzz.ValidatorEnv, ing *v1.Ingress, a *fuzz.IngressValidatorAttributes) error { // Capture the env for use later in CheckResponse v.ing = ing v.env = env diff --git a/pkg/fuzz/helpers.go b/pkg/fuzz/helpers.go index aeeeb38fbe..12b2e98aff 100644 --- a/pkg/fuzz/helpers.go +++ b/pkg/fuzz/helpers.go @@ -22,7 +22,7 @@ import ( "strings" v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/ingress-gce/pkg/annotations" @@ -33,7 +33,7 @@ import ( ) // ServiceForPath returns the Service and ServicePort associated with the given path. -func ServiceForPath(host, path string, ing *v1beta1.Ingress, env ValidatorEnv) (*v1.Service, *v1.ServicePort, error) { +func ServiceForPath(host, path string, ing *networkingv1.Ingress, env ValidatorEnv) (*v1.Service, *v1.ServicePort, error) { sm := ServiceMapFromIngress(ing) if path == pathForDefaultBackend { path = "" @@ -47,13 +47,13 @@ func ServiceForPath(host, path string, ing *v1beta1.Ingress, env ValidatorEnv) ( if err != nil { return nil, nil, err } - service, ok := serviceMap[b.ServiceName] + service, ok := serviceMap[b.Service.Name] if !ok { - return nil, nil, fmt.Errorf("service %q not found in environment", b.ServiceName) + return nil, nil, fmt.Errorf("service %q not found in environment", b.Service.Name) } - servicePort := translatorutil.ServicePort(*service, b.ServicePort) + servicePort := translatorutil.ServicePort(*service, b.Service.Port) if servicePort == nil { - return nil, nil, fmt.Errorf("port %+v in Service %q not found", b.ServicePort, b.ServiceName) + return nil, nil, fmt.Errorf("port %+v in Service %q not found", b.Service.Port, b.Service.Name) } return service, servicePort, nil @@ -62,7 +62,7 @@ func ServiceForPath(host, path string, ing *v1beta1.Ingress, env ValidatorEnv) ( // BackendConfigForPath returns the BackendConfig associated with the given path. // Note: This function returns an empty object (not nil pointer) if a BackendConfig // did not exist in the given environment. -func BackendConfigForPath(host, path string, ing *v1beta1.Ingress, env ValidatorEnv) (*backendconfig.BackendConfig, error) { +func BackendConfigForPath(host, path string, ing *networkingv1.Ingress, env ValidatorEnv) (*backendconfig.BackendConfig, error) { service, servicePort, err := ServiceForPath(host, path, ing, env) if err != nil { return nil, err @@ -106,15 +106,15 @@ type HostPath struct { } // ServiceMap is a map of (host, path) to the appropriate backend. -type ServiceMap map[HostPath]*v1beta1.IngressBackend +type ServiceMap map[HostPath]*networkingv1.IngressBackend // ServiceMapFromIngress creates a service map from the Ingress object. Note: // duplicate entries (e.g. invalid configurations) will result in the first // entry to be chosen. -func ServiceMapFromIngress(ing *v1beta1.Ingress) ServiceMap { +func ServiceMapFromIngress(ing *networkingv1.Ingress) ServiceMap { ret := ServiceMap{} - if defaultBackend := ing.Spec.Backend; defaultBackend != nil { + if defaultBackend := ing.Spec.DefaultBackend; defaultBackend != nil { ret[HostPath{}] = defaultBackend } @@ -135,7 +135,7 @@ func ServiceMapFromIngress(ing *v1beta1.Ingress) ServiceMap { return ret } -func FrontendConfigForIngress(ing *v1beta1.Ingress, env ValidatorEnv) (*frontendconfig.FrontendConfig, error) { +func FrontendConfigForIngress(ing *networkingv1.Ingress, env ValidatorEnv) (*frontendconfig.FrontendConfig, error) { name := annotations.FromIngress(ing).FrontendConfig() if name != "" { fcMap, err := env.FrontendConfigs() @@ -157,19 +157,19 @@ func FrontendConfigForIngress(ing *v1beta1.Ingress, env ValidatorEnv) (*frontend // // ing := NewIngressBuilder("ns1", "name1", "127.0.0.1").Build() type IngressBuilder struct { - ing *v1beta1.Ingress + ing *networkingv1.Ingress } // NewIngressBuilder instantiates a new IngressBuilder. func NewIngressBuilder(ns, name, vip string) *IngressBuilder { - var ing = &v1beta1.Ingress{ + var ing = &networkingv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: ns, }, } if vip != "" { - ing.Status = v1beta1.IngressStatus{ + ing.Status = networkingv1.IngressStatus{ LoadBalancer: v1.LoadBalancerStatus{ Ingress: []v1.LoadBalancerIngress{ {IP: "127.0.0.1"}, @@ -182,21 +182,23 @@ func NewIngressBuilder(ns, name, vip string) *IngressBuilder { // NewIngressBuilderFromExisting creates a IngressBuilder from an existing // Ingress object. The Ingress object will be copied. -func NewIngressBuilderFromExisting(i *v1beta1.Ingress) *IngressBuilder { +func NewIngressBuilderFromExisting(i *networkingv1.Ingress) *IngressBuilder { return &IngressBuilder{ing: i.DeepCopy()} } // Build returns a constructed Ingress. The Ingress is a copy, so the Builder // can be reused to construct multiple Ingress definitions. -func (i *IngressBuilder) Build() *v1beta1.Ingress { +func (i *IngressBuilder) Build() *networkingv1.Ingress { return i.ing.DeepCopy() } // DefaultBackend sets the default backend. -func (i *IngressBuilder) DefaultBackend(service string, port intstr.IntOrString) *IngressBuilder { - i.ing.Spec.Backend = &v1beta1.IngressBackend{ - ServiceName: service, - ServicePort: port, +func (i *IngressBuilder) DefaultBackend(service string, port networkingv1.ServiceBackendPort) *IngressBuilder { + i.ing.Spec.DefaultBackend = &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: service, + Port: port, + }, } return i } @@ -208,55 +210,59 @@ func (i *IngressBuilder) AddHost(host string) *IngressBuilder { } // Host returns the rule for a host and creates it if it did not exist. -func (i *IngressBuilder) Host(host string) *v1beta1.IngressRule { +func (i *IngressBuilder) Host(host string) *networkingv1.IngressRule { for idx := range i.ing.Spec.Rules { if i.ing.Spec.Rules[idx].Host == host { return &i.ing.Spec.Rules[idx] } } - i.ing.Spec.Rules = append(i.ing.Spec.Rules, v1beta1.IngressRule{ + i.ing.Spec.Rules = append(i.ing.Spec.Rules, networkingv1.IngressRule{ Host: host, - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{}, + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{}, }, }) return &i.ing.Spec.Rules[len(i.ing.Spec.Rules)-1] } // AddPath a new path for the given host if it did not already exist. -func (i *IngressBuilder) AddPath(host, path, service string, port intstr.IntOrString) *IngressBuilder { +func (i *IngressBuilder) AddPath(host, path, service string, port networkingv1.ServiceBackendPort) *IngressBuilder { i.Path(host, path, service, port) return i } // Path returns the Path matching the (host, path), appending the entry if // it does not already exist. -func (i *IngressBuilder) Path(host, path, service string, port intstr.IntOrString) *v1beta1.HTTPIngressPath { +func (i *IngressBuilder) Path(host, path, service string, port networkingv1.ServiceBackendPort) *networkingv1.HTTPIngressPath { h := i.Host(host) for idx := range h.HTTP.Paths { if h.HTTP.Paths[idx].Path == path { return &h.HTTP.Paths[idx] } } - h.HTTP.Paths = append(h.HTTP.Paths, v1beta1.HTTPIngressPath{ - Path: path, - Backend: v1beta1.IngressBackend{ - ServiceName: service, - ServicePort: port, + pathType := networkingv1.PathTypeImplementationSpecific + h.HTTP.Paths = append(h.HTTP.Paths, networkingv1.HTTPIngressPath{ + Path: path, + PathType: &pathType, + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: service, + Port: port, + }, }, }) return &h.HTTP.Paths[len(h.HTTP.Paths)-1] } // SetTLS sets TLS certs to given list. -func (i *IngressBuilder) SetTLS(tlsCerts []v1beta1.IngressTLS) *IngressBuilder { +func (i *IngressBuilder) SetTLS(tlsCerts []networkingv1.IngressTLS) *IngressBuilder { i.ing.Spec.TLS = tlsCerts return i } // AddTLS adds a TLS secret reference. func (i *IngressBuilder) AddTLS(hosts []string, secretName string) *IngressBuilder { - i.ing.Spec.TLS = append(i.ing.Spec.TLS, v1beta1.IngressTLS{ + i.ing.Spec.TLS = append(i.ing.Spec.TLS, networkingv1.IngressTLS{ Hosts: hosts, SecretName: secretName, }) diff --git a/pkg/fuzz/helpers_test.go b/pkg/fuzz/helpers_test.go index 8405a99918..4d0616ad2a 100644 --- a/pkg/fuzz/helpers_test.go +++ b/pkg/fuzz/helpers_test.go @@ -21,8 +21,8 @@ import ( "testing" "github.com/kr/pretty" - "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/core/v1" + networkingv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" ) @@ -61,43 +61,43 @@ func TestServiceMapFromIngress(t *testing.T) { for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *networkingv1.Ingress want ServiceMap }{ { desc: "one path", ing: NewIngressBuilder("n1", "ing1", ""). - AddPath("test1.com", "/foo", "s", intstr.FromInt(80)). + AddPath("test1.com", "/foo", "s", networkingv1.ServiceBackendPort{Number: 80}). Build(), want: ServiceMap{ - HostPath{"test1.com", "/foo"}: &v1beta1.IngressBackend{ - ServiceName: "s", ServicePort: intstr.IntOrString{IntVal: 80}, + HostPath{"test1.com", "/foo"}: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{Name: "s", Port: networkingv1.ServiceBackendPort{Number: 80}}, }, }, }, { desc: "multiple paths", ing: NewIngressBuilder("n1", "ing1", ""). - AddPath("test1.com", "/foo", "s", intstr.FromInt(80)). - AddPath("test1.com", "/bar", "s", intstr.FromInt(80)). + AddPath("test1.com", "/foo", "s", networkingv1.ServiceBackendPort{Number: 80}). + AddPath("test1.com", "/bar", "s", networkingv1.ServiceBackendPort{Number: 80}). Build(), want: ServiceMap{ - HostPath{"test1.com", "/foo"}: &v1beta1.IngressBackend{ - ServiceName: "s", ServicePort: intstr.IntOrString{IntVal: 80}, + HostPath{"test1.com", "/foo"}: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{Name: "s", Port: networkingv1.ServiceBackendPort{Number: 80}}, }, - HostPath{"test1.com", "/bar"}: &v1beta1.IngressBackend{ - ServiceName: "s", ServicePort: intstr.IntOrString{IntVal: 80}, + HostPath{"test1.com", "/bar"}: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{Name: "s", Port: networkingv1.ServiceBackendPort{Number: 80}}, }, }, }, { desc: "default backend", ing: NewIngressBuilder("n1", "ing1", ""). - DefaultBackend("s", intstr.FromInt(80)). + DefaultBackend("s", networkingv1.ServiceBackendPort{Number: 80}). Build(), want: ServiceMap{ - HostPath{}: &v1beta1.IngressBackend{ - ServiceName: "s", ServicePort: intstr.IntOrString{IntVal: 80}, + HostPath{}: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{Name: "s", Port: networkingv1.ServiceBackendPort{Number: 80}}, }, }, }, @@ -118,37 +118,43 @@ func TestIngressBuilder(t *testing.T) { name = "ing1" ns = "ns1" ) + pathType := networkingv1.PathTypeImplementationSpecific om := metav1.ObjectMeta{Name: name, Namespace: ns} for _, tc := range []struct { desc string - want *v1beta1.Ingress - got *v1beta1.Ingress + want *networkingv1.Ingress + got *networkingv1.Ingress }{ { desc: "empty", - want: &v1beta1.Ingress{ + want: &networkingv1.Ingress{ ObjectMeta: om, }, got: NewIngressBuilder(ns, name, "").Build(), }, { desc: "one path", - want: &v1beta1.Ingress{ + want: &networkingv1.Ingress{ ObjectMeta: om, - Spec: v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + Spec: networkingv1.IngressSpec{ + Rules: []networkingv1.IngressRule{ { Host: "test.com", - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{ + Paths: []networkingv1.HTTPIngressPath{ { - Path: "/", - Backend: v1beta1.IngressBackend{ - ServiceName: "svc1", - ServicePort: intstr.FromInt(80), + Path: "/", + PathType: &pathType, + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "svc1", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -159,14 +165,14 @@ func TestIngressBuilder(t *testing.T) { }, }, got: NewIngressBuilder(ns, name, ""). - AddPath("test.com", "/", "svc1", intstr.FromInt(80)). + AddPath("test.com", "/", "svc1", networkingv1.ServiceBackendPort{Number: 80}). Build(), }, { desc: "with VIP", - want: &v1beta1.Ingress{ + want: &networkingv1.Ingress{ ObjectMeta: om, - Status: v1beta1.IngressStatus{ + Status: networkingv1.IngressStatus{ LoadBalancer: v1.LoadBalancerStatus{ Ingress: []v1.LoadBalancerIngress{{IP: "127.0.0.1"}}, }, diff --git a/pkg/fuzz/validator.go b/pkg/fuzz/validator.go index a45ef8e402..cb40e86fe9 100644 --- a/pkg/fuzz/validator.go +++ b/pkg/fuzz/validator.go @@ -28,8 +28,8 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud" "github.com/google/go-cmp/cmp" - "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/core/v1" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" backendconfig "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" frontendconfig "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" @@ -128,7 +128,7 @@ func (a *IngressValidatorAttributes) schemes() []string { } // baseAttributes apply settings for the vanilla Ingress spec. -func (a *IngressValidatorAttributes) baseAttributes(ing *v1beta1.Ingress) { +func (a *IngressValidatorAttributes) baseAttributes(ing *networkingv1.Ingress) { // Check HTTP endpoint only if its enabled. if annotations.FromIngress(ing).AllowHTTP() { a.CheckHTTP = true @@ -142,7 +142,7 @@ func (a *IngressValidatorAttributes) baseAttributes(ing *v1beta1.Ingress) { } // applyFeatures applies the settings for each of the additional features. -func (a *IngressValidatorAttributes) applyFeatures(env ValidatorEnv, ing *v1beta1.Ingress, features []FeatureValidator) error { +func (a *IngressValidatorAttributes) applyFeatures(env ValidatorEnv, ing *networkingv1.Ingress, features []FeatureValidator) error { for _, f := range features { klog.V(4).Infof("Applying feature %q", f.Name()) if err := f.ConfigureAttributes(env, ing, a); err != nil { @@ -194,7 +194,7 @@ func DefaultAttributes() *IngressValidatorAttributes { // NewIngressValidator returns a new validator for checking the correctness of // an Ingress spec against the behavior of the instantiated load balancer. // If attribs is nil, then the default set of attributes will be used. -func NewIngressValidator(env ValidatorEnv, ing *v1beta1.Ingress, fc *frontendconfig.FrontendConfig, whiteboxTests []WhiteboxTest, attribs *IngressValidatorAttributes, features []Feature) (*IngressValidator, error) { +func NewIngressValidator(env ValidatorEnv, ing *networkingv1.Ingress, fc *frontendconfig.FrontendConfig, whiteboxTests []WhiteboxTest, attribs *IngressValidatorAttributes, features []Feature) (*IngressValidator, error) { var fvs []FeatureValidator for _, f := range features { fvs = append(fvs, f.NewValidator()) @@ -230,7 +230,7 @@ func NewIngressValidator(env ValidatorEnv, ing *v1beta1.Ingress, fc *frontendcon // IngressValidator encapsulates the logic required to validate a given configuration // is behaving correctly. type IngressValidator struct { - ing *v1beta1.Ingress + ing *networkingv1.Ingress fc *frontendconfig.FrontendConfig frontendNamer namer.IngressFrontendNamer features []FeatureValidator @@ -309,7 +309,7 @@ func (v *IngressValidator) CheckPaths(ctx context.Context, vr *IngressResult) er wg sync.WaitGroup ) for _, scheme := range v.attribs.schemes() { - if v.ing.Spec.Backend != nil { + if v.ing.Spec.DefaultBackend != nil { klog.V(2).Infof("Checking default backend for Ingress %s/%s", v.ing.Namespace, v.ing.Name) // Capture variables for the thunk. result := &PathResult{Scheme: scheme} diff --git a/pkg/fuzz/validator_test.go b/pkg/fuzz/validator_test.go index 0ea849ab54..f258e71f20 100644 --- a/pkg/fuzz/validator_test.go +++ b/pkg/fuzz/validator_test.go @@ -24,22 +24,21 @@ import ( "sync" "testing" - "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/core/v1" + networkingv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/client-go/kubernetes/fake" "k8s.io/ingress-gce/cmd/glbc/app" "k8s.io/ingress-gce/pkg/utils/namer" "k8s.io/klog" ) -var baseIngress = &v1beta1.Ingress{ +var baseIngress = &networkingv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: "ing1", Namespace: "default", }, - Status: v1beta1.IngressStatus{ + Status: networkingv1.IngressStatus{ LoadBalancer: v1.LoadBalancerStatus{ Ingress: []v1.LoadBalancerIngress{ {IP: "127.0.0.1"}, @@ -75,7 +74,7 @@ func (m *mockFeature) NewValidator() FeatureValidator { return m } -func (m *mockFeature) ConfigureAttributes(env ValidatorEnv, ing *v1beta1.Ingress, a *IngressValidatorAttributes) error { +func (m *mockFeature) ConfigureAttributes(env ValidatorEnv, ing *networkingv1.Ingress, a *IngressValidatorAttributes) error { switch m.mode { case mockValidatorUnstable: a.CheckHTTP = !a.CheckHTTP @@ -104,7 +103,7 @@ func TestIngressValidatorAttributes(t *testing.T) { for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *networkingv1.Ingress wantCheckHTTP bool wantCheckHTTPS bool }{ @@ -140,7 +139,7 @@ func TestNewIngressValidator(t *testing.T) { for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *networkingv1.Ingress features []Feature wantErr bool @@ -234,11 +233,11 @@ func TestValidatorCheck(t *testing.T) { t.Parallel() ctx := context.Background() - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *networkingv1.Ingress dontStartServer bool hasDefaultBackend bool @@ -340,11 +339,11 @@ func TestValidatorCheckFeature(t *testing.T) { t.Parallel() ctx := context.Background() - port80 := intstr.FromInt(80) + port80 := networkingv1.ServiceBackendPort{Number: 80} for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *networkingv1.Ingress feature Feature wantNewValidatorErr bool diff --git a/pkg/fuzz/whitebox.go b/pkg/fuzz/whitebox.go index df8dcea14e..8c9f46002a 100644 --- a/pkg/fuzz/whitebox.go +++ b/pkg/fuzz/whitebox.go @@ -17,7 +17,7 @@ limitations under the License. package fuzz import ( - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" frontendconfig "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" ) @@ -27,5 +27,5 @@ type WhiteboxTest interface { // Name of the test. Name() string // Test is the test to run. - Test(ing *v1beta1.Ingress, fc *frontendconfig.FrontendConfig, gclb *GCLB) error + Test(ing *v1.Ingress, fc *frontendconfig.FrontendConfig, gclb *GCLB) error } diff --git a/pkg/fuzz/whitebox/num_backend_services.go b/pkg/fuzz/whitebox/num_backend_services.go index 497e785960..aa3efae2c4 100644 --- a/pkg/fuzz/whitebox/num_backend_services.go +++ b/pkg/fuzz/whitebox/num_backend_services.go @@ -19,7 +19,7 @@ package whitebox import ( "fmt" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" frontendconfig "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/fuzz" "k8s.io/ingress-gce/pkg/utils" @@ -37,11 +37,11 @@ func (t *numBackendServicesTest) Name() string { } // Test implements WhiteboxTest. -func (t *numBackendServicesTest) Test(ing *v1beta1.Ingress, fc *frontendconfig.FrontendConfig, gclb *fuzz.GCLB) error { +func (t *numBackendServicesTest) Test(ing *v1.Ingress, fc *frontendconfig.FrontendConfig, gclb *fuzz.GCLB) error { t.uniqSvcPorts = make(map[utils.ServicePortID]bool) expectedBackendServices := 0 - if ing.Spec.Backend == nil { + if ing.Spec.DefaultBackend == nil { expectedBackendServices++ } diff --git a/pkg/fuzz/whitebox/num_forwarding_rules.go b/pkg/fuzz/whitebox/num_forwarding_rules.go index 831ac9299b..736235c4db 100644 --- a/pkg/fuzz/whitebox/num_forwarding_rules.go +++ b/pkg/fuzz/whitebox/num_forwarding_rules.go @@ -19,7 +19,7 @@ package whitebox import ( "fmt" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" frontendconfig "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/fuzz" @@ -36,7 +36,7 @@ func (t *numForwardingRulesTest) Name() string { } // Test implements WhiteboxTest. -func (t *numForwardingRulesTest) Test(ing *v1beta1.Ingress, fc *frontendconfig.FrontendConfig, gclb *fuzz.GCLB) error { +func (t *numForwardingRulesTest) Test(ing *v1.Ingress, fc *frontendconfig.FrontendConfig, gclb *fuzz.GCLB) error { expectedForwardingRules := 0 an := annotations.FromIngress(ing) diff --git a/pkg/fuzz/whitebox/num_target_proxies.go b/pkg/fuzz/whitebox/num_target_proxies.go index d723e50f4f..921e58b513 100644 --- a/pkg/fuzz/whitebox/num_target_proxies.go +++ b/pkg/fuzz/whitebox/num_target_proxies.go @@ -19,7 +19,7 @@ package whitebox import ( "fmt" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" frontendconfig "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/fuzz" @@ -36,7 +36,7 @@ func (t *numTargetProxiesTest) Name() string { } // Test implements WhiteboxTest. -func (t *numTargetProxiesTest) Test(ing *v1beta1.Ingress, fc *frontendconfig.FrontendConfig, gclb *fuzz.GCLB) error { +func (t *numTargetProxiesTest) Test(ing *v1.Ingress, fc *frontendconfig.FrontendConfig, gclb *fuzz.GCLB) error { expectedHTTPTargetProxies, expectedHTTPSTargetProxies := 0, 0 an := annotations.FromIngress(ing) diff --git a/pkg/fuzz/whitebox/redirect_url_map.go b/pkg/fuzz/whitebox/redirect_url_map.go index 28f9d650a7..4d1fa3bff0 100644 --- a/pkg/fuzz/whitebox/redirect_url_map.go +++ b/pkg/fuzz/whitebox/redirect_url_map.go @@ -20,7 +20,7 @@ import ( "fmt" "strings" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" frontendconfig "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/fuzz" ) @@ -36,7 +36,7 @@ func (t *redirectURLMapTest) Name() string { } // Test implements WhiteboxTest. -func (t *redirectURLMapTest) Test(ing *v1beta1.Ingress, fc *frontendconfig.FrontendConfig, gclb *fuzz.GCLB) error { +func (t *redirectURLMapTest) Test(ing *v1.Ingress, fc *frontendconfig.FrontendConfig, gclb *fuzz.GCLB) error { expectedMaps := 0 if fc != nil && fc.Spec.RedirectToHttps != nil && fc.Spec.RedirectToHttps.Enabled { diff --git a/pkg/loadbalancers/addresses_test.go b/pkg/loadbalancers/addresses_test.go index 7ea4cda374..333aa517cd 100644 --- a/pkg/loadbalancers/addresses_test.go +++ b/pkg/loadbalancers/addresses_test.go @@ -21,7 +21,7 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" "github.com/google/go-cmp/cmp" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" "k8s.io/ingress-gce/pkg/composite" ) @@ -53,7 +53,7 @@ func TestNewStaticAddress(t *testing.T) { for _, tc := range testCases { t.Run(tc.desc, func(t *testing.T) { l7 := &L7{ - ingress: v1beta1.Ingress{Spec: v1beta1.IngressSpec{}}, + ingress: v1.Ingress{Spec: v1.IngressSpec{}}, fw: &composite.ForwardingRule{IPAddress: tc.ip}, } diff --git a/pkg/loadbalancers/features/features.go b/pkg/loadbalancers/features/features.go index 53341724ca..9a57a2c9a6 100644 --- a/pkg/loadbalancers/features/features.go +++ b/pkg/loadbalancers/features/features.go @@ -19,7 +19,7 @@ package features import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/ingress-gce/pkg/utils" ) @@ -92,7 +92,7 @@ func (r *ResourceVersions) merge(other *ResourceVersions) *ResourceVersions { } // featuresFromIngress returns the features enabled by an ingress -func featuresFromIngress(ing *v1beta1.Ingress) []string { +func featuresFromIngress(ing *v1.Ingress) []string { var result []string if utils.IsGCEL7ILBIngress(ing) { result = append(result, FeatureL7ILB) @@ -149,11 +149,11 @@ func scopeFromFeatures(features []string) meta.KeyType { // TODO: (shance) refactor scope to be per-resource // ScopeFromIngress returns the required scope of features for an Ingress -func ScopeFromIngress(ing *v1beta1.Ingress) meta.KeyType { +func ScopeFromIngress(ing *v1.Ingress) meta.KeyType { return scopeFromFeatures(featuresFromIngress(ing)) } // VersionsFromIngress returns a ResourceVersions struct containing all of the resources per version -func VersionsFromIngress(ing *v1beta1.Ingress) *ResourceVersions { +func VersionsFromIngress(ing *v1.Ingress) *ResourceVersions { return versionsFromFeatures(featuresFromIngress(ing)) } diff --git a/pkg/loadbalancers/features/features_test.go b/pkg/loadbalancers/features/features_test.go index 2dd284519e..952842e2df 100644 --- a/pkg/loadbalancers/features/features_test.go +++ b/pkg/loadbalancers/features/features_test.go @@ -17,11 +17,12 @@ limitations under the License. package features import ( - "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/networking/v1beta1" - "k8s.io/apimachinery/pkg/apis/meta/v1" "reflect" "testing" + + "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" + networkingv1 "k8s.io/api/networking/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) const ( @@ -62,7 +63,7 @@ var ( UrlMap: meta.VersionAlpha, } - emptyIng = v1beta1.Ingress{ + emptyIng = networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{}, }, @@ -86,7 +87,7 @@ var ( func TestScopeFromIngress(t *testing.T) { testCases := []struct { desc string - ing v1beta1.Ingress + ing networkingv1.Ingress scope meta.KeyType }{ { diff --git a/pkg/loadbalancers/interfaces.go b/pkg/loadbalancers/interfaces.go index 25cd05baee..c0312fb4bc 100644 --- a/pkg/loadbalancers/interfaces.go +++ b/pkg/loadbalancers/interfaces.go @@ -18,7 +18,7 @@ package loadbalancers import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" ) // LoadBalancerPool is an interface to manage the cloud resources associated @@ -27,13 +27,13 @@ type LoadBalancerPool interface { // Ensure ensures a loadbalancer and its resources given the RuntimeInfo. Ensure(ri *L7RuntimeInfo) (*L7, error) // GCv2 garbage collects loadbalancer associated with given ingress using v2 naming scheme. - GCv2(ing *v1beta1.Ingress, scope meta.KeyType) error + GCv2(ing *v1.Ingress, scope meta.KeyType) error // GCv1 garbage collects loadbalancers not in the input list using v1 naming scheme. GCv1(names []string) error // FrontendScopeChangeGC checks if GC is needed for an ingress that has changed scopes - FrontendScopeChangeGC(ing *v1beta1.Ingress) (*meta.KeyType, error) + FrontendScopeChangeGC(ing *v1.Ingress) (*meta.KeyType, error) // Shutdown deletes all loadbalancers for given list of ingresses. - Shutdown(ings []*v1beta1.Ingress) error + Shutdown(ings []*v1.Ingress) error // HasUrlMap returns true if an URL map exists in GCE for given ingress. - HasUrlMap(ing *v1beta1.Ingress) (bool, error) + HasUrlMap(ing *v1.Ingress) (bool, error) } diff --git a/pkg/loadbalancers/l7.go b/pkg/loadbalancers/l7.go index 4b555a809f..c377a6055e 100644 --- a/pkg/loadbalancers/l7.go +++ b/pkg/loadbalancers/l7.go @@ -26,7 +26,7 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" corev1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/tools/record" "k8s.io/ingress-gce/pkg/annotations" @@ -53,7 +53,7 @@ type L7RuntimeInfo struct { // TLSName is the name of the preshared cert to use. Multiple certs can be specified as a comma-separated string TLSName string // Ingress is the processed Ingress API object. - Ingress *v1beta1.Ingress + Ingress *v1.Ingress // AllowHTTP will not setup :80, if TLS is nil and AllowHTTP is set, // no loadbalancer is created. AllowHTTP bool @@ -74,7 +74,7 @@ type L7 struct { // runtimeInfo is non-cloudprovider information passed from the controller. runtimeInfo *L7RuntimeInfo // ingress stores the ingress - ingress v1beta1.Ingress + ingress v1.Ingress // cloud is an interface to manage loadbalancers in the GCE cloud. cloud *gce.Cloud // um is the UrlMap associated with this L7. @@ -215,7 +215,7 @@ func (l *L7) edgeHopHttps() error { } // requireDeleteFrontend returns true if gce loadbalancer resources needs to deleted for given protocol. -func requireDeleteFrontend(ing v1beta1.Ingress, protocol namer.NamerProtocol) bool { +func requireDeleteFrontend(ing v1.Ingress, protocol namer.NamerProtocol) bool { var keys []string switch protocol { case namer.HTTPSProtocol: diff --git a/pkg/loadbalancers/l7s.go b/pkg/loadbalancers/l7s.go index 4659d9008b..425c4d5e6d 100644 --- a/pkg/loadbalancers/l7s.go +++ b/pkg/loadbalancers/l7s.go @@ -21,7 +21,7 @@ import ( "net/http" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/common/operator" "k8s.io/ingress-gce/pkg/composite" "k8s.io/ingress-gce/pkg/events" @@ -117,7 +117,7 @@ func (l *L7s) list(key *meta.Key, version meta.Version) ([]*composite.UrlMap, er } // GCv2 implements LoadBalancerPool. -func (l *L7s) GCv2(ing *v1beta1.Ingress, scope meta.KeyType) error { +func (l *L7s) GCv2(ing *v1.Ingress, scope meta.KeyType) error { ingKey := common.NamespacedName(ing) klog.V(2).Infof("GCv2(%v)", ingKey) if err := l.delete(l.namerFactory.Namer(ing), features.VersionsFromIngress(ing), scope); err != nil { @@ -131,7 +131,7 @@ func (l *L7s) GCv2(ing *v1beta1.Ingress, scope meta.KeyType) error { // (e.g. when a user migrates from ILB to ELB on the same ingress or vice versa.) // This only applies to the V2 Naming Scheme // TODO(shance): Refactor to avoid calling GCE every sync loop -func (l *L7s) FrontendScopeChangeGC(ing *v1beta1.Ingress) (*meta.KeyType, error) { +func (l *L7s) FrontendScopeChangeGC(ing *v1.Ingress) (*meta.KeyType, error) { if ing == nil { return nil, nil } @@ -226,14 +226,14 @@ func (l *L7s) gc(urlMaps []*composite.UrlMap, knownLoadBalancers map[namer_util. } // Shutdown implements LoadBalancerPool. -func (l *L7s) Shutdown(ings []*v1beta1.Ingress) error { +func (l *L7s) Shutdown(ings []*v1.Ingress) error { // Delete ingresses that use v1 naming scheme. if err := l.GCv1([]string{}); err != nil { return fmt.Errorf("error deleting load-balancers for v1 naming policy: %v", err) } // Delete ingresses that use v2 naming policy. var errs []error - v2Ings := operator.Ingresses(ings).Filter(func(ing *v1beta1.Ingress) bool { + v2Ings := operator.Ingresses(ings).Filter(func(ing *v1.Ingress) bool { return namer_util.FrontendNamingScheme(ing) == namer_util.V2NamingScheme }).AsList() for _, ing := range v2Ings { @@ -249,7 +249,7 @@ func (l *L7s) Shutdown(ings []*v1beta1.Ingress) error { } // HasUrlMap implements LoadBalancerPool. -func (l *L7s) HasUrlMap(ing *v1beta1.Ingress) (bool, error) { +func (l *L7s) HasUrlMap(ing *v1.Ingress) (bool, error) { namer := l.namerFactory.Namer(ing) key, err := composite.CreateKey(l.cloud, namer.UrlMap(), features.ScopeFromIngress(ing)) if err != nil { diff --git a/pkg/loadbalancers/l7s_test.go b/pkg/loadbalancers/l7s_test.go index c3d0d91dcf..ff68296160 100644 --- a/pkg/loadbalancers/l7s_test.go +++ b/pkg/loadbalancers/l7s_test.go @@ -25,7 +25,7 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" "google.golang.org/api/compute/v1" "google.golang.org/api/googleapi" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/ingress-gce/pkg/composite" @@ -316,27 +316,27 @@ func TestV2GC(t *testing.T) { feNamerFactory := l7sPool.namerFactory testCases := []struct { desc string - ingressToDelete *v1beta1.Ingress + ingressToDelete *networkingv1.Ingress addV1Ingresses bool - gcpLBs []*v1beta1.Ingress - expectedLBs []*v1beta1.Ingress + gcpLBs []*networkingv1.Ingress + expectedLBs []*networkingv1.Ingress }{ { desc: "empty", ingressToDelete: newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKeyV2), addV1Ingresses: false, - gcpLBs: []*v1beta1.Ingress{}, - expectedLBs: []*v1beta1.Ingress{}, + gcpLBs: []*networkingv1.Ingress{}, + expectedLBs: []*networkingv1.Ingress{}, }, { desc: "simple case v2 only", ingressToDelete: newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:15], longName[:20], common.FinalizerKeyV2), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:15], longName[:20], common.FinalizerKeyV2), }, @@ -344,7 +344,7 @@ func TestV2GC(t *testing.T) { { desc: "simple case both v1 and v2", ingressToDelete: newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:10], longName[:11], common.FinalizerKey), @@ -352,7 +352,7 @@ func TestV2GC(t *testing.T) { newIngressWithFinalizer(longName[:21], longName[:27], common.FinalizerKey), newIngressWithFinalizer(longName, longName, common.FinalizerKey), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:10], longName[:11], common.FinalizerKey), newIngressWithFinalizer(longName[:20], longName[:27], common.FinalizerKey), @@ -363,12 +363,12 @@ func TestV2GC(t *testing.T) { { desc: "63 characters v2 only", ingressToDelete: newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:19], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:19], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), }, @@ -376,7 +376,7 @@ func TestV2GC(t *testing.T) { { desc: "63 characters both v1 and v2", ingressToDelete: newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), @@ -385,7 +385,7 @@ func TestV2GC(t *testing.T) { newIngressWithFinalizer(longName[:21], longName[:27], common.FinalizerKey), newIngressWithFinalizer(longName, longName, common.FinalizerKey), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKey), @@ -397,12 +397,12 @@ func TestV2GC(t *testing.T) { { desc: "longNameSpace v2 only", ingressToDelete: newIngressWithFinalizer(longName, longName[:1], common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName, longName[:1], common.FinalizerKeyV2), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), }, @@ -410,7 +410,7 @@ func TestV2GC(t *testing.T) { { desc: "longNameSpace both v1 and v2", ingressToDelete: newIngressWithFinalizer(longName, longName[:1], common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName, longName[:1], common.FinalizerKeyV2), @@ -419,7 +419,7 @@ func TestV2GC(t *testing.T) { newIngressWithFinalizer(longName[:21], longName[:27], common.FinalizerKey), newIngressWithFinalizer(longName, longName, common.FinalizerKey), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKey), @@ -431,12 +431,12 @@ func TestV2GC(t *testing.T) { { desc: "longName v2 only", ingressToDelete: newIngressWithFinalizer(longName[:1], longName, common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:1], longName, common.FinalizerKeyV2), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), }, @@ -444,7 +444,7 @@ func TestV2GC(t *testing.T) { { desc: "longName both v1 and v2", ingressToDelete: newIngressWithFinalizer(longName[:1], longName, common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:1], longName, common.FinalizerKeyV2), @@ -453,7 +453,7 @@ func TestV2GC(t *testing.T) { newIngressWithFinalizer(longName[:21], longName[:27], common.FinalizerKey), newIngressWithFinalizer(longName, longName, common.FinalizerKey), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKey), @@ -465,12 +465,12 @@ func TestV2GC(t *testing.T) { { desc: "longNameSpace and longName v2 only", ingressToDelete: newIngressWithFinalizer(longName, longName, common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName, longName, common.FinalizerKeyV2), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:18], longName[:18], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), }, @@ -478,7 +478,7 @@ func TestV2GC(t *testing.T) { { desc: "longNameSpace and longName both v1 and v2", ingressToDelete: newIngressWithFinalizer(longName, longName, common.FinalizerKeyV2), - gcpLBs: []*v1beta1.Ingress{ + gcpLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName, longName, common.FinalizerKeyV2), @@ -487,7 +487,7 @@ func TestV2GC(t *testing.T) { newIngressWithFinalizer(longName[:21], longName[:27], common.FinalizerKey), newIngressWithFinalizer(longName, longName, common.FinalizerKey), }, - expectedLBs: []*v1beta1.Ingress{ + expectedLBs: []*networkingv1.Ingress{ newIngressWithFinalizer(longName[:10], longName[:15], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:30], longName[:30], common.FinalizerKeyV2), newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKey), @@ -501,7 +501,7 @@ func TestV2GC(t *testing.T) { // Add LBs owned by another cluster. otherNamer := namer_util.NewNamer("clusteruid", "fw1") otherFeNamerFactory := namer_util.NewFrontendNamerFactory(otherNamer, "ksuid234") - otherIngresses := []*v1beta1.Ingress{ + otherIngresses := []*networkingv1.Ingress{ // ingresses with v1 naming scheme. newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKey), newIngressWithFinalizer(longName[:20], longName[:27], common.FinalizerKey), @@ -571,7 +571,7 @@ func TestDoNotLeakV2LB(t *testing.T) { type testCase struct { desc string - ing *v1beta1.Ingress + ing *networkingv1.Ingress } var testCases []testCase @@ -583,7 +583,7 @@ func TestDoNotLeakV2LB(t *testing.T) { // Add LBs owned by another cluster. otherNamer := namer_util.NewNamer("clusteruid", "fw1") otherFeNamerFactory := namer_util.NewFrontendNamerFactory(otherNamer, "ksuid234") - otherIngresses := []*v1beta1.Ingress{ + otherIngresses := []*networkingv1.Ingress{ // ingresses with v1 naming scheme. newIngressWithFinalizer(longName[:10], longName[:10], common.FinalizerKey), newIngressWithFinalizer(longName[:20], longName[:27], common.FinalizerKey), @@ -722,8 +722,8 @@ func generateKeyWithLength(length int) string { return fmt.Sprintf("%s/%s", longName[:length/2], longName[:length-length/2]) } -func newIngressWithFinalizer(namespace, name, finalizer string) *v1beta1.Ingress { - return &v1beta1.Ingress{ +func newIngressWithFinalizer(namespace, name, finalizer string) *networkingv1.Ingress { + return &networkingv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, diff --git a/pkg/loadbalancers/loadbalancers_test.go b/pkg/loadbalancers/loadbalancers_test.go index 00cf4d029e..76286fbe20 100644 --- a/pkg/loadbalancers/loadbalancers_test.go +++ b/pkg/loadbalancers/loadbalancers_test.go @@ -30,7 +30,7 @@ import ( "github.com/google/go-cmp/cmp" "google.golang.org/api/compute/v1" "google.golang.org/api/googleapi" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/ingress-gce/pkg/annotations" @@ -63,7 +63,7 @@ type testJig struct { fakeGCE *gce.Cloud mock *cloud.MockGCE namer *namer_util.Namer - ing *v1beta1.Ingress + ing *networkingv1.Ingress feNamer namer_util.IngressFrontendNamer t *testing.T } @@ -145,8 +145,8 @@ func (j *testJig) String() string { return "testJig.String() Not implemented" } -func newIngress() *v1beta1.Ingress { - return &v1beta1.Ingress{ +func newIngress() *networkingv1.Ingress { + return &networkingv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: ingressName, Namespace: namespace, @@ -162,8 +162,8 @@ func newFakeLoadBalancerPool(cloud *gce.Cloud, t *testing.T, namer *namer_util.N return L7s{cloud, namer, events.RecorderProducerMock{}, namer_util.NewFrontendNamerFactory(namer, "")} } -func newILBIngress() *v1beta1.Ingress { - return &v1beta1.Ingress{ +func newILBIngress() *networkingv1.Ingress { + return &networkingv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: ingressName, Namespace: namespace, @@ -1844,14 +1844,14 @@ func TestResourceDeletionWithScopeChange(t *testing.T) { beforeClass string afterClass string gcScope meta.KeyType - ing *v1beta1.Ingress + ing *networkingv1.Ingress }{ { desc: "ELB to ILB", beforeClass: "gce", afterClass: "gce-internal", gcScope: meta.Global, - ing: &v1beta1.Ingress{ + ing: &networkingv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: "ing-1", Namespace: namespace, @@ -1864,7 +1864,7 @@ func TestResourceDeletionWithScopeChange(t *testing.T) { beforeClass: "gce-internal", afterClass: "gce", gcScope: meta.Regional, - ing: &v1beta1.Ingress{ + ing: &networkingv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: "ing-2", Namespace: namespace, diff --git a/pkg/metrics/features.go b/pkg/metrics/features.go index 9c7f1aefc2..236898eb5e 100644 --- a/pkg/metrics/features.go +++ b/pkg/metrics/features.go @@ -20,7 +20,7 @@ import ( "fmt" "strconv" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/utils" @@ -115,7 +115,7 @@ const ( ) // featuresForIngress returns the list of features for given ingress. -func featuresForIngress(ing *v1beta1.Ingress, fc *frontendconfigv1beta1.FrontendConfig) []feature { +func featuresForIngress(ing *v1.Ingress, fc *frontendconfigv1beta1.FrontendConfig) []feature { features := []feature{ingress} ingKey := fmt.Sprintf("%s/%s", ing.Namespace, ing.Name) @@ -235,7 +235,7 @@ func featuresForIngress(ing *v1beta1.Ingress, fc *frontendconfigv1beta1.Frontend } // hasSecretBasedCerts returns true if ingress spec contains a secret based cert. -func hasSecretBasedCerts(ing *v1beta1.Ingress) bool { +func hasSecretBasedCerts(ing *v1.Ingress) bool { for _, tlsSecret := range ing.Spec.TLS { if tlsSecret.SecretName == "" { continue diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go index a2542e2ee4..95122d8d38 100644 --- a/pkg/metrics/metrics.go +++ b/pkg/metrics/metrics.go @@ -22,7 +22,7 @@ import ( "time" "github.com/prometheus/client_golang/prometheus" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/util/wait" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/utils" @@ -90,7 +90,7 @@ func init() { } // NewIngressState returns ingress state for given ingress and service ports. -func NewIngressState(ing *v1beta1.Ingress, fc *frontendconfigv1beta1.FrontendConfig, svcPorts []utils.ServicePort) IngressState { +func NewIngressState(ing *v1.Ingress, fc *frontendconfigv1beta1.FrontendConfig, svcPorts []utils.ServicePort) IngressState { return IngressState{ingress: ing, frontendconfig: fc, servicePorts: svcPorts} } diff --git a/pkg/metrics/metrics_test.go b/pkg/metrics/metrics_test.go index d7bc8c44e3..259721b4cf 100644 --- a/pkg/metrics/metrics_test.go +++ b/pkg/metrics/metrics_test.go @@ -21,10 +21,9 @@ import ( "testing" "github.com/google/go-cmp/cmp" - "k8s.io/api/networking/v1beta1" - v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + v1 "k8s.io/api/networking/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/ingress-gce/pkg/annotations" backendconfigv1 "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" @@ -41,7 +40,7 @@ var ( Name: "dummy-service", Namespace: defaultNamespace, }, - Port: intstr.FromInt(80), + Port: v1.ServiceBackendPort{Number: 80}, }, BackendConfig: &backendconfigv1.BackendConfig{ Spec: backendconfigv1.BackendConfigSpec{ @@ -69,7 +68,7 @@ var ( Name: "foo-service", Namespace: defaultNamespace, }, - Port: intstr.FromInt(80), + Port: v1.ServiceBackendPort{Number: 80}, }, NEGEnabled: true, BackendConfig: &backendconfigv1.BackendConfig{ @@ -95,7 +94,7 @@ var ( Name: "dummy-service", Namespace: defaultNamespace, }, - Port: intstr.FromInt(80), + Port: v1.ServiceBackendPort{Number: 80}, }, NEGEnabled: true, L7ILBEnabled: true, @@ -106,7 +105,7 @@ var ( Name: "bar-service", Namespace: defaultNamespace, }, - Port: intstr.FromInt(5000), + Port: v1.ServiceBackendPort{Number: 5000}, }, NEGEnabled: true, L7ILBEnabled: true, @@ -128,7 +127,7 @@ var ( } ingressStates = []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress fc *frontendconfigv1beta1.FrontendConfig frontendFeatures []feature svcPorts []utils.ServicePort @@ -136,8 +135,8 @@ var ( }{ { "empty spec", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress0", }, @@ -149,8 +148,8 @@ var ( }, { "http disabled", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress1", Annotations: map[string]string{ @@ -164,17 +163,21 @@ var ( }, { "default backend", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress2", }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, nil, @@ -185,13 +188,13 @@ var ( }, { "host rule only", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress3", }, - Spec: v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + Spec: v1.IngressSpec{ + Rules: []v1.IngressRule{ { Host: "foo.bar", }, @@ -205,23 +208,27 @@ var ( }, { "both host and path rules", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress4", }, - Spec: v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + Spec: v1.IngressSpec{ + Rules: []v1.IngressRule{ { Host: "foo.bar", - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: v1.IngressRuleValue{ + HTTP: &v1.HTTPIngressRuleValue{ + Paths: []v1.HTTPIngressPath{ { Path: "/foo", - Backend: v1beta1.IngressBackend{ - ServiceName: "foo-service", - ServicePort: intstr.FromInt(80), + Backend: v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "foo-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, }, }, @@ -240,27 +247,35 @@ var ( }, { "default backend and host rule", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress5", }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{ + Rules: []v1.IngressRule{ { Host: "foo.bar", - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: v1.IngressRuleValue{ + HTTP: &v1.HTTPIngressRuleValue{ + Paths: []v1.HTTPIngressPath{ { Path: "/foo", - Backend: v1beta1.IngressBackend{ - ServiceName: "foo-service", - ServicePort: intstr.FromInt(80), + Backend: v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "foo-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, }, }, @@ -280,8 +295,8 @@ var ( }, { "tls termination with pre-shared certs", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress6", Annotations: map[string]string{ @@ -289,12 +304,16 @@ var ( SSLCertKey: "pre-shared-cert1,pre-shared-cert2", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, nil, @@ -306,8 +325,8 @@ var ( }, { "tls termination with google managed certs", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress7", Annotations: map[string]string{ @@ -315,12 +334,16 @@ var ( SSLCertKey: "managed-cert1,managed-cert2", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, nil, @@ -332,8 +355,8 @@ var ( }, { "tls termination with pre-shared and google managed certs", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress8", Annotations: map[string]string{ @@ -342,12 +365,16 @@ var ( SSLCertKey: "pre-shared-cert1,pre-shared-cert2,managed-cert1,managed-cert2", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, nil, @@ -359,8 +386,8 @@ var ( }, { "tls termination with pre-shared and secret based certs", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress9", Annotations: map[string]string{ @@ -368,18 +395,22 @@ var ( SSLCertKey: "pre-shared-cert1,pre-shared-cert2", }, }, - Spec: v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + Spec: v1.IngressSpec{ + Rules: []v1.IngressRule{ { Host: "foo.bar", - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: v1.IngressRuleValue{ + HTTP: &v1.HTTPIngressRuleValue{ + Paths: []v1.HTTPIngressPath{ { Path: "/foo", - Backend: v1beta1.IngressBackend{ - ServiceName: "foo-service", - ServicePort: intstr.FromInt(80), + Backend: v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "foo-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, }, }, @@ -387,7 +418,7 @@ var ( }, }, }, - TLS: []v1beta1.IngressTLS{ + TLS: []v1.IngressTLS{ { Hosts: []string{"foo.bar"}, SecretName: "secret-1", @@ -404,8 +435,8 @@ var ( }, { "global static ip", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress10", Annotations: map[string]string{ @@ -414,12 +445,16 @@ var ( staticIPKey: "10.0.1.2", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, nil, @@ -431,30 +466,39 @@ var ( }, { "default backend, host rule for internal load-balancer", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress11", Annotations: map[string]string{ ingressClassKey: gceL7ILBIngressClass, }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{ + Rules: []v1.IngressRule{ { Host: "bar", - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: v1.IngressRuleValue{ + HTTP: &v1.HTTPIngressRuleValue{ + Paths: []v1.HTTPIngressPath{ { Path: "/bar", - Backend: v1beta1.IngressBackend{ - ServiceName: "bar-service", - ServicePort: intstr.FromInt(5000), + Backend: v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + + Name: "bar-service", + Port: v1.ServiceBackendPort{ + Number: int32(5000), + }, + }, }, }, }, @@ -473,20 +517,24 @@ var ( }, { "non-existent pre-shared cert", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress12", Annotations: map[string]string{ preSharedCertKey: "pre-shared-cert1", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, nil, @@ -496,8 +544,8 @@ var ( }, { "user specified global static IP", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress13", Annotations: map[string]string{ @@ -505,12 +553,16 @@ var ( staticIPKey: "user-spec-static-ip", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, nil, @@ -521,8 +573,8 @@ var ( }, { "sslpolicy and tls termination with pre-shared certs", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress14", Annotations: map[string]string{ @@ -530,12 +582,16 @@ var ( SSLCertKey: "pre-shared-cert1,pre-shared-cert2", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, &frontendconfigv1beta1.FrontendConfig{ @@ -550,8 +606,8 @@ var ( }, { "user specified regional static IP", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress15", Annotations: map[string]string{ @@ -559,12 +615,16 @@ var ( ingressClassKey: "gce-internal", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, nil, @@ -575,8 +635,8 @@ var ( }, { "HTTPS Redirects and tls termination with pre-shared certs", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress16", Annotations: map[string]string{ @@ -584,12 +644,16 @@ var ( SSLCertKey: "pre-shared-cert1,pre-shared-cert2", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, &frontendconfigv1beta1.FrontendConfig{ @@ -604,8 +668,8 @@ var ( }, { "HTTPS Redirects Disabled and tls termination with pre-shared certs", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress17", Annotations: map[string]string{ @@ -613,12 +677,16 @@ var ( SSLCertKey: "pre-shared-cert1,pre-shared-cert2", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, &frontendconfigv1beta1.FrontendConfig{ @@ -633,8 +701,8 @@ var ( }, { "empty sslpolicy and tls termination with pre-shared certs", - &v1beta1.Ingress{ - ObjectMeta: v1.ObjectMeta{ + &v1.Ingress{ + ObjectMeta: metav1.ObjectMeta{ Namespace: defaultNamespace, Name: "ingress18", Annotations: map[string]string{ @@ -642,12 +710,16 @@ var ( SSLCertKey: "pre-shared-cert1,pre-shared-cert2", }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "dummy-service", + Port: v1.ServiceBackendPort{ + Number: int32(80), + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []v1.IngressRule{}, }, }, &frontendconfigv1beta1.FrontendConfig{ diff --git a/pkg/metrics/types.go b/pkg/metrics/types.go index 2bc926e96d..c282be9f21 100644 --- a/pkg/metrics/types.go +++ b/pkg/metrics/types.go @@ -17,14 +17,14 @@ limitations under the License. package metrics import ( - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" "k8s.io/ingress-gce/pkg/utils" ) // IngressState defines an ingress and its associated service ports. type IngressState struct { - ingress *v1beta1.Ingress + ingress *v1.Ingress frontendconfig *frontendconfigv1beta1.FrontendConfig servicePorts []utils.ServicePort } diff --git a/pkg/neg/controller.go b/pkg/neg/controller.go index 75b27c1277..af7a190eec 100644 --- a/pkg/neg/controller.go +++ b/pkg/neg/controller.go @@ -780,7 +780,7 @@ func (c *Controller) enqueueIngressServices(ing *v1.Ingress) { } // enqueue default backend service - if ing.Spec.Backend == nil { + if ing.Spec.DefaultBackend == nil { c.enqueueService(cache.ExplicitKey(c.defaultBackendService.ID.Service.String())) } } diff --git a/pkg/neg/controller_test.go b/pkg/neg/controller_test.go index 434450362b..94f4ba7df9 100644 --- a/pkg/neg/controller_test.go +++ b/pkg/neg/controller_test.go @@ -35,7 +35,7 @@ import ( istioV1alpha3 "istio.io/api/networking/v1alpha3" apiv1 "k8s.io/api/core/v1" v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" @@ -66,7 +66,7 @@ var ( Name: "default-http-backend", Namespace: "kube-system", }, - Port: intstr.FromString("http"), + Port: networkingv1.ServiceBackendPort{Name: "http"}, }, Port: 80, TargetPort: "9376"} @@ -434,20 +434,24 @@ func TestGatherPortMappingUsedByIngress(t *testing.T) { t.Parallel() testCases := []struct { - ings []v1beta1.Ingress + ings []networkingv1.Ingress expect []int32 desc string }{ { - []v1beta1.Ingress{{ + []networkingv1.Ingress{{ ObjectMeta: metav1.ObjectMeta{ Name: testServiceName, Namespace: testServiceNamespace, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "nonExists", - ServicePort: intstr.FromString(testNamedPort), + Spec: networkingv1.IngressSpec{ + DefaultBackend: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "nonExists", + Port: networkingv1.ServiceBackendPort{ + Name: testNamedPort, + }, + }, }, }, }}, @@ -455,15 +459,19 @@ func TestGatherPortMappingUsedByIngress(t *testing.T) { "no match", }, { - []v1beta1.Ingress{{ + []networkingv1.Ingress{{ ObjectMeta: metav1.ObjectMeta{ Name: testServiceName, Namespace: testServiceNamespace, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: testServiceName, - ServicePort: intstr.FromString("NonExisted"), + Spec: networkingv1.IngressSpec{ + DefaultBackend: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: testServiceName, + Port: networkingv1.ServiceBackendPort{ + Name: "NonExisted", + }, + }, }, }, }}, @@ -471,29 +479,37 @@ func TestGatherPortMappingUsedByIngress(t *testing.T) { "ingress spec point to non-existed service port", }, { - []v1beta1.Ingress{{ + []networkingv1.Ingress{{ ObjectMeta: metav1.ObjectMeta{ Name: testServiceName, Namespace: testServiceNamespace, }, - Spec: v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + Spec: networkingv1.IngressSpec{ + Rules: []networkingv1.IngressRule{ { - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{ + Paths: []networkingv1.HTTPIngressPath{ { Path: "/path1", - Backend: v1beta1.IngressBackend{ - ServiceName: testServiceName, - ServicePort: intstr.FromInt(80), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: testServiceName, + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, { Path: "/path2", - Backend: v1beta1.IngressBackend{ - ServiceName: "nonExisted", - ServicePort: intstr.FromInt(443), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "nonExisted", + Port: networkingv1.ServiceBackendPort{ + Number: 443, + }, + }, }, }, }, @@ -507,32 +523,37 @@ func TestGatherPortMappingUsedByIngress(t *testing.T) { "ingress point to multiple services", }, { - []v1beta1.Ingress{*newTestIngress(testServiceName), *newTestIngress(testServiceName)}, + []networkingv1.Ingress{*newTestIngress(testServiceName), *newTestIngress(testServiceName)}, []int32{80, 443, 8081}, "two ingresses with multiple different references to service", }, { - []v1beta1.Ingress{*newTestIngress(testServiceName)}, + []networkingv1.Ingress{*newTestIngress(testServiceName)}, []int32{80, 443, 8081}, "one ingress with multiple different references to service", }, { - []v1beta1.Ingress{{ + []networkingv1.Ingress{{ ObjectMeta: metav1.ObjectMeta{ Name: testServiceName, Namespace: testServiceNamespace, }, - Spec: v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + Spec: networkingv1.IngressSpec{ + Rules: []networkingv1.IngressRule{ { - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{ + Paths: []networkingv1.HTTPIngressPath{ { Path: "/path1", - Backend: v1beta1.IngressBackend{ - ServiceName: testServiceName, - ServicePort: intstr.FromString(testNamedPortWithNumber), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + + Name: testServiceName, + Port: networkingv1.ServiceBackendPort{ + Name: testNamedPortWithNumber, + }, + }, }, }, }, @@ -552,7 +573,7 @@ func TestGatherPortMappingUsedByIngress(t *testing.T) { defer controller.stop() portTupleSet := gatherPortMappingUsedByIngress(tc.ings, newTestService(controller, true, []int32{})) if len(portTupleSet) != len(tc.expect) { - t.Errorf("Expect %v ports, but got %v.", len(tc.expect), len(portTupleSet)) + t.Errorf("For test case %q, expect %d ports, but got %d.", tc.desc, len(tc.expect), len(portTupleSet)) } for _, exp := range tc.expect { @@ -566,7 +587,7 @@ func TestGatherPortMappingUsedByIngress(t *testing.T) { } } if !found { - t.Errorf("Expect ports to include %v.", exp) + t.Errorf("For test case %q, expect ports to include %v.", tc.desc, exp) } } } @@ -712,7 +733,8 @@ func TestDefaultBackendServicePortInfoMapForL7ILB(t *testing.T) { Service: types.NamespacedName{ Namespace: testServiceNamespace, Name: "newDefaultBackend", }, - Port: intstr.FromInt(80), + // Default Backend Service Port is always referenced by name + Port: networkingv1.ServiceBackendPort{Name: "80"}, }, Port: 80, TargetPort: "8888", @@ -738,10 +760,10 @@ func TestDefaultBackendServicePortInfoMapForL7ILB(t *testing.T) { if tc.defaultOverride { // Override backend service controller.defaultBackendService = tc.defaultBackendServiceServicePort - ing.Spec.Backend = nil + ing.Spec.DefaultBackend = nil } - newIng, err := controller.client.NetworkingV1beta1().Ingresses(testServiceNamespace).Create(context.TODO(), ing, metav1.CreateOptions{}) + newIng, err := controller.client.NetworkingV1().Ingresses(testServiceNamespace).Create(context.TODO(), ing, metav1.CreateOptions{}) if err != nil { t.Fatal(err) } @@ -776,28 +798,30 @@ func TestMergeDefaultBackendServicePortInfoMap(t *testing.T) { for _, tc := range []struct { desc string - getIngress func() *v1beta1.Ingress + getIngress func() *networkingv1.Ingress defaultService *v1.Service expectNeg bool }{ { desc: "no ingress", - getIngress: func() *v1beta1.Ingress { return nil }, + getIngress: func() *networkingv1.Ingress { return nil }, defaultService: defaultBackendService, expectNeg: false, }, { desc: "no ingress and default backend service has NEG annotation", - getIngress: func() *v1beta1.Ingress { return nil }, + getIngress: func() *networkingv1.Ingress { return nil }, defaultService: defaultBackendServiceWithNeg, expectNeg: false, }, { desc: "ing1 has backend and default backend service does not have NEG annotation", - getIngress: func() *v1beta1.Ingress { + getIngress: func() *networkingv1.Ingress { ing := newTestIngress("ing1") - ing.Spec.Backend = &v1beta1.IngressBackend{ - ServiceName: "svc1", + ing.Spec.DefaultBackend = &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "svc1", + }, } return ing }, @@ -806,15 +830,15 @@ func TestMergeDefaultBackendServicePortInfoMap(t *testing.T) { }, { desc: "ing1 has backend and default backend service has NEG annotation", - getIngress: func() *v1beta1.Ingress { return nil }, + getIngress: func() *networkingv1.Ingress { return nil }, defaultService: defaultBackendServiceWithNeg, expectNeg: false, }, { desc: "ing2 does not backend and default backend service does not have NEG annotation", - getIngress: func() *v1beta1.Ingress { + getIngress: func() *networkingv1.Ingress { ing := newTestIngress("ing2") - ing.Spec.Backend = nil + ing.Spec.DefaultBackend = nil return ing }, defaultService: defaultBackendService, @@ -822,13 +846,13 @@ func TestMergeDefaultBackendServicePortInfoMap(t *testing.T) { }, { desc: "ing2 does not backend and default backend service has NEG annotation", - getIngress: func() *v1beta1.Ingress { return nil }, + getIngress: func() *networkingv1.Ingress { return nil }, defaultService: defaultBackendServiceWithNeg, expectNeg: true, }, { desc: "ing3 is L7 ILB, has backend and default backend service does not have NEG annotation", - getIngress: func() *v1beta1.Ingress { + getIngress: func() *networkingv1.Ingress { ing := newTestIngress("ing3") ing.Annotations = map[string]string{annotations.IngressClassKey: annotations.GceL7ILBIngressClass} return ing @@ -838,10 +862,10 @@ func TestMergeDefaultBackendServicePortInfoMap(t *testing.T) { }, { desc: "L7ILB is enabled, ing4 is L7 ILB, does not has backend and default backend service does not have NEG annotation", - getIngress: func() *v1beta1.Ingress { + getIngress: func() *networkingv1.Ingress { ing := newTestIngress("ing4") ing.Annotations = map[string]string{annotations.IngressClassKey: annotations.GceL7ILBIngressClass} - ing.Spec.Backend = nil + ing.Spec.DefaultBackend = nil return ing }, defaultService: defaultBackendService, @@ -849,7 +873,7 @@ func TestMergeDefaultBackendServicePortInfoMap(t *testing.T) { }, { desc: "cluster has many ingresses (ILB and XLB) without backend and default backend service has NEG annotation", - getIngress: func() *v1beta1.Ingress { return nil }, + getIngress: func() *networkingv1.Ingress { return nil }, defaultService: defaultBackendServiceWithNeg, expectNeg: true, }, @@ -869,7 +893,7 @@ func TestMergeDefaultBackendServicePortInfoMap(t *testing.T) { if tc.expectNeg { if !reflect.DeepEqual(portMap, expectPortMap) { - t.Errorf("for test case %q, expect port map == %v, but got %v", tc.desc, expectPortMap, portMap) + t.Errorf("for test case %q, expect port map == \n%+v, but got \n%+v", tc.desc, expectPortMap, portMap) } } else { if !reflect.DeepEqual(portMap, expectEmptyPortmap) { @@ -1392,41 +1416,57 @@ func generateCustomNamedNegAnnotation(ingress bool, svcPorts map[int32]string) s return string(formattedAnnotation) } -func newTestIngress(name string) *v1beta1.Ingress { - return &v1beta1.Ingress{ +func newTestIngress(name string) *networkingv1.Ingress { + return &networkingv1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: testServiceNamespace, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: testServiceName, - ServicePort: intstr.FromString(testNamedPort), + Spec: networkingv1.IngressSpec{ + DefaultBackend: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: testServiceName, + Port: networkingv1.ServiceBackendPort{ + Name: testNamedPort, + }, + }, }, - Rules: []v1beta1.IngressRule{ + Rules: []networkingv1.IngressRule{ { - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{ + Paths: []networkingv1.HTTPIngressPath{ { Path: "/path1", - Backend: v1beta1.IngressBackend{ - ServiceName: testServiceName, - ServicePort: intstr.FromInt(80), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: testServiceName, + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, { Path: "/path2", - Backend: v1beta1.IngressBackend{ - ServiceName: testServiceName, - ServicePort: intstr.FromInt(443), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: testServiceName, + Port: networkingv1.ServiceBackendPort{ + Number: 443, + }, + }, }, }, { Path: "/path3", - Backend: v1beta1.IngressBackend{ - ServiceName: testServiceName, - ServicePort: intstr.FromString(testNamedPort), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: testServiceName, + Port: networkingv1.ServiceBackendPort{ + Name: testNamedPort, + }, + }, }, }, }, diff --git a/pkg/neg/syncers/syncer_test.go b/pkg/neg/syncers/syncer_test.go index 86c39fe96f..161d0faffd 100644 --- a/pkg/neg/syncers/syncer_test.go +++ b/pkg/neg/syncers/syncer_test.go @@ -21,8 +21,8 @@ import ( "testing" "time" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/tools/record" negtypes "k8s.io/ingress-gce/pkg/neg/types" @@ -46,7 +46,7 @@ var ( Name: "default-http-backend", Namespace: "kube-system", }, - Port: intstr.FromString("http"), + Port: v1.ServiceBackendPort{Name: "http"}, }, TargetPort: "9376", } diff --git a/pkg/neg/types/testing.go b/pkg/neg/types/testing.go index 323ef566ef..ef371285aa 100644 --- a/pkg/neg/types/testing.go +++ b/pkg/neg/types/testing.go @@ -22,7 +22,7 @@ import ( apiv1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" informerv1 "k8s.io/client-go/informers/core/v1" - informerv1beta1 "k8s.io/client-go/informers/networking/v1beta1" + informernetworking "k8s.io/client-go/informers/networking/v1" "k8s.io/client-go/kubernetes" "k8s.io/client-go/kubernetes/fake" "k8s.io/client-go/tools/cache" @@ -80,7 +80,7 @@ func NewTestContextWithKubeClient(kubeClient kubernetes.Interface) *TestContext Cloud: fakeGCE, NegNamer: clusterNamer, L4Namer: l4namer, - IngressInformer: informerv1beta1.NewIngressInformer(kubeClient, namespace, resyncPeriod, utils.NewNamespaceIndexer()), + IngressInformer: informernetworking.NewIngressInformer(kubeClient, namespace, resyncPeriod, utils.NewNamespaceIndexer()), PodInformer: informerv1.NewPodInformer(kubeClient, namespace, resyncPeriod, utils.NewNamespaceIndexer()), ServiceInformer: informerv1.NewServiceInformer(kubeClient, namespace, resyncPeriod, utils.NewNamespaceIndexer()), EndpointInformer: informerv1.NewEndpointsInformer(kubeClient, namespace, resyncPeriod, utils.NewNamespaceIndexer()), diff --git a/pkg/sync/interfaces.go b/pkg/sync/interfaces.go index a8d01c9999..a10ab56b26 100644 --- a/pkg/sync/interfaces.go +++ b/pkg/sync/interfaces.go @@ -18,7 +18,7 @@ package sync import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/utils" ) @@ -31,7 +31,7 @@ type Syncer interface { // GC workflow performs frontend resource deletion based on given gc algorithm. // TODO(rramkumar): Do we need to rethink the strategy of GC'ing // all Ingresses at once? - GC(ings []*v1beta1.Ingress, currIng *v1beta1.Ingress, frontendGCAlgorithm utils.FrontendGCAlgorithm, scope meta.KeyType) error + GC(ings []*v1.Ingress, currIng *v1.Ingress, frontendGCAlgorithm utils.FrontendGCAlgorithm, scope meta.KeyType) error } // Controller is an interface for ingress controllers and declares methods @@ -40,19 +40,19 @@ type Controller interface { // SyncBackends syncs the backends for a GCLB given some existing state. SyncBackends(state interface{}) error // GCBackends garbage collects backends for all ingresses given a list of ingresses to exclude from GC. - GCBackends(toKeep []*v1beta1.Ingress) error + GCBackends(toKeep []*v1.Ingress) error // SyncLoadBalancer syncs the front-end load balancer resources for a GCLB given some existing state. SyncLoadBalancer(state interface{}) error // GCv1LoadBalancers garbage collects front-end load balancer resources for all ingresses // given a list of ingresses with v1 naming policy to exclude from GC. - GCv1LoadBalancers(toKeep []*v1beta1.Ingress) error + GCv1LoadBalancers(toKeep []*v1.Ingress) error // GCv2LoadBalancer garbage collects front-end load balancer resources for given ingress // with v2 naming policy. - GCv2LoadBalancer(ing *v1beta1.Ingress, scope meta.KeyType) error + GCv2LoadBalancer(ing *v1.Ingress, scope meta.KeyType) error // PostProcess allows for doing some post-processing after an Ingress is synced to a GCLB. PostProcess(state interface{}) error // EnsureDeleteV1Finalizers ensures that v1 finalizers are removed for given list of ingresses. - EnsureDeleteV1Finalizers(toCleanup []*v1beta1.Ingress) error + EnsureDeleteV1Finalizers(toCleanup []*v1.Ingress) error // EnsureDeleteV2Finalizer ensures that v2 finalizer is removed for given ingress. - EnsureDeleteV2Finalizer(ing *v1beta1.Ingress) error + EnsureDeleteV2Finalizer(ing *v1.Ingress) error } diff --git a/pkg/sync/sync.go b/pkg/sync/sync.go index fc6400b6e5..513ce23370 100644 --- a/pkg/sync/sync.go +++ b/pkg/sync/sync.go @@ -21,7 +21,7 @@ import ( "fmt" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/common/operator" "k8s.io/ingress-gce/pkg/utils" "k8s.io/ingress-gce/pkg/utils/common" @@ -65,7 +65,7 @@ func (s *IngressSyncer) Sync(state interface{}) error { } // GC implements Syncer. -func (s *IngressSyncer) GC(ings []*v1beta1.Ingress, currIng *v1beta1.Ingress, frontendGCAlgorithm utils.FrontendGCAlgorithm, scope meta.KeyType) error { +func (s *IngressSyncer) GC(ings []*v1.Ingress, currIng *v1.Ingress, frontendGCAlgorithm utils.FrontendGCAlgorithm, scope meta.KeyType) error { var lbErr, err error var errs []error switch frontendGCAlgorithm { @@ -85,7 +85,7 @@ func (s *IngressSyncer) GC(ings []*v1beta1.Ingress, currIng *v1beta1.Ingress, fr case utils.CleanupV1FrontendResources: klog.V(3).Infof("Using algorithm CleanupV1FrontendResources to GC frontend of ingress %s", common.NamespacedName(currIng)) // Filter GCE ingresses that use v1 naming scheme. - v1Ingresses := operator.Ingresses(ings).Filter(func(ing *v1beta1.Ingress) bool { + v1Ingresses := operator.Ingresses(ings).Filter(func(ing *v1.Ingress) bool { return namer.FrontendNamingScheme(ing) == namer.V1NamingScheme }) // Partition these into ingresses those need cleanup and those don't. @@ -113,7 +113,7 @@ func (s *IngressSyncer) GC(ings []*v1beta1.Ingress, currIng *v1beta1.Ingress, fr // 1) It is a GCLB Ingress. // 2) It is not a deletion candidate. A deletion candidate is an ingress // with deletion stamp and a finalizer. - toKeep := operator.Ingresses(ings).Filter(func(ing *v1beta1.Ingress) bool { + toKeep := operator.Ingresses(ings).Filter(func(ing *v1.Ingress) bool { return !utils.NeedsCleanup(ing) }).AsList() if beErr := s.controller.GCBackends(toKeep); beErr != nil { diff --git a/pkg/test/frontendconfig.go b/pkg/test/frontendconfig.go index d1346d2b93..8db6df2784 100644 --- a/pkg/test/frontendconfig.go +++ b/pkg/test/frontendconfig.go @@ -1,7 +1,7 @@ package test import ( - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/annotations" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -18,14 +18,14 @@ var ( }, } - IngressWithoutFrontendConfig = &v1beta1.Ingress{ + IngressWithoutFrontendConfig = &v1.Ingress{ ObjectMeta: meta_v1.ObjectMeta{ Name: "ing-no-config", Namespace: "test", }, } - IngressWithFrontendConfig = &v1beta1.Ingress{ + IngressWithFrontendConfig = &v1.Ingress{ ObjectMeta: meta_v1.ObjectMeta{ Name: "ing-with-config", Namespace: "test", @@ -35,7 +35,7 @@ var ( }, } - IngressWithFrontendConfigOtherNamespace = &v1beta1.Ingress{ + IngressWithFrontendConfigOtherNamespace = &v1.Ingress{ ObjectMeta: meta_v1.ObjectMeta{ Name: "ing-with-config", Namespace: "other-namespace", @@ -45,7 +45,7 @@ var ( }, } - IngressWithOtherFrontendConfig = &v1beta1.Ingress{ + IngressWithOtherFrontendConfig = &v1.Ingress{ ObjectMeta: meta_v1.ObjectMeta{ Name: "ing-with-config", Namespace: "test", diff --git a/pkg/test/utils.go b/pkg/test/utils.go index 8a88c81324..932623d062 100644 --- a/pkg/test/utils.go +++ b/pkg/test/utils.go @@ -11,10 +11,9 @@ import ( dto "github.com/prometheus/client_model/go" "google.golang.org/api/compute/v1" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/tools/record" "k8s.io/ingress-gce/pkg/annotations" @@ -32,7 +31,7 @@ const ( ) var ( - BackendPort = intstr.IntOrString{Type: intstr.Int, IntVal: 80} + BackendPort = networkingv1.ServiceBackendPort{Number: 80} DefaultBeSvcPort = utils.ServicePort{ ID: utils.ServicePortID{Service: types.NamespacedName{Namespace: "system", Name: "default"}, Port: BackendPort}, NodePort: 30000, @@ -41,11 +40,11 @@ var ( ) // NewIngress returns an Ingress with the given spec. -func NewIngress(name types.NamespacedName, spec v1beta1.IngressSpec) *v1beta1.Ingress { - return &v1beta1.Ingress{ +func NewIngress(name types.NamespacedName, spec networkingv1.IngressSpec) *networkingv1.Ingress { + return &networkingv1.Ingress{ TypeMeta: meta_v1.TypeMeta{ Kind: "Ingress", - APIVersion: "networking/v1beta1", + APIVersion: "networking/v1", }, ObjectMeta: meta_v1.ObjectMeta{ Name: name.Name, @@ -104,22 +103,24 @@ func NewBackendConfig(name types.NamespacedName, spec backendconfig.BackendConfi } // Backend returns an IngressBackend with the given service name/port. -func Backend(name string, port intstr.IntOrString) *v1beta1.IngressBackend { - return &v1beta1.IngressBackend{ - ServiceName: name, - ServicePort: port, +func Backend(name string, port networkingv1.ServiceBackendPort) *networkingv1.IngressBackend { + return &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: name, + Port: port, + }, } } // DecodeIngress deserializes an Ingress object. -func DecodeIngress(data []byte) (*v1beta1.Ingress, error) { +func DecodeIngress(data []byte) (*networkingv1.Ingress, error) { decode := scheme.Codecs.UniversalDeserializer().Decode obj, _, err := decode(data, nil, nil) if err != nil { return nil, err } - return obj.(*v1beta1.Ingress), nil + return obj.(*networkingv1.Ingress), nil } // flag is a type representing controller flag. diff --git a/pkg/translator/translator.go b/pkg/translator/translator.go index a209874a7b..3b46c52bdd 100644 --- a/pkg/translator/translator.go +++ b/pkg/translator/translator.go @@ -25,7 +25,7 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" @@ -38,7 +38,7 @@ import ( // Env contains all k8s & GCP configuration needed to perform the translation. type Env struct { // Ing is the Ingress we are translating. - Ing *v1beta1.Ingress + Ing *v1.Ingress // TODO(shance): this should be a map, similar to SecretsMap // FrontendConfig is the frontendconfig associated with the Ingress FrontendConfig *frontendconfigv1beta1.FrontendConfig @@ -56,7 +56,7 @@ type Env struct { } // NewEnv returns an Env for the given Ingress. -func NewEnv(ing *v1beta1.Ingress, client kubernetes.Interface, vip, net, subnet string) (*Env, error) { +func NewEnv(ing *v1.Ingress, client kubernetes.Interface, vip, net, subnet string) (*Env, error) { ret := &Env{Ing: ing, SecretsMap: make(map[string]*api_v1.Secret), VIP: vip, Network: net, Subnetwork: subnet} for _, tlsSpec := range ing.Spec.TLS { if len(tlsSpec.SecretName) == 0 { diff --git a/pkg/translator/translator_test.go b/pkg/translator/translator_test.go index b0f1317bad..36bcc50894 100644 --- a/pkg/translator/translator_test.go +++ b/pkg/translator/translator_test.go @@ -22,7 +22,7 @@ import ( "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta" "github.com/google/go-cmp/cmp" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes/fake" frontendconfigv1beta1 "k8s.io/ingress-gce/pkg/apis/frontendconfig/v1beta1" @@ -263,16 +263,16 @@ func TestSecrets(t *testing.T) { cases := []struct { desc string - ing *v1beta1.Ingress + ing *v1.Ingress want []*api_v1.Secret wantErr bool }{ { desc: "ingress-single-secret", // TODO(rramkumar): Read Ingress spec from a file. - ing: &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - TLS: []v1beta1.IngressTLS{ + ing: &v1.Ingress{ + Spec: v1.IngressSpec{ + TLS: []v1.IngressTLS{ {SecretName: "first-secret"}, }, }, @@ -281,9 +281,9 @@ func TestSecrets(t *testing.T) { }, { desc: "ingress-multi-secret", - ing: &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - TLS: []v1beta1.IngressTLS{ + ing: &v1.Ingress{ + Spec: v1.IngressSpec{ + TLS: []v1.IngressTLS{ {SecretName: "first-secret"}, {SecretName: "second-secret"}, {SecretName: "third-secret"}, @@ -294,9 +294,9 @@ func TestSecrets(t *testing.T) { }, { desc: "mci-missing-secret", - ing: &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - TLS: []v1beta1.IngressTLS{ + ing: &v1.Ingress{ + Spec: v1.IngressSpec{ + TLS: []v1.IngressTLS{ {SecretName: "does-not-exist-secret"}, }, }, @@ -305,9 +305,9 @@ func TestSecrets(t *testing.T) { }, { desc: "mci-secret-empty-cert", - ing: &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - TLS: []v1beta1.IngressTLS{ + ing: &v1.Ingress{ + Spec: v1.IngressSpec{ + TLS: []v1.IngressTLS{ {SecretName: "secret-no-cert"}, }, }, @@ -316,9 +316,9 @@ func TestSecrets(t *testing.T) { }, { desc: "mci-secret-empty-priv-key", - ing: &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - TLS: []v1beta1.IngressTLS{ + ing: &v1.Ingress{ + Spec: v1.IngressSpec{ + TLS: []v1.IngressTLS{ {SecretName: "secret-no-key"}, }, }, @@ -328,9 +328,9 @@ func TestSecrets(t *testing.T) { { desc: "ingress-single-secret and missing secret", // TODO(rramkumar): Read Ingress spec from a file. - ing: &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - TLS: []v1beta1.IngressTLS{ + ing: &v1.Ingress{ + Spec: v1.IngressSpec{ + TLS: []v1.IngressTLS{ {SecretName: "first-secret"}, {SecretName: "does-not-exist-secret"}, }, diff --git a/pkg/utils/common/common.go b/pkg/utils/common/common.go index be8c281be7..a195c0a4ab 100644 --- a/pkg/utils/common/common.go +++ b/pkg/utils/common/common.go @@ -23,11 +23,11 @@ import ( "fmt" "strconv" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/strategicpatch" - client "k8s.io/client-go/kubernetes/typed/networking/v1beta1" + client "k8s.io/client-go/kubernetes/typed/networking/v1" "k8s.io/client-go/tools/cache" "k8s.io/klog" ) @@ -64,7 +64,7 @@ func ContentHash(s string, n int) string { // NamespacedName returns namespaced name string of a given ingress. // Note: This is used for logging. -func NamespacedName(ing *v1beta1.Ingress) string { +func NamespacedName(ing *v1.Ingress) string { if ing == nil { return "" } @@ -75,7 +75,7 @@ func NamespacedName(ing *v1beta1.Ingress) string { // This falls back to utility function in case of an error. // Note: Ingress Store and NamespacedName both return same key in general. But, Ingress Store // returns where as NamespacedName returns / when is empty. -func IngressKeyFunc(ing *v1beta1.Ingress) string { +func IngressKeyFunc(ing *v1.Ingress) string { ingKey, err := KeyFunc(ing) if err == nil { return ingKey @@ -88,7 +88,7 @@ func IngressKeyFunc(ing *v1beta1.Ingress) string { } // ToIngressKeys returns a list of ingress keys for given list of ingresses. -func ToIngressKeys(ings []*v1beta1.Ingress) []string { +func ToIngressKeys(ings []*v1.Ingress) []string { ingKeys := make([]string, 0, len(ings)) for _, ing := range ings { ingKeys = append(ingKeys, IngressKeyFunc(ing)) @@ -98,7 +98,7 @@ func ToIngressKeys(ings []*v1beta1.Ingress) []string { // PatchIngressObjectMetadata patches the given ingress's metadata based on new // ingress metadata. -func PatchIngressObjectMetadata(ic client.IngressInterface, ing *v1beta1.Ingress, newObjectMetadata metav1.ObjectMeta) (*v1beta1.Ingress, error) { +func PatchIngressObjectMetadata(ic client.IngressInterface, ing *v1.Ingress, newObjectMetadata metav1.ObjectMeta) (*v1.Ingress, error) { newIng := ing.DeepCopy() newIng.ObjectMeta = newObjectMetadata return patchIngress(ic, ing, newIng) @@ -106,7 +106,7 @@ func PatchIngressObjectMetadata(ic client.IngressInterface, ing *v1beta1.Ingress // PatchIngressStatus patches the given ingress's Status based on new ingress // status. -func PatchIngressStatus(ic client.IngressInterface, ing *v1beta1.Ingress, newStatus v1beta1.IngressStatus) (*v1beta1.Ingress, error) { +func PatchIngressStatus(ic client.IngressInterface, ing *v1.Ingress, newStatus v1.IngressStatus) (*v1.Ingress, error) { newIng := ing.DeepCopy() newIng.Status = newStatus return patchIngress(ic, ing, newIng) @@ -116,7 +116,7 @@ func PatchIngressStatus(ic client.IngressInterface, ing *v1beta1.Ingress, newSta // the old and new ingresses. // Note that both Status and ObjectMetadata (annotations and finalizers) // can be patched via `status` subresource API endpoint. -func patchIngress(ic client.IngressInterface, oldIngress, newIngress *v1beta1.Ingress) (*v1beta1.Ingress, error) { +func patchIngress(ic client.IngressInterface, oldIngress, newIngress *v1.Ingress) (*v1.Ingress, error) { ingKey := fmt.Sprintf("%s/%s", oldIngress.Namespace, oldIngress.Name) oldData, err := json.Marshal(oldIngress) if err != nil { @@ -128,7 +128,7 @@ func patchIngress(ic client.IngressInterface, oldIngress, newIngress *v1beta1.In return nil, fmt.Errorf("failed to Marshal newData for ingress %s: %v", ingKey, err) } - patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, v1beta1.Ingress{}) + patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, v1.Ingress{}) if err != nil { return nil, fmt.Errorf("failed to create TwoWayMergePatch for ingress %s: %v", ingKey, err) } diff --git a/pkg/utils/common/common_test.go b/pkg/utils/common/common_test.go index 398f488e67..1f86720399 100644 --- a/pkg/utils/common/common_test.go +++ b/pkg/utils/common/common_test.go @@ -21,9 +21,8 @@ import ( "github.com/google/go-cmp/cmp" apiv1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/client-go/kubernetes/fake" "k8s.io/kubernetes/pkg/util/slice" ) @@ -31,13 +30,13 @@ import ( func TestPatchIngressObjectMetadata(t *testing.T) { for _, tc := range []struct { desc string - ing *v1beta1.Ingress - newMetaFunc func(*v1beta1.Ingress) *v1beta1.Ingress + ing *v1.Ingress + newMetaFunc func(*v1.Ingress) *v1.Ingress }{ { desc: "add annotation", ing: newTestIngress("ns1", "add-annotation-ing"), - newMetaFunc: func(ing *v1beta1.Ingress) *v1beta1.Ingress { + newMetaFunc: func(ing *v1.Ingress) *v1.Ingress { ret := ing.DeepCopy() ret.Annotations["test-annotation-key3"] = "test-value3" return ret @@ -46,7 +45,7 @@ func TestPatchIngressObjectMetadata(t *testing.T) { { desc: "delete annotation", ing: newTestIngress("ns2", "delete-annotation-ing"), - newMetaFunc: func(ing *v1beta1.Ingress) *v1beta1.Ingress { + newMetaFunc: func(ing *v1.Ingress) *v1.Ingress { ret := ing.DeepCopy() delete(ret.Annotations, testAnnotationKey) return ret @@ -55,7 +54,7 @@ func TestPatchIngressObjectMetadata(t *testing.T) { { desc: "delete all annotations", ing: newTestIngress("ns3", "delete-all-annotations-ing"), - newMetaFunc: func(ing *v1beta1.Ingress) *v1beta1.Ingress { + newMetaFunc: func(ing *v1.Ingress) *v1.Ingress { ret := ing.DeepCopy() ret.Annotations = nil return ret @@ -64,7 +63,7 @@ func TestPatchIngressObjectMetadata(t *testing.T) { { desc: "add finalizer", ing: newTestIngress("ns4", "add-finalizer-ing"), - newMetaFunc: func(ing *v1beta1.Ingress) *v1beta1.Ingress { + newMetaFunc: func(ing *v1.Ingress) *v1.Ingress { ret := ing.DeepCopy() ret.Finalizers = append(ret.Finalizers, "new-test-ingress-finalizer") return ret @@ -73,7 +72,7 @@ func TestPatchIngressObjectMetadata(t *testing.T) { { desc: "delete finalizer", ing: newTestIngress("ns5", "delete-finalizer-ing"), - newMetaFunc: func(ing *v1beta1.Ingress) *v1beta1.Ingress { + newMetaFunc: func(ing *v1.Ingress) *v1.Ingress { ret := ing.DeepCopy() ret.Finalizers = slice.RemoveString(ret.Finalizers, testFinalizer, nil) return ret @@ -82,7 +81,7 @@ func TestPatchIngressObjectMetadata(t *testing.T) { { desc: "delete annotation and finalizer", ing: newTestIngress("ns6", "delete-annotation-and-finalizer-ing"), - newMetaFunc: func(ing *v1beta1.Ingress) *v1beta1.Ingress { + newMetaFunc: func(ing *v1.Ingress) *v1.Ingress { ret := ing.DeepCopy() ret.Annotations = nil ret.Finalizers = nil @@ -92,7 +91,7 @@ func TestPatchIngressObjectMetadata(t *testing.T) { } { t.Run(tc.desc, func(t *testing.T) { ingKey := fmt.Sprintf("%s/%s", tc.ing.Namespace, tc.ing.Name) - ingClient := fake.NewSimpleClientset().NetworkingV1beta1().Ingresses(tc.ing.Namespace) + ingClient := fake.NewSimpleClientset().NetworkingV1().Ingresses(tc.ing.Namespace) if _, err := ingClient.Create(context.TODO(), tc.ing, metav1.CreateOptions{}); err != nil { t.Fatalf("Create(%s) = %v, want nil", ingKey, err) } @@ -120,15 +119,15 @@ func TestPatchIngressObjectMetadata(t *testing.T) { func TestPatchIngressStatus(t *testing.T) { for _, tc := range []struct { desc string - ing *v1beta1.Ingress - newMetaFunc func(*v1beta1.Ingress) *v1beta1.Ingress + ing *v1.Ingress + newMetaFunc func(*v1.Ingress) *v1.Ingress }{ { desc: "update status", ing: newTestIngress("ns1", "update-status-ing"), - newMetaFunc: func(ing *v1beta1.Ingress) *v1beta1.Ingress { + newMetaFunc: func(ing *v1.Ingress) *v1.Ingress { ret := ing.DeepCopy() - ret.Status = v1beta1.IngressStatus{ + ret.Status = v1.IngressStatus{ LoadBalancer: apiv1.LoadBalancerStatus{ Ingress: []apiv1.LoadBalancerIngress{ {IP: "10.0.0.1"}, @@ -141,16 +140,16 @@ func TestPatchIngressStatus(t *testing.T) { { desc: "delete status", ing: newTestIngress("ns2", "delete-status-ing"), - newMetaFunc: func(ing *v1beta1.Ingress) *v1beta1.Ingress { + newMetaFunc: func(ing *v1.Ingress) *v1.Ingress { ret := ing.DeepCopy() - ret.Status = v1beta1.IngressStatus{} + ret.Status = v1.IngressStatus{} return ret }, }, } { t.Run(tc.desc, func(t *testing.T) { ingKey := fmt.Sprintf("%s/%s", tc.ing.Namespace, tc.ing.Name) - ingClient := fake.NewSimpleClientset().NetworkingV1beta1().Ingresses(tc.ing.Namespace) + ingClient := fake.NewSimpleClientset().NetworkingV1().Ingresses(tc.ing.Namespace) if _, err := ingClient.Create(context.TODO(), tc.ing, metav1.CreateOptions{}); err != nil { t.Fatalf("Create(%s) = %v, want nil", ingKey, err) } @@ -172,11 +171,11 @@ const ( testFinalizer = "test-finalizer" ) -func newTestIngress(namespace, name string) *v1beta1.Ingress { - return &v1beta1.Ingress{ +func newTestIngress(namespace, name string) *v1.Ingress { + return &v1.Ingress{ TypeMeta: metav1.TypeMeta{ Kind: "Ingress", - APIVersion: "networking/v1beta1", + APIVersion: "networking/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: name, @@ -187,13 +186,17 @@ func newTestIngress(namespace, name string) *v1beta1.Ingress { }, Finalizers: []string{testFinalizer}, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "test-svc", - ServicePort: intstr.FromInt(8080), + Spec: v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{ + Service: &v1.IngressServiceBackend{ + Name: "test-svc", + Port: v1.ServiceBackendPort{ + Number: 8080, + }, + }, }, }, - Status: v1beta1.IngressStatus{ + Status: v1.IngressStatus{ LoadBalancer: apiv1.LoadBalancerStatus{ Ingress: []apiv1.LoadBalancerIngress{ {IP: "127.0.0.1"}, diff --git a/pkg/utils/common/finalizer.go b/pkg/utils/common/finalizer.go index e2ac88136e..0cc509820b 100644 --- a/pkg/utils/common/finalizer.go +++ b/pkg/utils/common/finalizer.go @@ -17,10 +17,10 @@ import ( "fmt" corev1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" - client "k8s.io/client-go/kubernetes/typed/networking/v1beta1" + client "k8s.io/client-go/kubernetes/typed/networking/v1" "k8s.io/ingress-gce/pkg/utils/patch" "k8s.io/klog" "k8s.io/kubernetes/pkg/util/slice" @@ -62,7 +62,7 @@ func HasGivenFinalizer(m meta_v1.ObjectMeta, key string) bool { } // EnsureFinalizer ensures that the specified finalizer exists on given Ingress. -func EnsureFinalizer(ing *v1beta1.Ingress, ingClient client.IngressInterface, finalizerKey string) (*v1beta1.Ingress, error) { +func EnsureFinalizer(ing *v1.Ingress, ingClient client.IngressInterface, finalizerKey string) (*v1.Ingress, error) { updated := ing.DeepCopy() if needToAddFinalizer(ing.ObjectMeta, finalizerKey) { updated.ObjectMeta.Finalizers = append(updated.ObjectMeta.Finalizers, finalizerKey) @@ -80,7 +80,7 @@ func needToAddFinalizer(m meta_v1.ObjectMeta, key string) bool { } // EnsureDeleteFinalizer ensures that the specified finalizer is deleted from given Ingress. -func EnsureDeleteFinalizer(ing *v1beta1.Ingress, ingClient client.IngressInterface, finalizerKey string) error { +func EnsureDeleteFinalizer(ing *v1.Ingress, ingClient client.IngressInterface, finalizerKey string) error { if HasGivenFinalizer(ing.ObjectMeta, finalizerKey) { updatedObjectMeta := ing.ObjectMeta.DeepCopy() updatedObjectMeta.Finalizers = slice.RemoveString(updatedObjectMeta.Finalizers, finalizerKey, nil) diff --git a/pkg/utils/gceurlmap_test.go b/pkg/utils/gceurlmap_test.go index 8ee6d0205b..f48067c0b9 100644 --- a/pkg/utils/gceurlmap_test.go +++ b/pkg/utils/gceurlmap_test.go @@ -20,7 +20,7 @@ import ( "reflect" "testing" - "k8s.io/apimachinery/pkg/util/intstr" + v1 "k8s.io/api/networking/v1" ) func TestGCEURLMap(t *testing.T) { @@ -120,7 +120,7 @@ func TestGCEURLMapEquals(t *testing.T) { // Test different DefaultBackend. diffDefault := newTestMap() - b := NewServicePortWithID("svc-Y", "ns", intstr.FromInt(80)) + b := NewServicePortWithID("svc-Y", "ns", v1.ServiceBackendPort{Number: 80}) diffDefault.DefaultBackend = &b if EqualMapping(someMap, diffDefault) { t.Errorf("EqualMapping(%+v, %+v) = true, want false", someMap, diffDefault) @@ -148,7 +148,7 @@ func TestGCEURLMapEquals(t *testing.T) { t.Errorf("EqualMapping(%+v, %+v) = true, want false", someMap, diffPaths) } // Change a PathRule's backend. - diffPaths.HostRules[0].Paths[0] = PathRule{Path: "/ex1", Backend: NewServicePortWithID("svc-M", "ns", intstr.FromInt(80))} + diffPaths.HostRules[0].Paths[0] = PathRule{Path: "/ex1", Backend: NewServicePortWithID("svc-M", "ns", v1.ServiceBackendPort{Number: 80})} if EqualMapping(someMap, diffPaths) { t.Errorf("EqualMapping(%+v, %+v) = true, want false", someMap, diffPaths) } @@ -163,11 +163,11 @@ func TestAllServicePorts(t *testing.T) { t.Parallel() m := newTestMap() wantPorts := []ServicePort{ - NewServicePortWithID("svc-X", "ns", intstr.FromInt(80)), - NewServicePortWithID("svc-A", "ns", intstr.FromInt(80)), - NewServicePortWithID("svc-B", "ns", intstr.FromInt(80)), - NewServicePortWithID("svc-C", "ns", intstr.FromInt(80)), - NewServicePortWithID("svc-D", "ns", intstr.FromInt(80)), + NewServicePortWithID("svc-X", "ns", v1.ServiceBackendPort{Number: 80}), + NewServicePortWithID("svc-A", "ns", v1.ServiceBackendPort{Number: 80}), + NewServicePortWithID("svc-B", "ns", v1.ServiceBackendPort{Number: 80}), + NewServicePortWithID("svc-C", "ns", v1.ServiceBackendPort{Number: 80}), + NewServicePortWithID("svc-D", "ns", v1.ServiceBackendPort{Number: 80}), } gotPorts := m.AllServicePorts() @@ -180,16 +180,16 @@ func TestAllServicePorts(t *testing.T) { func newTestMap() *GCEURLMap { m := NewGCEURLMap() - b := NewServicePortWithID("svc-X", "ns", intstr.FromInt(80)) + b := NewServicePortWithID("svc-X", "ns", v1.ServiceBackendPort{Number: 80}) m.DefaultBackend = &b rules := []PathRule{ - PathRule{Path: "/ex1", Backend: NewServicePortWithID("svc-A", "ns", intstr.FromInt(80))}, - PathRule{Path: "/ex2", Backend: NewServicePortWithID("svc-B", "ns", intstr.FromInt(80))}, + PathRule{Path: "/ex1", Backend: NewServicePortWithID("svc-A", "ns", v1.ServiceBackendPort{Number: 80})}, + PathRule{Path: "/ex2", Backend: NewServicePortWithID("svc-B", "ns", v1.ServiceBackendPort{Number: 80})}, } m.PutPathRulesForHost("example.com", rules) rules = []PathRule{ - PathRule{Path: "/foo1", Backend: NewServicePortWithID("svc-C", "ns", intstr.FromInt(80))}, - PathRule{Path: "/foo2", Backend: NewServicePortWithID("svc-D", "ns", intstr.FromInt(80))}, + PathRule{Path: "/foo1", Backend: NewServicePortWithID("svc-C", "ns", v1.ServiceBackendPort{Number: 80})}, + PathRule{Path: "/foo2", Backend: NewServicePortWithID("svc-D", "ns", v1.ServiceBackendPort{Number: 80})}, } m.PutPathRulesForHost("foo.bar.com", rules) return m diff --git a/pkg/utils/namer/frontendnamer.go b/pkg/utils/namer/frontendnamer.go index ae8aed50c8..6d8fcf8a6b 100644 --- a/pkg/utils/namer/frontendnamer.go +++ b/pkg/utils/namer/frontendnamer.go @@ -17,7 +17,7 @@ import ( "fmt" "strings" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/ingress-gce/pkg/utils/common" "k8s.io/klog" @@ -59,13 +59,13 @@ type Scheme string // V1IngressFrontendNamer implements IngressFrontendNamer. This is a wrapper on top of namer.Namer. type V1IngressFrontendNamer struct { - ing *v1beta1.Ingress + ing *v1.Ingress namer *Namer lbName LoadBalancerName } // newV1IngressFrontendNamer returns v1 frontend namer for given ingress. -func newV1IngressFrontendNamer(ing *v1beta1.Ingress, namer *Namer) IngressFrontendNamer { +func newV1IngressFrontendNamer(ing *v1.Ingress, namer *Namer) IngressFrontendNamer { lbName := namer.LoadBalancer(common.IngressKeyFunc(ing)) return &V1IngressFrontendNamer{ing: ing, namer: namer, lbName: lbName} } @@ -123,7 +123,7 @@ func (ln *V1IngressFrontendNamer) IsValidLoadBalancer() bool { // V2IngressFrontendNamer implements IngressFrontendNamer. type V2IngressFrontendNamer struct { - ing *v1beta1.Ingress + ing *v1.Ingress // prefix for all resource names (ex.: "k8s"). prefix string // Load balancer name to be included in resource name. @@ -145,7 +145,7 @@ type V2IngressFrontendNamer struct { // Target HTTPS Proxy : k8s2-ts-uid01234-namespace-ingress-cysix1wq // URL Map : k8s2-um-uid01234-namespace-ingress-cysix1wq // SSL Certificate : k8s2-cr-uid01234-- -func newV2IngressFrontendNamer(ing *v1beta1.Ingress, kubeSystemUID string, prefix string) IngressFrontendNamer { +func newV2IngressFrontendNamer(ing *v1.Ingress, kubeSystemUID string, prefix string) IngressFrontendNamer { clusterUID := common.ContentHash(kubeSystemUID, clusterUIDLength) namer := &V2IngressFrontendNamer{ing: ing, prefix: prefix, clusterUID: clusterUID} // Initialize lbName. @@ -248,7 +248,7 @@ func NewFrontendNamerFactory(namer *Namer, kubeSystemUID types.UID) IngressFront } // Namer implements IngressFrontendNamerFactory. -func (rn *FrontendNamerFactory) Namer(ing *v1beta1.Ingress) IngressFrontendNamer { +func (rn *FrontendNamerFactory) Namer(ing *v1.Ingress) IngressFrontendNamer { namingScheme := FrontendNamingScheme(ing) switch namingScheme { case V1NamingScheme: diff --git a/pkg/utils/namer/frontendnamer_test.go b/pkg/utils/namer/frontendnamer_test.go index 3ee77e9447..f9c3cec247 100644 --- a/pkg/utils/namer/frontendnamer_test.go +++ b/pkg/utils/namer/frontendnamer_test.go @@ -22,7 +22,7 @@ import ( "testing" "github.com/google/go-cmp/cmp" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) @@ -31,8 +31,8 @@ const ( kubeSystemUID = "kubesystem-uid1" ) -func newIngress(namespace, name string) *v1beta1.Ingress { - return &v1beta1.Ingress{ +func newIngress(namespace, name string) *v1.Ingress { + return &v1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, diff --git a/pkg/utils/namer/interfaces.go b/pkg/utils/namer/interfaces.go index d56ebbe8fb..ca3df91810 100644 --- a/pkg/utils/namer/interfaces.go +++ b/pkg/utils/namer/interfaces.go @@ -13,9 +13,7 @@ limitations under the License. package namer -import ( - "k8s.io/api/networking/v1beta1" -) +import v1 "k8s.io/api/networking/v1" // IngressFrontendNamer is an interface to name GCE frontend resources. type IngressFrontendNamer interface { @@ -45,7 +43,7 @@ type IngressFrontendNamer interface { // a load balancer. type IngressFrontendNamerFactory interface { // Namer returns IngressFrontendNamer for given ingress. - Namer(ing *v1beta1.Ingress) IngressFrontendNamer + Namer(ing *v1.Ingress) IngressFrontendNamer // NamerForLoadBalancer returns IngressFrontendNamer given a load-balancer // name. This used only for v1 naming scheme. NamerForLoadBalancer(loadBalancer LoadBalancerName) IngressFrontendNamer diff --git a/pkg/utils/namer/utils.go b/pkg/utils/namer/utils.go index a504cf3def..cc51fffd2f 100644 --- a/pkg/utils/namer/utils.go +++ b/pkg/utils/namer/utils.go @@ -17,7 +17,7 @@ import ( "fmt" "regexp" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/ingress-gce/pkg/utils/common" "k8s.io/klog" ) @@ -62,7 +62,7 @@ func TrimFieldsEvenly(max int, fields ...string) []string { } // FrontendNamingScheme returns naming scheme for given ingress based on its finalizer. -func FrontendNamingScheme(ing *v1beta1.Ingress) Scheme { +func FrontendNamingScheme(ing *v1.Ingress) Scheme { switch { case common.HasGivenFinalizer(ing.ObjectMeta, common.FinalizerKeyV2): return V2NamingScheme diff --git a/pkg/utils/patch/patch_test.go b/pkg/utils/patch/patch_test.go index 500f821652..454a65e5b2 100644 --- a/pkg/utils/patch/patch_test.go +++ b/pkg/utils/patch/patch_test.go @@ -21,7 +21,7 @@ import ( "github.com/google/go-cmp/cmp" apiv1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes/fake" "k8s.io/kubernetes/pkg/util/slice" @@ -29,13 +29,13 @@ import ( func TestStrategicMergePatchBytes(t *testing.T) { // Patch an Ingress w/ a finalizer - ing := &v1beta1.Ingress{} - updated := &v1beta1.Ingress{ + ing := &v1.Ingress{} + updated := &v1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Finalizers: []string{"foo"}, }, } - b, err := StrategicMergePatchBytes(ing, updated, v1beta1.Ingress{}) + b, err := StrategicMergePatchBytes(ing, updated, v1.Ingress{}) if err != nil { t.Fatal(err) } @@ -46,8 +46,8 @@ func TestStrategicMergePatchBytes(t *testing.T) { // Patch an Ingress with the finalizer removed ing = updated - updated = &v1beta1.Ingress{} - b, err = StrategicMergePatchBytes(ing, updated, v1beta1.Ingress{}) + updated = &v1.Ingress{} + b, err = StrategicMergePatchBytes(ing, updated, v1.Ingress{}) if err != nil { t.Fatal(err) } @@ -59,8 +59,8 @@ func TestStrategicMergePatchBytes(t *testing.T) { func TestJSONMergePatchBytes(t *testing.T) { // Patch an Ingress w/ a finalizer - ing := &v1beta1.Ingress{} - updated := &v1beta1.Ingress{ + ing := &v1.Ingress{} + updated := &v1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Finalizers: []string{"foo"}, }, @@ -76,7 +76,7 @@ func TestJSONMergePatchBytes(t *testing.T) { // Patch an Ingress with an additional finalizer ing = updated - updated = &v1beta1.Ingress{ + updated = &v1.Ingress{ ObjectMeta: metav1.ObjectMeta{ Finalizers: []string{"foo", "bar"}, }, @@ -91,7 +91,7 @@ func TestJSONMergePatchBytes(t *testing.T) { } // Patch an Ingress with the finalizer removed ing = updated - updated = &v1beta1.Ingress{} + updated = &v1.Ingress{} b, err = MergePatchBytes(ing, updated) if err != nil { t.Fatal(err) diff --git a/pkg/utils/serviceport.go b/pkg/utils/serviceport.go index 1888ea37ac..a2268e171c 100644 --- a/pkg/utils/serviceport.go +++ b/pkg/utils/serviceport.go @@ -19,9 +19,8 @@ package utils import ( "fmt" - "k8s.io/api/networking/v1beta1" + v1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/ingress-gce/pkg/annotations" backendconfigv1 "k8s.io/ingress-gce/pkg/apis/backendconfig/v1" "k8s.io/ingress-gce/pkg/utils/namer" @@ -30,7 +29,7 @@ import ( // ServicePortID contains the Service and Port fields. type ServicePortID struct { Service types.NamespacedName - Port intstr.IntOrString + Port v1.ServiceBackendPort } func (id ServicePortID) String() string { @@ -79,18 +78,18 @@ func (sp ServicePort) IGName() string { } // BackendToServicePortID creates a ServicePortID from a given IngressBackend and namespace. -func BackendToServicePortID(be v1beta1.IngressBackend, namespace string) ServicePortID { +func BackendToServicePortID(be v1.IngressBackend, namespace string) ServicePortID { return ServicePortID{ Service: types.NamespacedName{ - Name: be.ServiceName, + Name: be.Service.Name, Namespace: namespace, }, - Port: be.ServicePort, + Port: be.Service.Port, } } // NewServicePortWithID returns a ServicePort with only ID. -func NewServicePortWithID(svcName, svcNamespace string, port intstr.IntOrString) ServicePort { +func NewServicePortWithID(svcName, svcNamespace string, port v1.ServiceBackendPort) ServicePort { return ServicePort{ ID: ServicePortID{ Service: types.NamespacedName{ diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go index 61edbdb217..150fab2a39 100644 --- a/pkg/utils/utils.go +++ b/pkg/utils/utils.go @@ -31,7 +31,7 @@ import ( "google.golang.org/api/compute/v1" "google.golang.org/api/googleapi" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" @@ -278,7 +278,7 @@ func IGLinks(igs []*compute.InstanceGroup) (igLinks []string) { // IsGCEIngress returns true if the Ingress matches the class managed by this // controller. -func IsGCEIngress(ing *v1beta1.Ingress) bool { +func IsGCEIngress(ing *networkingv1.Ingress) bool { class := annotations.FromIngress(ing).IngressClass() if flags.F.IngressClass != "" && class == flags.F.IngressClass { return true @@ -301,20 +301,20 @@ func IsGCEIngress(ing *v1beta1.Ingress) bool { // IsGCEMultiClusterIngress returns true if the given Ingress has // ingress.class annotation set to "gce-multi-cluster". -func IsGCEMultiClusterIngress(ing *v1beta1.Ingress) bool { +func IsGCEMultiClusterIngress(ing *networkingv1.Ingress) bool { class := annotations.FromIngress(ing).IngressClass() return class == annotations.GceMultiIngressClass } // IsGCEL7ILBIngress returns true if the given Ingress has // ingress.class annotation set to "gce-l7-ilb" -func IsGCEL7ILBIngress(ing *v1beta1.Ingress) bool { +func IsGCEL7ILBIngress(ing *networkingv1.Ingress) bool { class := annotations.FromIngress(ing).IngressClass() return class == annotations.GceL7ILBIngressClass } // IsGLBCIngress returns true if the given Ingress should be processed by GLBC -func IsGLBCIngress(ing *v1beta1.Ingress) bool { +func IsGLBCIngress(ing *networkingv1.Ingress) bool { return IsGCEIngress(ing) || IsGCEMultiClusterIngress(ing) } @@ -438,13 +438,13 @@ func JoinErrs(errs []error) error { // TraverseIngressBackends traverse thru all backends specified in the input ingress and call process // If process return true, then return and stop traversing the backends -func TraverseIngressBackends(ing *v1beta1.Ingress, process func(id ServicePortID) bool) { +func TraverseIngressBackends(ing *networkingv1.Ingress, process func(id ServicePortID) bool) { if ing == nil { return } // Check service of default backend - if ing.Spec.Backend != nil { - if process(ServicePortID{Service: types.NamespacedName{Namespace: ing.Namespace, Name: ing.Spec.Backend.ServiceName}, Port: ing.Spec.Backend.ServicePort}) { + if ing.Spec.DefaultBackend != nil { + if process(ServicePortID{Service: types.NamespacedName{Namespace: ing.Namespace, Name: ing.Spec.DefaultBackend.Service.Name}, Port: ing.Spec.DefaultBackend.Service.Port}) { return } } @@ -455,7 +455,7 @@ func TraverseIngressBackends(ing *v1beta1.Ingress, process func(id ServicePortID continue } for _, p := range rule.IngressRuleValue.HTTP.Paths { - if process(ServicePortID{Service: types.NamespacedName{Namespace: ing.Namespace, Name: p.Backend.ServiceName}, Port: p.Backend.ServicePort}) { + if process(ServicePortID{Service: types.NamespacedName{Namespace: ing.Namespace, Name: p.Backend.Service.Name}, Port: p.Backend.Service.Port}) { return } } @@ -468,12 +468,12 @@ func ServiceKeyFunc(namespace, name string) string { } // NeedsCleanup returns true if the ingress needs to have its associated resources deleted. -func NeedsCleanup(ing *v1beta1.Ingress) bool { +func NeedsCleanup(ing *networkingv1.Ingress) bool { return common.IsDeletionCandidate(ing.ObjectMeta) || !IsGLBCIngress(ing) } // HasVIP returns true if given ingress has a vip. -func HasVIP(ing *v1beta1.Ingress) bool { +func HasVIP(ing *networkingv1.Ingress) bool { if ing == nil { return false } diff --git a/pkg/utils/utils_test.go b/pkg/utils/utils_test.go index 47db78373c..51ba68808a 100644 --- a/pkg/utils/utils_test.go +++ b/pkg/utils/utils_test.go @@ -30,9 +30,8 @@ import ( "k8s.io/ingress-gce/pkg/utils/common" api_v1 "k8s.io/api/core/v1" - "k8s.io/api/networking/v1beta1" + networkingv1 "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" - "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/legacy-cloud-providers/gce" ) @@ -221,47 +220,59 @@ func TestTraverseIngressBackends(t *testing.T) { t.Parallel() testCases := []struct { desc string - ing *v1beta1.Ingress - expectBackends []v1beta1.IngressBackend + ing *networkingv1.Ingress + expectBackends []networkingv1.IngressBackend }{ { "empty spec", - &v1beta1.Ingress{}, - []v1beta1.IngressBackend{}, + &networkingv1.Ingress{}, + []networkingv1.IngressBackend{}, }, { "one default backend", - &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + &networkingv1.Ingress{ + Spec: networkingv1.IngressSpec{ + DefaultBackend: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "dummy-service", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, }, - Rules: []v1beta1.IngressRule{}, + Rules: []networkingv1.IngressRule{}, }, }, - []v1beta1.IngressBackend{ + []networkingv1.IngressBackend{ { - ServiceName: "dummy-service", - ServicePort: intstr.FromInt(80), + Service: &networkingv1.IngressServiceBackend{ + Name: "dummy-service", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, { "one backend in path", - &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + &networkingv1.Ingress{ + Spec: networkingv1.IngressSpec{ + Rules: []networkingv1.IngressRule{ { Host: "foo.bar", - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{ + Paths: []networkingv1.HTTPIngressPath{ { Path: "/foo", - Backend: v1beta1.IngressBackend{ - ServiceName: "foo-service", - ServicePort: intstr.FromInt(80), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "foo-service", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, @@ -271,52 +282,68 @@ func TestTraverseIngressBackends(t *testing.T) { }, }, }, - []v1beta1.IngressBackend{ + []networkingv1.IngressBackend{ { - ServiceName: "foo-service", - ServicePort: intstr.FromInt(80), + Service: &networkingv1.IngressServiceBackend{ + Name: "foo-service", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, }, { "one rule with only host", - &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - Rules: []v1beta1.IngressRule{ + &networkingv1.Ingress{ + Spec: networkingv1.IngressSpec{ + Rules: []networkingv1.IngressRule{ { Host: "foo.bar", }, }, }, }, - []v1beta1.IngressBackend{}, + []networkingv1.IngressBackend{}, }, { "complex ingress spec", - &v1beta1.Ingress{ - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "backend-service", - ServicePort: intstr.FromInt(81), + &networkingv1.Ingress{ + Spec: networkingv1.IngressSpec{ + DefaultBackend: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "backend-service", + Port: networkingv1.ServiceBackendPort{ + Number: 81, + }, + }, }, - Rules: []v1beta1.IngressRule{ + Rules: []networkingv1.IngressRule{ { Host: "foo.bar", - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{ + Paths: []networkingv1.HTTPIngressPath{ { Path: "/foo", - Backend: v1beta1.IngressBackend{ - ServiceName: "foo-service", - ServicePort: intstr.FromInt(82), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "foo-service", + Port: networkingv1.ServiceBackendPort{ + Number: 82, + }, + }, }, }, { Path: "/bar", - Backend: v1beta1.IngressBackend{ - ServiceName: "bar-service", - ServicePort: intstr.FromInt(83), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "bar-service", + Port: networkingv1.ServiceBackendPort{ + Number: 83, + }, + }, }, }, }, @@ -324,21 +351,29 @@ func TestTraverseIngressBackends(t *testing.T) { }, }, { - IngressRuleValue: v1beta1.IngressRuleValue{ - HTTP: &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{ + Paths: []networkingv1.HTTPIngressPath{ { Path: "/a", - Backend: v1beta1.IngressBackend{ - ServiceName: "a-service", - ServicePort: intstr.FromInt(84), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "a-service", + Port: networkingv1.ServiceBackendPort{ + Number: 84, + }, + }, }, }, { Path: "/b", - Backend: v1beta1.IngressBackend{ - ServiceName: "b-service", - ServicePort: intstr.FromInt(85), + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "b-service", + Port: networkingv1.ServiceBackendPort{ + Number: 85, + }, + }, }, }, }, @@ -354,26 +389,46 @@ func TestTraverseIngressBackends(t *testing.T) { }, }, }, - []v1beta1.IngressBackend{ + []networkingv1.IngressBackend{ { - ServiceName: "backend-service", - ServicePort: intstr.FromInt(81), + Service: &networkingv1.IngressServiceBackend{ + Name: "backend-service", + Port: networkingv1.ServiceBackendPort{ + Number: 81, + }, + }, }, { - ServiceName: "foo-service", - ServicePort: intstr.FromInt(82), + Service: &networkingv1.IngressServiceBackend{ + Name: "foo-service", + Port: networkingv1.ServiceBackendPort{ + Number: 82, + }, + }, }, { - ServiceName: "bar-service", - ServicePort: intstr.FromInt(83), + Service: &networkingv1.IngressServiceBackend{ + Name: "bar-service", + Port: networkingv1.ServiceBackendPort{ + Number: 83, + }, + }, }, { - ServiceName: "a-service", - ServicePort: intstr.FromInt(84), + Service: &networkingv1.IngressServiceBackend{ + Name: "a-service", + Port: networkingv1.ServiceBackendPort{ + Number: 84, + }, + }, }, { - ServiceName: "b-service", - ServicePort: intstr.FromInt(85), + Service: &networkingv1.IngressServiceBackend{ + Name: "b-service", + Port: networkingv1.ServiceBackendPort{ + Number: 85, + }, + }, }, }, }, @@ -382,8 +437,8 @@ func TestTraverseIngressBackends(t *testing.T) { for _, tc := range testCases { counter := 0 TraverseIngressBackends(tc.ing, func(id ServicePortID) bool { - if tc.expectBackends[counter].ServiceName != id.Service.Name || tc.expectBackends[counter].ServicePort != id.Port { - t.Errorf("Test case %q, for backend %v, expecting service name %q and service port %q, but got %q, %q", tc.desc, counter, tc.expectBackends[counter].ServiceName, tc.expectBackends[counter].ServicePort.String(), id.Service.Name, id.Port.String()) + if tc.expectBackends[counter].Service.Name != id.Service.Name || tc.expectBackends[counter].Service.Port != id.Port { + t.Errorf("Test case %q, for backend %v, expecting service name %q and service port %+v, but got %q, %q", tc.desc, counter, tc.expectBackends[counter].Service.Name, tc.expectBackends[counter].Service.Port, id.Service.Name, id.Port.String()) } counter += 1 return false @@ -460,13 +515,13 @@ func TestIsGCEIngress(t *testing.T) { var wrongClassName = "wrong-class" testCases := []struct { desc string - ingress *v1beta1.Ingress + ingress *networkingv1.Ingress ingressClassFlag string expected bool }{ { desc: "No ingress class", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{}, }, @@ -475,7 +530,7 @@ func TestIsGCEIngress(t *testing.T) { }, { desc: "unknown ingress class", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{ annotations.IngressClassKey: "foo"}, @@ -485,7 +540,7 @@ func TestIsGCEIngress(t *testing.T) { }, { desc: "L7 ILB ingress class", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{ annotations.IngressClassKey: annotations.GceL7ILBIngressClass}, @@ -495,7 +550,7 @@ func TestIsGCEIngress(t *testing.T) { }, { desc: "Set by flag with non-matching class", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{ annotations.IngressClassKey: wrongClassName}, @@ -506,7 +561,7 @@ func TestIsGCEIngress(t *testing.T) { }, { desc: "Set by flag with matching class", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{ annotations.IngressClassKey: "right-class"}, @@ -517,11 +572,11 @@ func TestIsGCEIngress(t *testing.T) { }, { desc: "No ingress class annotation, ingressClassName set", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{}, }, - Spec: v1beta1.IngressSpec{ + Spec: networkingv1.IngressSpec{ IngressClassName: &wrongClassName, }, }, @@ -530,12 +585,12 @@ func TestIsGCEIngress(t *testing.T) { { // Annotation supercedes spec.ingressClassName desc: "Set by flag with matching class, and ingressClassName set", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{ annotations.IngressClassKey: "right-class"}, }, - Spec: v1beta1.IngressSpec{ + Spec: networkingv1.IngressSpec{ IngressClassName: &wrongClassName, }, }, @@ -562,12 +617,12 @@ func TestIsGCEL7ILBIngress(t *testing.T) { t.Parallel() testCases := []struct { desc string - ingress *v1beta1.Ingress + ingress *networkingv1.Ingress expected bool }{ { desc: "No ingress class", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{}, }, @@ -576,12 +631,12 @@ func TestIsGCEL7ILBIngress(t *testing.T) { }, { desc: "Empty Annotations", - ingress: &v1beta1.Ingress{}, + ingress: &networkingv1.Ingress{}, expected: false, }, { desc: "L7 ILB ingress class", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{ annotations.IngressClassKey: annotations.GceL7ILBIngressClass}, @@ -591,7 +646,7 @@ func TestIsGCEL7ILBIngress(t *testing.T) { }, { desc: "foo ingress class", - ingress: &v1beta1.Ingress{ + ingress: &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Annotations: map[string]string{ annotations.IngressClassKey: "foo-class"}, @@ -634,7 +689,7 @@ func TestNeedsCleanup(t *testing.T) { if !tc.isGLBCIngress { ingressClass = "nginx" } - ingress := &v1beta1.Ingress{ + ingress := &networkingv1.Ingress{ ObjectMeta: v1.ObjectMeta{ Name: "ing", Namespace: "default", @@ -642,10 +697,14 @@ func TestNeedsCleanup(t *testing.T) { "kubernetes.io/ingress.class": ingressClass, }, }, - Spec: v1beta1.IngressSpec{ - Backend: &v1beta1.IngressBackend{ - ServiceName: "my-service", - ServicePort: intstr.FromInt(80), + Spec: networkingv1.IngressSpec{ + DefaultBackend: &networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "my-service", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, }, }, } @@ -669,24 +728,24 @@ func TestNeedsCleanup(t *testing.T) { func TestHasVIP(t *testing.T) { for _, tc := range []struct { desc string - ing *v1beta1.Ingress + ing *networkingv1.Ingress expectHasVIP bool }{ {"nil", nil, false}, - {"empty ingress status", &v1beta1.Ingress{ - Status: v1beta1.IngressStatus{}, + {"empty ingress status", &networkingv1.Ingress{ + Status: networkingv1.IngressStatus{}, }, false, }, - {"empty load-balancer status", &v1beta1.Ingress{ - Status: v1beta1.IngressStatus{ + {"empty load-balancer status", &networkingv1.Ingress{ + Status: networkingv1.IngressStatus{ LoadBalancer: api_v1.LoadBalancerStatus{}, }, }, false, }, - {"empty load-balancer ingress", &v1beta1.Ingress{ - Status: v1beta1.IngressStatus{ + {"empty load-balancer ingress", &networkingv1.Ingress{ + Status: networkingv1.IngressStatus{ LoadBalancer: api_v1.LoadBalancerStatus{ Ingress: []api_v1.LoadBalancerIngress{}, }, @@ -694,8 +753,8 @@ func TestHasVIP(t *testing.T) { }, false, }, - {"empty IP", &v1beta1.Ingress{ - Status: v1beta1.IngressStatus{ + {"empty IP", &networkingv1.Ingress{ + Status: networkingv1.IngressStatus{ LoadBalancer: api_v1.LoadBalancerStatus{ Ingress: []api_v1.LoadBalancerIngress{ {IP: ""}, @@ -705,8 +764,8 @@ func TestHasVIP(t *testing.T) { }, false, }, - {"valid IP", &v1beta1.Ingress{ - Status: v1beta1.IngressStatus{ + {"valid IP", &networkingv1.Ingress{ + Status: networkingv1.IngressStatus{ LoadBalancer: api_v1.LoadBalancerStatus{ Ingress: []api_v1.LoadBalancerIngress{ {IP: "0.0.0.0"}, @@ -716,8 +775,8 @@ func TestHasVIP(t *testing.T) { }, true, }, - {"random", &v1beta1.Ingress{ - Status: v1beta1.IngressStatus{ + {"random", &networkingv1.Ingress{ + Status: networkingv1.IngressStatus{ LoadBalancer: api_v1.LoadBalancerStatus{ Ingress: []api_v1.LoadBalancerIngress{ {IP: "xxxxxx"}, From fd1d362cb08afbb1839cc8f7dd4011fbb344360c Mon Sep 17 00:00:00 2001 From: Swetha Repakula Date: Tue, 27 Apr 2021 11:04:24 -0700 Subject: [PATCH 4/4] Handle non-service backends - skip processing backend when service is nil - return error when a non-service backend is specified on a GCE Ingress --- .../ingress-null-service-backend.json | 34 +++++++ .../ingress-null-service-backend.yaml | 18 ++++ pkg/controller/translator/translator.go | 15 ++- pkg/controller/translator/translator_test.go | 15 +++ pkg/utils/serviceport.go | 7 +- pkg/utils/utils.go | 8 +- pkg/utils/utils_test.go | 95 +++++++++++++++++++ 7 files changed, 185 insertions(+), 7 deletions(-) create mode 100644 pkg/controller/translator/testdata/ingress-null-service-backend.json create mode 100644 pkg/controller/translator/testdata/ingress-null-service-backend.yaml diff --git a/pkg/controller/translator/testdata/ingress-null-service-backend.json b/pkg/controller/translator/testdata/ingress-null-service-backend.json new file mode 100644 index 0000000000..ab30ba7c60 --- /dev/null +++ b/pkg/controller/translator/testdata/ingress-null-service-backend.json @@ -0,0 +1,34 @@ +{ + "DefaultBackend": { + "ID": { + "Service": { + "Namespace": "kube-system", + "Name": "default-http-backend" + }, + "Port": { + "Name": "http" + } + } + }, + "HostRules": [ + { + "HostName": "foo.bar.com", + "Paths": [ + { + "Path": "/testpath", + "Backend": { + "ID": { + "Service": { + "Namespace": "default", + "Name": "first-service" + }, + "Port": { + "Number": 80 + } + } + } + } + ] + } + ] +} diff --git a/pkg/controller/translator/testdata/ingress-null-service-backend.yaml b/pkg/controller/translator/testdata/ingress-null-service-backend.yaml new file mode 100644 index 0000000000..e1fbf14317 --- /dev/null +++ b/pkg/controller/translator/testdata/ingress-null-service-backend.yaml @@ -0,0 +1,18 @@ +apiVersion: networking.k8s.io/v1 +kind: Ingress +metadata: + name: test-ingress + namespace: default +spec: + rules: + - host: foo.bar.com + http: + paths: + - path: /empty + backend: + - path: /testpath + backend: + service: + name: first-service + port: + number: 80 diff --git a/pkg/controller/translator/translator.go b/pkg/controller/translator/translator.go index 7a47f12a70..847b835948 100644 --- a/pkg/controller/translator/translator.go +++ b/pkg/controller/translator/translator.go @@ -207,7 +207,13 @@ func (t *Translator) TranslateIngress(ing *v1.Ingress, systemDefaultBackend util pathRules := []utils.PathRule{} for _, p := range rule.HTTP.Paths { - svcPort, err := t.getServicePort(utils.BackendToServicePortID(p.Backend, ing.Namespace), params, namer) + svcPortID, err := utils.BackendToServicePortID(p.Backend, ing.Namespace) + if err != nil { + // Only error possible is Backend is not a Service Backend, so move to next path + errs = append(errs, err) + continue + } + svcPort, err := t.getServicePort(svcPortID, params, namer) if err != nil { errs = append(errs, err) } @@ -238,7 +244,12 @@ func (t *Translator) TranslateIngress(ing *v1.Ingress, systemDefaultBackend util } if ing.Spec.DefaultBackend != nil { - svcPort, err := t.getServicePort(utils.BackendToServicePortID(*ing.Spec.DefaultBackend, ing.Namespace), params, namer) + svcPortID, err := utils.BackendToServicePortID(*ing.Spec.DefaultBackend, ing.Namespace) + if err != nil { + errs = append(errs, err) + return urlMap, errs + } + svcPort, err := t.getServicePort(svcPortID, params, namer) if err == nil { urlMap.DefaultBackend = svcPort return urlMap, errs diff --git a/pkg/controller/translator/translator_test.go b/pkg/controller/translator/translator_test.go index 69c50679f3..94d39ccaf8 100644 --- a/pkg/controller/translator/translator_test.go +++ b/pkg/controller/translator/translator_test.go @@ -170,6 +170,21 @@ func TestTranslateIngress(t *testing.T) { wantErrCount: 1, wantGCEURLMap: utils.NewGCEURLMap(), }, + { + desc: "null service default backend", + ing: test.NewIngress(types.NamespacedName{Name: "my-ingress", Namespace: "default"}, + v1.IngressSpec{ + DefaultBackend: &v1.IngressBackend{}, + }), + wantErrCount: 1, + wantGCEURLMap: utils.NewGCEURLMap(), + }, + { + desc: "null service backend", + ing: ingressFromFile(t, "ingress-null-service-backend.yaml"), + wantErrCount: 1, + wantGCEURLMap: gceURLMapFromFile(t, "ingress-null-service-backend.json"), + }, } for _, tc := range cases { diff --git a/pkg/utils/serviceport.go b/pkg/utils/serviceport.go index a2268e171c..6c54b95ab0 100644 --- a/pkg/utils/serviceport.go +++ b/pkg/utils/serviceport.go @@ -78,14 +78,17 @@ func (sp ServicePort) IGName() string { } // BackendToServicePortID creates a ServicePortID from a given IngressBackend and namespace. -func BackendToServicePortID(be v1.IngressBackend, namespace string) ServicePortID { +func BackendToServicePortID(be v1.IngressBackend, namespace string) (ServicePortID, error) { + if be.Service == nil { + return ServicePortID{}, fmt.Errorf("Ingress Backend is not a service") + } return ServicePortID{ Service: types.NamespacedName{ Name: be.Service.Name, Namespace: namespace, }, Port: be.Service.Port, - } + }, nil } // NewServicePortWithID returns a ServicePort with only ID. diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go index 150fab2a39..1b19a3315c 100644 --- a/pkg/utils/utils.go +++ b/pkg/utils/utils.go @@ -443,7 +443,7 @@ func TraverseIngressBackends(ing *networkingv1.Ingress, process func(id ServiceP return } // Check service of default backend - if ing.Spec.DefaultBackend != nil { + if ing.Spec.DefaultBackend != nil && ing.Spec.DefaultBackend.Service != nil { if process(ServicePortID{Service: types.NamespacedName{Namespace: ing.Namespace, Name: ing.Spec.DefaultBackend.Service.Name}, Port: ing.Spec.DefaultBackend.Service.Port}) { return } @@ -455,8 +455,10 @@ func TraverseIngressBackends(ing *networkingv1.Ingress, process func(id ServiceP continue } for _, p := range rule.IngressRuleValue.HTTP.Paths { - if process(ServicePortID{Service: types.NamespacedName{Namespace: ing.Namespace, Name: p.Backend.Service.Name}, Port: p.Backend.Service.Port}) { - return + if p.Backend.Service != nil { + if process(ServicePortID{Service: types.NamespacedName{Namespace: ing.Namespace, Name: p.Backend.Service.Name}, Port: p.Backend.Service.Port}) { + return + } } } } diff --git a/pkg/utils/utils_test.go b/pkg/utils/utils_test.go index 51ba68808a..20fccc027a 100644 --- a/pkg/utils/utils_test.go +++ b/pkg/utils/utils_test.go @@ -19,6 +19,7 @@ package utils import ( "errors" "fmt" + "reflect" "testing" "time" @@ -432,6 +433,49 @@ func TestTraverseIngressBackends(t *testing.T) { }, }, }, + { + "non service backend", + &networkingv1.Ingress{ + Spec: networkingv1.IngressSpec{ + Rules: []networkingv1.IngressRule{ + { + Host: "foo.bar", + IngressRuleValue: networkingv1.IngressRuleValue{ + HTTP: &networkingv1.HTTPIngressRuleValue{ + Paths: []networkingv1.HTTPIngressPath{ + { + Path: "/foo", + Backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "foo-service", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, + }, + }, + { + Path: "/non-service", + Backend: networkingv1.IngressBackend{}, + }, + }, + }, + }, + }, + }, + }, + }, + []networkingv1.IngressBackend{ + { + Service: &networkingv1.IngressServiceBackend{ + Name: "foo-service", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, + }, + }, + }, } for _, tc := range testCases { @@ -900,3 +944,54 @@ func TestIsHTTPErrorCode(t *testing.T) { } } } + +func TestBackendToServicePortID(t *testing.T) { + testNS := "test-namespace" + for _, tc := range []struct { + desc string + backend networkingv1.IngressBackend + expectErr bool + }{ + { + desc: "service is populated", + backend: networkingv1.IngressBackend{ + Service: &networkingv1.IngressServiceBackend{ + Name: "my-svc", + Port: networkingv1.ServiceBackendPort{ + Number: 80, + }, + }, + }, + }, + { + desc: "service is nil", + backend: networkingv1.IngressBackend{}, + expectErr: true, + }, + } { + t.Run(tc.desc, func(t *testing.T) { + + svcPortID, err := BackendToServicePortID(tc.backend, testNS) + if !tc.expectErr && err != nil { + t.Errorf("unexpected error: %q", err) + } else if tc.expectErr && err == nil { + t.Errorf("expected an error, but got none") + } + + expectedID := ServicePortID{} + if !tc.expectErr { + expectedID = ServicePortID{ + Service: types.NamespacedName{ + Name: tc.backend.Service.Name, + Namespace: testNS, + }, + Port: tc.backend.Service.Port, + } + } + + if !reflect.DeepEqual(expectedID, svcPortID) { + t.Errorf("expected svc port id to be %+v, but got %+v", expectedID, svcPortID) + } + }) + } +}