Fix dependencies

vendor/k8s.io/client-go/discovery/discovery_client.go

@@ -27,7 +27,7 @@ import (
 	"time"
 
 	"github.com/golang/protobuf/proto"
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
+	openapi_v2 "github.com/googleapis/gnostic/OpenAPIv2"
 
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

vendor/k8s.io/client-go/kubernetes/clientset.go

@@ -27,6 +27,7 @@ import (
 	appsv1 "k8s.io/client-go/kubernetes/typed/apps/v1"
 	appsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
 	appsv1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2"
+	auditregistrationv1alpha1 "k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1"
 	authenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1"
 	authenticationv1beta1 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
 	authorizationv1 "k8s.io/client-go/kubernetes/typed/authorization/v1"
@@ -37,14 +38,12 @@ import (
 	batchv1 "k8s.io/client-go/kubernetes/typed/batch/v1"
 	batchv1beta1 "k8s.io/client-go/kubernetes/typed/batch/v1beta1"
 	batchv2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1"
-	certificatesv1 "k8s.io/client-go/kubernetes/typed/certificates/v1"
 	certificatesv1beta1 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
 	coordinationv1 "k8s.io/client-go/kubernetes/typed/coordination/v1"
 	coordinationv1beta1 "k8s.io/client-go/kubernetes/typed/coordination/v1beta1"
 	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
 	discoveryv1alpha1 "k8s.io/client-go/kubernetes/typed/discovery/v1alpha1"
 	discoveryv1beta1 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1"
-	eventsv1 "k8s.io/client-go/kubernetes/typed/events/v1"
 	eventsv1beta1 "k8s.io/client-go/kubernetes/typed/events/v1beta1"
 	extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
 	flowcontrolv1alpha1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1"
@@ -74,6 +73,7 @@ type Interface interface {
 	AppsV1() appsv1.AppsV1Interface
 	AppsV1beta1() appsv1beta1.AppsV1beta1Interface
 	AppsV1beta2() appsv1beta2.AppsV1beta2Interface
+	AuditregistrationV1alpha1() auditregistrationv1alpha1.AuditregistrationV1alpha1Interface
 	AuthenticationV1() authenticationv1.AuthenticationV1Interface
 	AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface
 	AuthorizationV1() authorizationv1.AuthorizationV1Interface
@@ -84,14 +84,12 @@ type Interface interface {
 	BatchV1() batchv1.BatchV1Interface
 	BatchV1beta1() batchv1beta1.BatchV1beta1Interface
 	BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface
-	CertificatesV1() certificatesv1.CertificatesV1Interface
 	CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface
 	CoordinationV1beta1() coordinationv1beta1.CoordinationV1beta1Interface
 	CoordinationV1() coordinationv1.CoordinationV1Interface
 	CoreV1() corev1.CoreV1Interface
 	DiscoveryV1alpha1() discoveryv1alpha1.DiscoveryV1alpha1Interface
 	DiscoveryV1beta1() discoveryv1beta1.DiscoveryV1beta1Interface
-	EventsV1() eventsv1.EventsV1Interface
 	EventsV1beta1() eventsv1beta1.EventsV1beta1Interface
 	ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface
 	FlowcontrolV1alpha1() flowcontrolv1alpha1.FlowcontrolV1alpha1Interface
@@ -121,6 +119,7 @@ type Clientset struct {
 	appsV1                       *appsv1.AppsV1Client
 	appsV1beta1                  *appsv1beta1.AppsV1beta1Client
 	appsV1beta2                  *appsv1beta2.AppsV1beta2Client
+	auditregistrationV1alpha1    *auditregistrationv1alpha1.AuditregistrationV1alpha1Client
 	authenticationV1             *authenticationv1.AuthenticationV1Client
 	authenticationV1beta1        *authenticationv1beta1.AuthenticationV1beta1Client
 	authorizationV1              *authorizationv1.AuthorizationV1Client
@@ -131,14 +130,12 @@ type Clientset struct {
 	batchV1                      *batchv1.BatchV1Client
 	batchV1beta1                 *batchv1beta1.BatchV1beta1Client
 	batchV2alpha1                *batchv2alpha1.BatchV2alpha1Client
-	certificatesV1               *certificatesv1.CertificatesV1Client
 	certificatesV1beta1          *certificatesv1beta1.CertificatesV1beta1Client
 	coordinationV1beta1          *coordinationv1beta1.CoordinationV1beta1Client
 	coordinationV1               *coordinationv1.CoordinationV1Client
 	coreV1                       *corev1.CoreV1Client
 	discoveryV1alpha1            *discoveryv1alpha1.DiscoveryV1alpha1Client
 	discoveryV1beta1             *discoveryv1beta1.DiscoveryV1beta1Client
-	eventsV1                     *eventsv1.EventsV1Client
 	eventsV1beta1                *eventsv1beta1.EventsV1beta1Client
 	extensionsV1beta1            *extensionsv1beta1.ExtensionsV1beta1Client
 	flowcontrolV1alpha1          *flowcontrolv1alpha1.FlowcontrolV1alpha1Client
@@ -184,6 +181,11 @@ func (c *Clientset) AppsV1beta2() appsv1beta2.AppsV1beta2Interface {
 	return c.appsV1beta2
 }
 
+// AuditregistrationV1alpha1 retrieves the AuditregistrationV1alpha1Client
+func (c *Clientset) AuditregistrationV1alpha1() auditregistrationv1alpha1.AuditregistrationV1alpha1Interface {
+	return c.auditregistrationV1alpha1
+}
+
 // AuthenticationV1 retrieves the AuthenticationV1Client
 func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
 	return c.authenticationV1
@@ -234,11 +236,6 @@ func (c *Clientset) BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface {
 	return c.batchV2alpha1
 }
 
-// CertificatesV1 retrieves the CertificatesV1Client
-func (c *Clientset) CertificatesV1() certificatesv1.CertificatesV1Interface {
-	return c.certificatesV1
-}
-
 // CertificatesV1beta1 retrieves the CertificatesV1beta1Client
 func (c *Clientset) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface {
 	return c.certificatesV1beta1
@@ -269,11 +266,6 @@ func (c *Clientset) DiscoveryV1beta1() discoveryv1beta1.DiscoveryV1beta1Interfac
 	return c.discoveryV1beta1
 }
 
-// EventsV1 retrieves the EventsV1Client
-func (c *Clientset) EventsV1() eventsv1.EventsV1Interface {
-	return c.eventsV1
-}
-
 // EventsV1beta1 retrieves the EventsV1beta1Client
 func (c *Clientset) EventsV1beta1() eventsv1beta1.EventsV1beta1Interface {
 	return c.eventsV1beta1
@@ -405,6 +397,10 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
+	cs.auditregistrationV1alpha1, err = auditregistrationv1alpha1.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
 	cs.authenticationV1, err = authenticationv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
@@ -445,10 +441,6 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
-	cs.certificatesV1, err = certificatesv1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
 	cs.certificatesV1beta1, err = certificatesv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
@@ -473,10 +465,6 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
-	cs.eventsV1, err = eventsv1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
 	cs.eventsV1beta1, err = eventsv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
@@ -566,6 +554,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 	cs.appsV1 = appsv1.NewForConfigOrDie(c)
 	cs.appsV1beta1 = appsv1beta1.NewForConfigOrDie(c)
 	cs.appsV1beta2 = appsv1beta2.NewForConfigOrDie(c)
+	cs.auditregistrationV1alpha1 = auditregistrationv1alpha1.NewForConfigOrDie(c)
 	cs.authenticationV1 = authenticationv1.NewForConfigOrDie(c)
 	cs.authenticationV1beta1 = authenticationv1beta1.NewForConfigOrDie(c)
 	cs.authorizationV1 = authorizationv1.NewForConfigOrDie(c)
@@ -576,14 +565,12 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 	cs.batchV1 = batchv1.NewForConfigOrDie(c)
 	cs.batchV1beta1 = batchv1beta1.NewForConfigOrDie(c)
 	cs.batchV2alpha1 = batchv2alpha1.NewForConfigOrDie(c)
-	cs.certificatesV1 = certificatesv1.NewForConfigOrDie(c)
 	cs.certificatesV1beta1 = certificatesv1beta1.NewForConfigOrDie(c)
 	cs.coordinationV1beta1 = coordinationv1beta1.NewForConfigOrDie(c)
 	cs.coordinationV1 = coordinationv1.NewForConfigOrDie(c)
 	cs.coreV1 = corev1.NewForConfigOrDie(c)
 	cs.discoveryV1alpha1 = discoveryv1alpha1.NewForConfigOrDie(c)
 	cs.discoveryV1beta1 = discoveryv1beta1.NewForConfigOrDie(c)
-	cs.eventsV1 = eventsv1.NewForConfigOrDie(c)
 	cs.eventsV1beta1 = eventsv1beta1.NewForConfigOrDie(c)
 	cs.extensionsV1beta1 = extensionsv1beta1.NewForConfigOrDie(c)
 	cs.flowcontrolV1alpha1 = flowcontrolv1alpha1.NewForConfigOrDie(c)
@@ -615,6 +602,7 @@ func New(c rest.Interface) *Clientset {
 	cs.appsV1 = appsv1.New(c)
 	cs.appsV1beta1 = appsv1beta1.New(c)
 	cs.appsV1beta2 = appsv1beta2.New(c)
+	cs.auditregistrationV1alpha1 = auditregistrationv1alpha1.New(c)
 	cs.authenticationV1 = authenticationv1.New(c)
 	cs.authenticationV1beta1 = authenticationv1beta1.New(c)
 	cs.authorizationV1 = authorizationv1.New(c)
@@ -625,14 +613,12 @@ func New(c rest.Interface) *Clientset {
 	cs.batchV1 = batchv1.New(c)
 	cs.batchV1beta1 = batchv1beta1.New(c)
 	cs.batchV2alpha1 = batchv2alpha1.New(c)
-	cs.certificatesV1 = certificatesv1.New(c)
 	cs.certificatesV1beta1 = certificatesv1beta1.New(c)
 	cs.coordinationV1beta1 = coordinationv1beta1.New(c)
 	cs.coordinationV1 = coordinationv1.New(c)
 	cs.coreV1 = corev1.New(c)
 	cs.discoveryV1alpha1 = discoveryv1alpha1.New(c)
 	cs.discoveryV1beta1 = discoveryv1beta1.New(c)
-	cs.eventsV1 = eventsv1.New(c)
 	cs.eventsV1beta1 = eventsv1beta1.New(c)
 	cs.extensionsV1beta1 = extensionsv1beta1.New(c)
 	cs.flowcontrolV1alpha1 = flowcontrolv1alpha1.New(c)

vendor/k8s.io/client-go/kubernetes/scheme/register.go

@@ -24,6 +24,7 @@ import (
 	appsv1 "k8s.io/api/apps/v1"
 	appsv1beta1 "k8s.io/api/apps/v1beta1"
 	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	auditregistrationv1alpha1 "k8s.io/api/auditregistration/v1alpha1"
 	authenticationv1 "k8s.io/api/authentication/v1"
 	authenticationv1beta1 "k8s.io/api/authentication/v1beta1"
 	authorizationv1 "k8s.io/api/authorization/v1"
@@ -34,14 +35,12 @@ import (
 	batchv1 "k8s.io/api/batch/v1"
 	batchv1beta1 "k8s.io/api/batch/v1beta1"
 	batchv2alpha1 "k8s.io/api/batch/v2alpha1"
-	certificatesv1 "k8s.io/api/certificates/v1"
 	certificatesv1beta1 "k8s.io/api/certificates/v1beta1"
 	coordinationv1 "k8s.io/api/coordination/v1"
 	coordinationv1beta1 "k8s.io/api/coordination/v1beta1"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1alpha1 "k8s.io/api/discovery/v1alpha1"
 	discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
-	eventsv1 "k8s.io/api/events/v1"
 	eventsv1beta1 "k8s.io/api/events/v1beta1"
 	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
 	flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
@@ -76,6 +75,7 @@ var localSchemeBuilder = runtime.SchemeBuilder{
 	appsv1.AddToScheme,
 	appsv1beta1.AddToScheme,
 	appsv1beta2.AddToScheme,
+	auditregistrationv1alpha1.AddToScheme,
 	authenticationv1.AddToScheme,
 	authenticationv1beta1.AddToScheme,
 	authorizationv1.AddToScheme,
@@ -86,14 +86,12 @@ var localSchemeBuilder = runtime.SchemeBuilder{
 	batchv1.AddToScheme,
 	batchv1beta1.AddToScheme,
 	batchv2alpha1.AddToScheme,
-	certificatesv1.AddToScheme,
 	certificatesv1beta1.AddToScheme,
 	coordinationv1beta1.AddToScheme,
 	coordinationv1.AddToScheme,
 	corev1.AddToScheme,
 	discoveryv1alpha1.AddToScheme,
 	discoveryv1beta1.AddToScheme,
-	eventsv1.AddToScheme,
 	eventsv1beta1.AddToScheme,
 	extensionsv1beta1.AddToScheme,
 	flowcontrolv1alpha1.AddToScheme,

vendor/k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1/auditregistration_client.go

@@ -16,30 +16,30 @@ limitations under the License.
 
 // Code generated by client-gen. DO NOT EDIT.
 
-package v1
+package v1alpha1
 
 import (
-	v1 "k8s.io/api/certificates/v1"
+	v1alpha1 "k8s.io/api/auditregistration/v1alpha1"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
 
-type CertificatesV1Interface interface {
+type AuditregistrationV1alpha1Interface interface {
 	RESTClient() rest.Interface
-	CertificateSigningRequestsGetter
+	AuditSinksGetter
 }
 
-// CertificatesV1Client is used to interact with features provided by the certificates.k8s.io group.
-type CertificatesV1Client struct {
+// AuditregistrationV1alpha1Client is used to interact with features provided by the auditregistration.k8s.io group.
+type AuditregistrationV1alpha1Client struct {
 	restClient rest.Interface
 }
 
-func (c *CertificatesV1Client) CertificateSigningRequests() CertificateSigningRequestInterface {
-	return newCertificateSigningRequests(c)
+func (c *AuditregistrationV1alpha1Client) AuditSinks() AuditSinkInterface {
+	return newAuditSinks(c)
 }
 
-// NewForConfig creates a new CertificatesV1Client for the given config.
-func NewForConfig(c *rest.Config) (*CertificatesV1Client, error) {
+// NewForConfig creates a new AuditregistrationV1alpha1Client for the given config.
+func NewForConfig(c *rest.Config) (*AuditregistrationV1alpha1Client, error) {
 	config := *c
 	if err := setConfigDefaults(&config); err != nil {
 		return nil, err
@@ -48,12 +48,12 @@ func NewForConfig(c *rest.Config) (*CertificatesV1Client, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &CertificatesV1Client{client}, nil
+	return &AuditregistrationV1alpha1Client{client}, nil
 }
 
-// NewForConfigOrDie creates a new CertificatesV1Client for the given config and
+// NewForConfigOrDie creates a new AuditregistrationV1alpha1Client for the given config and
 // panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *CertificatesV1Client {
+func NewForConfigOrDie(c *rest.Config) *AuditregistrationV1alpha1Client {
 	client, err := NewForConfig(c)
 	if err != nil {
 		panic(err)
@@ -61,13 +61,13 @@ func NewForConfigOrDie(c *rest.Config) *CertificatesV1Client {
 	return client
 }
 
-// New creates a new CertificatesV1Client for the given RESTClient.
-func New(c rest.Interface) *CertificatesV1Client {
-	return &CertificatesV1Client{c}
+// New creates a new AuditregistrationV1alpha1Client for the given RESTClient.
+func New(c rest.Interface) *AuditregistrationV1alpha1Client {
+	return &AuditregistrationV1alpha1Client{c}
 }
 
 func setConfigDefaults(config *rest.Config) error {
-	gv := v1.SchemeGroupVersion
+	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
 	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
@@ -81,7 +81,7 @@ func setConfigDefaults(config *rest.Config) error {
 
 // RESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *CertificatesV1Client) RESTClient() rest.Interface {
+func (c *AuditregistrationV1alpha1Client) RESTClient() rest.Interface {
 	if c == nil {
 		return nil
 	}

vendor/k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1/auditsink.go

@@ -0,0 +1,168 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	"context"
+	"time"
+
+	v1alpha1 "k8s.io/api/auditregistration/v1alpha1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	scheme "k8s.io/client-go/kubernetes/scheme"
+	rest "k8s.io/client-go/rest"
+)
+
+// AuditSinksGetter has a method to return a AuditSinkInterface.
+// A group's client should implement this interface.
+type AuditSinksGetter interface {
+	AuditSinks() AuditSinkInterface
+}
+
+// AuditSinkInterface has methods to work with AuditSink resources.
+type AuditSinkInterface interface {
+	Create(ctx context.Context, auditSink *v1alpha1.AuditSink, opts v1.CreateOptions) (*v1alpha1.AuditSink, error)
+	Update(ctx context.Context, auditSink *v1alpha1.AuditSink, opts v1.UpdateOptions) (*v1alpha1.AuditSink, error)
+	Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
+	DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
+	Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.AuditSink, error)
+	List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.AuditSinkList, error)
+	Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
+	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.AuditSink, err error)
+	AuditSinkExpansion
+}
+
+// auditSinks implements AuditSinkInterface
+type auditSinks struct {
+	client rest.Interface
+}
+
+// newAuditSinks returns a AuditSinks
+func newAuditSinks(c *AuditregistrationV1alpha1Client) *auditSinks {
+	return &auditSinks{
+		client: c.RESTClient(),
+	}
+}
+
+// Get takes name of the auditSink, and returns the corresponding auditSink object, and an error if there is any.
+func (c *auditSinks) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.AuditSink, err error) {
+	result = &v1alpha1.AuditSink{}
+	err = c.client.Get().
+		Resource("auditsinks").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of AuditSinks that match those selectors.
+func (c *auditSinks) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.AuditSinkList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &v1alpha1.AuditSinkList{}
+	err = c.client.Get().
+		Resource("auditsinks").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested auditSinks.
+func (c *auditSinks) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	opts.Watch = true
+	return c.client.Get().
+		Resource("auditsinks").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch(ctx)
+}
+
+// Create takes the representation of a auditSink and creates it.  Returns the server's representation of the auditSink, and an error, if there is any.
+func (c *auditSinks) Create(ctx context.Context, auditSink *v1alpha1.AuditSink, opts v1.CreateOptions) (result *v1alpha1.AuditSink, err error) {
+	result = &v1alpha1.AuditSink{}
+	err = c.client.Post().
+		Resource("auditsinks").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(auditSink).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Update takes the representation of a auditSink and updates it. Returns the server's representation of the auditSink, and an error, if there is any.
+func (c *auditSinks) Update(ctx context.Context, auditSink *v1alpha1.AuditSink, opts v1.UpdateOptions) (result *v1alpha1.AuditSink, err error) {
+	result = &v1alpha1.AuditSink{}
+	err = c.client.Put().
+		Resource("auditsinks").
+		Name(auditSink.Name).
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(auditSink).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Delete takes name of the auditSink and deletes it. Returns an error if one occurs.
+func (c *auditSinks) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("auditsinks").
+		Name(name).
+		Body(&opts).
+		Do(ctx).
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *auditSinks) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	var timeout time.Duration
+	if listOpts.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Resource("auditsinks").
+		VersionedParams(&listOpts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(&opts).
+		Do(ctx).
+		Error()
+}
+
+// Patch applies the patch and returns the patched auditSink.
+func (c *auditSinks) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.AuditSink, err error) {
+	result = &v1alpha1.AuditSink{}
+	err = c.client.Patch(pt).
+		Resource("auditsinks").
+		Name(name).
+		SubResource(subresources...).
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(data).
+		Do(ctx).
+		Into(result)
+	return
+}

vendor/k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1/doc.go

@@ -17,4 +17,4 @@ limitations under the License.
 // Code generated by client-gen. DO NOT EDIT.
 
 // This package has the automatically generated typed clients.
-package v1
+package v1alpha1

vendor/k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1/generated_expansion.go

@@ -16,6 +16,6 @@ limitations under the License.
 
 // Code generated by client-gen. DO NOT EDIT.
 
-package v1
+package v1alpha1
 
-type EventExpansion interface{}
+type AuditSinkExpansion interface{}

vendor/k8s.io/client-go/kubernetes/typed/certificates/v1/certificatesigningrequest.go

@@ -1,200 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	"context"
-	"time"
-
-	v1 "k8s.io/api/certificates/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-// CertificateSigningRequestsGetter has a method to return a CertificateSigningRequestInterface.
-// A group's client should implement this interface.
-type CertificateSigningRequestsGetter interface {
-	CertificateSigningRequests() CertificateSigningRequestInterface
-}
-
-// CertificateSigningRequestInterface has methods to work with CertificateSigningRequest resources.
-type CertificateSigningRequestInterface interface {
-	Create(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.CreateOptions) (*v1.CertificateSigningRequest, error)
-	Update(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (*v1.CertificateSigningRequest, error)
-	UpdateStatus(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (*v1.CertificateSigningRequest, error)
-	Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error
-	DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error
-	Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.CertificateSigningRequest, error)
-	List(ctx context.Context, opts metav1.ListOptions) (*v1.CertificateSigningRequestList, error)
-	Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
-	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.CertificateSigningRequest, err error)
-	UpdateApproval(ctx context.Context, certificateSigningRequestName string, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (*v1.CertificateSigningRequest, error)
-
-	CertificateSigningRequestExpansion
-}
-
-// certificateSigningRequests implements CertificateSigningRequestInterface
-type certificateSigningRequests struct {
-	client rest.Interface
-}
-
-// newCertificateSigningRequests returns a CertificateSigningRequests
-func newCertificateSigningRequests(c *CertificatesV1Client) *certificateSigningRequests {
-	return &certificateSigningRequests{
-		client: c.RESTClient(),
-	}
-}
-
-// Get takes name of the certificateSigningRequest, and returns the corresponding certificateSigningRequest object, and an error if there is any.
-func (c *certificateSigningRequests) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.CertificateSigningRequest, err error) {
-	result = &v1.CertificateSigningRequest{}
-	err = c.client.Get().
-		Resource("certificatesigningrequests").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of CertificateSigningRequests that match those selectors.
-func (c *certificateSigningRequests) List(ctx context.Context, opts metav1.ListOptions) (result *v1.CertificateSigningRequestList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1.CertificateSigningRequestList{}
-	err = c.client.Get().
-		Resource("certificatesigningrequests").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested certificateSigningRequests.
-func (c *certificateSigningRequests) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	opts.Watch = true
-	return c.client.Get().
-		Resource("certificatesigningrequests").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch(ctx)
-}
-
-// Create takes the representation of a certificateSigningRequest and creates it.  Returns the server's representation of the certificateSigningRequest, and an error, if there is any.
-func (c *certificateSigningRequests) Create(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.CreateOptions) (result *v1.CertificateSigningRequest, err error) {
-	result = &v1.CertificateSigningRequest{}
-	err = c.client.Post().
-		Resource("certificatesigningrequests").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(certificateSigningRequest).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Update takes the representation of a certificateSigningRequest and updates it. Returns the server's representation of the certificateSigningRequest, and an error, if there is any.
-func (c *certificateSigningRequests) Update(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (result *v1.CertificateSigningRequest, err error) {
-	result = &v1.CertificateSigningRequest{}
-	err = c.client.Put().
-		Resource("certificatesigningrequests").
-		Name(certificateSigningRequest.Name).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(certificateSigningRequest).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
-func (c *certificateSigningRequests) UpdateStatus(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (result *v1.CertificateSigningRequest, err error) {
-	result = &v1.CertificateSigningRequest{}
-	err = c.client.Put().
-		Resource("certificatesigningrequests").
-		Name(certificateSigningRequest.Name).
-		SubResource("status").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(certificateSigningRequest).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Delete takes name of the certificateSigningRequest and deletes it. Returns an error if one occurs.
-func (c *certificateSigningRequests) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
-	return c.client.Delete().
-		Resource("certificatesigningrequests").
-		Name(name).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *certificateSigningRequests) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error {
-	var timeout time.Duration
-	if listOpts.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Resource("certificatesigningrequests").
-		VersionedParams(&listOpts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// Patch applies the patch and returns the patched certificateSigningRequest.
-func (c *certificateSigningRequests) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.CertificateSigningRequest, err error) {
-	result = &v1.CertificateSigningRequest{}
-	err = c.client.Patch(pt).
-		Resource("certificatesigningrequests").
-		Name(name).
-		SubResource(subresources...).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(data).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// UpdateApproval takes the top resource name and the representation of a certificateSigningRequest and updates it. Returns the server's representation of the certificateSigningRequest, and an error, if there is any.
-func (c *certificateSigningRequests) UpdateApproval(ctx context.Context, certificateSigningRequestName string, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (result *v1.CertificateSigningRequest, err error) {
-	result = &v1.CertificateSigningRequest{}
-	err = c.client.Put().
-		Resource("certificatesigningrequests").
-		Name(certificateSigningRequestName).
-		SubResource("approval").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(certificateSigningRequest).
-		Do(ctx).
-		Into(result)
-	return
-}

vendor/k8s.io/client-go/kubernetes/typed/certificates/v1/doc.go

@@ -1,20 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-// This package has the automatically generated typed clients.
-package v1

vendor/k8s.io/client-go/kubernetes/typed/certificates/v1/generated_expansion.go

@@ -1,21 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1
-
-type CertificateSigningRequestExpansion interface{}

vendor/k8s.io/client-go/kubernetes/typed/core/v1/pod_expansion.go

@@ -22,7 +22,6 @@ import (
 	v1 "k8s.io/api/core/v1"
 	policy "k8s.io/api/policy/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/net"
 	"k8s.io/client-go/kubernetes/scheme"
 	restclient "k8s.io/client-go/rest"
 )
@@ -32,7 +31,6 @@ type PodExpansion interface {
 	Bind(ctx context.Context, binding *v1.Binding, opts metav1.CreateOptions) error
 	Evict(ctx context.Context, eviction *policy.Eviction) error
 	GetLogs(name string, opts *v1.PodLogOptions) *restclient.Request
-	ProxyGet(scheme, name, port, path string, params map[string]string) restclient.ResponseWrapper
 }
 
 // Bind applies the provided binding to the named pod in the current namespace (binding.Namespace is ignored).
@@ -48,17 +46,3 @@ func (c *pods) Evict(ctx context.Context, eviction *policy.Eviction) error {
 func (c *pods) GetLogs(name string, opts *v1.PodLogOptions) *restclient.Request {
 	return c.client.Get().Namespace(c.ns).Name(name).Resource("pods").SubResource("log").VersionedParams(opts, scheme.ParameterCodec)
 }
-
-// ProxyGet returns a response of the pod by calling it through the proxy.
-func (c *pods) ProxyGet(scheme, name, port, path string, params map[string]string) restclient.ResponseWrapper {
-	request := c.client.Get().
-		Namespace(c.ns).
-		Resource("pods").
-		SubResource("proxy").
-		Name(net.JoinSchemeNamePort(scheme, name, port)).
-		Suffix(path)
-	for k, v := range params {
-		request = request.Param(k, v)
-	}
-	return request
-}

vendor/k8s.io/client-go/kubernetes/typed/events/v1/event.go

@@ -1,178 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	"context"
-	"time"
-
-	v1 "k8s.io/api/events/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-// EventsGetter has a method to return a EventInterface.
-// A group's client should implement this interface.
-type EventsGetter interface {
-	Events(namespace string) EventInterface
-}
-
-// EventInterface has methods to work with Event resources.
-type EventInterface interface {
-	Create(ctx context.Context, event *v1.Event, opts metav1.CreateOptions) (*v1.Event, error)
-	Update(ctx context.Context, event *v1.Event, opts metav1.UpdateOptions) (*v1.Event, error)
-	Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error
-	DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error
-	Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Event, error)
-	List(ctx context.Context, opts metav1.ListOptions) (*v1.EventList, error)
-	Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
-	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Event, err error)
-	EventExpansion
-}
-
-// events implements EventInterface
-type events struct {
-	client rest.Interface
-	ns     string
-}
-
-// newEvents returns a Events
-func newEvents(c *EventsV1Client, namespace string) *events {
-	return &events{
-		client: c.RESTClient(),
-		ns:     namespace,
-	}
-}
-
-// Get takes name of the event, and returns the corresponding event object, and an error if there is any.
-func (c *events) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.Event, err error) {
-	result = &v1.Event{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("events").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of Events that match those selectors.
-func (c *events) List(ctx context.Context, opts metav1.ListOptions) (result *v1.EventList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1.EventList{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("events").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested events.
-func (c *events) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	opts.Watch = true
-	return c.client.Get().
-		Namespace(c.ns).
-		Resource("events").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch(ctx)
-}
-
-// Create takes the representation of a event and creates it.  Returns the server's representation of the event, and an error, if there is any.
-func (c *events) Create(ctx context.Context, event *v1.Event, opts metav1.CreateOptions) (result *v1.Event, err error) {
-	result = &v1.Event{}
-	err = c.client.Post().
-		Namespace(c.ns).
-		Resource("events").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(event).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Update takes the representation of a event and updates it. Returns the server's representation of the event, and an error, if there is any.
-func (c *events) Update(ctx context.Context, event *v1.Event, opts metav1.UpdateOptions) (result *v1.Event, err error) {
-	result = &v1.Event{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("events").
-		Name(event.Name).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(event).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Delete takes name of the event and deletes it. Returns an error if one occurs.
-func (c *events) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("events").
-		Name(name).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *events) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error {
-	var timeout time.Duration
-	if listOpts.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("events").
-		VersionedParams(&listOpts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// Patch applies the patch and returns the patched event.
-func (c *events) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Event, err error) {
-	result = &v1.Event{}
-	err = c.client.Patch(pt).
-		Namespace(c.ns).
-		Resource("events").
-		Name(name).
-		SubResource(subresources...).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(data).
-		Do(ctx).
-		Into(result)
-	return
-}

vendor/k8s.io/client-go/kubernetes/typed/events/v1/events_client.go

@@ -1,89 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	v1 "k8s.io/api/events/v1"
-	"k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-type EventsV1Interface interface {
-	RESTClient() rest.Interface
-	EventsGetter
-}
-
-// EventsV1Client is used to interact with features provided by the events.k8s.io group.
-type EventsV1Client struct {
-	restClient rest.Interface
-}
-
-func (c *EventsV1Client) Events(namespace string) EventInterface {
-	return newEvents(c, namespace)
-}
-
-// NewForConfig creates a new EventsV1Client for the given config.
-func NewForConfig(c *rest.Config) (*EventsV1Client, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &EventsV1Client{client}, nil
-}
-
-// NewForConfigOrDie creates a new EventsV1Client for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *EventsV1Client {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new EventsV1Client for the given RESTClient.
-func New(c rest.Interface) *EventsV1Client {
-	return &EventsV1Client{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	gv := v1.SchemeGroupVersion
-	config.GroupVersion = &gv
-	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
-
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-
-	return nil
-}
-
-// RESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *EventsV1Client) RESTClient() rest.Interface {
-	if c == nil {
-		return nil
-	}
-	return c.restClient
-}

vendor/k8s.io/client-go/kubernetes/typed/networking/v1/generated_expansion.go

@@ -18,8 +18,4 @@ limitations under the License.
 
 package v1
 
-type IngressExpansion interface{}
-
-type IngressClassExpansion interface{}
-
 type NetworkPolicyExpansion interface{}

vendor/k8s.io/client-go/kubernetes/typed/networking/v1/ingress.go

@@ -1,195 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	"context"
-	"time"
-
-	v1 "k8s.io/api/networking/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-// IngressesGetter has a method to return a IngressInterface.
-// A group's client should implement this interface.
-type IngressesGetter interface {
-	Ingresses(namespace string) IngressInterface
-}
-
-// IngressInterface has methods to work with Ingress resources.
-type IngressInterface interface {
-	Create(ctx context.Context, ingress *v1.Ingress, opts metav1.CreateOptions) (*v1.Ingress, error)
-	Update(ctx context.Context, ingress *v1.Ingress, opts metav1.UpdateOptions) (*v1.Ingress, error)
-	UpdateStatus(ctx context.Context, ingress *v1.Ingress, opts metav1.UpdateOptions) (*v1.Ingress, error)
-	Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error
-	DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error
-	Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Ingress, error)
-	List(ctx context.Context, opts metav1.ListOptions) (*v1.IngressList, error)
-	Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
-	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Ingress, err error)
-	IngressExpansion
-}
-
-// ingresses implements IngressInterface
-type ingresses struct {
-	client rest.Interface
-	ns     string
-}
-
-// newIngresses returns a Ingresses
-func newIngresses(c *NetworkingV1Client, namespace string) *ingresses {
-	return &ingresses{
-		client: c.RESTClient(),
-		ns:     namespace,
-	}
-}
-
-// Get takes name of the ingress, and returns the corresponding ingress object, and an error if there is any.
-func (c *ingresses) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.Ingress, err error) {
-	result = &v1.Ingress{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("ingresses").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of Ingresses that match those selectors.
-func (c *ingresses) List(ctx context.Context, opts metav1.ListOptions) (result *v1.IngressList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1.IngressList{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("ingresses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested ingresses.
-func (c *ingresses) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	opts.Watch = true
-	return c.client.Get().
-		Namespace(c.ns).
-		Resource("ingresses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch(ctx)
-}
-
-// Create takes the representation of a ingress and creates it.  Returns the server's representation of the ingress, and an error, if there is any.
-func (c *ingresses) Create(ctx context.Context, ingress *v1.Ingress, opts metav1.CreateOptions) (result *v1.Ingress, err error) {
-	result = &v1.Ingress{}
-	err = c.client.Post().
-		Namespace(c.ns).
-		Resource("ingresses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(ingress).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Update takes the representation of a ingress and updates it. Returns the server's representation of the ingress, and an error, if there is any.
-func (c *ingresses) Update(ctx context.Context, ingress *v1.Ingress, opts metav1.UpdateOptions) (result *v1.Ingress, err error) {
-	result = &v1.Ingress{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("ingresses").
-		Name(ingress.Name).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(ingress).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
-func (c *ingresses) UpdateStatus(ctx context.Context, ingress *v1.Ingress, opts metav1.UpdateOptions) (result *v1.Ingress, err error) {
-	result = &v1.Ingress{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("ingresses").
-		Name(ingress.Name).
-		SubResource("status").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(ingress).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Delete takes name of the ingress and deletes it. Returns an error if one occurs.
-func (c *ingresses) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("ingresses").
-		Name(name).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *ingresses) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error {
-	var timeout time.Duration
-	if listOpts.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("ingresses").
-		VersionedParams(&listOpts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// Patch applies the patch and returns the patched ingress.
-func (c *ingresses) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Ingress, err error) {
-	result = &v1.Ingress{}
-	err = c.client.Patch(pt).
-		Namespace(c.ns).
-		Resource("ingresses").
-		Name(name).
-		SubResource(subresources...).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(data).
-		Do(ctx).
-		Into(result)
-	return
-}

vendor/k8s.io/client-go/kubernetes/typed/networking/v1/ingressclass.go

@@ -1,168 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	"context"
-	"time"
-
-	v1 "k8s.io/api/networking/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-// IngressClassesGetter has a method to return a IngressClassInterface.
-// A group's client should implement this interface.
-type IngressClassesGetter interface {
-	IngressClasses() IngressClassInterface
-}
-
-// IngressClassInterface has methods to work with IngressClass resources.
-type IngressClassInterface interface {
-	Create(ctx context.Context, ingressClass *v1.IngressClass, opts metav1.CreateOptions) (*v1.IngressClass, error)
-	Update(ctx context.Context, ingressClass *v1.IngressClass, opts metav1.UpdateOptions) (*v1.IngressClass, error)
-	Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error
-	DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error
-	Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.IngressClass, error)
-	List(ctx context.Context, opts metav1.ListOptions) (*v1.IngressClassList, error)
-	Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
-	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.IngressClass, err error)
-	IngressClassExpansion
-}
-
-// ingressClasses implements IngressClassInterface
-type ingressClasses struct {
-	client rest.Interface
-}
-
-// newIngressClasses returns a IngressClasses
-func newIngressClasses(c *NetworkingV1Client) *ingressClasses {
-	return &ingressClasses{
-		client: c.RESTClient(),
-	}
-}
-
-// Get takes name of the ingressClass, and returns the corresponding ingressClass object, and an error if there is any.
-func (c *ingressClasses) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.IngressClass, err error) {
-	result = &v1.IngressClass{}
-	err = c.client.Get().
-		Resource("ingressclasses").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of IngressClasses that match those selectors.
-func (c *ingressClasses) List(ctx context.Context, opts metav1.ListOptions) (result *v1.IngressClassList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1.IngressClassList{}
-	err = c.client.Get().
-		Resource("ingressclasses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested ingressClasses.
-func (c *ingressClasses) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	opts.Watch = true
-	return c.client.Get().
-		Resource("ingressclasses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch(ctx)
-}
-
-// Create takes the representation of a ingressClass and creates it.  Returns the server's representation of the ingressClass, and an error, if there is any.
-func (c *ingressClasses) Create(ctx context.Context, ingressClass *v1.IngressClass, opts metav1.CreateOptions) (result *v1.IngressClass, err error) {
-	result = &v1.IngressClass{}
-	err = c.client.Post().
-		Resource("ingressclasses").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(ingressClass).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Update takes the representation of a ingressClass and updates it. Returns the server's representation of the ingressClass, and an error, if there is any.
-func (c *ingressClasses) Update(ctx context.Context, ingressClass *v1.IngressClass, opts metav1.UpdateOptions) (result *v1.IngressClass, err error) {
-	result = &v1.IngressClass{}
-	err = c.client.Put().
-		Resource("ingressclasses").
-		Name(ingressClass.Name).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(ingressClass).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Delete takes name of the ingressClass and deletes it. Returns an error if one occurs.
-func (c *ingressClasses) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error {
-	return c.client.Delete().
-		Resource("ingressclasses").
-		Name(name).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *ingressClasses) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error {
-	var timeout time.Duration
-	if listOpts.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Resource("ingressclasses").
-		VersionedParams(&listOpts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// Patch applies the patch and returns the patched ingressClass.
-func (c *ingressClasses) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.IngressClass, err error) {
-	result = &v1.IngressClass{}
-	err = c.client.Patch(pt).
-		Resource("ingressclasses").
-		Name(name).
-		SubResource(subresources...).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(data).
-		Do(ctx).
-		Into(result)
-	return
-}

vendor/k8s.io/client-go/kubernetes/typed/networking/v1/networking_client.go

@@ -26,8 +26,6 @@ import (
 
 type NetworkingV1Interface interface {
 	RESTClient() rest.Interface
-	IngressesGetter
-	IngressClassesGetter
 	NetworkPoliciesGetter
 }
 
@@ -36,14 +34,6 @@ type NetworkingV1Client struct {
 	restClient rest.Interface
 }
 
-func (c *NetworkingV1Client) Ingresses(namespace string) IngressInterface {
-	return newIngresses(c, namespace)
-}
-
-func (c *NetworkingV1Client) IngressClasses() IngressClassInterface {
-	return newIngressClasses(c)
-}
-
 func (c *NetworkingV1Client) NetworkPolicies(namespace string) NetworkPolicyInterface {
 	return newNetworkPolicies(c, namespace)
 }

vendor/k8s.io/client-go/kubernetes/typed/storage/v1alpha1/csistoragecapacity.go

@@ -1,178 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	"context"
-	"time"
-
-	v1alpha1 "k8s.io/api/storage/v1alpha1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	scheme "k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-// CSIStorageCapacitiesGetter has a method to return a CSIStorageCapacityInterface.
-// A group's client should implement this interface.
-type CSIStorageCapacitiesGetter interface {
-	CSIStorageCapacities(namespace string) CSIStorageCapacityInterface
-}
-
-// CSIStorageCapacityInterface has methods to work with CSIStorageCapacity resources.
-type CSIStorageCapacityInterface interface {
-	Create(ctx context.Context, cSIStorageCapacity *v1alpha1.CSIStorageCapacity, opts v1.CreateOptions) (*v1alpha1.CSIStorageCapacity, error)
-	Update(ctx context.Context, cSIStorageCapacity *v1alpha1.CSIStorageCapacity, opts v1.UpdateOptions) (*v1alpha1.CSIStorageCapacity, error)
-	Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
-	DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
-	Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.CSIStorageCapacity, error)
-	List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.CSIStorageCapacityList, error)
-	Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
-	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.CSIStorageCapacity, err error)
-	CSIStorageCapacityExpansion
-}
-
-// cSIStorageCapacities implements CSIStorageCapacityInterface
-type cSIStorageCapacities struct {
-	client rest.Interface
-	ns     string
-}
-
-// newCSIStorageCapacities returns a CSIStorageCapacities
-func newCSIStorageCapacities(c *StorageV1alpha1Client, namespace string) *cSIStorageCapacities {
-	return &cSIStorageCapacities{
-		client: c.RESTClient(),
-		ns:     namespace,
-	}
-}
-
-// Get takes name of the cSIStorageCapacity, and returns the corresponding cSIStorageCapacity object, and an error if there is any.
-func (c *cSIStorageCapacities) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.CSIStorageCapacity, err error) {
-	result = &v1alpha1.CSIStorageCapacity{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("csistoragecapacities").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of CSIStorageCapacities that match those selectors.
-func (c *cSIStorageCapacities) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.CSIStorageCapacityList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1alpha1.CSIStorageCapacityList{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("csistoragecapacities").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested cSIStorageCapacities.
-func (c *cSIStorageCapacities) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	opts.Watch = true
-	return c.client.Get().
-		Namespace(c.ns).
-		Resource("csistoragecapacities").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch(ctx)
-}
-
-// Create takes the representation of a cSIStorageCapacity and creates it.  Returns the server's representation of the cSIStorageCapacity, and an error, if there is any.
-func (c *cSIStorageCapacities) Create(ctx context.Context, cSIStorageCapacity *v1alpha1.CSIStorageCapacity, opts v1.CreateOptions) (result *v1alpha1.CSIStorageCapacity, err error) {
-	result = &v1alpha1.CSIStorageCapacity{}
-	err = c.client.Post().
-		Namespace(c.ns).
-		Resource("csistoragecapacities").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(cSIStorageCapacity).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Update takes the representation of a cSIStorageCapacity and updates it. Returns the server's representation of the cSIStorageCapacity, and an error, if there is any.
-func (c *cSIStorageCapacities) Update(ctx context.Context, cSIStorageCapacity *v1alpha1.CSIStorageCapacity, opts v1.UpdateOptions) (result *v1alpha1.CSIStorageCapacity, err error) {
-	result = &v1alpha1.CSIStorageCapacity{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("csistoragecapacities").
-		Name(cSIStorageCapacity.Name).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(cSIStorageCapacity).
-		Do(ctx).
-		Into(result)
-	return
-}
-
-// Delete takes name of the cSIStorageCapacity and deletes it. Returns an error if one occurs.
-func (c *cSIStorageCapacities) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("csistoragecapacities").
-		Name(name).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *cSIStorageCapacities) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
-	var timeout time.Duration
-	if listOpts.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("csistoragecapacities").
-		VersionedParams(&listOpts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(&opts).
-		Do(ctx).
-		Error()
-}
-
-// Patch applies the patch and returns the patched cSIStorageCapacity.
-func (c *cSIStorageCapacities) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.CSIStorageCapacity, err error) {
-	result = &v1alpha1.CSIStorageCapacity{}
-	err = c.client.Patch(pt).
-		Namespace(c.ns).
-		Resource("csistoragecapacities").
-		Name(name).
-		SubResource(subresources...).
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Body(data).
-		Do(ctx).
-		Into(result)
-	return
-}

vendor/k8s.io/client-go/kubernetes/typed/storage/v1alpha1/generated_expansion.go

@@ -18,6 +18,4 @@ limitations under the License.
 
 package v1alpha1
 
-type CSIStorageCapacityExpansion interface{}
-
 type VolumeAttachmentExpansion interface{}

vendor/k8s.io/client-go/kubernetes/typed/storage/v1alpha1/storage_client.go

@@ -26,7 +26,6 @@ import (
 
 type StorageV1alpha1Interface interface {
 	RESTClient() rest.Interface
-	CSIStorageCapacitiesGetter
 	VolumeAttachmentsGetter
 }
 
@@ -35,10 +34,6 @@ type StorageV1alpha1Client struct {
 	restClient rest.Interface
 }
 
-func (c *StorageV1alpha1Client) CSIStorageCapacities(namespace string) CSIStorageCapacityInterface {
-	return newCSIStorageCapacities(c, namespace)
-}
-
 func (c *StorageV1alpha1Client) VolumeAttachments() VolumeAttachmentInterface {
 	return newVolumeAttachments(c)
 }

vendor/k8s.io/client-go/plugin/pkg/client/auth/exec/exec.go

@@ -29,7 +29,6 @@ import (
 	"os"
 	"os/exec"
 	"reflect"
-	"strings"
 	"sync"
 	"time"
 
@@ -39,7 +38,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/apimachinery/pkg/util/clock"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/client-go/pkg/apis/clientauthentication"
 	"k8s.io/client-go/pkg/apis/clientauthentication/v1alpha1"
@@ -48,17 +46,11 @@ import (
 	"k8s.io/client-go/tools/metrics"
 	"k8s.io/client-go/transport"
 	"k8s.io/client-go/util/connrotation"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 )
 
 const execInfoEnv = "KUBERNETES_EXEC_INFO"
 const onRotateListWarningLength = 1000
-const installHintVerboseHelp = `
-
-It looks like you are trying to use a client-go credential plugin that is not installed.
-
-To learn more about this feature, consult the documentation available at:
-      https://kubernetes.io/docs/reference/access-authn-authz/authentication/#client-go-credential-plugins`
 
 var scheme = runtime.NewScheme()
 var codecs = serializer.NewCodecFactory(scheme)
@@ -116,44 +108,6 @@ func (c *cache) put(s string, a *Authenticator) *Authenticator {
 	return a
 }
 
-// sometimes rate limits how often a function f() is called. Specifically, Do()
-// will run the provided function f() up to threshold times every interval
-// duration.
-type sometimes struct {
-	threshold int
-	interval  time.Duration
-
-	clock clock.Clock
-	mu    sync.Mutex
-
-	count  int       // times we have called f() in this window
-	window time.Time // beginning of current window of length interval
-}
-
-func (s *sometimes) Do(f func()) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	now := s.clock.Now()
-	if s.window.IsZero() {
-		s.window = now
-	}
-
-	// If we are no longer in our saved time window, then we get to reset our run
-	// count back to 0 and start increasing towards the threshold again.
-	if inWindow := now.Sub(s.window) < s.interval; !inWindow {
-		s.window = now
-		s.count = 0
-	}
-
-	// If we have not run the function more than threshold times in this current
-	// time window, we get to run it now!
-	if underThreshold := s.count < s.threshold; underThreshold {
-		s.count++
-		f()
-	}
-}
-
 // GetAuthenticator returns an exec-based plugin for providing client credentials.
 func GetAuthenticator(config *api.ExecConfig) (*Authenticator, error) {
 	return newAuthenticator(globalCache, config)
@@ -175,13 +129,6 @@ func newAuthenticator(c *cache, config *api.ExecConfig) (*Authenticator, error)
 		args:  config.Args,
 		group: gv,
 
-		installHint: config.InstallHint,
-		sometimes: &sometimes{
-			threshold: 10,
-			interval:  time.Hour,
-			clock:     clock.RealClock{},
-		},
-
 		stdin:       os.Stdin,
 		stderr:      os.Stderr,
 		interactive: terminal.IsTerminal(int(os.Stdout.Fd())),
@@ -205,12 +152,6 @@ type Authenticator struct {
 	group schema.GroupVersion
 	env   []string
 
-	// Used to avoid log spew by rate limiting install hint printing. We didn't do
-	// this by interval based rate limiting alone since that way may have prevented
-	// the install hint from showing up for kubectl users.
-	sometimes   *sometimes
-	installHint string
-
 	// Stubbable for testing
 	stdin       io.Reader
 	stderr      io.Writer
@@ -237,15 +178,6 @@ type credentials struct {
 // UpdateTransportConfig updates the transport.Config to use credentials
 // returned by the plugin.
 func (a *Authenticator) UpdateTransportConfig(c *transport.Config) error {
-	// If a bearer token is present in the request - avoid the GetCert callback when
-	// setting up the transport, as that triggers the exec action if the server is
-	// also configured to allow client certificates for authentication. For requests
-	// like "kubectl get --token (token) pods" we should assume the intention is to
-	// use the provided token for authentication.
-	if c.HasTokenAuth() {
-		return nil
-	}
-
 	c.Wrap(func(rt http.RoundTripper) http.RoundTripper {
 		return &roundTripper{a, rt}
 	})
@@ -391,7 +323,7 @@ func (a *Authenticator) refreshCredsLocked(r *clientauthentication.Response) err
 	}
 
 	if err := cmd.Run(); err != nil {
-		return a.wrapCmdRunErrorLocked(err)
+		return fmt.Errorf("exec: %v", err)
 	}
 
 	_, gvk, err := codecs.UniversalDecoder(a.group).Decode(stdout.Bytes(), nil, cred)
@@ -462,35 +394,3 @@ func (a *Authenticator) refreshCredsLocked(r *clientauthentication.Response) err
 	expirationMetrics.set(a, expiry)
 	return nil
 }
-
-// wrapCmdRunErrorLocked pulls out the code to construct a helpful error message
-// for when the exec plugin's binary fails to Run().
-//
-// It must be called while holding the Authenticator's mutex.
-func (a *Authenticator) wrapCmdRunErrorLocked(err error) error {
-	switch err.(type) {
-	case *exec.Error: // Binary does not exist (see exec.Error).
-		builder := strings.Builder{}
-		fmt.Fprintf(&builder, "exec: executable %s not found", a.cmd)
-
-		a.sometimes.Do(func() {
-			fmt.Fprint(&builder, installHintVerboseHelp)
-			if a.installHint != "" {
-				fmt.Fprintf(&builder, "\n\n%s", a.installHint)
-			}
-		})
-
-		return errors.New(builder.String())
-
-	case *exec.ExitError: // Binary execution failed (see exec.Cmd.Run()).
-		e := err.(*exec.ExitError)
-		return fmt.Errorf(
-			"exec: executable %s failed with exit code %d",
-			a.cmd,
-			e.ProcessState.ExitCode(),
-		)
-
-	default:
-		return fmt.Errorf("exec: %v", err)
-	}
-}

vendor/k8s.io/client-go/plugin/pkg/client/auth/gcp/gcp.go

@@ -33,7 +33,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/yaml"
 	restclient "k8s.io/client-go/rest"
 	"k8s.io/client-go/util/jsonpath"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 )
 
 func init() {

vendor/k8s.io/client-go/rest/client.go

@@ -94,10 +94,6 @@ type RESTClient struct {
 	// overridden.
 	rateLimiter flowcontrol.RateLimiter
 
-	// warningHandler is shared among all requests created by this client.
-	// If not set, defaultWarningHandler is used.
-	warningHandler WarningHandler
-
 	// Set specific behavior of the client.  If not set http.DefaultClient will be used.
 	Client *http.Client
 }

vendor/k8s.io/client-go/rest/config.go

@@ -23,7 +23,6 @@ import (
 	"io/ioutil"
 	"net"
 	"net/http"
-	"net/url"
 	"os"
 	"path/filepath"
 	gruntime "runtime"
@@ -38,7 +37,7 @@ import (
 	"k8s.io/client-go/transport"
 	certutil "k8s.io/client-go/util/cert"
 	"k8s.io/client-go/util/flowcontrol"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 )
 
 const (
@@ -123,23 +122,12 @@ type Config struct {
 	// Rate limiter for limiting connections to the master from this client. If present overwrites QPS/Burst
 	RateLimiter flowcontrol.RateLimiter
 
-	// WarningHandler handles warnings in server responses.
-	// If not set, the default warning handler is used.
-	WarningHandler WarningHandler
-
 	// The maximum length of time to wait before giving up on a server request. A value of zero means no timeout.
 	Timeout time.Duration
 
 	// Dial specifies the dial function for creating unencrypted TCP connections.
 	Dial func(ctx context.Context, network, address string) (net.Conn, error)
 
-	// Proxy is the the proxy func to be used for all requests made by this
-	// transport. If Proxy is nil, http.ProxyFromEnvironment is used. If Proxy
-	// returns a nil *URL, no proxy is used.
-	//
-	// socks5 proxying does not currently support spdy streaming endpoints.
-	Proxy func(*http.Request) (*url.URL, error)
-
 	// Version forces a specific version to be used (if registered)
 	// Do we need this?
 	// Version string
@@ -343,11 +331,7 @@ func RESTClientFor(config *Config) (*RESTClient, error) {
 		Negotiator:         runtime.NewClientNegotiator(config.NegotiatedSerializer, gv),
 	}
 
-	restClient, err := NewRESTClient(baseURL, versionedAPIPath, clientContent, rateLimiter, httpClient)
-	if err == nil && config.WarningHandler != nil {
-		restClient.warningHandler = config.WarningHandler
-	}
-	return restClient, err
+	return NewRESTClient(baseURL, versionedAPIPath, clientContent, rateLimiter, httpClient)
 }
 
 // UnversionedRESTClientFor is the same as RESTClientFor, except that it allows
@@ -401,11 +385,7 @@ func UnversionedRESTClientFor(config *Config) (*RESTClient, error) {
 		Negotiator:         runtime.NewClientNegotiator(config.NegotiatedSerializer, gv),
 	}
 
-	restClient, err := NewRESTClient(baseURL, versionedAPIPath, clientContent, rateLimiter, httpClient)
-	if err == nil && config.WarningHandler != nil {
-		restClient.warningHandler = config.WarningHandler
-	}
-	return restClient, err
+	return NewRESTClient(baseURL, versionedAPIPath, clientContent, rateLimiter, httpClient)
 }
 
 // SetKubernetesDefaults sets default values on the provided client config for accessing the
@@ -574,14 +554,12 @@ func AnonymousClientConfig(config *Config) *Config {
 			NextProtos: config.TLSClientConfig.NextProtos,
 		},
 		RateLimiter:        config.RateLimiter,
-		WarningHandler:     config.WarningHandler,
 		UserAgent:          config.UserAgent,
 		DisableCompression: config.DisableCompression,
 		QPS:                config.QPS,
 		Burst:              config.Burst,
 		Timeout:            config.Timeout,
 		Dial:               config.Dial,
-		Proxy:              config.Proxy,
 	}
 }
 
@@ -621,9 +599,7 @@ func CopyConfig(config *Config) *Config {
 		QPS:                config.QPS,
 		Burst:              config.Burst,
 		RateLimiter:        config.RateLimiter,
-		WarningHandler:     config.WarningHandler,
 		Timeout:            config.Timeout,
 		Dial:               config.Dial,
-		Proxy:              config.Proxy,
 	}
 }

vendor/k8s.io/client-go/rest/plugin.go

@@ -21,7 +21,7 @@ import (
 	"net/http"
 	"sync"
 
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 )

vendor/k8s.io/client-go/rest/request.go

@@ -45,7 +45,7 @@ import (
 	restclientwatch "k8s.io/client-go/rest/watch"
 	"k8s.io/client-go/tools/metrics"
 	"k8s.io/client-go/util/flowcontrol"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 )
 
 var (
@@ -88,12 +88,9 @@ var noBackoff = &NoBackoff{}
 type Request struct {
 	c *RESTClient
 
-	warningHandler WarningHandler
-
 	rateLimiter flowcontrol.RateLimiter
 	backoff     BackoffManager
 	timeout     time.Duration
-	maxRetries  int
 
 	// generic components accessible via method setters
 	verb       string
@@ -137,13 +134,11 @@ func NewRequest(c *RESTClient) *Request {
 	}
 
 	r := &Request{
-		c:              c,
-		rateLimiter:    c.rateLimiter,
-		backoff:        backoff,
-		timeout:        timeout,
-		pathPrefix:     pathPrefix,
-		maxRetries:     10,
-		warningHandler: c.warningHandler,
+		c:           c,
+		rateLimiter: c.rateLimiter,
+		backoff:     backoff,
+		timeout:     timeout,
+		pathPrefix:  pathPrefix,
 	}
 
 	switch {
@@ -221,13 +216,6 @@ func (r *Request) BackOff(manager BackoffManager) *Request {
 	return r
 }
 
-// WarningHandler sets the handler this client uses when warning headers are encountered.
-// If set to nil, this client will use the default warning handler (see SetDefaultWarningHandler).
-func (r *Request) WarningHandler(handler WarningHandler) *Request {
-	r.warningHandler = handler
-	return r
-}
-
 // Throttle receives a rate-limiter and sets or replaces an existing request limiter
 func (r *Request) Throttle(limiter flowcontrol.RateLimiter) *Request {
 	r.rateLimiter = limiter
@@ -403,18 +391,6 @@ func (r *Request) Timeout(d time.Duration) *Request {
 	return r
 }
 
-// MaxRetries makes the request use the given integer as a ceiling of retrying upon receiving
-// "Retry-After" headers and 429 status-code in the response. The default is 10 unless this
-// function is specifically called with a different value.
-// A zero maxRetries prevent it from doing retires and return an error immediately.
-func (r *Request) MaxRetries(maxRetries int) *Request {
-	if maxRetries < 0 {
-		maxRetries = 0
-	}
-	r.maxRetries = maxRetries
-	return r
-}
-
 // Body makes the request use obj as the body. Optional.
 // If obj is a string, try to read a file of that name.
 // If obj is a []byte, send it directly.
@@ -618,7 +594,7 @@ var globalThrottledLogger = &throttledLogger{
 
 func (b *throttledLogger) attemptToLog() (klog.Level, bool) {
 	for _, setting := range b.settings {
-		if bool(klog.V(setting.logLevel).Enabled()) {
+		if bool(klog.V(setting.logLevel)) {
 			// Return early without write locking if possible.
 			if func() bool {
 				setting.lock.RLock()
@@ -702,8 +678,6 @@ func (r *Request) Watch(ctx context.Context) (watch.Interface, error) {
 		return nil, err
 	}
 
-	handleWarnings(resp.Header, r.warningHandler)
-
 	frameReader := framer.NewFrameReader(resp.Body)
 	watchEventDecoder := streaming.NewDecoder(frameReader, streamingSerializer)
 
@@ -776,7 +750,6 @@ func (r *Request) Stream(ctx context.Context) (io.ReadCloser, error) {
 
 	switch {
 	case (resp.StatusCode >= 200) && (resp.StatusCode < 300):
-		handleWarnings(resp.Header, r.warningHandler)
 		return resp.Body, nil
 
 	default:
@@ -858,6 +831,7 @@ func (r *Request) request(ctx context.Context, fn func(*http.Request, *http.Resp
 	}
 
 	// Right now we make about ten retry attempts if we get a Retry-After response.
+	maxRetries := 10
 	retries := 0
 	for {
 
@@ -920,7 +894,7 @@ func (r *Request) request(ctx context.Context, fn func(*http.Request, *http.Resp
 			}()
 
 			retries++
-			if seconds, wait := checkWait(resp); wait && retries <= r.maxRetries {
+			if seconds, wait := checkWait(resp); wait && retries < maxRetries {
 				if seeker, ok := r.body.(io.Seeker); ok && r.body != nil {
 					_, err := seeker.Seek(0, 0)
 					if err != nil {
@@ -1033,7 +1007,6 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu
 				body:        body,
 				contentType: contentType,
 				statusCode:  resp.StatusCode,
-				warnings:    handleWarnings(resp.Header, r.warningHandler),
 			}
 		}
 	}
@@ -1052,7 +1025,6 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu
 			statusCode:  resp.StatusCode,
 			decoder:     decoder,
 			err:         err,
-			warnings:    handleWarnings(resp.Header, r.warningHandler),
 		}
 	}
 
@@ -1061,7 +1033,6 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu
 		contentType: contentType,
 		statusCode:  resp.StatusCode,
 		decoder:     decoder,
-		warnings:    handleWarnings(resp.Header, r.warningHandler),
 	}
 }
 
@@ -1069,11 +1040,11 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu
 func truncateBody(body string) string {
 	max := 0
 	switch {
-	case bool(klog.V(10).Enabled()):
+	case bool(klog.V(10)):
 		return body
-	case bool(klog.V(9).Enabled()):
+	case bool(klog.V(9)):
 		max = 10240
-	case bool(klog.V(8).Enabled()):
+	case bool(klog.V(8)):
 		max = 1024
 	}
 
@@ -1088,7 +1059,7 @@ func truncateBody(body string) string {
 // allocating a new string for the body output unless necessary. Uses a simple heuristic to determine
 // whether the body is printable.
 func glogBody(prefix string, body []byte) {
-	if klog.V(8).Enabled() {
+	if klog.V(8) {
 		if bytes.IndexFunc(body, func(r rune) bool {
 			return r < 0x0a
 		}) != -1 {
@@ -1197,7 +1168,6 @@ func retryAfterSeconds(resp *http.Response) (int, bool) {
 // Result contains the result of calling Request.Do().
 type Result struct {
 	body        []byte
-	warnings    []net.WarningHeader
 	contentType string
 	err         error
 	statusCode  int
@@ -1311,11 +1281,6 @@ func (r Result) Error() error {
 	return r.err
 }
 
-// Warnings returns any warning headers received in the response
-func (r Result) Warnings() []net.WarningHeader {
-	return r.warnings
-}
-
 // NameMayNotBe specifies strings that cannot be used as names specified as path segments (like the REST API or etcd store)
 var NameMayNotBe = []string{".", ".."}
 

vendor/k8s.io/client-go/rest/transport.go

@@ -85,8 +85,7 @@ func (c *Config) TransportConfig() (*transport.Config, error) {
 			Groups:   c.Impersonate.Groups,
 			Extra:    c.Impersonate.Extra,
 		},
-		Dial:  c.Dial,
-		Proxy: c.Proxy,
+		Dial: c.Dial,
 	}
 
 	if c.ExecProvider != nil && c.AuthProvider != nil {

vendor/k8s.io/client-go/rest/urlbackoff.go

@@ -22,7 +22,7 @@ import (
 
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/util/flowcontrol"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 )
 
 // Set of resp. Codes that we backoff for.

vendor/k8s.io/client-go/rest/warnings.go

@@ -1,144 +0,0 @@
-/*
-Copyright 2020 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package rest
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"sync"
-
-	"k8s.io/klog/v2"
-
-	"k8s.io/apimachinery/pkg/util/net"
-)
-
-// WarningHandler is an interface for handling warning headers
-type WarningHandler interface {
-	// HandleWarningHeader is called with the warn code, agent, and text when a warning header is countered.
-	HandleWarningHeader(code int, agent string, text string)
-}
-
-var (
-	defaultWarningHandler     WarningHandler = WarningLogger{}
-	defaultWarningHandlerLock sync.RWMutex
-)
-
-// SetDefaultWarningHandler sets the default handler client uses when warning headers are encountered.
-// By default, warnings are printed to stderr.
-func SetDefaultWarningHandler(l WarningHandler) {
-	defaultWarningHandlerLock.Lock()
-	defer defaultWarningHandlerLock.Unlock()
-	defaultWarningHandler = l
-}
-func getDefaultWarningHandler() WarningHandler {
-	defaultWarningHandlerLock.RLock()
-	defer defaultWarningHandlerLock.RUnlock()
-	l := defaultWarningHandler
-	return l
-}
-
-// NoWarnings is an implementation of WarningHandler that suppresses warnings.
-type NoWarnings struct{}
-
-func (NoWarnings) HandleWarningHeader(code int, agent string, message string) {}
-
-// WarningLogger is an implementation of WarningHandler that logs code 299 warnings
-type WarningLogger struct{}
-
-func (WarningLogger) HandleWarningHeader(code int, agent string, message string) {
-	if code != 299 || len(message) == 0 {
-		return
-	}
-	klog.Warning(message)
-}
-
-type warningWriter struct {
-	// out is the writer to output warnings to
-	out io.Writer
-	// opts contains options controlling warning output
-	opts WarningWriterOptions
-	// writtenLock guards written and writtenCount
-	writtenLock  sync.Mutex
-	writtenCount int
-	written      map[string]struct{}
-}
-
-// WarningWriterOptions controls the behavior of a WarningHandler constructed using NewWarningWriter()
-type WarningWriterOptions struct {
-	// Deduplicate indicates a given warning message should only be written once.
-	// Setting this to true in a long-running process handling many warnings can result in increased memory use.
-	Deduplicate bool
-	// Color indicates that warning output can include ANSI color codes
-	Color bool
-}
-
-// NewWarningWriter returns an implementation of WarningHandler that outputs code 299 warnings to the specified writer.
-func NewWarningWriter(out io.Writer, opts WarningWriterOptions) *warningWriter {
-	h := &warningWriter{out: out, opts: opts}
-	if opts.Deduplicate {
-		h.written = map[string]struct{}{}
-	}
-	return h
-}
-
-const (
-	yellowColor = "\u001b[33;1m"
-	resetColor  = "\u001b[0m"
-)
-
-// HandleWarningHeader prints warnings with code=299 to the configured writer.
-func (w *warningWriter) HandleWarningHeader(code int, agent string, message string) {
-	if code != 299 || len(message) == 0 {
-		return
-	}
-
-	w.writtenLock.Lock()
-	defer w.writtenLock.Unlock()
-
-	if w.opts.Deduplicate {
-		if _, alreadyWritten := w.written[message]; alreadyWritten {
-			return
-		}
-		w.written[message] = struct{}{}
-	}
-	w.writtenCount++
-
-	if w.opts.Color {
-		fmt.Fprintf(w.out, "%sWarning:%s %s\n", yellowColor, resetColor, message)
-	} else {
-		fmt.Fprintf(w.out, "Warning: %s\n", message)
-	}
-}
-
-func (w *warningWriter) WarningCount() int {
-	w.writtenLock.Lock()
-	defer w.writtenLock.Unlock()
-	return w.writtenCount
-}
-
-func handleWarnings(headers http.Header, handler WarningHandler) []net.WarningHeader {
-	if handler == nil {
-		handler = getDefaultWarningHandler()
-	}
-
-	warnings, _ := net.ParseWarningHeaders(headers["Warning"])
-	for _, warning := range warnings {
-		handler.HandleWarningHeader(warning.Code, warning.Agent, warning.Text)
-	}
-	return warnings
-}

vendor/k8s.io/client-go/tools/clientcmd/api/helpers.go

@@ -98,9 +98,6 @@ func ShortenConfig(config *Config) {
 		if len(authInfo.ClientCertificateData) > 0 {
 			authInfo.ClientCertificateData = redactedBytes
 		}
-		if len(authInfo.Token) > 0 {
-			authInfo.Token = "REDACTED"
-		}
 		config.AuthInfos[key] = authInfo
 	}
 	for key, cluster := range config.Clusters {

vendor/k8s.io/client-go/tools/clientcmd/api/types.go

@@ -82,17 +82,6 @@ type Cluster struct {
 	// CertificateAuthorityData contains PEM-encoded certificate authority certificates. Overrides CertificateAuthority
 	// +optional
 	CertificateAuthorityData []byte `json:"certificate-authority-data,omitempty"`
-	// ProxyURL is the URL to the proxy to be used for all requests made by this
-	// client. URLs with "http", "https", and "socks5" schemes are supported.  If
-	// this configuration is not provided or the empty string, the client
-	// attempts to construct a proxy configuration from http_proxy and
-	// https_proxy environment variables. If these environment variables are not
-	// set, the client does not attempt to proxy requests.
-	//
-	// socks5 proxying does not currently support spdy streaming endpoints (exec,
-	// attach, port forward).
-	// +optional
-	ProxyURL string `json:"proxy-url,omitempty"`
 	// Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
 	// +optional
 	Extensions map[string]runtime.Object `json:"extensions,omitempty"`
@@ -193,7 +182,7 @@ func (c AuthProviderConfig) String() string {
 // ExecConfig specifies a command to provide client credentials. The command is exec'd
 // and outputs structured stdout holding credentials.
 //
-// See the client.authentication.k8s.io API group for specifications of the exact input
+// See the client.authentiction.k8s.io API group for specifications of the exact input
 // and output format
 type ExecConfig struct {
 	// Command to execute.
@@ -210,11 +199,6 @@ type ExecConfig struct {
 	// Preferred input version of the ExecInfo. The returned ExecCredentials MUST use
 	// the same encoding version as the input.
 	APIVersion string `json:"apiVersion,omitempty"`
-
-	// This text is shown to the user when the executable doesn't seem to be
-	// present. For example, `brew install foo-cli` might be a good InstallHint for
-	// foo-cli on Mac OS systems.
-	InstallHint string `json:"installHint,omitempty"`
 }
 
 var _ fmt.Stringer = new(ExecConfig)

vendor/k8s.io/client-go/tools/clientcmd/api/v1/types.go

@@ -75,17 +75,6 @@ type Cluster struct {
 	// CertificateAuthorityData contains PEM-encoded certificate authority certificates. Overrides CertificateAuthority
 	// +optional
 	CertificateAuthorityData []byte `json:"certificate-authority-data,omitempty"`
-	// ProxyURL is the URL to the proxy to be used for all requests made by this
-	// client. URLs with "http", "https", and "socks5" schemes are supported.  If
-	// this configuration is not provided or the empty string, the client
-	// attempts to construct a proxy configuration from http_proxy and
-	// https_proxy environment variables. If these environment variables are not
-	// set, the client does not attempt to proxy requests.
-	//
-	// socks5 proxying does not currently support spdy streaming endpoints (exec,
-	// attach, port forward).
-	// +optional
-	ProxyURL string `json:"proxy-url,omitempty"`
 	// Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields
 	// +optional
 	Extensions []NamedExtension `json:"extensions,omitempty"`
@@ -192,7 +181,7 @@ type AuthProviderConfig struct {
 // ExecConfig specifies a command to provide client credentials. The command is exec'd
 // and outputs structured stdout holding credentials.
 //
-// See the client.authentication.k8s.io API group for specifications of the exact input
+// See the client.authentiction.k8s.io API group for specifications of the exact input
 // and output format
 type ExecConfig struct {
 	// Command to execute.
@@ -209,11 +198,6 @@ type ExecConfig struct {
 	// Preferred input version of the ExecInfo. The returned ExecCredentials MUST use
 	// the same encoding version as the input.
 	APIVersion string `json:"apiVersion,omitempty"`
-
-	// This text is shown to the user when the executable doesn't seem to be
-	// present. For example, `brew install foo-cli` might be a good InstallHint for
-	// foo-cli on Mac OS systems.
-	InstallHint string `json:"installHint,omitempty"`
 }
 
 // ExecEnvVar is used for setting environment variables when executing an exec-based

vendor/k8s.io/client-go/tools/clientcmd/api/v1/zz_generated.conversion.go

@@ -237,7 +237,6 @@ func autoConvert_v1_Cluster_To_api_Cluster(in *Cluster, out *api.Cluster, s conv
 	out.InsecureSkipTLSVerify = in.InsecureSkipTLSVerify
 	out.CertificateAuthority = in.CertificateAuthority
 	out.CertificateAuthorityData = *(*[]byte)(unsafe.Pointer(&in.CertificateAuthorityData))
-	out.ProxyURL = in.ProxyURL
 	if err := Convert_Slice_v1_NamedExtension_To_Map_string_To_runtime_Object(&in.Extensions, &out.Extensions, s); err != nil {
 		return err
 	}
@@ -256,7 +255,6 @@ func autoConvert_api_Cluster_To_v1_Cluster(in *api.Cluster, out *Cluster, s conv
 	out.InsecureSkipTLSVerify = in.InsecureSkipTLSVerify
 	out.CertificateAuthority = in.CertificateAuthority
 	out.CertificateAuthorityData = *(*[]byte)(unsafe.Pointer(&in.CertificateAuthorityData))
-	out.ProxyURL = in.ProxyURL
 	if err := Convert_Map_string_To_runtime_Object_To_Slice_v1_NamedExtension(&in.Extensions, &out.Extensions, s); err != nil {
 		return err
 	}
@@ -358,7 +356,6 @@ func autoConvert_v1_ExecConfig_To_api_ExecConfig(in *ExecConfig, out *api.ExecCo
 	out.Args = *(*[]string)(unsafe.Pointer(&in.Args))
 	out.Env = *(*[]api.ExecEnvVar)(unsafe.Pointer(&in.Env))
 	out.APIVersion = in.APIVersion
-	out.InstallHint = in.InstallHint
 	return nil
 }
 
@@ -372,7 +369,6 @@ func autoConvert_api_ExecConfig_To_v1_ExecConfig(in *api.ExecConfig, out *ExecCo
 	out.Args = *(*[]string)(unsafe.Pointer(&in.Args))
 	out.Env = *(*[]ExecEnvVar)(unsafe.Pointer(&in.Env))
 	out.APIVersion = in.APIVersion
-	out.InstallHint = in.InstallHint
 	return nil
 }
 

vendor/k8s.io/client-go/tools/clientcmd/client_config.go

@@ -20,18 +20,16 @@ import (
 	"fmt"
 	"io"
 	"io/ioutil"
-	"net/http"
 	"net/url"
 	"os"
 	"strings"
-	"unicode"
+
+	"github.com/imdario/mergo"
+	"k8s.io/klog"
 
 	restclient "k8s.io/client-go/rest"
 	clientauth "k8s.io/client-go/tools/auth"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
-	"k8s.io/klog/v2"
-
-	"github.com/imdario/mergo"
 )
 
 var (
@@ -152,15 +150,8 @@ func (config *DirectClientConfig) ClientConfig() (*restclient.Config, error) {
 
 	clientConfig := &restclient.Config{}
 	clientConfig.Host = configClusterInfo.Server
-	if configClusterInfo.ProxyURL != "" {
-		u, err := parseProxyURL(configClusterInfo.ProxyURL)
-		if err != nil {
-			return nil, err
-		}
-		clientConfig.Proxy = http.ProxyURL(u)
-	}
 
-	if config.overrides != nil && len(config.overrides.Timeout) > 0 {
+	if len(config.overrides.Timeout) > 0 {
 		timeout, err := ParseTimeout(config.overrides.Timeout)
 		if err != nil {
 			return nil, err
@@ -270,7 +261,6 @@ func (config *DirectClientConfig) getUserIdentificationPartialConfig(configAuthI
 	}
 	if configAuthInfo.Exec != nil {
 		mergedConfig.ExecProvider = configAuthInfo.Exec
-		mergedConfig.ExecProvider.InstallHint = cleanANSIEscapeCodes(mergedConfig.ExecProvider.InstallHint)
 	}
 
 	// if there still isn't enough information to authenticate the user, try prompting
@@ -316,41 +306,6 @@ func canIdentifyUser(config restclient.Config) bool {
 		config.ExecProvider != nil
 }
 
-// cleanANSIEscapeCodes takes an arbitrary string and ensures that there are no
-// ANSI escape sequences that could put the terminal in a weird state (e.g.,
-// "\e[1m" bolds text)
-func cleanANSIEscapeCodes(s string) string {
-	// spaceControlCharacters includes tab, new line, vertical tab, new page, and
-	// carriage return. These are in the unicode.Cc category, but that category also
-	// contains ESC (U+001B) which we don't want.
-	spaceControlCharacters := unicode.RangeTable{
-		R16: []unicode.Range16{
-			{Lo: 0x0009, Hi: 0x000D, Stride: 1},
-		},
-	}
-
-	// Why not make this deny-only (instead of allow-only)? Because unicode.C
-	// contains newline and tab characters that we want.
-	allowedRanges := []*unicode.RangeTable{
-		unicode.L,
-		unicode.M,
-		unicode.N,
-		unicode.P,
-		unicode.S,
-		unicode.Z,
-		&spaceControlCharacters,
-	}
-	builder := strings.Builder{}
-	for _, roon := range s {
-		if unicode.IsOneOf(allowedRanges, roon) {
-			builder.WriteRune(roon) // returns nil error, per go doc
-		} else {
-			fmt.Fprintf(&builder, "%U", roon)
-		}
-	}
-	return builder.String()
-}
-
 // Namespace implements ClientConfig
 func (config *DirectClientConfig) Namespace() (string, bool, error) {
 	if config.overrides != nil && config.overrides.Context.Namespace != "" {
@@ -418,7 +373,7 @@ func (config *DirectClientConfig) ConfirmUsable() error {
 // getContextName returns the default, or user-set context name, and a boolean that indicates
 // whether the default context name has been overwritten by a user-set flag, or left as its default value
 func (config *DirectClientConfig) getContextName() (string, bool) {
-	if config.overrides != nil && len(config.overrides.CurrentContext) != 0 {
+	if len(config.overrides.CurrentContext) != 0 {
 		return config.overrides.CurrentContext, true
 	}
 	if len(config.contextName) != 0 {
@@ -432,7 +387,7 @@ func (config *DirectClientConfig) getContextName() (string, bool) {
 // and a boolean indicating  whether the default authInfo name is overwritten by a user-set flag, or
 // left as its default value
 func (config *DirectClientConfig) getAuthInfoName() (string, bool) {
-	if config.overrides != nil && len(config.overrides.Context.AuthInfo) != 0 {
+	if len(config.overrides.Context.AuthInfo) != 0 {
 		return config.overrides.Context.AuthInfo, true
 	}
 	context, _ := config.getContext()
@@ -443,7 +398,7 @@ func (config *DirectClientConfig) getAuthInfoName() (string, bool) {
 // indicating whether the default clusterName has been overwritten by a user-set flag, or left as
 // its default value
 func (config *DirectClientConfig) getClusterName() (string, bool) {
-	if config.overrides != nil && len(config.overrides.Context.Cluster) != 0 {
+	if len(config.overrides.Context.Cluster) != 0 {
 		return config.overrides.Context.Cluster, true
 	}
 	context, _ := config.getContext()
@@ -461,9 +416,7 @@ func (config *DirectClientConfig) getContext() (clientcmdapi.Context, error) {
 	} else if required {
 		return clientcmdapi.Context{}, fmt.Errorf("context %q does not exist", contextName)
 	}
-	if config.overrides != nil {
-		mergo.MergeWithOverwrite(mergedContext, config.overrides.Context)
-	}
+	mergo.MergeWithOverwrite(mergedContext, config.overrides.Context)
 
 	return *mergedContext, nil
 }
@@ -479,9 +432,7 @@ func (config *DirectClientConfig) getAuthInfo() (clientcmdapi.AuthInfo, error) {
 	} else if required {
 		return clientcmdapi.AuthInfo{}, fmt.Errorf("auth info %q does not exist", authInfoName)
 	}
-	if config.overrides != nil {
-		mergo.MergeWithOverwrite(mergedAuthInfo, config.overrides.AuthInfo)
-	}
+	mergo.MergeWithOverwrite(mergedAuthInfo, config.overrides.AuthInfo)
 
 	return *mergedAuthInfo, nil
 }
@@ -492,37 +443,30 @@ func (config *DirectClientConfig) getCluster() (clientcmdapi.Cluster, error) {
 	clusterInfoName, required := config.getClusterName()
 
 	mergedClusterInfo := clientcmdapi.NewCluster()
-	if config.overrides != nil {
-		mergo.MergeWithOverwrite(mergedClusterInfo, config.overrides.ClusterDefaults)
-	}
+	mergo.MergeWithOverwrite(mergedClusterInfo, config.overrides.ClusterDefaults)
 	if configClusterInfo, exists := clusterInfos[clusterInfoName]; exists {
 		mergo.MergeWithOverwrite(mergedClusterInfo, configClusterInfo)
 	} else if required {
 		return clientcmdapi.Cluster{}, fmt.Errorf("cluster %q does not exist", clusterInfoName)
 	}
-	if config.overrides != nil {
-		mergo.MergeWithOverwrite(mergedClusterInfo, config.overrides.ClusterInfo)
-	}
-
+	mergo.MergeWithOverwrite(mergedClusterInfo, config.overrides.ClusterInfo)
 	// * An override of --insecure-skip-tls-verify=true and no accompanying CA/CA data should clear already-set CA/CA data
 	// otherwise, a kubeconfig containing a CA reference would return an error that "CA and insecure-skip-tls-verify couldn't both be set".
 	// * An override of --certificate-authority should also override TLS skip settings and CA data, otherwise existing CA data will take precedence.
-	if config.overrides != nil {
-		caLen := len(config.overrides.ClusterInfo.CertificateAuthority)
-		caDataLen := len(config.overrides.ClusterInfo.CertificateAuthorityData)
-		if config.overrides.ClusterInfo.InsecureSkipTLSVerify || caLen > 0 || caDataLen > 0 {
-			mergedClusterInfo.InsecureSkipTLSVerify = config.overrides.ClusterInfo.InsecureSkipTLSVerify
-			mergedClusterInfo.CertificateAuthority = config.overrides.ClusterInfo.CertificateAuthority
-			mergedClusterInfo.CertificateAuthorityData = config.overrides.ClusterInfo.CertificateAuthorityData
-		}
+	caLen := len(config.overrides.ClusterInfo.CertificateAuthority)
+	caDataLen := len(config.overrides.ClusterInfo.CertificateAuthorityData)
+	if config.overrides.ClusterInfo.InsecureSkipTLSVerify || caLen > 0 || caDataLen > 0 {
+		mergedClusterInfo.InsecureSkipTLSVerify = config.overrides.ClusterInfo.InsecureSkipTLSVerify
+		mergedClusterInfo.CertificateAuthority = config.overrides.ClusterInfo.CertificateAuthority
+		mergedClusterInfo.CertificateAuthorityData = config.overrides.ClusterInfo.CertificateAuthorityData
+	}
 
-		// if the --tls-server-name has been set in overrides, use that value.
-		// if the --server has been set in overrides, then use the value of --tls-server-name specified on the CLI too.  This gives the property
-		// that setting a --server will effectively clear the KUBECONFIG value of tls-server-name if it is specified on the command line which is
-		// usually correct.
-		if config.overrides.ClusterInfo.TLSServerName != "" || config.overrides.ClusterInfo.Server != "" {
-			mergedClusterInfo.TLSServerName = config.overrides.ClusterInfo.TLSServerName
-		}
+	// if the --tls-server-name has been set in overrides, use that value.
+	// if the --server has been set in overrides, then use the value of --tls-server-name specified on the CLI too.  This gives the property
+	// that setting a --server will effectively clear the KUBECONFIG value of tls-server-name if it is specified on the command line which is
+	// usually correct.
+	if config.overrides.ClusterInfo.TLSServerName != "" || config.overrides.ClusterInfo.Server != "" {
+		mergedClusterInfo.TLSServerName = config.overrides.ClusterInfo.TLSServerName
 	}
 
 	return *mergedClusterInfo, nil

vendor/k8s.io/client-go/tools/clientcmd/config.go

@@ -24,7 +24,7 @@ import (
 	"reflect"
 	"sort"
 
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 
 	restclient "k8s.io/client-go/rest"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
@@ -58,15 +58,6 @@ type PathOptions struct {
 	LoadingRules *ClientConfigLoadingRules
 }
 
-var (
-	// UseModifyConfigLock ensures that access to kubeconfig file using ModifyConfig method
-	// is being guarded by a lock file.
-	// This variable is intentionaly made public so other consumers of this library
-	// can modify its default behavior, but be caution when disabling it since
-	// this will make your code not threadsafe.
-	UseModifyConfigLock = true
-)
-
 func (o *PathOptions) GetEnvVarFiles() []string {
 	if len(o.EnvVar) == 0 {
 		return []string{}
@@ -165,17 +156,15 @@ func NewDefaultPathOptions() *PathOptions {
 // that means that this code will only write into a single file.  If you want to relativizePaths, you must provide a fully qualified path in any
 // modified element.
 func ModifyConfig(configAccess ConfigAccess, newConfig clientcmdapi.Config, relativizePaths bool) error {
-	if UseModifyConfigLock {
-		possibleSources := configAccess.GetLoadingPrecedence()
-		// sort the possible kubeconfig files so we always "lock" in the same order
-		// to avoid deadlock (note: this can fail w/ symlinks, but... come on).
-		sort.Strings(possibleSources)
-		for _, filename := range possibleSources {
-			if err := lockFile(filename); err != nil {
-				return err
-			}
-			defer unlockFile(filename)
+	possibleSources := configAccess.GetLoadingPrecedence()
+	// sort the possible kubeconfig files so we always "lock" in the same order
+	// to avoid deadlock (note: this can fail w/ symlinks, but... come on).
+	sort.Strings(possibleSources)
+	for _, filename := range possibleSources {
+		if err := lockFile(filename); err != nil {
+			return err
 		}
+		defer unlockFile(filename)
 	}
 
 	startingConfig, err := configAccess.GetStartingConfig()

vendor/k8s.io/client-go/tools/clientcmd/helpers.go

@@ -18,7 +18,6 @@ package clientcmd
 
 import (
 	"fmt"
-	"net/url"
 	"strconv"
 	"time"
 )
@@ -34,17 +33,3 @@ func ParseTimeout(duration string) (time.Duration, error) {
 	}
 	return 0, fmt.Errorf("Invalid timeout value. Timeout must be a single integer in seconds, or an integer followed by a corresponding time unit (e.g. 1s | 2m | 3h)")
 }
-
-func parseProxyURL(proxyURL string) (*url.URL, error) {
-	u, err := url.Parse(proxyURL)
-	if err != nil {
-		return nil, fmt.Errorf("could not parse: %v", proxyURL)
-	}
-
-	switch u.Scheme {
-	case "http", "https", "socks5":
-	default:
-		return nil, fmt.Errorf("unsupported scheme %q, must be http, https, or socks5", u.Scheme)
-	}
-	return u, nil
-}

vendor/k8s.io/client-go/tools/clientcmd/loader.go

@@ -28,7 +28,7 @@ import (
 	"strings"
 
 	"github.com/imdario/mergo"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"

vendor/k8s.io/client-go/tools/clientcmd/merged_client_builder.go

@@ -20,7 +20,7 @@ import (
 	"io"
 	"sync"
 
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 
 	restclient "k8s.io/client-go/rest"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
@@ -60,26 +60,27 @@ func NewInteractiveDeferredLoadingClientConfig(loader ClientConfigLoader, overri
 }
 
 func (config *DeferredLoadingClientConfig) createClientConfig() (ClientConfig, error) {
-	config.loadingLock.Lock()
-	defer config.loadingLock.Unlock()
+	if config.clientConfig == nil {
+		config.loadingLock.Lock()
+		defer config.loadingLock.Unlock()
 
-	if config.clientConfig != nil {
-		return config.clientConfig, nil
-	}
-	mergedConfig, err := config.loader.Load()
-	if err != nil {
-		return nil, err
+		if config.clientConfig == nil {
+			mergedConfig, err := config.loader.Load()
+			if err != nil {
+				return nil, err
+			}
+
+			var mergedClientConfig ClientConfig
+			if config.fallbackReader != nil {
+				mergedClientConfig = NewInteractiveClientConfig(*mergedConfig, config.overrides.CurrentContext, config.overrides, config.fallbackReader, config.loader)
+			} else {
+				mergedClientConfig = NewNonInteractiveClientConfig(*mergedConfig, config.overrides.CurrentContext, config.overrides, config.loader)
+			}
+
+			config.clientConfig = mergedClientConfig
+		}
 	}
 
-	var currentContext string
-	if config.overrides != nil {
-		currentContext = config.overrides.CurrentContext
-	}
-	if config.fallbackReader != nil {
-		config.clientConfig = NewInteractiveClientConfig(*mergedConfig, currentContext, config.overrides, config.fallbackReader, config.loader)
-	} else {
-		config.clientConfig = NewNonInteractiveClientConfig(*mergedConfig, currentContext, config.overrides, config.loader)
-	}
 	return config.clientConfig, nil
 }
 

vendor/k8s.io/client-go/tools/clientcmd/validation.go

@@ -30,24 +30,11 @@ import (
 
 var (
 	ErrNoContext   = errors.New("no context chosen")
-	ErrEmptyConfig = NewEmptyConfigError("no configuration has been provided, try setting KUBERNETES_MASTER environment variable")
+	ErrEmptyConfig = errors.New("no configuration has been provided, try setting KUBERNETES_MASTER environment variable")
 	// message is for consistency with old behavior
 	ErrEmptyCluster = errors.New("cluster has no server defined")
 )
 
-// NewEmptyConfigError returns an error wrapping the given message which IsEmptyConfig() will recognize as an empty config error
-func NewEmptyConfigError(message string) error {
-	return &errEmptyConfig{message}
-}
-
-type errEmptyConfig struct {
-	message string
-}
-
-func (e *errEmptyConfig) Error() string {
-	return e.message
-}
-
 type errContextNotFound struct {
 	ContextName string
 }
@@ -73,14 +60,9 @@ func IsContextNotFound(err error) bool {
 func IsEmptyConfig(err error) bool {
 	switch t := err.(type) {
 	case errConfigurationInvalid:
-		if len(t) != 1 {
-			return false
-		}
-		_, ok := t[0].(*errEmptyConfig)
-		return ok
+		return len(t) == 1 && t[0] == ErrEmptyConfig
 	}
-	_, ok := err.(*errEmptyConfig)
-	return ok
+	return err == ErrEmptyConfig
 }
 
 // errConfigurationInvalid is a set of errors indicating the configuration is invalid.
@@ -227,11 +209,6 @@ func validateClusterInfo(clusterName string, clusterInfo clientcmdapi.Cluster) [
 			validationErrors = append(validationErrors, fmt.Errorf("no server found for cluster %q", clusterName))
 		}
 	}
-	if proxyURL := clusterInfo.ProxyURL; proxyURL != "" {
-		if _, err := parseProxyURL(proxyURL); err != nil {
-			validationErrors = append(validationErrors, fmt.Errorf("invalid 'proxy-url' %q for cluster %q: %v", proxyURL, clusterName, err))
-		}
-	}
 	// Make sure CA data and CA file aren't both specified
 	if len(clusterInfo.CertificateAuthority) != 0 && len(clusterInfo.CertificateAuthorityData) != 0 {
 		validationErrors = append(validationErrors, fmt.Errorf("certificate-authority-data and certificate-authority are both specified for %v. certificate-authority-data will override.", clusterName))

vendor/k8s.io/client-go/tools/metrics/OWNERS

@@ -2,5 +2,6 @@
 
 reviewers:
 - wojtek-t
+- eparis
 - krousey
 - jayunit100

vendor/k8s.io/client-go/transport/cache.go

@@ -83,7 +83,7 @@ func (c *tlsTransportCache) get(config *Config) (http.RoundTripper, error) {
 		return nil, err
 	}
 	// The options didn't require a custom TLS config
-	if tlsConfig == nil && config.Dial == nil && config.Proxy == nil {
+	if tlsConfig == nil && config.Dial == nil {
 		return http.DefaultTransport, nil
 	}
 
@@ -104,13 +104,8 @@ func (c *tlsTransportCache) get(config *Config) (http.RoundTripper, error) {
 		go dynamicCertDialer.Run(wait.NeverStop)
 	}
 
-	proxy := http.ProxyFromEnvironment
-	if config.Proxy != nil {
-		proxy = config.Proxy
-	}
-
 	transport := utilnet.SetTransportDefaults(&http.Transport{
-		Proxy:               proxy,
+		Proxy:               http.ProxyFromEnvironment,
 		TLSHandshakeTimeout: 10 * time.Second,
 		TLSClientConfig:     tlsConfig,
 		MaxIdleConnsPerHost: idleConnsPerHost,
@@ -133,7 +128,7 @@ func tlsConfigKey(c *Config) (tlsCacheKey, bool, error) {
 		return tlsCacheKey{}, false, err
 	}
 
-	if c.TLS.GetCert != nil || c.Dial != nil || c.Proxy != nil {
+	if c.TLS.GetCert != nil || c.Dial != nil {
 		// cannot determine equality for functions
 		return tlsCacheKey{}, false, nil
 	}

vendor/k8s.io/client-go/transport/cert_rotation.go

@@ -29,7 +29,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/util/connrotation"
 	"k8s.io/client-go/util/workqueue"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 )
 
 const workItemKey = "key"

vendor/k8s.io/client-go/transport/config.go

@@ -21,7 +21,6 @@ import (
 	"crypto/tls"
 	"net"
 	"net/http"
-	"net/url"
 )
 
 // Config holds various options for establishing a transport.
@@ -69,13 +68,6 @@ type Config struct {
 
 	// Dial specifies the dial function for creating unencrypted TCP connections.
 	Dial func(ctx context.Context, network, address string) (net.Conn, error)
-
-	// Proxy is the the proxy func to be used for all requests made by this
-	// transport. If Proxy is nil, http.ProxyFromEnvironment is used. If Proxy
-	// returns a nil *URL, no proxy is used.
-	//
-	// socks5 proxying does not currently support spdy streaming endpoints.
-	Proxy func(*http.Request) (*url.URL, error)
 }
 
 // ImpersonationConfig has all the available impersonation options

vendor/k8s.io/client-go/transport/round_trippers.go

@@ -23,7 +23,7 @@ import (
 	"time"
 
 	"golang.org/x/oauth2"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 
 	utilnet "k8s.io/apimachinery/pkg/util/net"
 )
@@ -67,13 +67,13 @@ func HTTPWrappersForConfig(config *Config, rt http.RoundTripper) (http.RoundTrip
 // DebugWrappers wraps a round tripper and logs based on the current log level.
 func DebugWrappers(rt http.RoundTripper) http.RoundTripper {
 	switch {
-	case bool(klog.V(9).Enabled()):
+	case bool(klog.V(9)):
 		rt = newDebuggingRoundTripper(rt, debugCurlCommand, debugURLTiming, debugResponseHeaders)
-	case bool(klog.V(8).Enabled()):
+	case bool(klog.V(8)):
 		rt = newDebuggingRoundTripper(rt, debugJustURL, debugRequestHeaders, debugResponseStatus, debugResponseHeaders)
-	case bool(klog.V(7).Enabled()):
+	case bool(klog.V(7)):
 		rt = newDebuggingRoundTripper(rt, debugJustURL, debugRequestHeaders, debugResponseStatus)
-	case bool(klog.V(6).Enabled()):
+	case bool(klog.V(6)):
 		rt = newDebuggingRoundTripper(rt, debugURLTiming)
 	}
 

vendor/k8s.io/client-go/transport/token_source.go

@@ -26,7 +26,7 @@ import (
 
 	"golang.org/x/oauth2"
 
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 )
 
 // TokenSourceWrapTransport returns a WrapTransport that injects bearer tokens

vendor/k8s.io/client-go/transport/transport.go

@@ -27,7 +27,7 @@ import (
 	"time"
 
 	utilnet "k8s.io/apimachinery/pkg/util/net"
-	"k8s.io/klog/v2"
+	"k8s.io/klog"
 )
 
 // New returns an http.RoundTripper that will provide the authentication

vendor/k8s.io/client-go/util/cert/cert.go

@@ -28,7 +28,7 @@ import (
 	"io/ioutil"
 	"math/big"
 	"net"
-	"path/filepath"
+	"path"
 	"strings"
 	"time"
 
@@ -96,8 +96,8 @@ func GenerateSelfSignedCertKeyWithFixtures(host string, alternateIPs []net.IP, a
 	maxAge := time.Hour * 24 * 365          // one year self-signed certs
 
 	baseName := fmt.Sprintf("%s_%s_%s", host, strings.Join(ipsToStrings(alternateIPs), "-"), strings.Join(alternateDNS, "-"))
-	certFixturePath := filepath.Join(fixtureDirectory, baseName+".crt")
-	keyFixturePath := filepath.Join(fixtureDirectory, baseName+".key")
+	certFixturePath := path.Join(fixtureDirectory, baseName+".crt")
+	keyFixturePath := path.Join(fixtureDirectory, baseName+".key")
 	if len(fixtureDirectory) > 0 {
 		cert, err := ioutil.ReadFile(certFixturePath)
 		if err == nil {

vendor/k8s.io/client-go/util/jsonpath/jsonpath.go

@@ -18,7 +18,6 @@ package jsonpath
 
 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
 	"io"
 	"reflect"
@@ -30,14 +29,13 @@ import (
 type JSONPath struct {
 	name       string
 	parser     *Parser
+	stack      [][]reflect.Value // push and pop values in different scopes
+	cur        []reflect.Value   // current scope values
 	beginRange int
 	inRange    int
 	endRange   int
 
-	lastEndNode *Node
-
 	allowMissingKeys bool
-	outputJSON       bool
 }
 
 // New creates a new JSONPath with the given name.
@@ -83,12 +81,12 @@ func (j *JSONPath) FindResults(data interface{}) ([][]reflect.Value, error) {
 		return nil, fmt.Errorf("%s is an incomplete jsonpath template", j.name)
 	}
 
-	cur := []reflect.Value{reflect.ValueOf(data)}
+	j.cur = []reflect.Value{reflect.ValueOf(data)}
 	nodes := j.parser.Root.Nodes
 	fullResult := [][]reflect.Value{}
 	for i := 0; i < len(nodes); i++ {
 		node := nodes[i]
-		results, err := j.walk(cur, node)
+		results, err := j.walk(j.cur, node)
 		if err != nil {
 			return nil, err
 		}
@@ -96,90 +94,34 @@ func (j *JSONPath) FindResults(data interface{}) ([][]reflect.Value, error) {
 		// encounter an end node, break the current block
 		if j.endRange > 0 && j.endRange <= j.inRange {
 			j.endRange--
-			j.lastEndNode = &nodes[i]
 			break
 		}
 		// encounter a range node, start a range loop
 		if j.beginRange > 0 {
 			j.beginRange--
 			j.inRange++
-			if len(results) > 0 {
-				for _, value := range results {
-					j.parser.Root.Nodes = nodes[i+1:]
-					nextResults, err := j.FindResults(value.Interface())
-					if err != nil {
-						return nil, err
-					}
-					fullResult = append(fullResult, nextResults...)
-				}
-			} else {
-				// If the range has no results, we still need to process the nodes within the range
-				// so the position will advance to the end node
+			for k, value := range results {
 				j.parser.Root.Nodes = nodes[i+1:]
-				_, err := j.FindResults(nil)
+				if k == len(results)-1 {
+					j.inRange--
+				}
+				nextResults, err := j.FindResults(value.Interface())
 				if err != nil {
 					return nil, err
 				}
+				fullResult = append(fullResult, nextResults...)
 			}
-			j.inRange--
-
-			// Fast forward to resume processing after the most recent end node that was encountered
-			for k := i + 1; k < len(nodes); k++ {
-				if &nodes[k] == j.lastEndNode {
-					i = k
-					break
-				}
-			}
-			continue
+			break
 		}
 		fullResult = append(fullResult, results)
 	}
 	return fullResult, nil
 }
 
-// EnableJSONOutput changes the PrintResults behavior to return a JSON array of results
-func (j *JSONPath) EnableJSONOutput(v bool) {
-	j.outputJSON = v
-}
-
 // PrintResults writes the results into writer
 func (j *JSONPath) PrintResults(wr io.Writer, results []reflect.Value) error {
-	if j.outputJSON {
-		// convert the []reflect.Value to something that json
-		// will be able to marshal
-		r := make([]interface{}, 0, len(results))
-		for i := range results {
-			r = append(r, results[i].Interface())
-		}
-		results = []reflect.Value{reflect.ValueOf(r)}
-	}
 	for i, r := range results {
-		var text []byte
-		var err error
-		outputJSON := true
-		kind := r.Kind()
-		if kind == reflect.Interface {
-			kind = r.Elem().Kind()
-		}
-		switch kind {
-		case reflect.Map:
-		case reflect.Array:
-		case reflect.Slice:
-		case reflect.Struct:
-		default:
-			outputJSON = false
-		}
-		switch {
-		case outputJSON || j.outputJSON:
-			if j.outputJSON {
-				text, err = json.MarshalIndent(r.Interface(), "", "    ")
-				text = append(text, '\n')
-			} else {
-				text, err = json.Marshal(r.Interface())
-			}
-		default:
-			text, err = j.evalToText(r)
-		}
+		text, err := j.evalToText(r)
 		if err != nil {
 			return err
 		}
@@ -190,9 +132,7 @@ func (j *JSONPath) PrintResults(wr io.Writer, results []reflect.Value) error {
 			return err
 		}
 	}
-
 	return nil
-
 }
 
 // walk visits tree rooted at the given node in DFS order
@@ -272,11 +212,17 @@ func (j *JSONPath) evalIdentifier(input []reflect.Value, node *IdentifierNode) (
 	results := []reflect.Value{}
 	switch node.Name {
 	case "range":
+		j.stack = append(j.stack, j.cur)
 		j.beginRange++
 		results = input
 	case "end":
-		if j.inRange > 0 {
+		if j.endRange < j.inRange { // inside a loop, break the current block
 			j.endRange++
+			break
+		}
+		// the loop is about to end, pop value and continue the following execution
+		if len(j.stack) > 0 {
+			j.cur, j.stack = j.stack[len(j.stack)-1], j.stack[:len(j.stack)-1]
 		} else {
 			return results, fmt.Errorf("not in range, nothing to end")
 		}

vendor/k8s.io/client-go/util/jsonpath/parser.go

@@ -214,11 +214,8 @@ func (p *Parser) parseIdentifier(cur *ListNode) error {
 	return p.parseInsideAction(cur)
 }
 
-// parseRecursive scans the recursive descent operator ..
+// parseRecursive scans the recursive desent operator ..
 func (p *Parser) parseRecursive(cur *ListNode) error {
-	if lastIndex := len(cur.Nodes) - 1; lastIndex >= 0 && cur.Nodes[lastIndex].Type() == NodeRecursive {
-		return fmt.Errorf("invalid multiple recursive descent")
-	}
 	p.pos += len("..")
 	p.consumeText()
 	cur.append(newRecursive())

vendor/k8s.io/client-go/util/workqueue/default_rate_limiters.go

@@ -62,6 +62,54 @@ func (r *BucketRateLimiter) NumRequeues(item interface{}) int {
 func (r *BucketRateLimiter) Forget(item interface{}) {
 }
 
+// ItemBucketRateLimiter implements a workqueue ratelimiter API using standard rate.Limiter.
+// Each key is using a separate limiter.
+type ItemBucketRateLimiter struct {
+	r     rate.Limit
+	burst int
+
+	limitersLock sync.Mutex
+	limiters     map[interface{}]*rate.Limiter
+}
+
+var _ RateLimiter = &ItemBucketRateLimiter{}
+
+// NewItemBucketRateLimiter creates new ItemBucketRateLimiter instance.
+func NewItemBucketRateLimiter(r rate.Limit, burst int) *ItemBucketRateLimiter {
+	return &ItemBucketRateLimiter{
+		r:        r,
+		burst:    burst,
+		limiters: make(map[interface{}]*rate.Limiter),
+	}
+}
+
+// When returns a time.Duration which we need to wait before item is processed.
+func (r *ItemBucketRateLimiter) When(item interface{}) time.Duration {
+	r.limitersLock.Lock()
+	defer r.limitersLock.Unlock()
+
+	limiter, ok := r.limiters[item]
+	if !ok {
+		limiter = rate.NewLimiter(r.r, r.burst)
+		r.limiters[item] = limiter
+	}
+
+	return limiter.Reserve().Delay()
+}
+
+// NumRequeues returns always 0 (doesn't apply to ItemBucketRateLimiter).
+func (r *ItemBucketRateLimiter) NumRequeues(item interface{}) int {
+	return 0
+}
+
+// Forget removes item from the internal state.
+func (r *ItemBucketRateLimiter) Forget(item interface{}) {
+	r.limitersLock.Lock()
+	defer r.limitersLock.Unlock()
+
+	delete(r.limiters, item)
+}
+
 // ItemExponentialFailureRateLimiter does a simple baseDelay*2^<num-failures> limit
 // dealing with max failures and expiration are up to the caller
 type ItemExponentialFailureRateLimiter struct {

vendor/k8s.io/client-go/util/workqueue/delaying_queue.go

@@ -38,12 +38,6 @@ func NewDelayingQueue() DelayingInterface {
 	return NewDelayingQueueWithCustomClock(clock.RealClock{}, "")
 }
 
-// NewDelayingQueueWithCustomQueue constructs a new workqueue with ability to
-// inject custom queue Interface instead of the default one
-func NewDelayingQueueWithCustomQueue(q Interface, name string) DelayingInterface {
-	return newDelayingQueue(clock.RealClock{}, q, name)
-}
-
 // NewNamedDelayingQueue constructs a new named workqueue with delayed queuing ability
 func NewNamedDelayingQueue(name string) DelayingInterface {
 	return NewDelayingQueueWithCustomClock(clock.RealClock{}, name)
@@ -52,12 +46,8 @@ func NewNamedDelayingQueue(name string) DelayingInterface {
 // NewDelayingQueueWithCustomClock constructs a new named workqueue
 // with ability to inject real or fake clock for testing purposes
 func NewDelayingQueueWithCustomClock(clock clock.Clock, name string) DelayingInterface {
-	return newDelayingQueue(clock, NewNamed(name), name)
-}
-
-func newDelayingQueue(clock clock.Clock, q Interface, name string) *delayingType {
 	ret := &delayingType{
-		Interface:       q,
+		Interface:       NewNamed(name),
 		clock:           clock,
 		heartbeat:       clock.NewTicker(maxWait),
 		stopCh:          make(chan struct{}),
@@ -66,6 +56,7 @@ func newDelayingQueue(clock clock.Clock, q Interface, name string) *delayingType
 	}
 
 	go ret.waitingLoop()
+
 	return ret
 }
 

vendor/k8s.io/client-go/util/workqueue/parallelizer.go

@@ -25,77 +25,39 @@ import (
 
 type DoWorkPieceFunc func(piece int)
 
-type options struct {
-	chunkSize int
-}
-
-type Options func(*options)
-
-// WithChunkSize allows to set chunks of work items to the workers, rather than
-// processing one by one.
-// It is recommended to use this option if the number of pieces significantly
-// higher than the number of workers and the work done for each item is small.
-func WithChunkSize(c int) func(*options) {
-	return func(o *options) {
-		o.chunkSize = c
-	}
-}
-
 // ParallelizeUntil is a framework that allows for parallelizing N
 // independent pieces of work until done or the context is canceled.
-func ParallelizeUntil(ctx context.Context, workers, pieces int, doWorkPiece DoWorkPieceFunc, opts ...Options) {
-	if pieces == 0 {
-		return
-	}
-	o := options{}
-	for _, opt := range opts {
-		opt(&o)
-	}
-	chunkSize := o.chunkSize
-	if chunkSize < 1 {
-		chunkSize = 1
-	}
-
-	chunks := ceilDiv(pieces, chunkSize)
-	toProcess := make(chan int, chunks)
-	for i := 0; i < chunks; i++ {
-		toProcess <- i
-	}
-	close(toProcess)
-
+func ParallelizeUntil(ctx context.Context, workers, pieces int, doWorkPiece DoWorkPieceFunc) {
 	var stop <-chan struct{}
 	if ctx != nil {
 		stop = ctx.Done()
 	}
-	if chunks < workers {
-		workers = chunks
+
+	toProcess := make(chan int, pieces)
+	for i := 0; i < pieces; i++ {
+		toProcess <- i
 	}
+	close(toProcess)
+
+	if pieces < workers {
+		workers = pieces
+	}
+
 	wg := sync.WaitGroup{}
 	wg.Add(workers)
 	for i := 0; i < workers; i++ {
 		go func() {
 			defer utilruntime.HandleCrash()
 			defer wg.Done()
-			for chunk := range toProcess {
-				start := chunk * chunkSize
-				end := start + chunkSize
-				if end > pieces {
-					end = pieces
-				}
-				for p := start; p < end; p++ {
-					select {
-					case <-stop:
-						return
-					default:
-						doWorkPiece(p)
-					}
+			for piece := range toProcess {
+				select {
+				case <-stop:
+					return
+				default:
+					doWorkPiece(piece)
 				}
 			}
 		}()
 	}
 	wg.Wait()
 }
-
-func ceilDiv(a, b int) int {
-	return (a + b - 1) / b
-}