From ee0ead380362f09c8505505cd142d092064c5a6c Mon Sep 17 00:00:00 2001 From: Ruben Vargas Palma Date: Thu, 14 May 2020 13:28:41 -0500 Subject: [PATCH] Migrate Ingress from API extensions/v1beta1 to networking.k8s.io/v1beta1 (#1039) * Migrate Ingress from API extensions/v1beta1 to networking.k8s.io/v1beta1 Signed-off-by: Ruben Vargas * Add network.k8s.io ingress api detection Signed-off-by: Ruben Vargas * Add client layer for decide which version of API ingress to use Signed-off-by: Ruben Vargas * Ingress new/old api tests Signed-off-by: Ruben Vargas * Set used api when the client is created, minor format issues Signed-off-by: Ruben Vargas * Fix lint issues Signed-off-by: Ruben Vargas * Change the API detection to run once at start Signed-off-by: Ruben Vargas * Avoid string assertion on viper.get Signed-off-by: Ruben Vargas --- deploy/cluster_role.yaml | 12 ++ deploy/role.yaml | 13 ++ pkg/autodetect/main.go | 21 ++++ pkg/controller/jaeger/ingress.go | 13 +- pkg/controller/jaeger/ingress_test.go | 2 +- pkg/ingress/ingress.go | 172 ++++++++++++++++++++++++++ pkg/ingress/ingress_test.go | 144 +++++++++++++++++++++ pkg/ingress/query.go | 36 +++--- pkg/inventory/ingress.go | 2 +- pkg/inventory/ingress_test.go | 2 +- pkg/strategy/strategy.go | 2 +- pkg/strategy/strategy_test.go | 2 +- test/e2e/wait_util.go | 4 +- 13 files changed, 395 insertions(+), 30 deletions(-) create mode 100644 pkg/ingress/ingress.go create mode 100644 pkg/ingress/ingress_test.go diff --git a/deploy/cluster_role.yaml b/deploy/cluster_role.yaml index 660d48fc6..d4f6f7e9f 100644 --- a/deploy/cluster_role.yaml +++ b/deploy/cluster_role.yaml @@ -75,6 +75,18 @@ rules: - 'update' - 'delete' - 'watch' +# Ingress for kubernetes 1.14 or higher +- apiGroups: + - networking.k8s.io + resources: + - ingresses + verbs: + - 'get' + - 'list' + - 'create' + - 'update' + - 'delete' + - 'watch' - apiGroups: - batch resources: diff --git a/deploy/role.yaml b/deploy/role.yaml index 7484b45eb..dc88ab346 100644 --- a/deploy/role.yaml +++ b/deploy/role.yaml @@ -71,6 +71,18 @@ rules: - 'update' - 'delete' - 'watch' +# Ingress for kubernetes 1.14 or higher +- apiGroups: + - networking.k8s.io + resources: + - ingresses + verbs: + - 'get' + - 'list' + - 'create' + - 'update' + - 'delete' + - 'watch' - apiGroups: - batch resources: @@ -156,3 +168,4 @@ rules: - 'update' - 'delete' - 'watch' + diff --git a/pkg/autodetect/main.go b/pkg/autodetect/main.go index 10bff8e35..f5522045a 100644 --- a/pkg/autodetect/main.go +++ b/pkg/autodetect/main.go @@ -17,6 +17,8 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/manager" + "github.com/jaegertracing/jaeger-operator/pkg/ingress" + v1 "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inject" ) @@ -98,6 +100,8 @@ func (b *Background) autoDetectCapabilities() { b.firstRun.Do(func() { // the platform won't change during the execution of the operator, need to run it only once b.detectPlatform(ctx, apiList) + b.detectIngressAPI() + }) b.detectElasticsearch(ctx, apiList) @@ -133,6 +137,23 @@ func (b *Background) detectPlatform(ctx context.Context, apiList *metav1.APIGrou } } +func (b *Background) detectIngressAPI() { + apiRes, err := b.dcl.ServerResourcesForGroupVersion("networking.k8s.io/v1beta1") + if err != nil { + viper.Set("ingress-api", ingress.ExtensionAPI) + log.WithField("ingress-api", viper.GetString("ingress-api")).Info("Auto-detected ingress api") + return + } + + for _, r := range apiRes.APIResources { + if r.Name == "ingresses" { + viper.Set("ingress-api", ingress.NetworkingAPI) + log.WithField("ingress-api", viper.GetString("ingress-api")).Info("Auto-detected ingress api") + break + } + } +} + func (b *Background) detectElasticsearch(ctx context.Context, apiList *metav1.APIGroupList) { // detect whether the Elasticsearch operator is available if b.retryDetectEs { diff --git a/pkg/controller/jaeger/ingress.go b/pkg/controller/jaeger/ingress.go index e60f686fd..95c65805b 100644 --- a/pkg/controller/jaeger/ingress.go +++ b/pkg/controller/jaeger/ingress.go @@ -3,9 +3,11 @@ package jaeger import ( "context" + "github.com/jaegertracing/jaeger-operator/pkg/ingress" + log "github.com/sirupsen/logrus" "go.opentelemetry.io/otel/global" - "k8s.io/api/extensions/v1beta1" + "k8s.io/api/networking/v1beta1" "sigs.k8s.io/controller-runtime/pkg/client" v1 "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" @@ -14,6 +16,7 @@ import ( ) func (r *ReconcileJaeger) applyIngresses(ctx context.Context, jaeger v1.Jaeger, desired []v1beta1.Ingress) error { + ingressClient := ingress.NewIngressClient(r.client, r.rClient) tracer := global.TraceProvider().GetTracer(v1.ReconciliationTracer) ctx, span := tracer.Start(ctx, "applyIngresses") defer span.End() @@ -26,7 +29,7 @@ func (r *ReconcileJaeger) applyIngresses(ctx context.Context, jaeger v1.Jaeger, }), } list := &v1beta1.IngressList{} - if err := r.rClient.List(ctx, list, opts...); err != nil { + if err := ingressClient.List(ctx, list, opts...); err != nil { return tracing.HandleError(err, span) } @@ -36,7 +39,7 @@ func (r *ReconcileJaeger) applyIngresses(ctx context.Context, jaeger v1.Jaeger, "ingress": d.Name, "namespace": d.Namespace, }).Debug("creating ingress") - if err := r.client.Create(ctx, &d); err != nil { + if err := ingressClient.Create(ctx, &d); err != nil { return tracing.HandleError(err, span) } } @@ -46,7 +49,7 @@ func (r *ReconcileJaeger) applyIngresses(ctx context.Context, jaeger v1.Jaeger, "ingress": d.Name, "namespace": d.Namespace, }).Debug("updating ingress") - if err := r.client.Update(ctx, &d); err != nil { + if err := ingressClient.Update(ctx, &d); err != nil { return tracing.HandleError(err, span) } } @@ -56,7 +59,7 @@ func (r *ReconcileJaeger) applyIngresses(ctx context.Context, jaeger v1.Jaeger, "ingress": d.Name, "namespace": d.Namespace, }).Debug("deleting ingress") - if err := r.client.Delete(ctx, &d); err != nil { + if err := ingressClient.Delete(ctx, &d); err != nil { return tracing.HandleError(err, span) } } diff --git a/pkg/controller/jaeger/ingress_test.go b/pkg/controller/jaeger/ingress_test.go index fa963779b..8feb7fdd2 100644 --- a/pkg/controller/jaeger/ingress_test.go +++ b/pkg/controller/jaeger/ingress_test.go @@ -5,7 +5,7 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/extensions/v1beta1" + "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" diff --git a/pkg/ingress/ingress.go b/pkg/ingress/ingress.go new file mode 100644 index 000000000..012042084 --- /dev/null +++ b/pkg/ingress/ingress.go @@ -0,0 +1,172 @@ +package ingress + +import ( + "context" + + "github.com/spf13/viper" + + extv1beta "k8s.io/api/extensions/v1beta1" + netv1beta "k8s.io/api/networking/v1beta1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +// ExtensionAPI indicate k8s networking.k8s.io/v1beta1 should be used on the current cluster +const ExtensionAPI = "extension" + +// NetworkingAPI indicate k8s extensions/v1beta1 should be used on the current cluster +const NetworkingAPI = "networking" + +// Client wrap around k8s client, and decide which ingress API should be used, depending on cluster capabilities. +type Client struct { + client client.Client + rClient client.Reader + extensionAPI bool +} + +// NewIngressClient Creates a new Ingress.client wrapper. +func NewIngressClient(client client.Client, reader client.Reader) *Client { + return &Client{ + client: client, + rClient: reader, + extensionAPI: viper.GetString("ingress-api") == ExtensionAPI, + } +} + +func (c *Client) fromExtToNet(ingress extv1beta.Ingress) netv1beta.Ingress { + oldIngress := netv1beta.Ingress{ + TypeMeta: metav1.TypeMeta{ + Kind: "Ingress", + APIVersion: "extensions/v1beta1", + }, + ObjectMeta: ingress.ObjectMeta, + } + + if ingress.Spec.Backend != nil { + oldIngress.Spec = netv1beta.IngressSpec{ + Backend: &netv1beta.IngressBackend{ + ServiceName: ingress.Spec.Backend.ServiceName, + ServicePort: ingress.Spec.Backend.ServicePort, + }, + } + } + + for _, tls := range ingress.Spec.TLS { + oldIngress.Spec.TLS = append(oldIngress.Spec.TLS, netv1beta.IngressTLS{ + Hosts: tls.Hosts, + SecretName: tls.SecretName, + }) + } + + for _, rule := range ingress.Spec.Rules { + httpIngressPaths := make([]netv1beta.HTTPIngressPath, len(rule.HTTP.Paths)) + for i, path := range rule.HTTP.Paths { + httpIngressPaths[i].Backend.ServicePort = path.Backend.ServicePort + httpIngressPaths[i].Backend.ServiceName = path.Backend.ServiceName + httpIngressPaths[i].Path = path.Path + + } + + oldIngress.Spec.Rules = append(oldIngress.Spec.Rules, netv1beta.IngressRule{ + Host: rule.Host, + IngressRuleValue: netv1beta.IngressRuleValue{ + HTTP: &netv1beta.HTTPIngressRuleValue{ + Paths: httpIngressPaths, + }, + }, + }) + } + + return oldIngress +} + +func (c *Client) fromNetToExt(ingress netv1beta.Ingress) extv1beta.Ingress { + oldIngress := extv1beta.Ingress{ + TypeMeta: metav1.TypeMeta{ + Kind: "Ingress", + APIVersion: "extensions/v1beta1", + }, + ObjectMeta: ingress.ObjectMeta, + } + + if ingress.Spec.Backend != nil { + oldIngress.Spec = extv1beta.IngressSpec{ + Backend: &extv1beta.IngressBackend{ + ServiceName: ingress.Spec.Backend.ServiceName, + ServicePort: ingress.Spec.Backend.ServicePort, + }, + } + } + + for _, tls := range ingress.Spec.TLS { + oldIngress.Spec.TLS = append(oldIngress.Spec.TLS, extv1beta.IngressTLS{ + Hosts: tls.Hosts, + SecretName: tls.SecretName, + }) + } + + for _, rule := range ingress.Spec.Rules { + httpIngressPaths := make([]extv1beta.HTTPIngressPath, len(rule.HTTP.Paths)) + for i, path := range rule.HTTP.Paths { + httpIngressPaths[i].Backend.ServicePort = path.Backend.ServicePort + httpIngressPaths[i].Backend.ServiceName = path.Backend.ServiceName + httpIngressPaths[i].Path = path.Path + + } + + oldIngress.Spec.Rules = append(oldIngress.Spec.Rules, extv1beta.IngressRule{ + Host: rule.Host, + IngressRuleValue: extv1beta.IngressRuleValue{ + HTTP: &extv1beta.HTTPIngressRuleValue{ + Paths: httpIngressPaths, + }, + }, + }) + } + + return oldIngress +} + +// List is a wrap function that calls k8s client List with extend or networking API. +func (c *Client) List(ctx context.Context, list *netv1beta.IngressList, opts ...client.ListOption) error { + if c.extensionAPI { + extIngressList := extv1beta.IngressList{} + err := c.rClient.List(ctx, &extIngressList, opts...) + if err != nil { + return err + } + for _, item := range extIngressList.Items { + list.Items = append(list.Items, c.fromExtToNet(item)) + } + return nil + } + return c.rClient.List(ctx, list, opts...) +} + +// Update is a wrap function that calls k8s client Update with extend or networking API. +func (c *Client) Update(ctx context.Context, obj *netv1beta.Ingress, opts ...client.UpdateOption) error { + if c.extensionAPI { + extIngressList := c.fromNetToExt(*obj) + return c.client.Update(ctx, &extIngressList, opts...) + } + return c.client.Update(ctx, obj, opts...) + +} + +// Delete is a wrap function that calls k8s client Delete with extend or networking API. +func (c *Client) Delete(ctx context.Context, obj *netv1beta.Ingress, opts ...client.DeleteOption) error { + if c.extensionAPI { + extIngressList := c.fromNetToExt(*obj) + return c.client.Delete(ctx, &extIngressList, opts...) + } + return c.client.Delete(ctx, obj, opts...) +} + +// Create is a wrap function that calls k8s client Create with extend or networking API. +func (c *Client) Create(ctx context.Context, obj *netv1beta.Ingress, opts ...client.CreateOption) error { + if c.extensionAPI { + extIngressList := c.fromNetToExt(*obj) + return c.client.Create(ctx, &extIngressList, opts...) + } + return c.client.Create(ctx, obj, opts...) +} diff --git a/pkg/ingress/ingress_test.go b/pkg/ingress/ingress_test.go new file mode 100644 index 000000000..54fcb1bdc --- /dev/null +++ b/pkg/ingress/ingress_test.go @@ -0,0 +1,144 @@ +package ingress + +import ( + "context" + + "github.com/spf13/viper" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + extv1beta "k8s.io/api/extensions/v1beta1" + netv1beta "k8s.io/api/networking/v1beta1" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/client-go/kubernetes/scheme" + "sigs.k8s.io/controller-runtime/pkg/client/fake" + + v1 "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" + + "testing" +) + +func getIngress() *netv1beta.Ingress { + jaeger := v1.NewJaeger(types.NamespacedName{Name: "TestQueryIngressTLSSecret"}) + + jaeger.Spec.Ingress.TLS = []v1.JaegerIngressTLSSpec{ + v1.JaegerIngressTLSSpec{ + SecretName: "test-secret", + }, + } + + ingress := NewQueryIngress(jaeger) + dep := ingress.Get() + return dep +} + +func TestIngressNetworkingAPI(t *testing.T) { + viper.Set("ingress-api", NetworkingAPI) + s := scheme.Scheme + s.AddKnownTypes(v1.SchemeGroupVersion, &v1.Jaeger{}) + s.AddKnownTypes(v1.SchemeGroupVersion, &v1.JaegerList{}) + cl := fake.NewFakeClient() + + ingressClient := NewIngressClient(cl, cl) + ingress := getIngress() + // Test create + err := ingressClient.Create(context.Background(), ingress) + assert.NoError(t, err) + + // Get ingress for both APIs + netIngress := &netv1beta.Ingress{} + extIngress := &extv1beta.Ingress{} + + // extension.Ingress should not exist + err = cl.Get(context.Background(), types.NamespacedName{Name: ingress.GetName(), Namespace: ingress.GetNamespace()}, extIngress) + require.Error(t, err) + assert.Equal(t, err.(*apierrors.StatusError).ErrStatus.Reason, metav1.StatusReasonNotFound) + + // networking.Ingress + err = cl.Get(context.Background(), types.NamespacedName{Name: ingress.GetName(), Namespace: ingress.GetNamespace()}, netIngress) + assert.NoError(t, err) + + // List + netIngressList := &netv1beta.IngressList{} + err = ingressClient.List(context.Background(), netIngressList) + assert.NoError(t, err) + assert.Equal(t, 1, len(netIngressList.Items)) + + // Should return 0 (not using extension API) + extIngressList := &extv1beta.IngressList{} + err = cl.List(context.Background(), extIngressList) + assert.NoError(t, err) + assert.Equal(t, 0, len(extIngressList.Items)) + + // Update + updatedIngress := getIngress() + updatedIngress.Spec.Backend.ServiceName = "updated-srv" + err = ingressClient.Update(context.Background(), updatedIngress) + require.NoError(t, err) + + err = cl.Get(context.Background(), types.NamespacedName{Name: ingress.GetName(), Namespace: ingress.GetNamespace()}, netIngress) + require.NoError(t, err) + assert.Equal(t, "updated-srv", netIngress.Spec.Backend.ServiceName) + + // Delete + err = ingressClient.Delete(context.Background(), ingress) + err = cl.Get(context.Background(), types.NamespacedName{Name: ingress.GetName(), Namespace: ingress.GetNamespace()}, netIngress) + require.Error(t, err) + assert.Equal(t, err.(*apierrors.StatusError).ErrStatus.Reason, metav1.StatusReasonNotFound) +} + +func TestIngressExtensionAPI(t *testing.T) { + viper.Set("ingress-api", ExtensionAPI) + s := scheme.Scheme + s.AddKnownTypes(v1.SchemeGroupVersion, &v1.Jaeger{}) + s.AddKnownTypes(v1.SchemeGroupVersion, &v1.JaegerList{}) + cl := fake.NewFakeClient() + + ingressClient := NewIngressClient(cl, cl) + ingress := getIngress() + // Test create + err := ingressClient.Create(context.Background(), ingress) + assert.NoError(t, err) + + // Get ingress for both APIs + netIngress := &netv1beta.Ingress{} + extIngress := &extv1beta.Ingress{} + + // networking.Ingress should not exist + err = cl.Get(context.Background(), types.NamespacedName{Name: ingress.GetName(), Namespace: ingress.GetNamespace()}, netIngress) + require.Error(t, err) + assert.Equal(t, err.(*apierrors.StatusError).ErrStatus.Reason, metav1.StatusReasonNotFound) + + // extension.Ingress + err = cl.Get(context.Background(), types.NamespacedName{Name: ingress.GetName(), Namespace: ingress.GetNamespace()}, extIngress) + assert.NoError(t, err) + + // List + extIngressList := &netv1beta.IngressList{} + err = ingressClient.List(context.Background(), extIngressList) + assert.NoError(t, err) + assert.Equal(t, 1, len(extIngressList.Items)) + + // Should return 0 (not using networking API) + netIngressList := &netv1beta.IngressList{} + err = cl.List(context.Background(), netIngressList) + assert.NoError(t, err) + assert.Equal(t, 0, len(netIngressList.Items)) + + // Update + updatedIngress := getIngress() + updatedIngress.Spec.Backend.ServiceName = "updated-srv" + err = ingressClient.Update(context.Background(), updatedIngress) + require.NoError(t, err) + + err = cl.Get(context.Background(), types.NamespacedName{Name: ingress.GetName(), Namespace: ingress.GetNamespace()}, extIngress) + require.NoError(t, err) + assert.Equal(t, "updated-srv", extIngress.Spec.Backend.ServiceName) + + // Delete + err = ingressClient.Delete(context.Background(), ingress) + err = cl.Get(context.Background(), types.NamespacedName{Name: ingress.GetName(), Namespace: ingress.GetNamespace()}, extIngress) + require.Error(t, err) + assert.Equal(t, err.(*apierrors.StatusError).ErrStatus.Reason, metav1.StatusReasonNotFound) +} diff --git a/pkg/ingress/query.go b/pkg/ingress/query.go index 920ccb1a0..488c96fc7 100644 --- a/pkg/ingress/query.go +++ b/pkg/ingress/query.go @@ -3,7 +3,7 @@ package ingress import ( "fmt" - extv1beta1 "k8s.io/api/extensions/v1beta1" + netv1beta1 "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" @@ -23,7 +23,7 @@ func NewQueryIngress(jaeger *v1.Jaeger) *QueryIngress { } // Get returns an ingress specification for the current instance -func (i *QueryIngress) Get() *extv1beta1.Ingress { +func (i *QueryIngress) Get() *netv1beta1.Ingress { if i.jaeger.Spec.Ingress.Enabled != nil && *i.jaeger.Spec.Ingress.Enabled == false { return nil } @@ -36,8 +36,8 @@ func (i *QueryIngress) Get() *extv1beta1.Ingress { commonSpec := util.Merge([]v1.JaegerCommonSpec{i.jaeger.Spec.Ingress.JaegerCommonSpec, i.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) - spec := extv1beta1.IngressSpec{} - backend := extv1beta1.IngressBackend{ + spec := netv1beta1.IngressSpec{} + backend := netv1beta1.IngressBackend{ ServiceName: service.GetNameForQueryService(i.jaeger), ServicePort: intstr.FromInt(service.GetPortForQueryService(i.jaeger)), } @@ -46,10 +46,10 @@ func (i *QueryIngress) Get() *extv1beta1.Ingress { i.addTLSSpec(&spec) - return &extv1beta1.Ingress{ + return &netv1beta1.Ingress{ TypeMeta: metav1.TypeMeta{ Kind: "Ingress", - APIVersion: "extensions/v1beta1", + APIVersion: "networking.k8s.io/v1beta1", }, ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("%s-query", i.jaeger.Name), @@ -70,7 +70,7 @@ func (i *QueryIngress) Get() *extv1beta1.Ingress { } } -func (i *QueryIngress) addRulesSpec(spec *extv1beta1.IngressSpec, backend *extv1beta1.IngressBackend) { +func (i *QueryIngress) addRulesSpec(spec *netv1beta1.IngressSpec, backend *netv1beta1.IngressBackend) { path := "" if allInOneQueryBasePath, ok := i.jaeger.Spec.AllInOne.Options.Map()["query.base-path"]; ok && i.jaeger.Spec.Strategy == v1.DeploymentStrategyAllInOne { @@ -87,10 +87,10 @@ func (i *QueryIngress) addRulesSpec(spec *extv1beta1.IngressSpec, backend *extv1 } } -func (i *QueryIngress) addTLSSpec(spec *extv1beta1.IngressSpec) { +func (i *QueryIngress) addTLSSpec(spec *netv1beta1.IngressSpec) { if len(i.jaeger.Spec.Ingress.TLS) > 0 { for _, tls := range i.jaeger.Spec.Ingress.TLS { - spec.TLS = append(spec.TLS, extv1beta1.IngressTLS{ + spec.TLS = append(spec.TLS, netv1beta1.IngressTLS{ Hosts: tls.Hosts, SecretName: tls.SecretName, }) @@ -99,31 +99,31 @@ func (i *QueryIngress) addTLSSpec(spec *extv1beta1.IngressSpec) { i.jaeger.Logger().Warn("Both 'ingress.secretName' and 'ingress.tls' are set. 'ingress.secretName' is deprecated and is therefore ignored.") } } else if i.jaeger.Spec.Ingress.SecretName != "" { - spec.TLS = append(spec.TLS, extv1beta1.IngressTLS{ + spec.TLS = append(spec.TLS, netv1beta1.IngressTLS{ SecretName: i.jaeger.Spec.Ingress.SecretName, }) i.jaeger.Logger().Warn("'ingress.secretName' property is deprecated and will be removed in the future. Please use 'ingress.tls' instead.") } } -func getRules(path string, hosts []string, backend *extv1beta1.IngressBackend) []extv1beta1.IngressRule { +func getRules(path string, hosts []string, backend *netv1beta1.IngressBackend) []netv1beta1.IngressRule { if len(hosts) > 0 { - rules := make([]extv1beta1.IngressRule, len(hosts)) + rules := make([]netv1beta1.IngressRule, len(hosts)) for i, host := range hosts { rule := getRule(host, path, backend) rules[i] = rule } return rules } - return []extv1beta1.IngressRule{getRule("", path, backend)} + return []netv1beta1.IngressRule{getRule("", path, backend)} } -func getRule(host string, path string, backend *extv1beta1.IngressBackend) extv1beta1.IngressRule { - rule := extv1beta1.IngressRule{} +func getRule(host string, path string, backend *netv1beta1.IngressBackend) netv1beta1.IngressRule { + rule := netv1beta1.IngressRule{} rule.Host = host - rule.HTTP = &extv1beta1.HTTPIngressRuleValue{ - Paths: []extv1beta1.HTTPIngressPath{ - extv1beta1.HTTPIngressPath{ + rule.HTTP = &netv1beta1.HTTPIngressRuleValue{ + Paths: []netv1beta1.HTTPIngressPath{ + netv1beta1.HTTPIngressPath{ Path: path, Backend: *backend, }, diff --git a/pkg/inventory/ingress.go b/pkg/inventory/ingress.go index ab54ee498..02992af33 100644 --- a/pkg/inventory/ingress.go +++ b/pkg/inventory/ingress.go @@ -3,7 +3,7 @@ package inventory import ( "fmt" - "k8s.io/api/extensions/v1beta1" + "k8s.io/api/networking/v1beta1" "github.com/jaegertracing/jaeger-operator/pkg/util" ) diff --git a/pkg/inventory/ingress_test.go b/pkg/inventory/ingress_test.go index fd1d31399..186aace72 100644 --- a/pkg/inventory/ingress_test.go +++ b/pkg/inventory/ingress_test.go @@ -4,7 +4,7 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/extensions/v1beta1" + "k8s.io/api/networking/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) diff --git a/pkg/strategy/strategy.go b/pkg/strategy/strategy.go index e07004b44..1f2240827 100644 --- a/pkg/strategy/strategy.go +++ b/pkg/strategy/strategy.go @@ -7,7 +7,7 @@ import ( batchv1 "k8s.io/api/batch/v1" batchv1beta1 "k8s.io/api/batch/v1beta1" corev1 "k8s.io/api/core/v1" - "k8s.io/api/extensions/v1beta1" + "k8s.io/api/networking/v1beta1" rbac "k8s.io/api/rbac/v1" "k8s.io/apimachinery/pkg/runtime" diff --git a/pkg/strategy/strategy_test.go b/pkg/strategy/strategy_test.go index c85912553..a5321b4d6 100644 --- a/pkg/strategy/strategy_test.go +++ b/pkg/strategy/strategy_test.go @@ -9,7 +9,7 @@ import ( batchv1 "k8s.io/api/batch/v1" batchv1beta1 "k8s.io/api/batch/v1beta1" v1 "k8s.io/api/core/v1" - "k8s.io/api/extensions/v1beta1" + "k8s.io/api/networking/v1beta1" rbac "k8s.io/api/rbac/v1" kafkav1beta1 "github.com/jaegertracing/jaeger-operator/pkg/apis/kafka/v1beta1" diff --git a/test/e2e/wait_util.go b/test/e2e/wait_util.go index 4f211e0ca..0373e48d5 100644 --- a/test/e2e/wait_util.go +++ b/test/e2e/wait_util.go @@ -8,7 +8,7 @@ import ( "github.com/operator-framework/operator-sdk/pkg/test/e2eutil" "github.com/sirupsen/logrus" "github.com/stretchr/testify/require" - "k8s.io/api/extensions/v1beta1" + "k8s.io/api/networking/v1beta1" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/wait" @@ -77,7 +77,7 @@ func WaitForIngress(t *testing.T, kubeclient kubernetes.Interface, namespace, na start := time.Now() var ingress *v1beta1.Ingress err := wait.Poll(retryInterval, timeout, func() (done bool, err error) { - ingress, err = kubeclient.ExtensionsV1beta1().Ingresses(namespace).Get(name, metav1.GetOptions{}) + ingress, err = kubeclient.NetworkingV1beta1().Ingresses(namespace).Get(name, metav1.GetOptions{}) if err != nil { if apierrors.IsNotFound(err) { t.Logf("Waiting for availability of %s ingress\n", name)