baalajimaestro/traefik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

chore: update linter

Browse source
This commit is contained in:
Fernandez Ludovic 2023-04-17 10:56:36 +02:00
parent 598caf6f78
commit 928db9bc42
25 changed files with 817 additions and 743 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

145
.golangci.yml
View file

@ -6,9 +6,10 @@ run:
linters-settings: linters-settings:
govet: govet:
check-shadowing: false enable-all: true
golint: disable:
min-confidence: 0 - shadow
- fieldalignment
gocyclo: gocyclo:
min-complexity: 14 min-complexity: 14
goconst: goconst:
@ -33,40 +34,112 @@ linters-settings:
keywords: keywords:
- FIXME - FIXME
importas: importas:
corev1: k8s.io/api/core/v1 no-unaliased: true
networkingv1beta1: k8s.io/api/networking/v1beta1 alias:
extensionsv1beta1: k8s.io/api/extensions/v1beta1 - alias: composeapi
metav1: k8s.io/apimachinery/pkg/apis/meta/v1 pkg: github.com/docker/compose/v2/pkg/api
kubeerror: k8s.io/apimachinery/pkg/api/errors
composeapi: github.com/docker/compose/v2/pkg/api # Standard Kubernetes rewrites:
- alias: corev1
pkg: "k8s.io/api/core/v1"
- alias: netv1
pkg: "k8s.io/api/networking/v1"
- alias: netv1beta1
pkg: "k8s.io/api/networking/v1beta1"
- alias: admv1
pkg: "k8s.io/api/admission/v1"
- alias: admv1beta1
pkg: "k8s.io/api/admission/v1beta1"
- alias: extv1beta1
pkg: "k8s.io/api/extensions/v1beta1"
- alias: metav1
pkg: "k8s.io/apimachinery/pkg/apis/meta/v1"
- alias: ktypes
pkg: "k8s.io/apimachinery/pkg/types"
- alias: kerror
pkg: "k8s.io/apimachinery/pkg/api/errors"
- alias: kclientset
pkg: "k8s.io/client-go/kubernetes"
- alias: kinformers
pkg: "k8s.io/client-go/informers"
- alias: ktesting
pkg: "k8s.io/client-go/testing"
- alias: kschema
pkg: "k8s.io/apimachinery/pkg/runtime/schema"
- alias: kscheme
pkg: "k8s.io/client-go/kubernetes/scheme"
- alias: kversion
pkg: "k8s.io/apimachinery/pkg/version"
- alias: kubefake
pkg: "k8s.io/client-go/kubernetes/fake"
- alias: discoveryfake
pkg: "k8s.io/client-go/discovery/fake"
# Kubernetes Gateway rewrites:
- alias: gateclientset
pkg: "sigs.k8s.io/gateway-api/pkg/client/clientset/gateway/versioned"
- alias: gateinformers
pkg: "sigs.k8s.io/gateway-api/pkg/client/informers/gateway/externalversions"
- alias: gatev1alpha2
pkg: "sigs.k8s.io/gateway-api/apis/v1alpha2"
# Traefik Kubernetes rewrites:
- alias: containousv1alpha1
pkg: "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikcontainous/v1alpha1"
- alias: traefikv1alpha1
pkg: "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1"
- alias: traefikclientset
pkg: "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned"
- alias: traefikinformers
pkg: "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/informers/externalversions"
- alias: traefikscheme
pkg: "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned/scheme"
- alias: traefikcrdfake
pkg: "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned/fake"
tagalign:
align: false
sort: true
order:
- description
- json
- toml
- yaml
- yml
- label
- label-slice-as-struct
- file
- kv
- export
revive: revive:
rules: rules:
- name: struct-tag - name: struct-tag
rules: - name: blank-imports
- name: blank-imports - name: context-as-argument
- name: context-as-argument - name: context-keys-type
- name: context-keys-type - name: dot-imports
- name: dot-imports - name: error-return
- name: error-return - name: error-strings
- name: error-strings - name: error-naming
- name: error-naming - name: exported
- name: exported disabled: true
- name: if-return - name: if-return
- name: increment-decrement - name: increment-decrement
- name: var-naming - name: var-naming
- name: var-declaration - name: var-declaration
- name: package-comments - name: package-comments
- name: range disabled: true
- name: receiver-naming - name: range
- name: time-naming - name: receiver-naming
- name: unexported-return - name: time-naming
- name: indent-error-flow - name: unexported-return
- name: errorf - name: indent-error-flow
- name: empty-block - name: errorf
- name: superfluous-else - name: empty-block
- name: unused-parameter - name: superfluous-else
- name: unreachable-code - name: unused-parameter
- name: redefines-builtin-id disabled: true
- name: unreachable-code
- name: redefines-builtin-id
gomoddirectives: gomoddirectives:
replace-allow-list: replace-allow-list:
- github.com/abbot/go-http-auth - github.com/abbot/go-http-auth
@ -183,3 +256,7 @@ issues:
text: "Function 'loadConfigurationFromCRD' has too many statements" text: "Function 'loadConfigurationFromCRD' has too many statements"
linters: linters:
- funlen - funlen
- path: pkg/provider/kubernetes/gateway/client_mock_test.go
text: 'unusedwrite: unused write to field'
linters:
- govet

106
pkg/provider/kubernetes/crd/client.go
View file

