Update dependencies to v0.16.4 tag

Automated cherry pick of #83692: add a fallback for kube-scheduler  when events.k8s.io is

Kubernetes-commit: ed185580bc39ad4316471ad2170de2c9ac0b06a2

Godeps/Godeps.json

@@ -76,7 +76,7 @@
 		},
 		{
 			"ImportPath": "github.com/evanphx/json-patch",
-			"Rev": "v4.9.0"
+			"Rev": "v4.2.0"
 		},
 		{
 			"ImportPath": "github.com/fsnotify/fsnotify",
@@ -124,11 +124,11 @@
 		},
 		{
 			"ImportPath": "github.com/golang/protobuf",
-			"Rev": "v1.3.2"
+			"Rev": "v1.3.1"
 		},
 		{
 			"ImportPath": "github.com/google/btree",
-			"Rev": "v1.0.0"
+			"Rev": "4030bb1f1f0c"
 		},
 		{
 			"ImportPath": "github.com/google/go-cmp",
@@ -164,7 +164,7 @@
 		},
 		{
 			"ImportPath": "github.com/gregjones/httpcache",
-			"Rev": "9cad4c3443a7"
+			"Rev": "787624de3eb7"
 		},
 		{
 			"ImportPath": "github.com/hashicorp/golang-lru",
@@ -180,7 +180,7 @@
 		},
 		{
 			"ImportPath": "github.com/json-iterator/go",
-			"Rev": "v1.1.8"
+			"Rev": "v1.1.7"
 		},
 		{
 			"ImportPath": "github.com/jstemmer/go-junit-report",
@@ -228,20 +228,16 @@
 		},
 		{
 			"ImportPath": "github.com/onsi/ginkgo",
-			"Rev": "v1.10.1"
+			"Rev": "v1.8.0"
 		},
 		{
 			"ImportPath": "github.com/onsi/gomega",
-			"Rev": "v1.7.0"
+			"Rev": "v1.5.0"
 		},
 		{
 			"ImportPath": "github.com/peterbourgon/diskv",
 			"Rev": "v2.0.1"
 		},