@ -9,17 +9,17 @@ import (
"time" "time"
"github.com/rs/zerolog/log" "github.com/rs/zerolog/log"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned" traefikclientset "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/informers/externalversions" traefikinformers "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/informers/externalversions"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1" traefikv1alpha1 "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s" "github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s"
"github.com/traefik/traefik/v3/pkg/version" "github.com/traefik/traefik/v3/pkg/version"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
kubeerror "k8s.io/apimachinery/pkg/api/errors" kerror "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/informers" kinformers "k8s.io/client-go/informers"
"k8s.io/client-go/kubernetes" kclientset "k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest" "k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd" "k8s.io/client-go/tools/clientcmd"
) )
@ -31,17 +31,17 @@ const resyncPeriod = 10 * time.Minute
// The stores can then be accessed via the Get* functions. // The stores can then be accessed via the Get* functions.
type Client interface { type Client interface {
WatchAll(namespaces []string, stopCh <-chan struct{}) (<-chan interface{}, error) WatchAll(namespaces []string, stopCh <-chan struct{}) (<-chan interface{}, error)
GetIngressRoutes() []*v1alpha1.IngressRoute GetIngressRoutes() []*traefikv1alpha1.IngressRoute
GetIngressRouteTCPs() []*v1alpha1.IngressRouteTCP GetIngressRouteTCPs() []*traefikv1alpha1.IngressRouteTCP
GetIngressRouteUDPs() []*v1alpha1.IngressRouteUDP GetIngressRouteUDPs() []*traefikv1alpha1.IngressRouteUDP
GetMiddlewares() []*v1alpha1.Middleware GetMiddlewares() []*traefikv1alpha1.Middleware
GetMiddlewareTCPs() []*v1alpha1.MiddlewareTCP GetMiddlewareTCPs() []*traefikv1alpha1.MiddlewareTCP
GetTraefikService(namespace, name string) (*v1alpha1.TraefikService, bool, error) GetTraefikService(namespace, name string) (*traefikv1alpha1.TraefikService, bool, error)
GetTraefikServices() []*v1alpha1.TraefikService GetTraefikServices() []*traefikv1alpha1.TraefikService
GetTLSOptions() []*v1alpha1.TLSOption GetTLSOptions() []*traefikv1alpha1.TLSOption
GetServersTransports() []*v1alpha1.ServersTransport GetServersTransports() []*traefikv1alpha1.ServersTransport
GetServersTransportTCPs() []*v1alpha1.ServersTransportTCP GetServersTransportTCPs() []*traefikv1alpha1.ServersTransportTCP
GetTLSStores() []*v1alpha1.TLSStore GetTLSStores() []*traefikv1alpha1.TLSStore
GetService(namespace, name string) (*corev1.Service, bool, error) GetService(namespace, name string) (*corev1.Service, bool, error)
GetSecret(namespace, name string) (*corev1.Secret, bool, error) GetSecret(namespace, name string) (*corev1.Secret, bool, error)
GetEndpoints(namespace, name string) (*corev1.Endpoints, bool, error) GetEndpoints(namespace, name string) (*corev1.Endpoints, bool, error)
@ -49,12 +49,12 @@ type Client interface {
// TODO: add tests for the clientWrapper (and its methods) itself. // TODO: add tests for the clientWrapper (and its methods) itself.
type clientWrapper struct { type clientWrapper struct {
csCrd versioned.Interface csCrd traefikclientset.Interface
csKube kubernetes.Interface csKube kclientset.Interface
factoriesCrd map[string]externalversions.SharedInformerFactory factoriesCrd map[string]traefikinformers.SharedInformerFactory
factoriesKube map[string]informers.SharedInformerFactory factoriesKube map[string]kinformers.SharedInformerFactory
factoriesSecret map[string]informers.SharedInformerFactory factoriesSecret map[string]kinformers.SharedInformerFactory
labelSelector string labelSelector string
@ -71,12 +71,12 @@ func createClientFromConfig(c *rest.Config) (*clientWrapper, error) {
runtime.GOARCH, runtime.GOARCH,
) )
csCrd, err := versioned.NewForConfig(c) csCrd, err := traefikclientset.NewForConfig(c)
if err != nil { if err != nil {
return nil, err return nil, err
} }
csKube, err := kubernetes.NewForConfig(c) csKube, err := kclientset.NewForConfig(c)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -84,13 +84,13 @@ func createClientFromConfig(c *rest.Config) (*clientWrapper, error) {
return newClientImpl(csKube, csCrd), nil return newClientImpl(csKube, csCrd), nil
} }
func newClientImpl(csKube kubernetes.Interface, csCrd versioned.Interface) *clientWrapper { func newClientImpl(csKube kclientset.Interface, csCrd traefikclientset.Interface) *clientWrapper {
return &clientWrapper{ return &clientWrapper{
csCrd: csCrd, csCrd: csCrd,
csKube: csKube, csKube: csKube,
factoriesCrd: make(map[string]externalversions.SharedInformerFactory), factoriesCrd: make(map[string]traefikinformers.SharedInformerFactory),
factoriesKube: make(map[string]informers.SharedInformerFactory), factoriesKube: make(map[string]kinformers.SharedInformerFactory),
factoriesSecret: make(map[string]informers.SharedInformerFactory), factoriesSecret: make(map[string]kinformers.SharedInformerFactory),
} }
} }
@ -163,7 +163,7 @@ func (c *clientWrapper) WatchAll(namespaces []string, stopCh <-chan struct{}) (<
} }
for _, ns := range namespaces { for _, ns := range namespaces {
factoryCrd := externalversions.NewSharedInformerFactoryWithOptions(c.csCrd, resyncPeriod, externalversions.WithNamespace(ns), externalversions.WithTweakListOptions(matchesLabelSelector)) factoryCrd := traefikinformers.NewSharedInformerFactoryWithOptions(c.csCrd, resyncPeriod, traefikinformers.WithNamespace(ns), traefikinformers.WithTweakListOptions(matchesLabelSelector))
factoryCrd.Traefik().V1alpha1().IngressRoutes().Informer().AddEventHandler(eventHandler) factoryCrd.Traefik().V1alpha1().IngressRoutes().Informer().AddEventHandler(eventHandler)
factoryCrd.Traefik().V1alpha1().Middlewares().Informer().AddEventHandler(eventHandler) factoryCrd.Traefik().V1alpha1().Middlewares().Informer().AddEventHandler(eventHandler)
factoryCrd.Traefik().V1alpha1().MiddlewareTCPs().Informer().AddEventHandler(eventHandler) factoryCrd.Traefik().V1alpha1().MiddlewareTCPs().Informer().AddEventHandler(eventHandler)
@ -175,11 +175,11 @@ func (c *clientWrapper) WatchAll(namespaces []string, stopCh <-chan struct{}) (<
factoryCrd.Traefik().V1alpha1().TLSStores().Informer().AddEventHandler(eventHandler) factoryCrd.Traefik().V1alpha1().TLSStores().Informer().AddEventHandler(eventHandler)
factoryCrd.Traefik().V1alpha1().TraefikServices().Informer().AddEventHandler(eventHandler) factoryCrd.Traefik().V1alpha1().TraefikServices().Informer().AddEventHandler(eventHandler)
factoryKube := informers.NewSharedInformerFactoryWithOptions(c.csKube, resyncPeriod, informers.WithNamespace(ns)) factoryKube := kinformers.NewSharedInformerFactoryWithOptions(c.csKube, resyncPeriod, kinformers.WithNamespace(ns))
factoryKube.Core().V1().Services().Informer().AddEventHandler(eventHandler) factoryKube.Core().V1().Services().Informer().AddEventHandler(eventHandler)
factoryKube.Core().V1().Endpoints().Informer().AddEventHandler(eventHandler) factoryKube.Core().V1().Endpoints().Informer().AddEventHandler(eventHandler)
factorySecret := informers.NewSharedInformerFactoryWithOptions(c.csKube, resyncPeriod, informers.WithNamespace(ns), informers.WithTweakListOptions(notOwnedByHelm)) factorySecret := kinformers.NewSharedInformerFactoryWithOptions(c.csKube, resyncPeriod, kinformers.WithNamespace(ns), kinformers.WithTweakListOptions(notOwnedByHelm))
factorySecret.Core().V1().Secrets().Informer().AddEventHandler(eventHandler) factorySecret.Core().V1().Secrets().Informer().AddEventHandler(eventHandler)
c.factoriesCrd[ns] = factoryCrd c.factoriesCrd[ns] = factoryCrd
@ -216,8 +216,8 @@ func (c *clientWrapper) WatchAll(namespaces []string, stopCh <-chan struct{}) (<
return eventCh, nil return eventCh, nil
} }
func (c *clientWrapper) GetIngressRoutes() []*v1alpha1.IngressRoute { func (c *clientWrapper) GetIngressRoutes() []*traefikv1alpha1.IngressRoute {
var result []*v1alpha1.IngressRoute var result []*traefikv1alpha1.IngressRoute
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
ings, err := factory.Traefik().V1alpha1().IngressRoutes().Lister().List(labels.Everything()) ings, err := factory.Traefik().V1alpha1().IngressRoutes().Lister().List(labels.Everything())
@ -230,8 +230,8 @@ func (c *clientWrapper) GetIngressRoutes() []*v1alpha1.IngressRoute {
return result return result
} }
func (c *clientWrapper) GetIngressRouteTCPs() []*v1alpha1.IngressRouteTCP { func (c *clientWrapper) GetIngressRouteTCPs() []*traefikv1alpha1.IngressRouteTCP {
var result []*v1alpha1.IngressRouteTCP var result []*traefikv1alpha1.IngressRouteTCP
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
ings, err := factory.Traefik().V1alpha1().IngressRouteTCPs().Lister().List(labels.Everything()) ings, err := factory.Traefik().V1alpha1().IngressRouteTCPs().Lister().List(labels.Everything())
@ -244,8 +244,8 @@ func (c *clientWrapper) GetIngressRouteTCPs() []*v1alpha1.IngressRouteTCP {
return result return result
} }
func (c *clientWrapper) GetIngressRouteUDPs() []*v1alpha1.IngressRouteUDP { func (c *clientWrapper) GetIngressRouteUDPs() []*traefikv1alpha1.IngressRouteUDP {
var result []*v1alpha1.IngressRouteUDP var result []*traefikv1alpha1.IngressRouteUDP
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
ings, err := factory.Traefik().V1alpha1().IngressRouteUDPs().Lister().List(labels.Everything()) ings, err := factory.Traefik().V1alpha1().IngressRouteUDPs().Lister().List(labels.Everything())
@ -258,8 +258,8 @@ func (c *clientWrapper) GetIngressRouteUDPs() []*v1alpha1.IngressRouteUDP {
return result return result
} }
func (c *clientWrapper) GetMiddlewares() []*v1alpha1.Middleware { func (c *clientWrapper) GetMiddlewares() []*traefikv1alpha1.Middleware {
var result []*v1alpha1.Middleware var result []*traefikv1alpha1.Middleware
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
middlewares, err := factory.Traefik().V1alpha1().Middlewares().Lister().List(labels.Everything()) middlewares, err := factory.Traefik().V1alpha1().Middlewares().Lister().List(labels.Everything())
@ -272,8 +272,8 @@ func (c *clientWrapper) GetMiddlewares() []*v1alpha1.Middleware {
return result return result
} }
func (c *clientWrapper) GetMiddlewareTCPs() []*v1alpha1.MiddlewareTCP { func (c *clientWrapper) GetMiddlewareTCPs() []*traefikv1alpha1.MiddlewareTCP {
var result []*v1alpha1.MiddlewareTCP var result []*traefikv1alpha1.MiddlewareTCP
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
middlewares, err := factory.Traefik().V1alpha1().MiddlewareTCPs().Lister().List(labels.Everything()) middlewares, err := factory.Traefik().V1alpha1().MiddlewareTCPs().Lister().List(labels.Everything())
@ -287,7 +287,7 @@ func (c *clientWrapper) GetMiddlewareTCPs() []*v1alpha1.MiddlewareTCP {
} }
// GetTraefikService returns the named service from the given namespace. // GetTraefikService returns the named service from the given namespace.
func (c *clientWrapper) GetTraefikService(namespace, name string) (*v1alpha1.TraefikService, bool, error) { func (c *clientWrapper) GetTraefikService(namespace, name string) (*traefikv1alpha1.TraefikService, bool, error) {
if !c.isWatchedNamespace(namespace) { if !c.isWatchedNamespace(namespace) {
return nil, false, fmt.Errorf("failed to get service %s/%s: namespace is not within watched namespaces", namespace, name) return nil, false, fmt.Errorf("failed to get service %s/%s: namespace is not within watched namespaces", namespace, name)
} }
@ -298,8 +298,8 @@ func (c *clientWrapper) GetTraefikService(namespace, name string) (*v1alpha1.Tra
return service, exist, err return service, exist, err
} }
func (c *clientWrapper) GetTraefikServices() []*v1alpha1.TraefikService { func (c *clientWrapper) GetTraefikServices() []*traefikv1alpha1.TraefikService {
var result []*v1alpha1.TraefikService var result []*traefikv1alpha1.TraefikService
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
traefikServices, err := factory.Traefik().V1alpha1().TraefikServices().Lister().List(labels.Everything()) traefikServices, err := factory.Traefik().V1alpha1().TraefikServices().Lister().List(labels.Everything())
@ -313,8 +313,8 @@ func (c *clientWrapper) GetTraefikServices() []*v1alpha1.TraefikService {
} }
// GetServersTransports returns all ServersTransport. // GetServersTransports returns all ServersTransport.
func (c *clientWrapper) GetServersTransports() []*v1alpha1.ServersTransport { func (c *clientWrapper) GetServersTransports() []*traefikv1alpha1.ServersTransport {
var result []*v1alpha1.ServersTransport var result []*traefikv1alpha1.ServersTransport
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
serversTransports, err := factory.Traefik().V1alpha1().ServersTransports().Lister().List(labels.Everything()) serversTransports, err := factory.Traefik().V1alpha1().ServersTransports().Lister().List(labels.Everything())
@ -328,8 +328,8 @@ func (c *clientWrapper) GetServersTransports() []*v1alpha1.ServersTransport {
} }
// GetServersTransportTCPs returns all ServersTransportTCP. // GetServersTransportTCPs returns all ServersTransportTCP.
func (c *clientWrapper) GetServersTransportTCPs() []*v1alpha1.ServersTransportTCP { func (c *clientWrapper) GetServersTransportTCPs() []*traefikv1alpha1.ServersTransportTCP {
var result []*v1alpha1.ServersTransportTCP var result []*traefikv1alpha1.ServersTransportTCP
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
serversTransports, err := factory.Traefik().V1alpha1().ServersTransportTCPs().Lister().List(labels.Everything()) serversTransports, err := factory.Traefik().V1alpha1().ServersTransportTCPs().Lister().List(labels.Everything())
@ -343,8 +343,8 @@ func (c *clientWrapper) GetServersTransportTCPs() []*v1alpha1.ServersTransportTC
} }
// GetTLSOptions returns all TLS options. // GetTLSOptions returns all TLS options.
func (c *clientWrapper) GetTLSOptions() []*v1alpha1.TLSOption { func (c *clientWrapper) GetTLSOptions() []*traefikv1alpha1.TLSOption {
var result []*v1alpha1.TLSOption var result []*traefikv1alpha1.TLSOption
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
options, err := factory.Traefik().V1alpha1().TLSOptions().Lister().List(labels.Everything()) options, err := factory.Traefik().V1alpha1().TLSOptions().Lister().List(labels.Everything())
@ -358,8 +358,8 @@ func (c *clientWrapper) GetTLSOptions() []*v1alpha1.TLSOption {
} }
// GetTLSStores returns all TLS stores. // GetTLSStores returns all TLS stores.
func (c *clientWrapper) GetTLSStores() []*v1alpha1.TLSStore { func (c *clientWrapper) GetTLSStores() []*traefikv1alpha1.TLSStore {
var result []*v1alpha1.TLSStore var result []*traefikv1alpha1.TLSStore
for ns, factory := range c.factoriesCrd { for ns, factory := range c.factoriesCrd {
stores, err := factory.Traefik().V1alpha1().TLSStores().Lister().List(labels.Everything()) stores, err := factory.Traefik().V1alpha1().TLSStores().Lister().List(labels.Everything())
@ -435,7 +435,7 @@ func (c *clientWrapper) isWatchedNamespace(ns string) bool {
// translateNotFoundError will translate a "not found" error to a boolean return // translateNotFoundError will translate a "not found" error to a boolean return
// value which indicates if the resource exists and a nil error. // value which indicates if the resource exists and a nil error.
func translateNotFoundError(err error) (bool, error) { func translateNotFoundError(err error) (bool, error) {
if kubeerror.IsNotFound(err) { if kerror.IsNotFound(err) {
return false, nil return false, nil
} }
return err == nil, err return err == nil, err

70
pkg/provider/kubernetes/crd/client_mock_test.go
View file

@ -5,17 +5,17 @@ import (
"os" "os"
"path/filepath" "path/filepath"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1" traefikv1alpha1 "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s" "github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
"k8s.io/client-go/kubernetes/scheme" kscheme "k8s.io/client-go/kubernetes/scheme"
) )
var _ Client = (*clientMock)(nil) var _ Client = (*clientMock)(nil)
func init() { func init() {
// required by k8s.MustParseYaml // required by k8s.MustParseYaml
err := v1alpha1.AddToScheme(scheme.Scheme) err := traefikv1alpha1.AddToScheme(kscheme.Scheme)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -30,16 +30,16 @@ type clientMock struct {
apiSecretError error apiSecretError error
apiEndpointsError error apiEndpointsError error
ingressRoutes []*v1alpha1.IngressRoute ingressRoutes []*traefikv1alpha1.IngressRoute
ingressRouteTCPs []*v1alpha1.IngressRouteTCP ingressRouteTCPs []*traefikv1alpha1.IngressRouteTCP
ingressRouteUDPs []*v1alpha1.IngressRouteUDP ingressRouteUDPs []*traefikv1alpha1.IngressRouteUDP
middlewares []*v1alpha1.Middleware middlewares []*traefikv1alpha1.Middleware
middlewareTCPs []*v1alpha1.MiddlewareTCP middlewareTCPs []*traefikv1alpha1.MiddlewareTCP
tlsOptions []*v1alpha1.TLSOption tlsOptions []*traefikv1alpha1.TLSOption
tlsStores []*v1alpha1.TLSStore tlsStores []*traefikv1alpha1.TLSStore
traefikServices []*v1alpha1.TraefikService traefikServices []*traefikv1alpha1.TraefikService
serversTransports []*v1alpha1.ServersTransport serversTransports []*traefikv1alpha1.ServersTransport
serversTransportTCPs []*v1alpha1.ServersTransportTCP serversTransportTCPs []*traefikv1alpha1.ServersTransportTCP
watchChan chan interface{} watchChan chan interface{}
} }
@ -60,25 +60,25 @@ func newClientMock(paths ...string) clientMock {
c.services = append(c.services, o) c.services = append(c.services, o)
case *corev1.Endpoints: case *corev1.Endpoints:
c.endpoints = append(c.endpoints, o) c.endpoints = append(c.endpoints, o)
case *v1alpha1.IngressRoute: case *traefikv1alpha1.IngressRoute:
c.ingressRoutes = append(c.ingressRoutes, o) c.ingressRoutes = append(c.ingressRoutes, o)
case *v1alpha1.IngressRouteTCP: case *traefikv1alpha1.IngressRouteTCP:
c.ingressRouteTCPs = append(c.ingressRouteTCPs, o) c.ingressRouteTCPs = append(c.ingressRouteTCPs, o)
case *v1alpha1.IngressRouteUDP: case *traefikv1alpha1.IngressRouteUDP:
c.ingressRouteUDPs = append(c.ingressRouteUDPs, o) c.ingressRouteUDPs = append(c.ingressRouteUDPs, o)
case *v1alpha1.Middleware: case *traefikv1alpha1.Middleware:
c.middlewares = append(c.middlewares, o) c.middlewares = append(c.middlewares, o)
case *v1alpha1.MiddlewareTCP: case *traefikv1alpha1.MiddlewareTCP:
c.middlewareTCPs = append(c.middlewareTCPs, o) c.middlewareTCPs = append(c.middlewareTCPs, o)
case *v1alpha1.TraefikService: case *traefikv1alpha1.TraefikService:
c.traefikServices = append(c.traefikServices, o) c.traefikServices = append(c.traefikServices, o)
case *v1alpha1.TLSOption: case *traefikv1alpha1.TLSOption:
c.tlsOptions = append(c.tlsOptions, o) c.tlsOptions = append(c.tlsOptions, o)
case *v1alpha1.ServersTransport: case *traefikv1alpha1.ServersTransport:
c.serversTransports = append(c.serversTransports, o) c.serversTransports = append(c.serversTransports, o)
case *v1alpha1.ServersTransportTCP: case *traefikv1alpha1.ServersTransportTCP:
c.serversTransportTCPs = append(c.serversTransportTCPs, o) c.serversTransportTCPs = append(c.serversTransportTCPs, o)
case *v1alpha1.TLSStore: case *traefikv1alpha1.TLSStore:
c.tlsStores = append(c.tlsStores, o) c.tlsStores = append(c.tlsStores, o)
case *corev1.Secret: case *corev1.Secret:
c.secrets = append(c.secrets, o) c.secrets = append(c.secrets, o)
@ -91,27 +91,27 @@ func newClientMock(paths ...string) clientMock {
return c return c
} }
func (c clientMock) GetIngressRoutes() []*v1alpha1.IngressRoute { func (c clientMock) GetIngressRoutes() []*traefikv1alpha1.IngressRoute {
return c.ingressRoutes return c.ingressRoutes
} }
func (c clientMock) GetIngressRouteTCPs() []*v1alpha1.IngressRouteTCP { func (c clientMock) GetIngressRouteTCPs() []*traefikv1alpha1.IngressRouteTCP {
return c.ingressRouteTCPs return c.ingressRouteTCPs
} }
func (c clientMock) GetIngressRouteUDPs() []*v1alpha1.IngressRouteUDP { func (c clientMock) GetIngressRouteUDPs() []*traefikv1alpha1.IngressRouteUDP {
return c.ingressRouteUDPs return c.ingressRouteUDPs
} }
func (c clientMock) GetMiddlewares() []*v1alpha1.Middleware { func (c clientMock) GetMiddlewares() []*traefikv1alpha1.Middleware {
return c.middlewares return c.middlewares
} }
func (c clientMock) GetMiddlewareTCPs() []*v1alpha1.MiddlewareTCP { func (c clientMock) GetMiddlewareTCPs() []*traefikv1alpha1.MiddlewareTCP {
return c.middlewareTCPs return c.middlewareTCPs
} }
func (c clientMock) GetTraefikService(namespace, name string) (*v1alpha1.TraefikService, bool, error) { func (c clientMock) GetTraefikService(namespace, name string) (*traefikv1alpha1.TraefikService, bool, error) {
for _, svc := range c.traefikServices { for _, svc := range c.traefikServices {
if svc.Namespace == namespace && svc.Name == name { if svc.Namespace == namespace && svc.Name == name {
return svc, true, nil return svc, true, nil
@ -121,27 +121,27 @@ func (c clientMock) GetTraefikService(namespace, name string) (*v1alpha1.Traefik
return nil, false, nil return nil, false, nil
} }
func (c clientMock) GetTraefikServices() []*v1alpha1.TraefikService { func (c clientMock) GetTraefikServices() []*traefikv1alpha1.TraefikService {
return c.traefikServices return c.traefikServices
} }
func (c clientMock) GetTLSOptions() []*v1alpha1.TLSOption { func (c clientMock) GetTLSOptions() []*traefikv1alpha1.TLSOption {
return c.tlsOptions return c.tlsOptions
} }
func (c clientMock) GetTLSStores() []*v1alpha1.TLSStore { func (c clientMock) GetTLSStores() []*traefikv1alpha1.TLSStore {
return c.tlsStores return c.tlsStores
} }
func (c clientMock) GetServersTransports() []*v1alpha1.ServersTransport { func (c clientMock) GetServersTransports() []*traefikv1alpha1.ServersTransport {
return c.serversTransports return c.serversTransports
} }
func (c clientMock) GetServersTransportTCPs() []*v1alpha1.ServersTransportTCP { func (c clientMock) GetServersTransportTCPs() []*traefikv1alpha1.ServersTransportTCP {
return c.serversTransportTCPs return c.serversTransportTCPs
} }
func (c clientMock) GetTLSOption(namespace, name string) (*v1alpha1.TLSOption, bool, error) { func (c clientMock) GetTLSOption(namespace, name string) (*traefikv1alpha1.TLSOption, bool, error) {
for _, option := range c.tlsOptions { for _, option := range c.tlsOptions {
if option.Namespace == namespace && option.Name == name { if option.Namespace == namespace && option.Name == name {
return option, true, nil return option, true, nil

4
pkg/provider/kubernetes/crd/client_test.go
View file

@ -6,7 +6,7 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
crdfake "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned/fake" traefikcrdfake "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned/fake"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
kubefake "k8s.io/client-go/kubernetes/fake" kubefake "k8s.io/client-go/kubernetes/fake"
@ -30,7 +30,7 @@ func TestClientIgnoresHelmOwnedSecrets(t *testing.T) {
} }
kubeClient := kubefake.NewSimpleClientset(helmSecret, secret) kubeClient := kubefake.NewSimpleClientset(helmSecret, secret)
crdClient := crdfake.NewSimpleClientset() crdClient := traefikcrdfake.NewSimpleClientset()
client := newClientImpl(kubeClient, crdClient) client := newClientImpl(kubeClient, crdClient)

6
pkg/provider/kubernetes/crd/generated/clientset/versioned/fake/clientset_generated.go
View file

@ -33,7 +33,7 @@ import (
"k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/watch" "k8s.io/apimachinery/pkg/watch"
"k8s.io/client-go/discovery" "k8s.io/client-go/discovery"
fakediscovery "k8s.io/client-go/discovery/fake" discoveryfake "k8s.io/client-go/discovery/fake"
"k8s.io/client-go/testing" "k8s.io/client-go/testing"
) )
@ -50,7 +50,7 @@ func NewSimpleClientset(objects ...runtime.Object) *Clientset {
} }
cs := &Clientset{tracker: o} cs := &Clientset{tracker: o}
cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake} cs.discovery = &discoveryfake.FakeDiscovery{Fake: &cs.Fake}
cs.AddReactor("*", "*", testing.ObjectReaction(o)) cs.AddReactor("*", "*", testing.ObjectReaction(o))
cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) { cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
gvr := action.GetResource() gvr := action.GetResource()
@ -70,7 +70,7 @@ func NewSimpleClientset(objects ...runtime.Object) *Clientset {
// you want to test easier. // you want to test easier.
type Clientset struct { type Clientset struct {
testing.Fake testing.Fake
discovery *fakediscovery.FakeDiscovery discovery *discoveryfake.FakeDiscovery
tracker testing.ObjectTracker tracker testing.ObjectTracker
} }

20
pkg/provider/kubernetes/crd/kubernetes.go
View file

@ -25,7 +25,7 @@ import (
"github.com/traefik/traefik/v3/pkg/job" "github.com/traefik/traefik/v3/pkg/job"
"github.com/traefik/traefik/v3/pkg/logs" "github.com/traefik/traefik/v3/pkg/logs"
"github.com/traefik/traefik/v3/pkg/provider" "github.com/traefik/traefik/v3/pkg/provider"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1" traefikv1alpha1 "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1"
"github.com/traefik/traefik/v3/pkg/safe" "github.com/traefik/traefik/v3/pkg/safe"
"github.com/traefik/traefik/v3/pkg/tls" "github.com/traefik/traefik/v3/pkg/tls"
"github.com/traefik/traefik/v3/pkg/types" "github.com/traefik/traefik/v3/pkg/types"
@ -598,7 +598,7 @@ func getSecretValue(c Client, ns, urn string) (string, error) {
return string(secretValue), nil return string(secretValue), nil
} }
func createCircuitBreakerMiddleware(circuitBreaker *v1alpha1.CircuitBreaker) (*dynamic.CircuitBreaker, error) { func createCircuitBreakerMiddleware(circuitBreaker *traefikv1alpha1.CircuitBreaker) (*dynamic.CircuitBreaker, error) {
if circuitBreaker == nil { if circuitBreaker == nil {
return nil, nil return nil, nil
} }
@ -627,7 +627,7 @@ func createCircuitBreakerMiddleware(circuitBreaker *v1alpha1.CircuitBreaker) (*d
return cb, nil return cb, nil
} }
func createRateLimitMiddleware(rateLimit *v1alpha1.RateLimit) (*dynamic.RateLimit, error) { func createRateLimitMiddleware(rateLimit *traefikv1alpha1.RateLimit) (*dynamic.RateLimit, error) {
if rateLimit == nil { if rateLimit == nil {
return nil, nil return nil, nil
} }
@ -653,7 +653,7 @@ func createRateLimitMiddleware(rateLimit *v1alpha1.RateLimit) (*dynamic.RateLimi
return rl, nil return rl, nil
} }
func createRetryMiddleware(retry *v1alpha1.Retry) (*dynamic.Retry, error) { func createRetryMiddleware(retry *traefikv1alpha1.Retry) (*dynamic.Retry, error) {
if retry == nil { if retry == nil {
return nil, nil return nil, nil
} }
@ -668,7 +668,7 @@ func createRetryMiddleware(retry *v1alpha1.Retry) (*dynamic.Retry, error) {
return r, nil return r, nil
} }
func (p *Provider) createErrorPageMiddleware(client Client, namespace string, errorPage *v1alpha1.ErrorPage) (*dynamic.ErrorPage, *dynamic.Service, error) { func (p *Provider) createErrorPageMiddleware(client Client, namespace string, errorPage *traefikv1alpha1.ErrorPage) (*dynamic.ErrorPage, *dynamic.Service, error) {
if errorPage == nil { if errorPage == nil {
return nil, nil, nil return nil, nil, nil
} }
@ -693,7 +693,7 @@ func (p *Provider) createErrorPageMiddleware(client Client, namespace string, er
return errorPageMiddleware, balancerServerHTTP, nil return errorPageMiddleware, balancerServerHTTP, nil
} }
func createForwardAuthMiddleware(k8sClient Client, namespace string, auth *v1alpha1.ForwardAuth) (*dynamic.ForwardAuth, error) { func createForwardAuthMiddleware(k8sClient Client, namespace string, auth *traefikv1alpha1.ForwardAuth) (*dynamic.ForwardAuth, error) {
if auth == nil { if auth == nil {
return nil, nil return nil, nil
} }
@ -784,7 +784,7 @@ func loadAuthTLSSecret(namespace, secretName string, k8sClient Client) (string,
return getCertificateBlocks(secret, namespace, secretName) return getCertificateBlocks(secret, namespace, secretName)
} }
func createBasicAuthMiddleware(client Client, namespace string, basicAuth *v1alpha1.BasicAuth) (*dynamic.BasicAuth, error) { func createBasicAuthMiddleware(client Client, namespace string, basicAuth *traefikv1alpha1.BasicAuth) (*dynamic.BasicAuth, error) {
if basicAuth == nil { if basicAuth == nil {
return nil, nil return nil, nil
} }
@ -831,7 +831,7 @@ func createBasicAuthMiddleware(client Client, namespace string, basicAuth *v1alp
}, nil }, nil
} }
func createDigestAuthMiddleware(client Client, namespace string, digestAuth *v1alpha1.DigestAuth) (*dynamic.DigestAuth, error) { func createDigestAuthMiddleware(client Client, namespace string, digestAuth *traefikv1alpha1.DigestAuth) (*dynamic.DigestAuth, error) {
if digestAuth == nil { if digestAuth == nil {
return nil, nil return nil, nil
} }
@ -906,7 +906,7 @@ func loadAuthCredentials(secret *corev1.Secret) ([]string, error) {
return credentials, nil return credentials, nil
} }
func createChainMiddleware(ctx context.Context, namespace string, chain *v1alpha1.Chain) *dynamic.Chain { func createChainMiddleware(ctx context.Context, namespace string, chain *traefikv1alpha1.Chain) *dynamic.Chain {
if chain == nil { if chain == nil {
return nil return nil
} }
@ -1071,7 +1071,7 @@ func buildTLSStores(ctx context.Context, client Client) (map[string]tls.Store, m
} }
// buildCertificates loads TLSStore certificates from secrets and sets them into tlsConfigs. // buildCertificates loads TLSStore certificates from secrets and sets them into tlsConfigs.
func buildCertificates(client Client, tlsStore, namespace string, certificates []v1alpha1.Certificate, tlsConfigs map[string]*tls.CertAndStores) error { func buildCertificates(client Client, tlsStore, namespace string, certificates []traefikv1alpha1.Certificate, tlsConfigs map[string]*tls.CertAndStores) error {
for _, c := range certificates { for _, c := range certificates {
configKey := namespace + "/" + c.SecretName configKey := namespace + "/" + c.SecretName
if _, tlsExists := tlsConfigs[configKey]; !tlsExists { if _, tlsExists := tlsConfigs[configKey]; !tlsExists {

26
pkg/provider/kubernetes/crd/kubernetes_http.go
View file

@ -12,7 +12,7 @@ import (
"github.com/traefik/traefik/v3/pkg/config/dynamic" "github.com/traefik/traefik/v3/pkg/config/dynamic"
"github.com/traefik/traefik/v3/pkg/logs" "github.com/traefik/traefik/v3/pkg/logs"
"github.com/traefik/traefik/v3/pkg/provider" "github.com/traefik/traefik/v3/pkg/provider"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1" traefikv1alpha1 "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1"
"github.com/traefik/traefik/v3/pkg/tls" "github.com/traefik/traefik/v3/pkg/tls"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/intstr"
@ -84,8 +84,8 @@ func (p *Provider) loadIngressRouteConfiguration(ctx context.Context, client Cli
serviceName := normalized serviceName := normalized
if len(route.Services) > 1 { if len(route.Services) > 1 {
spec := v1alpha1.TraefikServiceSpec{ spec := traefikv1alpha1.TraefikServiceSpec{
Weighted: &v1alpha1.WeightedRoundRobin{ Weighted: &traefikv1alpha1.WeightedRoundRobin{
Services: route.Services, Services: route.Services,
}, },
} }
@ -155,7 +155,7 @@ func (p *Provider) loadIngressRouteConfiguration(ctx context.Context, client Cli
return conf return conf
} }
func (p *Provider) makeMiddlewareKeys(ctx context.Context, ingRouteNamespace string, middlewares []v1alpha1.MiddlewareRef) ([]string, error) { func (p *Provider) makeMiddlewareKeys(ctx context.Context, ingRouteNamespace string, middlewares []traefikv1alpha1.MiddlewareRef) ([]string, error) {
var mds []string var mds []string
for _, mi := range middlewares { for _, mi := range middlewares {
@ -203,7 +203,7 @@ type configBuilder struct {
// buildTraefikService creates the configuration for the traefik service defined in tService, // buildTraefikService creates the configuration for the traefik service defined in tService,
// and adds it to the given conf map. // and adds it to the given conf map.
func (c configBuilder) buildTraefikService(ctx context.Context, tService *v1alpha1.TraefikService, conf map[string]*dynamic.Service) error { func (c configBuilder) buildTraefikService(ctx context.Context, tService *traefikv1alpha1.TraefikService, conf map[string]*dynamic.Service) error {
id := provider.Normalize(makeID(tService.Namespace, tService.Name)) id := provider.Normalize(makeID(tService.Namespace, tService.Name))
if tService.Spec.Weighted != nil { if tService.Spec.Weighted != nil {
@ -217,7 +217,7 @@ func (c configBuilder) buildTraefikService(ctx context.Context, tService *v1alph
// buildServicesLB creates the configuration for the load-balancer of services named id, and defined in tService. // buildServicesLB creates the configuration for the load-balancer of services named id, and defined in tService.
// It adds it to the given conf map. // It adds it to the given conf map.
func (c configBuilder) buildServicesLB(ctx context.Context, namespace string, tService v1alpha1.TraefikServiceSpec, id string, conf map[string]*dynamic.Service) error { func (c configBuilder) buildServicesLB(ctx context.Context, namespace string, tService traefikv1alpha1.TraefikServiceSpec, id string, conf map[string]*dynamic.Service) error {
var wrrServices []dynamic.WRRService var wrrServices []dynamic.WRRService
for _, service := range tService.Weighted.Services { for _, service := range tService.Weighted.Services {
@ -252,7 +252,7 @@ func (c configBuilder) buildServicesLB(ctx context.Context, namespace string, tS
// buildMirroring creates the configuration for the mirroring service named id, and defined by tService. // buildMirroring creates the configuration for the mirroring service named id, and defined by tService.
// It adds it to the given conf map. // It adds it to the given conf map.
func (c configBuilder) buildMirroring(ctx context.Context, tService *v1alpha1.TraefikService, id string, conf map[string]*dynamic.Service) error { func (c configBuilder) buildMirroring(ctx context.Context, tService *traefikv1alpha1.TraefikService, id string, conf map[string]*dynamic.Service) error {
fullNameMain, k8sService, err := c.nameAndService(ctx, tService.Namespace, tService.Spec.Mirroring.LoadBalancerSpec) fullNameMain, k8sService, err := c.nameAndService(ctx, tService.Namespace, tService.Spec.Mirroring.LoadBalancerSpec)
if err != nil { if err != nil {
return err return err
@ -291,7 +291,7 @@ func (c configBuilder) buildMirroring(ctx context.Context, tService *v1alpha1.Tr
} }
// buildServersLB creates the configuration for the load-balancer of servers defined by svc. // buildServersLB creates the configuration for the load-balancer of servers defined by svc.
func (c configBuilder) buildServersLB(namespace string, svc v1alpha1.LoadBalancerSpec) (*dynamic.Service, error) { func (c configBuilder) buildServersLB(namespace string, svc traefikv1alpha1.LoadBalancerSpec) (*dynamic.Service, error) {
servers, err := c.loadServers(namespace, svc) servers, err := c.loadServers(namespace, svc)
if err != nil { if err != nil {
return nil, err return nil, err
@ -344,7 +344,7 @@ func (c *configBuilder) makeServersTransportKey(parentNamespace string, serversT
return provider.Normalize(makeID(parentNamespace, serversTransportName)), nil return provider.Normalize(makeID(parentNamespace, serversTransportName)), nil
} }
func (c configBuilder) loadServers(parentNamespace string, svc v1alpha1.LoadBalancerSpec) ([]dynamic.Server, error) { func (c configBuilder) loadServers(parentNamespace string, svc traefikv1alpha1.LoadBalancerSpec) ([]dynamic.Server, error) {
strategy := svc.Strategy strategy := svc.Strategy
if strategy == "" { if strategy == "" {
strategy = roundRobinStrategy strategy = roundRobinStrategy
@ -452,7 +452,7 @@ func (c configBuilder) loadServers(parentNamespace string, svc v1alpha1.LoadBala
// In addition, if the service is a Kubernetes one, // In addition, if the service is a Kubernetes one,
// it generates and returns the configuration part for such a service, // it generates and returns the configuration part for such a service,
// so that the caller can add it to the global config map. // so that the caller can add it to the global config map.
func (c configBuilder) nameAndService(ctx context.Context, parentNamespace string, service v1alpha1.LoadBalancerSpec) (string, *dynamic.Service, error) { func (c configBuilder) nameAndService(ctx context.Context, parentNamespace string, service traefikv1alpha1.LoadBalancerSpec) (string, *dynamic.Service, error) {
svcCtx := log.Ctx(ctx).With().Str(logs.ServiceName, service.Name).Logger().WithContext(ctx) svcCtx := log.Ctx(ctx).With().Str(logs.ServiceName, service.Name).Logger().WithContext(ctx)
namespace := namespaceOrFallback(service, parentNamespace) namespace := namespaceOrFallback(service, parentNamespace)
@ -487,7 +487,7 @@ func splitSvcNameProvider(name string) (string, string) {
return svc, pvd return svc, pvd
} }
func fullServiceName(ctx context.Context, namespace string, service v1alpha1.LoadBalancerSpec, port intstr.IntOrString) string { func fullServiceName(ctx context.Context, namespace string, service traefikv1alpha1.LoadBalancerSpec, port intstr.IntOrString) string {
if (port.Type == intstr.Int && port.IntVal != 0) || (port.Type == intstr.String && port.StrVal != "") { if (port.Type == intstr.Int && port.IntVal != 0) || (port.Type == intstr.String && port.StrVal != "") {
return provider.Normalize(fmt.Sprintf("%s-%s-%s", namespace, service.Name, &port)) return provider.Normalize(fmt.Sprintf("%s-%s-%s", namespace, service.Name, &port))
} }
@ -508,7 +508,7 @@ func fullServiceName(ctx context.Context, namespace string, service v1alpha1.Loa
return provider.Normalize(name) + providerNamespaceSeparator + pName return provider.Normalize(name) + providerNamespaceSeparator + pName
} }
func namespaceOrFallback(lb v1alpha1.LoadBalancerSpec, fallback string) string { func namespaceOrFallback(lb traefikv1alpha1.LoadBalancerSpec, fallback string) string {
if lb.Namespace != "" { if lb.Namespace != "" {
return lb.Namespace return lb.Namespace
} }
@ -516,7 +516,7 @@ func namespaceOrFallback(lb v1alpha1.LoadBalancerSpec, fallback string) string {
} }
// getTLSHTTP mutates tlsConfigs. // getTLSHTTP mutates tlsConfigs.
func getTLSHTTP(ctx context.Context, ingressRoute *v1alpha1.IngressRoute, k8sClient Client, tlsConfigs map[string]*tls.CertAndStores) error { func getTLSHTTP(ctx context.Context, ingressRoute *traefikv1alpha1.IngressRoute, k8sClient Client, tlsConfigs map[string]*tls.CertAndStores) error {
if ingressRoute.Spec.TLS == nil { if ingressRoute.Spec.TLS == nil {
return nil return nil
} }

10
pkg/provider/kubernetes/crd/kubernetes_tcp.go
View file

@ -12,7 +12,7 @@ import (
"github.com/traefik/traefik/v3/pkg/config/dynamic" "github.com/traefik/traefik/v3/pkg/config/dynamic"
"github.com/traefik/traefik/v3/pkg/logs" "github.com/traefik/traefik/v3/pkg/logs"
"github.com/traefik/traefik/v3/pkg/provider" "github.com/traefik/traefik/v3/pkg/provider"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1" traefikv1alpha1 "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1"
"github.com/traefik/traefik/v3/pkg/tls" "github.com/traefik/traefik/v3/pkg/tls"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
) )
@ -144,7 +144,7 @@ func (p *Provider) loadIngressRouteTCPConfiguration(ctx context.Context, client
return conf return conf
} }
func (p *Provider) makeMiddlewareTCPKeys(ctx context.Context, ingRouteTCPNamespace string, middlewares []v1alpha1.ObjectReference) ([]string, error) { func (p *Provider) makeMiddlewareTCPKeys(ctx context.Context, ingRouteTCPNamespace string, middlewares []traefikv1alpha1.ObjectReference) ([]string, error) {
var mds []string var mds []string
for _, mi := range middlewares { for _, mi := range middlewares {
@ -173,7 +173,7 @@ func (p *Provider) makeMiddlewareTCPKeys(ctx context.Context, ingRouteTCPNamespa
return mds, nil return mds, nil
} }
func (p *Provider) createLoadBalancerServerTCP(client Client, parentNamespace string, service v1alpha1.ServiceTCP) (*dynamic.TCPService, error) { func (p *Provider) createLoadBalancerServerTCP(client Client, parentNamespace string, service traefikv1alpha1.ServiceTCP) (*dynamic.TCPService, error) {
ns := parentNamespace ns := parentNamespace
if len(service.Namespace) > 0 { if len(service.Namespace) > 0 {
if !isNamespaceAllowed(p.AllowCrossNamespace, parentNamespace, service.Namespace) { if !isNamespaceAllowed(p.AllowCrossNamespace, parentNamespace, service.Namespace) {
@ -213,7 +213,7 @@ func (p *Provider) createLoadBalancerServerTCP(client Client, parentNamespace st
return tcpService, nil return tcpService, nil
} }
func (p *Provider) loadTCPServers(client Client, namespace string, svc v1alpha1.ServiceTCP) ([]dynamic.TCPServer, error) { func (p *Provider) loadTCPServers(client Client, namespace string, svc traefikv1alpha1.ServiceTCP) ([]dynamic.TCPServer, error) {
service, exists, err := client.GetService(namespace, svc.Name) service, exists, err := client.GetService(namespace, svc.Name)
if err != nil { if err != nil {
return nil, err return nil, err
@ -304,7 +304,7 @@ func (p *Provider) makeTCPServersTransportKey(parentNamespace string, serversTra
} }
// getTLSTCP mutates tlsConfigs. // getTLSTCP mutates tlsConfigs.
func getTLSTCP(ctx context.Context, ingressRoute *v1alpha1.IngressRouteTCP, k8sClient Client, tlsConfigs map[string]*tls.CertAndStores) error { func getTLSTCP(ctx context.Context, ingressRoute *traefikv1alpha1.IngressRouteTCP, k8sClient Client, tlsConfigs map[string]*tls.CertAndStores) error {
if ingressRoute.Spec.TLS == nil { if ingressRoute.Spec.TLS == nil {
return nil return nil
} }

66
pkg/provider/kubernetes/crd/kubernetes_test.go
View file

@ -14,8 +14,8 @@ import (
ptypes "github.com/traefik/paerser/types" ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v3/pkg/config/dynamic" "github.com/traefik/traefik/v3/pkg/config/dynamic"
"github.com/traefik/traefik/v3/pkg/provider" "github.com/traefik/traefik/v3/pkg/provider"
crdfake "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned/fake" traefikcrdfake "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/generated/clientset/versioned/fake"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1" traefikv1alpha1 "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s" "github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s"
"github.com/traefik/traefik/v3/pkg/tls" "github.com/traefik/traefik/v3/pkg/tls"
"github.com/traefik/traefik/v3/pkg/types" "github.com/traefik/traefik/v3/pkg/types"
@ -6400,25 +6400,25 @@ func TestCrossNamespace(t *testing.T) {
switch o := obj.(type) { switch o := obj.(type) {
case *corev1.Service, *corev1.Endpoints, *corev1.Secret: case *corev1.Service, *corev1.Endpoints, *corev1.Secret:
k8sObjects = append(k8sObjects, o) k8sObjects = append(k8sObjects, o)
case *v1alpha1.IngressRoute: case *traefikv1alpha1.IngressRoute:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.IngressRouteTCP: case *traefikv1alpha1.IngressRouteTCP:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.IngressRouteUDP: case *traefikv1alpha1.IngressRouteUDP:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.Middleware: case *traefikv1alpha1.Middleware:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.MiddlewareTCP: case *traefikv1alpha1.MiddlewareTCP:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TraefikService: case *traefikv1alpha1.TraefikService:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TLSOption: case *traefikv1alpha1.TLSOption:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TLSStore: case *traefikv1alpha1.TLSStore:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.ServersTransport: case *traefikv1alpha1.ServersTransport:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.ServersTransportTCP: case *traefikv1alpha1.ServersTransportTCP:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
default: default:
} }
@ -6426,7 +6426,7 @@ func TestCrossNamespace(t *testing.T) {
} }
kubeClient := kubefake.NewSimpleClientset(k8sObjects...) kubeClient := kubefake.NewSimpleClientset(k8sObjects...)
crdClient := crdfake.NewSimpleClientset(crdObjects...) crdClient := traefikcrdfake.NewSimpleClientset(crdObjects...)
client := newClientImpl(kubeClient, crdClient) client := newClientImpl(kubeClient, crdClient)
@ -6707,19 +6707,19 @@ func TestExternalNameService(t *testing.T) {
switch o := obj.(type) { switch o := obj.(type) {
case *corev1.Service, *corev1.Endpoints, *corev1.Secret: case *corev1.Service, *corev1.Endpoints, *corev1.Secret:
k8sObjects = append(k8sObjects, o) k8sObjects = append(k8sObjects, o)
case *v1alpha1.IngressRoute: case *traefikv1alpha1.IngressRoute:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.IngressRouteTCP: case *traefikv1alpha1.IngressRouteTCP:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.IngressRouteUDP: case *traefikv1alpha1.IngressRouteUDP:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.Middleware: case *traefikv1alpha1.Middleware:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TraefikService: case *traefikv1alpha1.TraefikService:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TLSOption: case *traefikv1alpha1.TLSOption:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TLSStore: case *traefikv1alpha1.TLSStore:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
default: default:
} }
@ -6727,7 +6727,7 @@ func TestExternalNameService(t *testing.T) {
} }
kubeClient := kubefake.NewSimpleClientset(k8sObjects...) kubeClient := kubefake.NewSimpleClientset(k8sObjects...)
crdClient := crdfake.NewSimpleClientset(crdObjects...) crdClient := traefikcrdfake.NewSimpleClientset(crdObjects...)
client := newClientImpl(kubeClient, crdClient) client := newClientImpl(kubeClient, crdClient)
@ -6920,19 +6920,19 @@ func TestNativeLB(t *testing.T) {
switch o := obj.(type) { switch o := obj.(type) {
case *corev1.Service, *corev1.Endpoints, *corev1.Secret: case *corev1.Service, *corev1.Endpoints, *corev1.Secret:
k8sObjects = append(k8sObjects, o) k8sObjects = append(k8sObjects, o)
case *v1alpha1.IngressRoute: case *traefikv1alpha1.IngressRoute:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.IngressRouteTCP: case *traefikv1alpha1.IngressRouteTCP:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.IngressRouteUDP: case *traefikv1alpha1.IngressRouteUDP:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.Middleware: case *traefikv1alpha1.Middleware:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TraefikService: case *traefikv1alpha1.TraefikService:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TLSOption: case *traefikv1alpha1.TLSOption:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
case *v1alpha1.TLSStore: case *traefikv1alpha1.TLSStore:
crdObjects = append(crdObjects, o) crdObjects = append(crdObjects, o)
default: default:
} }
@ -6940,7 +6940,7 @@ func TestNativeLB(t *testing.T) {
} }
kubeClient := kubefake.NewSimpleClientset(k8sObjects...) kubeClient := kubefake.NewSimpleClientset(k8sObjects...)
crdClient := crdfake.NewSimpleClientset(crdObjects...) crdClient := traefikcrdfake.NewSimpleClientset(crdObjects...)
client := newClientImpl(kubeClient, crdClient) client := newClientImpl(kubeClient, crdClient)
@ -6980,7 +6980,7 @@ func TestCreateBasicAuthCredentials(t *testing.T) {
} }
kubeClient := kubefake.NewSimpleClientset(k8sObjects...) kubeClient := kubefake.NewSimpleClientset(k8sObjects...)
crdClient := crdfake.NewSimpleClientset(crdObjects...) crdClient := traefikcrdfake.NewSimpleClientset(crdObjects...)
client := newClientImpl(kubeClient, crdClient) client := newClientImpl(kubeClient, crdClient)
@ -6989,13 +6989,13 @@ func TestCreateBasicAuthCredentials(t *testing.T) {
eventCh, err := client.WatchAll([]string{"default"}, stopCh) eventCh, err := client.WatchAll([]string{"default"}, stopCh)
require.NoError(t, err) require.NoError(t, err)
if k8sObjects != nil || crdObjects != nil { if len(k8sObjects) != 0 || len(crdObjects) != 0 {
// just wait for the first event // just wait for the first event
<-eventCh <-eventCh
} }
// Testing for username/password components in basic-auth secret // Testing for username/password components in basic-auth secret
basicAuth, secretErr := createBasicAuthMiddleware(client, "default", &v1alpha1.BasicAuth{Secret: "basic-auth-secret"}) basicAuth, secretErr := createBasicAuthMiddleware(client, "default", &traefikv1alpha1.BasicAuth{Secret: "basic-auth-secret"})
require.NoError(t, secretErr) require.NoError(t, secretErr)
require.Len(t, basicAuth.Users, 1) require.Len(t, basicAuth.Users, 1)
@ -7010,7 +7010,7 @@ func TestCreateBasicAuthCredentials(t *testing.T) {
assert.True(t, auth.CheckSecret("password", hashedPassword)) assert.True(t, auth.CheckSecret("password", hashedPassword))
// Testing for username/password components in htpasswd secret // Testing for username/password components in htpasswd secret
basicAuth, secretErr = createBasicAuthMiddleware(client, "default", &v1alpha1.BasicAuth{Secret: "auth-secret"}) basicAuth, secretErr = createBasicAuthMiddleware(client, "default", &traefikv1alpha1.BasicAuth{Secret: "auth-secret"})
require.NoError(t, secretErr) require.NoError(t, secretErr)
require.Len(t, basicAuth.Users, 2) require.Len(t, basicAuth.Users, 2)

6
pkg/provider/kubernetes/crd/kubernetes_udp.go
View file

@ -9,7 +9,7 @@ import (
"github.com/rs/zerolog/log" "github.com/rs/zerolog/log"
"github.com/traefik/traefik/v3/pkg/config/dynamic" "github.com/traefik/traefik/v3/pkg/config/dynamic"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1" traefikv1alpha1 "github.com/traefik/traefik/v3/pkg/provider/kubernetes/crd/traefikio/v1alpha1"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
) )
@ -78,7 +78,7 @@ func (p *Provider) loadIngressRouteUDPConfiguration(ctx context.Context, client
return conf return conf
} }
func (p *Provider) createLoadBalancerServerUDP(client Client, parentNamespace string, service v1alpha1.ServiceUDP) (*dynamic.UDPService, error) { func (p *Provider) createLoadBalancerServerUDP(client Client, parentNamespace string, service traefikv1alpha1.ServiceUDP) (*dynamic.UDPService, error) {
ns := parentNamespace ns := parentNamespace
if len(service.Namespace) > 0 { if len(service.Namespace) > 0 {
if !isNamespaceAllowed(p.AllowCrossNamespace, parentNamespace, service.Namespace) { if !isNamespaceAllowed(p.AllowCrossNamespace, parentNamespace, service.Namespace) {
@ -102,7 +102,7 @@ func (p *Provider) createLoadBalancerServerUDP(client Client, parentNamespace st
return udpService, nil return udpService, nil
} }
func (p *Provider) loadUDPServers(client Client, namespace string, svc v1alpha1.ServiceUDP) ([]dynamic.UDPServer, error) { func (p *Provider) loadUDPServers(client Client, namespace string, svc traefikv1alpha1.ServiceUDP) ([]dynamic.UDPServer, error) {
service, exists, err := client.GetService(namespace, svc.Name) service, exists, err := client.GetService(namespace, svc.Name)
if err != nil { if err != nil {
return nil, err return nil, err

8
pkg/provider/kubernetes/crd/traefikio/v1alpha1/register.go
View file

@ -3,7 +3,7 @@ package v1alpha1
import ( import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema" kschema "k8s.io/apimachinery/pkg/runtime/schema"
) )
// GroupName is the group name for Traefik. // GroupName is the group name for Traefik.
@ -18,15 +18,15 @@ var (
) )
// SchemeGroupVersion is group version used to register these objects. // SchemeGroupVersion is group version used to register these objects.
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"} var SchemeGroupVersion = kschema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
// Kind takes an unqualified kind and returns back a Group qualified GroupKind. // Kind takes an unqualified kind and returns back a Group qualified GroupKind.
func Kind(kind string) schema.GroupKind { func Kind(kind string) kschema.GroupKind {
return SchemeGroupVersion.WithKind(kind).GroupKind() return SchemeGroupVersion.WithKind(kind).GroupKind()
} }
// Resource takes an unqualified resource and returns a Group qualified GroupResource. // Resource takes an unqualified resource and returns a Group qualified GroupResource.
func Resource(resource string) schema.GroupResource { func Resource(resource string) kschema.GroupResource {
return SchemeGroupVersion.WithResource(resource).GroupResource() return SchemeGroupVersion.WithResource(resource).GroupResource()
} }

90
pkg/provider/kubernetes/gateway/client.go
View file

@ -9,16 +9,16 @@ import (
"github.com/rs/zerolog/log" "github.com/rs/zerolog/log"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
kubeerror "k8s.io/apimachinery/pkg/api/errors" kerror "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/informers" kinformers "k8s.io/client-go/informers"
"k8s.io/client-go/kubernetes" kclientset "k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest" "k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd" "k8s.io/client-go/tools/clientcmd"
"sigs.k8s.io/gateway-api/apis/v1alpha2" gatev1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
"sigs.k8s.io/gateway-api/pkg/client/clientset/gateway/versioned" gateclientset "sigs.k8s.io/gateway-api/pkg/client/clientset/gateway/versioned"
"sigs.k8s.io/gateway-api/pkg/client/informers/gateway/externalversions" gateinformers "sigs.k8s.io/gateway-api/pkg/client/informers/gateway/externalversions"
) )
const resyncPeriod = 10 * time.Minute const resyncPeriod = 10 * time.Minute
@ -33,7 +33,7 @@ func (reh *resourceEventHandler) OnAdd(obj interface{}) {
func (reh *resourceEventHandler) OnUpdate(oldObj, newObj interface{}) { func (reh *resourceEventHandler) OnUpdate(oldObj, newObj interface{}) {
switch oldObj.(type) { switch oldObj.(type) {
case *v1alpha2.GatewayClass: case *gatev1alpha2.GatewayClass:
// Skip update for gateway classes. We only manage addition or deletion for this cluster-wide resource. // Skip update for gateway classes. We only manage addition or deletion for this cluster-wide resource.
return return
default: default:
@ -50,13 +50,13 @@ func (reh *resourceEventHandler) OnDelete(obj interface{}) {
// The stores can then be accessed via the Get* functions. // The stores can then be accessed via the Get* functions.
type Client interface { type Client interface {
WatchAll(namespaces []string, stopCh <-chan struct{}) (<-chan interface{}, error) WatchAll(namespaces []string, stopCh <-chan struct{}) (<-chan interface{}, error)
GetGatewayClasses() ([]*v1alpha2.GatewayClass, error) GetGatewayClasses() ([]*gatev1alpha2.GatewayClass, error)
UpdateGatewayStatus(gateway *v1alpha2.Gateway, gatewayStatus v1alpha2.GatewayStatus) error UpdateGatewayStatus(gateway *gatev1alpha2.Gateway, gatewayStatus gatev1alpha2.GatewayStatus) error
UpdateGatewayClassStatus(gatewayClass *v1alpha2.GatewayClass, condition metav1.Condition) error UpdateGatewayClassStatus(gatewayClass *gatev1alpha2.GatewayClass, condition metav1.Condition) error
GetGateways() []*v1alpha2.Gateway GetGateways() []*gatev1alpha2.Gateway
GetHTTPRoutes(namespaces []string) ([]*v1alpha2.HTTPRoute, error) GetHTTPRoutes(namespaces []string) ([]*gatev1alpha2.HTTPRoute, error)
GetTCPRoutes(namespaces []string) ([]*v1alpha2.TCPRoute, error) GetTCPRoutes(namespaces []string) ([]*gatev1alpha2.TCPRoute, error)
GetTLSRoutes(namespaces []string) ([]*v1alpha2.TLSRoute, error) GetTLSRoutes(namespaces []string) ([]*gatev1alpha2.TLSRoute, error)
GetService(namespace, name string) (*corev1.Service, bool, error) GetService(namespace, name string) (*corev1.Service, bool, error)
GetSecret(namespace, name string) (*corev1.Secret, bool, error) GetSecret(namespace, name string) (*corev1.Secret, bool, error)
GetEndpoints(namespace, name string) (*corev1.Endpoints, bool, error) GetEndpoints(namespace, name string) (*corev1.Endpoints, bool, error)
@ -64,14 +64,14 @@ type Client interface {
} }
type clientWrapper struct { type clientWrapper struct {
csGateway versioned.Interface csGateway gateclientset.Interface
csKube kubernetes.Interface csKube kclientset.Interface
factoryNamespace informers.SharedInformerFactory factoryNamespace kinformers.SharedInformerFactory
factoryGatewayClass externalversions.SharedInformerFactory factoryGatewayClass gateinformers.SharedInformerFactory
factoriesGateway map[string]externalversions.SharedInformerFactory factoriesGateway map[string]gateinformers.SharedInformerFactory
factoriesKube map[string]informers.SharedInformerFactory factoriesKube map[string]kinformers.SharedInformerFactory
factoriesSecret map[string]informers.SharedInformerFactory factoriesSecret map[string]kinformers.SharedInformerFactory
isNamespaceAll bool isNamespaceAll bool
watchedNamespaces []string watchedNamespaces []string
@ -80,12 +80,12 @@ type clientWrapper struct {
} }
func createClientFromConfig(c *rest.Config) (*clientWrapper, error) { func createClientFromConfig(c *rest.Config) (*clientWrapper, error) {
csGateway, err := versioned.NewForConfig(c) csGateway, err := gateclientset.NewForConfig(c)
if err != nil { if err != nil {
return nil, err return nil, err
} }
csKube, err := kubernetes.NewForConfig(c) csKube, err := kclientset.NewForConfig(c)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -93,13 +93,13 @@ func createClientFromConfig(c *rest.Config) (*clientWrapper, error) {
return newClientImpl(csKube, csGateway), nil return newClientImpl(csKube, csGateway), nil
} }
func newClientImpl(csKube kubernetes.Interface, csGateway versioned.Interface) *clientWrapper { func newClientImpl(csKube kclientset.Interface, csGateway gateclientset.Interface) *clientWrapper {
return &clientWrapper{ return &clientWrapper{
csGateway: csGateway, csGateway: csGateway,
csKube: csKube, csKube: csKube,
factoriesGateway: make(map[string]externalversions.SharedInformerFactory), factoriesGateway: make(map[string]gateinformers.SharedInformerFactory),
factoriesKube: make(map[string]informers.SharedInformerFactory), factoriesKube: make(map[string]kinformers.SharedInformerFactory),
factoriesSecret: make(map[string]informers.SharedInformerFactory), factoriesSecret: make(map[string]kinformers.SharedInformerFactory),
} }
} }
@ -171,27 +171,27 @@ func (c *clientWrapper) WatchAll(namespaces []string, stopCh <-chan struct{}) (<
options.LabelSelector = c.labelSelector options.LabelSelector = c.labelSelector
} }
c.factoryNamespace = informers.NewSharedInformerFactory(c.csKube, resyncPeriod) c.factoryNamespace = kinformers.NewSharedInformerFactory(c.csKube, resyncPeriod)
c.factoryNamespace.Core().V1().Namespaces().Informer().AddEventHandler(eventHandler) c.factoryNamespace.Core().V1().Namespaces().Informer().AddEventHandler(eventHandler)
c.factoryGatewayClass = externalversions.NewSharedInformerFactoryWithOptions(c.csGateway, resyncPeriod, externalversions.WithTweakListOptions(labelSelectorOptions)) c.factoryGatewayClass = gateinformers.NewSharedInformerFactoryWithOptions(c.csGateway, resyncPeriod, gateinformers.WithTweakListOptions(labelSelectorOptions))
c.factoryGatewayClass.Gateway().V1alpha2().GatewayClasses().Informer().AddEventHandler(eventHandler) c.factoryGatewayClass.Gateway().V1alpha2().GatewayClasses().Informer().AddEventHandler(eventHandler)
// TODO manage Reference Policy // TODO manage Reference Policy
// https://gateway-api.sigs.k8s.io/v1alpha2/references/spec/#gateway.networking.k8s.io/v1alpha2.ReferencePolicy // https://gateway-api.sigs.k8s.io/v1alpha2/references/spec/#gateway.networking.k8s.io/v1alpha2.ReferencePolicy
for _, ns := range namespaces { for _, ns := range namespaces {
factoryGateway := externalversions.NewSharedInformerFactoryWithOptions(c.csGateway, resyncPeriod, externalversions.WithNamespace(ns)) factoryGateway := gateinformers.NewSharedInformerFactoryWithOptions(c.csGateway, resyncPeriod, gateinformers.WithNamespace(ns))
factoryGateway.Gateway().V1alpha2().Gateways().Informer().AddEventHandler(eventHandler) factoryGateway.Gateway().V1alpha2().Gateways().Informer().AddEventHandler(eventHandler)
factoryGateway.Gateway().V1alpha2().HTTPRoutes().Informer().AddEventHandler(eventHandler) factoryGateway.Gateway().V1alpha2().HTTPRoutes().Informer().AddEventHandler(eventHandler)
factoryGateway.Gateway().V1alpha2().TCPRoutes().Informer().AddEventHandler(eventHandler) factoryGateway.Gateway().V1alpha2().TCPRoutes().Informer().AddEventHandler(eventHandler)
factoryGateway.Gateway().V1alpha2().TLSRoutes().Informer().AddEventHandler(eventHandler) factoryGateway.Gateway().V1alpha2().TLSRoutes().Informer().AddEventHandler(eventHandler)
factoryKube := informers.NewSharedInformerFactoryWithOptions(c.csKube, resyncPeriod, informers.WithNamespace(ns)) factoryKube := kinformers.NewSharedInformerFactoryWithOptions(c.csKube, resyncPeriod, kinformers.WithNamespace(ns))
factoryKube.Core().V1().Services().Informer().AddEventHandler(eventHandler) factoryKube.Core().V1().Services().Informer().AddEventHandler(eventHandler)
factoryKube.Core().V1().Endpoints().Informer().AddEventHandler(eventHandler) factoryKube.Core().V1().Endpoints().Informer().AddEventHandler(eventHandler)
factorySecret := informers.NewSharedInformerFactoryWithOptions(c.csKube, resyncPeriod, informers.WithNamespace(ns), informers.WithTweakListOptions(notOwnedByHelm)) factorySecret := kinformers.NewSharedInformerFactoryWithOptions(c.csKube, resyncPeriod, kinformers.WithNamespace(ns), kinformers.WithTweakListOptions(notOwnedByHelm))
factorySecret.Core().V1().Secrets().Informer().AddEventHandler(eventHandler) factorySecret.Core().V1().Secrets().Informer().AddEventHandler(eventHandler)
c.factoriesGateway[ns] = factoryGateway c.factoriesGateway[ns] = factoryGateway
@ -260,8 +260,8 @@ func (c *clientWrapper) GetNamespaces(selector labels.Selector) ([]string, error
return namespaces, nil return namespaces, nil
} }
func (c *clientWrapper) GetHTTPRoutes(namespaces []string) ([]*v1alpha2.HTTPRoute, error) { func (c *clientWrapper) GetHTTPRoutes(namespaces []string) ([]*gatev1alpha2.HTTPRoute, error) {
var httpRoutes []*v1alpha2.HTTPRoute var httpRoutes []*gatev1alpha2.HTTPRoute
for _, namespace := range namespaces { for _, namespace := range namespaces {
if !c.isWatchedNamespace(namespace) { if !c.isWatchedNamespace(namespace) {
log.Warn().Msgf("Failed to get HTTPRoutes: %q is not within watched namespaces", namespace) log.Warn().Msgf("Failed to get HTTPRoutes: %q is not within watched namespaces", namespace)
@ -284,8 +284,8 @@ func (c *clientWrapper) GetHTTPRoutes(namespaces []string) ([]*v1alpha2.HTTPRout
return httpRoutes, nil return httpRoutes, nil
} }
func (c *clientWrapper) GetTCPRoutes(namespaces []string) ([]*v1alpha2.TCPRoute, error) { func (c *clientWrapper) GetTCPRoutes(namespaces []string) ([]*gatev1alpha2.TCPRoute, error) {
var tcpRoutes []*v1alpha2.TCPRoute var tcpRoutes []*gatev1alpha2.TCPRoute
for _, namespace := range namespaces { for _, namespace := range namespaces {
if !c.isWatchedNamespace(namespace) { if !c.isWatchedNamespace(namespace) {
log.Warn().Msgf("Failed to get TCPRoutes: %q is not within watched namespaces", namespace) log.Warn().Msgf("Failed to get TCPRoutes: %q is not within watched namespaces", namespace)
@ -307,8 +307,8 @@ func (c *clientWrapper) GetTCPRoutes(namespaces []string) ([]*v1alpha2.TCPRoute,
return tcpRoutes, nil return tcpRoutes, nil
} }
func (c *clientWrapper) GetTLSRoutes(namespaces []string) ([]*v1alpha2.TLSRoute, error) { func (c *clientWrapper) GetTLSRoutes(namespaces []string) ([]*gatev1alpha2.TLSRoute, error) {
var tlsRoutes []*v1alpha2.TLSRoute var tlsRoutes []*gatev1alpha2.TLSRoute
for _, namespace := range namespaces { for _, namespace := range namespaces {
if !c.isWatchedNamespace(namespace) { if !c.isWatchedNamespace(namespace) {
log.Warn().Msgf("Failed to get TLSRoutes: %q is not within watched namespaces", namespace) log.Warn().Msgf("Failed to get TLSRoutes: %q is not within watched namespaces", namespace)
@ -330,8 +330,8 @@ func (c *clientWrapper) GetTLSRoutes(namespaces []string) ([]*v1alpha2.TLSRoute,
return tlsRoutes, nil return tlsRoutes, nil
} }
func (c *clientWrapper) GetGateways() []*v1alpha2.Gateway { func (c *clientWrapper) GetGateways() []*gatev1alpha2.Gateway {
var result []*v1alpha2.Gateway var result []*gatev1alpha2.Gateway
for ns, factory := range c.factoriesGateway { for ns, factory := range c.factoriesGateway {
gateways, err := factory.Gateway().V1alpha2().Gateways().Lister().List(labels.Everything()) gateways, err := factory.Gateway().V1alpha2().Gateways().Lister().List(labels.Everything())
@ -345,11 +345,11 @@ func (c *clientWrapper) GetGateways() []*v1alpha2.Gateway {
return result return result
} }
func (c *clientWrapper) GetGatewayClasses() ([]*v1alpha2.GatewayClass, error) { func (c *clientWrapper) GetGatewayClasses() ([]*gatev1alpha2.GatewayClass, error) {
return c.factoryGatewayClass.Gateway().V1alpha2().GatewayClasses().Lister().List(labels.Everything()) return c.factoryGatewayClass.Gateway().V1alpha2().GatewayClasses().Lister().List(labels.Everything())
} }
func (c *clientWrapper) UpdateGatewayClassStatus(gatewayClass *v1alpha2.GatewayClass, condition metav1.Condition) error { func (c *clientWrapper) UpdateGatewayClassStatus(gatewayClass *gatev1alpha2.GatewayClass, condition metav1.Condition) error {
gc := gatewayClass.DeepCopy() gc := gatewayClass.DeepCopy()
var newConditions []metav1.Condition var newConditions []metav1.Condition
@ -380,7 +380,7 @@ func (c *clientWrapper) UpdateGatewayClassStatus(gatewayClass *v1alpha2.GatewayC
return nil return nil
} }
func (c *clientWrapper) UpdateGatewayStatus(gateway *v1alpha2.Gateway, gatewayStatus v1alpha2.GatewayStatus) error { func (c *clientWrapper) UpdateGatewayStatus(gateway *gatev1alpha2.Gateway, gatewayStatus gatev1alpha2.GatewayStatus) error {
if !c.isWatchedNamespace(gateway.Namespace) { if !c.isWatchedNamespace(gateway.Namespace) {
return fmt.Errorf("cannot update Gateway status %s/%s: namespace is not within watched namespaces", gateway.Namespace, gateway.Name) return fmt.Errorf("cannot update Gateway status %s/%s: namespace is not within watched namespaces", gateway.Namespace, gateway.Name)
} }
@ -403,7 +403,7 @@ func (c *clientWrapper) UpdateGatewayStatus(gateway *v1alpha2.Gateway, gatewaySt
return nil return nil
} }
func statusEquals(oldStatus, newStatus v1alpha2.GatewayStatus) bool { func statusEquals(oldStatus, newStatus gatev1alpha2.GatewayStatus) bool {
if len(oldStatus.Listeners) != len(newStatus.Listeners) { if len(oldStatus.Listeners) != len(newStatus.Listeners) {
return false return false
} }
@ -510,7 +510,7 @@ func eventHandlerFunc(events chan<- interface{}, obj interface{}) {
// translateNotFoundError will translate a "not found" error to a boolean return // translateNotFoundError will translate a "not found" error to a boolean return
// value which indicates if the resource exists and a nil error. // value which indicates if the resource exists and a nil error.
func translateNotFoundError(err error) (bool, error) { func translateNotFoundError(err error) (bool, error) {
if kubeerror.IsNotFound(err) { if kerror.IsNotFound(err) {
return false, nil return false, nil
} }
return err == nil, err return err == nil, err

48
pkg/provider/kubernetes/gateway/client_mock_test.go
View file

@ -9,15 +9,15 @@ import (
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/kubernetes/scheme" kscheme "k8s.io/client-go/kubernetes/scheme"
"sigs.k8s.io/gateway-api/apis/v1alpha2" gatev1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
) )
var _ Client = (*clientMock)(nil) var _ Client = (*clientMock)(nil)
func init() { func init() {
// required by k8s.MustParseYaml // required by k8s.MustParseYaml
err := v1alpha2.AddToScheme(scheme.Scheme) err := gatev1alpha2.AddToScheme(kscheme.Scheme)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -33,11 +33,11 @@ type clientMock struct {
apiSecretError error apiSecretError error
apiEndpointsError error apiEndpointsError error
gatewayClasses []*v1alpha2.GatewayClass gatewayClasses []*gatev1alpha2.GatewayClass
gateways []*v1alpha2.Gateway gateways []*gatev1alpha2.Gateway
httpRoutes []*v1alpha2.HTTPRoute httpRoutes []*gatev1alpha2.HTTPRoute
tcpRoutes []*v1alpha2.TCPRoute tcpRoutes []*gatev1alpha2.TCPRoute
tlsRoutes []*v1alpha2.TLSRoute tlsRoutes []*gatev1alpha2.TLSRoute
watchChan chan interface{} watchChan chan interface{}
} }
@ -62,15 +62,15 @@ func newClientMock(paths ...string) clientMock {
c.namespaces = append(c.namespaces, o) c.namespaces = append(c.namespaces, o)
case *corev1.Endpoints: case *corev1.Endpoints:
c.endpoints = append(c.endpoints, o) c.endpoints = append(c.endpoints, o)
case *v1alpha2.GatewayClass: case *gatev1alpha2.GatewayClass:
c.gatewayClasses = append(c.gatewayClasses, o) c.gatewayClasses = append(c.gatewayClasses, o)
case *v1alpha2.Gateway: case *gatev1alpha2.Gateway:
c.gateways = append(c.gateways, o) c.gateways = append(c.gateways, o)
case *v1alpha2.HTTPRoute: case *gatev1alpha2.HTTPRoute:
c.httpRoutes = append(c.httpRoutes, o) c.httpRoutes = append(c.httpRoutes, o)
case *v1alpha2.TCPRoute: case *gatev1alpha2.TCPRoute:
c.tcpRoutes = append(c.tcpRoutes, o) c.tcpRoutes = append(c.tcpRoutes, o)
case *v1alpha2.TLSRoute: case *gatev1alpha2.TLSRoute:
c.tlsRoutes = append(c.tlsRoutes, o) c.tlsRoutes = append(c.tlsRoutes, o)
default: default:
panic(fmt.Sprintf("Unknown runtime object %+v %T", o, o)) panic(fmt.Sprintf("Unknown runtime object %+v %T", o, o))
@ -81,7 +81,7 @@ func newClientMock(paths ...string) clientMock {
return c return c
} }
func (c clientMock) UpdateGatewayStatus(gateway *v1alpha2.Gateway, gatewayStatus v1alpha2.GatewayStatus) error { func (c clientMock) UpdateGatewayStatus(gateway *gatev1alpha2.Gateway, gatewayStatus gatev1alpha2.GatewayStatus) error {
for _, g := range c.gateways { for _, g := range c.gateways {
if g.Name == gateway.Name { if g.Name == gateway.Name {
if !statusEquals(g.Status, gatewayStatus) { if !statusEquals(g.Status, gatewayStatus) {
@ -94,7 +94,7 @@ func (c clientMock) UpdateGatewayStatus(gateway *v1alpha2.Gateway, gatewayStatus
return nil return nil
} }
func (c clientMock) UpdateGatewayClassStatus(gatewayClass *v1alpha2.GatewayClass, condition metav1.Condition) error { func (c clientMock) UpdateGatewayClassStatus(gatewayClass *gatev1alpha2.GatewayClass, condition metav1.Condition) error {
for _, gc := range c.gatewayClasses { for _, gc := range c.gatewayClasses {
if gc.Name == gatewayClass.Name { if gc.Name == gatewayClass.Name {
for _, c := range gc.Status.Conditions { for _, c := range gc.Status.Conditions {
@ -110,7 +110,7 @@ func (c clientMock) UpdateGatewayClassStatus(gatewayClass *v1alpha2.GatewayClass
return nil return nil
} }
func (c clientMock) UpdateGatewayStatusConditions(gateway *v1alpha2.Gateway, condition metav1.Condition) error { func (c clientMock) UpdateGatewayStatusConditions(gateway *gatev1alpha2.Gateway, condition metav1.Condition) error {
for _, g := range c.gatewayClasses { for _, g := range c.gatewayClasses {
if g.Name == gateway.Name { if g.Name == gateway.Name {
for _, c := range g.Status.Conditions { for _, c := range g.Status.Conditions {
@ -126,11 +126,11 @@ func (c clientMock) UpdateGatewayStatusConditions(gateway *v1alpha2.Gateway, con
return nil return nil
} }
func (c clientMock) GetGatewayClasses() ([]*v1alpha2.GatewayClass, error) { func (c clientMock) GetGatewayClasses() ([]*gatev1alpha2.GatewayClass, error) {
return c.gatewayClasses, nil return c.gatewayClasses, nil
} }
func (c clientMock) GetGateways() []*v1alpha2.Gateway { func (c clientMock) GetGateways() []*gatev1alpha2.Gateway {
return c.gateways return c.gateways
} }
@ -148,8 +148,8 @@ func (c clientMock) GetNamespaces(selector labels.Selector) ([]string, error) {
return ns, nil return ns, nil
} }
func (c clientMock) GetHTTPRoutes(namespaces []string) ([]*v1alpha2.HTTPRoute, error) { func (c clientMock) GetHTTPRoutes(namespaces []string) ([]*gatev1alpha2.HTTPRoute, error) {
var httpRoutes []*v1alpha2.HTTPRoute var httpRoutes []*gatev1alpha2.HTTPRoute
for _, namespace := range namespaces { for _, namespace := range namespaces {
for _, httpRoute := range c.httpRoutes { for _, httpRoute := range c.httpRoutes {
if inNamespace(httpRoute.ObjectMeta, namespace) { if inNamespace(httpRoute.ObjectMeta, namespace) {
@ -160,8 +160,8 @@ func (c clientMock) GetHTTPRoutes(namespaces []string) ([]*v1alpha2.HTTPRoute, e
return httpRoutes, nil return httpRoutes, nil
} }
func (c clientMock) GetTCPRoutes(namespaces []string) ([]*v1alpha2.TCPRoute, error) { func (c clientMock) GetTCPRoutes(namespaces []string) ([]*gatev1alpha2.TCPRoute, error) {
var tcpRoutes []*v1alpha2.TCPRoute var tcpRoutes []*gatev1alpha2.TCPRoute
for _, namespace := range namespaces { for _, namespace := range namespaces {
for _, tcpRoute := range c.tcpRoutes { for _, tcpRoute := range c.tcpRoutes {
if inNamespace(tcpRoute.ObjectMeta, namespace) { if inNamespace(tcpRoute.ObjectMeta, namespace) {
@ -172,8 +172,8 @@ func (c clientMock) GetTCPRoutes(namespaces []string) ([]*v1alpha2.TCPRoute, err
return tcpRoutes, nil return tcpRoutes, nil
} }
func (c clientMock) GetTLSRoutes(namespaces []string) ([]*v1alpha2.TLSRoute, error) { func (c clientMock) GetTLSRoutes(namespaces []string) ([]*gatev1alpha2.TLSRoute, error) {
var tlsRoutes []*v1alpha2.TLSRoute var tlsRoutes []*gatev1alpha2.TLSRoute
for _, namespace := range namespaces { for _, namespace := range namespaces {
for _, tlsRoute := range c.tlsRoutes { for _, tlsRoute := range c.tlsRoutes {
if inNamespace(tlsRoute.ObjectMeta, namespace) { if inNamespace(tlsRoute.ObjectMeta, namespace) {

70
pkg/provider/kubernetes/gateway/client_test.go
View file

@ -5,32 +5,32 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"sigs.k8s.io/gateway-api/apis/v1alpha2" gatev1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
) )
func TestStatusEquals(t *testing.T) { func TestStatusEquals(t *testing.T) {
testCases := []struct { testCases := []struct {
desc string desc string
statusA v1alpha2.GatewayStatus statusA gatev1alpha2.GatewayStatus
statusB v1alpha2.GatewayStatus statusB gatev1alpha2.GatewayStatus
expected bool expected bool
}{ }{
{ {
desc: "Empty", desc: "Empty",
statusA: v1alpha2.GatewayStatus{}, statusA: gatev1alpha2.GatewayStatus{},
statusB: v1alpha2.GatewayStatus{}, statusB: gatev1alpha2.GatewayStatus{},
expected: true, expected: true,
}, },
{ {
desc: "Same status", desc: "Same status",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
Type: "foobar", Type: "foobar",
Reason: "foobar", Reason: "foobar",
}, },
}, },
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Name: "foo", Name: "foo",
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
@ -42,14 +42,14 @@ func TestStatusEquals(t *testing.T) {
}, },
}, },
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
Type: "foobar", Type: "foobar",
Reason: "foobar", Reason: "foobar",
}, },
}, },
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Name: "foo", Name: "foo",
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
@ -65,11 +65,11 @@ func TestStatusEquals(t *testing.T) {
}, },
{ {
desc: "Listeners length not equal", desc: "Listeners length not equal",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{}, Listeners: []gatev1alpha2.ListenerStatus{},
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{}, {},
}, },
}, },
@ -77,10 +77,10 @@ func TestStatusEquals(t *testing.T) {
}, },
{ {
desc: "Gateway conditions length not equal", desc: "Gateway conditions length not equal",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Conditions: []metav1.Condition{}, Conditions: []metav1.Condition{},
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{}, {},
}, },
@ -89,14 +89,14 @@ func TestStatusEquals(t *testing.T) {
}, },
{ {
desc: "Gateway conditions different types", desc: "Gateway conditions different types",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
Type: "foobar", Type: "foobar",
}, },
}, },
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
Type: "foobir", Type: "foobir",
@ -107,14 +107,14 @@ func TestStatusEquals(t *testing.T) {
}, },
{ {
desc: "Gateway conditions same types but different reason", desc: "Gateway conditions same types but different reason",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
Type: "foobar", Type: "foobar",
}, },
}, },
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
Type: "foobar", Type: "foobar",
@ -126,16 +126,16 @@ func TestStatusEquals(t *testing.T) {
}, },
{ {
desc: "Gateway listeners conditions length", desc: "Gateway listeners conditions length",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Name: "foo", Name: "foo",
Conditions: []metav1.Condition{}, Conditions: []metav1.Condition{},
}, },
}, },
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Name: "foo", Name: "foo",
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
@ -148,8 +148,8 @@ func TestStatusEquals(t *testing.T) {
}, },
{ {
desc: "Gateway listeners conditions same types but different status", desc: "Gateway listeners conditions same types but different status",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
@ -159,8 +159,8 @@ func TestStatusEquals(t *testing.T) {
}, },
}, },
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
@ -175,8 +175,8 @@ func TestStatusEquals(t *testing.T) {
}, },
{ {
desc: "Gateway listeners conditions same types but different message", desc: "Gateway listeners conditions same types but different message",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
@ -186,8 +186,8 @@ func TestStatusEquals(t *testing.T) {
}, },
}, },
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
{ {
@ -202,8 +202,8 @@ func TestStatusEquals(t *testing.T) {
}, },
{ {
desc: "Gateway listeners conditions same types/reason but different names", desc: "Gateway listeners conditions same types/reason but different names",
statusA: v1alpha2.GatewayStatus{ statusA: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Name: "foo", Name: "foo",
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{
@ -215,8 +215,8 @@ func TestStatusEquals(t *testing.T) {
}, },
}, },
}, },
statusB: v1alpha2.GatewayStatus{ statusB: gatev1alpha2.GatewayStatus{
Listeners: []v1alpha2.ListenerStatus{ Listeners: []gatev1alpha2.ListenerStatus{
{ {
Name: "bar", Name: "bar",
Conditions: []metav1.Condition{ Conditions: []metav1.Condition{

224
pkg/provider/kubernetes/gateway/kubernetes.go
View file

@ -31,7 +31,7 @@ import (
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
"k8s.io/utils/pointer" "k8s.io/utils/pointer"
"k8s.io/utils/strings/slices" "k8s.io/utils/strings/slices"
"sigs.k8s.io/gateway-api/apis/v1alpha2" gatev1alpha2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
) )
const ( const (
@ -209,14 +209,14 @@ func (p *Provider) loadConfigurationFromGateway(ctx context.Context, client Clie
gatewayClassNames[gatewayClass.Name] = struct{}{} gatewayClassNames[gatewayClass.Name] = struct{}{}
err := client.UpdateGatewayClassStatus(gatewayClass, metav1.Condition{ err := client.UpdateGatewayClassStatus(gatewayClass, metav1.Condition{
Type: string(v1alpha2.GatewayClassConditionStatusAccepted), Type: string(gatev1alpha2.GatewayClassConditionStatusAccepted),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
Reason: "Handled", Reason: "Handled",
Message: "Handled by Traefik controller", Message: "Handled by Traefik controller",
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
}) })
if err != nil { if err != nil {
logger.Error().Err(err).Msgf("Failed to update %s condition", v1alpha2.GatewayClassConditionStatusAccepted) logger.Error().Err(err).Msgf("Failed to update %s condition", gatev1alpha2.GatewayClassConditionStatusAccepted)
} }
} }
} }
@ -272,7 +272,7 @@ func (p *Provider) loadConfigurationFromGateway(ctx context.Context, client Clie
return conf return conf
} }
func (p *Provider) createGatewayConf(ctx context.Context, client Client, gateway *v1alpha2.Gateway) (*dynamic.Configuration, error) { func (p *Provider) createGatewayConf(ctx context.Context, client Client, gateway *gatev1alpha2.Gateway) (*dynamic.Configuration, error) {
conf := &dynamic.Configuration{ conf := &dynamic.Configuration{
HTTP: &dynamic.HTTPConfiguration{ HTTP: &dynamic.HTTPConfiguration{
Routers: map[string]*dynamic.Router{}, Routers: map[string]*dynamic.Router{},
@ -318,15 +318,15 @@ func (p *Provider) createGatewayConf(ctx context.Context, client Client, gateway
return conf, nil return conf, nil
} }
func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *v1alpha2.Gateway, conf *dynamic.Configuration, tlsConfigs map[string]*tls.CertAndStores) []v1alpha2.ListenerStatus { func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *gatev1alpha2.Gateway, conf *dynamic.Configuration, tlsConfigs map[string]*tls.CertAndStores) []gatev1alpha2.ListenerStatus {
logger := log.Ctx(ctx) logger := log.Ctx(ctx)
listenerStatuses := make([]v1alpha2.ListenerStatus, len(gateway.Spec.Listeners)) listenerStatuses := make([]gatev1alpha2.ListenerStatus, len(gateway.Spec.Listeners))
allocatedListeners := make(map[string]struct{}) allocatedListeners := make(map[string]struct{})
for i, listener := range gateway.Spec.Listeners { for i, listener := range gateway.Spec.Listeners {
listenerStatuses[i] = v1alpha2.ListenerStatus{ listenerStatuses[i] = gatev1alpha2.ListenerStatus{
Name: listener.Name, Name: listener.Name,
SupportedKinds: []v1alpha2.RouteGroupKind{}, SupportedKinds: []gatev1alpha2.RouteGroupKind{},
Conditions: []metav1.Condition{}, Conditions: []metav1.Condition{},
} }
@ -348,7 +348,7 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
if _, ok := allocatedListeners[listenerKey]; ok { if _, ok := allocatedListeners[listenerKey]; ok {
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionConflicted), Type: string(gatev1alpha2.ListenerConditionConflicted),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "DuplicateListener", Reason: "DuplicateListener",
@ -364,19 +364,19 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
if err != nil { if err != nil {
// update "Detached" status with "PortUnavailable" reason // update "Detached" status with "PortUnavailable" reason
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionDetached), Type: string(gatev1alpha2.ListenerConditionDetached),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonPortUnavailable), Reason: string(gatev1alpha2.ListenerReasonPortUnavailable),
Message: fmt.Sprintf("Cannot find entryPoint for Gateway: %v", err), Message: fmt.Sprintf("Cannot find entryPoint for Gateway: %v", err),
}) })
continue continue
} }
if (listener.Protocol == v1alpha2.HTTPProtocolType || listener.Protocol == v1alpha2.TCPProtocolType) && listener.TLS != nil { if (listener.Protocol == gatev1alpha2.HTTPProtocolType || listener.Protocol == gatev1alpha2.TCPProtocolType) && listener.TLS != nil {
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionDetached), Type: string(gatev1alpha2.ListenerConditionDetached),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidTLSConfiguration", // TODO check the spec if a proper reason is introduced at some point Reason: "InvalidTLSConfiguration", // TODO check the spec if a proper reason is introduced at some point
@ -387,11 +387,11 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
} }
// TLS // TLS
if listener.Protocol == v1alpha2.HTTPSProtocolType || listener.Protocol == v1alpha2.TLSProtocolType { if listener.Protocol == gatev1alpha2.HTTPSProtocolType || listener.Protocol == gatev1alpha2.TLSProtocolType {
if listener.TLS == nil || (len(listener.TLS.CertificateRefs) == 0 && listener.TLS.Mode != nil && *listener.TLS.Mode != v1alpha2.TLSModePassthrough) { if listener.TLS == nil || (len(listener.TLS.CertificateRefs) == 0 && listener.TLS.Mode != nil && *listener.TLS.Mode != gatev1alpha2.TLSModePassthrough) {
// update "Detached" status with "UnsupportedProtocol" reason // update "Detached" status with "UnsupportedProtocol" reason
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionDetached), Type: string(gatev1alpha2.ListenerConditionDetached),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidTLSConfiguration", // TODO check the spec if a proper reason is introduced at some point Reason: "InvalidTLSConfiguration", // TODO check the spec if a proper reason is introduced at some point
@ -402,12 +402,12 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
continue continue
} }
var tlsModeType v1alpha2.TLSModeType var tlsModeType gatev1alpha2.TLSModeType
if listener.TLS.Mode != nil { if listener.TLS.Mode != nil {
tlsModeType = *listener.TLS.Mode tlsModeType = *listener.TLS.Mode
} }
isTLSPassthrough := tlsModeType == v1alpha2.TLSModePassthrough isTLSPassthrough := tlsModeType == gatev1alpha2.TLSModePassthrough
if isTLSPassthrough && len(listener.TLS.CertificateRefs) > 0 { if isTLSPassthrough && len(listener.TLS.CertificateRefs) > 0 {
// https://gateway-api.sigs.k8s.io/v1alpha2/references/spec/#gateway.networking.k8s.io/v1alpha2.GatewayTLSConfig // https://gateway-api.sigs.k8s.io/v1alpha2/references/spec/#gateway.networking.k8s.io/v1alpha2.GatewayTLSConfig
@ -418,12 +418,12 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
// Protocol TLS -> Passthrough -> TLSRoute/TCPRoute // Protocol TLS -> Passthrough -> TLSRoute/TCPRoute
// Protocol TLS -> Terminate -> TLSRoute/TCPRoute // Protocol TLS -> Terminate -> TLSRoute/TCPRoute
// Protocol HTTPS -> Terminate -> HTTPRoute // Protocol HTTPS -> Terminate -> HTTPRoute
if listener.Protocol == v1alpha2.HTTPSProtocolType && isTLSPassthrough { if listener.Protocol == gatev1alpha2.HTTPSProtocolType && isTLSPassthrough {
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionDetached), Type: string(gatev1alpha2.ListenerConditionDetached),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonUnsupportedProtocol), Reason: string(gatev1alpha2.ListenerReasonUnsupportedProtocol),
Message: "HTTPS protocol is not supported with TLS mode Passthrough", Message: "HTTPS protocol is not supported with TLS mode Passthrough",
}) })
@ -434,10 +434,10 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
if len(listener.TLS.CertificateRefs) == 0 { if len(listener.TLS.CertificateRefs) == 0 {
// update "ResolvedRefs" status true with "InvalidCertificateRef" reason // update "ResolvedRefs" status true with "InvalidCertificateRef" reason
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonInvalidCertificateRef), Reason: string(gatev1alpha2.ListenerReasonInvalidCertificateRef),
Message: "One TLS CertificateRef is required in Terminate mode", Message: "One TLS CertificateRef is required in Terminate mode",
}) })
@ -451,10 +451,10 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
certificateRef.Group == nil || (*certificateRef.Group != "" && *certificateRef.Group != "core") { certificateRef.Group == nil || (*certificateRef.Group != "" && *certificateRef.Group != "core") {
// update "ResolvedRefs" status true with "InvalidCertificateRef" reason // update "ResolvedRefs" status true with "InvalidCertificateRef" reason
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonInvalidCertificateRef), Reason: string(gatev1alpha2.ListenerReasonInvalidCertificateRef),
Message: fmt.Sprintf("Unsupported TLS CertificateRef group/kind: %v/%v", certificateRef.Group, certificateRef.Kind), Message: fmt.Sprintf("Unsupported TLS CertificateRef group/kind: %v/%v", certificateRef.Group, certificateRef.Kind),
}) })
@ -464,10 +464,10 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
// TODO Support ReferencePolicy to support cross namespace references. // TODO Support ReferencePolicy to support cross namespace references.
if certificateRef.Namespace != nil && string(*certificateRef.Namespace) != gateway.Namespace { if certificateRef.Namespace != nil && string(*certificateRef.Namespace) != gateway.Namespace {
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonInvalidCertificateRef), Reason: string(gatev1alpha2.ListenerReasonInvalidCertificateRef),
Message: "Cross namespace secrets are not supported", Message: "Cross namespace secrets are not supported",
}) })
@ -480,10 +480,10 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "InvalidCertificateRef" reason // update "ResolvedRefs" status true with "InvalidCertificateRef" reason
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonInvalidCertificateRef), Reason: string(gatev1alpha2.ListenerReasonInvalidCertificateRef),
Message: fmt.Sprintf("Error while retrieving certificate: %v", err), Message: fmt.Sprintf("Error while retrieving certificate: %v", err),
}) })
@ -510,10 +510,10 @@ func (p *Provider) fillGatewayConf(ctx context.Context, client Client, gateway *
return listenerStatuses return listenerStatuses
} }
func (p *Provider) makeGatewayStatus(listenerStatuses []v1alpha2.ListenerStatus) (v1alpha2.GatewayStatus, error) { func (p *Provider) makeGatewayStatus(listenerStatuses []gatev1alpha2.ListenerStatus) (gatev1alpha2.GatewayStatus, error) {
// As Status.Addresses are not implemented yet, we initialize an empty array to follow the API expectations. // As Status.Addresses are not implemented yet, we initialize an empty array to follow the API expectations.
gatewayStatus := v1alpha2.GatewayStatus{ gatewayStatus := gatev1alpha2.GatewayStatus{
Addresses: []v1alpha2.GatewayAddress{}, Addresses: []gatev1alpha2.GatewayAddress{},
} }
var result error var result error
@ -521,7 +521,7 @@ func (p *Provider) makeGatewayStatus(listenerStatuses []v1alpha2.ListenerStatus)
if len(listener.Conditions) == 0 { if len(listener.Conditions) == 0 {
// GatewayConditionReady "Ready", GatewayConditionReason "ListenerReady" // GatewayConditionReady "Ready", GatewayConditionReason "ListenerReady"
listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{ listenerStatuses[i].Conditions = append(listenerStatuses[i].Conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionReady), Type: string(gatev1alpha2.ListenerConditionReady),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "ListenerReady", Reason: "ListenerReady",
@ -539,10 +539,10 @@ func (p *Provider) makeGatewayStatus(listenerStatuses []v1alpha2.ListenerStatus)
if result != nil { if result != nil {
// GatewayConditionReady "Ready", GatewayConditionReason "ListenersNotValid" // GatewayConditionReady "Ready", GatewayConditionReason "ListenersNotValid"
gatewayStatus.Conditions = append(gatewayStatus.Conditions, metav1.Condition{ gatewayStatus.Conditions = append(gatewayStatus.Conditions, metav1.Condition{
Type: string(v1alpha2.GatewayConditionReady), Type: string(gatev1alpha2.GatewayConditionReady),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.GatewayReasonListenersNotValid), Reason: string(gatev1alpha2.GatewayReasonListenersNotValid),
Message: "All Listeners must be valid", Message: "All Listeners must be valid",
}) })
@ -554,7 +554,7 @@ func (p *Provider) makeGatewayStatus(listenerStatuses []v1alpha2.ListenerStatus)
gatewayStatus.Conditions = append(gatewayStatus.Conditions, gatewayStatus.Conditions = append(gatewayStatus.Conditions,
// update "Scheduled" status with "ResourcesAvailable" reason // update "Scheduled" status with "ResourcesAvailable" reason
metav1.Condition{ metav1.Condition{
Type: string(v1alpha2.GatewayConditionScheduled), Type: string(gatev1alpha2.GatewayConditionScheduled),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
Reason: "ResourcesAvailable", Reason: "ResourcesAvailable",
Message: "Resources available", Message: "Resources available",
@ -562,7 +562,7 @@ func (p *Provider) makeGatewayStatus(listenerStatuses []v1alpha2.ListenerStatus)
}, },
// update "Ready" status with "ListenersValid" reason // update "Ready" status with "ListenersValid" reason
metav1.Condition{ metav1.Condition{
Type: string(v1alpha2.GatewayConditionReady), Type: string(gatev1alpha2.GatewayConditionReady),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
Reason: "ListenersValid", Reason: "ListenersValid",
Message: "Listeners valid", Message: "Listeners valid",
@ -573,14 +573,14 @@ func (p *Provider) makeGatewayStatus(listenerStatuses []v1alpha2.ListenerStatus)
return gatewayStatus, nil return gatewayStatus, nil
} }
func (p *Provider) entryPointName(port v1alpha2.PortNumber, protocol v1alpha2.ProtocolType) (string, error) { func (p *Provider) entryPointName(port gatev1alpha2.PortNumber, protocol gatev1alpha2.ProtocolType) (string, error) {
portStr := strconv.FormatInt(int64(port), 10) portStr := strconv.FormatInt(int64(port), 10)
for name, entryPoint := range p.EntryPoints { for name, entryPoint := range p.EntryPoints {
if strings.HasSuffix(entryPoint.Address, ":"+portStr) { if strings.HasSuffix(entryPoint.Address, ":"+portStr) {
// If the protocol is HTTP the entryPoint must have no TLS conf // If the protocol is HTTP the entryPoint must have no TLS conf
// Not relevant for v1alpha2.TLSProtocolType && v1alpha2.TCPProtocolType // Not relevant for gatev1alpha2.TLSProtocolType && gatev1alpha2.TCPProtocolType
if protocol == v1alpha2.HTTPProtocolType && entryPoint.HasHTTPTLSConf { if protocol == gatev1alpha2.HTTPProtocolType && entryPoint.HasHTTPTLSConf {
continue continue
} }
@ -591,43 +591,43 @@ func (p *Provider) entryPointName(port v1alpha2.PortNumber, protocol v1alpha2.Pr
return "", fmt.Errorf("no matching entryPoint for port %d and protocol %q", port, protocol) return "", fmt.Errorf("no matching entryPoint for port %d and protocol %q", port, protocol)
} }
func supportedRouteKinds(protocol v1alpha2.ProtocolType) ([]v1alpha2.RouteGroupKind, []metav1.Condition) { func supportedRouteKinds(protocol gatev1alpha2.ProtocolType) ([]gatev1alpha2.RouteGroupKind, []metav1.Condition) {
group := v1alpha2.Group(v1alpha2.GroupName) group := gatev1alpha2.Group(gatev1alpha2.GroupName)
switch protocol { switch protocol {
case v1alpha2.TCPProtocolType: case gatev1alpha2.TCPProtocolType:
return []v1alpha2.RouteGroupKind{{Kind: kindTCPRoute, Group: &group}}, nil return []gatev1alpha2.RouteGroupKind{{Kind: kindTCPRoute, Group: &group}}, nil
case v1alpha2.HTTPProtocolType, v1alpha2.HTTPSProtocolType: case gatev1alpha2.HTTPProtocolType, gatev1alpha2.HTTPSProtocolType:
return []v1alpha2.RouteGroupKind{{Kind: kindHTTPRoute, Group: &group}}, nil return []gatev1alpha2.RouteGroupKind{{Kind: kindHTTPRoute, Group: &group}}, nil
case v1alpha2.TLSProtocolType: case gatev1alpha2.TLSProtocolType:
return []v1alpha2.RouteGroupKind{ return []gatev1alpha2.RouteGroupKind{
{Kind: kindTCPRoute, Group: &group}, {Kind: kindTCPRoute, Group: &group},
{Kind: kindTLSRoute, Group: &group}, {Kind: kindTLSRoute, Group: &group},
}, nil }, nil
} }
return nil, []metav1.Condition{{ return nil, []metav1.Condition{{
Type: string(v1alpha2.ListenerConditionDetached), Type: string(gatev1alpha2.ListenerConditionDetached),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonUnsupportedProtocol), Reason: string(gatev1alpha2.ListenerReasonUnsupportedProtocol),
Message: fmt.Sprintf("Unsupported listener protocol %q", protocol), Message: fmt.Sprintf("Unsupported listener protocol %q", protocol),
}} }}
} }
func getAllowedRouteKinds(listener v1alpha2.Listener, supportedKinds []v1alpha2.RouteGroupKind) ([]v1alpha2.RouteGroupKind, []metav1.Condition) { func getAllowedRouteKinds(listener gatev1alpha2.Listener, supportedKinds []gatev1alpha2.RouteGroupKind) ([]gatev1alpha2.RouteGroupKind, []metav1.Condition) {
if listener.AllowedRoutes == nil || len(listener.AllowedRoutes.Kinds) == 0 { if listener.AllowedRoutes == nil || len(listener.AllowedRoutes.Kinds) == 0 {
return supportedKinds, nil return supportedKinds, nil
} }
var ( var (
routeKinds []v1alpha2.RouteGroupKind routeKinds []gatev1alpha2.RouteGroupKind
conditions []metav1.Condition conditions []metav1.Condition
) )
uniqRouteKinds := map[v1alpha2.Kind]struct{}{} uniqRouteKinds := map[gatev1alpha2.Kind]struct{}{}
for _, routeKind := range listener.AllowedRoutes.Kinds { for _, routeKind := range listener.AllowedRoutes.Kinds {
var isSupported bool var isSupported bool
for _, kind := range supportedKinds { for _, kind := range supportedKinds {
@ -639,10 +639,10 @@ func getAllowedRouteKinds(listener v1alpha2.Listener, supportedKinds []v1alpha2.
if !isSupported { if !isSupported {
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionDetached), Type: string(gatev1alpha2.ListenerConditionDetached),
Status: metav1.ConditionTrue, Status: metav1.ConditionTrue,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonInvalidRouteKinds), Reason: string(gatev1alpha2.ListenerReasonInvalidRouteKinds),
Message: fmt.Sprintf("Listener protocol %q does not support RouteGroupKind %v/%s", listener.Protocol, routeKind.Group, routeKind.Kind), Message: fmt.Sprintf("Listener protocol %q does not support RouteGroupKind %v/%s", listener.Protocol, routeKind.Group, routeKind.Kind),
}) })
continue continue
@ -657,7 +657,7 @@ func getAllowedRouteKinds(listener v1alpha2.Listener, supportedKinds []v1alpha2.
return routeKinds, conditions return routeKinds, conditions
} }
func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha2.Listener, gateway *v1alpha2.Gateway, client Client, conf *dynamic.Configuration) []metav1.Condition { func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener gatev1alpha2.Listener, gateway *gatev1alpha2.Gateway, client Client, conf *dynamic.Configuration) []metav1.Condition {
if listener.AllowedRoutes == nil { if listener.AllowedRoutes == nil {
// Should not happen due to validation. // Should not happen due to validation.
return nil return nil
@ -667,7 +667,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "InvalidRoutesRef" reason // update "ResolvedRefs" status true with "InvalidRoutesRef" reason
return []metav1.Condition{{ return []metav1.Condition{{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidRouteNamespacesSelector", // Should never happen as the selector is validated by kubernetes Reason: "InvalidRouteNamespacesSelector", // Should never happen as the selector is validated by kubernetes
@ -679,10 +679,10 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "InvalidRoutesRef" reason // update "ResolvedRefs" status true with "InvalidRoutesRef" reason
return []metav1.Condition{{ return []metav1.Condition{{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonRefNotPermitted), Reason: string(gatev1alpha2.ListenerReasonRefNotPermitted),
Message: fmt.Sprintf("Cannot fetch HTTPRoutes: %v", err), Message: fmt.Sprintf("Cannot fetch HTTPRoutes: %v", err),
}} }}
} }
@ -708,7 +708,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
hostRule, err := hostRule(hostnames) hostRule, err := hostRule(hostnames)
if err != nil { if err != nil {
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidRouteHostname", // TODO check the spec if a proper reason is introduced at some point Reason: "InvalidRouteHostname", // TODO check the spec if a proper reason is introduced at some point
@ -722,7 +722,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "DroppedRoutes" reason // update "ResolvedRefs" status true with "DroppedRoutes" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "UnsupportedPathOrHeaderType", // TODO check the spec if a proper reason is introduced at some point Reason: "UnsupportedPathOrHeaderType", // TODO check the spec if a proper reason is introduced at some point
@ -735,7 +735,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
EntryPoints: []string{ep}, EntryPoints: []string{ep},
} }
if listener.Protocol == v1alpha2.HTTPSProtocolType && listener.TLS != nil { if listener.Protocol == gatev1alpha2.HTTPSProtocolType && listener.TLS != nil {
// TODO support let's encrypt // TODO support let's encrypt
router.TLS = &dynamic.RouterTLSConfig{} router.TLS = &dynamic.RouterTLSConfig{}
} }
@ -746,7 +746,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "DroppedRoutes" reason // update "ResolvedRefs" status true with "DroppedRoutes" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidRouterKey", // Should never happen Reason: "InvalidRouterKey", // Should never happen
@ -761,7 +761,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "InvalidFilters" reason // update "ResolvedRefs" status true with "InvalidFilters" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidFilters", // TODO check the spec if a proper reason is introduced at some point Reason: "InvalidFilters", // TODO check the spec if a proper reason is introduced at some point
@ -789,7 +789,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "DroppedRoutes" reason // update "ResolvedRefs" status true with "DroppedRoutes" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidBackendRefs", // TODO check the spec if a proper reason is introduced at some point Reason: "InvalidBackendRefs", // TODO check the spec if a proper reason is introduced at some point
@ -818,7 +818,7 @@ func gatewayHTTPRouteToHTTPConf(ctx context.Context, ep string, listener v1alpha
return conditions return conditions
} }
func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.Listener, gateway *v1alpha2.Gateway, client Client, conf *dynamic.Configuration) []metav1.Condition { func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener gatev1alpha2.Listener, gateway *gatev1alpha2.Gateway, client Client, conf *dynamic.Configuration) []metav1.Condition {
if listener.AllowedRoutes == nil { if listener.AllowedRoutes == nil {
// Should not happen due to validation. // Should not happen due to validation.
return nil return nil
@ -828,7 +828,7 @@ func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "InvalidRoutesRef" reason // update "ResolvedRefs" status true with "InvalidRoutesRef" reason
return []metav1.Condition{{ return []metav1.Condition{{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidRouteNamespacesSelector", // TODO should never happen as the selector is validated by Kubernetes Reason: "InvalidRouteNamespacesSelector", // TODO should never happen as the selector is validated by Kubernetes
@ -840,10 +840,10 @@ func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "InvalidRoutesRef" reason // update "ResolvedRefs" status true with "InvalidRoutesRef" reason
return []metav1.Condition{{ return []metav1.Condition{{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonRefNotPermitted), Reason: string(gatev1alpha2.ListenerReasonRefNotPermitted),
Message: fmt.Sprintf("Cannot fetch TCPRoutes: %v", err), Message: fmt.Sprintf("Cannot fetch TCPRoutes: %v", err),
}} }}
} }
@ -864,10 +864,10 @@ func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
EntryPoints: []string{ep}, EntryPoints: []string{ep},
} }
if listener.Protocol == v1alpha2.TLSProtocolType && listener.TLS != nil { if listener.Protocol == gatev1alpha2.TLSProtocolType && listener.TLS != nil {
// TODO support let's encrypt // TODO support let's encrypt
router.TLS = &dynamic.RouterTCPTLSConfig{ router.TLS = &dynamic.RouterTCPTLSConfig{
Passthrough: listener.TLS.Mode != nil && *listener.TLS.Mode == v1alpha2.TLSModePassthrough, Passthrough: listener.TLS.Mode != nil && *listener.TLS.Mode == gatev1alpha2.TLSModePassthrough,
} }
} }
@ -877,7 +877,7 @@ func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "DroppedRoutes" reason // update "ResolvedRefs" status true with "DroppedRoutes" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidRouterKey", // Should never happen Reason: "InvalidRouterKey", // Should never happen
@ -902,7 +902,7 @@ func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "DroppedRoutes" reason // update "ResolvedRefs" status true with "DroppedRoutes" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidBackendRefs", // TODO check the spec if a proper reason is introduced at some point Reason: "InvalidBackendRefs", // TODO check the spec if a proper reason is introduced at some point
@ -948,7 +948,7 @@ func gatewayTCPRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
return conditions return conditions
} }
func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.Listener, gateway *v1alpha2.Gateway, client Client, conf *dynamic.Configuration) []metav1.Condition { func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener gatev1alpha2.Listener, gateway *gatev1alpha2.Gateway, client Client, conf *dynamic.Configuration) []metav1.Condition {
if listener.AllowedRoutes == nil { if listener.AllowedRoutes == nil {
// Should not happen due to validation. // Should not happen due to validation.
return nil return nil
@ -958,7 +958,7 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "InvalidRoutesRef" reason // update "ResolvedRefs" status true with "InvalidRoutesRef" reason
return []metav1.Condition{{ return []metav1.Condition{{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidRouteNamespacesSelector", // TODO should never happen as the selector is validated by Kubernetes Reason: "InvalidRouteNamespacesSelector", // TODO should never happen as the selector is validated by Kubernetes
@ -970,10 +970,10 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "InvalidRoutesRef" reason // update "ResolvedRefs" status true with "InvalidRoutesRef" reason
return []metav1.Condition{{ return []metav1.Condition{{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: string(v1alpha2.ListenerReasonRefNotPermitted), Reason: string(gatev1alpha2.ListenerReasonRefNotPermitted),
Message: fmt.Sprintf("Cannot fetch TLSRoutes: %v", err), Message: fmt.Sprintf("Cannot fetch TLSRoutes: %v", err),
}} }}
} }
@ -993,9 +993,9 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if len(hostnames) == 0 && listener.Hostname != nil && *listener.Hostname != "" && len(route.Spec.Hostnames) > 0 { if len(hostnames) == 0 && listener.Hostname != nil && *listener.Hostname != "" && len(route.Spec.Hostnames) > 0 {
for _, parent := range route.Status.Parents { for _, parent := range route.Status.Parents {
parent.Conditions = append(parent.Conditions, metav1.Condition{ parent.Conditions = append(parent.Conditions, metav1.Condition{
Type: string(v1alpha2.GatewayClassConditionStatusAccepted), Type: string(gatev1alpha2.GatewayClassConditionStatusAccepted),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
Reason: string(v1alpha2.ListenerReasonRouteConflict), Reason: string(gatev1alpha2.ListenerReasonRouteConflict),
Message: fmt.Sprintf("No hostname match between listener: %v and route: %v", listener.Hostname, route.Spec.Hostnames), Message: fmt.Sprintf("No hostname match between listener: %v and route: %v", listener.Hostname, route.Spec.Hostnames),
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
}) })
@ -1008,7 +1008,7 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "DroppedRoutes" reason // update "ResolvedRefs" status true with "DroppedRoutes" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidHostnames", // TODO check the spec if a proper reason is introduced at some point Reason: "InvalidHostnames", // TODO check the spec if a proper reason is introduced at some point
@ -1022,7 +1022,7 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
Rule: rule, Rule: rule,
EntryPoints: []string{ep}, EntryPoints: []string{ep},
TLS: &dynamic.RouterTCPTLSConfig{ TLS: &dynamic.RouterTCPTLSConfig{
Passthrough: listener.TLS.Mode != nil && *listener.TLS.Mode == v1alpha2.TLSModePassthrough, Passthrough: listener.TLS.Mode != nil && *listener.TLS.Mode == gatev1alpha2.TLSModePassthrough,
}, },
} }
@ -1032,7 +1032,7 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "DroppedRoutes" reason // update "ResolvedRefs" status true with "DroppedRoutes" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidRouterKey", // Should never happen Reason: "InvalidRouterKey", // Should never happen
@ -1057,7 +1057,7 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
if err != nil { if err != nil {
// update "ResolvedRefs" status true with "DroppedRoutes" reason // update "ResolvedRefs" status true with "DroppedRoutes" reason
conditions = append(conditions, metav1.Condition{ conditions = append(conditions, metav1.Condition{
Type: string(v1alpha2.ListenerConditionResolvedRefs), Type: string(gatev1alpha2.ListenerConditionResolvedRefs),
Status: metav1.ConditionFalse, Status: metav1.ConditionFalse,
LastTransitionTime: metav1.Now(), LastTransitionTime: metav1.Now(),
Reason: "InvalidBackendRefs", // TODO check the spec if a proper reason is introduced at some point Reason: "InvalidBackendRefs", // TODO check the spec if a proper reason is introduced at some point
@ -1105,18 +1105,18 @@ func gatewayTLSRouteToTCPConf(ctx context.Context, ep string, listener v1alpha2.
// Because of Kubernetes validation we admit that the given Hostnames are valid. // Because of Kubernetes validation we admit that the given Hostnames are valid.
// https://github.com/kubernetes-sigs/gateway-api/blob/ff9883da4cad8554cd300394f725ab3a27502785/apis/v1alpha2/shared_types.go#L252 // https://github.com/kubernetes-sigs/gateway-api/blob/ff9883da4cad8554cd300394f725ab3a27502785/apis/v1alpha2/shared_types.go#L252
func matchingHostnames(listener v1alpha2.Listener, hostnames []v1alpha2.Hostname) []v1alpha2.Hostname { func matchingHostnames(listener gatev1alpha2.Listener, hostnames []gatev1alpha2.Hostname) []gatev1alpha2.Hostname {
if listener.Hostname == nil || *listener.Hostname == "" { if listener.Hostname == nil || *listener.Hostname == "" {
return hostnames return hostnames
} }
if len(hostnames) == 0 { if len(hostnames) == 0 {
return []v1alpha2.Hostname{*listener.Hostname} return []gatev1alpha2.Hostname{*listener.Hostname}
} }
listenerLabels := strings.Split(string(*listener.Hostname), ".") listenerLabels := strings.Split(string(*listener.Hostname), ".")
var matches []v1alpha2.Hostname var matches []gatev1alpha2.Hostname
for _, hostname := range hostnames { for _, hostname := range hostnames {
if hostname == *listener.Hostname { if hostname == *listener.Hostname {
@ -1147,9 +1147,9 @@ func matchingHostnames(listener v1alpha2.Listener, hostnames []v1alpha2.Hostname
return matches return matches
} }
func shouldAttach(gateway *v1alpha2.Gateway, listener v1alpha2.Listener, routeNamespace string, routeSpec v1alpha2.CommonRouteSpec) bool { func shouldAttach(gateway *gatev1alpha2.Gateway, listener gatev1alpha2.Listener, routeNamespace string, routeSpec gatev1alpha2.CommonRouteSpec) bool {
for _, parentRef := range routeSpec.ParentRefs { for _, parentRef := range routeSpec.ParentRefs {
if parentRef.Group == nil || *parentRef.Group != v1alpha2.GroupName { if parentRef.Group == nil || *parentRef.Group != gatev1alpha2.GroupName {
continue continue
} }
@ -1174,19 +1174,19 @@ func shouldAttach(gateway *v1alpha2.Gateway, listener v1alpha2.Listener, routeNa
return false return false
} }
func getRouteBindingSelectorNamespace(client Client, gatewayNamespace string, routeNamespaces *v1alpha2.RouteNamespaces) ([]string, error) { func getRouteBindingSelectorNamespace(client Client, gatewayNamespace string, routeNamespaces *gatev1alpha2.RouteNamespaces) ([]string, error) {
if routeNamespaces == nil || routeNamespaces.From == nil { if routeNamespaces == nil || routeNamespaces.From == nil {
return []string{gatewayNamespace}, nil return []string{gatewayNamespace}, nil
} }
switch *routeNamespaces.From { switch *routeNamespaces.From {
case v1alpha2.NamespacesFromAll: case gatev1alpha2.NamespacesFromAll:
return []string{metav1.NamespaceAll}, nil return []string{metav1.NamespaceAll}, nil
case v1alpha2.NamespacesFromSame: case gatev1alpha2.NamespacesFromSame:
return []string{gatewayNamespace}, nil return []string{gatewayNamespace}, nil
case v1alpha2.NamespacesFromSelector: case gatev1alpha2.NamespacesFromSelector:
selector, err := metav1.LabelSelectorAsSelector(routeNamespaces.Selector) selector, err := metav1.LabelSelectorAsSelector(routeNamespaces.Selector)
if err != nil { if err != nil {
return nil, fmt.Errorf("malformed selector: %w", err) return nil, fmt.Errorf("malformed selector: %w", err)
@ -1198,7 +1198,7 @@ func getRouteBindingSelectorNamespace(client Client, gatewayNamespace string, ro
return nil, fmt.Errorf("unsupported RouteSelectType: %q", *routeNamespaces.From) return nil, fmt.Errorf("unsupported RouteSelectType: %q", *routeNamespaces.From)
} }
func hostRule(hostnames []v1alpha2.Hostname) (string, error) { func hostRule(hostnames []gatev1alpha2.Hostname) (string, error) {
var rules []string var rules []string
for _, hostname := range hostnames { for _, hostname := range hostnames {
@ -1235,9 +1235,9 @@ func hostRule(hostnames []v1alpha2.Hostname) (string, error) {
} }
} }
func hostSNIRule(hostnames []v1alpha2.Hostname) (string, error) { func hostSNIRule(hostnames []gatev1alpha2.Hostname) (string, error) {
rules := make([]string, 0, len(hostnames)) rules := make([]string, 0, len(hostnames))
uniqHostnames := map[v1alpha2.Hostname]struct{}{} uniqHostnames := map[gatev1alpha2.Hostname]struct{}{}
for _, hostname := range hostnames { for _, hostname := range hostnames {
if len(hostname) == 0 { if len(hostname) == 0 {
@ -1272,7 +1272,7 @@ func hostSNIRule(hostnames []v1alpha2.Hostname) (string, error) {
return strings.Join(rules, " || "), nil return strings.Join(rules, " || "), nil
} }
func extractRule(routeRule v1alpha2.HTTPRouteRule, hostRule string) (string, error) { func extractRule(routeRule gatev1alpha2.HTTPRouteRule, hostRule string) (string, error) {
var rule string var rule string
var matchesRules []string var matchesRules []string
@ -1286,9 +1286,9 @@ func extractRule(routeRule v1alpha2.HTTPRouteRule, hostRule string) (string, err
if match.Path != nil && match.Path.Type != nil && match.Path.Value != nil { if match.Path != nil && match.Path.Type != nil && match.Path.Value != nil {
// TODO handle other path types // TODO handle other path types
switch *match.Path.Type { switch *match.Path.Type {
case v1alpha2.PathMatchExact: case gatev1alpha2.PathMatchExact:
matchRules = append(matchRules, fmt.Sprintf("Path(`%s`)", *match.Path.Value)) matchRules = append(matchRules, fmt.Sprintf("Path(`%s`)", *match.Path.Value))
case v1alpha2.PathMatchPathPrefix: case gatev1alpha2.PathMatchPathPrefix:
matchRules = append(matchRules, fmt.Sprintf("PathPrefix(`%s`)", *match.Path.Value)) matchRules = append(matchRules, fmt.Sprintf("PathPrefix(`%s`)", *match.Path.Value))
default: default:
return "", fmt.Errorf("unsupported path match %s", *match.Path.Type) return "", fmt.Errorf("unsupported path match %s", *match.Path.Type)
@ -1329,7 +1329,7 @@ func extractRule(routeRule v1alpha2.HTTPRouteRule, hostRule string) (string, err
return rule + "(" + strings.Join(matchesRules, " || ") + ")", nil return rule + "(" + strings.Join(matchesRules, " || ") + ")", nil
} }
func extractHeaderRules(headers []v1alpha2.HTTPHeaderMatch) ([]string, error) { func extractHeaderRules(headers []gatev1alpha2.HTTPHeaderMatch) ([]string, error) {
var headerRules []string var headerRules []string
// TODO handle other headers types // TODO handle other headers types
@ -1340,7 +1340,7 @@ func extractHeaderRules(headers []v1alpha2.HTTPHeaderMatch) ([]string, error) {
} }
switch *header.Type { switch *header.Type {
case v1alpha2.HeaderMatchExact: case gatev1alpha2.HeaderMatchExact:
headerRules = append(headerRules, fmt.Sprintf("Headers(`%s`,`%s`)", header.Name, header.Value)) headerRules = append(headerRules, fmt.Sprintf("Headers(`%s`,`%s`)", header.Name, header.Value))
default: default:
return nil, fmt.Errorf("unsupported header match type %s", *header.Type) return nil, fmt.Errorf("unsupported header match type %s", *header.Type)
@ -1369,7 +1369,7 @@ func makeID(namespace, name string) string {
return namespace + "-" + name return namespace + "-" + name
} }
func getTLS(k8sClient Client, secretName v1alpha2.ObjectName, namespace string) (*tls.CertAndStores, error) { func getTLS(k8sClient Client, secretName gatev1alpha2.ObjectName, namespace string) (*tls.CertAndStores, error) {
secret, exists, err := k8sClient.GetSecret(namespace, string(secretName)) secret, exists, err := k8sClient.GetSecret(namespace, string(secretName))
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to fetch secret %s/%s: %w", namespace, secretName, err) return nil, fmt.Errorf("failed to fetch secret %s/%s: %w", namespace, secretName, err)
@ -1443,7 +1443,7 @@ func getCertificateBlocks(secret *corev1.Secret, namespace, secretName string) (
} }
// loadServices is generating a WRR service, even when there is only one target. // loadServices is generating a WRR service, even when there is only one target.
func loadServices(client Client, namespace string, backendRefs []v1alpha2.HTTPBackendRef) (*dynamic.Service, map[string]*dynamic.Service, error) { func loadServices(client Client, namespace string, backendRefs []gatev1alpha2.HTTPBackendRef) (*dynamic.Service, map[string]*dynamic.Service, error) {
services := map[string]*dynamic.Service{} services := map[string]*dynamic.Service{}
wrrSvc := &dynamic.Service{ wrrSvc := &dynamic.Service{
@ -1566,7 +1566,7 @@ func loadServices(client Client, namespace string, backendRefs []v1alpha2.HTTPBa
} }
// loadTCPServices is generating a WRR service, even when there is only one target. // loadTCPServices is generating a WRR service, even when there is only one target.
func loadTCPServices(client Client, namespace string, backendRefs []v1alpha2.BackendRef) (*dynamic.TCPService, map[string]*dynamic.TCPService, error) { func loadTCPServices(client Client, namespace string, backendRefs []gatev1alpha2.BackendRef) (*dynamic.TCPService, map[string]*dynamic.TCPService, error) {
services := map[string]*dynamic.TCPService{} services := map[string]*dynamic.TCPService{}
wrrSvc := &dynamic.TCPService{ wrrSvc := &dynamic.TCPService{
@ -1684,16 +1684,16 @@ func loadTCPServices(client Client, namespace string, backendRefs []v1alpha2.Bac
return wrrSvc, services, nil return wrrSvc, services, nil
} }
func loadMiddlewares(listener v1alpha2.Listener, prefix string, filters []v1alpha2.HTTPRouteFilter) (map[string]*dynamic.Middleware, error) { func loadMiddlewares(listener gatev1alpha2.Listener, prefix string, filters []gatev1alpha2.HTTPRouteFilter) (map[string]*dynamic.Middleware, error) {
middlewares := make(map[string]*dynamic.Middleware) middlewares := make(map[string]*dynamic.Middleware)
// The spec allows for an empty string in which case we should use the // The spec allows for an empty string in which case we should use the
// scheme of the request which in this case is the listener scheme. // scheme of the request which in this case is the listener scheme.
var listenerScheme string var listenerScheme string
switch listener.Protocol { switch listener.Protocol {
case v1alpha2.HTTPProtocolType: case gatev1alpha2.HTTPProtocolType:
listenerScheme = "http" listenerScheme = "http"
case v1alpha2.HTTPSProtocolType: case gatev1alpha2.HTTPSProtocolType:
listenerScheme = "https" listenerScheme = "https"
default: default:
return nil, fmt.Errorf("invalid listener protocol %s", listener.Protocol) return nil, fmt.Errorf("invalid listener protocol %s", listener.Protocol)
@ -1702,7 +1702,7 @@ func loadMiddlewares(listener v1alpha2.Listener, prefix string, filters []v1alph
for i, filter := range filters { for i, filter := range filters {
var middleware *dynamic.Middleware var middleware *dynamic.Middleware
switch filter.Type { switch filter.Type {
case v1alpha2.HTTPRouteFilterRequestRedirect: case gatev1alpha2.HTTPRouteFilterRequestRedirect:
var err error var err error
middleware, err = createRedirectRegexMiddleware(listenerScheme, filter.RequestRedirect) middleware, err = createRedirectRegexMiddleware(listenerScheme, filter.RequestRedirect)
if err != nil { if err != nil {
@ -1724,7 +1724,7 @@ func loadMiddlewares(listener v1alpha2.Listener, prefix string, filters []v1alph
return middlewares, nil return middlewares, nil
} }
func createRedirectRegexMiddleware(scheme string, filter *v1alpha2.HTTPRequestRedirectFilter) (*dynamic.Middleware, error) { func createRedirectRegexMiddleware(scheme string, filter *gatev1alpha2.HTTPRequestRedirectFilter) (*dynamic.Middleware, error) {
// Use the HTTPRequestRedirectFilter scheme if defined. // Use the HTTPRequestRedirectFilter scheme if defined.
filterScheme := scheme filterScheme := scheme
if filter.Scheme != nil { if filter.Scheme != nil {
@ -1802,7 +1802,7 @@ func throttleEvents(ctx context.Context, throttleDuration time.Duration, pool *s
return eventsChanBuffered return eventsChanBuffered
} }
func isTraefikService(ref v1alpha2.BackendRef) bool { func isTraefikService(ref gatev1alpha2.BackendRef) bool {
if ref.Kind == nil || ref.Group == nil { if ref.Kind == nil || ref.Group == nil {
return false return false
} }
@ -1810,13 +1810,13 @@ func isTraefikService(ref v1alpha2.BackendRef) bool {
return *ref.Group == traefikv1alpha1.GroupName && *ref.Kind == kindTraefikService return *ref.Group == traefikv1alpha1.GroupName && *ref.Kind == kindTraefikService
} }
func isInternalService(ref v1alpha2.BackendRef) bool { func isInternalService(ref gatev1alpha2.BackendRef) bool {
return isTraefikService(ref) && strings.HasSuffix(string(ref.Name), "@internal") return isTraefikService(ref) && strings.HasSuffix(string(ref.Name), "@internal")
} }
// makeListenerKey joins protocol, hostname, and port of a listener into a string key. // makeListenerKey joins protocol, hostname, and port of a listener into a string key.
func makeListenerKey(l v1alpha2.Listener) string { func makeListenerKey(l gatev1alpha2.Listener) string {
var hostname v1alpha2.Hostname var hostname gatev1alpha2.Hostname
if l.Hostname != nil { if l.Hostname != nil {
hostname = *l.Hostname hostname = *l.Hostname
} }

442
pkg/provider/kubernetes/gateway/kubernetes_test.go
View file

File diff suppressed because it is too large Load diff

36
pkg/provider/kubernetes/ingress/builder_ingress_test.go
View file

@ -1,9 +1,9 @@
package ingress package ingress
import networkingv1 "k8s.io/api/networking/v1" import netv1 "k8s.io/api/networking/v1"
func buildIngress(opts ...func(*networkingv1.Ingress)) *networkingv1.Ingress { func buildIngress(opts ...func(*netv1.Ingress)) *netv1.Ingress {
i := &networkingv1.Ingress{} i := &netv1.Ingress{}
i.Kind = "Ingress" i.Kind = "Ingress"
for _, opt := range opts { for _, opt := range opts {
opt(i) opt(i)
@ -11,15 +11,15 @@ func buildIngress(opts ...func(*networkingv1.Ingress)) *networkingv1.Ingress {
return i return i
} }
func iNamespace(value string) func(*networkingv1.Ingress) { func iNamespace(value string) func(*netv1.Ingress) {
return func(i *networkingv1.Ingress) { return func(i *netv1.Ingress) {
i.Namespace = value i.Namespace = value
} }
} }
func iRules(opts ...func(*networkingv1.IngressSpec)) func(*networkingv1.Ingress) { func iRules(opts ...func(*netv1.IngressSpec)) func(*netv1.Ingress) {
return func(i *networkingv1.Ingress) { return func(i *netv1.Ingress) {
s := &networkingv1.IngressSpec{} s := &netv1.IngressSpec{}
for _, opt := range opts { for _, opt := range opts {
opt(s) opt(s)
} }
@ -27,9 +27,9 @@ func iRules(opts ...func(*networkingv1.IngressSpec)) func(*networkingv1.Ingress)
} }
} }
func iRule(opts ...func(*networkingv1.IngressRule)) func(*networkingv1.IngressSpec) { func iRule(opts ...func(*netv1.IngressRule)) func(*netv1.IngressSpec) {
return func(spec *networkingv1.IngressSpec) { return func(spec *netv1.IngressSpec) {
r := &networkingv1.IngressRule{} r := &netv1.IngressRule{}
for _, opt := range opts { for _, opt := range opts {
opt(r) opt(r)
} }
@ -37,24 +37,24 @@ func iRule(opts ...func(*networkingv1.IngressRule)) func(*networkingv1.IngressSp
} }
} }
func iHost(name string) func(*networkingv1.IngressRule) { func iHost(name string) func(*netv1.IngressRule) {
return func(rule *networkingv1.IngressRule) { return func(rule *netv1.IngressRule) {
rule.Host = name rule.Host = name
} }
} }
func iTLSes(opts ...func(*networkingv1.IngressTLS)) func(*networkingv1.Ingress) { func iTLSes(opts ...func(*netv1.IngressTLS)) func(*netv1.Ingress) {
return func(i *networkingv1.Ingress) { return func(i *netv1.Ingress) {
for _, opt := range opts { for _, opt := range opts {
iTLS := networkingv1.IngressTLS{} iTLS := netv1.IngressTLS{}
opt(&iTLS) opt(&iTLS)
i.Spec.TLS = append(i.Spec.TLS, iTLS) i.Spec.TLS = append(i.Spec.TLS, iTLS)
} }
} }
} }
func iTLS(secret string, hosts ...string) func(*networkingv1.IngressTLS) { func iTLS(secret string, hosts ...string) func(*netv1.IngressTLS) {
return func(i *networkingv1.IngressTLS) { return func(i *netv1.IngressTLS) {
i.SecretName = secret i.SecretName = secret
i.Hosts = hosts i.Hosts = hosts
} }

86
pkg/provider/kubernetes/ingress/client.go
View file

@ -14,14 +14,14 @@ import (
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s" "github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s"
traefikversion "github.com/traefik/traefik/v3/pkg/version" traefikversion "github.com/traefik/traefik/v3/pkg/version"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1" netv1 "k8s.io/api/networking/v1"
networkingv1beta1 "k8s.io/api/networking/v1beta1" netv1beta1 "k8s.io/api/networking/v1beta1"
kubeerror "k8s.io/apimachinery/pkg/api/errors" kerror "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/client-go/informers" kinformers "k8s.io/client-go/informers"
"k8s.io/client-go/kubernetes" kclientset "k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest" "k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd" "k8s.io/client-go/tools/clientcmd"
) )
@ -40,21 +40,21 @@ type marshaler interface {
// The stores can then be accessed via the Get* functions. // The stores can then be accessed via the Get* functions.
type Client interface { type Client interface {
WatchAll(namespaces []string, stopCh <-chan struct{}) (<-chan interface{}, error) WatchAll(namespaces []string, stopCh <-chan struct{}) (<-chan interface{}, error)
GetIngresses() []*networkingv1.Ingress GetIngresses() []*netv1.Ingress
GetIngressClasses() ([]*networkingv1.IngressClass, error) GetIngressClasses() ([]*netv1.IngressClass, error)
GetService(namespace, name string) (*corev1.Service, bool, error) GetService(namespace, name string) (*corev1.Service, bool, error)
GetSecret(namespace, name string) (*corev1.Secret, bool, error) GetSecret(namespace, name string) (*corev1.Secret, bool, error)
GetEndpoints(namespace, name string) (*corev1.Endpoints, bool, error) GetEndpoints(namespace, name string) (*corev1.Endpoints, bool, error)
UpdateIngressStatus(ing *networkingv1.Ingress, ingStatus []corev1.LoadBalancerIngress) error UpdateIngressStatus(ing *netv1.Ingress, ingStatus []corev1.LoadBalancerIngress) error
GetServerVersion() *version.Version GetServerVersion() *version.Version
} }
type clientWrapper struct { type clientWrapper struct {
clientset kubernetes.Interface clientset kclientset.Interface
factoriesKube map[string]informers.SharedInformerFactory factoriesKube map[string]kinformers.SharedInformerFactory
factoriesSecret map[string]informers.SharedInformerFactory factoriesSecret map[string]kinformers.SharedInformerFactory
factoriesIngress map[string]informers.SharedInformerFactory factoriesIngress map[string]kinformers.SharedInformerFactory
clusterFactory informers.SharedInformerFactory clusterFactory kinformers.SharedInformerFactory
ingressLabelSelector string ingressLabelSelector string
isNamespaceAll bool isNamespaceAll bool
disableIngressClassInformer bool disableIngressClassInformer bool
@ -118,7 +118,7 @@ func createClientFromConfig(c *rest.Config) (*clientWrapper, error) {
runtime.GOARCH, runtime.GOARCH,
) )
clientset, err := kubernetes.NewForConfig(c) clientset, err := kclientset.NewForConfig(c)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -126,12 +126,12 @@ func createClientFromConfig(c *rest.Config) (*clientWrapper, error) {
return newClientImpl(clientset), nil return newClientImpl(clientset), nil
} }
func newClientImpl(clientset kubernetes.Interface) *clientWrapper { func newClientImpl(clientset kclientset.Interface) *clientWrapper {
return &clientWrapper{ return &clientWrapper{
clientset: clientset, clientset: clientset,
factoriesSecret: make(map[string]informers.SharedInformerFactory), factoriesSecret: make(map[string]kinformers.SharedInformerFactory),
factoriesIngress: make(map[string]informers.SharedInformerFactory), factoriesIngress: make(map[string]kinformers.SharedInformerFactory),
factoriesKube: make(map[string]informers.SharedInformerFactory), factoriesKube: make(map[string]kinformers.SharedInformerFactory),
} }
} }
@ -169,7 +169,7 @@ func (c *clientWrapper) WatchAll(namespaces []string, stopCh <-chan struct{}) (<
} }
for _, ns := range namespaces { for _, ns := range namespaces {
factoryIngress := informers.NewSharedInformerFactoryWithOptions(c.clientset, resyncPeriod, informers.WithNamespace(ns), informers.WithTweakListOptions(matchesLabelSelector)) factoryIngress := kinformers.NewSharedInformerFactoryWithOptions(c.clientset, resyncPeriod, kinformers.WithNamespace(ns), kinformers.WithTweakListOptions(matchesLabelSelector))
if supportsNetworkingV1Ingress(serverVersion) { if supportsNetworkingV1Ingress(serverVersion) {
factoryIngress.Networking().V1().Ingresses().Informer().AddEventHandler(eventHandler) factoryIngress.Networking().V1().Ingresses().Informer().AddEventHandler(eventHandler)
@ -179,12 +179,12 @@ func (c *clientWrapper) WatchAll(namespaces []string, stopCh <-chan struct{}) (<
c.factoriesIngress[ns] = factoryIngress c.factoriesIngress[ns] = factoryIngress
factoryKube := informers.NewSharedInformerFactoryWithOptions(c.clientset, resyncPeriod, informers.WithNamespace(ns)) factoryKube := kinformers.NewSharedInformerFactoryWithOptions(c.clientset, resyncPeriod, kinformers.WithNamespace(ns))
factoryKube.Core().V1().Services().Informer().AddEventHandler(eventHandler) factoryKube.Core().V1().Services().Informer().AddEventHandler(eventHandler)
factoryKube.Core().V1().Endpoints().Informer().AddEventHandler(eventHandler) factoryKube.Core().V1().Endpoints().Informer().AddEventHandler(eventHandler)
c.factoriesKube[ns] = factoryKube c.factoriesKube[ns] = factoryKube
factorySecret := informers.NewSharedInformerFactoryWithOptions(c.clientset, resyncPeriod, informers.WithNamespace(ns), informers.WithTweakListOptions(notOwnedByHelm)) factorySecret := kinformers.NewSharedInformerFactoryWithOptions(c.clientset, resyncPeriod, kinformers.WithNamespace(ns), kinformers.WithTweakListOptions(notOwnedByHelm))
factorySecret.Core().V1().Secrets().Informer().AddEventHandler(eventHandler) factorySecret.Core().V1().Secrets().Informer().AddEventHandler(eventHandler)
c.factoriesSecret[ns] = factorySecret c.factoriesSecret[ns] = factorySecret
} }
@ -216,7 +216,7 @@ func (c *clientWrapper) WatchAll(namespaces []string, stopCh <-chan struct{}) (<
} }
if !c.disableIngressClassInformer && supportsIngressClass(serverVersion) { if !c.disableIngressClassInformer && supportsIngressClass(serverVersion) {
c.clusterFactory = informers.NewSharedInformerFactoryWithOptions(c.clientset, resyncPeriod) c.clusterFactory = kinformers.NewSharedInformerFactoryWithOptions(c.clientset, resyncPeriod)
if supportsNetworkingV1Ingress(serverVersion) { if supportsNetworkingV1Ingress(serverVersion) {
c.clusterFactory.Networking().V1().IngressClasses().Informer().AddEventHandler(eventHandler) c.clusterFactory.Networking().V1().IngressClasses().Informer().AddEventHandler(eventHandler)
@ -237,8 +237,8 @@ func (c *clientWrapper) WatchAll(namespaces []string, stopCh <-chan struct{}) (<
} }
// GetIngresses returns all Ingresses for observed namespaces in the cluster. // GetIngresses returns all Ingresses for observed namespaces in the cluster.
func (c *clientWrapper) GetIngresses() []*networkingv1.Ingress { func (c *clientWrapper) GetIngresses() []*netv1.Ingress {
var results []*networkingv1.Ingress var results []*netv1.Ingress
isNetworkingV1Supported := supportsNetworkingV1Ingress(c.serverVersion) isNetworkingV1Supported := supportsNetworkingV1Ingress(c.serverVersion)
@ -277,13 +277,13 @@ func (c *clientWrapper) GetIngresses() []*networkingv1.Ingress {
return results return results
} }
func toNetworkingV1(ing marshaler) (*networkingv1.Ingress, error) { func toNetworkingV1(ing marshaler) (*netv1.Ingress, error) {
data, err := ing.Marshal() data, err := ing.Marshal()
if err != nil { if err != nil {
return nil, err return nil, err
} }
ni := &networkingv1.Ingress{} ni := &netv1.Ingress{}
err = ni.Unmarshal(data) err = ni.Unmarshal(data)
if err != nil { if err != nil {
return nil, err return nil, err
@ -292,13 +292,13 @@ func toNetworkingV1(ing marshaler) (*networkingv1.Ingress, error) {
return ni, nil return ni, nil
} }
func toNetworkingV1IngressClass(ing marshaler) (*networkingv1.IngressClass, error) { func toNetworkingV1IngressClass(ing marshaler) (*netv1.IngressClass, error) {
data, err := ing.Marshal() data, err := ing.Marshal()
if err != nil { if err != nil {
return nil, err return nil, err
} }
ni := &networkingv1.IngressClass{} ni := &netv1.IngressClass{}
err = ni.Unmarshal(data) err = ni.Unmarshal(data)
if err != nil { if err != nil {
return nil, err return nil, err
@ -307,9 +307,9 @@ func toNetworkingV1IngressClass(ing marshaler) (*networkingv1.IngressClass, erro
return ni, nil return ni, nil
} }
func addServiceFromV1Beta1(ing *networkingv1.Ingress, old networkingv1beta1.Ingress) { func addServiceFromV1Beta1(ing *netv1.Ingress, old netv1beta1.Ingress) {
if old.Spec.Backend != nil { if old.Spec.Backend != nil {
port := networkingv1.ServiceBackendPort{} port := netv1.ServiceBackendPort{}
if old.Spec.Backend.ServicePort.Type == intstr.Int { if old.Spec.Backend.ServicePort.Type == intstr.Int {
port.Number = old.Spec.Backend.ServicePort.IntVal port.Number = old.Spec.Backend.ServicePort.IntVal
} else { } else {
@ -317,8 +317,8 @@ func addServiceFromV1Beta1(ing *networkingv1.Ingress, old networkingv1beta1.Ingr
} }
if old.Spec.Backend.ServiceName != "" { if old.Spec.Backend.ServiceName != "" {
ing.Spec.DefaultBackend = &networkingv1.IngressBackend{ ing.Spec.DefaultBackend = &netv1.IngressBackend{
Service: &networkingv1.IngressServiceBackend{ Service: &netv1.IngressServiceBackend{
Name: old.Spec.Backend.ServiceName, Name: old.Spec.Backend.ServiceName,
Port: port, Port: port,
}, },
@ -334,14 +334,14 @@ func addServiceFromV1Beta1(ing *networkingv1.Ingress, old networkingv1beta1.Ingr
if path.Backend.Service == nil { if path.Backend.Service == nil {
oldBackend := old.Spec.Rules[rc].HTTP.Paths[pc].Backend oldBackend := old.Spec.Rules[rc].HTTP.Paths[pc].Backend
port := networkingv1.ServiceBackendPort{} port := netv1.ServiceBackendPort{}
if oldBackend.ServicePort.Type == intstr.Int { if oldBackend.ServicePort.Type == intstr.Int {
port.Number = oldBackend.ServicePort.IntVal port.Number = oldBackend.ServicePort.IntVal
} else { } else {
port.Name = oldBackend.ServicePort.StrVal port.Name = oldBackend.ServicePort.StrVal
} }
svc := networkingv1.IngressServiceBackend{ svc := netv1.IngressServiceBackend{
Name: oldBackend.ServiceName, Name: oldBackend.ServiceName,
Port: port, Port: port,
} }
@ -353,7 +353,7 @@ func addServiceFromV1Beta1(ing *networkingv1.Ingress, old networkingv1beta1.Ingr
} }
// UpdateIngressStatus updates an Ingress with a provided status. // UpdateIngressStatus updates an Ingress with a provided status.
func (c *clientWrapper) UpdateIngressStatus(src *networkingv1.Ingress, ingStatus []corev1.LoadBalancerIngress) error { func (c *clientWrapper) UpdateIngressStatus(src *netv1.Ingress, ingStatus []corev1.LoadBalancerIngress) error {
if !c.isWatchedNamespace(src.Namespace) { if !c.isWatchedNamespace(src.Namespace) {
return fmt.Errorf("failed to get ingress %s/%s: namespace is not within watched namespaces", src.Namespace, src.Name) return fmt.Errorf("failed to get ingress %s/%s: namespace is not within watched namespaces", src.Namespace, src.Name)
} }
@ -375,7 +375,7 @@ func (c *clientWrapper) UpdateIngressStatus(src *networkingv1.Ingress, ingStatus
} }
ingCopy := ing.DeepCopy() ingCopy := ing.DeepCopy()
ingCopy.Status = networkingv1.IngressStatus{LoadBalancer: corev1.LoadBalancerStatus{Ingress: ingStatus}} ingCopy.Status = netv1.IngressStatus{LoadBalancer: corev1.LoadBalancerStatus{Ingress: ingStatus}}
ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
defer cancel() defer cancel()
@ -389,7 +389,7 @@ func (c *clientWrapper) UpdateIngressStatus(src *networkingv1.Ingress, ingStatus
return nil return nil
} }
func (c *clientWrapper) updateIngressStatusOld(src *networkingv1.Ingress, ingStatus []corev1.LoadBalancerIngress) error { func (c *clientWrapper) updateIngressStatusOld(src *netv1.Ingress, ingStatus []corev1.LoadBalancerIngress) error {
ing, err := c.factoriesIngress[c.lookupNamespace(src.Namespace)].Networking().V1beta1().Ingresses().Lister().Ingresses(src.Namespace).Get(src.Name) ing, err := c.factoriesIngress[c.lookupNamespace(src.Namespace)].Networking().V1beta1().Ingresses().Lister().Ingresses(src.Namespace).Get(src.Name)
if err != nil { if err != nil {
return fmt.Errorf("failed to get ingress %s/%s: %w", src.Namespace, src.Name, err) return fmt.Errorf("failed to get ingress %s/%s: %w", src.Namespace, src.Name, err)
@ -403,7 +403,7 @@ func (c *clientWrapper) updateIngressStatusOld(src *networkingv1.Ingress, ingSta
} }
ingCopy := ing.DeepCopy() ingCopy := ing.DeepCopy()
ingCopy.Status = networkingv1beta1.IngressStatus{LoadBalancer: corev1.LoadBalancerStatus{Ingress: ingStatus}} ingCopy.Status = netv1beta1.IngressStatus{LoadBalancer: corev1.LoadBalancerStatus{Ingress: ingStatus}}
ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout) ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
defer cancel() defer cancel()
@ -469,12 +469,12 @@ func (c *clientWrapper) GetSecret(namespace, name string) (*corev1.Secret, bool,
return secret, exist, err return secret, exist, err
} }
func (c *clientWrapper) GetIngressClasses() ([]*networkingv1.IngressClass, error) { func (c *clientWrapper) GetIngressClasses() ([]*netv1.IngressClass, error) {
if c.clusterFactory == nil { if c.clusterFactory == nil {
return nil, errors.New("cluster factory not loaded") return nil, errors.New("cluster factory not loaded")
} }
var ics []*networkingv1.IngressClass var ics []*netv1.IngressClass
if !supportsNetworkingV1Ingress(c.serverVersion) { if !supportsNetworkingV1Ingress(c.serverVersion) {
ingressClasses, err := c.clusterFactory.Networking().V1beta1().IngressClasses().Lister().List(labels.Everything()) ingressClasses, err := c.clusterFactory.Networking().V1beta1().IngressClasses().Lister().List(labels.Everything())
if err != nil { if err != nil {
@ -530,7 +530,7 @@ func (c *clientWrapper) GetServerVersion() *version.Version {
// translateNotFoundError will translate a "not found" error to a boolean return // translateNotFoundError will translate a "not found" error to a boolean return
// value which indicates if the resource exists and a nil error. // value which indicates if the resource exists and a nil error.
func translateNotFoundError(err error) (bool, error) { func translateNotFoundError(err error) (bool, error) {
if kubeerror.IsNotFound(err) { if kerror.IsNotFound(err) {
return false, nil return false, nil
} }
return err == nil, err return err == nil, err
@ -559,8 +559,8 @@ func supportsIngressClass(serverVersion *version.Version) bool {
} }
// filterIngressClassByName return a slice containing ingressclasses with the correct name. // filterIngressClassByName return a slice containing ingressclasses with the correct name.
func filterIngressClassByName(ingressClassName string, ics []*networkingv1.IngressClass) []*networkingv1.IngressClass { func filterIngressClassByName(ingressClassName string, ics []*netv1.IngressClass) []*netv1.IngressClass {
var ingressClasses []*networkingv1.IngressClass var ingressClasses []*netv1.IngressClass
for _, ic := range ics { for _, ic := range ics {
if ic.Name == ingressClassName { if ic.Name == ingressClassName {

22
pkg/provider/kubernetes/ingress/client_mock_test.go
View file

@ -7,18 +7,18 @@ import (
"github.com/hashicorp/go-version" "github.com/hashicorp/go-version"
"github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s" "github.com/traefik/traefik/v3/pkg/provider/kubernetes/k8s"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1" netv1 "k8s.io/api/networking/v1"
networkingv1beta1 "k8s.io/api/networking/v1beta1" netv1beta1 "k8s.io/api/networking/v1beta1"
) )
var _ Client = (*clientMock)(nil) var _ Client = (*clientMock)(nil)
type clientMock struct { type clientMock struct {
ingresses []*networkingv1.Ingress ingresses []*netv1.Ingress
services []*corev1.Service services []*corev1.Service
secrets []*corev1.Secret secrets []*corev1.Secret
endpoints []*corev1.Endpoints endpoints []*corev1.Endpoints
ingressClasses []*networkingv1.IngressClass ingressClasses []*netv1.IngressClass
serverVersion *version.Version serverVersion *version.Version
@ -50,22 +50,22 @@ func newClientMock(serverVersion string, paths ...string) clientMock {
c.secrets = append(c.secrets, o) c.secrets = append(c.secrets, o)
case *corev1.Endpoints: case *corev1.Endpoints:
c.endpoints = append(c.endpoints, o) c.endpoints = append(c.endpoints, o)
case *networkingv1beta1.Ingress: case *netv1beta1.Ingress:
ing, err := toNetworkingV1(o) ing, err := toNetworkingV1(o)
if err != nil { if err != nil {
panic(err) panic(err)
} }
addServiceFromV1Beta1(ing, *o) addServiceFromV1Beta1(ing, *o)
c.ingresses = append(c.ingresses, ing) c.ingresses = append(c.ingresses, ing)
case *networkingv1.Ingress: case *netv1.Ingress:
c.ingresses = append(c.ingresses, o) c.ingresses = append(c.ingresses, o)
case *networkingv1beta1.IngressClass: case *netv1beta1.IngressClass:
ic, err := toNetworkingV1IngressClass(o) ic, err := toNetworkingV1IngressClass(o)
if err != nil { if err != nil {
panic(err) panic(err)
} }
c.ingressClasses = append(c.ingressClasses, ic) c.ingressClasses = append(c.ingressClasses, ic)
case *networkingv1.IngressClass: case *netv1.IngressClass:
c.ingressClasses = append(c.ingressClasses, o) c.ingressClasses = append(c.ingressClasses, o)
default: default:
panic(fmt.Sprintf("Unknown runtime object %+v %T", o, o)) panic(fmt.Sprintf("Unknown runtime object %+v %T", o, o))
@ -76,7 +76,7 @@ func newClientMock(serverVersion string, paths ...string) clientMock {
return c return c
} }
func (c clientMock) GetIngresses() []*networkingv1.Ingress { func (c clientMock) GetIngresses() []*netv1.Ingress {
return c.ingresses return c.ingresses
} }
@ -124,7 +124,7 @@ func (c clientMock) GetSecret(namespace, name string) (*corev1.Secret, bool, err
return nil, false, nil return nil, false, nil
} }
func (c clientMock) GetIngressClasses() ([]*networkingv1.IngressClass, error) { func (c clientMock) GetIngressClasses() ([]*netv1.IngressClass, error) {
return c.ingressClasses, nil return c.ingressClasses, nil
} }
@ -132,6 +132,6 @@ func (c clientMock) WatchAll(namespaces []string, stopCh <-chan struct{}) (<-cha
return c.watchChan, nil return c.watchChan, nil
} }
func (c clientMock) UpdateIngressStatus(_ *networkingv1.Ingress, _ []corev1.LoadBalancerIngress) error { func (c clientMock) UpdateIngressStatus(_ *netv1.Ingress, _ []corev1.LoadBalancerIngress) error {
return c.apiIngressStatusError return c.apiIngressStatusError
} }

36
pkg/provider/kubernetes/ingress/client_test.go
View file

@ -9,13 +9,13 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1" netv1 "k8s.io/api/networking/v1"
"k8s.io/api/networking/v1beta1" netv1beta1 "k8s.io/api/networking/v1beta1"
kubeerror "k8s.io/apimachinery/pkg/api/errors" kerror "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema" kschema "k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/version" kversion "k8s.io/apimachinery/pkg/version"
fakediscovery "k8s.io/client-go/discovery/fake" discoveryfake "k8s.io/client-go/discovery/fake"
kubefake "k8s.io/client-go/kubernetes/fake" kubefake "k8s.io/client-go/kubernetes/fake"
) )
@ -28,7 +28,7 @@ func TestTranslateNotFoundError(t *testing.T) {
}{ }{
{ {
desc: "kubernetes not found error", desc: "kubernetes not found error",
err: kubeerror.NewNotFound(schema.GroupResource{}, "foo"), err: kerror.NewNotFound(kschema.GroupResource{}, "foo"),
expectedExists: false, expectedExists: false,
expectedError: nil, expectedError: nil,
}, },
@ -154,8 +154,8 @@ func TestClientIgnoresHelmOwnedSecrets(t *testing.T) {
kubeClient := kubefake.NewSimpleClientset(helmSecret, secret) kubeClient := kubefake.NewSimpleClientset(helmSecret, secret)
discovery, _ := kubeClient.Discovery().(*fakediscovery.FakeDiscovery) discovery, _ := kubeClient.Discovery().(*discoveryfake.FakeDiscovery)
discovery.FakedServerVersion = &version.Info{ discovery.FakedServerVersion = &kversion.Info{
GitVersion: "v1.19", GitVersion: "v1.19",
} }
@ -223,8 +223,8 @@ func TestClientIgnoresEmptyEndpointUpdates(t *testing.T) {
kubeClient := kubefake.NewSimpleClientset(emptyEndpoint, filledEndpoint) kubeClient := kubefake.NewSimpleClientset(emptyEndpoint, filledEndpoint)
discovery, _ := kubeClient.Discovery().(*fakediscovery.FakeDiscovery) discovery, _ := kubeClient.Discovery().(*discoveryfake.FakeDiscovery)
discovery.FakedServerVersion = &version.Info{ discovery.FakedServerVersion = &kversion.Info{
GitVersion: "v1.19", GitVersion: "v1.19",
} }
@ -291,14 +291,14 @@ func TestClientIgnoresEmptyEndpointUpdates(t *testing.T) {
} }
func TestClientUsesCorrectServerVersion(t *testing.T) { func TestClientUsesCorrectServerVersion(t *testing.T) {
ingressV1Beta := &v1beta1.Ingress{ ingressV1Beta := &netv1beta1.Ingress{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Namespace: "default", Namespace: "default",
Name: "ingress-v1beta", Name: "ingress-v1beta",
}, },
} }
ingressV1 := &networkingv1.Ingress{ ingressV1 := &netv1.Ingress{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Namespace: "default", Namespace: "default",
Name: "ingress-v1", Name: "ingress-v1",
@ -307,8 +307,8 @@ func TestClientUsesCorrectServerVersion(t *testing.T) {
kubeClient := kubefake.NewSimpleClientset(ingressV1Beta, ingressV1) kubeClient := kubefake.NewSimpleClientset(ingressV1Beta, ingressV1)
discovery, _ := kubeClient.Discovery().(*fakediscovery.FakeDiscovery) discovery, _ := kubeClient.Discovery().(*discoveryfake.FakeDiscovery)
discovery.FakedServerVersion = &version.Info{ discovery.FakedServerVersion = &kversion.Info{
GitVersion: "v1.18.12+foobar", GitVersion: "v1.18.12+foobar",
} }
@ -321,7 +321,7 @@ func TestClientUsesCorrectServerVersion(t *testing.T) {
select { select {
case event := <-eventCh: case event := <-eventCh:
ingress, ok := event.(*v1beta1.Ingress) ingress, ok := event.(*netv1beta1.Ingress)
require.True(t, ok) require.True(t, ok)
assert.Equal(t, "ingress-v1beta", ingress.Name) assert.Equal(t, "ingress-v1beta", ingress.Name)
@ -335,7 +335,7 @@ func TestClientUsesCorrectServerVersion(t *testing.T) {
case <-time.After(50 * time.Millisecond): case <-time.After(50 * time.Millisecond):
} }
discovery.FakedServerVersion = &version.Info{ discovery.FakedServerVersion = &kversion.Info{
GitVersion: "v1.19", GitVersion: "v1.19",
} }
@ -344,7 +344,7 @@ func TestClientUsesCorrectServerVersion(t *testing.T) {
select { select {
case event := <-eventCh: case event := <-eventCh:
ingress, ok := event.(*networkingv1.Ingress) ingress, ok := event.(*netv1.Ingress)
require.True(t, ok) require.True(t, ok)
assert.Equal(t, "ingress-v1", ingress.Name) assert.Equal(t, "ingress-v1", ingress.Name)

18
pkg/provider/kubernetes/ingress/kubernetes.go
View file

@ -25,7 +25,7 @@ import (
"github.com/traefik/traefik/v3/pkg/safe" "github.com/traefik/traefik/v3/pkg/safe"
"github.com/traefik/traefik/v3/pkg/tls" "github.com/traefik/traefik/v3/pkg/tls"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1" netv1 "k8s.io/api/networking/v1"
"k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/labels"
) )
@ -195,7 +195,7 @@ func (p *Provider) loadConfigurationFromIngresses(ctx context.Context, client Cl
serverVersion := client.GetServerVersion() serverVersion := client.GetServerVersion()
var ingressClasses []*networkingv1.IngressClass var ingressClasses []*netv1.IngressClass
if !p.DisableIngressClassLookup && supportsIngressClass(serverVersion) { if !p.DisableIngressClassLookup && supportsIngressClass(serverVersion) {
ics, err := client.GetIngressClasses() ics, err := client.GetIngressClasses()
@ -346,7 +346,7 @@ func (p *Provider) loadConfigurationFromIngresses(ctx context.Context, client Cl
return conf return conf
} }
func (p *Provider) updateIngressStatus(ing *networkingv1.Ingress, k8sClient Client) error { func (p *Provider) updateIngressStatus(ing *netv1.Ingress, k8sClient Client) error {
// Only process if an EndpointIngress has been configured. // Only process if an EndpointIngress has been configured.
if p.IngressEndpoint == nil { if p.IngressEndpoint == nil {
return nil return nil
@ -385,7 +385,7 @@ func (p *Provider) updateIngressStatus(ing *networkingv1.Ingress, k8sClient Clie
return k8sClient.UpdateIngressStatus(ing, service.Status.LoadBalancer.Ingress) return k8sClient.UpdateIngressStatus(ing, service.Status.LoadBalancer.Ingress)
} }
func (p *Provider) shouldProcessIngress(ingress *networkingv1.Ingress, ingressClasses []*networkingv1.IngressClass) bool { func (p *Provider) shouldProcessIngress(ingress *netv1.Ingress, ingressClasses []*netv1.IngressClass) bool {
// configuration through the new kubernetes ingressClass // configuration through the new kubernetes ingressClass
if ingress.Spec.IngressClassName != nil { if ingress.Spec.IngressClassName != nil {
for _, ic := range ingressClasses { for _, ic := range ingressClasses {
@ -410,7 +410,7 @@ func buildHostRule(host string) string {
return fmt.Sprintf("Host(`%s`)", host) return fmt.Sprintf("Host(`%s`)", host)
} }
func getCertificates(ctx context.Context, ingress *networkingv1.Ingress, k8sClient Client, tlsConfigs map[string]*tls.CertAndStores) error { func getCertificates(ctx context.Context, ingress *netv1.Ingress, k8sClient Client, tlsConfigs map[string]*tls.CertAndStores) error {
for _, t := range ingress.Spec.TLS { for _, t := range ingress.Spec.TLS {
if t.SecretName == "" { if t.SecretName == "" {
log.Ctx(ctx).Debug().Msg("Skipping TLS sub-section: No secret name provided") log.Ctx(ctx).Debug().Msg("Skipping TLS sub-section: No secret name provided")
@ -495,7 +495,7 @@ func getTLSConfig(tlsConfigs map[string]*tls.CertAndStores) []*tls.CertAndStores
return configs return configs
} }
func (p *Provider) loadService(client Client, namespace string, backend networkingv1.IngressBackend) (*dynamic.Service, error) { func (p *Provider) loadService(client Client, namespace string, backend netv1.IngressBackend) (*dynamic.Service, error) {
service, exists, err := client.GetService(namespace, backend.Service.Name) service, exists, err := client.GetService(namespace, backend.Service.Name)
if err != nil { if err != nil {
return nil, err return nil, err
@ -645,7 +645,7 @@ func makeRouterKeyWithHash(key, rule string) (string, error) {
return dupKey, nil return dupKey, nil
} }
func loadRouter(rule networkingv1.IngressRule, pa networkingv1.HTTPIngressPath, rtConfig *RouterConfig, serviceName string) *dynamic.Router { func loadRouter(rule netv1.IngressRule, pa netv1.HTTPIngressPath, rtConfig *RouterConfig, serviceName string) *dynamic.Router {
var rules []string var rules []string
if len(rule.Host) > 0 { if len(rule.Host) > 0 {
rules = []string{buildHostRule(rule.Host)} rules = []string{buildHostRule(rule.Host)}
@ -654,11 +654,11 @@ func loadRouter(rule networkingv1.IngressRule, pa networkingv1.HTTPIngressPath,
if len(pa.Path) > 0 { if len(pa.Path) > 0 {
matcher := defaultPathMatcher matcher := defaultPathMatcher
if pa.PathType == nil || *pa.PathType == "" || *pa.PathType == networkingv1.PathTypeImplementationSpecific { if pa.PathType == nil || *pa.PathType == "" || *pa.PathType == netv1.PathTypeImplementationSpecific {
if rtConfig != nil && rtConfig.Router != nil && rtConfig.Router.PathMatcher != "" { if rtConfig != nil && rtConfig.Router != nil && rtConfig.Router.PathMatcher != "" {
matcher = rtConfig.Router.PathMatcher matcher = rtConfig.Router.PathMatcher
} }
} else if *pa.PathType == networkingv1.PathTypeExact { } else if *pa.PathType == netv1.PathTypeExact {
matcher = "Path" matcher = "Path"
} }

4
pkg/provider/kubernetes/ingress/kubernetes_test.go
View file

@ -17,7 +17,7 @@ import (
"github.com/traefik/traefik/v3/pkg/tls" "github.com/traefik/traefik/v3/pkg/tls"
"github.com/traefik/traefik/v3/pkg/types" "github.com/traefik/traefik/v3/pkg/types"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1" netv1 "k8s.io/api/networking/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
) )
@ -2160,7 +2160,7 @@ func TestGetCertificates(t *testing.T) {
testCases := []struct { testCases := []struct {
desc string desc string
ingress *networkingv1.Ingress ingress *netv1.Ingress
client Client client Client
result map[string]*tls.CertAndStores result map[string]*tls.CertAndStores
errResult string errResult string

10
pkg/provider/kubernetes/k8s/event_handler_test.go
View file

@ -5,7 +5,7 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
corev1 "k8s.io/api/core/v1" corev1 "k8s.io/api/core/v1"
v1 "k8s.io/api/networking/v1" netv1 "k8s.io/api/networking/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
) )
@ -63,12 +63,12 @@ func Test_detectChanges(t *testing.T) {
}, },
{ {
name: "Ingress With same version", name: "Ingress With same version",
oldObj: &v1.Ingress{ oldObj: &netv1.Ingress{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "1", ResourceVersion: "1",
}, },
}, },
newObj: &v1.Ingress{ newObj: &netv1.Ingress{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "1", ResourceVersion: "1",
}, },
@ -76,12 +76,12 @@ func Test_detectChanges(t *testing.T) {
}, },
{ {
name: "Ingress With different version", name: "Ingress With different version",
oldObj: &v1.Ingress{ oldObj: &netv1.Ingress{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "1", ResourceVersion: "1",
}, },
}, },
newObj: &v1.Ingress{ newObj: &netv1.Ingress{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "2", ResourceVersion: "2",
}, },

4
pkg/provider/kubernetes/k8s/parser.go
View file

@ -7,7 +7,7 @@ import (
"github.com/rs/zerolog/log" "github.com/rs/zerolog/log"
"k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/kubernetes/scheme" kscheme "k8s.io/client-go/kubernetes/scheme"
) )
// MustParseYaml parses a YAML to objects. // MustParseYaml parses a YAML to objects.
@ -21,7 +21,7 @@ func MustParseYaml(content []byte) []runtime.Object {
continue continue
} }
decode := scheme.Codecs.UniversalDeserializer().Decode decode := kscheme.Codecs.UniversalDeserializer().Decode
obj, groupVersionKind, err := decode([]byte(file), nil, nil) obj, groupVersionKind, err := decode([]byte(file), nil, nil)
if err != nil { if err != nil {
panic(fmt.Sprintf("Error while decoding YAML object. Err was: %s", err)) panic(fmt.Sprintf("Error while decoding YAML object. Err was: %s", err))

3
pkg/server/service/roundtripper_test.go
View file

@ -467,9 +467,6 @@ func newFakeSpiffePKI(trustDomain spiffeid.TrustDomain) (fakeSpiffePKI, error) {
IsCA: true, IsCA: true,
PublicKey: caPrivateKey.Public(), PublicKey: caPrivateKey.Public(),
} }
if err != nil {
return fakeSpiffePKI{}, err
}
caCertDER, err := x509.CreateCertificate( caCertDER, err := x509.CreateCertificate(
rand.Reader, rand.Reader,