-		{
-			"ImportPath": "github.com/pkg/errors",
-			"Rev": "v0.8.1"
-		},
 		{
 			"ImportPath": "github.com/pmezard/go-difflib",
 			"Rev": "v1.0.0"
@@ -252,7 +248,7 @@
 		},
 		{
 			"ImportPath": "github.com/spf13/pflag",
-			"Rev": "v1.0.5"
+			"Rev": "v1.0.3"
 		},
 		{
 			"ImportPath": "github.com/stretchr/objx",
@@ -260,7 +256,7 @@
 		},
 		{
 			"ImportPath": "github.com/stretchr/testify",
-			"Rev": "v1.4.0"
+			"Rev": "v1.3.0"
 		},
 		{
 			"ImportPath": "go.opencensus.io",
@@ -268,7 +264,7 @@
 		},
 		{
 			"ImportPath": "golang.org/x/crypto",
-			"Rev": "bac4c82f6975"
+			"Rev": "e84da0312774"
 		},
 		{
 			"ImportPath": "golang.org/x/exp",
@@ -276,39 +272,35 @@
 		},
 		{
 			"ImportPath": "golang.org/x/lint",
-			"Rev": "5614ed5bae6f"
+			"Rev": "8f45f776aaf1"
 		},
 		{
 			"ImportPath": "golang.org/x/net",
-			"Rev": "13f9640d40b9"
+			"Rev": "cdfb69ac37fc"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "0f29369cfe45"
+			"Rev": "9f3314589c9a"
 		},
 		{
 			"ImportPath": "golang.org/x/sync",
-			"Rev": "112230192c58"
+			"Rev": "42b317875d0f"
 		},
 		{
 			"ImportPath": "golang.org/x/sys",
-			"Rev": "fde4db37ae7a"
+			"Rev": "3b5209105503"
 		},
 		{
 			"ImportPath": "golang.org/x/text",
-			"Rev": "v0.3.2"
+			"Rev": "e6919f6577db"
 		},
 		{
 			"ImportPath": "golang.org/x/time",
-			"Rev": "9d24e82272b4"
+			"Rev": "f51c12702a4d"
 		},
 		{
 			"ImportPath": "golang.org/x/tools",
-			"Rev": "65e3620a7ae7"
-		},
-		{
-			"ImportPath": "golang.org/x/xerrors",
-			"Rev": "a985d3407aa7"
+			"Rev": "e65039ee4138"
 		},
 		{
 			"ImportPath": "google.golang.org/api",
@@ -336,7 +328,7 @@
 		},
 		{
 			"ImportPath": "gopkg.in/inf.v0",
-			"Rev": "v0.9.1"
+			"Rev": "v0.9.0"
 		},
 		{
 			"ImportPath": "gopkg.in/tomb.v1",
@@ -344,7 +336,7 @@
 		},
 		{
 			"ImportPath": "gopkg.in/yaml.v2",
-			"Rev": "v2.2.8"
+			"Rev": "v2.2.4"
 		},
 		{
 			"ImportPath": "honnef.co/go/tools",
@@ -352,11 +344,11 @@
 		},
 		{
 			"ImportPath": "k8s.io/api",
-			"Rev": "v0.17.15"
+			"Rev": "v0.16.4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery",
-			"Rev": "v0.17.15"
+			"Rev": "v0.16.4"
 		},
 		{
 			"ImportPath": "k8s.io/gengo",
@@ -364,19 +356,19 @@
 		},
 		{
 			"ImportPath": "k8s.io/klog",
-			"Rev": "v1.0.0"
+			"Rev": "v0.4.0"
 		},
 		{
 			"ImportPath": "k8s.io/kube-openapi",
-			"Rev": "bcb3869e6f29"
+			"Rev": "743ec37842bf"
 		},
 		{
 			"ImportPath": "k8s.io/utils",
-			"Rev": "e782cd3c129f"
+			"Rev": "581e00157fb1"
 		},
 		{
-			"ImportPath": "sigs.k8s.io/structured-merge-diff/v2",
-			"Rev": "v2.0.1"
+			"ImportPath": "sigs.k8s.io/structured-merge-diff",
+			"Rev": "15d366b2352e"
 		},
 		{
 			"ImportPath": "sigs.k8s.io/yaml",

README.md

@@ -2,9 +2,9 @@
 
 Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.
 
-We recommend using the `kubernetes-1.x.y` tag matching the current Kubernetes release (`kubernetes-1.15.3` at the time this was written).
-See [INSTALL.md](/INSTALL.md) for detailed installation instructions.
-`go get k8s.io/client-go@master` works, but will fetch `master`, which may be less stable than a tagged release.
+We currently recommend using the v12.0.0 tag. See [INSTALL.md](/INSTALL.md) for
+detailed installation instructions. `go get k8s.io/client-go/...` works, but
+will build `master`, which doesn't handle the dependencies well.
 
 [![BuildStatus Widget]][BuildStatus Result]
 [![GoReport Widget]][GoReport Status]
@@ -164,8 +164,8 @@ This repository is still a mirror of
 the code development is still done in the staging area. Since Kubernetes 1.8
 release, when syncing the code from the staging area, we also sync the Kubernetes
 version tags to client-go, prefixed with "kubernetes-". For example, if you check
-out the `kubernetes-1.15.3` tag in client-go, the code you get is exactly the
-same as if you check out the `v1.15.3` tag in Kubernetes, and change directory to
+out the `kubernetes-v1.8.0` tag in client-go, the code you get is exactly the
+same as if you check out the `v1.8.0` tag in kubernetes, and change directory to
 `staging/src/k8s.io/client-go`. The purpose is to let users quickly find matching
 commits among published repos, like
 [sample-apiserver](https://github.com/kubernetes/sample-apiserver),
@@ -176,13 +176,10 @@ you care about backwards compatibility.
 
 ### How to get it
 
-Use go1.11+ and fetch the desired version using the `go get` command. For example:
-
-```
-go get k8s.io/client-go@kubernetes-1.15.3
-```
-
-See [INSTALL.md](/INSTALL.md) for detailed instructions.
+You can use `go get k8s.io/client-go/...` to get client-go, but **you will get
+the unstable master branch** and `client-go`'s vendored dependencies will not be
+added to your `$GOPATH`. So we think most users will want to use a dependency
+management system. See [INSTALL.md](/INSTALL.md) for detailed instructions.
 
 ### How to use it
 

deprecated-dynamic/client.go

@@ -0,0 +1,131 @@
+/*
+Copyright 2016 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 dynamic provides a client interface to arbitrary Kubernetes
+// APIs that exposes common high level operations and exposes common
+// metadata.
+package deprecated_dynamic
+
+import (
+	"strings"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/dynamic"
+	restclient "k8s.io/client-go/rest"
+)
+
+// Interface is a Kubernetes client that allows you to access metadata
+// and manipulate metadata of a Kubernetes API group.
+type Interface interface {
+	// Resource returns an API interface to the specified resource for this client's
+	// group and version.  If resource is not a namespaced resource, then namespace
+	// is ignored.  The ResourceInterface inherits the parameter codec of this client.
+	Resource(resource *metav1.APIResource, namespace string) ResourceInterface
+}
+
+// ResourceInterface is an API interface to a specific resource under a
+// dynamic client.
+type ResourceInterface interface {
+	// List returns a list of objects for this resource.
+	List(opts metav1.ListOptions) (runtime.Object, error)
+	// Get gets the resource with the specified name.
+	Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error)
+	// Delete deletes the resource with the specified name.
+	Delete(name string, opts *metav1.DeleteOptions) error
+	// DeleteCollection deletes a collection of objects.
+	DeleteCollection(deleteOptions *metav1.DeleteOptions, listOptions metav1.ListOptions) error
+	// Create creates the provided resource.
+	Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error)
+	// Update updates the provided resource.
+	Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error)
+	// Watch returns a watch.Interface that watches the resource.
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	// Patch patches the provided resource.
+	Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error)
+}
+
+// Client is a Kubernetes client that allows you to access metadata
+// and manipulate metadata of a Kubernetes API group, and implements Interface.
+type Client struct {
+	version  schema.GroupVersion
+	delegate dynamic.Interface
+}
+
+// NewClient returns a new client based on the passed in config. The
+// codec is ignored, as the dynamic client uses it's own codec.
+func NewClient(conf *restclient.Config, version schema.GroupVersion) (*Client, error) {
+	delegate, err := dynamic.NewForConfig(conf)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Client{version: version, delegate: delegate}, nil
+}
+
+// Resource returns an API interface to the specified resource for this client's
+// group and version. If resource is not a namespaced resource, then namespace
+// is ignored. The ResourceInterface inherits the parameter codec of c.
+func (c *Client) Resource(resource *metav1.APIResource, namespace string) ResourceInterface {
+	resourceTokens := strings.SplitN(resource.Name, "/", 2)
+	subresources := []string{}
+	if len(resourceTokens) > 1 {
+		subresources = strings.Split(resourceTokens[1], "/")
+	}
+
+	if len(namespace) == 0 {
+		return oldResourceShim(c.delegate.Resource(c.version.WithResource(resourceTokens[0])), subresources)
+	}
+	return oldResourceShim(c.delegate.Resource(c.version.WithResource(resourceTokens[0])).Namespace(namespace), subresources)
+}
+
+// the old interfaces used the wrong type for lists.  this fixes that
+func oldResourceShim(in dynamic.ResourceInterface, subresources []string) ResourceInterface {
+	return oldResourceShimType{ResourceInterface: in, subresources: subresources}
+}
+
+type oldResourceShimType struct {
+	dynamic.ResourceInterface
+	subresources []string
+}
+
+func (s oldResourceShimType) Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	return s.ResourceInterface.Create(obj, metav1.CreateOptions{}, s.subresources...)
+}
+
+func (s oldResourceShimType) Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	return s.ResourceInterface.Update(obj, metav1.UpdateOptions{}, s.subresources...)
+}
+
+func (s oldResourceShimType) Delete(name string, opts *metav1.DeleteOptions) error {
+	return s.ResourceInterface.Delete(name, opts, s.subresources...)
+}
+
+func (s oldResourceShimType) Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error) {
+	return s.ResourceInterface.Get(name, opts, s.subresources...)
+}
+
+func (s oldResourceShimType) List(opts metav1.ListOptions) (runtime.Object, error) {
+	return s.ResourceInterface.List(opts)
+}
+
+func (s oldResourceShimType) Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error) {
+	return s.ResourceInterface.Patch(name, pt, data, metav1.PatchOptions{}, s.subresources...)
+}

deprecated-dynamic/client_pool.go

@@ -0,0 +1,122 @@
+/*
+Copyright 2016 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 deprecated_dynamic
+
+import (
+	"sync"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	restclient "k8s.io/client-go/rest"
+)
+
+// ClientPool manages a pool of dynamic clients.
+type ClientPool interface {
+	// ClientForGroupVersionResource returns a client configured for the specified groupVersionResource.
+	// Resource may be empty.
+	ClientForGroupVersionResource(resource schema.GroupVersionResource) (Interface, error)
+	// ClientForGroupVersionKind returns a client configured for the specified groupVersionKind.
+	// Kind may be empty.
+	ClientForGroupVersionKind(kind schema.GroupVersionKind) (Interface, error)
+}
+
+// APIPathResolverFunc knows how to convert a groupVersion to its API path. The Kind field is
+// optional.
+type APIPathResolverFunc func(kind schema.GroupVersionKind) string
+
+// LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
+func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
+	if len(kind.Group) == 0 {
+		return "/api"
+	}
+	return "/apis"
+}
+
+// clientPoolImpl implements ClientPool and caches clients for the resource group versions
+// is asked to retrieve. This type is thread safe.
+type clientPoolImpl struct {
+	lock                sync.RWMutex
+	config              *restclient.Config
+	clients             map[schema.GroupVersion]*Client
+	apiPathResolverFunc APIPathResolverFunc
+	mapper              meta.RESTMapper
+}
+
+// NewClientPool returns a ClientPool from the specified config. It reuses clients for the same
+// group version. It is expected this type may be wrapped by specific logic that special cases certain
+// resources or groups.
+func NewClientPool(config *restclient.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
+	confCopy := *config
+
+	return &clientPoolImpl{
+		config:              &confCopy,
+		clients:             map[schema.GroupVersion]*Client{},
+		apiPathResolverFunc: apiPathResolverFunc,
+		mapper:              mapper,
+	}
+}
+
+// Instantiates a new dynamic client pool with the given config.
+func NewDynamicClientPool(cfg *restclient.Config) ClientPool {
+	// restMapper is not needed when using LegacyAPIPathResolverFunc
+	emptyMapper := meta.MultiRESTMapper{}
+	return NewClientPool(cfg, emptyMapper, LegacyAPIPathResolverFunc)
+}
+
+// ClientForGroupVersionResource uses the provided RESTMapper to identify the appropriate resource. Resource may
+// be empty. If no matching kind is found the underlying client for that group is still returned.
+func (c *clientPoolImpl) ClientForGroupVersionResource(resource schema.GroupVersionResource) (Interface, error) {
+	kinds, err := c.mapper.KindsFor(resource)
+	if err != nil {
+		if meta.IsNoMatchError(err) {
+			return c.ClientForGroupVersionKind(schema.GroupVersionKind{Group: resource.Group, Version: resource.Version})
+		}
+		return nil, err
+	}
+	return c.ClientForGroupVersionKind(kinds[0])
+}
+
+// ClientForGroupVersion returns a client for the specified groupVersion, creates one if none exists. Kind
+// in the GroupVersionKind may be empty.
+func (c *clientPoolImpl) ClientForGroupVersionKind(kind schema.GroupVersionKind) (Interface, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	gv := kind.GroupVersion()
+
+	// do we have a client already configured?
+	if existingClient, found := c.clients[gv]; found {
+		return existingClient, nil
+	}
+
+	// avoid changing the original config
+	confCopy := *c.config
+	conf := &confCopy
+
+	// we need to set the api path based on group version, if no group, default to legacy path
+	conf.APIPath = c.apiPathResolverFunc(kind)
+
+	// we need to make a client
+	conf.GroupVersion = &gv
+
+	dynamicClient, err := NewClient(conf, gv)
+	if err != nil {
+		return nil, err
+	}
+	c.clients[gv] = dynamicClient
+	return dynamicClient, nil
+}

deprecated-dynamic/client_test.go

@@ -0,0 +1,624 @@
+/*
+Copyright 2016 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 deprecated_dynamic
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/watch"
+	restclient "k8s.io/client-go/rest"
+	restclientwatch "k8s.io/client-go/rest/watch"
+)
+
+func getJSON(version, kind, name string) []byte {
+	return []byte(fmt.Sprintf(`{"apiVersion": %q, "kind": %q, "metadata": {"name": %q}}`, version, kind, name))
+}
+
+func getListJSON(version, kind string, items ...[]byte) []byte {
+	json := fmt.Sprintf(`{"apiVersion": %q, "kind": %q, "items": [%s]}`,
+		version, kind, bytes.Join(items, []byte(",")))
+	return []byte(json)
+}
+
+func getObject(version, kind, name string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": version,
+			"kind":       kind,
+			"metadata": map[string]interface{}{
+				"name": name,
+			},
+		},
+	}
+}
+
+func getClientServer(gv *schema.GroupVersion, h func(http.ResponseWriter, *http.Request)) (Interface, *httptest.Server, error) {
+	srv := httptest.NewServer(http.HandlerFunc(h))
+	cl, err := NewClient(&restclient.Config{
+		Host:          srv.URL,
+		ContentConfig: restclient.ContentConfig{GroupVersion: gv},
+	}, *gv)
+	if err != nil {
+		srv.Close()
+		return nil, nil, err
+	}
+	return cl, srv, nil
+}
+
+func TestList(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		path      string
+		resp      []byte
+		want      *unstructured.UnstructuredList
+	}{
+		{
+			name: "normal_list",
+			path: "/apis/gtest/vtest/rtest",
+			resp: getListJSON("vTest", "rTestList",
+				getJSON("vTest", "rTest", "item1"),
+				getJSON("vTest", "rTest", "item2")),
+			want: &unstructured.UnstructuredList{
+				Object: map[string]interface{}{
+					"apiVersion": "vTest",
+					"kind":       "rTestList",
+				},
+				Items: []unstructured.Unstructured{
+					*getObject("vTest", "rTest", "item1"),
+					*getObject("vTest", "rTest", "item2"),
+				},
+			},
+		},
+		{
+			name:      "namespaced_list",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			resp: getListJSON("vTest", "rTestList",
+				getJSON("vTest", "rTest", "item1"),
+				getJSON("vTest", "rTest", "item2")),
+			want: &unstructured.UnstructuredList{
+				Object: map[string]interface{}{
+					"apiVersion": "vTest",
+					"kind":       "rTestList",
+				},
+				Items: []unstructured.Unstructured{
+					*getObject("vTest", "rTest", "item1"),
+					*getObject("vTest", "rTest", "item2"),
+				},
+			},
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("List(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("List(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			w.Write(tc.resp)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).List(metav1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when listing %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("List(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}
+
+func TestGet(t *testing.T) {
+	tcs := []struct {
+		resource  string
+		namespace string
+		name      string
+		path      string
+		resp      []byte
+		want      *unstructured.Unstructured
+	}{
+		{
+			resource: "rtest",
+			name:     "normal_get",
+			path:     "/apis/gtest/vtest/rtest/normal_get",
+			resp:     getJSON("vTest", "rTest", "normal_get"),
+			want:     getObject("vTest", "rTest", "normal_get"),
+		},
+		{
+			resource:  "rtest",
+			namespace: "nstest",
+			name:      "namespaced_get",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_get",
+			resp:      getJSON("vTest", "rTest", "namespaced_get"),
+			want:      getObject("vTest", "rTest", "namespaced_get"),
+		},
+		{
+			resource: "rtest/srtest",
+			name:     "normal_subresource_get",
+			path:     "/apis/gtest/vtest/rtest/normal_subresource_get/srtest",
+			resp:     getJSON("vTest", "srTest", "normal_subresource_get"),
+			want:     getObject("vTest", "srTest", "normal_subresource_get"),
+		},
+		{
+			resource:  "rtest/srtest",
+			namespace: "nstest",
+			name:      "namespaced_subresource_get",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_get/srtest",
+			resp:      getJSON("vTest", "srTest", "namespaced_subresource_get"),
+			want:      getObject("vTest", "srTest", "namespaced_subresource_get"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("Get(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Get(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			w.Write(tc.resp)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Get(tc.name, metav1.GetOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when getting %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("Get(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}
+
+func TestDelete(t *testing.T) {
+	background := metav1.DeletePropagationBackground
+	uid := types.UID("uid")
+
+	statusOK := &metav1.Status{
+		TypeMeta: metav1.TypeMeta{Kind: "Status"},
+		Status:   metav1.StatusSuccess,
+	}
+	tcs := []struct {
+		namespace     string
+		name          string
+		path          string
+		deleteOptions *metav1.DeleteOptions
+	}{
+		{
+			name: "normal_delete",
+			path: "/apis/gtest/vtest/rtest/normal_delete",
+		},
+		{
+			namespace: "nstest",
+			name:      "namespaced_delete",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete",
+		},
+		{
+			namespace:     "nstest",
+			name:          "namespaced_delete_with_options",
+			path:          "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete_with_options",
+			deleteOptions: &metav1.DeleteOptions{Preconditions: &metav1.Preconditions{UID: &uid}, PropagationPolicy: &background},
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "DELETE" {
+				t.Errorf("Delete(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Delete(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		err = cl.Resource(resource, tc.namespace).Delete(tc.name, tc.deleteOptions)
+		if err != nil {
+			t.Errorf("unexpected error when deleting %q: %v", tc.name, err)
+			continue
+		}
+	}
+}
+
+func TestDeleteCollection(t *testing.T) {
+	statusOK := &metav1.Status{
+		TypeMeta: metav1.TypeMeta{Kind: "Status"},
+		Status:   metav1.StatusSuccess,
+	}
+	tcs := []struct {
+		namespace string
+		name      string
+		path      string
+	}{
+		{
+			name: "normal_delete_collection",
+			path: "/apis/gtest/vtest/rtest",
+		},
+		{
+			namespace: "nstest",
+			name:      "namespaced_delete_collection",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "DELETE" {
+				t.Errorf("DeleteCollection(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("DeleteCollection(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, metav1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when deleting collection %q: %v", tc.name, err)
+			continue
+		}
+	}
+}
+
+func TestCreate(t *testing.T) {
+	tcs := []struct {
+		resource  string
+		name      string
+		namespace string
+		obj       *unstructured.Unstructured
+		path      string
+	}{
+		{
+			resource: "rtest",
+			name:     "normal_create",
+			path:     "/apis/gtest/vtest/rtest",
+			obj:      getObject("gtest/vTest", "rTest", "normal_create"),
+		},
+		{
+			resource:  "rtest",
+			name:      "namespaced_create",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			obj:       getObject("gtest/vTest", "rTest", "namespaced_create"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "POST" {
+				t.Errorf("Create(%q) got HTTP method %s. wanted POST", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Create(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Create(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Create(tc.obj)
+		if err != nil {
+			t.Errorf("unexpected error when creating %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.obj) {
+			t.Errorf("Create(%q) want: %v\ngot: %v", tc.name, tc.obj, got)
+		}
+	}
+}
+
+func TestUpdate(t *testing.T) {
+	tcs := []struct {
+		resource  string
+		name      string
+		namespace string
+		obj       *unstructured.Unstructured
+		path      string
+	}{
+		{
+			resource: "rtest",
+			name:     "normal_update",
+			path:     "/apis/gtest/vtest/rtest/normal_update",
+			obj:      getObject("gtest/vTest", "rTest", "normal_update"),
+		},
+		{
+			resource:  "rtest",
+			name:      "namespaced_update",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_update",
+			obj:       getObject("gtest/vTest", "rTest", "namespaced_update"),
+		},
+		{
+			resource: "rtest/srtest",
+			name:     "normal_subresource_update",
+			path:     "/apis/gtest/vtest/rtest/normal_update/srtest",
+			obj:      getObject("gtest/vTest", "srTest", "normal_update"),
+		},
+		{
+			resource:  "rtest/srtest",
+			name:      "namespaced_subresource_update",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_update/srtest",
+			obj:       getObject("gtest/vTest", "srTest", "namespaced_update"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "PUT" {
+				t.Errorf("Update(%q) got HTTP method %s. wanted PUT", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Update(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Update(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Update(tc.obj)
+		if err != nil {
+			t.Errorf("unexpected error when updating %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.obj) {
+			t.Errorf("Update(%q) want: %v\ngot: %v", tc.name, tc.obj, got)
+		}
+	}
+}
+
+func TestWatch(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		events    []watch.Event
+		path      string
+		query     string
+	}{
+		{
+			name:  "normal_watch",
+			path:  "/apis/gtest/vtest/rtest",
+			query: "watch=true",
+			events: []watch.Event{
+				{Type: watch.Added, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
+				{Type: watch.Modified, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
+				{Type: watch.Deleted, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
+			},
+		},
+		{
+			name:      "namespaced_watch",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			query:     "watch=true",
+			events: []watch.Event{
+				{Type: watch.Added, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Modified, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Deleted, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
+			},
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("Watch(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Watch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+			if r.URL.RawQuery != tc.query {
+				t.Errorf("Watch(%q) got query %s. wanted %s", tc.name, r.URL.RawQuery, tc.query)
+			}
+
+			codec := unstructured.UnstructuredJSONScheme
+			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, codec), codec)
+			for _, e := range tc.events {
+				enc.Encode(&e)
+			}
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		watcher, err := cl.Resource(resource, tc.namespace).Watch(metav1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when watching %q: %v", tc.name, err)
+			continue
+		}
+
+		for _, want := range tc.events {
+			got := <-watcher.ResultChan()
+			if !reflect.DeepEqual(got, want) {
+				t.Errorf("Watch(%q) want: %v\ngot: %v", tc.name, want, got)
+			}
+		}
+	}
+}
+
+func TestPatch(t *testing.T) {
+	tcs := []struct {
+		resource  string
+		name      string
+		namespace string
+		patch     []byte
+		want      *unstructured.Unstructured
+		path      string
+	}{
+		{
+			resource: "rtest",
+			name:     "normal_patch",
+			path:     "/apis/gtest/vtest/rtest/normal_patch",
+			patch:    getJSON("gtest/vTest", "rTest", "normal_patch"),
+			want:     getObject("gtest/vTest", "rTest", "normal_patch"),
+		},
+		{
+			resource:  "rtest",
+			name:      "namespaced_patch",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_patch",
+			patch:     getJSON("gtest/vTest", "rTest", "namespaced_patch"),
+			want:      getObject("gtest/vTest", "rTest", "namespaced_patch"),
+		},
+		{
+			resource: "rtest/srtest",
+			name:     "normal_subresource_patch",
+			path:     "/apis/gtest/vtest/rtest/normal_subresource_patch/srtest",
+			patch:    getJSON("gtest/vTest", "srTest", "normal_subresource_patch"),
+			want:     getObject("gtest/vTest", "srTest", "normal_subresource_patch"),
+		},
+		{
+			resource:  "rtest/srtest",
+			name:      "namespaced_subresource_patch",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_patch/srtest",
+			patch:     getJSON("gtest/vTest", "srTest", "namespaced_subresource_patch"),
+			want:      getObject("gtest/vTest", "srTest", "namespaced_subresource_patch"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "PATCH" {
+				t.Errorf("Patch(%q) got HTTP method %s. wanted PATCH", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Patch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			content := r.Header.Get("Content-Type")
+			if content != string(types.StrategicMergePatchType) {
+				t.Errorf("Patch(%q) got Content-Type %s. wanted %s", tc.name, content, types.StrategicMergePatchType)
+			}
+
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Patch(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Header().Set("Content-Type", "application/json")
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, types.StrategicMergePatchType, tc.patch)
+		if err != nil {
+			t.Errorf("unexpected error when patching %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("Patch(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}

discovery/discovery_client.go

@@ -463,13 +463,6 @@ func setDiscoveryDefaults(config *restclient.Config) error {
 	if config.Timeout == 0 {
 		config.Timeout = defaultTimeout
 	}
-	if config.Burst == 0 && config.QPS < 100 {
-		// discovery is expected to be bursty, increase the default burst
-		// to accommodate looking up resource info for many API groups.
-		// matches burst set by ConfigFlags#ToDiscoveryClient().
-		// see https://issue.k8s.io/86149
-		config.Burst = 100
-	}
 	codec := runtime.NoopEncoder{Decoder: scheme.Codecs.UniversalDecoder()}
 	config.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec})
 	if len(config.UserAgent) == 0 {

discovery/discovery_client_test.go

@@ -24,7 +24,6 @@ import (
 	"net/http/httptest"
 	"reflect"
 	"testing"
-	"time"
 
 	"github.com/gogo/protobuf/proto"
 	"github.com/googleapis/gnostic/OpenAPIv2"
@@ -199,26 +198,6 @@ func TestGetServerResources(t *testing.T) {
 			{Name: "jobs", Namespaced: true, Kind: "Job"},
 		},
 	}
-	extensionsbeta3 := metav1.APIResourceList{GroupVersion: "extensions/v1beta3", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta4 := metav1.APIResourceList{GroupVersion: "extensions/v1beta4", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta5 := metav1.APIResourceList{GroupVersion: "extensions/v1beta5", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta6 := metav1.APIResourceList{GroupVersion: "extensions/v1beta6", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta7 := metav1.APIResourceList{GroupVersion: "extensions/v1beta7", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta8 := metav1.APIResourceList{GroupVersion: "extensions/v1beta8", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta9 := metav1.APIResourceList{GroupVersion: "extensions/v1beta9", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta10 := metav1.APIResourceList{GroupVersion: "extensions/v1beta10", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-
-	appsbeta1 := metav1.APIResourceList{GroupVersion: "apps/v1beta1", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta2 := metav1.APIResourceList{GroupVersion: "apps/v1beta2", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta3 := metav1.APIResourceList{GroupVersion: "apps/v1beta3", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta4 := metav1.APIResourceList{GroupVersion: "apps/v1beta4", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta5 := metav1.APIResourceList{GroupVersion: "apps/v1beta5", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta6 := metav1.APIResourceList{GroupVersion: "apps/v1beta6", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta7 := metav1.APIResourceList{GroupVersion: "apps/v1beta7", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta8 := metav1.APIResourceList{GroupVersion: "apps/v1beta8", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta9 := metav1.APIResourceList{GroupVersion: "apps/v1beta9", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta10 := metav1.APIResourceList{GroupVersion: "apps/v1beta10", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-
 	tests := []struct {
 		resourcesList *metav1.APIResourceList
 		path          string
@@ -253,42 +232,6 @@ func TestGetServerResources(t *testing.T) {
 			list = &beta
 		case "/apis/extensions/v1beta2":
 			list = &beta2
-		case "/apis/extensions/v1beta3":
-			list = &extensionsbeta3
-		case "/apis/extensions/v1beta4":
-			list = &extensionsbeta4
-		case "/apis/extensions/v1beta5":
-			list = &extensionsbeta5
-		case "/apis/extensions/v1beta6":
-			list = &extensionsbeta6
-		case "/apis/extensions/v1beta7":
-			list = &extensionsbeta7
-		case "/apis/extensions/v1beta8":
-			list = &extensionsbeta8
-		case "/apis/extensions/v1beta9":
-			list = &extensionsbeta9
-		case "/apis/extensions/v1beta10":
-			list = &extensionsbeta10
-		case "/apis/apps/v1beta1":
-			list = &appsbeta1
-		case "/apis/apps/v1beta2":
-			list = &appsbeta2
-		case "/apis/apps/v1beta3":
-			list = &appsbeta3
-		case "/apis/apps/v1beta4":
-			list = &appsbeta4
-		case "/apis/apps/v1beta5":
-			list = &appsbeta5
-		case "/apis/apps/v1beta6":
-			list = &appsbeta6
-		case "/apis/apps/v1beta7":
-			list = &appsbeta7
-		case "/apis/apps/v1beta8":
-			list = &appsbeta8
-		case "/apis/apps/v1beta9":
-			list = &appsbeta9
-		case "/apis/apps/v1beta10":
-			list = &appsbeta10
 		case "/api":
 			list = &metav1.APIVersions{
 				Versions: []string{
@@ -298,34 +241,11 @@ func TestGetServerResources(t *testing.T) {
 		case "/apis":
 			list = &metav1.APIGroupList{
 				Groups: []metav1.APIGroup{
-					{
-						Name: "apps",
-						Versions: []metav1.GroupVersionForDiscovery{
-							{GroupVersion: "apps/v1beta1", Version: "v1beta1"},
-							{GroupVersion: "apps/v1beta2", Version: "v1beta2"},
-							{GroupVersion: "apps/v1beta3", Version: "v1beta3"},
-							{GroupVersion: "apps/v1beta4", Version: "v1beta4"},
-							{GroupVersion: "apps/v1beta5", Version: "v1beta5"},
-							{GroupVersion: "apps/v1beta6", Version: "v1beta6"},
-							{GroupVersion: "apps/v1beta7", Version: "v1beta7"},
-							{GroupVersion: "apps/v1beta8", Version: "v1beta8"},
-							{GroupVersion: "apps/v1beta9", Version: "v1beta9"},
-							{GroupVersion: "apps/v1beta10", Version: "v1beta10"},
-						},
-					},
 					{
 						Name: "extensions",
 						Versions: []metav1.GroupVersionForDiscovery{
 							{GroupVersion: "extensions/v1beta1", Version: "v1beta1"},
 							{GroupVersion: "extensions/v1beta2", Version: "v1beta2"},
-							{GroupVersion: "extensions/v1beta3", Version: "v1beta3"},
-							{GroupVersion: "extensions/v1beta4", Version: "v1beta4"},
-							{GroupVersion: "extensions/v1beta5", Version: "v1beta5"},
-							{GroupVersion: "extensions/v1beta6", Version: "v1beta6"},
-							{GroupVersion: "extensions/v1beta7", Version: "v1beta7"},
-							{GroupVersion: "extensions/v1beta8", Version: "v1beta8"},
-							{GroupVersion: "extensions/v1beta9", Version: "v1beta9"},
-							{GroupVersion: "extensions/v1beta10", Version: "v1beta10"},
 						},
 					},
 				},
@@ -345,8 +265,8 @@ func TestGetServerResources(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 	for _, test := range tests {
-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 		got, err := client.ServerResourcesForGroupVersion(test.request)
 		if test.expectErr {
 			if err == nil {
@@ -363,40 +283,12 @@ func TestGetServerResources(t *testing.T) {
 		}
 	}
 
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	start := time.Now()
 	serverResources, err := client.ServerResources()
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	end := time.Now()
-	if d := end.Sub(start); d > time.Second {
-		t.Errorf("took too long to perform discovery: %s", d)
-	}
 	serverGroupVersions := groupVersions(serverResources)
-	expectedGroupVersions := []string{
-		"v1",
-		"apps/v1beta1",
-		"apps/v1beta2",
-		"apps/v1beta3",
-		"apps/v1beta4",
-		"apps/v1beta5",
-		"apps/v1beta6",
-		"apps/v1beta7",
-		"apps/v1beta8",
-		"apps/v1beta9",
-		"apps/v1beta10",
-		"extensions/v1beta1",
-		"extensions/v1beta2",
-		"extensions/v1beta3",
-		"extensions/v1beta4",
-		"extensions/v1beta5",
-		"extensions/v1beta6",
-		"extensions/v1beta7",
-		"extensions/v1beta8",
-		"extensions/v1beta9",
-		"extensions/v1beta10",
-	}
+	expectedGroupVersions := []string{"v1", "extensions/v1beta1", "extensions/v1beta2"}
 	if !reflect.DeepEqual(expectedGroupVersions, serverGroupVersions) {
 		t.Errorf("unexpected group versions: %v", diff.ObjectReflectDiff(expectedGroupVersions, serverGroupVersions))
 	}

dynamic/client_test.go

@@ -537,8 +537,6 @@ func TestWatch(t *testing.T) {
 				t.Errorf("Watch(%q) got query %s. wanted %s", tc.name, r.URL.RawQuery, tc.query)
 			}
 
-			w.Header().Set("Content-Type", "application/json")
-
 			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, unstructured.UnstructuredJSONScheme), unstructured.UnstructuredJSONScheme)
 			for _, e := range tc.events {
 				enc.Encode(&e)

dynamic/scheme.go

@@ -18,11 +18,11 @@ package dynamic
 
 import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/apimachinery/pkg/runtime/serializer/json"
+	"k8s.io/apimachinery/pkg/runtime/serializer/versioning"
 )
 
 var watchScheme = runtime.NewScheme()
@@ -41,6 +41,37 @@ func init() {
 	metav1.AddToGroupVersion(deleteScheme, versionV1)
 }
 
+var watchJsonSerializerInfo = runtime.SerializerInfo{
+	MediaType:        "application/json",
+	MediaTypeType:    "application",
+	MediaTypeSubType: "json",
+	EncodesAsText:    true,
+	Serializer:       json.NewSerializer(json.DefaultMetaFactory, watchScheme, watchScheme, false),
+	PrettySerializer: json.NewSerializer(json.DefaultMetaFactory, watchScheme, watchScheme, true),
+	StreamSerializer: &runtime.StreamSerializerInfo{
+		EncodesAsText: true,
+		Serializer:    json.NewSerializer(json.DefaultMetaFactory, watchScheme, watchScheme, false),
+		Framer:        json.Framer,
+	},
+}
+
+// watchNegotiatedSerializer is used to read the wrapper of the watch stream
+type watchNegotiatedSerializer struct{}
+
+var watchNegotiatedSerializerInstance = watchNegotiatedSerializer{}
+
+func (s watchNegotiatedSerializer) SupportedMediaTypes() []runtime.SerializerInfo {
+	return []runtime.SerializerInfo{watchJsonSerializerInfo}
+}
+
+func (s watchNegotiatedSerializer) EncoderForVersion(encoder runtime.Encoder, gv runtime.GroupVersioner) runtime.Encoder {
+	return versioning.NewDefaultingCodecForScheme(watchScheme, encoder, nil, gv, nil)
+}
+
+func (s watchNegotiatedSerializer) DecoderToVersion(decoder runtime.Decoder, gv runtime.GroupVersioner) runtime.Decoder {
+	return versioning.NewDefaultingCodecForScheme(watchScheme, nil, decoder, nil, gv)
+}
+
 // basicNegotiatedSerializer is used to handle discovery and error handling serialization
 type basicNegotiatedSerializer struct{}
 
@@ -51,8 +82,8 @@ func (s basicNegotiatedSerializer) SupportedMediaTypes() []runtime.SerializerInf
 			MediaTypeType:    "application",
 			MediaTypeSubType: "json",
 			EncodesAsText:    true,
-			Serializer:       json.NewSerializer(json.DefaultMetaFactory, unstructuredCreater{basicScheme}, unstructuredTyper{basicScheme}, false),
-			PrettySerializer: json.NewSerializer(json.DefaultMetaFactory, unstructuredCreater{basicScheme}, unstructuredTyper{basicScheme}, true),
+			Serializer:       json.NewSerializer(json.DefaultMetaFactory, basicScheme, basicScheme, false),
+			PrettySerializer: json.NewSerializer(json.DefaultMetaFactory, basicScheme, basicScheme, true),
 			StreamSerializer: &runtime.StreamSerializerInfo{
 				EncodesAsText: true,
 				Serializer:    json.NewSerializer(json.DefaultMetaFactory, basicScheme, basicScheme, false),
@@ -63,46 +94,9 @@ func (s basicNegotiatedSerializer) SupportedMediaTypes() []runtime.SerializerInf
 }
 
 func (s basicNegotiatedSerializer) EncoderForVersion(encoder runtime.Encoder, gv runtime.GroupVersioner) runtime.Encoder {
-	return runtime.WithVersionEncoder{
-		Version:     gv,
-		Encoder:     encoder,
-		ObjectTyper: unstructuredTyper{basicScheme},
-	}
+	return versioning.NewDefaultingCodecForScheme(watchScheme, encoder, nil, gv, nil)
 }
 
 func (s basicNegotiatedSerializer) DecoderToVersion(decoder runtime.Decoder, gv runtime.GroupVersioner) runtime.Decoder {
-	return decoder
-}
-
-type unstructuredCreater struct {
-	nested runtime.ObjectCreater
-}
-
-func (c unstructuredCreater) New(kind schema.GroupVersionKind) (runtime.Object, error) {
-	out, err := c.nested.New(kind)
-	if err == nil {
-		return out, nil
-	}
-	out = &unstructured.Unstructured{}
-	out.GetObjectKind().SetGroupVersionKind(kind)
-	return out, nil
-}
-
-type unstructuredTyper struct {
-	nested runtime.ObjectTyper
-}
-
-func (t unstructuredTyper) ObjectKinds(obj runtime.Object) ([]schema.GroupVersionKind, bool, error) {
-	kinds, unversioned, err := t.nested.ObjectKinds(obj)
-	if err == nil {
-		return kinds, unversioned, nil
-	}
-	if _, ok := obj.(runtime.Unstructured); ok && !obj.GetObjectKind().GroupVersionKind().Empty() {
-		return []schema.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
-	}
-	return nil, false, err
-}
-
-func (t unstructuredTyper) Recognizes(gvk schema.GroupVersionKind) bool {
-	return true
+	return versioning.NewDefaultingCodecForScheme(watchScheme, nil, decoder, nil, gv)
 }

dynamic/simple.go

@@ -18,12 +18,14 @@ package dynamic
 
 import (
 	"fmt"
+	"io"
 
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/rest"
@@ -280,10 +282,31 @@ func (c *dynamicResourceClient) List(opts metav1.ListOptions) (*unstructured.Uns
 }
 
 func (c *dynamicResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	internalGV := schema.GroupVersions{
+		{Group: c.resource.Group, Version: runtime.APIVersionInternal},
+		// always include the legacy group as a decoding target to handle non-error `Status` return types
+		{Group: "", Version: runtime.APIVersionInternal},
+	}
+	s := &rest.Serializers{
+		Encoder: watchNegotiatedSerializerInstance.EncoderForVersion(watchJsonSerializerInfo.Serializer, c.resource.GroupVersion()),
+		Decoder: watchNegotiatedSerializerInstance.DecoderToVersion(watchJsonSerializerInfo.Serializer, internalGV),
+
+		RenegotiatedDecoder: func(contentType string, params map[string]string) (runtime.Decoder, error) {
+			return watchNegotiatedSerializerInstance.DecoderToVersion(watchJsonSerializerInfo.Serializer, internalGV), nil
+		},
+		StreamingSerializer: watchJsonSerializerInfo.StreamSerializer.Serializer,
+		Framer:              watchJsonSerializerInfo.StreamSerializer.Framer,
+	}
+
+	wrappedDecoderFn := func(body io.ReadCloser) streaming.Decoder {
+		framer := s.Framer.NewFrameReader(body)
+		return streaming.NewDecoder(framer, s.StreamingSerializer)
+	}
+
 	opts.Watch = true
 	return c.client.client.Get().AbsPath(c.makeURLSegments("")...).
 		SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
-		Watch()
+		WatchWithSpecificDecoders(wrappedDecoderFn, unstructured.UnstructuredJSONScheme)
 }
 
 func (c *dynamicResourceClient) Patch(name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*unstructured.Unstructured, error) {

examples/create-update-delete-deployment/main.go

@@ -33,7 +33,7 @@ import (
 	"k8s.io/client-go/util/retry"
 	//
 	// Uncomment to load all auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth"
+	// _ "k8s.io/client-go/plugin/pkg/client/auth
 	//
 	// Or uncomment to load specific auth plugins
 	// _ "k8s.io/client-go/plugin/pkg/client/auth/azure"

examples/dynamic-create-update-delete-deployment/main.go

@@ -34,7 +34,7 @@ import (
 	"k8s.io/client-go/util/retry"
 	//
 	// Uncomment to load all auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth"
+	// _ "k8s.io/client-go/plugin/pkg/client/auth
 	//
 	// Or uncomment to load specific auth plugins
 	// _ "k8s.io/client-go/plugin/pkg/client/auth/azure"

examples/in-cluster-client-configuration/main.go

@@ -27,7 +27,7 @@ import (
 	"k8s.io/client-go/rest"
 	//
 	// Uncomment to load all auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth"
+	// _ "k8s.io/client-go/plugin/pkg/client/auth
 	//
 	// Or uncomment to load specific auth plugins
 	// _ "k8s.io/client-go/plugin/pkg/client/auth/azure"
@@ -48,8 +48,6 @@ func main() {
 		panic(err.Error())
 	}
 	for {
-		// get pods in all the namespaces by omitting namespace
-		// Or specify namespace to get pods in particular namespace
 		pods, err := clientset.CoreV1().Pods("").List(metav1.ListOptions{})
 		if err != nil {
 			panic(err.Error())
@@ -57,17 +55,17 @@ func main() {
 		fmt.Printf("There are %d pods in the cluster\n", len(pods.Items))
 
 		// Examples for error handling:
-		// - Use helper functions e.g. errors.IsNotFound()
+		// - Use helper functions like e.g. errors.IsNotFound()
 		// - And/or cast to StatusError and use its properties like e.g. ErrStatus.Message
 		_, err = clientset.CoreV1().Pods("default").Get("example-xxxxx", metav1.GetOptions{})
 		if errors.IsNotFound(err) {
-			fmt.Printf("Pod example-xxxxx not found in default namespace\n")
+			fmt.Printf("Pod not found\n")
 		} else if statusError, isStatus := err.(*errors.StatusError); isStatus {
 			fmt.Printf("Error getting pod %v\n", statusError.ErrStatus.Message)
 		} else if err != nil {
 			panic(err.Error())
 		} else {
-			fmt.Printf("Found example-xxxxx pod in default namespace\n")
+			fmt.Printf("Found pod\n")
 		}
 
 		time.Sleep(10 * time.Second)

examples/leader-election/README.md

@@ -7,16 +7,15 @@ This example demonstrates how to use the leader election package.
 Run the following three commands in separate terminals. Each terminal needs a unique `id`.
 
 ```bash
-# first terminal
-go run main.go -kubeconfig=/path/to/kubeconfig -logtostderr=true -lease-lock-name=example -lease-lock-namespace=default -id=1
+# first terminal 
+go run *.go -kubeconfig=/my/config -logtostderr=true -id=1
 
-# second terminal
-go run main.go -kubeconfig=/path/to/kubeconfig -logtostderr=true -lease-lock-name=example -lease-lock-namespace=default -id=2
+# second terminal 
+go run *.go -kubeconfig=/my/config -logtostderr=true -id=2
 
 # third terminal
-go run main.go -kubeconfig=/path/to/kubeconfig -logtostderr=true -lease-lock-name=example -lease-lock-namespace=default -id=3
+go run *.go -kubeconfig=/my/config -logtostderr=true -id=3
 ```
-
 > You can ignore the `-kubeconfig` flag if you are running these commands in the Kubernetes cluster.
 
 Now kill the existing leader. You will see from the terminal outputs that one of the remaining two processes will be elected as the new leader.

examples/leader-election/main.go

@@ -19,18 +19,21 @@ package main
 import (
 	"context"
 	"flag"
+	"fmt"
+	"log"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 	"time"
 
-	"github.com/google/uuid"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 	"k8s.io/client-go/tools/leaderelection"
 	"k8s.io/client-go/tools/leaderelection/resourcelock"
+	"k8s.io/client-go/transport"
 	"k8s.io/klog"
 )
 
@@ -59,16 +62,13 @@ func main() {
 	var id string
 
 	flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
-	flag.StringVar(&id, "id", uuid.New().String(), "the holder identity name")
-	flag.StringVar(&leaseLockName, "lease-lock-name", "", "the lease lock resource name")
-	flag.StringVar(&leaseLockNamespace, "lease-lock-namespace", "", "the lease lock resource namespace")
+	flag.StringVar(&id, "id", "", "the holder identity name")
+	flag.StringVar(&leaseLockName, "lease-lock-name", "example", "the lease lock resource name")
+	flag.StringVar(&leaseLockNamespace, "lease-lock-namespace", "default", "the lease lock resource namespace")
 	flag.Parse()
 
-	if leaseLockName == "" {
-		klog.Fatal("unable to get lease lock resource name (missing lease-lock-name flag).")
-	}
-	if leaseLockNamespace == "" {
-		klog.Fatal("unable to get lease lock resource namespace (missing lease-lock-namespace flag).")
+	if id == "" {
+		klog.Fatal("unable to get id (missing id flag).")
 	}
 
 	// leader election uses the Kubernetes API by writing to a
@@ -82,29 +82,6 @@ func main() {
 	}
 	client := clientset.NewForConfigOrDie(config)
 
-	run := func(ctx context.Context) {
-		// complete your controller loop here
-		klog.Info("Controller loop...")
-
-		select {}
-	}
-
-	// use a Go context so we can tell the leaderelection code when we
-	// want to step down
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// listen for interrupts or the Linux SIGTERM signal and cancel
-	// our context, which the leader election code will observe and
-	// step down
-	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
-	go func() {
-		<-ch
-		klog.Info("Received termination, signaling shutdown")
-		cancel()
-	}()
-
 	// we use the Lease lock type since edits to Leases are less common
 	// and fewer objects in the cluster watch "all Leases".
 	lock := &resourcelock.LeaseLock{
@@ -118,6 +95,25 @@ func main() {
 		},
 	}
 
+	// use a Go context so we can tell the leaderelection code when we
+	// want to step down
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// use a client that will stop allowing new requests once the context ends
+	config.Wrap(transport.ContextCanceller(ctx, fmt.Errorf("the leader is shutting down")))
+
+	// listen for interrupts or the Linux SIGTERM signal and cancel
+	// our context, which the leader election code will observe and
+	// step down
+	ch := make(chan os.Signal, 1)
+	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-ch
+		log.Printf("Received termination, signaling shutdown")
+		cancel()
+	}()
+
 	// start the leader election code loop
 	leaderelection.RunOrDie(ctx, leaderelection.LeaderElectionConfig{
 		Lock: lock,
@@ -135,12 +131,12 @@ func main() {
 			OnStartedLeading: func(ctx context.Context) {
 				// we're notified when we start - this is where you would
 				// usually put your code
-				run(ctx)
+				klog.Infof("%s: leading", id)
 			},
 			OnStoppedLeading: func() {
-				// we can do cleanup here
-				klog.Infof("leader lost: %s", id)
-				os.Exit(0)
+				// we can do cleanup here, or after the RunOrDie method
+				// returns
+				klog.Infof("%s: lost", id)
 			},
 			OnNewLeader: func(identity string) {
 				// we're notified when new leader elected
@@ -148,8 +144,18 @@ func main() {
 					// I just got the lock
 					return
 				}
-				klog.Infof("new leader elected: %s", identity)
+				klog.Infof("new leader elected: %v", identity)
 			},
 		},
 	})
+
+	// because the context is closed, the client should report errors
+	_, err = client.CoordinationV1().Leases(leaseLockNamespace).Get(leaseLockName, metav1.GetOptions{})
+	if err == nil || !strings.Contains(err.Error(), "the leader is shutting down") {
+		log.Fatalf("%s: expected to get an error when trying to make a client call: %v", id, err)
+	}
+
+	// we no longer hold the lease, so perform any cleanup and then
+	// exit
+	log.Printf("%s: done", id)
 }

go.mod

@@ -9,35 +9,38 @@ require (
 	github.com/Azure/go-autorest/autorest v0.9.0
 	github.com/Azure/go-autorest/autorest/adal v0.5.0
 	github.com/davecgh/go-spew v1.1.1
-	github.com/evanphx/json-patch v4.9.0+incompatible
+	github.com/evanphx/json-patch v4.2.0+incompatible
 	github.com/gogo/protobuf v1.2.2-0.20190723190241-65acae22fc9d
 	github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903
-	github.com/golang/protobuf v1.3.2
-	github.com/google/btree v1.0.0 // indirect
+	github.com/golang/protobuf v1.3.1
 	github.com/google/gofuzz v1.0.0
-	github.com/google/uuid v1.1.1
 	github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d
 	github.com/gophercloud/gophercloud v0.1.0
-	github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7
+	github.com/gregjones/httpcache v0.0.0-20170728041850-787624de3eb7
 	github.com/imdario/mergo v0.3.5
 	github.com/peterbourgon/diskv v2.0.1+incompatible
-	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.4.0
-	golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975
-	golang.org/x/net v0.0.0-20191004110552-13f9640d40b9
+	github.com/spf13/pflag v1.0.3
+	github.com/stretchr/testify v1.3.0
+	golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8
+	golang.org/x/net v0.0.0-20190812203447-cdfb69ac37fc
 	golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45
-	golang.org/x/time v0.0.0-20190308202827-9d24e82272b4
+	golang.org/x/time v0.0.0-20181108054448-85acf8d2951c
 	google.golang.org/appengine v1.5.0 // indirect
-	k8s.io/api v0.17.15
-	k8s.io/apimachinery v0.17.15
-	k8s.io/klog v1.0.0
-	k8s.io/utils v0.0.0-20191114184206-e782cd3c129f
+	k8s.io/api v0.16.4
+	k8s.io/apimachinery v0.16.4
+	k8s.io/klog v0.4.0
+	k8s.io/utils v0.0.0-20190801114015-581e00157fb1
 	sigs.k8s.io/yaml v1.1.0
 )
 
 replace (
-	golang.org/x/sys => golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a // pinned to release-branch.go1.13
-	golang.org/x/tools => golang.org/x/tools v0.0.0-20190821162956-65e3620a7ae7 // pinned to release-branch.go1.13
-	k8s.io/api => k8s.io/api v0.17.15
-	k8s.io/apimachinery => k8s.io/apimachinery v0.17.15
+	golang.org/x/crypto => golang.org/x/crypto v0.0.0-20181025213731-e84da0312774
+	golang.org/x/lint => golang.org/x/lint v0.0.0-20181217174547-8f45f776aaf1
+	golang.org/x/oauth2 => golang.org/x/oauth2 v0.0.0-20190402181905-9f3314589c9a
+	golang.org/x/sync => golang.org/x/sync v0.0.0-20181108010431-42b317875d0f
+	golang.org/x/sys => golang.org/x/sys v0.0.0-20190209173611-3b5209105503
+	golang.org/x/text => golang.org/x/text v0.3.1-0.20181227161524-e6919f6577db
+	golang.org/x/time => golang.org/x/time v0.0.0-20161028155119-f51c12702a4d
+	k8s.io/api => k8s.io/api v0.16.4
+	k8s.io/apimachinery => k8s.io/apimachinery v0.16.4
 )

go.sum

@@ -21,6 +21,7 @@ github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb0
 github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
 github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/davecgh/go-spew v0.0.0-20151105211317-5215b55f46b2/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -31,8 +32,8 @@ github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZ
 github.com/elazarl/goproxy v0.0.0-20170405201442-c4fc26588b6e h1:p1yVGRW3nmb85p1Sh1ZJSDm4A4iKLS5QNbvUHMgGu/M=
 github.com/elazarl/goproxy v0.0.0-20170405201442-c4fc26588b6e/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
 github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
-github.com/evanphx/json-patch v4.9.0+incompatible h1:kLcOMZeuLAJvL2BPWLMIj5oaZQobrkAqrL+WFZwQses=
-github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
+github.com/evanphx/json-patch v4.2.0+incompatible h1:fUDGZCv/7iAN7u0puUVhvKCcsR6vRfwrJatElLBEf0I=
+github.com/evanphx/json-patch v4.2.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
@@ -49,29 +50,28 @@ github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4er
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c h1:964Od4U6p2jUkFxvCydnIczKteheJEzHRToSGK3Bnlw=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/gofuzz v0.0.0-20161122191042-44d81051d367/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
 github.com/google/gofuzz v1.0.0 h1:A8PeW59pxE9IoFRqBp37U+mSNaQoZ46F1f0f863XSXw=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d h1:7XGaL1e6bYS1yIonGp9761ExpPPV1ui0SAC59Yube9k=
 github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
 github.com/gophercloud/gophercloud v0.1.0 h1:P/nh25+rzXouhytV2pUHBb65fnds26Ghl8/391+sT5o=
 github.com/gophercloud/gophercloud v0.1.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEoIEcSTewFxm1c5g8=
-github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7 h1:pdN6V1QBWetyv/0+wjACpqVH+eVULgEjkurDLq3goeM=
-github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/gregjones/httpcache v0.0.0-20170728041850-787624de3eb7 h1:6TSoaYExHper8PYsJu23GWVNOyYRCSnIFyxKgLSZ54w=
+github.com/gregjones/httpcache v0.0.0-20170728041850-787624de3eb7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
 github.com/hashicorp/golang-lru v0.5.0 h1:CL2msUPvZTLb5O648aiLNJw3hnBxN2+1Jq8rCOH9wdo=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU=
@@ -80,9 +80,9 @@ github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/imdario/mergo v0.3.5 h1:JboBksRwiiAJWvIYJVo46AfV+IAIKZpfrSzVKj42R4Q=
 github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.8 h1:QiWkFLKq0T7mpzwOTu6BzNDbfTE8OLrYhVKYMLF46Ok=
-github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v0.0.0-20180612202835-f2b4162afba3/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.7 h1:KfgG9LzI+pYjr4xvmz/5H4FXjokeP+rlHLhv3iH62Fo=
+github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
@@ -95,6 +95,7 @@ github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180320133207-05fbef0ca5da/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
@@ -103,35 +104,29 @@ github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+
 github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.10.1 h1:q/mM8GF/n0shIN8SaAZ0V+jnLPzen6WIVZdiwrRlMlo=
-github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.8.0 h1:VkHVNpR4iVnU8XQR6DBm8BqYjN7CRzw+xKUbVVbbW9w=
+github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
-github.com/onsi/gomega v1.7.0 h1:XPnZz8VVBHjVsy1vzJmRwIcSwiUO+JFfrv/xGiigmME=
-github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.5.0 h1:izbySO9zDPmjJ8rDjLvkA2zJHIo+HkYXHnf7eN7SSyo=
+github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI=
 github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v0.0.0-20151208002404-e3a8ff8ce365/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975 h1:/Tl7pH94bvbAAHBdZJT947M/+gp0+CqQXDtMRC0fseo=
-golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20181025213731-e84da0312774 h1:a4tQYYYuK9QdeO/+kEvNYyuR21S+7ve5EANok6hABhI=
+golang.org/x/crypto v0.0.0-20181025213731-e84da0312774/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20181217174547-8f45f776aaf1/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -139,30 +134,24 @@ golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191004110552-13f9640d40b9 h1:rjwSpXsdiK0dV8/Naq3kAw9ymfAeJIyd0upUIElB+lI=
-golang.org/x/net v0.0.0-20191004110552-13f9640d40b9/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45 h1:SVwTIAaPC2U/AvvLNZ2a7OVsmBpC8L5BlwK1whH3hm0=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a h1:aYOabOQFp6Vj6W1F80affTUvO9UxmJRx8K0gsfABByQ=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20190821162956-65e3620a7ae7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/net v0.0.0-20190812203447-cdfb69ac37fc h1:gkKoSkUmnU6bpS/VhkuO27bzQeSA51uaEfbOW5dNb68=
+golang.org/x/net v0.0.0-20190812203447-cdfb69ac37fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/oauth2 v0.0.0-20190402181905-9f3314589c9a h1:tImsplftrFpALCYumobsd0K86vlAs/eXGFms2txfJfA=
+golang.org/x/oauth2 v0.0.0-20190402181905-9f3314589c9a/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190209173611-3b5209105503 h1:5SvYFrOM3W8Mexn9/oA44Ji7vhXAZQ9hiP+1Q/DMrWg=
+golang.org/x/sys v0.0.0-20190209173611-3b5209105503/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.1-0.20181227161524-e6919f6577db h1:6/JqlYfC1CCaLnGceQTI+sDGhC9UBSPAsBqI0Gun6kU=
+golang.org/x/text v0.3.1-0.20181227161524-e6919f6577db/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/time v0.0.0-20161028155119-f51c12702a4d h1:TnM+PKb3ylGmZvyPXmo9m/wktg7Jn/a/fNmr33HSj8g=
+golang.org/x/time v0.0.0-20161028155119-f51c12702a4d/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
@@ -178,29 +167,29 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
-gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/inf.v0 v0.9.0 h1:3zYtXIO92bvsdS3ggAdA8Gb4Azj0YU+TVY1uGYNFA8o=
+gopkg.in/inf.v0 v0.9.0/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-k8s.io/api v0.17.15/go.mod h1:mCepU58Bb3HpTKL9PsivAEq7oeWHTj9eK2Drst9gPKU=
-k8s.io/apimachinery v0.17.15/go.mod h1:T54ZSpncArE25c5r2PbUPsLeTpkPWY/ivafigSX6+xk=
+k8s.io/api v0.16.4/go.mod h1:AtzMnsR45tccQss5q8RnF+W8L81DH6XwXwo/joEx9u0=
+k8s.io/apimachinery v0.16.4/go.mod h1:llRdnznGEAqC3DcNm6yEj472xaFVfLM7hnYofMb12tQ=
 k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
 k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
 k8s.io/klog v0.3.0/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
-k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8=
-k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I=
-k8s.io/kube-openapi v0.0.0-20200410145947-bcb3869e6f29 h1:NeQXVJ2XFSkRoPzRo8AId01ZER+j8oV4SZADT4iBOXQ=
-k8s.io/kube-openapi v0.0.0-20200410145947-bcb3869e6f29/go.mod h1:F+5wygcW0wmRTnM3cOgIqGivxkwSWIWT5YdsDbeAOaU=
-k8s.io/utils v0.0.0-20191114184206-e782cd3c129f h1:GiPwtSzdP43eI1hpPCbROQCCIgCuiMMNF8YUVLF3vJo=
-k8s.io/utils v0.0.0-20191114184206-e782cd3c129f/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
-sigs.k8s.io/structured-merge-diff/v2 v2.0.1/go.mod h1:Wb7vfKAodbKgf6tn1Kl0VvGj7mRH6DGaRcixXEJXTsE=
+k8s.io/klog v0.4.0 h1:lCJCxf/LIowc2IGS9TPjWDyXY4nOmdGdfcwwDQCOURQ=
+k8s.io/klog v0.4.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I=
+k8s.io/kube-openapi v0.0.0-20190816220812-743ec37842bf h1:EYm5AW/UUDbnmnI+gK0TJDVK9qPLhM+sRHYanNKw0EQ=
+k8s.io/kube-openapi v0.0.0-20190816220812-743ec37842bf/go.mod h1:1TqjTSzOxsLGIKfj0lK8EeCP7K1iUG65v09OM0/WG5E=
+k8s.io/utils v0.0.0-20190801114015-581e00157fb1 h1:+ySTxfHnfzZb9ys375PXNlLhkJPLKgHajBU0N62BDvE=
+k8s.io/utils v0.0.0-20190801114015-581e00157fb1/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
+sigs.k8s.io/structured-merge-diff v0.0.0-20190525122527-15d366b2352e/go.mod h1:wWxsB5ozmmv/SG7nM11ayaAW51xMvak/t1r0CSlcokI=
 sigs.k8s.io/yaml v1.1.0 h1:4A07+ZFc2wgJwo8YNlQpr1rVlgUDlxXHhPJciaPY5gs=
 sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=

informers/discovery/interface.go

@@ -20,7 +20,6 @@ package discovery
 
 import (
 	v1alpha1 "k8s.io/client-go/informers/discovery/v1alpha1"
-	v1beta1 "k8s.io/client-go/informers/discovery/v1beta1"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
 )
 
@@ -28,8 +27,6 @@ import (
 type Interface interface {
 	// V1alpha1 provides access to shared informers for resources in V1alpha1.
 	V1alpha1() v1alpha1.Interface
-	// V1beta1 provides access to shared informers for resources in V1beta1.
-	V1beta1() v1beta1.Interface
 }
 
 type group struct {
@@ -47,8 +44,3 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
 func (g *group) V1alpha1() v1alpha1.Interface {
 	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
 }
-
-// V1beta1 returns a new v1beta1.Interface.
-func (g *group) V1beta1() v1beta1.Interface {
-	return v1beta1.New(g.factory, g.namespace, g.tweakListOptions)
-}

informers/discovery/v1beta1/endpointslice.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 informer-gen. DO NOT EDIT.
-
-package v1beta1
-
-import (
-	time "time"
-
-	discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	watch "k8s.io/apimachinery/pkg/watch"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	kubernetes "k8s.io/client-go/kubernetes"
-	v1beta1 "k8s.io/client-go/listers/discovery/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// EndpointSliceInformer provides access to a shared informer and lister for
-// EndpointSlices.
-type EndpointSliceInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.EndpointSliceLister
-}
-
-type endpointSliceInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-	namespace        string
-}
-
-// NewEndpointSliceInformer constructs a new informer for EndpointSlice type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewEndpointSliceInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredEndpointSliceInformer(client, namespace, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredEndpointSliceInformer constructs a new informer for EndpointSlice type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewFilteredEndpointSliceInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.DiscoveryV1beta1().EndpointSlices(namespace).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.DiscoveryV1beta1().EndpointSlices(namespace).Watch(options)
-			},
-		},
-		&discoveryv1beta1.EndpointSlice{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *endpointSliceInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredEndpointSliceInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *endpointSliceInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&discoveryv1beta1.EndpointSlice{}, f.defaultInformer)
-}
-
-func (f *endpointSliceInformer) Lister() v1beta1.EndpointSliceLister {
-	return v1beta1.NewEndpointSliceLister(f.Informer().GetIndexer())
-}

informers/discovery/v1beta1/interface.go

@@ -1,45 +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 informer-gen. DO NOT EDIT.
-
-package v1beta1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// EndpointSlices returns a EndpointSliceInformer.
-	EndpointSlices() EndpointSliceInformer
-}
-
-type version struct {
-	factory          internalinterfaces.SharedInformerFactory
-	namespace        string
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
-	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
-}
-
-// EndpointSlices returns a EndpointSliceInformer.
-func (v *version) EndpointSlices() EndpointSliceInformer {
-	return &endpointSliceInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
-}

informers/factory.go

@@ -37,7 +37,6 @@ import (
 	discovery "k8s.io/client-go/informers/discovery"
 	events "k8s.io/client-go/informers/events"
 	extensions "k8s.io/client-go/informers/extensions"
-	flowcontrol "k8s.io/client-go/informers/flowcontrol"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
 	networking "k8s.io/client-go/informers/networking"
 	node "k8s.io/client-go/informers/node"
@@ -201,7 +200,6 @@ type SharedInformerFactory interface {
 	Discovery() discovery.Interface
 	Events() events.Interface
 	Extensions() extensions.Interface
-	Flowcontrol() flowcontrol.Interface
 	Networking() networking.Interface
 	Node() node.Interface
 	Policy() policy.Interface
@@ -255,10 +253,6 @@ func (f *sharedInformerFactory) Extensions() extensions.Interface {
 	return extensions.New(f, f.namespace, f.tweakListOptions)
 }
 
-func (f *sharedInformerFactory) Flowcontrol() flowcontrol.Interface {
-	return flowcontrol.New(f, f.namespace, f.tweakListOptions)
-}
-
 func (f *sharedInformerFactory) Networking() networking.Interface {
 	return networking.New(f, f.namespace, f.tweakListOptions)
 }

informers/flowcontrol/interface.go

@@ -1,46 +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 informer-gen. DO NOT EDIT.
-
-package flowcontrol
-
-import (
-	v1alpha1 "k8s.io/client-go/informers/flowcontrol/v1alpha1"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1alpha1 provides access to shared informers for resources in V1alpha1.
-	V1alpha1() v1alpha1.Interface
-}
-
-type group struct {
-	factory          internalinterfaces.SharedInformerFactory
-	namespace        string
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
-	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
-}
-
-// V1alpha1 returns a new v1alpha1.Interface.
-func (g *group) V1alpha1() v1alpha1.Interface {
-	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
-}

informers/flowcontrol/v1alpha1/flowschema.go

@@ -1,88 +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 informer-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	time "time"
-
-	flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	watch "k8s.io/apimachinery/pkg/watch"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	kubernetes "k8s.io/client-go/kubernetes"
-	v1alpha1 "k8s.io/client-go/listers/flowcontrol/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// FlowSchemaInformer provides access to a shared informer and lister for
-// FlowSchemas.
-type FlowSchemaInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.FlowSchemaLister
-}
-
-type flowSchemaInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// NewFlowSchemaInformer constructs a new informer for FlowSchema type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewFlowSchemaInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredFlowSchemaInformer(client, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredFlowSchemaInformer constructs a new informer for FlowSchema type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewFilteredFlowSchemaInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.FlowcontrolV1alpha1().FlowSchemas().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.FlowcontrolV1alpha1().FlowSchemas().Watch(options)
-			},
-		},
-		&flowcontrolv1alpha1.FlowSchema{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *flowSchemaInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredFlowSchemaInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *flowSchemaInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&flowcontrolv1alpha1.FlowSchema{}, f.defaultInformer)
-}
-
-func (f *flowSchemaInformer) Lister() v1alpha1.FlowSchemaLister {
-	return v1alpha1.NewFlowSchemaLister(f.Informer().GetIndexer())
-}

informers/flowcontrol/v1alpha1/interface.go

@@ -1,52 +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 informer-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// FlowSchemas returns a FlowSchemaInformer.
-	FlowSchemas() FlowSchemaInformer
-	// PriorityLevelConfigurations returns a PriorityLevelConfigurationInformer.
-	PriorityLevelConfigurations() PriorityLevelConfigurationInformer
-}
-
-type version struct {
-	factory          internalinterfaces.SharedInformerFactory
-	namespace        string
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
-	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
-}
-
-// FlowSchemas returns a FlowSchemaInformer.
-func (v *version) FlowSchemas() FlowSchemaInformer {
-	return &flowSchemaInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
-}
-
-// PriorityLevelConfigurations returns a PriorityLevelConfigurationInformer.
-func (v *version) PriorityLevelConfigurations() PriorityLevelConfigurationInformer {
-	return &priorityLevelConfigurationInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
-}

informers/flowcontrol/v1alpha1/prioritylevelconfiguration.go

@@ -1,88 +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 informer-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	time "time"
-
-	flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	watch "k8s.io/apimachinery/pkg/watch"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	kubernetes "k8s.io/client-go/kubernetes"
-	v1alpha1 "k8s.io/client-go/listers/flowcontrol/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// PriorityLevelConfigurationInformer provides access to a shared informer and lister for
-// PriorityLevelConfigurations.
-type PriorityLevelConfigurationInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.PriorityLevelConfigurationLister
-}
-
-type priorityLevelConfigurationInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// NewPriorityLevelConfigurationInformer constructs a new informer for PriorityLevelConfiguration type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewPriorityLevelConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredPriorityLevelConfigurationInformer(client, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredPriorityLevelConfigurationInformer constructs a new informer for PriorityLevelConfiguration type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewFilteredPriorityLevelConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.FlowcontrolV1alpha1().PriorityLevelConfigurations().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.FlowcontrolV1alpha1().PriorityLevelConfigurations().Watch(options)
-			},
-		},
-		&flowcontrolv1alpha1.PriorityLevelConfiguration{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *priorityLevelConfigurationInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredPriorityLevelConfigurationInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *priorityLevelConfigurationInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&flowcontrolv1alpha1.PriorityLevelConfiguration{}, f.defaultInformer)
-}
-
-func (f *priorityLevelConfigurationInformer) Lister() v1alpha1.PriorityLevelConfigurationLister {
-	return v1alpha1.NewPriorityLevelConfigurationLister(f.Informer().GetIndexer())
-}

informers/generic.go

@@ -38,10 +38,8 @@ import (
 	coordinationv1beta1 "k8s.io/api/coordination/v1beta1"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1alpha1 "k8s.io/api/discovery/v1alpha1"
-	discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
 	eventsv1beta1 "k8s.io/api/events/v1beta1"
 	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
-	flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
 	networkingv1 "k8s.io/api/networking/v1"
 	networkingv1beta1 "k8s.io/api/networking/v1beta1"
 	nodev1alpha1 "k8s.io/api/node/v1alpha1"
@@ -209,10 +207,6 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 	case discoveryv1alpha1.SchemeGroupVersion.WithResource("endpointslices"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Discovery().V1alpha1().EndpointSlices().Informer()}, nil
 
-		// Group=discovery.k8s.io, Version=v1beta1
-	case discoveryv1beta1.SchemeGroupVersion.WithResource("endpointslices"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Discovery().V1beta1().EndpointSlices().Informer()}, nil
-
 		// Group=events.k8s.io, Version=v1beta1
 	case eventsv1beta1.SchemeGroupVersion.WithResource("events"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Events().V1beta1().Events().Informer()}, nil
@@ -231,12 +225,6 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 	case extensionsv1beta1.SchemeGroupVersion.WithResource("replicasets"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().ReplicaSets().Informer()}, nil
 
-		// Group=flowcontrol.apiserver.k8s.io, Version=v1alpha1
-	case flowcontrolv1alpha1.SchemeGroupVersion.WithResource("flowschemas"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Flowcontrol().V1alpha1().FlowSchemas().Informer()}, nil
-	case flowcontrolv1alpha1.SchemeGroupVersion.WithResource("prioritylevelconfigurations"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Flowcontrol().V1alpha1().PriorityLevelConfigurations().Informer()}, nil
-
 		// Group=networking.k8s.io, Version=v1
 	case networkingv1.SchemeGroupVersion.WithResource("networkpolicies"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1().NetworkPolicies().Informer()}, nil
@@ -306,8 +294,6 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Settings().V1alpha1().PodPresets().Informer()}, nil
 
 		// Group=storage.k8s.io, Version=v1
-	case storagev1.SchemeGroupVersion.WithResource("csinodes"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Storage().V1().CSINodes().Informer()}, nil
 	case storagev1.SchemeGroupVersion.WithResource("storageclasses"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Storage().V1().StorageClasses().Informer()}, nil
 	case storagev1.SchemeGroupVersion.WithResource("volumeattachments"):

informers/storage/v1/csinode.go

@@ -1,88 +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 informer-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	time "time"
-
-	storagev1 "k8s.io/api/storage/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	watch "k8s.io/apimachinery/pkg/watch"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	kubernetes "k8s.io/client-go/kubernetes"
-	v1 "k8s.io/client-go/listers/storage/v1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// CSINodeInformer provides access to a shared informer and lister for
-// CSINodes.
-type CSINodeInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.CSINodeLister
-}
-
-type cSINodeInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// NewCSINodeInformer constructs a new informer for CSINode type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewCSINodeInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredCSINodeInformer(client, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredCSINodeInformer constructs a new informer for CSINode type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewFilteredCSINodeInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.StorageV1().CSINodes().List(options)
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.StorageV1().CSINodes().Watch(options)
-			},
-		},
-		&storagev1.CSINode{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *cSINodeInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredCSINodeInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *cSINodeInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&storagev1.CSINode{}, f.defaultInformer)
-}
-
-func (f *cSINodeInformer) Lister() v1.CSINodeLister {
-	return v1.NewCSINodeLister(f.Informer().GetIndexer())
-}

informers/storage/v1/interface.go

@@ -24,8 +24,6 @@ import (
 
 // Interface provides access to all the informers in this group version.
 type Interface interface {
-	// CSINodes returns a CSINodeInformer.
-	CSINodes() CSINodeInformer
 	// StorageClasses returns a StorageClassInformer.
 	StorageClasses() StorageClassInformer
 	// VolumeAttachments returns a VolumeAttachmentInformer.
@@ -43,11 +41,6 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
 	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
 }
 
-// CSINodes returns a CSINodeInformer.
-func (v *version) CSINodes() CSINodeInformer {
-	return &cSINodeInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
-}
-
 // StorageClasses returns a StorageClassInformer.
 func (v *version) StorageClasses() StorageClassInformer {
 	return &storageClassInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}

kubernetes/clientset.go

@@ -43,10 +43,8 @@ import (
 	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"
 	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"
 	networkingv1 "k8s.io/client-go/kubernetes/typed/networking/v1"
 	networkingv1beta1 "k8s.io/client-go/kubernetes/typed/networking/v1beta1"
 	nodev1alpha1 "k8s.io/client-go/kubernetes/typed/node/v1alpha1"
@@ -89,10 +87,8 @@ type Interface interface {
 	CoordinationV1() coordinationv1.CoordinationV1Interface
 	CoreV1() corev1.CoreV1Interface
 	DiscoveryV1alpha1() discoveryv1alpha1.DiscoveryV1alpha1Interface
-	DiscoveryV1beta1() discoveryv1beta1.DiscoveryV1beta1Interface
 	EventsV1beta1() eventsv1beta1.EventsV1beta1Interface
 	ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface
-	FlowcontrolV1alpha1() flowcontrolv1alpha1.FlowcontrolV1alpha1Interface
 	NetworkingV1() networkingv1.NetworkingV1Interface
 	NetworkingV1beta1() networkingv1beta1.NetworkingV1beta1Interface
 	NodeV1alpha1() nodev1alpha1.NodeV1alpha1Interface
@@ -135,10 +131,8 @@ type Clientset struct {
 	coordinationV1               *coordinationv1.CoordinationV1Client
 	coreV1                       *corev1.CoreV1Client
 	discoveryV1alpha1            *discoveryv1alpha1.DiscoveryV1alpha1Client
-	discoveryV1beta1             *discoveryv1beta1.DiscoveryV1beta1Client
 	eventsV1beta1                *eventsv1beta1.EventsV1beta1Client
 	extensionsV1beta1            *extensionsv1beta1.ExtensionsV1beta1Client
-	flowcontrolV1alpha1          *flowcontrolv1alpha1.FlowcontrolV1alpha1Client
 	networkingV1                 *networkingv1.NetworkingV1Client
 	networkingV1beta1            *networkingv1beta1.NetworkingV1beta1Client
 	nodeV1alpha1                 *nodev1alpha1.NodeV1alpha1Client
@@ -261,11 +255,6 @@ func (c *Clientset) DiscoveryV1alpha1() discoveryv1alpha1.DiscoveryV1alpha1Inter
 	return c.discoveryV1alpha1
 }
 
-// DiscoveryV1beta1 retrieves the DiscoveryV1beta1Client
-func (c *Clientset) DiscoveryV1beta1() discoveryv1beta1.DiscoveryV1beta1Interface {
-	return c.discoveryV1beta1
-}
-
 // EventsV1beta1 retrieves the EventsV1beta1Client
 func (c *Clientset) EventsV1beta1() eventsv1beta1.EventsV1beta1Interface {
 	return c.eventsV1beta1
@@ -276,11 +265,6 @@ func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Inter
 	return c.extensionsV1beta1
 }
 
-// FlowcontrolV1alpha1 retrieves the FlowcontrolV1alpha1Client
-func (c *Clientset) FlowcontrolV1alpha1() flowcontrolv1alpha1.FlowcontrolV1alpha1Interface {
-	return c.flowcontrolV1alpha1
-}
-
 // NetworkingV1 retrieves the NetworkingV1Client
 func (c *Clientset) NetworkingV1() networkingv1.NetworkingV1Interface {
 	return c.networkingV1
@@ -461,10 +445,6 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
-	cs.discoveryV1beta1, err = discoveryv1beta1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
 	cs.eventsV1beta1, err = eventsv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
@@ -473,10 +453,6 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
-	cs.flowcontrolV1alpha1, err = flowcontrolv1alpha1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
 	cs.networkingV1, err = networkingv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
@@ -570,10 +546,8 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 	cs.coordinationV1 = coordinationv1.NewForConfigOrDie(c)
 	cs.coreV1 = corev1.NewForConfigOrDie(c)
 	cs.discoveryV1alpha1 = discoveryv1alpha1.NewForConfigOrDie(c)
-	cs.discoveryV1beta1 = discoveryv1beta1.NewForConfigOrDie(c)
 	cs.eventsV1beta1 = eventsv1beta1.NewForConfigOrDie(c)
 	cs.extensionsV1beta1 = extensionsv1beta1.NewForConfigOrDie(c)
-	cs.flowcontrolV1alpha1 = flowcontrolv1alpha1.NewForConfigOrDie(c)
 	cs.networkingV1 = networkingv1.NewForConfigOrDie(c)
 	cs.networkingV1beta1 = networkingv1beta1.NewForConfigOrDie(c)
 	cs.nodeV1alpha1 = nodev1alpha1.NewForConfigOrDie(c)
@@ -618,10 +592,8 @@ func New(c rest.Interface) *Clientset {
 	cs.coordinationV1 = coordinationv1.New(c)
 	cs.coreV1 = corev1.New(c)
 	cs.discoveryV1alpha1 = discoveryv1alpha1.New(c)
-	cs.discoveryV1beta1 = discoveryv1beta1.New(c)
 	cs.eventsV1beta1 = eventsv1beta1.New(c)
 	cs.extensionsV1beta1 = extensionsv1beta1.New(c)
-	cs.flowcontrolV1alpha1 = flowcontrolv1alpha1.New(c)
 	cs.networkingV1 = networkingv1.New(c)
 	cs.networkingV1beta1 = networkingv1beta1.New(c)
 	cs.nodeV1alpha1 = nodev1alpha1.New(c)

kubernetes/fake/clientset_generated.go

@@ -66,14 +66,10 @@ import (
 	fakecorev1 "k8s.io/client-go/kubernetes/typed/core/v1/fake"
 	discoveryv1alpha1 "k8s.io/client-go/kubernetes/typed/discovery/v1alpha1"
 	fakediscoveryv1alpha1 "k8s.io/client-go/kubernetes/typed/discovery/v1alpha1/fake"
-	discoveryv1beta1 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1"
-	fakediscoveryv1beta1 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1/fake"
 	eventsv1beta1 "k8s.io/client-go/kubernetes/typed/events/v1beta1"
 	fakeeventsv1beta1 "k8s.io/client-go/kubernetes/typed/events/v1beta1/fake"
 	extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
 	fakeextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1/fake"
-	flowcontrolv1alpha1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1"
-	fakeflowcontrolv1alpha1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1/fake"
 	networkingv1 "k8s.io/client-go/kubernetes/typed/networking/v1"
 	fakenetworkingv1 "k8s.io/client-go/kubernetes/typed/networking/v1/fake"
 	networkingv1beta1 "k8s.io/client-go/kubernetes/typed/networking/v1beta1"
@@ -259,11 +255,6 @@ func (c *Clientset) DiscoveryV1alpha1() discoveryv1alpha1.DiscoveryV1alpha1Inter
 	return &fakediscoveryv1alpha1.FakeDiscoveryV1alpha1{Fake: &c.Fake}
 }
 
-// DiscoveryV1beta1 retrieves the DiscoveryV1beta1Client
-func (c *Clientset) DiscoveryV1beta1() discoveryv1beta1.DiscoveryV1beta1Interface {
-	return &fakediscoveryv1beta1.FakeDiscoveryV1beta1{Fake: &c.Fake}
-}
-
 // EventsV1beta1 retrieves the EventsV1beta1Client
 func (c *Clientset) EventsV1beta1() eventsv1beta1.EventsV1beta1Interface {
 	return &fakeeventsv1beta1.FakeEventsV1beta1{Fake: &c.Fake}
@@ -274,11 +265,6 @@ func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Inter
 	return &fakeextensionsv1beta1.FakeExtensionsV1beta1{Fake: &c.Fake}
 }
 
-// FlowcontrolV1alpha1 retrieves the FlowcontrolV1alpha1Client
-func (c *Clientset) FlowcontrolV1alpha1() flowcontrolv1alpha1.FlowcontrolV1alpha1Interface {
-	return &fakeflowcontrolv1alpha1.FakeFlowcontrolV1alpha1{Fake: &c.Fake}
-}
-
 // NetworkingV1 retrieves the NetworkingV1Client
 func (c *Clientset) NetworkingV1() networkingv1.NetworkingV1Interface {
 	return &fakenetworkingv1.FakeNetworkingV1{Fake: &c.Fake}

kubernetes/fake/register.go

@@ -40,10 +40,8 @@ import (
 	coordinationv1beta1 "k8s.io/api/coordination/v1beta1"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1alpha1 "k8s.io/api/discovery/v1alpha1"
-	discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
 	eventsv1beta1 "k8s.io/api/events/v1beta1"
 	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
-	flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
 	networkingv1 "k8s.io/api/networking/v1"
 	networkingv1beta1 "k8s.io/api/networking/v1beta1"
 	nodev1alpha1 "k8s.io/api/node/v1alpha1"
@@ -91,10 +89,8 @@ var localSchemeBuilder = runtime.SchemeBuilder{
 	coordinationv1.AddToScheme,
 	corev1.AddToScheme,
 	discoveryv1alpha1.AddToScheme,
-	discoveryv1beta1.AddToScheme,
 	eventsv1beta1.AddToScheme,
 	extensionsv1beta1.AddToScheme,
-	flowcontrolv1alpha1.AddToScheme,
 	networkingv1.AddToScheme,
 	networkingv1beta1.AddToScheme,
 	nodev1alpha1.AddToScheme,

kubernetes/scheme/register.go

@@ -40,10 +40,8 @@ import (
 	coordinationv1beta1 "k8s.io/api/coordination/v1beta1"
 	corev1 "k8s.io/api/core/v1"
 	discoveryv1alpha1 "k8s.io/api/discovery/v1alpha1"
-	discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
 	eventsv1beta1 "k8s.io/api/events/v1beta1"
 	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
-	flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
 	networkingv1 "k8s.io/api/networking/v1"
 	networkingv1beta1 "k8s.io/api/networking/v1beta1"
 	nodev1alpha1 "k8s.io/api/node/v1alpha1"
@@ -91,10 +89,8 @@ var localSchemeBuilder = runtime.SchemeBuilder{
 	coordinationv1.AddToScheme,
 	corev1.AddToScheme,
 	discoveryv1alpha1.AddToScheme,
-	discoveryv1beta1.AddToScheme,
 	eventsv1beta1.AddToScheme,
 	extensionsv1beta1.AddToScheme,
-	flowcontrolv1alpha1.AddToScheme,
 	networkingv1.AddToScheme,
 	networkingv1beta1.AddToScheme,
 	nodev1alpha1.AddToScheme,

kubernetes/typed/authentication/v1/fake/fake_tokenreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authenticationapi "k8s.io/api/authentication/v1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeTokenReviews) Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
-	return c.CreateContext(context.Background(), tokenReview)
-}
-
-func (c *FakeTokenReviews) CreateContext(ctx context.Context, tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authenticationapi.SchemeGroupVersion.WithResource("tokenreviews"), tokenReview), &authenticationapi.TokenReview{})
 	return obj.(*authenticationapi.TokenReview), err
 }

kubernetes/typed/authentication/v1/tokenreview_expansion.go

@@ -17,24 +17,16 @@ limitations under the License.
 package v1
 
 import (
-	"context"
-
 	authenticationapi "k8s.io/api/authentication/v1"
 )
 
 type TokenReviewExpansion interface {
 	Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error)
-	CreateContext(ctx context.Context, tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error)
 }
 
 func (c *tokenReviews) Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
-	return c.CreateContext(context.Background(), tokenReview)
-}
-
-func (c *tokenReviews) CreateContext(ctx context.Context, tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
 	result = &authenticationapi.TokenReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Resource("tokenreviews").
 		Body(tokenReview).
 		Do().

kubernetes/typed/authentication/v1beta1/fake/fake_tokenreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authenticationapi "k8s.io/api/authentication/v1beta1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeTokenReviews) Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
-	return c.CreateContext(context.Background(), tokenReview)
-}
-
-func (c *FakeTokenReviews) CreateContext(ctx context.Context, tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authenticationapi.SchemeGroupVersion.WithResource("tokenreviews"), tokenReview), &authenticationapi.TokenReview{})
 	return obj.(*authenticationapi.TokenReview), err
 }

kubernetes/typed/authentication/v1beta1/tokenreview_expansion.go

@@ -17,24 +17,16 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
-
 	authenticationapi "k8s.io/api/authentication/v1beta1"
 )
 
 type TokenReviewExpansion interface {
 	Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error)
-	CreateContext(ctx context.Context, tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error)
 }
 
 func (c *tokenReviews) Create(tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
-	return c.CreateContext(context.Background(), tokenReview)
-}
-
-func (c *tokenReviews) CreateContext(ctx context.Context, tokenReview *authenticationapi.TokenReview) (result *authenticationapi.TokenReview, err error) {
 	result = &authenticationapi.TokenReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Resource("tokenreviews").
 		Body(tokenReview).
 		Do().

kubernetes/typed/authorization/v1/fake/fake_localsubjectaccessreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeLocalSubjectAccessReviews) Create(sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *FakeLocalSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewCreateAction(authorizationapi.SchemeGroupVersion.WithResource("localsubjectaccessreviews"), c.ns, sar), &authorizationapi.SubjectAccessReview{})
 	return obj.(*authorizationapi.LocalSubjectAccessReview), err
 }

kubernetes/typed/authorization/v1/fake/fake_selfsubjectaccessreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeSelfSubjectAccessReviews) Create(sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *FakeSelfSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("selfsubjectaccessreviews"), sar), &authorizationapi.SelfSubjectAccessReview{})
 	return obj.(*authorizationapi.SelfSubjectAccessReview), err
 }

kubernetes/typed/authorization/v1/fake/fake_selfsubjectrulesreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeSelfSubjectRulesReviews) Create(srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error) {
-	return c.CreateContext(context.Background(), srr)
-}
-
-func (c *FakeSelfSubjectRulesReviews) CreateContext(ctx context.Context, srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("selfsubjectrulesreviews"), srr), &authorizationapi.SelfSubjectRulesReview{})
 	return obj.(*authorizationapi.SelfSubjectRulesReview), err
 }

kubernetes/typed/authorization/v1/fake/fake_subjectaccessreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeSubjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *FakeSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("subjectaccessreviews"), sar), &authorizationapi.SubjectAccessReview{})
 	if obj == nil {
 		return nil, err

kubernetes/typed/authorization/v1/localsubjectaccessreview_expansion.go

@@ -17,24 +17,16 @@ limitations under the License.
 package v1
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1"
 )
 
 type LocalSubjectAccessReviewExpansion interface {
 	Create(sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error)
-	CreateContext(ctx context.Context, sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error)
 }
 
 func (c *localSubjectAccessReviews) Create(sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *localSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error) {
 	result = &authorizationapi.LocalSubjectAccessReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Namespace(c.ns).
 		Resource("localsubjectaccessreviews").
 		Body(sar).

kubernetes/typed/authorization/v1/selfsubjectaccessreview_expansion.go

@@ -17,24 +17,16 @@ limitations under the License.
 package v1
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1"
 )
 
 type SelfSubjectAccessReviewExpansion interface {
 	Create(sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error)
-	CreateContext(ctx context.Context, sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error)
 }
 
 func (c *selfSubjectAccessReviews) Create(sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *selfSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error) {
 	result = &authorizationapi.SelfSubjectAccessReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Resource("selfsubjectaccessreviews").
 		Body(sar).
 		Do().

kubernetes/typed/authorization/v1/selfsubjectrulesreview_expansion.go

@@ -17,24 +17,16 @@ limitations under the License.
 package v1
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1"
 )
 
 type SelfSubjectRulesReviewExpansion interface {
 	Create(srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error)
-	CreateContext(ctx context.Context, srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error)
 }
 
 func (c *selfSubjectRulesReviews) Create(srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error) {
-	return c.CreateContext(context.Background(), srr)
-}
-
-func (c *selfSubjectRulesReviews) CreateContext(ctx context.Context, srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error) {
 	result = &authorizationapi.SelfSubjectRulesReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Resource("selfsubjectrulesreviews").
 		Body(srr).
 		Do().

kubernetes/typed/authorization/v1/subjectaccessreview_expansion.go

@@ -17,25 +17,17 @@ limitations under the License.
 package v1
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1"
 )
 
 // The SubjectAccessReviewExpansion interface allows manually adding extra methods to the AuthorizationInterface.
 type SubjectAccessReviewExpansion interface {
 	Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error)
-	CreateContext(ctx context.Context, sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error)
 }
 
 func (c *subjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *subjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
 	result = &authorizationapi.SubjectAccessReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Resource("subjectaccessreviews").
 		Body(sar).
 		Do().

kubernetes/typed/authorization/v1beta1/fake/fake_localsubjectaccessreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1beta1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeLocalSubjectAccessReviews) Create(sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *FakeLocalSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewCreateAction(authorizationapi.SchemeGroupVersion.WithResource("localsubjectaccessreviews"), c.ns, sar), &authorizationapi.SubjectAccessReview{})
 	return obj.(*authorizationapi.LocalSubjectAccessReview), err
 }

kubernetes/typed/authorization/v1beta1/fake/fake_selfsubjectaccessreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1beta1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeSelfSubjectAccessReviews) Create(sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *FakeSelfSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("selfsubjectaccessreviews"), sar), &authorizationapi.SelfSubjectAccessReview{})
 	return obj.(*authorizationapi.SelfSubjectAccessReview), err
 }

kubernetes/typed/authorization/v1beta1/fake/fake_selfsubjectrulesreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1beta1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeSelfSubjectRulesReviews) Create(srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error) {
-	return c.CreateContext(context.Background(), srr)
-}
-
-func (c *FakeSelfSubjectRulesReviews) CreateContext(ctx context.Context, srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("selfsubjectrulesreviews"), srr), &authorizationapi.SelfSubjectRulesReview{})
 	return obj.(*authorizationapi.SelfSubjectRulesReview), err
 }

kubernetes/typed/authorization/v1beta1/fake/fake_subjectaccessreview_expansion.go

@@ -17,17 +17,11 @@ limitations under the License.
 package fake
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1beta1"
 	core "k8s.io/client-go/testing"
 )
 
 func (c *FakeSubjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *FakeSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
 	obj, err := c.Fake.Invokes(core.NewRootCreateAction(authorizationapi.SchemeGroupVersion.WithResource("subjectaccessreviews"), sar), &authorizationapi.SubjectAccessReview{})
 	return obj.(*authorizationapi.SubjectAccessReview), err
 }

kubernetes/typed/authorization/v1beta1/localsubjectaccessreview_expansion.go

@@ -17,24 +17,16 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1beta1"
 )
 
 type LocalSubjectAccessReviewExpansion interface {
 	Create(sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error)
-	CreateContext(ctx context.Context, sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error)
 }
 
 func (c *localSubjectAccessReviews) Create(sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *localSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.LocalSubjectAccessReview) (result *authorizationapi.LocalSubjectAccessReview, err error) {
 	result = &authorizationapi.LocalSubjectAccessReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Namespace(c.ns).
 		Resource("localsubjectaccessreviews").
 		Body(sar).

kubernetes/typed/authorization/v1beta1/selfsubjectaccessreview_expansion.go

@@ -17,24 +17,16 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1beta1"
 )
 
 type SelfSubjectAccessReviewExpansion interface {
 	Create(sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error)
-	CreateContext(ctx context.Context, sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error)
 }
 
 func (c *selfSubjectAccessReviews) Create(sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *selfSubjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.SelfSubjectAccessReview) (result *authorizationapi.SelfSubjectAccessReview, err error) {
 	result = &authorizationapi.SelfSubjectAccessReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Resource("selfsubjectaccessreviews").
 		Body(sar).
 		Do().

kubernetes/typed/authorization/v1beta1/selfsubjectrulesreview_expansion.go

@@ -17,24 +17,16 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1beta1"
 )
 
 type SelfSubjectRulesReviewExpansion interface {
 	Create(srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error)
-	CreateContext(ctx context.Context, srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error)
 }
 
 func (c *selfSubjectRulesReviews) Create(srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error) {
-	return c.CreateContext(context.Background(), srr)
-}
-
-func (c *selfSubjectRulesReviews) CreateContext(ctx context.Context, srr *authorizationapi.SelfSubjectRulesReview) (result *authorizationapi.SelfSubjectRulesReview, err error) {
 	result = &authorizationapi.SelfSubjectRulesReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Resource("selfsubjectrulesreviews").
 		Body(srr).
 		Do().

kubernetes/typed/authorization/v1beta1/subjectaccessreview_expansion.go

@@ -17,25 +17,17 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
-
 	authorizationapi "k8s.io/api/authorization/v1beta1"
 )
 
 // The SubjectAccessReviewExpansion interface allows manually adding extra methods to the AuthorizationInterface.
 type SubjectAccessReviewExpansion interface {
 	Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error)
-	CreateContext(ctx context.Context, sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error)
 }
 
 func (c *subjectAccessReviews) Create(sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
-	return c.CreateContext(context.Background(), sar)
-}
-
-func (c *subjectAccessReviews) CreateContext(ctx context.Context, sar *authorizationapi.SubjectAccessReview) (result *authorizationapi.SubjectAccessReview, err error) {
 	result = &authorizationapi.SubjectAccessReview{}
 	err = c.client.Post().
-		Context(ctx).
 		Resource("subjectaccessreviews").
 		Body(sar).
 		Do().

kubernetes/typed/core/v1/event_expansion.go

@@ -104,17 +104,17 @@ func (e *events) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.Ev
 	if err != nil {
 		return nil, err
 	}
-	if len(e.ns) > 0 && ref.Namespace != e.ns {
+	if e.ns != "" && ref.Namespace != e.ns {
 		return nil, fmt.Errorf("won't be able to find any events of namespace '%v' in namespace '%v'", ref.Namespace, e.ns)
 	}
 	stringRefKind := string(ref.Kind)
 	var refKind *string
-	if len(stringRefKind) > 0 {
+	if stringRefKind != "" {
 		refKind = &stringRefKind
 	}
 	stringRefUID := string(ref.UID)
 	var refUID *string
-	if len(stringRefUID) > 0 {
+	if stringRefUID != "" {
 		refUID = &stringRefUID
 	}
 	fieldSelector := e.GetFieldSelector(&ref.Name, &ref.Namespace, refKind, refUID)
@@ -124,9 +124,10 @@ func (e *events) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.Ev
 // Returns the appropriate field selector based on the API version being used to communicate with the server.
 // The returned field selector can be used with List and Watch to filter desired events.
 func (e *events) GetFieldSelector(involvedObjectName, involvedObjectNamespace, involvedObjectKind, involvedObjectUID *string) fields.Selector {
+	apiVersion := e.client.APIVersion().String()
 	field := fields.Set{}
 	if involvedObjectName != nil {
-		field["involvedObject.name"] = *involvedObjectName
+		field[GetInvolvedObjectNameFieldLabel(apiVersion)] = *involvedObjectName
 	}
 	if involvedObjectNamespace != nil {
 		field["involvedObject.namespace"] = *involvedObjectNamespace
@@ -141,7 +142,6 @@ func (e *events) GetFieldSelector(involvedObjectName, involvedObjectNamespace, i
 }
 
 // Returns the appropriate field label to use for name of the involved object as per the given API version.
-// DEPRECATED: please use "involvedObject.name" inline.
 func GetInvolvedObjectNameFieldLabel(version string) string {
 	return "involvedObject.name"
 }

kubernetes/typed/discovery/v1beta1/discovery_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 v1beta1
-
-import (
-	v1beta1 "k8s.io/api/discovery/v1beta1"
-	"k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-type DiscoveryV1beta1Interface interface {
-	RESTClient() rest.Interface
-	EndpointSlicesGetter
-}
-
-// DiscoveryV1beta1Client is used to interact with features provided by the discovery.k8s.io group.
-type DiscoveryV1beta1Client struct {
-	restClient rest.Interface
-}
-
-func (c *DiscoveryV1beta1Client) EndpointSlices(namespace string) EndpointSliceInterface {
-	return newEndpointSlices(c, namespace)
-}
-
-// NewForConfig creates a new DiscoveryV1beta1Client for the given config.
-func NewForConfig(c *rest.Config) (*DiscoveryV1beta1Client, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &DiscoveryV1beta1Client{client}, nil
-}
-
-// NewForConfigOrDie creates a new DiscoveryV1beta1Client for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *DiscoveryV1beta1Client {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new DiscoveryV1beta1Client for the given RESTClient.
-func New(c rest.Interface) *DiscoveryV1beta1Client {
-	return &DiscoveryV1beta1Client{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	gv := v1beta1.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 *DiscoveryV1beta1Client) RESTClient() rest.Interface {
-	if c == nil {
-		return nil
-	}
-	return c.restClient
-}

kubernetes/typed/discovery/v1beta1/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 v1beta1

kubernetes/typed/discovery/v1beta1/endpointslice.go

@@ -1,174 +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 v1beta1
-
-import (
-	"time"
-
-	v1beta1 "k8s.io/api/discovery/v1beta1"
-	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"
-)
-
-// EndpointSlicesGetter has a method to return a EndpointSliceInterface.
-// A group's client should implement this interface.
-type EndpointSlicesGetter interface {
-	EndpointSlices(namespace string) EndpointSliceInterface
-}
-
-// EndpointSliceInterface has methods to work with EndpointSlice resources.
-type EndpointSliceInterface interface {
-	Create(*v1beta1.EndpointSlice) (*v1beta1.EndpointSlice, error)
-	Update(*v1beta1.EndpointSlice) (*v1beta1.EndpointSlice, error)
-	Delete(name string, options *v1.DeleteOptions) error
-	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
-	Get(name string, options v1.GetOptions) (*v1beta1.EndpointSlice, error)
-	List(opts v1.ListOptions) (*v1beta1.EndpointSliceList, error)
-	Watch(opts v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.EndpointSlice, err error)
-	EndpointSliceExpansion
-}
-
-// endpointSlices implements EndpointSliceInterface
-type endpointSlices struct {
-	client rest.Interface
-	ns     string
-}
-
-// newEndpointSlices returns a EndpointSlices
-func newEndpointSlices(c *DiscoveryV1beta1Client, namespace string) *endpointSlices {
-	return &endpointSlices{
-		client: c.RESTClient(),
-		ns:     namespace,
-	}
-}
-
-// Get takes name of the endpointSlice, and returns the corresponding endpointSlice object, and an error if there is any.
-func (c *endpointSlices) Get(name string, options v1.GetOptions) (result *v1beta1.EndpointSlice, err error) {
-	result = &v1beta1.EndpointSlice{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("endpointslices").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do().
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of EndpointSlices that match those selectors.
-func (c *endpointSlices) List(opts v1.ListOptions) (result *v1beta1.EndpointSliceList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1beta1.EndpointSliceList{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("endpointslices").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do().
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested endpointSlices.
-func (c *endpointSlices) Watch(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("endpointslices").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch()
-}
-
-// Create takes the representation of a endpointSlice and creates it.  Returns the server's representation of the endpointSlice, and an error, if there is any.
-func (c *endpointSlices) Create(endpointSlice *v1beta1.EndpointSlice) (result *v1beta1.EndpointSlice, err error) {
-	result = &v1beta1.EndpointSlice{}
-	err = c.client.Post().
-		Namespace(c.ns).
-		Resource("endpointslices").
-		Body(endpointSlice).
-		Do().
-		Into(result)
-	return
-}
-
-// Update takes the representation of a endpointSlice and updates it. Returns the server's representation of the endpointSlice, and an error, if there is any.
-func (c *endpointSlices) Update(endpointSlice *v1beta1.EndpointSlice) (result *v1beta1.EndpointSlice, err error) {
-	result = &v1beta1.EndpointSlice{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("endpointslices").
-		Name(endpointSlice.Name).
-		Body(endpointSlice).
-		Do().
-		Into(result)
-	return
-}
-
-// Delete takes name of the endpointSlice and deletes it. Returns an error if one occurs.
-func (c *endpointSlices) Delete(name string, options *v1.DeleteOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("endpointslices").
-		Name(name).
-		Body(options).
-		Do().
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *endpointSlices) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	var timeout time.Duration
-	if listOptions.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("endpointslices").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(options).
-		Do().
-		Error()
-}
-
-// Patch applies the patch and returns the patched endpointSlice.
-func (c *endpointSlices) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.EndpointSlice, err error) {
-	result = &v1beta1.EndpointSlice{}
-	err = c.client.Patch(pt).
-		Namespace(c.ns).
-		Resource("endpointslices").
-		SubResource(subresources...).
-		Name(name).
-		Body(data).
-		Do().
-		Into(result)
-	return
-}

kubernetes/typed/discovery/v1beta1/fake/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.
-
-// Package fake has the automatically generated clients.
-package fake

kubernetes/typed/discovery/v1beta1/fake/fake_discovery_client.go

@@ -1,40 +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 fake
-
-import (
-	v1beta1 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
-)
-
-type FakeDiscoveryV1beta1 struct {
-	*testing.Fake
-}
-
-func (c *FakeDiscoveryV1beta1) EndpointSlices(namespace string) v1beta1.EndpointSliceInterface {
-	return &FakeEndpointSlices{c, namespace}
-}
-
-// RESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *FakeDiscoveryV1beta1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
-}

kubernetes/typed/discovery/v1beta1/fake/fake_endpointslice.go

@@ -1,128 +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 fake
-
-import (
-	v1beta1 "k8s.io/api/discovery/v1beta1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	testing "k8s.io/client-go/testing"
-)
-
-// FakeEndpointSlices implements EndpointSliceInterface
-type FakeEndpointSlices struct {
-	Fake *FakeDiscoveryV1beta1
-	ns   string
-}
-
-var endpointslicesResource = schema.GroupVersionResource{Group: "discovery.k8s.io", Version: "v1beta1", Resource: "endpointslices"}
-
-var endpointslicesKind = schema.GroupVersionKind{Group: "discovery.k8s.io", Version: "v1beta1", Kind: "EndpointSlice"}
-
-// Get takes name of the endpointSlice, and returns the corresponding endpointSlice object, and an error if there is any.
-func (c *FakeEndpointSlices) Get(name string, options v1.GetOptions) (result *v1beta1.EndpointSlice, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewGetAction(endpointslicesResource, c.ns, name), &v1beta1.EndpointSlice{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1beta1.EndpointSlice), err
-}
-
-// List takes label and field selectors, and returns the list of EndpointSlices that match those selectors.
-func (c *FakeEndpointSlices) List(opts v1.ListOptions) (result *v1beta1.EndpointSliceList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewListAction(endpointslicesResource, endpointslicesKind, c.ns, opts), &v1beta1.EndpointSliceList{})
-
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1beta1.EndpointSliceList{ListMeta: obj.(*v1beta1.EndpointSliceList).ListMeta}
-	for _, item := range obj.(*v1beta1.EndpointSliceList).Items {
-		if label.Matches(labels.Set(item.Labels)) {
-			list.Items = append(list.Items, item)
-		}
-	}
-	return list, err
-}
-
-// Watch returns a watch.Interface that watches the requested endpointSlices.
-func (c *FakeEndpointSlices) Watch(opts v1.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewWatchAction(endpointslicesResource, c.ns, opts))
-
-}
-
-// Create takes the representation of a endpointSlice and creates it.  Returns the server's representation of the endpointSlice, and an error, if there is any.
-func (c *FakeEndpointSlices) Create(endpointSlice *v1beta1.EndpointSlice) (result *v1beta1.EndpointSlice, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewCreateAction(endpointslicesResource, c.ns, endpointSlice), &v1beta1.EndpointSlice{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1beta1.EndpointSlice), err
-}
-
-// Update takes the representation of a endpointSlice and updates it. Returns the server's representation of the endpointSlice, and an error, if there is any.
-func (c *FakeEndpointSlices) Update(endpointSlice *v1beta1.EndpointSlice) (result *v1beta1.EndpointSlice, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateAction(endpointslicesResource, c.ns, endpointSlice), &v1beta1.EndpointSlice{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1beta1.EndpointSlice), err
-}
-
-// Delete takes name of the endpointSlice and deletes it. Returns an error if one occurs.
-func (c *FakeEndpointSlices) Delete(name string, options *v1.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewDeleteAction(endpointslicesResource, c.ns, name), &v1beta1.EndpointSlice{})
-
-	return err
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *FakeEndpointSlices) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	action := testing.NewDeleteCollectionAction(endpointslicesResource, c.ns, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1beta1.EndpointSliceList{})
-	return err
-}
-
-// Patch applies the patch and returns the patched endpointSlice.
-func (c *FakeEndpointSlices) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.EndpointSlice, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(endpointslicesResource, c.ns, name, pt, data, subresources...), &v1beta1.EndpointSlice{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1beta1.EndpointSlice), err
-}

kubernetes/typed/discovery/v1beta1/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 v1beta1
-
-type EndpointSliceExpansion interface{}

kubernetes/typed/flowcontrol/v1alpha1/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 v1alpha1

kubernetes/typed/flowcontrol/v1alpha1/fake/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.
-
-// Package fake has the automatically generated clients.
-package fake

kubernetes/typed/flowcontrol/v1alpha1/fake/fake_flowcontrol_client.go

@@ -1,44 +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 fake
-
-import (
-	v1alpha1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
-)
-
-type FakeFlowcontrolV1alpha1 struct {
-	*testing.Fake
-}
-
-func (c *FakeFlowcontrolV1alpha1) FlowSchemas() v1alpha1.FlowSchemaInterface {
-	return &FakeFlowSchemas{c}
-}
-
-func (c *FakeFlowcontrolV1alpha1) PriorityLevelConfigurations() v1alpha1.PriorityLevelConfigurationInterface {
-	return &FakePriorityLevelConfigurations{c}
-}
-
-// RESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *FakeFlowcontrolV1alpha1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
-}

kubernetes/typed/flowcontrol/v1alpha1/fake/fake_flowschema.go

@@ -1,131 +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 fake
-
-import (
-	v1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	testing "k8s.io/client-go/testing"
-)
-
-// FakeFlowSchemas implements FlowSchemaInterface
-type FakeFlowSchemas struct {
-	Fake *FakeFlowcontrolV1alpha1
-}
-
-var flowschemasResource = schema.GroupVersionResource{Group: "flowcontrol.apiserver.k8s.io", Version: "v1alpha1", Resource: "flowschemas"}
-
-var flowschemasKind = schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1alpha1", Kind: "FlowSchema"}
-
-// Get takes name of the flowSchema, and returns the corresponding flowSchema object, and an error if there is any.
-func (c *FakeFlowSchemas) Get(name string, options v1.GetOptions) (result *v1alpha1.FlowSchema, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootGetAction(flowschemasResource, name), &v1alpha1.FlowSchema{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.FlowSchema), err
-}
-
-// List takes label and field selectors, and returns the list of FlowSchemas that match those selectors.
-func (c *FakeFlowSchemas) List(opts v1.ListOptions) (result *v1alpha1.FlowSchemaList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootListAction(flowschemasResource, flowschemasKind, opts), &v1alpha1.FlowSchemaList{})
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1alpha1.FlowSchemaList{ListMeta: obj.(*v1alpha1.FlowSchemaList).ListMeta}
-	for _, item := range obj.(*v1alpha1.FlowSchemaList).Items {
-		if label.Matches(labels.Set(item.Labels)) {
-			list.Items = append(list.Items, item)
-		}
-	}
-	return list, err
-}
-
-// Watch returns a watch.Interface that watches the requested flowSchemas.
-func (c *FakeFlowSchemas) Watch(opts v1.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewRootWatchAction(flowschemasResource, opts))
-}
-
-// Create takes the representation of a flowSchema and creates it.  Returns the server's representation of the flowSchema, and an error, if there is any.
-func (c *FakeFlowSchemas) Create(flowSchema *v1alpha1.FlowSchema) (result *v1alpha1.FlowSchema, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootCreateAction(flowschemasResource, flowSchema), &v1alpha1.FlowSchema{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.FlowSchema), err
-}
-
-// Update takes the representation of a flowSchema and updates it. Returns the server's representation of the flowSchema, and an error, if there is any.
-func (c *FakeFlowSchemas) Update(flowSchema *v1alpha1.FlowSchema) (result *v1alpha1.FlowSchema, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateAction(flowschemasResource, flowSchema), &v1alpha1.FlowSchema{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.FlowSchema), err
-}
-
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
-func (c *FakeFlowSchemas) UpdateStatus(flowSchema *v1alpha1.FlowSchema) (*v1alpha1.FlowSchema, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateSubresourceAction(flowschemasResource, "status", flowSchema), &v1alpha1.FlowSchema{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.FlowSchema), err
-}
-
-// Delete takes name of the flowSchema and deletes it. Returns an error if one occurs.
-func (c *FakeFlowSchemas) Delete(name string, options *v1.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewRootDeleteAction(flowschemasResource, name), &v1alpha1.FlowSchema{})
-	return err
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *FakeFlowSchemas) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	action := testing.NewRootDeleteCollectionAction(flowschemasResource, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1alpha1.FlowSchemaList{})
-	return err
-}
-
-// Patch applies the patch and returns the patched flowSchema.
-func (c *FakeFlowSchemas) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.FlowSchema, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(flowschemasResource, name, pt, data, subresources...), &v1alpha1.FlowSchema{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.FlowSchema), err
-}

kubernetes/typed/flowcontrol/v1alpha1/fake/fake_prioritylevelconfiguration.go

@@ -1,131 +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 fake
-
-import (
-	v1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	testing "k8s.io/client-go/testing"
-)
-
-// FakePriorityLevelConfigurations implements PriorityLevelConfigurationInterface
-type FakePriorityLevelConfigurations struct {
-	Fake *FakeFlowcontrolV1alpha1
-}
-
-var prioritylevelconfigurationsResource = schema.GroupVersionResource{Group: "flowcontrol.apiserver.k8s.io", Version: "v1alpha1", Resource: "prioritylevelconfigurations"}
-
-var prioritylevelconfigurationsKind = schema.GroupVersionKind{Group: "flowcontrol.apiserver.k8s.io", Version: "v1alpha1", Kind: "PriorityLevelConfiguration"}
-
-// Get takes name of the priorityLevelConfiguration, and returns the corresponding priorityLevelConfiguration object, and an error if there is any.
-func (c *FakePriorityLevelConfigurations) Get(name string, options v1.GetOptions) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootGetAction(prioritylevelconfigurationsResource, name), &v1alpha1.PriorityLevelConfiguration{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PriorityLevelConfiguration), err
-}
-
-// List takes label and field selectors, and returns the list of PriorityLevelConfigurations that match those selectors.
-func (c *FakePriorityLevelConfigurations) List(opts v1.ListOptions) (result *v1alpha1.PriorityLevelConfigurationList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootListAction(prioritylevelconfigurationsResource, prioritylevelconfigurationsKind, opts), &v1alpha1.PriorityLevelConfigurationList{})
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1alpha1.PriorityLevelConfigurationList{ListMeta: obj.(*v1alpha1.PriorityLevelConfigurationList).ListMeta}
-	for _, item := range obj.(*v1alpha1.PriorityLevelConfigurationList).Items {
-		if label.Matches(labels.Set(item.Labels)) {
-			list.Items = append(list.Items, item)
-		}
-	}
-	return list, err
-}
-
-// Watch returns a watch.Interface that watches the requested priorityLevelConfigurations.
-func (c *FakePriorityLevelConfigurations) Watch(opts v1.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewRootWatchAction(prioritylevelconfigurationsResource, opts))
-}
-
-// Create takes the representation of a priorityLevelConfiguration and creates it.  Returns the server's representation of the priorityLevelConfiguration, and an error, if there is any.
-func (c *FakePriorityLevelConfigurations) Create(priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootCreateAction(prioritylevelconfigurationsResource, priorityLevelConfiguration), &v1alpha1.PriorityLevelConfiguration{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PriorityLevelConfiguration), err
-}
-
-// Update takes the representation of a priorityLevelConfiguration and updates it. Returns the server's representation of the priorityLevelConfiguration, and an error, if there is any.
-func (c *FakePriorityLevelConfigurations) Update(priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateAction(prioritylevelconfigurationsResource, priorityLevelConfiguration), &v1alpha1.PriorityLevelConfiguration{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PriorityLevelConfiguration), err
-}
-
-// UpdateStatus was generated because the type contains a Status member.
-// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
-func (c *FakePriorityLevelConfigurations) UpdateStatus(priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration) (*v1alpha1.PriorityLevelConfiguration, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateSubresourceAction(prioritylevelconfigurationsResource, "status", priorityLevelConfiguration), &v1alpha1.PriorityLevelConfiguration{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PriorityLevelConfiguration), err
-}
-
-// Delete takes name of the priorityLevelConfiguration and deletes it. Returns an error if one occurs.
-func (c *FakePriorityLevelConfigurations) Delete(name string, options *v1.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewRootDeleteAction(prioritylevelconfigurationsResource, name), &v1alpha1.PriorityLevelConfiguration{})
-	return err
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *FakePriorityLevelConfigurations) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	action := testing.NewRootDeleteCollectionAction(prioritylevelconfigurationsResource, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1alpha1.PriorityLevelConfigurationList{})
-	return err
-}
-
-// Patch applies the patch and returns the patched priorityLevelConfiguration.
-func (c *FakePriorityLevelConfigurations) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(prioritylevelconfigurationsResource, name, pt, data, subresources...), &v1alpha1.PriorityLevelConfiguration{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.PriorityLevelConfiguration), err
-}

kubernetes/typed/flowcontrol/v1alpha1/flowcontrol_client.go

@@ -1,94 +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 (
-	v1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
-	"k8s.io/client-go/kubernetes/scheme"
-	rest "k8s.io/client-go/rest"
-)
-
-type FlowcontrolV1alpha1Interface interface {
-	RESTClient() rest.Interface
-	FlowSchemasGetter
-	PriorityLevelConfigurationsGetter
-}
-
-// FlowcontrolV1alpha1Client is used to interact with features provided by the flowcontrol.apiserver.k8s.io group.
-type FlowcontrolV1alpha1Client struct {
-	restClient rest.Interface
-}
-
-func (c *FlowcontrolV1alpha1Client) FlowSchemas() FlowSchemaInterface {
-	return newFlowSchemas(c)
-}
-
-func (c *FlowcontrolV1alpha1Client) PriorityLevelConfigurations() PriorityLevelConfigurationInterface {
-	return newPriorityLevelConfigurations(c)
-}
-
-// NewForConfig creates a new FlowcontrolV1alpha1Client for the given config.
-func NewForConfig(c *rest.Config) (*FlowcontrolV1alpha1Client, error) {
-	config := *c
-	if err := setConfigDefaults(&config); err != nil {
-		return nil, err
-	}
-	client, err := rest.RESTClientFor(&config)
-	if err != nil {
-		return nil, err
-	}
-	return &FlowcontrolV1alpha1Client{client}, nil
-}
-
-// NewForConfigOrDie creates a new FlowcontrolV1alpha1Client for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) *FlowcontrolV1alpha1Client {
-	client, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return client
-}
-
-// New creates a new FlowcontrolV1alpha1Client for the given RESTClient.
-func New(c rest.Interface) *FlowcontrolV1alpha1Client {
-	return &FlowcontrolV1alpha1Client{c}
-}
-
-func setConfigDefaults(config *rest.Config) error {
-	gv := v1alpha1.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 *FlowcontrolV1alpha1Client) RESTClient() rest.Interface {
-	if c == nil {
-		return nil
-	}
-	return c.restClient
-}

kubernetes/typed/flowcontrol/v1alpha1/flowschema.go

@@ -1,180 +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 (
-	"time"
-
-	v1alpha1 "k8s.io/api/flowcontrol/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"
-)
-
-// FlowSchemasGetter has a method to return a FlowSchemaInterface.
-// A group's client should implement this interface.
-type FlowSchemasGetter interface {
-	FlowSchemas() FlowSchemaInterface
-}
-
-// FlowSchemaInterface has methods to work with FlowSchema resources.
-type FlowSchemaInterface interface {
-	Create(*v1alpha1.FlowSchema) (*v1alpha1.FlowSchema, error)
-	Update(*v1alpha1.FlowSchema) (*v1alpha1.FlowSchema, error)
-	UpdateStatus(*v1alpha1.FlowSchema) (*v1alpha1.FlowSchema, error)
-	Delete(name string, options *v1.DeleteOptions) error
-	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
-	Get(name string, options v1.GetOptions) (*v1alpha1.FlowSchema, error)
-	List(opts v1.ListOptions) (*v1alpha1.FlowSchemaList, error)
-	Watch(opts v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.FlowSchema, err error)
-	FlowSchemaExpansion
-}
-
-// flowSchemas implements FlowSchemaInterface
-type flowSchemas struct {
-	client rest.Interface
-}
-
-// newFlowSchemas returns a FlowSchemas
-func newFlowSchemas(c *FlowcontrolV1alpha1Client) *flowSchemas {
-	return &flowSchemas{
-		client: c.RESTClient(),
-	}
-}
-
-// Get takes name of the flowSchema, and returns the corresponding flowSchema object, and an error if there is any.
-func (c *flowSchemas) Get(name string, options v1.GetOptions) (result *v1alpha1.FlowSchema, err error) {
-	result = &v1alpha1.FlowSchema{}
-	err = c.client.Get().
-		Resource("flowschemas").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do().
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of FlowSchemas that match those selectors.
-func (c *flowSchemas) List(opts v1.ListOptions) (result *v1alpha1.FlowSchemaList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1alpha1.FlowSchemaList{}
-	err = c.client.Get().
-		Resource("flowschemas").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do().
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested flowSchemas.
-func (c *flowSchemas) Watch(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("flowschemas").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch()
-}
-
-// Create takes the representation of a flowSchema and creates it.  Returns the server's representation of the flowSchema, and an error, if there is any.
-func (c *flowSchemas) Create(flowSchema *v1alpha1.FlowSchema) (result *v1alpha1.FlowSchema, err error) {
-	result = &v1alpha1.FlowSchema{}
-	err = c.client.Post().
-		Resource("flowschemas").
-		Body(flowSchema).
-		Do().
-		Into(result)
-	return
-}
-
-// Update takes the representation of a flowSchema and updates it. Returns the server's representation of the flowSchema, and an error, if there is any.
-func (c *flowSchemas) Update(flowSchema *v1alpha1.FlowSchema) (result *v1alpha1.FlowSchema, err error) {
-	result = &v1alpha1.FlowSchema{}
-	err = c.client.Put().
-		Resource("flowschemas").
-		Name(flowSchema.Name).
-		Body(flowSchema).
-		Do().
-		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 *flowSchemas) UpdateStatus(flowSchema *v1alpha1.FlowSchema) (result *v1alpha1.FlowSchema, err error) {
-	result = &v1alpha1.FlowSchema{}
-	err = c.client.Put().
-		Resource("flowschemas").
-		Name(flowSchema.Name).
-		SubResource("status").
-		Body(flowSchema).
-		Do().
-		Into(result)
-	return
-}
-
-// Delete takes name of the flowSchema and deletes it. Returns an error if one occurs.
-func (c *flowSchemas) Delete(name string, options *v1.DeleteOptions) error {
-	return c.client.Delete().
-		Resource("flowschemas").
-		Name(name).
-		Body(options).
-		Do().
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *flowSchemas) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	var timeout time.Duration
-	if listOptions.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Resource("flowschemas").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(options).
-		Do().
-		Error()
-}
-
-// Patch applies the patch and returns the patched flowSchema.
-func (c *flowSchemas) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.FlowSchema, err error) {
-	result = &v1alpha1.FlowSchema{}
-	err = c.client.Patch(pt).
-		Resource("flowschemas").
-		SubResource(subresources...).
-		Name(name).
-		Body(data).
-		Do().
-		Into(result)
-	return
-}

kubernetes/typed/flowcontrol/v1alpha1/generated_expansion.go

@@ -1,23 +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
-
-type FlowSchemaExpansion interface{}
-
-type PriorityLevelConfigurationExpansion interface{}

kubernetes/typed/flowcontrol/v1alpha1/prioritylevelconfiguration.go

@@ -1,180 +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 (
-	"time"
-
-	v1alpha1 "k8s.io/api/flowcontrol/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"
-)
-
-// PriorityLevelConfigurationsGetter has a method to return a PriorityLevelConfigurationInterface.
-// A group's client should implement this interface.
-type PriorityLevelConfigurationsGetter interface {
-	PriorityLevelConfigurations() PriorityLevelConfigurationInterface
-}
-
-// PriorityLevelConfigurationInterface has methods to work with PriorityLevelConfiguration resources.
-type PriorityLevelConfigurationInterface interface {
-	Create(*v1alpha1.PriorityLevelConfiguration) (*v1alpha1.PriorityLevelConfiguration, error)
-	Update(*v1alpha1.PriorityLevelConfiguration) (*v1alpha1.PriorityLevelConfiguration, error)
-	UpdateStatus(*v1alpha1.PriorityLevelConfiguration) (*v1alpha1.PriorityLevelConfiguration, error)
-	Delete(name string, options *v1.DeleteOptions) error
-	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
-	Get(name string, options v1.GetOptions) (*v1alpha1.PriorityLevelConfiguration, error)
-	List(opts v1.ListOptions) (*v1alpha1.PriorityLevelConfigurationList, error)
-	Watch(opts v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.PriorityLevelConfiguration, err error)
-	PriorityLevelConfigurationExpansion
-}
-
-// priorityLevelConfigurations implements PriorityLevelConfigurationInterface
-type priorityLevelConfigurations struct {
-	client rest.Interface
-}
-
-// newPriorityLevelConfigurations returns a PriorityLevelConfigurations
-func newPriorityLevelConfigurations(c *FlowcontrolV1alpha1Client) *priorityLevelConfigurations {
-	return &priorityLevelConfigurations{
-		client: c.RESTClient(),
-	}
-}
-
-// Get takes name of the priorityLevelConfiguration, and returns the corresponding priorityLevelConfiguration object, and an error if there is any.
-func (c *priorityLevelConfigurations) Get(name string, options v1.GetOptions) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	result = &v1alpha1.PriorityLevelConfiguration{}
-	err = c.client.Get().
-		Resource("prioritylevelconfigurations").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do().
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of PriorityLevelConfigurations that match those selectors.
-func (c *priorityLevelConfigurations) List(opts v1.ListOptions) (result *v1alpha1.PriorityLevelConfigurationList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1alpha1.PriorityLevelConfigurationList{}
-	err = c.client.Get().
-		Resource("prioritylevelconfigurations").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do().
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested priorityLevelConfigurations.
-func (c *priorityLevelConfigurations) Watch(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("prioritylevelconfigurations").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch()
-}
-
-// Create takes the representation of a priorityLevelConfiguration and creates it.  Returns the server's representation of the priorityLevelConfiguration, and an error, if there is any.
-func (c *priorityLevelConfigurations) Create(priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	result = &v1alpha1.PriorityLevelConfiguration{}
-	err = c.client.Post().
-		Resource("prioritylevelconfigurations").
-		Body(priorityLevelConfiguration).
-		Do().
-		Into(result)
-	return
-}
-
-// Update takes the representation of a priorityLevelConfiguration and updates it. Returns the server's representation of the priorityLevelConfiguration, and an error, if there is any.
-func (c *priorityLevelConfigurations) Update(priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	result = &v1alpha1.PriorityLevelConfiguration{}
-	err = c.client.Put().
-		Resource("prioritylevelconfigurations").
-		Name(priorityLevelConfiguration.Name).
-		Body(priorityLevelConfiguration).
-		Do().
-		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 *priorityLevelConfigurations) UpdateStatus(priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	result = &v1alpha1.PriorityLevelConfiguration{}
-	err = c.client.Put().
-		Resource("prioritylevelconfigurations").
-		Name(priorityLevelConfiguration.Name).
-		SubResource("status").
-		Body(priorityLevelConfiguration).
-		Do().
-		Into(result)
-	return
-}
-
-// Delete takes name of the priorityLevelConfiguration and deletes it. Returns an error if one occurs.
-func (c *priorityLevelConfigurations) Delete(name string, options *v1.DeleteOptions) error {
-	return c.client.Delete().
-		Resource("prioritylevelconfigurations").
-		Name(name).
-		Body(options).
-		Do().
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *priorityLevelConfigurations) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	var timeout time.Duration
-	if listOptions.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Resource("prioritylevelconfigurations").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(options).
-		Do().
-		Error()
-}
-
-// Patch applies the patch and returns the patched priorityLevelConfiguration.
-func (c *priorityLevelConfigurations) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.PriorityLevelConfiguration, err error) {
-	result = &v1alpha1.PriorityLevelConfiguration{}
-	err = c.client.Patch(pt).
-		Resource("prioritylevelconfigurations").
-		SubResource(subresources...).
-		Name(name).
-		Body(data).
-		Do().
-		Into(result)
-	return
-}

kubernetes/typed/storage/v1/csinode.go

@@ -1,164 +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 (
-	"time"
-
-	v1 "k8s.io/api/storage/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"
-)
-
-// CSINodesGetter has a method to return a CSINodeInterface.
-// A group's client should implement this interface.
-type CSINodesGetter interface {
-	CSINodes() CSINodeInterface
-}
-
-// CSINodeInterface has methods to work with CSINode resources.
-type CSINodeInterface interface {
-	Create(*v1.CSINode) (*v1.CSINode, error)
-	Update(*v1.CSINode) (*v1.CSINode, error)
-	Delete(name string, options *metav1.DeleteOptions) error
-	DeleteCollection(options *metav1.DeleteOptions, listOptions metav1.ListOptions) error
-	Get(name string, options metav1.GetOptions) (*v1.CSINode, error)
-	List(opts metav1.ListOptions) (*v1.CSINodeList, error)
-	Watch(opts metav1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.CSINode, err error)
-	CSINodeExpansion
-}
-
-// cSINodes implements CSINodeInterface
-type cSINodes struct {
-	client rest.Interface
-}
-
-// newCSINodes returns a CSINodes
-func newCSINodes(c *StorageV1Client) *cSINodes {
-	return &cSINodes{
-		client: c.RESTClient(),
-	}
-}
-
-// Get takes name of the cSINode, and returns the corresponding cSINode object, and an error if there is any.
-func (c *cSINodes) Get(name string, options metav1.GetOptions) (result *v1.CSINode, err error) {
-	result = &v1.CSINode{}
-	err = c.client.Get().
-		Resource("csinodes").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do().
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of CSINodes that match those selectors.
-func (c *cSINodes) List(opts metav1.ListOptions) (result *v1.CSINodeList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1.CSINodeList{}
-	err = c.client.Get().
-		Resource("csinodes").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do().
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested cSINodes.
-func (c *cSINodes) Watch(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("csinodes").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch()
-}
-
-// Create takes the representation of a cSINode and creates it.  Returns the server's representation of the cSINode, and an error, if there is any.
-func (c *cSINodes) Create(cSINode *v1.CSINode) (result *v1.CSINode, err error) {
-	result = &v1.CSINode{}
-	err = c.client.Post().
-		Resource("csinodes").
-		Body(cSINode).
-		Do().
-		Into(result)
-	return
-}
-
-// Update takes the representation of a cSINode and updates it. Returns the server's representation of the cSINode, and an error, if there is any.
-func (c *cSINodes) Update(cSINode *v1.CSINode) (result *v1.CSINode, err error) {
-	result = &v1.CSINode{}
-	err = c.client.Put().
-		Resource("csinodes").
-		Name(cSINode.Name).
-		Body(cSINode).
-		Do().
-		Into(result)
-	return
-}
-
-// Delete takes name of the cSINode and deletes it. Returns an error if one occurs.
-func (c *cSINodes) Delete(name string, options *metav1.DeleteOptions) error {
-	return c.client.Delete().
-		Resource("csinodes").
-		Name(name).
-		Body(options).
-		Do().
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *cSINodes) DeleteCollection(options *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
-	var timeout time.Duration
-	if listOptions.TimeoutSeconds != nil {
-		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
-	}
-	return c.client.Delete().
-		Resource("csinodes").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(options).
-		Do().
-		Error()
-}
-
-// Patch applies the patch and returns the patched cSINode.
-func (c *cSINodes) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.CSINode, err error) {
-	result = &v1.CSINode{}
-	err = c.client.Patch(pt).
-		Resource("csinodes").
-		SubResource(subresources...).
-		Name(name).
-		Body(data).
-		Do().
-		Into(result)
-	return
-}

kubernetes/typed/storage/v1/fake/fake_csinode.go

@@ -1,120 +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 fake
-
-import (
-	storagev1 "k8s.io/api/storage/v1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	testing "k8s.io/client-go/testing"
-)
-
-// FakeCSINodes implements CSINodeInterface
-type FakeCSINodes struct {
-	Fake *FakeStorageV1
-}
-
-var csinodesResource = schema.GroupVersionResource{Group: "storage.k8s.io", Version: "v1", Resource: "csinodes"}
-
-var csinodesKind = schema.GroupVersionKind{Group: "storage.k8s.io", Version: "v1", Kind: "CSINode"}
-
-// Get takes name of the cSINode, and returns the corresponding cSINode object, and an error if there is any.
-func (c *FakeCSINodes) Get(name string, options v1.GetOptions) (result *storagev1.CSINode, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootGetAction(csinodesResource, name), &storagev1.CSINode{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*storagev1.CSINode), err
-}
-
-// List takes label and field selectors, and returns the list of CSINodes that match those selectors.
-func (c *FakeCSINodes) List(opts v1.ListOptions) (result *storagev1.CSINodeList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootListAction(csinodesResource, csinodesKind, opts), &storagev1.CSINodeList{})
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &storagev1.CSINodeList{ListMeta: obj.(*storagev1.CSINodeList).ListMeta}
-	for _, item := range obj.(*storagev1.CSINodeList).Items {
-		if label.Matches(labels.Set(item.Labels)) {
-			list.Items = append(list.Items, item)
-		}
-	}
-	return list, err
-}
-
-// Watch returns a watch.Interface that watches the requested cSINodes.
-func (c *FakeCSINodes) Watch(opts v1.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewRootWatchAction(csinodesResource, opts))
-}
-
-// Create takes the representation of a cSINode and creates it.  Returns the server's representation of the cSINode, and an error, if there is any.
-func (c *FakeCSINodes) Create(cSINode *storagev1.CSINode) (result *storagev1.CSINode, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootCreateAction(csinodesResource, cSINode), &storagev1.CSINode{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*storagev1.CSINode), err
-}
-
-// Update takes the representation of a cSINode and updates it. Returns the server's representation of the cSINode, and an error, if there is any.
-func (c *FakeCSINodes) Update(cSINode *storagev1.CSINode) (result *storagev1.CSINode, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateAction(csinodesResource, cSINode), &storagev1.CSINode{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*storagev1.CSINode), err
-}
-
-// Delete takes name of the cSINode and deletes it. Returns an error if one occurs.
-func (c *FakeCSINodes) Delete(name string, options *v1.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewRootDeleteAction(csinodesResource, name), &storagev1.CSINode{})
-	return err
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *FakeCSINodes) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	action := testing.NewRootDeleteCollectionAction(csinodesResource, listOptions)
-
-	_, err := c.Fake.Invokes(action, &storagev1.CSINodeList{})
-	return err
-}
-
-// Patch applies the patch and returns the patched cSINode.
-func (c *FakeCSINodes) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *storagev1.CSINode, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(csinodesResource, name, pt, data, subresources...), &storagev1.CSINode{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*storagev1.CSINode), err
-}

kubernetes/typed/storage/v1/fake/fake_storage_client.go

@@ -28,10 +28,6 @@ type FakeStorageV1 struct {
 	*testing.Fake
 }
 
-func (c *FakeStorageV1) CSINodes() v1.CSINodeInterface {
-	return &FakeCSINodes{c}
-}
-
 func (c *FakeStorageV1) StorageClasses() v1.StorageClassInterface {
 	return &FakeStorageClasses{c}
 }

kubernetes/typed/storage/v1/generated_expansion.go

@@ -18,8 +18,6 @@ limitations under the License.
 
 package v1
 
-type CSINodeExpansion interface{}
-
 type StorageClassExpansion interface{}
 
 type VolumeAttachmentExpansion interface{}

kubernetes/typed/storage/v1/storage_client.go

@@ -26,7 +26,6 @@ import (
 
 type StorageV1Interface interface {
 	RESTClient() rest.Interface
-	CSINodesGetter
 	StorageClassesGetter
 	VolumeAttachmentsGetter
 }
@@ -36,10 +35,6 @@ type StorageV1Client struct {
 	restClient rest.Interface
 }
 
-func (c *StorageV1Client) CSINodes() CSINodeInterface {
-	return newCSINodes(c)
-}
-
 func (c *StorageV1Client) StorageClasses() StorageClassInterface {
 	return newStorageClasses(c)
 }

listers/discovery/v1beta1/endpointslice.go

@@ -1,94 +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 lister-gen. DO NOT EDIT.
-
-package v1beta1
-
-import (
-	v1beta1 "k8s.io/api/discovery/v1beta1"
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/client-go/tools/cache"
-)
-
-// EndpointSliceLister helps list EndpointSlices.
-type EndpointSliceLister interface {
-	// List lists all EndpointSlices in the indexer.
-	List(selector labels.Selector) (ret []*v1beta1.EndpointSlice, err error)
-	// EndpointSlices returns an object that can list and get EndpointSlices.
-	EndpointSlices(namespace string) EndpointSliceNamespaceLister
-	EndpointSliceListerExpansion
-}
-
-// endpointSliceLister implements the EndpointSliceLister interface.
-type endpointSliceLister struct {
-	indexer cache.Indexer
-}
-
-// NewEndpointSliceLister returns a new EndpointSliceLister.
-func NewEndpointSliceLister(indexer cache.Indexer) EndpointSliceLister {
-	return &endpointSliceLister{indexer: indexer}
-}
-
-// List lists all EndpointSlices in the indexer.
-func (s *endpointSliceLister) List(selector labels.Selector) (ret []*v1beta1.EndpointSlice, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1beta1.EndpointSlice))
-	})
-	return ret, err
-}
-
-// EndpointSlices returns an object that can list and get EndpointSlices.
-func (s *endpointSliceLister) EndpointSlices(namespace string) EndpointSliceNamespaceLister {
-	return endpointSliceNamespaceLister{indexer: s.indexer, namespace: namespace}
-}
-
-// EndpointSliceNamespaceLister helps list and get EndpointSlices.
-type EndpointSliceNamespaceLister interface {
-	// List lists all EndpointSlices in the indexer for a given namespace.
-	List(selector labels.Selector) (ret []*v1beta1.EndpointSlice, err error)
-	// Get retrieves the EndpointSlice from the indexer for a given namespace and name.
-	Get(name string) (*v1beta1.EndpointSlice, error)
-	EndpointSliceNamespaceListerExpansion
-}
-
-// endpointSliceNamespaceLister implements the EndpointSliceNamespaceLister
-// interface.
-type endpointSliceNamespaceLister struct {
-	indexer   cache.Indexer
-	namespace string
-}
-
-// List lists all EndpointSlices in the indexer for a given namespace.
-func (s endpointSliceNamespaceLister) List(selector labels.Selector) (ret []*v1beta1.EndpointSlice, err error) {
-	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1beta1.EndpointSlice))
-	})
-	return ret, err
-}
-
-// Get retrieves the EndpointSlice from the indexer for a given namespace and name.
-func (s endpointSliceNamespaceLister) Get(name string) (*v1beta1.EndpointSlice, error) {
-	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(v1beta1.Resource("endpointslice"), name)
-	}
-	return obj.(*v1beta1.EndpointSlice), nil
-}

listers/discovery/v1beta1/expansion_generated.go

@@ -1,27 +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 lister-gen. DO NOT EDIT.
-
-package v1beta1
-
-// EndpointSliceListerExpansion allows custom methods to be added to
-// EndpointSliceLister.
-type EndpointSliceListerExpansion interface{}
-
-// EndpointSliceNamespaceListerExpansion allows custom methods to be added to
-// EndpointSliceNamespaceLister.
-type EndpointSliceNamespaceListerExpansion interface{}

listers/flowcontrol/v1alpha1/expansion_generated.go

@@ -1,27 +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 lister-gen. DO NOT EDIT.
-
-package v1alpha1
-
-// FlowSchemaListerExpansion allows custom methods to be added to
-// FlowSchemaLister.
-type FlowSchemaListerExpansion interface{}
-
-// PriorityLevelConfigurationListerExpansion allows custom methods to be added to
-// PriorityLevelConfigurationLister.
-type PriorityLevelConfigurationListerExpansion interface{}

listers/flowcontrol/v1alpha1/flowschema.go

@@ -1,65 +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 lister-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	v1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/client-go/tools/cache"
-)
-
-// FlowSchemaLister helps list FlowSchemas.
-type FlowSchemaLister interface {
-	// List lists all FlowSchemas in the indexer.
-	List(selector labels.Selector) (ret []*v1alpha1.FlowSchema, err error)
-	// Get retrieves the FlowSchema from the index for a given name.
-	Get(name string) (*v1alpha1.FlowSchema, error)
-	FlowSchemaListerExpansion
-}
-
-// flowSchemaLister implements the FlowSchemaLister interface.
-type flowSchemaLister struct {
-	indexer cache.Indexer
-}
-
-// NewFlowSchemaLister returns a new FlowSchemaLister.
-func NewFlowSchemaLister(indexer cache.Indexer) FlowSchemaLister {
-	return &flowSchemaLister{indexer: indexer}
-}
-
-// List lists all FlowSchemas in the indexer.
-func (s *flowSchemaLister) List(selector labels.Selector) (ret []*v1alpha1.FlowSchema, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1alpha1.FlowSchema))
-	})
-	return ret, err
-}
-
-// Get retrieves the FlowSchema from the index for a given name.
-func (s *flowSchemaLister) Get(name string) (*v1alpha1.FlowSchema, error) {
-	obj, exists, err := s.indexer.GetByKey(name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(v1alpha1.Resource("flowschema"), name)
-	}
-	return obj.(*v1alpha1.FlowSchema), nil
-}

listers/flowcontrol/v1alpha1/prioritylevelconfiguration.go

@@ -1,65 +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 lister-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	v1alpha1 "k8s.io/api/flowcontrol/v1alpha1"
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/client-go/tools/cache"
-)
-
-// PriorityLevelConfigurationLister helps list PriorityLevelConfigurations.
-type PriorityLevelConfigurationLister interface {
-	// List lists all PriorityLevelConfigurations in the indexer.
-	List(selector labels.Selector) (ret []*v1alpha1.PriorityLevelConfiguration, err error)
-	// Get retrieves the PriorityLevelConfiguration from the index for a given name.
-	Get(name string) (*v1alpha1.PriorityLevelConfiguration, error)
-	PriorityLevelConfigurationListerExpansion
-}
-
-// priorityLevelConfigurationLister implements the PriorityLevelConfigurationLister interface.
-type priorityLevelConfigurationLister struct {
-	indexer cache.Indexer
-}
-
-// NewPriorityLevelConfigurationLister returns a new PriorityLevelConfigurationLister.
-func NewPriorityLevelConfigurationLister(indexer cache.Indexer) PriorityLevelConfigurationLister {
-	return &priorityLevelConfigurationLister{indexer: indexer}
-}
-
-// List lists all PriorityLevelConfigurations in the indexer.
-func (s *priorityLevelConfigurationLister) List(selector labels.Selector) (ret []*v1alpha1.PriorityLevelConfiguration, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1alpha1.PriorityLevelConfiguration))
-	})
-	return ret, err
-}
-
-// Get retrieves the PriorityLevelConfiguration from the index for a given name.
-func (s *priorityLevelConfigurationLister) Get(name string) (*v1alpha1.PriorityLevelConfiguration, error) {
-	obj, exists, err := s.indexer.GetByKey(name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(v1alpha1.Resource("prioritylevelconfiguration"), name)
-	}
-	return obj.(*v1alpha1.PriorityLevelConfiguration), nil
-}

listers/storage/v1/csinode.go

@@ -1,65 +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 lister-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	v1 "k8s.io/api/storage/v1"
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/client-go/tools/cache"
-)
-
-// CSINodeLister helps list CSINodes.
-type CSINodeLister interface {
-	// List lists all CSINodes in the indexer.
-	List(selector labels.Selector) (ret []*v1.CSINode, err error)
-	// Get retrieves the CSINode from the index for a given name.
-	Get(name string) (*v1.CSINode, error)
-	CSINodeListerExpansion
-}
-
-// cSINodeLister implements the CSINodeLister interface.
-type cSINodeLister struct {
-	indexer cache.Indexer
-}
-
-// NewCSINodeLister returns a new CSINodeLister.
-func NewCSINodeLister(indexer cache.Indexer) CSINodeLister {
-	return &cSINodeLister{indexer: indexer}
-}
-
-// List lists all CSINodes in the indexer.
-func (s *cSINodeLister) List(selector labels.Selector) (ret []*v1.CSINode, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1.CSINode))
-	})
-	return ret, err
-}
-
-// Get retrieves the CSINode from the index for a given name.
-func (s *cSINodeLister) Get(name string) (*v1.CSINode, error) {
-	obj, exists, err := s.indexer.GetByKey(name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(v1.Resource("csinode"), name)
-	}
-	return obj.(*v1.CSINode), nil
-}

listers/storage/v1/expansion_generated.go

@@ -18,10 +18,6 @@ limitations under the License.
 
 package v1
 
-// CSINodeListerExpansion allows custom methods to be added to
-// CSINodeLister.
-type CSINodeListerExpansion interface{}
-
 // StorageClassListerExpansion allows custom methods to be added to
 // StorageClassLister.
 type StorageClassListerExpansion interface{}

metadata/fake/simple.go

@@ -317,6 +317,7 @@ func (c *metadataResourceClient) List(opts metav1.ListOptions) (*metav1.PartialO
 	if !ok {
 		return nil, fmt.Errorf("incoming object is incorrect type %T", obj)
 	}
+	fmt.Printf("DEBUG: %#v\n", inputList)
 
 	list := &metav1.PartialObjectMetadataList{
 		ListMeta: inputList.ListMeta,

metadata/metadata.go

@@ -23,7 +23,7 @@ import (
 
 	"k8s.io/klog"
 
-	metainternalversionscheme "k8s.io/apimachinery/pkg/apis/meta/internalversion/scheme"
+	metainternalversion "k8s.io/apimachinery/pkg/apis/meta/internalversion"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -63,7 +63,7 @@ func ConfigFor(inConfig *rest.Config) *rest.Config {
 	config := rest.CopyConfig(inConfig)
 	config.AcceptContentTypes = "application/vnd.kubernetes.protobuf,application/json"
 	config.ContentType = "application/vnd.kubernetes.protobuf"
-	config.NegotiatedSerializer = metainternalversionscheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = metainternalversion.Codecs.WithoutConversion()
 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
 	}

pkg/apis/clientauthentication/v1beta1/zz_generated.conversion.go

@@ -51,6 +51,11 @@ func RegisterConversions(s *runtime.Scheme) error {
 	}); err != nil {
 		return err
 	}
+	if err := s.AddGeneratedConversionFunc((*clientauthentication.ExecCredentialSpec)(nil), (*ExecCredentialSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_clientauthentication_ExecCredentialSpec_To_v1beta1_ExecCredentialSpec(a.(*clientauthentication.ExecCredentialSpec), b.(*ExecCredentialSpec), scope)
+	}); err != nil {
+		return err
+	}
 	if err := s.AddGeneratedConversionFunc((*ExecCredentialStatus)(nil), (*clientauthentication.ExecCredentialStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
 		return Convert_v1beta1_ExecCredentialStatus_To_clientauthentication_ExecCredentialStatus(a.(*ExecCredentialStatus), b.(*clientauthentication.ExecCredentialStatus), scope)
 	}); err != nil {

pkg/version/def.bzl

@@ -16,7 +16,7 @@
 def version_x_defs():
   # This should match the list of packages in kube::version::ldflag
   stamp_pkgs = [
-      "k8s.io/component-base/version",
+      "k8s.io/kubernetes/pkg/version",
       # In hack/lib/version.sh, this has a vendor/ prefix. That isn't needed here?
       "k8s.io/client-go/pkg/version",
       ]

plugin/pkg/client/auth/exec/exec.go

@@ -48,7 +48,6 @@ import (
 )
 
 const execInfoEnv = "KUBERNETES_EXEC_INFO"
-const onRotateListWarningLength = 1000
 
 var scheme = runtime.NewScheme()
 var codecs = serializer.NewCodecFactory(scheme)
@@ -165,7 +164,7 @@ type Authenticator struct {
 	cachedCreds *credentials
 	exp         time.Time
 
-	onRotateList []func()
+	onRotate func()
 }
 
 type credentials struct {
@@ -192,15 +191,7 @@ func (a *Authenticator) UpdateTransportConfig(c *transport.Config) error {
 		dial = (&net.Dialer{Timeout: 30 * time.Second, KeepAlive: 30 * time.Second}).DialContext
 	}
 	d := connrotation.NewDialer(dial)
-
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.onRotateList = append(a.onRotateList, d.CloseAll)
-	onRotateListLength := len(a.onRotateList)
-	if onRotateListLength > onRotateListWarningLength {
-		klog.Warningf("constructing many client instances from the same exec auth config can cause performance problems during cert rotation and can exhaust available network connections; %d clients constructed calling %q", onRotateListLength, a.cmd)
-	}
-
+	a.onRotate = d.CloseAll
 	c.Dial = d.DialContext
 
 	return nil
@@ -362,10 +353,8 @@ func (a *Authenticator) refreshCredsLocked(r *clientauthentication.Response) err
 	a.cachedCreds = newCreds
 	// Only close all connections when TLS cert rotates. Token rotation doesn't
 	// need the extra noise.
-	if len(a.onRotateList) > 0 && oldCreds != nil && !reflect.DeepEqual(oldCreds.cert, a.cachedCreds.cert) {
-		for _, onRotate := range a.onRotateList {
-			onRotate()
-		}
+	if a.onRotate != nil && oldCreds != nil && !reflect.DeepEqual(oldCreds.cert, a.cachedCreds.cert) {
+		a.onRotate()
 	}
 	return nil
 }

plugin/pkg/client/auth/exec/exec_test.go

@@ -713,52 +713,6 @@ func TestTLSCredentials(t *testing.T) {
 	get(t, "valid TLS cert again", false)
 }
 
-func TestConcurrentUpdateTransportConfig(t *testing.T) {
-	n := time.Now()
-	now := func() time.Time { return n }
-
-	env := []string{""}
-	environ := func() []string {
-		s := make([]string, len(env))
-		copy(s, env)
-		return s
-	}
-
-	c := api.ExecConfig{
-		Command:    "./testdata/test-plugin.sh",
-		APIVersion: "client.authentication.k8s.io/v1alpha1",
-	}
-	a, err := newAuthenticator(newCache(), &c)
-	if err != nil {
-		t.Fatal(err)
-	}
-	a.environ = environ
-	a.now = now
-	a.stderr = ioutil.Discard
-
-	stopCh := make(chan struct{})
-	defer close(stopCh)
-
-	numConcurrent := 2
-
-	for i := 0; i < numConcurrent; i++ {
-		go func() {
-			for {
-				tc := &transport.Config{}
-				a.UpdateTransportConfig(tc)
-
-				select {
-				case <-stopCh:
-					return
-				default:
-					continue
-				}
-			}
-		}()
-	}
-	time.Sleep(2 * time.Second)
-}
-
 // genClientCert generates an x509 certificate for testing. Certificate and key
 // are returned in PEM encoding.
 func genClientCert(t *testing.T) ([]byte, []byte) {

plugin/pkg/client/auth/gcp/gcp_test.go

@@ -476,25 +476,25 @@ func Test_cmdTokenSource_roundTrip(t *testing.T) {
 	}{
 		{
 			"Unauthorized",
-			http.Response{StatusCode: http.StatusUnauthorized},
+			http.Response{StatusCode: 401},
 			make(map[string]string),
 			make(map[string]string),
 		},
 		{
 			"Unauthorized, nonempty defaultCache",
-			http.Response{StatusCode: http.StatusUnauthorized},
+			http.Response{StatusCode: 401},
 			cmdCache,
 			cmdCache,
 		},
 		{
 			"Authorized",
-			http.Response{StatusCode: http.StatusOK},
+			http.Response{StatusCode: 200},
 			make(map[string]string),
 			simpleCacheUpdated,
 		},
 		{
 			"Authorized, nonempty defaultCache",
-			http.Response{StatusCode: http.StatusOK},
+			http.Response{StatusCode: 200},
 			cmdCache,
 			cmdCacheUpdated,
 		},

rest/OWNERS

@@ -20,6 +20,7 @@ reviewers:
 - resouer
 - cjcullen
 - rmmh
+- lixiaobing10051267
 - asalkeld
 - juanvallejo
 - lojies

rest/client.go

@@ -17,6 +17,8 @@ limitations under the License.
 package rest
 
 import (
+	"fmt"
+	"mime"
 	"net/http"
 	"net/url"
 	"os"
@@ -49,28 +51,6 @@ type Interface interface {
 	APIVersion() schema.GroupVersion
 }
 
-// ClientContentConfig controls how RESTClient communicates with the server.
-//
-// TODO: ContentConfig will be updated to accept a Negotiator instead of a
-//   NegotiatedSerializer and NegotiatedSerializer will be removed.
-type ClientContentConfig struct {
-	// AcceptContentTypes specifies the types the client will accept and is optional.
-	// If not set, ContentType will be used to define the Accept header
-	AcceptContentTypes string
-	// ContentType specifies the wire format used to communicate with the server.
-	// This value will be set as the Accept header on requests made to the server if
-	// AcceptContentTypes is not set, and as the default content type on any object
-	// sent to the server. If not set, "application/json" is used.
-	ContentType string
-	// GroupVersion is the API version to talk to. Must be provided when initializing
-	// a RESTClient directly. When initializing a Client, will be set with the default
-	// code version. This is used as the default group version for VersionedParams.
-	GroupVersion schema.GroupVersion
-	// Negotiator is used for obtaining encoders and decoders for multiple
-	// supported media types.
-	Negotiator runtime.ClientNegotiator
-}
-
 // RESTClient imposes common Kubernetes API conventions on a set of resource paths.
 // The baseURL is expected to point to an HTTP or HTTPS path that is the parent
 // of one or more resources.  The server should return a decodable API resource
@@ -84,27 +64,34 @@ type RESTClient struct {
 	// versionedAPIPath is a path segment connecting the base URL to the resource root
 	versionedAPIPath string
 
-	// content describes how a RESTClient encodes and decodes responses.
-	content ClientContentConfig
+	// contentConfig is the information used to communicate with the server.
+	contentConfig ContentConfig
+
+	// serializers contain all serializers for underlying content type.
+	serializers Serializers
 
 	// creates BackoffManager that is passed to requests.
 	createBackoffMgr func() BackoffManager
 
-	// rateLimiter is shared among all requests created by this client unless specifically
-	// overridden.
-	rateLimiter flowcontrol.RateLimiter
+	// TODO extract this into a wrapper interface via the RESTClient interface in kubectl.
+	Throttle flowcontrol.RateLimiter
 
 	// Set specific behavior of the client.  If not set http.DefaultClient will be used.
 	Client *http.Client
 }
 
-// NewRESTClient creates a new RESTClient. This client performs generic REST functions
-// such as Get, Put, Post, and Delete on specified paths.
-func NewRESTClient(baseURL *url.URL, versionedAPIPath string, config ClientContentConfig, rateLimiter flowcontrol.RateLimiter, client *http.Client) (*RESTClient, error) {
-	if len(config.ContentType) == 0 {
-		config.ContentType = "application/json"
-	}
+type Serializers struct {
+	Encoder             runtime.Encoder
+	Decoder             runtime.Decoder
+	StreamingSerializer runtime.Serializer
+	Framer              runtime.Framer
+	RenegotiatedDecoder func(contentType string, params map[string]string) (runtime.Decoder, error)
+}
 
+// NewRESTClient creates a new RESTClient. This client performs generic REST functions
+// such as Get, Put, Post, and Delete on specified paths.  Codec controls encoding and
+// decoding of responses from the server.
+func NewRESTClient(baseURL *url.URL, versionedAPIPath string, config ContentConfig, maxQPS float32, maxBurst int, rateLimiter flowcontrol.RateLimiter, client *http.Client) (*RESTClient, error) {
 	base := *baseURL
 	if !strings.HasSuffix(base.Path, "/") {
 		base.Path += "/"
@@ -112,14 +99,31 @@ func NewRESTClient(baseURL *url.URL, versionedAPIPath string, config ClientConte
 	base.RawQuery = ""
 	base.Fragment = ""
 
+	if config.GroupVersion == nil {
+		config.GroupVersion = &schema.GroupVersion{}
+	}
+	if len(config.ContentType) == 0 {
+		config.ContentType = "application/json"
+	}
+	serializers, err := createSerializers(config)
+	if err != nil {
+		return nil, err
+	}
+
+	var throttle flowcontrol.RateLimiter
+	if maxQPS > 0 && rateLimiter == nil {
+		throttle = flowcontrol.NewTokenBucketRateLimiter(maxQPS, maxBurst)
+	} else if rateLimiter != nil {
+		throttle = rateLimiter
+	}
 	return &RESTClient{
 		base:             &base,
 		versionedAPIPath: versionedAPIPath,
-		content:          config,
+		contentConfig:    config,
+		serializers:      *serializers,
 		createBackoffMgr: readExpBackoffConfig,
-		rateLimiter:      rateLimiter,
-
-		Client: client,
+		Throttle:         throttle,
+		Client:           client,
 	}, nil
 }
 
@@ -128,7 +132,7 @@ func (c *RESTClient) GetRateLimiter() flowcontrol.RateLimiter {
 	if c == nil {
 		return nil
 	}
-	return c.rateLimiter
+	return c.Throttle
 }
 
 // readExpBackoffConfig handles the internal logic of determining what the
@@ -149,6 +153,58 @@ func readExpBackoffConfig() BackoffManager {
 			time.Duration(backoffDurationInt)*time.Second)}
 }
 
+// createSerializers creates all necessary serializers for given contentType.
+// TODO: the negotiated serializer passed to this method should probably return
+//   serializers that control decoding and versioning without this package
+//   being aware of the types. Depends on whether RESTClient must deal with
+//   generic infrastructure.
+func createSerializers(config ContentConfig) (*Serializers, error) {
+	mediaTypes := config.NegotiatedSerializer.SupportedMediaTypes()
+	contentType := config.ContentType
+	mediaType, _, err := mime.ParseMediaType(contentType)
+	if err != nil {
+		return nil, fmt.Errorf("the content type specified in the client configuration is not recognized: %v", err)
+	}
+	info, ok := runtime.SerializerInfoForMediaType(mediaTypes, mediaType)
+	if !ok {
+		if len(contentType) != 0 || len(mediaTypes) == 0 {
+			return nil, fmt.Errorf("no serializers registered for %s", contentType)
+		}
+		info = mediaTypes[0]
+	}
+
+	internalGV := schema.GroupVersions{
+		{
+			Group:   config.GroupVersion.Group,
+			Version: runtime.APIVersionInternal,
+		},
+		// always include the legacy group as a decoding target to handle non-error `Status` return types
+		{
+			Group:   "",
+			Version: runtime.APIVersionInternal,
+		},
+	}
+
+	s := &Serializers{
+		Encoder: config.NegotiatedSerializer.EncoderForVersion(info.Serializer, *config.GroupVersion),
+		Decoder: config.NegotiatedSerializer.DecoderToVersion(info.Serializer, internalGV),
+
+		RenegotiatedDecoder: func(contentType string, params map[string]string) (runtime.Decoder, error) {
+			info, ok := runtime.SerializerInfoForMediaType(mediaTypes, contentType)
+			if !ok {
+				return nil, fmt.Errorf("serializer for %s not registered", contentType)
+			}
+			return config.NegotiatedSerializer.DecoderToVersion(info.Serializer, internalGV), nil
+		},
+	}
+	if info.StreamSerializer != nil {
+		s.StreamingSerializer = info.StreamSerializer.Serializer
+		s.Framer = info.StreamSerializer.Framer
+	}
+
+	return s, nil
+}
+
 // Verb begins a request with a verb (GET, POST, PUT, DELETE).
 //
 // Example usage of RESTClient's request building interface:
@@ -163,7 +219,12 @@ func readExpBackoffConfig() BackoffManager {
 // list, ok := resp.(*api.PodList)
 //
 func (c *RESTClient) Verb(verb string) *Request {
-	return NewRequest(c).Verb(verb)
+	backoff := c.createBackoffMgr()
+
+	if c.Client == nil {
+		return NewRequest(nil, verb, c.base, c.versionedAPIPath, c.contentConfig, c.serializers, backoff, c.Throttle, 0)
+	}
+	return NewRequest(c.Client, verb, c.base, c.versionedAPIPath, c.contentConfig, c.serializers, backoff, c.Throttle, c.Client.Timeout)
 }
 
 // Post begins a POST request. Short for c.Verb("POST").
@@ -193,5 +254,5 @@ func (c *RESTClient) Delete() *Request {
 
 // APIVersion returns the APIVersion this RESTClient is expected to use.
 func (c *RESTClient) APIVersion() schema.GroupVersion {
-	return c.content.GroupVersion
+	return *c.contentConfig.GroupVersion
 }

rest/client_test.go

@@ -27,7 +27,7 @@ import (
 
 	"fmt"
 
-	v1 "k8s.io/api/core/v1"
+	"k8s.io/api/core/v1"
 	v1beta1 "k8s.io/api/extensions/v1beta1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -57,14 +57,12 @@ func TestSerializer(t *testing.T) {
 		NegotiatedSerializer: scheme.Codecs.WithoutConversion(),
 	}
 
-	n := runtime.NewClientNegotiator(contentConfig.NegotiatedSerializer, gv)
-	d, err := n.Decoder("application/json", nil)
+	serializer, err := createSerializers(contentConfig)
 	if err != nil {
 		t.Fatal(err)
 	}
-
 	// bytes based on actual return from API server when encoding an "unversioned" object
-	obj, err := runtime.Decode(d, []byte(`{"kind":"Status","apiVersion":"v1","metadata":{},"status":"Success"}`))
+	obj, err := runtime.Decode(serializer.Decoder, []byte(`{"kind":"Status","apiVersion":"v1","metadata":{},"status":"Success"}`))
 	t.Log(obj)
 	if err != nil {
 		t.Fatal(err)

rest/config.go

@@ -269,9 +269,6 @@ type ContentConfig struct {
 	GroupVersion *schema.GroupVersion
 	// NegotiatedSerializer is used for obtaining encoders and decoders for multiple
 	// supported media types.
-	//
-	// TODO: NegotiatedSerializer will be phased out as internal clients are removed
-	//   from Kubernetes.
 	NegotiatedSerializer runtime.NegotiatedSerializer
 }
 
@@ -286,6 +283,14 @@ func RESTClientFor(config *Config) (*RESTClient, error) {
 	if config.NegotiatedSerializer == nil {
 		return nil, fmt.Errorf("NegotiatedSerializer is required when initializing a RESTClient")
 	}
+	qps := config.QPS
+	if config.QPS == 0.0 {
+		qps = DefaultQPS
+	}
+	burst := config.Burst
+	if config.Burst == 0 {
+		burst = DefaultBurst
+	}
 
 	baseURL, versionedAPIPath, err := defaultServerUrlFor(config)
 	if err != nil {
@@ -305,33 +310,7 @@ func RESTClientFor(config *Config) (*RESTClient, error) {
 		}
 	}
 
-	rateLimiter := config.RateLimiter
-	if rateLimiter == nil {
-		qps := config.QPS
-		if config.QPS == 0.0 {
-			qps = DefaultQPS
-		}
-		burst := config.Burst
-		if config.Burst == 0 {
-			burst = DefaultBurst
-		}
-		if qps > 0 {
-			rateLimiter = flowcontrol.NewTokenBucketRateLimiter(qps, burst)
-		}
-	}
-
-	var gv schema.GroupVersion
-	if config.GroupVersion != nil {
-		gv = *config.GroupVersion
-	}
-	clientContent := ClientContentConfig{
-		AcceptContentTypes: config.AcceptContentTypes,
-		ContentType:        config.ContentType,
-		GroupVersion:       gv,
-		Negotiator:         runtime.NewClientNegotiator(config.NegotiatedSerializer, gv),
-	}
-
-	return NewRESTClient(baseURL, versionedAPIPath, clientContent, rateLimiter, httpClient)
+	return NewRESTClient(baseURL, versionedAPIPath, config.ContentConfig, qps, burst, config.RateLimiter, httpClient)
 }
 
 // UnversionedRESTClientFor is the same as RESTClientFor, except that it allows
@@ -359,33 +338,13 @@ func UnversionedRESTClientFor(config *Config) (*RESTClient, error) {
 		}
 	}
 
-	rateLimiter := config.RateLimiter
-	if rateLimiter == nil {
-		qps := config.QPS
-		if config.QPS == 0.0 {
-			qps = DefaultQPS
-		}
-		burst := config.Burst
-		if config.Burst == 0 {
-			burst = DefaultBurst
-		}
-		if qps > 0 {
-			rateLimiter = flowcontrol.NewTokenBucketRateLimiter(qps, burst)
-		}
+	versionConfig := config.ContentConfig
+	if versionConfig.GroupVersion == nil {
+		v := metav1.SchemeGroupVersion
+		versionConfig.GroupVersion = &v
 	}
 
-	gv := metav1.SchemeGroupVersion
-	if config.GroupVersion != nil {
-		gv = *config.GroupVersion
-	}
-	clientContent := ClientContentConfig{
-		AcceptContentTypes: config.AcceptContentTypes,
-		ContentType:        config.ContentType,
-		GroupVersion:       gv,
-		Negotiator:         runtime.NewClientNegotiator(config.NegotiatedSerializer, gv),
-	}
-
-	return NewRESTClient(baseURL, versionedAPIPath, clientContent, rateLimiter, httpClient)
+	return NewRESTClient(baseURL, versionedAPIPath, versionConfig, config.QPS, config.Burst, config.RateLimiter, httpClient)
 }
 
 // SetKubernetesDefaults sets default values on the provided client config for accessing the

rest/config_test.go

@@ -155,59 +155,6 @@ func TestRESTClientRequires(t *testing.T) {
 	}
 }
 
-func TestRESTClientLimiter(t *testing.T) {
-	testCases := []struct {
-		Name    string
-		Config  Config
-		Limiter flowcontrol.RateLimiter
-	}{
-		{
-			Config:  Config{},
-			Limiter: flowcontrol.NewTokenBucketRateLimiter(5, 10),
-		},
-		{
-			Config:  Config{QPS: 10},
-			Limiter: flowcontrol.NewTokenBucketRateLimiter(10, 10),
-		},
-		{
-			Config:  Config{QPS: -1},
-			Limiter: nil,
-		},
-		{
-			Config: Config{
-				RateLimiter: flowcontrol.NewTokenBucketRateLimiter(11, 12),
-			},
-			Limiter: flowcontrol.NewTokenBucketRateLimiter(11, 12),
-		},
-	}
-	for _, testCase := range testCases {
-		t.Run("Versioned_"+testCase.Name, func(t *testing.T) {
-			config := testCase.Config
-			config.Host = "127.0.0.1"
-			config.ContentConfig = ContentConfig{GroupVersion: &v1.SchemeGroupVersion, NegotiatedSerializer: scheme.Codecs}
-			client, err := RESTClientFor(&config)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if !reflect.DeepEqual(testCase.Limiter, client.rateLimiter) {
-				t.Fatalf("unexpected rate limiter: %#v", client.rateLimiter)
-			}
-		})
-		t.Run("Unversioned_"+testCase.Name, func(t *testing.T) {
-			config := testCase.Config
-			config.Host = "127.0.0.1"
-			config.ContentConfig = ContentConfig{GroupVersion: &v1.SchemeGroupVersion, NegotiatedSerializer: scheme.Codecs}
-			client, err := UnversionedRESTClientFor(&config)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if !reflect.DeepEqual(testCase.Limiter, client.rateLimiter) {
-				t.Fatalf("unexpected rate limiter: %#v", client.rateLimiter)
-			}
-		})
-	}
-}
-
 type fakeLimiter struct {
 	FakeSaturation float64
 	FakeQPS        float32
@@ -243,10 +190,6 @@ func (c *fakeCodec) Encode(obj runtime.Object, stream io.Writer) error {
 	return nil
 }
 
-func (c *fakeCodec) Identifier() runtime.Identifier {
-	return runtime.Identifier("fake")
-}
-
 type fakeRoundTripper struct{}
 
 func (r *fakeRoundTripper) RoundTrip(*http.Request) (*http.Response, error) {

rest/fake/fake.go

@@ -29,8 +29,6 @@ import (
 	"k8s.io/client-go/util/flowcontrol"
 )
 
-// CreateHTTPClient creates an http.Client that will invoke the provided roundTripper func
-// when a request is made.
 func CreateHTTPClient(roundTripper func(*http.Request) (*http.Response, error)) *http.Client {
 	return &http.Client{
 		Transport: roundTripperFunc(roundTripper),
@@ -43,49 +41,40 @@ func (f roundTripperFunc) RoundTrip(req *http.Request) (*http.Response, error) {
 	return f(req)
 }
 
-// RESTClient provides a fake RESTClient interface. It is used to mock network
-// interactions via a rest.Request, or to make them via the provided Client to
-// a specific server.
+// RESTClient provides a fake RESTClient interface.
 type RESTClient struct {
+	Client               *http.Client
 	NegotiatedSerializer runtime.NegotiatedSerializer
 	GroupVersion         schema.GroupVersion
 	VersionedAPIPath     string
 
-	// Err is returned when any request would be made to the server. If Err is set,
-	// Req will not be recorded, Resp will not be returned, and Client will not be
-	// invoked.
-	Err error
-	// Req is set to the last request that was executed (had the methods Do/DoRaw) invoked.
-	Req *http.Request
-	// If Client is specified, the client will be invoked instead of returning Resp if
-	// Err is not set.
-	Client *http.Client
-	// Resp is returned to the caller after Req is recorded, unless Err or Client are set.
+	Req  *http.Request
 	Resp *http.Response
+	Err  error
 }
 
 func (c *RESTClient) Get() *restclient.Request {
-	return c.Verb("GET")
+	return c.request("GET")
 }
 
 func (c *RESTClient) Put() *restclient.Request {
-	return c.Verb("PUT")
+	return c.request("PUT")
 }
 
 func (c *RESTClient) Patch(pt types.PatchType) *restclient.Request {
-	return c.Verb("PATCH").SetHeader("Content-Type", string(pt))
+	return c.request("PATCH").SetHeader("Content-Type", string(pt))
 }
 
 func (c *RESTClient) Post() *restclient.Request {
-	return c.Verb("POST")
+	return c.request("POST")
 }
 
 func (c *RESTClient) Delete() *restclient.Request {
-	return c.Verb("DELETE")
+	return c.request("DELETE")
 }
 
 func (c *RESTClient) Verb(verb string) *restclient.Request {
-	return c.Request().Verb(verb)
+	return c.request(verb)
 }
 
 func (c *RESTClient) APIVersion() schema.GroupVersion {
@@ -96,17 +85,28 @@ func (c *RESTClient) GetRateLimiter() flowcontrol.RateLimiter {
 	return nil
 }
 
-func (c *RESTClient) Request() *restclient.Request {
-	config := restclient.ClientContentConfig{
-		ContentType:  runtime.ContentTypeJSON,
-		GroupVersion: c.GroupVersion,
-		Negotiator:   runtime.NewClientNegotiator(c.NegotiatedSerializer, c.GroupVersion),
+func (c *RESTClient) request(verb string) *restclient.Request {
+	config := restclient.ContentConfig{
+		ContentType:          runtime.ContentTypeJSON,
+		GroupVersion:         &c.GroupVersion,
+		NegotiatedSerializer: c.NegotiatedSerializer,
 	}
-	return restclient.NewRequestWithClient(&url.URL{Scheme: "https", Host: "localhost"}, c.VersionedAPIPath, config, CreateHTTPClient(c.do))
+
+	ns := c.NegotiatedSerializer
+	info, _ := runtime.SerializerInfoForMediaType(ns.SupportedMediaTypes(), runtime.ContentTypeJSON)
+	serializers := restclient.Serializers{
+		// TODO this was hardcoded before, but it doesn't look right
+		Encoder: ns.EncoderForVersion(info.Serializer, c.GroupVersion),
+		Decoder: ns.DecoderToVersion(info.Serializer, c.GroupVersion),
+	}
+	if info.StreamSerializer != nil {
+		serializers.StreamingSerializer = info.StreamSerializer.Serializer
+		serializers.Framer = info.StreamSerializer.Framer
+	}
+	return restclient.NewRequest(c, verb, &url.URL{Host: "localhost"}, c.VersionedAPIPath, config, serializers, nil, nil, 0)
 }
 
-// do is invoked when a Request() created by this client is executed.
-func (c *RESTClient) do(req *http.Request) (*http.Response, error) {
+func (c *RESTClient) Do(req *http.Request) (*http.Response, error) {
 	if c.Err != nil {
 		return nil, c.Err
 	}

rest/request.go

@@ -48,8 +48,7 @@ import (
 
 var (
 	// longThrottleLatency defines threshold for logging requests. All requests being
-	// throttled (via the provided rateLimiter) for more than longThrottleLatency will
-	// be logged.
+	// throttle for more than longThrottleLatency will be logged.
 	longThrottleLatency = 50 * time.Millisecond
 )
 
@@ -75,20 +74,19 @@ func (r *RequestConstructionError) Error() string {
 	return fmt.Sprintf("request construction error: '%v'", r.Err)
 }
 
-var noBackoff = &NoBackoff{}
-
 // Request allows for building up a request to a server in a chained fashion.
 // Any errors are stored until the end of your call, so you only have to
 // check once.
 type Request struct {
-	c *RESTClient
+	// required
+	client HTTPClient
+	verb   string
 
-	rateLimiter flowcontrol.RateLimiter
-	backoff     BackoffManager
-	timeout     time.Duration
+	baseURL     *url.URL
+	content     ContentConfig
+	serializers Serializers
 
 	// generic components accessible via method setters
-	verb       string
 	pathPrefix string
 	subpath    string
 	params     url.Values
@@ -100,6 +98,7 @@ type Request struct {
 	resource     string
 	resourceName string
 	subresource  string
+	timeout      time.Duration
 
 	// output
 	err  error
@@ -107,63 +106,42 @@ type Request struct {
 
 	// This is only used for per-request timeouts, deadlines, and cancellations.
 	ctx context.Context
+
+	backoffMgr BackoffManager
+	throttle   flowcontrol.RateLimiter
 }
 
 // NewRequest creates a new request helper object for accessing runtime.Objects on a server.
-func NewRequest(c *RESTClient) *Request {
-	var backoff BackoffManager
-	if c.createBackoffMgr != nil {
-		backoff = c.createBackoffMgr()
-	}
+func NewRequest(client HTTPClient, verb string, baseURL *url.URL, versionedAPIPath string, content ContentConfig, serializers Serializers, backoff BackoffManager, throttle flowcontrol.RateLimiter, timeout time.Duration) *Request {
 	if backoff == nil {
-		backoff = noBackoff
+		klog.V(2).Infof("Not implementing request backoff strategy.")
+		backoff = &NoBackoff{}
 	}
 
-	var pathPrefix string
-	if c.base != nil {
-		pathPrefix = path.Join("/", c.base.Path, c.versionedAPIPath)
-	} else {
-		pathPrefix = path.Join("/", c.versionedAPIPath)
+	pathPrefix := "/"
+	if baseURL != nil {
+		pathPrefix = path.Join(pathPrefix, baseURL.Path)
 	}
-
-	var timeout time.Duration
-	if c.Client != nil {
-		timeout = c.Client.Timeout
-	}
-
 	r := &Request{
-		c:           c,
-		rateLimiter: c.rateLimiter,
-		backoff:     backoff,
+		client:      client,
+		verb:        verb,
+		baseURL:     baseURL,
+		pathPrefix:  path.Join(pathPrefix, versionedAPIPath),
+		content:     content,
+		serializers: serializers,
+		backoffMgr:  backoff,
+		throttle:    throttle,
 		timeout:     timeout,
-		pathPrefix:  pathPrefix,
 	}
-
 	switch {
-	case len(c.content.AcceptContentTypes) > 0:
-		r.SetHeader("Accept", c.content.AcceptContentTypes)
-	case len(c.content.ContentType) > 0:
-		r.SetHeader("Accept", c.content.ContentType+", */*")
+	case len(content.AcceptContentTypes) > 0:
+		r.SetHeader("Accept", content.AcceptContentTypes)
+	case len(content.ContentType) > 0:
+		r.SetHeader("Accept", content.ContentType+", */*")
 	}
 	return r
 }
 
-// NewRequestWithClient creates a Request with an embedded RESTClient for use in test scenarios.
-func NewRequestWithClient(base *url.URL, versionedAPIPath string, content ClientContentConfig, client *http.Client) *Request {
-	return NewRequest(&RESTClient{
-		base:             base,
-		versionedAPIPath: versionedAPIPath,
-		content:          content,
-		Client:           client,
-	})
-}
-
-// Verb sets the verb this request will use.
-func (r *Request) Verb(verb string) *Request {
-	r.verb = verb
-	return r
-}
-
 // Prefix adds segments to the relative beginning to the request path. These
 // items will be placed before the optional Namespace, Resource, or Name sections.
 // Setting AbsPath will clear any previously set Prefix segments
@@ -206,17 +184,17 @@ func (r *Request) Resource(resource string) *Request {
 // or defaults to the stub implementation if nil is provided
 func (r *Request) BackOff(manager BackoffManager) *Request {
 	if manager == nil {
-		r.backoff = &NoBackoff{}
+		r.backoffMgr = &NoBackoff{}
 		return r
 	}
 
-	r.backoff = manager
+	r.backoffMgr = manager
 	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
+	r.throttle = limiter
 	return r
 }
 
@@ -294,8 +272,8 @@ func (r *Request) AbsPath(segments ...string) *Request {
 	if r.err != nil {
 		return r
 	}
-	r.pathPrefix = path.Join(r.c.base.Path, path.Join(segments...))
-	if len(segments) == 1 && (len(r.c.base.Path) > 1 || len(segments[0]) > 1) && strings.HasSuffix(segments[0], "/") {
+	r.pathPrefix = path.Join(r.baseURL.Path, path.Join(segments...))
+	if len(segments) == 1 && (len(r.baseURL.Path) > 1 || len(segments[0]) > 1) && strings.HasSuffix(segments[0], "/") {
 		// preserve any trailing slashes for legacy behavior
 		r.pathPrefix += "/"
 	}
@@ -339,7 +317,7 @@ func (r *Request) Param(paramName, s string) *Request {
 // VersionedParams will not write query parameters that have omitempty set and are empty. If a
 // parameter has already been set it is appended to (Params and VersionedParams are additive).
 func (r *Request) VersionedParams(obj runtime.Object, codec runtime.ParameterCodec) *Request {
-	return r.SpecificallyVersionedParams(obj, codec, r.c.content.GroupVersion)
+	return r.SpecificallyVersionedParams(obj, codec, *r.content.GroupVersion)
 }
 
 func (r *Request) SpecificallyVersionedParams(obj runtime.Object, codec runtime.ParameterCodec, version schema.GroupVersion) *Request {
@@ -419,19 +397,14 @@ func (r *Request) Body(obj interface{}) *Request {
 		if reflect.ValueOf(t).IsNil() {
 			return r
 		}
-		encoder, err := r.c.content.Negotiator.Encoder(r.c.content.ContentType, nil)
-		if err != nil {
-			r.err = err
-			return r
-		}
-		data, err := runtime.Encode(encoder, t)
+		data, err := runtime.Encode(r.serializers.Encoder, t)
 		if err != nil {
 			r.err = err
 			return r
 		}
 		glogBody("Request Body", data)
 		r.body = bytes.NewReader(data)
-		r.SetHeader("Content-Type", r.c.content.ContentType)
+		r.SetHeader("Content-Type", r.content.ContentType)
 	default:
 		r.err = fmt.Errorf("unknown type used for body: %+v", obj)
 	}
@@ -460,8 +433,8 @@ func (r *Request) URL() *url.URL {
 	}
 
 	finalURL := &url.URL{}
-	if r.c.base != nil {
-		*finalURL = *r.c.base
+	if r.baseURL != nil {
+		*finalURL = *r.baseURL
 	}
 	finalURL.Path = p
 
@@ -495,8 +468,8 @@ func (r Request) finalURLTemplate() url.URL {
 	segments := strings.Split(r.URL().Path, "/")
 	groupIndex := 0
 	index := 0
-	if r.URL() != nil && r.c.base != nil && strings.Contains(r.URL().Path, r.c.base.Path) {
-		groupIndex += len(strings.Split(r.c.base.Path, "/"))
+	if r.URL() != nil && r.baseURL != nil && strings.Contains(r.URL().Path, r.baseURL.Path) {
+		groupIndex += len(strings.Split(r.baseURL.Path, "/"))
 	}
 	if groupIndex >= len(segments) {
 		return *url
@@ -549,16 +522,16 @@ func (r Request) finalURLTemplate() url.URL {
 }
 
 func (r *Request) tryThrottle() error {
-	if r.rateLimiter == nil {
+	if r.throttle == nil {
 		return nil
 	}
 
 	now := time.Now()
 	var err error
 	if r.ctx != nil {
-		err = r.rateLimiter.Wait(r.ctx)
+		err = r.throttle.Wait(r.ctx)
 	} else {
-		r.rateLimiter.Accept()
+		r.throttle.Accept()
 	}
 
 	if latency := time.Since(now); latency > longThrottleLatency {
@@ -571,11 +544,27 @@ func (r *Request) tryThrottle() error {
 // Watch attempts to begin watching the requested location.
 // Returns a watch.Interface, or an error.
 func (r *Request) Watch() (watch.Interface, error) {
+	return r.WatchWithSpecificDecoders(
+		func(body io.ReadCloser) streaming.Decoder {
+			framer := r.serializers.Framer.NewFrameReader(body)
+			return streaming.NewDecoder(framer, r.serializers.StreamingSerializer)
+		},
+		r.serializers.Decoder,
+	)
+}
+
+// WatchWithSpecificDecoders attempts to begin watching the requested location with a *different* decoder.
+// Turns out that you want one "standard" decoder for the watch event and one "personal" decoder for the content
+// Returns a watch.Interface, or an error.
+func (r *Request) WatchWithSpecificDecoders(wrapperDecoderFn func(io.ReadCloser) streaming.Decoder, embeddedDecoder runtime.Decoder) (watch.Interface, error) {
 	// We specifically don't want to rate limit watches, so we
-	// don't use r.rateLimiter here.
+	// don't use r.throttle here.
 	if r.err != nil {
 		return nil, r.err
 	}
+	if r.serializers.Framer == nil {
+		return nil, fmt.Errorf("watching resources is not possible with this client (content-type: %s)", r.content.ContentType)
+	}
 
 	url := r.URL().String()
 	req, err := http.NewRequest(r.verb, url, r.body)
@@ -586,24 +575,24 @@ func (r *Request) Watch() (watch.Interface, error) {
 		req = req.WithContext(r.ctx)
 	}
 	req.Header = r.headers
-	client := r.c.Client
+	client := r.client
 	if client == nil {
 		client = http.DefaultClient
 	}
-	r.backoff.Sleep(r.backoff.CalculateBackoff(r.URL()))
+	r.backoffMgr.Sleep(r.backoffMgr.CalculateBackoff(r.URL()))
 	resp, err := client.Do(req)
 	updateURLMetrics(r, resp, err)
-	if r.c.base != nil {
+	if r.baseURL != nil {
 		if err != nil {
-			r.backoff.UpdateBackoff(r.c.base, err, 0)
+			r.backoffMgr.UpdateBackoff(r.baseURL, err, 0)
 		} else {
-			r.backoff.UpdateBackoff(r.c.base, err, resp.StatusCode)
+			r.backoffMgr.UpdateBackoff(r.baseURL, err, resp.StatusCode)
 		}
 	}
 	if err != nil {
 		// The watch stream mechanism handles many common partial data errors, so closed
 		// connections can be retried in many cases.
-		if net.IsProbableEOF(err) || net.IsTimeout(err) {
+		if net.IsProbableEOF(err) {
 			return watch.NewEmptyWatch(), nil
 		}
 		return nil, err
@@ -615,22 +604,9 @@ func (r *Request) Watch() (watch.Interface, error) {
 		}
 		return nil, fmt.Errorf("for request %s, got status: %v", url, resp.StatusCode)
 	}
-
-	contentType := resp.Header.Get("Content-Type")
-	mediaType, params, err := mime.ParseMediaType(contentType)
-	if err != nil {
-		klog.V(4).Infof("Unexpected content type from the server: %q: %v", contentType, err)
-	}
-	objectDecoder, streamingSerializer, framer, err := r.c.content.Negotiator.StreamDecoder(mediaType, params)
-	if err != nil {
-		return nil, err
-	}
-
-	frameReader := framer.NewFrameReader(resp.Body)
-	watchEventDecoder := streaming.NewDecoder(frameReader, streamingSerializer)
-
+	wrapperDecoder := wrapperDecoderFn(resp.Body)
 	return watch.NewStreamWatcher(
-		restclientwatch.NewDecoder(watchEventDecoder, objectDecoder),
+		restclientwatch.NewDecoder(wrapperDecoder, embeddedDecoder),
 		// use 500 to indicate that the cause of the error is unknown - other error codes
 		// are more specific to HTTP interactions, and set a reason
 		errors.NewClientErrorReporter(http.StatusInternalServerError, r.verb, "ClientWatchDecoding"),
@@ -641,8 +617,8 @@ func (r *Request) Watch() (watch.Interface, error) {
 // It also handles corner cases for incomplete/invalid request data.
 func updateURLMetrics(req *Request, resp *http.Response, err error) {
 	url := "none"
-	if req.c.base != nil {
-		url = req.c.base.Host
+	if req.baseURL != nil {
+		url = req.baseURL.Host
 	}
 
 	// Errors can be arbitrary strings. Unbound label cardinality is not suitable for a metric
@@ -680,18 +656,18 @@ func (r *Request) Stream() (io.ReadCloser, error) {
 		req = req.WithContext(r.ctx)
 	}
 	req.Header = r.headers
-	client := r.c.Client
+	client := r.client
 	if client == nil {
 		client = http.DefaultClient
 	}
-	r.backoff.Sleep(r.backoff.CalculateBackoff(r.URL()))
+	r.backoffMgr.Sleep(r.backoffMgr.CalculateBackoff(r.URL()))
 	resp, err := client.Do(req)
 	updateURLMetrics(r, resp, err)
-	if r.c.base != nil {
+	if r.baseURL != nil {
 		if err != nil {
-			r.backoff.UpdateBackoff(r.URL(), err, 0)
+			r.backoffMgr.UpdateBackoff(r.URL(), err, 0)
 		} else {
-			r.backoff.UpdateBackoff(r.URL(), err, resp.StatusCode)
+			r.backoffMgr.UpdateBackoff(r.URL(), err, resp.StatusCode)
 		}
 	}
 	if err != nil {
@@ -715,33 +691,6 @@ func (r *Request) Stream() (io.ReadCloser, error) {
 	}
 }
 
-// requestPreflightCheck looks for common programmer errors on Request.
-//
-// We tackle here two programmer mistakes. The first one is to try to create
-// something(POST) using an empty string as namespace with namespaceSet as
-// true. If namespaceSet is true then namespace should also be defined. The
-// second mistake is, when under the same circumstances, the programmer tries
-// to GET, PUT or DELETE a named resource(resourceName != ""), again, if
-// namespaceSet is true then namespace must not be empty.
-func (r *Request) requestPreflightCheck() error {
-	if !r.namespaceSet {
-		return nil
-	}
-	if len(r.namespace) > 0 {
-		return nil
-	}
-
-	switch r.verb {
-	case "POST":
-		return fmt.Errorf("an empty namespace may not be set during creation")
-	case "GET", "PUT", "DELETE":
-		if len(r.resourceName) > 0 {
-			return fmt.Errorf("an empty namespace may not be set when a resource name is provided")
-		}
-	}
-	return nil
-}
-
 // request connects to the server and invokes the provided function when a server response is
 // received. It handles retry behavior and up front validation of requests. It will invoke
 // fn at most once. It will return an error if a problem occurred prior to connecting to the
@@ -758,11 +707,15 @@ func (r *Request) request(fn func(*http.Request, *http.Response)) error {
 		return r.err
 	}
 
-	if err := r.requestPreflightCheck(); err != nil {
-		return err
+	// TODO: added to catch programmer errors (invoking operations with an object with an empty namespace)
+	if (r.verb == "GET" || r.verb == "PUT" || r.verb == "DELETE") && r.namespaceSet && len(r.resourceName) > 0 && len(r.namespace) == 0 {
+		return fmt.Errorf("an empty namespace may not be set when a resource name is provided")
+	}
+	if (r.verb == "POST") && r.namespaceSet && len(r.namespace) == 0 {
+		return fmt.Errorf("an empty namespace may not be set during creation")
 	}
 
-	client := r.c.Client
+	client := r.client
 	if client == nil {
 		client = http.DefaultClient
 	}
@@ -789,11 +742,11 @@ func (r *Request) request(fn func(*http.Request, *http.Response)) error {
 		}
 		req.Header = r.headers
 
-		r.backoff.Sleep(r.backoff.CalculateBackoff(r.URL()))
+		r.backoffMgr.Sleep(r.backoffMgr.CalculateBackoff(r.URL()))
 		if retries > 0 {
 			// We are retrying the request that we already send to apiserver
 			// at least once before.
-			// This request should also be throttled with the client-internal rate limiter.
+			// This request should also be throttled with the client-internal throttler.
 			if err := r.tryThrottle(); err != nil {
 				return err
 			}
@@ -801,9 +754,9 @@ func (r *Request) request(fn func(*http.Request, *http.Response)) error {
 		resp, err := client.Do(req)
 		updateURLMetrics(r, resp, err)
 		if err != nil {
-			r.backoff.UpdateBackoff(r.URL(), err, 0)
+			r.backoffMgr.UpdateBackoff(r.URL(), err, 0)
 		} else {
-			r.backoff.UpdateBackoff(r.URL(), err, resp.StatusCode)
+			r.backoffMgr.UpdateBackoff(r.URL(), err, resp.StatusCode)
 		}
 		if err != nil {
 			// "Connection reset by peer" is usually a transient error.
@@ -846,7 +799,7 @@ func (r *Request) request(fn func(*http.Request, *http.Response)) error {
 				}
 
 				klog.V(4).Infof("Got a Retry-After %ds response for attempt %d to %v", seconds, retries, url)
-				r.backoff.Sleep(time.Duration(seconds) * time.Second)
+				r.backoffMgr.Sleep(time.Duration(seconds) * time.Second)
 				return false
 			}
 			fn(req, resp)
@@ -862,6 +815,8 @@ func (r *Request) request(fn func(*http.Request, *http.Response)) error {
 // processing.
 //
 // Error type:
+//  * If the request can't be constructed, or an error happened earlier while building its
+//    arguments: *RequestConstructionError
 //  * If the server responds with a status: *errors.StatusError or *errors.UnexpectedObjectError
 //  * http.Client.Do errors are returned directly.
 func (r *Request) Do() Result {
@@ -932,18 +887,14 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu
 	glogBody("Response Body", body)
 
 	// verify the content type is accurate
-	var decoder runtime.Decoder
 	contentType := resp.Header.Get("Content-Type")
-	if len(contentType) == 0 {
-		contentType = r.c.content.ContentType
-	}
-	if len(contentType) > 0 {
-		var err error
+	decoder := r.serializers.Decoder
+	if len(contentType) > 0 && (decoder == nil || (len(r.content.ContentType) > 0 && contentType != r.content.ContentType)) {
 		mediaType, params, err := mime.ParseMediaType(contentType)
 		if err != nil {
 			return Result{err: errors.NewInternalError(err)}
 		}
-		decoder, err = r.c.content.Negotiator.Decoder(mediaType, params)
+		decoder, err = r.serializers.RenegotiatedDecoder(mediaType, params)
 		if err != nil {
 			// if we fail to negotiate a decoder, treat this as an unstructured error
 			switch {
@@ -1063,7 +1014,7 @@ func (r *Request) newUnstructuredResponseError(body []byte, isTextResponse bool,
 	}
 	var groupResource schema.GroupResource
 	if len(r.resource) > 0 {
-		groupResource.Group = r.c.content.GroupVersion.Group
+		groupResource.Group = r.content.GroupVersion.Group
 		groupResource.Resource = r.resource
 	}
 	return errors.NewGenericServerResponse(

scale/client_test.go

@@ -180,7 +180,7 @@ func fakeScaleClient(t *testing.T) (ScalesGetter, []schema.GroupResource) {
 			if err != nil {
 				return nil, err
 			}
-			return &http.Response{StatusCode: http.StatusOK, Header: defaultHeaders(), Body: bytesBody(res)}, nil
+			return &http.Response{StatusCode: 200, Header: defaultHeaders(), Body: bytesBody(res)}, nil
 		case "PUT":
 			decoder := codecs.UniversalDeserializer()
 			body, err := ioutil.ReadAll(req.Body)
@@ -198,7 +198,7 @@ func fakeScaleClient(t *testing.T) (ScalesGetter, []schema.GroupResource) {
 			if err != nil {
 				return nil, err
 			}
-			return &http.Response{StatusCode: http.StatusOK, Header: defaultHeaders(), Body: bytesBody(res)}, nil
+			return &http.Response{StatusCode: 200, Header: defaultHeaders(), Body: bytesBody(res)}, nil
 		case "PATCH":
 			body, err := ioutil.ReadAll(req.Body)
 			if err != nil {
@@ -229,7 +229,7 @@ func fakeScaleClient(t *testing.T) (ScalesGetter, []schema.GroupResource) {
 			default:
 				return nil, fmt.Errorf("invalid patch type")
 			}
-			return &http.Response{StatusCode: http.StatusOK, Header: defaultHeaders(), Body: bytesBody(res)}, nil
+			return &http.Response{StatusCode: 200, Header: defaultHeaders(), Body: bytesBody(res)}, nil
 		default:
 			return nil, fmt.Errorf("unexpected request for URL %q with method %q", req.URL.String(), req.Method)
 		}

scale/scheme/appsv1beta1/conversion.go

@@ -22,9 +22,23 @@ import (
 	v1beta1 "k8s.io/api/apps/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/conversion"
+	"k8s.io/apimachinery/pkg/runtime"
 	scheme "k8s.io/client-go/scale/scheme"
 )
 
+// addConversions registers conversions between the internal version
+// of Scale and supported external versions of Scale.
+func addConversionFuncs(scheme *runtime.Scheme) error {
+	err := scheme.AddConversionFuncs(
+		Convert_scheme_ScaleStatus_To_v1beta1_ScaleStatus,
+		Convert_v1beta1_ScaleStatus_To_scheme_ScaleStatus,
+	)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
 func Convert_scheme_ScaleStatus_To_v1beta1_ScaleStatus(in *scheme.ScaleStatus, out *v1beta1.ScaleStatus, s conversion.Scope) error {
 	out.Replicas = in.Replicas
 	out.Selector = nil

scale/scheme/appsv1beta1/register.go

@@ -41,5 +41,5 @@ func init() {
 	// We only register manually written functions here. The registration of the
 	// generated functions takes place in the generated files. The separation
 	// makes the code compile even when the generated files are missing.
-	localSchemeBuilder.Register()
+	localSchemeBuilder.Register(addConversionFuncs)
 }

scale/scheme/appsv1beta1/zz_generated.conversion.go

@@ -54,6 +54,16 @@ func RegisterConversions(s *runtime.Scheme) error {
 	}); err != nil {
 		return err
 	}
+	if err := s.AddGeneratedConversionFunc((*v1beta1.ScaleStatus)(nil), (*scheme.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_v1beta1_ScaleStatus_To_scheme_ScaleStatus(a.(*v1beta1.ScaleStatus), b.(*scheme.ScaleStatus), scope)
+	}); err != nil {
+		return err
+	}
+	if err := s.AddGeneratedConversionFunc((*scheme.ScaleStatus)(nil), (*v1beta1.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
+		return Convert_scheme_ScaleStatus_To_v1beta1_ScaleStatus(a.(*scheme.ScaleStatus), b.(*v1beta1.ScaleStatus), scope)
+	}); err != nil {
+		return err
+	}
 	if err := s.AddConversionFunc((*scheme.ScaleStatus)(nil), (*v1beta1.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
 		return Convert_scheme_ScaleStatus_To_v1beta1_ScaleStatus(a.(*scheme.ScaleStatus), b.(*v1beta1.ScaleStatus), scope)
 	}); err != nil {