Merge remote-tracking branch 'origin/master' into release-1.14

Kubernetes-commit: 1ddce0577ab12daa1f934562debb0563b5c44fe7
Update to go 1.12 version of golang.org/x/net
2026-06-10 11:16:28 +00:00 · 2019-03-13 23:57:26 +00:00 · 2019-03-12 09:16:45 -04:00 · 2019-01-07 18:29:55 +05:30 · 2019-03-12 12:00:14 +00:00 · 2019-03-12 11:59:54 +00:00
121 changed files with 1126 additions and 3205 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+
+go_import_path: k8s.io/client-go
+
+go:
+  - 1.11.2
+
+script:
+  - go build ./...
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -1,214 +1,650 @@
 {
 	"ImportPath": "k8s.io/client-go",
-	"GoVersion": "unknown",
-	"GodepVersion": "gen-godeps",
+	"GoVersion": "go1.12",
+	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
 	],
 	"Deps": [
 		{
-			"ImportPath": "cloud.google.com/go",
-			"Rev": "v0.34.0"
+			"ImportPath": "cloud.google.com/go/compute/metadata",
+			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
 		},
 		{
-			"ImportPath": "github.com/Azure/go-autorest",
-			"Rev": "v11.1.2"
+			"ImportPath": "cloud.google.com/go/internal",
+			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
 		},
 		{
-			"ImportPath": "github.com/davecgh/go-spew",
-			"Rev": "v1.1.1"
+			"ImportPath": "github.com/Azure/go-autorest/autorest",
+			"Rev": "ea233b6412b0421a65dc6160e16c893364664a95"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/adal",
+			"Rev": "ea233b6412b0421a65dc6160e16c893364664a95"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/azure",
+			"Rev": "ea233b6412b0421a65dc6160e16c893364664a95"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/date",
+			"Rev": "ea233b6412b0421a65dc6160e16c893364664a95"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/logger",
+			"Rev": "ea233b6412b0421a65dc6160e16c893364664a95"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/version",
+			"Rev": "ea233b6412b0421a65dc6160e16c893364664a95"
+		},
+		{
+			"ImportPath": "github.com/davecgh/go-spew/spew",
+			"Rev": "782f4967f2dc4564575ca782fe2d04090b5faca8"
 		},
 		{
 			"ImportPath": "github.com/dgrijalva/jwt-go",
-			"Rev": "01aeca54ebda"
+			"Rev": "01aeca54ebda6e0fbfafd0a524d234159c05ec20"
 		},
 		{
 			"ImportPath": "github.com/docker/spdystream",
-			"Rev": "449fdfce4d96"
+			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
 		},
 		{
-			"ImportPath": "github.com/elazarl/goproxy",
-			"Rev": "c4fc26588b6e"
+			"ImportPath": "github.com/docker/spdystream/spdy",
+			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
 		},
 		{
 			"ImportPath": "github.com/evanphx/json-patch",
-			"Rev": "5858425f7550"
+			"Rev": "5858425f75500d40c52783dce87d085a483ce135"
 		},
 		{
-			"ImportPath": "github.com/fsnotify/fsnotify",
-			"Rev": "v1.4.7"
+			"ImportPath": "github.com/gogo/protobuf/proto",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
-			"ImportPath": "github.com/gogo/protobuf",
-			"Rev": "342cbe0a0415"
+			"ImportPath": "github.com/gogo/protobuf/sortkeys",
+			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
 		},
 		{
-			"ImportPath": "github.com/golang/groupcache",
-			"Rev": "02826c3e7903"
+			"ImportPath": "github.com/golang/groupcache/lru",
+			"Rev": "02826c3e79038b59d737d3b1c0a1d937f71a4433"
 		},
 		{
-			"ImportPath": "github.com/golang/protobuf",
-			"Rev": "v1.2.0"
+			"ImportPath": "github.com/golang/protobuf/proto",
+			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
+		},
+		{
+			"ImportPath": "github.com/golang/protobuf/ptypes",
+			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
+		},
+		{
+			"ImportPath": "github.com/golang/protobuf/ptypes/any",
+			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
+		},
+		{
+			"ImportPath": "github.com/golang/protobuf/ptypes/duration",
+			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
+		},
+		{
+			"ImportPath": "github.com/golang/protobuf/ptypes/timestamp",
+			"Rev": "b4deda0973fb4c70b50d226b1af49f3da59f5265"
 		},
 		{
 			"ImportPath": "github.com/google/btree",
-			"Rev": "7d79101e329e"
-		},
-		{
-			"ImportPath": "github.com/google/go-cmp",
-			"Rev": "v0.3.0"
+			"Rev": "7d79101e329e5a3adf994758c578dab82b90c017"
 		},
 		{
 			"ImportPath": "github.com/google/gofuzz",
-			"Rev": "24818f796faf"
+			"Rev": "24818f796faf91cd76ec7bddd72458fbced7a6c1"
 		},
 		{
-			"ImportPath": "github.com/google/uuid",
-			"Rev": "v1.0.0"
+			"ImportPath": "github.com/googleapis/gnostic/OpenAPIv2",
+			"Rev": "0c5108395e2debce0d731cf0287ddf7242066aba"
 		},
 		{
-			"ImportPath": "github.com/googleapis/gnostic",
-			"Rev": "0c5108395e2d"
+			"ImportPath": "github.com/googleapis/gnostic/compiler",
+			"Rev": "0c5108395e2debce0d731cf0287ddf7242066aba"
+		},
+		{
+			"ImportPath": "github.com/googleapis/gnostic/extensions",
+			"Rev": "0c5108395e2debce0d731cf0287ddf7242066aba"
 		},
 		{
 			"ImportPath": "github.com/gophercloud/gophercloud",
-			"Rev": "c818fa66e4c8"
+			"Rev": "c818fa66e4c88b30db28038fe3f18f2f4a0db9a8"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack",
+			"Rev": "c818fa66e4c88b30db28038fe3f18f2f4a0db9a8"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v2/tenants",
+			"Rev": "c818fa66e4c88b30db28038fe3f18f2f4a0db9a8"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v2/tokens",
+			"Rev": "c818fa66e4c88b30db28038fe3f18f2f4a0db9a8"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v3/tokens",
+			"Rev": "c818fa66e4c88b30db28038fe3f18f2f4a0db9a8"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack/utils",
+			"Rev": "c818fa66e4c88b30db28038fe3f18f2f4a0db9a8"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/pagination",
+			"Rev": "c818fa66e4c88b30db28038fe3f18f2f4a0db9a8"
 		},
 		{
 			"ImportPath": "github.com/gregjones/httpcache",
-			"Rev": "787624de3eb7"
+			"Rev": "787624de3eb7bd915c329cba748687a3b22666a6"
+		},
+		{
+			"ImportPath": "github.com/gregjones/httpcache/diskcache",
+			"Rev": "787624de3eb7bd915c329cba748687a3b22666a6"
 		},
 		{
 			"ImportPath": "github.com/hashicorp/golang-lru",
-			"Rev": "v0.5.0"
+			"Rev": "20f1fb78b0740ba8c3cb143a61e86ba5c8669768"
 		},
 		{
-			"ImportPath": "github.com/hpcloud/tail",
-			"Rev": "v1.0.0"
+			"ImportPath": "github.com/hashicorp/golang-lru/simplelru",
+			"Rev": "20f1fb78b0740ba8c3cb143a61e86ba5c8669768"
 		},
 		{
 			"ImportPath": "github.com/imdario/mergo",
-			"Rev": "v0.3.5"
+			"Rev": "9316a62528ac99aaecb4e47eadd6dc8aa6533d58"
 		},
 		{
 			"ImportPath": "github.com/json-iterator/go",
-			"Rev": "ab8a2e0c74be"
+			"Rev": "ab8a2e0c74be9d3be70b3184d9acc634935ded82"
 		},
 		{
 			"ImportPath": "github.com/modern-go/concurrent",
-			"Rev": "bacd9c7ef1dd"
+			"Rev": "bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94"
 		},
 		{
 			"ImportPath": "github.com/modern-go/reflect2",
-			"Rev": "v1.0.1"
-		},
-		{
-			"ImportPath": "github.com/mxk/go-flowrate",
-			"Rev": "cca7078d478f"
-		},
-		{
-			"ImportPath": "github.com/onsi/ginkgo",
-			"Rev": "v1.6.0"
-		},
-		{
-			"ImportPath": "github.com/onsi/gomega",
-			"Rev": "5533ce8a0da3"
+			"Rev": "94122c33edd36123c84d5368cfb2b69df93a0ec8"
 		},
 		{
 			"ImportPath": "github.com/peterbourgon/diskv",
-			"Rev": "v2.0.1"
+			"Rev": "5f041e8faa004a95c88a202771f4cc3e991971e6"
 		},
 		{
-			"ImportPath": "github.com/pmezard/go-difflib",
-			"Rev": "v1.0.0"
+			"ImportPath": "github.com/pmezard/go-difflib/difflib",
+			"Rev": "5d4384ee4fb2527b0a1256a821ebfc92f91efefc"
 		},
 		{
 			"ImportPath": "github.com/spf13/pflag",
-			"Rev": "v1.0.1"
+			"Rev": "583c0c0531f06d5278b7d917446061adc344b5cd"
 		},
 		{
-			"ImportPath": "github.com/stretchr/testify",
-			"Rev": "v1.2.2"
+			"ImportPath": "github.com/stretchr/testify/assert",
+			"Rev": "c679ae2cc0cb27ec3293fea7e254e47386f05d69"
 		},
 		{
-			"ImportPath": "golang.org/x/crypto",
-			"Rev": "e84da0312774"
+			"ImportPath": "golang.org/x/crypto/ssh/terminal",
+			"Rev": "de0752318171da717af4ce24d0a2e8626afaeb11"
 		},
 		{
-			"ImportPath": "golang.org/x/net",
-			"Rev": "cdfb69ac37fc"
+			"ImportPath": "golang.org/x/net/context",
+			"Rev": "65e2d4e15006aab9813ff8769e768bbf4bb667a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/context/ctxhttp",
+			"Rev": "65e2d4e15006aab9813ff8769e768bbf4bb667a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/http/httpguts",
+			"Rev": "65e2d4e15006aab9813ff8769e768bbf4bb667a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/http2",
+			"Rev": "65e2d4e15006aab9813ff8769e768bbf4bb667a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/http2/hpack",
+			"Rev": "65e2d4e15006aab9813ff8769e768bbf4bb667a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/idna",
+			"Rev": "65e2d4e15006aab9813ff8769e768bbf4bb667a0"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "9f3314589c9a"
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/sync",
-			"Rev": "42b317875d0f"
+			"ImportPath": "golang.org/x/oauth2/google",
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/sys",
-			"Rev": "3b5209105503"
+			"ImportPath": "golang.org/x/oauth2/internal",
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/text",
-			"Rev": "e6919f6577db"
+			"ImportPath": "golang.org/x/oauth2/jws",
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/time",
-			"Rev": "f51c12702a4d"
+			"ImportPath": "golang.org/x/oauth2/jwt",
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/tools",
-			"Rev": "aa82965741a9"
+			"ImportPath": "golang.org/x/sys/unix",
+			"Rev": "95c6576299259db960f6c5b9b69ea52422860fce"
 		},
 		{
-			"ImportPath": "google.golang.org/appengine",
-			"Rev": "v1.5.0"
+			"ImportPath": "golang.org/x/sys/windows",
+			"Rev": "95c6576299259db960f6c5b9b69ea52422860fce"
 		},
 		{
-			"ImportPath": "gopkg.in/check.v1",
-			"Rev": "20d25e280405"
+			"ImportPath": "golang.org/x/text/secure/bidirule",
+			"Rev": "b19bf474d317b857955b12035d2c5acb57ce8b01"
 		},
 		{
-			"ImportPath": "gopkg.in/fsnotify.v1",
-			"Rev": "v1.4.7"
+			"ImportPath": "golang.org/x/text/transform",
+			"Rev": "b19bf474d317b857955b12035d2c5acb57ce8b01"
+		},
+		{
+			"ImportPath": "golang.org/x/text/unicode/bidi",
+			"Rev": "b19bf474d317b857955b12035d2c5acb57ce8b01"
+		},
+		{
+			"ImportPath": "golang.org/x/text/unicode/norm",
+			"Rev": "b19bf474d317b857955b12035d2c5acb57ce8b01"
+		},
+		{
+			"ImportPath": "golang.org/x/time/rate",
+			"Rev": "f51c12702a4d776e4c1fa9b0fabab841babae631"
 		},
 		{
 			"ImportPath": "gopkg.in/inf.v0",
-			"Rev": "v0.9.0"
-		},
-		{
-			"ImportPath": "gopkg.in/tomb.v1",
-			"Rev": "dd632973f1e7"
+			"Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
 		},
 		{
 			"ImportPath": "gopkg.in/yaml.v2",
-			"Rev": "v2.2.8"
+			"Rev": "5420a8b6744d3b0345ab293f6fcba19c978f1183"
 		},
 		{
-			"ImportPath": "k8s.io/api",
-			"Rev": "v0.15.10"
+			"ImportPath": "k8s.io/api/admissionregistration/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
 		},
 		{
-			"ImportPath": "k8s.io/apimachinery",
-			"Rev": "v0.15.10"
+			"ImportPath": "k8s.io/api/apps/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/apps/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/apps/v1beta2",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/auditregistration/v1alpha1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/authentication/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/authentication/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/authorization/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/authorization/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/autoscaling/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/autoscaling/v2beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/autoscaling/v2beta2",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/batch/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/batch/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/batch/v2alpha1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/certificates/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/coordination/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/coordination/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/core/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/events/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/extensions/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/imagepolicy/v1alpha1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/networking/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/networking/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/node/v1alpha1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/node/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/policy/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/rbac/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/rbac/v1alpha1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/rbac/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/scheduling/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/scheduling/v1alpha1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/scheduling/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/settings/v1alpha1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/storage/v1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/storage/v1alpha1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/api/storage/v1beta1",
+			"Rev": "40a48860b5abbba9aa891b02b32da429b08d96a0"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/apitesting",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/apitesting/fuzzer",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/apitesting/roundtrip",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/equality",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/errors",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/meta",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/resource",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/fuzzer",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/internalversion",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1beta1",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/conversion",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/fields",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/labels",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/schema",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/selection",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/types",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/cache",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/clock",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/diff",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/errors",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/framer",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream/spdy",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/intstr",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/json",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/naming",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/net",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/remotecommand",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/runtime",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/sets",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/validation",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/validation/field",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/wait",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/yaml",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/version",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/watch",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/netutil",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect",
+			"Rev": "d7deff9243b165ee192f5551710ea4285dcfd615"
 		},
 		{
 			"ImportPath": "k8s.io/klog",
-			"Rev": "v0.3.1"
+			"Rev": "8e90cee79f823779174776412c13478955131846"
 		},
 		{
-			"ImportPath": "k8s.io/kube-openapi",
-			"Rev": "b3a7cee44a30"
+			"ImportPath": "k8s.io/kube-openapi/pkg/util/proto",
+			"Rev": "b3a7cee44a305be0a69e1b9ac03018307287e1b0"
 		},
 		{
-			"ImportPath": "k8s.io/utils",
-			"Rev": "c2654d5206da"
+			"ImportPath": "k8s.io/utils/buffer",
+			"Rev": "c2654d5206da6b7b6ace12841e8f359bb89b443c"
+		},
+		{
+			"ImportPath": "k8s.io/utils/integer",
+			"Rev": "c2654d5206da6b7b6ace12841e8f359bb89b443c"
+		},
+		{
+			"ImportPath": "k8s.io/utils/trace",
+			"Rev": "c2654d5206da6b7b6ace12841e8f359bb89b443c"
 		},
 		{
 			"ImportPath": "sigs.k8s.io/yaml",
-			"Rev": "v1.1.0"
+			"Rev": "fd68e9863619f6ec2fdd8625fe1f02e7c877e480"
 		}
 	]
-}
+}
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -3,48 +3,35 @@
 ## For the casual user

 If you want to write a simple script, don't care about a reproducible client
-library install, don't mind getting HEAD (which may be less stable than a
+library install, don't mind getting head (which may be less stable than a
 particular release), then simply:

 ```sh
-go get k8s.io/client-go@master
+$ go get k8s.io/client-go/...
 ```

-This will record a dependency on `k8s.io/client-go` in your go module.
-You can now import and use the `k8s.io/client-go` APIs in your project.
-The next time you `go build`, `go test`, or `go run` your project,
-`k8s.io/client-go` and its dependencies will be downloaded (if needed),
-and detailed dependency version info will be added to your `go.mod` file
-(or you can also run `go mod tidy` to do this directly).
-
-This assumes you are using go modules with go 1.11+.
-If you get a message like `cannot use path@version syntax in GOPATH mode`,
-you can choose to [opt into using go modules](#go-modules).
-If you are using a version of go prior to 1.11, or do not wish to use 
-go modules, you can download `k8s.io/client-go` to your `$GOPATH` instead:
+This will install `k8s.io/client-go` in your `$GOPATH`. `k8s.io/client-go`
+includes most of its own dependencies in its `k8s.io/client-go/vendor` path,
+except for `k8s.io/apimachinery` and `glog`. `go get` will recursively download
+these excluded repos to your `$GOPATH`, if they don't already exist. If
+`k8s.io/apimachinery` preexisted in `$GOPATH`, you also need to:

 ```sh
-go get -u k8s.io/client-go/...
-go get -u k8s.io/apimachinery/...
-cd $GOPATH/src/k8s.io/client-go
-git checkout v11.0.0
-cd $GOPATH/src/k8s.io/apimachinery
-git checkout kubernetes-1.14.0
+$ go get -u k8s.io/apimachinery/...
 ```

-This downloads a version of `k8s.io/client-go` prior to v1.12.0,
-which includes most of its dependencies in its `k8s.io/client-go/vendor` path
-(except for `k8s.io/apimachinery` and `glog`).
+because the head of client-go is only guaranteed to work with the head of
+apimachinery.

 We excluded `k8s.io/apimachinery` and `glog` from `k8s.io/client-go/vendor` to
 prevent `go get` users from hitting issues like
 [#19](https://github.com/kubernetes/client-go/issues/19) and
-[#83](https://github.com/kubernetes/client-go/issues/83). If your project shares
+[#83](https://github.com/kubernetes/client-go/issues/83). If your project share
 other dependencies with client-go, and you hit issues similar to #19 or #83,
 then you'll need to look down at the next section.

 Note: the official go policy is that libraries should not vendor their
-dependencies. This was unworkable for us, since our dependencies change and HEAD
+dependencies. This is unworkable for us, since our dependencies change and HEAD
 on every dependency has not necessarily been tested with client-go. In fact,
 HEAD from all dependencies may not even compile with client-go!

@@ -62,46 +49,39 @@ Reasons why you might need to use a dependency management system:
 There are three tools you could in theory use for this. Instructions
 for each follows.

-### Go modules
+### Godep

-Dependency management tools are built into go 1.11+ in the form of [go modules](https://github.com/golang/go/wiki/Modules).
-These are used by the main Kubernetes repo (>= 1.15) and `client-go` (on master, and v12.0.0+ once released) to manage dependencies.
-When using `client-go` v12.0.0+ and go 1.11.4+, go modules are the recommended dependency management tool.
+[godep](https://github.com/tools/godep) is an older dependency management tool, which is
+used by the main Kubernetes repo and `client-go` to manage dependencies.

-If you are using go 1.11 or 1.12 and are working with a project located within `$GOPATH`,
-you must opt into using go modules:
+Before proceeding with the below instructions, you should ensure that your
+$GOPATH is empty except for containing your own package and its dependencies,
+and you have a copy of godep somewhere in your $PATH.
+
+To install `client-go` and place its dependencies in your `$GOPATH`:

 ```sh
-export GO111MODULE=on
+go get k8s.io/client-go/...
+cd $GOPATH/src/k8s.io/client-go
+git checkout v9.0.0 # replace v9.0.0 with the required version
+# cd 1.5 # only necessary with 1.5 and 1.4 clients.
+godep restore ./...
 ```

-Ensure your project has a `go.mod` file defined at the root of your project.
-If you do not already have one, `go mod init` will create one for you:
+At this point, `client-go`'s dependencies have been placed in your $GOPATH, but
+if you were to build, `client-go` would still see its own copy of its
+dependencies in its `vendor` directory. You have two options at this point.
+
+If you would like to keep dependencies in your own project's vendor directory,
+then you can continue like this:

 ```sh
-go mod init
+cd $GOPATH/src/<my-pkg>
+godep save ./...
 ```

-Indicate which version of `client-go` your project requires.
-For `client-go` on master (and once version v12.0.0 is released), this is a single step:
-
-```sh
-go get k8s.io/client-go@master # or v12.0.0+ once released
-```
-
-For `client-go` prior to v12.0.0, you also need to indicate the required versions of `k8s.io/api` and `k8s.io/apimachinery`:
-
-```sh
-go get k8s.io/client-go@v11.0.0              # replace v11.0.0 with the required version (or use kubernetes-1.x.y tags if desired)
-go get k8s.io/api@kubernetes-1.14.0          # replace kubernetes-1.14.0 with the required version
-go get k8s.io/apimachinery@kubernetes-1.14.0 # replace kubernetes-1.14.0 with the required version
-```
-
-You can now import and use the `k8s.io/client-go` APIs in your project.
-The next time you `go build`, `go test`, or `go run` your project,
-`k8s.io/client-go` and its dependencies will be downloaded (if needed),
-and detailed dependency version info will be added to your `go.mod` file
-(or you can also run `go mod tidy` to do this directly).
+Alternatively, if you want to build using the dependencies in your `$GOPATH`,
+then `rm -rf vendor/` to remove `client-go`'s copy of its dependencies.

 ### Glide

@@ -119,7 +99,7 @@ your project:
 package: ( your project's import path ) # e.g. github.com/foo/bar
 import:
 - package: k8s.io/client-go
-  version: v11.0.0 # replace v11.0.0 with the required version
+  version: v9.0.0 # replace v9.0.0 with the required version
 ```

 Second, add a Go file that imports `client-go` somewhere in your project,
@@ -152,7 +132,7 @@ requests can override the version manually in `glide.yaml`. For example:
 package: ( your project's import path ) # e.g. github.com/foo/bar
 import:
 - package: k8s.io/client-go
-  version: v11.0.0 # replace v11.0.0 with the required version
+  version: v9.0.0 # replace v9.0.0 with the required version
 # Use a newer version of go-spew even though client-go wants an old one.
 - package: github.com/davecgh/go-spew
  version: v1.1.0
@@ -163,36 +143,20 @@ After modifying, run `glide up -v` again to re-populate your /vendor directory.
 Optionally, Glide users can also use [`glide-vc`](https://github.com/sgotti/glide-vc)
 after running `glide up -v` to remove unused files from /vendor.

-### Godep
+### Dep (Not supported yet!)

-[godep](https://github.com/tools/godep) is an older dependency management tool, which was
-used by the main Kubernetes repo (<= 1.14) and `client-go` (<= v11.0) to manage dependencies.
+[dep](https://github.com/golang/dep) is an up-and-coming dependency management
+tool, which has the goal of being accepted as part of the standard go toolchain.
+However, client-go does **NOT** work well with `dep` yet. To support `dep`, we
+need to fix at least two issues:
+1. publish native `Gopkg.toml` in client-go and other k8s.io repos, like `k8s.io/apimachinery`;
+2. find a way to express transitive constraints (see https://github.com/golang/dep/issues/1124).

-Before proceeding with the below instructions, you should ensure that your
-$GOPATH is empty except for containing your own package and its dependencies,
-and you have a copy of godep somewhere in your $PATH.
+As a workaround, which may or may not be worthwhile, you can specify all
+client-go dependencies manually as
+[override](https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md#override)
+in Gopkg.toml with the versions listed in [Godeps.json](./Godeps/Godeps.json),
+and manually update them when you upgrade client-go version.

-To install `client-go` and place its dependencies in your `$GOPATH`:
-
-```sh
-go get k8s.io/client-go/...
-cd $GOPATH/src/k8s.io/client-go
-git checkout v11.0.0 # v11.0.0 or older
-# cd 1.5 # only necessary with 1.5 and 1.4 clients.
-godep restore ./...
-```
-
-At this point, `client-go`'s dependencies have been placed in your $GOPATH, but
-if you were to build, `client-go` would still see its own copy of its
-dependencies in its `vendor` directory. You have two options at this point.
-
-If you would like to keep dependencies in your own project's vendor directory,
-then you can continue like this:
-
-```sh
-cd $GOPATH/src/<my-pkg>
-godep save ./...
-```
-
-Alternatively, if you want to build using the dependencies in your `$GOPATH`,
-then `rm -rf vendor/` to remove `client-go`'s copy of its dependencies.
+We are actively working on the two issues blocking using `dep`. For the
+meantime, we recommend using `glide` or `godeps`.
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@

 Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.

-We currently recommend using the v11.0.0 tag. See [INSTALL.md](/INSTALL.md) for
+We currently recommend using the v10.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.

@@ -92,16 +92,16 @@ We will backport bugfixes--but not new features--into older versions of

 #### Compatibility matrix

-|                     | Kubernetes 1.8 | Kubernetes 1.9 | Kubernetes 1.10 | Kubernetes 1.11 | Kubernetes 1.12 | Kubernetes 1.13 | Kubernetes 1.14 |
-|---------------------|----------------|----------------|-----------------|-----------------|-----------------|-----------------|-----------------|
-| client-go 5.0       | ✓              | +-             | +-              | +-              | +-              | +-              | +-              |
-| client-go 6.0       | +-             | ✓              | +-              | +-              | +-              | +-              | +-              |
-| client-go 7.0       | +-             | +-             | ✓               | +-              | +-              | +-              | +-              |
-| client-go 8.0       | +-             | +-             | +-              | ✓               | +-              | +-              | +-              |
-| client-go 9.0       | +-             | +-             | +-              | +-              | ✓               | +-              | +-              |
-| client-go 10.0      | +-             | +-             | +-              | +-              | +-              | ✓               | +-              |
-| client-go 11.0      | +-             | +-             | +-              | +-              | +-              | +-              | ✓               |
-| client-go HEAD      | +-             | +-             | +-              | +-              | +-              | +-              | +-              |
+|                     | Kubernetes 1.7 | Kubernetes 1.8 | Kubernetes 1.9 | Kubernetes 1.10 | Kubernetes 1.11 | Kubernetes 1.12 | Kubernetes 1.13 |
+|---------------------|----------------|----------------|----------------|-----------------|-----------------|-----------------|-----------------|
+| client-go 4.0       | ✓              | +-             | +-             | +-              | +-              | +-              | +-              |
+| client-go 5.0       | +-             | ✓              | +-             | +-              | +-              | +-              | +-              |
+| client-go 6.0       | +-             | +-             | ✓              | +-              | +-              | +-              | +-              |
+| client-go 7.0       | +-             | +-             | +-             | ✓               | +-              | +-              | +-              |
+| client-go 8.0       | +-             | +-             | +-             | +-              | ✓               | +-              | +-              |
+| client-go 9.0       | +-             | +-             | +-             | +-              | +-              | ✓               | +-              |
+| client-go 10.0      | +-             | +-             | +-             | +-              | +-              | +-              | ✓               |
+| client-go HEAD      | +-             | +-             | +-             | +-              | +-              | +-              | +-              |

 Key:

@@ -130,10 +130,9 @@ between client-go versions.
 | client-go 5.0  | Kubernetes main repo, 1.8 branch     | = -                           |
 | client-go 6.0  | Kubernetes main repo, 1.9 branch     | = -                           |
 | client-go 7.0  | Kubernetes main repo, 1.10 branch    | = -                           |
-| client-go 8.0  | Kubernetes main repo, 1.11 branch    | =-                            |
+| client-go 8.0  | Kubernetes main repo, 1.11 branch    | ✓                             |
 | client-go 9.0  | Kubernetes main repo, 1.12 branch    | ✓                             |
 | client-go 10.0 | Kubernetes main repo, 1.13 branch    | ✓                             |
-| client-go 11.0 | Kubernetes main repo, 1.14 branch    | ✓                             |
 | client-go HEAD | Kubernetes main repo, master branch  | ✓                             |

 Key:
@@ -188,7 +187,9 @@ refer to the out-of-cluster [example](examples/out-of-cluster-client-configurati

 ### Dependency management

-For details on how to correctly use a dependency management for installing client-go, please see [INSTALL.md](INSTALL.md).
+If your application depends on a package that client-go depends on, and you let the Go compiler find the dependency in `GOPATH`, you will end up with duplicated dependencies: one copy from the `GOPATH`, and one from the vendor folder of client-go. This will cause unexpected runtime error like flag redefinition, since the go compiler ends up importing both packages separately, even if they are exactly the same thing. If this happens, you can either
+* run `godep restore` ([godep](https://github.com/tools/godep)) in the client-go/ folder, then remove the vendor folder of client-go. Then the packages in your GOPATH will be the only copy
+* or run `godep save` in your application folder to flatten all dependencies.

 ### Contributing code
 Please send pull requests against the client packages in the Kubernetes main [repository](https://github.com/kubernetes/kubernetes). Changes in the staging area will be published to this repository every day.
--- a/deprecated-dynamic/bad_debt.go
+++ b/deprecated-dynamic/bad_debt.go
@@ -59,9 +59,15 @@ func (dynamicCodec) Encode(obj runtime.Object, w io.Writer) error {
 // ContentConfig returns a rest.ContentConfig for dynamic types.
 // Deprecated only used by test code and its wrong
 func ContentConfig() rest.ContentConfig {
+	var jsonInfo runtime.SerializerInfo
 	// TODO: scheme.Codecs here should become "pkg/apis/server/scheme" which is the minimal core you need
 	// to talk to a kubernetes server
-	jsonInfo, _ := runtime.SerializerInfoForMediaType(scheme.Codecs.SupportedMediaTypes(), runtime.ContentTypeJSON)
+	for _, info := range scheme.Codecs.SupportedMediaTypes() {
+		if info.MediaType == runtime.ContentTypeJSON {
+			jsonInfo = info
+			break
+		}
+	}

 	jsonInfo.Serializer = dynamicCodec{}
 	jsonInfo.PrettySerializer = nil
--- a/discovery/cached/disk/cached_discovery.go
+++ b/discovery/cached/disk/cached_discovery.go
@@ -172,7 +172,7 @@ func (d *CachedDiscoveryClient) getCachedFile(filename string) ([]byte, error) {
 }

 func (d *CachedDiscoveryClient) writeCachedFile(filename string, obj runtime.Object) error {
-	if err := os.MkdirAll(filepath.Dir(filename), 0750); err != nil {
+	if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
 		return err
 	}

@@ -191,7 +191,7 @@ func (d *CachedDiscoveryClient) writeCachedFile(filename string, obj runtime.Obj
 		return err
 	}

-	err = os.Chmod(f.Name(), 0660)
+	err = os.Chmod(f.Name(), 0755)
 	if err != nil {
 		return err
 	}
--- a/discovery/cached/disk/cached_discovery_test.go
+++ b/discovery/cached/disk/cached_discovery_test.go
@@ -19,7 +19,6 @@ package disk
 import (
 	"io/ioutil"
 	"os"
-	"path/filepath"
 	"testing"
 	"time"

@@ -97,32 +96,6 @@ func TestNewCachedDiscoveryClient_TTL(t *testing.T) {
 	assert.Equal(c.groupCalls, 2)
 }

-func TestNewCachedDiscoveryClient_PathPerm(t *testing.T) {
-	assert := assert.New(t)
-
-	d, err := ioutil.TempDir("", "")
-	assert.NoError(err)
-	os.RemoveAll(d)
-	defer os.RemoveAll(d)
-
-	c := fakeDiscoveryClient{}
-	cdc := newCachedDiscoveryClient(&c, d, 1*time.Nanosecond)
-	cdc.ServerGroups()
-
-	err = filepath.Walk(d, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if info.IsDir() {
-			assert.Equal(os.FileMode(0750), info.Mode().Perm())
-		} else {
-			assert.Equal(os.FileMode(0660), info.Mode().Perm())
-		}
-		return nil
-	})
-	assert.NoError(err)
-}
-
 type fakeDiscoveryClient struct {
 	groupCalls    int
 	resourceCalls int
--- a/discovery/cached/disk/round_tripper.go
+++ b/discovery/cached/disk/round_tripper.go
@@ -18,7 +18,6 @@ package disk

 import (
 	"net/http"
-	"os"
 	"path/filepath"

 	"github.com/gregjones/httpcache"
@@ -36,8 +35,6 @@ type cacheRoundTripper struct {
 // corresponding requests.
 func newCacheRoundTripper(cacheDir string, rt http.RoundTripper) http.RoundTripper {
 	d := diskv.New(diskv.Options{
-		PathPerm: os.FileMode(0750),
-		FilePerm: os.FileMode(0660),
 		BasePath: cacheDir,
 		TempDir:  filepath.Join(cacheDir, ".diskv-temp"),
 	})
--- a/discovery/cached/disk/round_tripper_test.go
+++ b/discovery/cached/disk/round_tripper_test.go
@@ -22,10 +22,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
-	"path/filepath"
 	"testing"
-
-	"github.com/stretchr/testify/assert"
 )

 // copied from k8s.io/client-go/transport/round_trippers_test.go
@@ -96,52 +93,3 @@ func TestCacheRoundTripper(t *testing.T) {
 		t.Errorf("Invalid content read from cache %q", string(content))
 	}
 }
-
-func TestCacheRoundTripperPathPerm(t *testing.T) {
-	assert := assert.New(t)
-
-	rt := &testRoundTripper{}
-	cacheDir, err := ioutil.TempDir("", "cache-rt")
-	os.RemoveAll(cacheDir)
-	defer os.RemoveAll(cacheDir)
-
-	if err != nil {
-		t.Fatal(err)
-	}
-	cache := newCacheRoundTripper(cacheDir, rt)
-
-	// First call, caches the response
-	req := &http.Request{
-		Method: http.MethodGet,
-		URL:    &url.URL{Host: "localhost"},
-	}
-	rt.Response = &http.Response{
-		Header:     http.Header{"ETag": []string{`"123456"`}},
-		Body:       ioutil.NopCloser(bytes.NewReader([]byte("Content"))),
-		StatusCode: http.StatusOK,
-	}
-	resp, err := cache.RoundTrip(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	content, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "Content" {
-		t.Errorf(`Expected Body to be "Content", got %q`, string(content))
-	}
-
-	err = filepath.Walk(cacheDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if info.IsDir() {
-			assert.Equal(os.FileMode(0750), info.Mode().Perm())
-		} else {
-			assert.Equal(os.FileMode(0660), info.Mode().Perm())
-		}
-		return nil
-	})
-	assert.NoError(err)
-}
--- a/dynamic/dynamicinformer/informer.go
+++ b/dynamic/dynamicinformer/informer.go
@@ -42,7 +42,7 @@ func NewFilteredDynamicSharedInformerFactory(client dynamic.Interface, defaultRe
 	return &dynamicSharedInformerFactory{
 		client:           client,
 		defaultResync:    defaultResync,
-		namespace:        namespace,
+		namespace:        metav1.NamespaceAll,
 		informers:        map[schema.GroupVersionResource]informers.GenericInformer{},
 		startedInformers: make(map[schema.GroupVersionResource]bool),
 		tweakListOptions: tweakListOptions,
--- a/dynamic/scheme.go
+++ b/dynamic/scheme.go
@@ -43,8 +43,6 @@ func init() {

 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),
@@ -79,8 +77,6 @@ func (s basicNegotiatedSerializer) SupportedMediaTypes() []runtime.SerializerInf
 	return []runtime.SerializerInfo{
 		{
 			MediaType:        "application/json",
-			MediaTypeType:    "application",
-			MediaTypeSubType: "json",
 			EncodesAsText:    true,
 			Serializer:       json.NewSerializer(json.DefaultMetaFactory, basicScheme, basicScheme, false),
 			PrettySerializer: json.NewSerializer(json.DefaultMetaFactory, basicScheme, basicScheme, true),
--- a/dynamic/simple.go
+++ b/dynamic/simple.go
@@ -17,7 +17,6 @@ limitations under the License.
 package dynamic

 import (
-	"fmt"
 	"io"

 	"k8s.io/apimachinery/pkg/api/meta"
@@ -37,19 +36,6 @@ type dynamicClient struct {

 var _ Interface = &dynamicClient{}

-// ConfigFor returns a copy of the provided config with the
-// appropriate dynamic client defaults set.
-func ConfigFor(inConfig *rest.Config) *rest.Config {
-	config := rest.CopyConfig(inConfig)
-	config.AcceptContentTypes = "application/json"
-	config.ContentType = "application/json"
-	config.NegotiatedSerializer = basicNegotiatedSerializer{} // this gets used for discovery and error handling types
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	return config
-}
-
 // NewForConfigOrDie creates a new Interface for the given config and
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) Interface {
@@ -60,12 +46,17 @@ func NewForConfigOrDie(c *rest.Config) Interface {
 	return ret
 }

-// NewForConfig creates a new dynamic client or returns an error.
 func NewForConfig(inConfig *rest.Config) (Interface, error) {
-	config := ConfigFor(inConfig)
+	config := rest.CopyConfig(inConfig)
 	// for serializing the options
 	config.GroupVersion = &schema.GroupVersion{}
 	config.APIPath = "/if-you-see-this-search-for-the-break"
+	config.AcceptContentTypes = "application/json"
+	config.ContentType = "application/json"
+	config.NegotiatedSerializer = basicNegotiatedSerializer{} // this gets used for discovery and error handling types
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}

 	restClient, err := rest.RESTClientFor(config)
 	if err != nil {
@@ -103,9 +94,6 @@ func (c *dynamicResourceClient) Create(obj *unstructured.Unstructured, opts meta
 			return nil, err
 		}
 		name = accessor.GetName()
-		if len(name) == 0 {
-			return nil, fmt.Errorf("name is required")
-		}
 	}

 	result := c.client.client.
@@ -134,10 +122,6 @@ func (c *dynamicResourceClient) Update(obj *unstructured.Unstructured, opts meta
 	if err != nil {
 		return nil, err
 	}
-	name := accessor.GetName()
-	if len(name) == 0 {
-		return nil, fmt.Errorf("name is required")
-	}
 	outBytes, err := runtime.Encode(unstructured.UnstructuredJSONScheme, obj)
 	if err != nil {
 		return nil, err
@@ -145,7 +129,7 @@ func (c *dynamicResourceClient) Update(obj *unstructured.Unstructured, opts meta

 	result := c.client.client.
 		Put().
-		AbsPath(append(c.makeURLSegments(name), subresources...)...).
+		AbsPath(append(c.makeURLSegments(accessor.GetName()), subresources...)...).
 		Body(outBytes).
 		SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
 		Do()
@@ -169,10 +153,6 @@ func (c *dynamicResourceClient) UpdateStatus(obj *unstructured.Unstructured, opt
 	if err != nil {
 		return nil, err
 	}
-	name := accessor.GetName()
-	if len(name) == 0 {
-		return nil, fmt.Errorf("name is required")
-	}

 	outBytes, err := runtime.Encode(unstructured.UnstructuredJSONScheme, obj)
 	if err != nil {
@@ -181,7 +161,7 @@ func (c *dynamicResourceClient) UpdateStatus(obj *unstructured.Unstructured, opt

 	result := c.client.client.
 		Put().
-		AbsPath(append(c.makeURLSegments(name), "status")...).
+		AbsPath(append(c.makeURLSegments(accessor.GetName()), "status")...).
 		Body(outBytes).
 		SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
 		Do()
@@ -201,9 +181,6 @@ func (c *dynamicResourceClient) UpdateStatus(obj *unstructured.Unstructured, opt
 }

 func (c *dynamicResourceClient) Delete(name string, opts *metav1.DeleteOptions, subresources ...string) error {
-	if len(name) == 0 {
-		return fmt.Errorf("name is required")
-	}
 	if opts == nil {
 		opts = &metav1.DeleteOptions{}
 	}
@@ -239,9 +216,6 @@ func (c *dynamicResourceClient) DeleteCollection(opts *metav1.DeleteOptions, lis
 }

 func (c *dynamicResourceClient) Get(name string, opts metav1.GetOptions, subresources ...string) (*unstructured.Unstructured, error) {
-	if len(name) == 0 {
-		return nil, fmt.Errorf("name is required")
-	}
 	result := c.client.client.Get().AbsPath(append(c.makeURLSegments(name), subresources...)...).SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).Do()
 	if err := result.Error(); err != nil {
 		return nil, err
@@ -310,9 +284,6 @@ func (c *dynamicResourceClient) Watch(opts metav1.ListOptions) (watch.Interface,
 }

 func (c *dynamicResourceClient) Patch(name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*unstructured.Unstructured, error) {
-	if len(name) == 0 {
-		return nil, fmt.Errorf("name is required")
-	}
 	result := c.client.client.
 		Patch(pt).
 		AbsPath(append(c.makeURLSegments(name), subresources...)...).
--- a/examples/README.md
+++ b/examples/README.md
@@ -11,7 +11,7 @@ To enable these plugins in your program, import them in your main package.

 You can load all auth plugins:
 ```go
-import _ "k8s.io/client-go/plugin/pkg/client/auth"
+import _ "k8s.io/client-go/plugin/pkg/client/auth
 ```

 Or you can load specific auth plugins:
@@ -42,10 +42,9 @@ import _ "k8s.io/client-go/plugin/pkg/client/auth/openstack"
  Register a custom resource type with the API, create/update/query this custom
  type, and write a controller that drives the cluster state based on the changes to
  the custom resources.
- [**Leader election**](./leader-election): Demonstrates the use of the leader election package, which can be used to implement HA controllers.

 [informer]: https://godoc.org/k8s.io/client-go/tools/cache#NewInformer

 ### Testing

- [**Fake Client**](./fake-client): Use a fake client in tests.
+- [**Fake Client**](./fake-client): Use a fake client in tests.
--- a/examples/in-cluster-client-configuration/README.md
+++ b/examples/in-cluster-client-configuration/README.md
@@ -37,7 +37,7 @@ kubectl create clusterrolebinding default-view --clusterrole=view --serviceaccou

 Then, run the image in a Pod with a single instance Deployment:

-    kubectl run --rm -i demo --image=in-cluster --image-pull-policy=Never
+    $ kubectl run --rm -i demo --image=in-cluster --image-pull-policy=Never

    There are 4 pods in the cluster
    There are 4 pods in the cluster
--- a/examples/leader-election/README.md
+++ b/examples/leader-election/README.md
@@ -1,21 +0,0 @@
-# Leader Election Example
-
-This example demonstrates how to use the leader election package.
-
-## Running
-
-Run the following three commands in separate terminals. Each terminal needs a unique `id`.
-
-```bash
-# first terminal 
-go run *.go -kubeconfig=/my/config -logtostderr=true -id=1
-
-# second terminal 
-go run *.go -kubeconfig=/my/config -logtostderr=true -id=2
-
-# third terminal
-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.
--- a/examples/out-of-cluster-client-configuration/README.md
+++ b/examples/out-of-cluster-client-configuration/README.md
@@ -22,7 +22,7 @@ Run this application with:
 Running this application will use the kubeconfig file and then authenticate to the
 cluster, and print the number of pods in the cluster every 10 seconds:

-    ./app
+    $ ./app
    There are 3 pods in the cluster
    There are 3 pods in the cluster
    There are 3 pods in the cluster
--- a/go.mod
+++ b/go.mod
@@ -1,42 +0,0 @@
-// This is a generated file. Do not edit directly.
-
-module k8s.io/client-go
-
-go 1.12
-
-require (
-	github.com/Azure/go-autorest v11.1.2+incompatible
-	github.com/davecgh/go-spew v1.1.1
-	github.com/dgrijalva/jwt-go v0.0.0-20160705203006-01aeca54ebda // indirect
-	github.com/evanphx/json-patch v0.0.0-20190203023257-5858425f7550
-	github.com/gogo/protobuf v0.0.0-20171007142547-342cbe0a0415
-	github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903
-	github.com/golang/protobuf v1.2.0
-	github.com/google/btree v0.0.0-20160524151835-7d79101e329e // indirect
-	github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf
-	github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d
-	github.com/gophercloud/gophercloud v0.0.0-20190126172459-c818fa66e4c8
-	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.1
-	github.com/stretchr/testify v1.2.2
-	golang.org/x/crypto v0.0.0-20181025213731-e84da0312774
-	golang.org/x/net v0.0.0-20190812203447-cdfb69ac37fc
-	golang.org/x/oauth2 v0.0.0-20190402181905-9f3314589c9a
-	golang.org/x/time v0.0.0-20161028155119-f51c12702a4d
-	google.golang.org/appengine v1.5.0 // indirect
-	k8s.io/api v0.15.10
-	k8s.io/apimachinery v0.15.10
-	k8s.io/klog v0.3.1
-	k8s.io/utils v0.0.0-20190221042446-c2654d5206da
-	sigs.k8s.io/yaml v1.1.0
-)
-
-replace (
-	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/tools => golang.org/x/tools v0.0.0-20190313210603-aa82965741a9
-	k8s.io/api => k8s.io/api v0.15.10
-	k8s.io/apimachinery => k8s.io/apimachinery v0.15.10
-)
--- a/go.sum
+++ b/go.sum
@@ -1,105 +0,0 @@
-cloud.google.com/go v0.34.0 h1:eOI3/cP2VTU6uZLDYAoic+eyzzB9YyGmJ7eIjl8rOPg=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-github.com/Azure/go-autorest v11.1.2+incompatible h1:viZ3tV5l4gE2Sw0xrasFHytCGtzYCrT+um/rrSQ1BfA=
-github.com/Azure/go-autorest v11.1.2+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
-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=
-github.com/dgrijalva/jwt-go v0.0.0-20160705203006-01aeca54ebda h1:NyywMz59neOoVRFDz+ccfKWxn784fiHMDnZSy6T+JXY=
-github.com/dgrijalva/jwt-go v0.0.0-20160705203006-01aeca54ebda/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96 h1:cenwrSVm+Z7QLSV/BsnenAOcDXdX4cMv4wP0B/5QbPg=
-github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM=
-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/evanphx/json-patch v0.0.0-20190203023257-5858425f7550 h1:mV9jbLoSW/8m4VK16ZkHTozJa8sesK5u5kTMFysTYac=
-github.com/evanphx/json-patch v0.0.0-20190203023257-5858425f7550/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/gogo/protobuf v0.0.0-20171007142547-342cbe0a0415 h1:WSBJMqJbLxsn+bTCPyPYZfqHdJmc8MK4wrBjMft6BAM=
-github.com/gogo/protobuf v0.0.0-20171007142547-342cbe0a0415/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903 h1:LbsanbbD6LieFkXbj9YNNBupiGHJgFeLpO0j0Fza1h8=
-github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-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/google/btree v0.0.0-20160524151835-7d79101e329e h1:JHB7F/4TJCrYBW8+GZO8VkWDj1jxcWuCl6uxKODiyi4=
-github.com/google/btree v0.0.0-20160524151835-7d79101e329e/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-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-20170612174753-24818f796faf h1:+RRA9JqSOZFfKrOeqr2z77+8R2RKyh8PG66dcu1V0ck=
-github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
-github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA=
-github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-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.0.0-20190126172459-c818fa66e4c8 h1:L9JPKrtsHMQ4VCRQfHvbbHBfB2Urn8xf6QZeXZ+OrN4=
-github.com/gophercloud/gophercloud v0.0.0-20190126172459-c818fa66e4c8/go.mod h1:3WdhXV3rUYy9p6AUW8d94kr+HS62Y4VL9mBnFxsD8q4=
-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/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 v0.0.0-20180701071628-ab8a2e0c74be h1:AHimNtVIpiBjPUhEF5KNCkrUyqTSA5zWUl8sQ2bfGBE=
-github.com/json-iterator/go v0.0.0-20180701071628-ab8a2e0c74be/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-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 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
-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/gomega v0.0.0-20190113212917-5533ce8a0da3 h1:EooPXg51Tn+xmWPXJUGCnJhJSpeuMlBmfJVcqIRmmv8=
-github.com/onsi/gomega v0.0.0-20190113212917-5533ce8a0da3/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/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/pflag v1.0.1 h1:aCvUg6QPl3ibpQUxyLkrEkCHtPqYJL4x9AuhqVqFis4=
-github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-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/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-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.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-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-20190313210603-aa82965741a9/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0 h1:KxkO13IPW4Lslp2bz+KHP2E3gtFlrIGNThxkZQ3g+4c=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/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.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.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-k8s.io/api v0.15.10/go.mod h1:PffiEKNf0aFiv2naEYSGTFHIGA9V8Qwt22DZIAokOzQ=
-k8s.io/apimachinery v0.15.10/go.mod h1:ZRw+v83FjgEqlzqaBkxL3XB21MSLYdzjsY9Bgxclhdw=
-k8s.io/klog v0.3.1 h1:RVgyDHY/kFKtLqh67NvEWIgkMneNoIrdkN0CxDSQc68=
-k8s.io/klog v0.3.1/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
-k8s.io/kube-openapi v0.0.0-20190228160746-b3a7cee44a30 h1:TRb4wNWoBVrH9plmkp2q86FIDppkbrEXdXlxU3a3BMI=
-k8s.io/kube-openapi v0.0.0-20190228160746-b3a7cee44a30/go.mod h1:BXM9ceUBTj2QnfH2MK1odQs778ajze1RxcmP6S8RVVc=
-k8s.io/utils v0.0.0-20190221042446-c2654d5206da h1:ElyM7RPonbKnQqOcw7dG2IK5uvQQn3b/WPHqD5mBvP4=
-k8s.io/utils v0.0.0-20190221042446-c2654d5206da/go.mod h1:8k8uAuAQ0rXslZKaEWd0c3oVhZz7sSzSiPnVZayjIX0=
-sigs.k8s.io/yaml v1.1.0 h1:4A07+ZFc2wgJwo8YNlQpr1rVlgUDlxXHhPJciaPY5gs=
-sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
--- a/informers/extensions/v1beta1/interface.go
+++ b/informers/extensions/v1beta1/interface.go
@@ -30,8 +30,6 @@ type Interface interface {
 	Deployments() DeploymentInformer
 	// Ingresses returns a IngressInformer.
 	Ingresses() IngressInformer
-	// NetworkPolicies returns a NetworkPolicyInformer.
-	NetworkPolicies() NetworkPolicyInformer
 	// PodSecurityPolicies returns a PodSecurityPolicyInformer.
 	PodSecurityPolicies() PodSecurityPolicyInformer
 	// ReplicaSets returns a ReplicaSetInformer.
@@ -64,11 +62,6 @@ func (v *version) Ingresses() IngressInformer {
 	return &ingressInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
 }

-// NetworkPolicies returns a NetworkPolicyInformer.
-func (v *version) NetworkPolicies() NetworkPolicyInformer {
-	return &networkPolicyInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
-}
-
 // PodSecurityPolicies returns a PodSecurityPolicyInformer.
 func (v *version) PodSecurityPolicies() PodSecurityPolicyInformer {
 	return &podSecurityPolicyInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
--- a/informers/extensions/v1beta1/networkpolicy.go
+++ b/informers/extensions/v1beta1/networkpolicy.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"
-
-	extensionsv1beta1 "k8s.io/api/extensions/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/extensions/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// NetworkPolicyInformer provides access to a shared informer and lister for
-// NetworkPolicies.
-type NetworkPolicyInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.NetworkPolicyLister
-}
-
-type networkPolicyInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-	namespace        string
-}
-
-// NewNetworkPolicyInformer constructs a new informer for NetworkPolicy 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 NewNetworkPolicyInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredNetworkPolicyInformer(client, namespace, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredNetworkPolicyInformer constructs a new informer for NetworkPolicy 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 NewFilteredNetworkPolicyInformer(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.ExtensionsV1beta1().NetworkPolicies(namespace).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.ExtensionsV1beta1().NetworkPolicies(namespace).Watch(options)
-			},
-		},
-		&extensionsv1beta1.NetworkPolicy{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *networkPolicyInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredNetworkPolicyInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *networkPolicyInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&extensionsv1beta1.NetworkPolicy{}, f.defaultInformer)
-}
-
-func (f *networkPolicyInformer) Lister() v1beta1.NetworkPolicyLister {
-	return v1beta1.NewNetworkPolicyLister(f.Informer().GetIndexer())
-}
--- a/informers/generic.go
+++ b/informers/generic.go
@@ -206,8 +206,6 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().Deployments().Informer()}, nil
 	case extensionsv1beta1.SchemeGroupVersion.WithResource("ingresses"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().Ingresses().Informer()}, nil
-	case extensionsv1beta1.SchemeGroupVersion.WithResource("networkpolicies"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().NetworkPolicies().Informer()}, nil
 	case extensionsv1beta1.SchemeGroupVersion.WithResource("podsecuritypolicies"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().PodSecurityPolicies().Informer()}, nil
 	case extensionsv1beta1.SchemeGroupVersion.WithResource("replicasets"):
--- a/kubernetes/fake/clientset_generated.go
+++ b/kubernetes/fake/clientset_generated.go
@@ -111,7 +111,7 @@ func NewSimpleClientset(objects ...runtime.Object) *Clientset {
 		}
 	}

-	cs := &Clientset{tracker: o}
+	cs := &Clientset{}
 	cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake}
 	cs.AddReactor("*", "*", testing.ObjectReaction(o))
 	cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
@@ -133,17 +133,12 @@ func NewSimpleClientset(objects ...runtime.Object) *Clientset {
 type Clientset struct {
 	testing.Fake
 	discovery *fakediscovery.FakeDiscovery
-	tracker   testing.ObjectTracker
 }

 func (c *Clientset) Discovery() discovery.DiscoveryInterface {
 	return c.discovery
 }

-func (c *Clientset) Tracker() testing.ObjectTracker {
-	return c.tracker
-}
-
 var _ clientset.Interface = &Clientset{}

 // AdmissionregistrationV1beta1 retrieves the AdmissionregistrationV1beta1Client
--- a/kubernetes/typed/admissionregistration/v1beta1/admissionregistration_client.go
+++ b/kubernetes/typed/admissionregistration/v1beta1/admissionregistration_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/admissionregistration/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -75,7 +76,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/apps/v1/apps_client.go
+++ b/kubernetes/typed/apps/v1/apps_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/apps/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -90,7 +91,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/apps/v1beta1/apps_client.go
+++ b/kubernetes/typed/apps/v1beta1/apps_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/apps/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -80,7 +81,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/apps/v1beta2/apps_client.go
+++ b/kubernetes/typed/apps/v1beta2/apps_client.go
@@ -20,6 +20,7 @@ package v1beta2

 import (
 	v1beta2 "k8s.io/api/apps/v1beta2"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -90,7 +91,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta2.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/auditregistration/v1alpha1/auditregistration_client.go
+++ b/kubernetes/typed/auditregistration/v1alpha1/auditregistration_client.go
@@ -20,6 +20,7 @@ package v1alpha1

 import (
 	v1alpha1 "k8s.io/api/auditregistration/v1alpha1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/authentication/v1/authentication_client.go
+++ b/kubernetes/typed/authentication/v1/authentication_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/authentication/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/authentication/v1beta1/authentication_client.go
+++ b/kubernetes/typed/authentication/v1beta1/authentication_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/authentication/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/authorization/v1/authorization_client.go
+++ b/kubernetes/typed/authorization/v1/authorization_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/authorization/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -85,7 +86,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/authorization/v1beta1/authorization_client.go
+++ b/kubernetes/typed/authorization/v1beta1/authorization_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/authorization/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -85,7 +86,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/autoscaling/v1/autoscaling_client.go
+++ b/kubernetes/typed/autoscaling/v1/autoscaling_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/autoscaling/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/autoscaling/v2beta1/autoscaling_client.go
+++ b/kubernetes/typed/autoscaling/v2beta1/autoscaling_client.go
@@ -20,6 +20,7 @@ package v2beta1

 import (
 	v2beta1 "k8s.io/api/autoscaling/v2beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v2beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/autoscaling/v2beta2/autoscaling_client.go
+++ b/kubernetes/typed/autoscaling/v2beta2/autoscaling_client.go
@@ -20,6 +20,7 @@ package v2beta2

 import (
 	v2beta2 "k8s.io/api/autoscaling/v2beta2"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v2beta2.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/batch/v1/batch_client.go
+++ b/kubernetes/typed/batch/v1/batch_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/batch/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/batch/v1beta1/batch_client.go
+++ b/kubernetes/typed/batch/v1beta1/batch_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/batch/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/batch/v2alpha1/batch_client.go
+++ b/kubernetes/typed/batch/v2alpha1/batch_client.go
@@ -20,6 +20,7 @@ package v2alpha1

 import (
 	v2alpha1 "k8s.io/api/batch/v2alpha1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v2alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/certificates/v1beta1/certificates_client.go
+++ b/kubernetes/typed/certificates/v1beta1/certificates_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/certificates/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/coordination/v1/coordination_client.go
+++ b/kubernetes/typed/coordination/v1/coordination_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/coordination/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/coordination/v1beta1/coordination_client.go
+++ b/kubernetes/typed/coordination/v1beta1/coordination_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/coordination/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/core/v1/core_client.go
+++ b/kubernetes/typed/core/v1/core_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/core/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -145,7 +146,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/api"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/events/v1beta1/event_expansion.go
+++ b/kubernetes/typed/events/v1beta1/event_expansion.go
@@ -1,98 +0,0 @@
-/*
-Copyright 2019 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 v1beta1
-
-import (
-	"fmt"
-
-	"k8s.io/api/events/v1beta1"
-	"k8s.io/apimachinery/pkg/types"
-)
-
-// The EventExpansion interface allows manually adding extra methods to the EventInterface.
-// TODO: Add querying functions to the event expansion
-type EventExpansion interface {
-	// CreateWithEventNamespace is the same as a Create
-	// except that it sends the request to the event.Namespace.
-	CreateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error)
-	// UpdateWithEventNamespace is the same as a Update
-	// except that it sends the request to the event.Namespace.
-	UpdateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error)
-	// PatchWithEventNamespace is the same as an Update
-	// except that it sends the request to the event.Namespace.
-	PatchWithEventNamespace(event *v1beta1.Event, data []byte) (*v1beta1.Event, error)
-}
-
-// CreateWithEventNamespace makes a new event.
-// Returns the copy of the event the server returns, or an error.
-// The namespace to create the event within is deduced from the event.
-// it must either match this event client's namespace, or this event client must
-// have been created with the "" namespace.
-func (e *events) CreateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error) {
-	if e.ns != "" && event.Namespace != e.ns {
-		return nil, fmt.Errorf("can't create an event with namespace '%v' in namespace '%v'", event.Namespace, e.ns)
-	}
-	result := &v1beta1.Event{}
-	err := e.client.Post().
-		NamespaceIfScoped(event.Namespace, len(event.Namespace) > 0).
-		Resource("events").
-		Body(event).
-		Do().
-		Into(result)
-	return result, err
-}
-
-// UpdateWithEventNamespace modifies an existing event.
-// It returns the copy of the event that the server returns, or an error.
-// The namespace and key to update the event within is deduced from the event.
-// The namespace must either match this event client's namespace, or this event client must have been
-// created with the "" namespace.
-// Update also requires the ResourceVersion to be set in the event object.
-func (e *events) UpdateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error) {
-	if e.ns != "" && event.Namespace != e.ns {
-		return nil, fmt.Errorf("can't update an event with namespace '%v' in namespace '%v'", event.Namespace, e.ns)
-	}
-	result := &v1beta1.Event{}
-	err := e.client.Put().
-		NamespaceIfScoped(event.Namespace, len(event.Namespace) > 0).
-		Resource("events").
-		Name(event.Name).
-		Body(event).
-		Do().
-		Into(result)
-	return result, err
-}
-
-// PatchWithEventNamespace modifies an existing event.
-// It returns the copy of the event that the server returns, or an error.
-// The namespace and name of the target event is deduced from the event.
-// The namespace must either match this event client's namespace, or this event client must
-//  have been created with the "" namespace.
-func (e *events) PatchWithEventNamespace(event *v1beta1.Event, data []byte) (*v1beta1.Event, error) {
-	if e.ns != "" && event.Namespace != e.ns {
-		return nil, fmt.Errorf("can't patch an event with namespace '%v' in namespace '%v'", event.Namespace, e.ns)
-	}
-	result := &v1beta1.Event{}
-	err := e.client.Patch(types.StrategicMergePatchType).
-		NamespaceIfScoped(event.Namespace, len(event.Namespace) > 0).
-		Resource("events").
-		Name(event.Name).
-		Body(data).
-		Do().
-		Into(result)
-	return result, err
-}
--- a/kubernetes/typed/events/v1beta1/events_client.go
+++ b/kubernetes/typed/events/v1beta1/events_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/events/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/events/v1beta1/fake/fake_event_expansion.go
+++ b/kubernetes/typed/events/v1beta1/fake/fake_event_expansion.go
@@ -1,66 +0,0 @@
-/*
-Copyright 2014 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 fake
-
-import (
-	v1beta1 "k8s.io/api/events/v1beta1"
-	types "k8s.io/apimachinery/pkg/types"
-	core "k8s.io/client-go/testing"
-)
-
-// CreateWithEventNamespace creats a new event. Returns the copy of the event the server returns, or an error.
-func (c *FakeEvents) CreateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error) {
-	action := core.NewRootCreateAction(eventsResource, event)
-	if c.ns != "" {
-		action = core.NewCreateAction(eventsResource, c.ns, event)
-	}
-	obj, err := c.Fake.Invokes(action, event)
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*v1beta1.Event), err
-}
-
-// UpdateWithEventNamespace replaces an existing event. Returns the copy of the event the server returns, or an error.
-func (c *FakeEvents) UpdateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error) {
-	action := core.NewRootUpdateAction(eventsResource, event)
-	if c.ns != "" {
-		action = core.NewUpdateAction(eventsResource, c.ns, event)
-	}
-	obj, err := c.Fake.Invokes(action, event)
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*v1beta1.Event), err
-}
-
-// PatchWithEventNamespace patches an existing event. Returns the copy of the event the server returns, or an error.
-func (c *FakeEvents) PatchWithEventNamespace(event *v1beta1.Event, data []byte) (*v1beta1.Event, error) {
-	pt := types.StrategicMergePatchType
-	action := core.NewRootPatchAction(eventsResource, event.Name, pt, data)
-	if c.ns != "" {
-		action = core.NewPatchAction(eventsResource, c.ns, event.Name, pt, data)
-	}
-	obj, err := c.Fake.Invokes(action, event)
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*v1beta1.Event), err
-}
--- a/kubernetes/typed/events/v1beta1/generated_expansion.go
+++ b/kubernetes/typed/events/v1beta1/generated_expansion.go
@@ -17,3 +17,5 @@ limitations under the License.
 // Code generated by client-gen. DO NOT EDIT.

 package v1beta1
+
+type EventExpansion interface{}
--- a/kubernetes/typed/extensions/v1beta1/extensions_client.go
+++ b/kubernetes/typed/extensions/v1beta1/extensions_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/extensions/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -29,7 +30,6 @@ type ExtensionsV1beta1Interface interface {
 	DaemonSetsGetter
 	DeploymentsGetter
 	IngressesGetter
-	NetworkPoliciesGetter
 	PodSecurityPoliciesGetter
 	ReplicaSetsGetter
 }
@@ -51,10 +51,6 @@ func (c *ExtensionsV1beta1Client) Ingresses(namespace string) IngressInterface {
 	return newIngresses(c, namespace)
 }

-func (c *ExtensionsV1beta1Client) NetworkPolicies(namespace string) NetworkPolicyInterface {
-	return newNetworkPolicies(c, namespace)
-}
-
 func (c *ExtensionsV1beta1Client) PodSecurityPolicies() PodSecurityPolicyInterface {
 	return newPodSecurityPolicies(c)
 }
@@ -95,7 +91,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/extensions/v1beta1/fake/fake_extensions_client.go
+++ b/kubernetes/typed/extensions/v1beta1/fake/fake_extensions_client.go
@@ -40,10 +40,6 @@ func (c *FakeExtensionsV1beta1) Ingresses(namespace string) v1beta1.IngressInter
 	return &FakeIngresses{c, namespace}
 }

-func (c *FakeExtensionsV1beta1) NetworkPolicies(namespace string) v1beta1.NetworkPolicyInterface {
-	return &FakeNetworkPolicies{c, namespace}
-}
-
 func (c *FakeExtensionsV1beta1) PodSecurityPolicies() v1beta1.PodSecurityPolicyInterface {
 	return &FakePodSecurityPolicies{c}
 }
--- a/kubernetes/typed/extensions/v1beta1/fake/fake_networkpolicy.go
+++ b/kubernetes/typed/extensions/v1beta1/fake/fake_networkpolicy.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/extensions/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"
-)
-
-// FakeNetworkPolicies implements NetworkPolicyInterface
-type FakeNetworkPolicies struct {
-	Fake *FakeExtensionsV1beta1
-	ns   string
-}
-
-var networkpoliciesResource = schema.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "networkpolicies"}
-
-var networkpoliciesKind = schema.GroupVersionKind{Group: "extensions", Version: "v1beta1", Kind: "NetworkPolicy"}
-
-// Get takes name of the networkPolicy, and returns the corresponding networkPolicy object, and an error if there is any.
-func (c *FakeNetworkPolicies) Get(name string, options v1.GetOptions) (result *v1beta1.NetworkPolicy, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewGetAction(networkpoliciesResource, c.ns, name), &v1beta1.NetworkPolicy{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1beta1.NetworkPolicy), err
-}
-
-// List takes label and field selectors, and returns the list of NetworkPolicies that match those selectors.
-func (c *FakeNetworkPolicies) List(opts v1.ListOptions) (result *v1beta1.NetworkPolicyList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewListAction(networkpoliciesResource, networkpoliciesKind, c.ns, opts), &v1beta1.NetworkPolicyList{})
-
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1beta1.NetworkPolicyList{ListMeta: obj.(*v1beta1.NetworkPolicyList).ListMeta}
-	for _, item := range obj.(*v1beta1.NetworkPolicyList).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 networkPolicies.
-func (c *FakeNetworkPolicies) Watch(opts v1.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewWatchAction(networkpoliciesResource, c.ns, opts))
-
-}
-
-// Create takes the representation of a networkPolicy and creates it.  Returns the server's representation of the networkPolicy, and an error, if there is any.
-func (c *FakeNetworkPolicies) Create(networkPolicy *v1beta1.NetworkPolicy) (result *v1beta1.NetworkPolicy, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewCreateAction(networkpoliciesResource, c.ns, networkPolicy), &v1beta1.NetworkPolicy{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1beta1.NetworkPolicy), err
-}
-
-// Update takes the representation of a networkPolicy and updates it. Returns the server's representation of the networkPolicy, and an error, if there is any.
-func (c *FakeNetworkPolicies) Update(networkPolicy *v1beta1.NetworkPolicy) (result *v1beta1.NetworkPolicy, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateAction(networkpoliciesResource, c.ns, networkPolicy), &v1beta1.NetworkPolicy{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1beta1.NetworkPolicy), err
-}
-
-// Delete takes name of the networkPolicy and deletes it. Returns an error if one occurs.
-func (c *FakeNetworkPolicies) Delete(name string, options *v1.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewDeleteAction(networkpoliciesResource, c.ns, name), &v1beta1.NetworkPolicy{})
-
-	return err
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *FakeNetworkPolicies) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	action := testing.NewDeleteCollectionAction(networkpoliciesResource, c.ns, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1beta1.NetworkPolicyList{})
-	return err
-}
-
-// Patch applies the patch and returns the patched networkPolicy.
-func (c *FakeNetworkPolicies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.NetworkPolicy, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(networkpoliciesResource, c.ns, name, pt, data, subresources...), &v1beta1.NetworkPolicy{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1beta1.NetworkPolicy), err
-}
--- a/kubernetes/typed/extensions/v1beta1/generated_expansion.go
+++ b/kubernetes/typed/extensions/v1beta1/generated_expansion.go
@@ -22,8 +22,6 @@ type DaemonSetExpansion interface{}

 type IngressExpansion interface{}

-type NetworkPolicyExpansion interface{}
-
 type PodSecurityPolicyExpansion interface{}

 type ReplicaSetExpansion interface{}
--- a/kubernetes/typed/extensions/v1beta1/networkpolicy.go
+++ b/kubernetes/typed/extensions/v1beta1/networkpolicy.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/extensions/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"
-)
-
-// NetworkPoliciesGetter has a method to return a NetworkPolicyInterface.
-// A group's client should implement this interface.
-type NetworkPoliciesGetter interface {
-	NetworkPolicies(namespace string) NetworkPolicyInterface
-}
-
-// NetworkPolicyInterface has methods to work with NetworkPolicy resources.
-type NetworkPolicyInterface interface {
-	Create(*v1beta1.NetworkPolicy) (*v1beta1.NetworkPolicy, error)
-	Update(*v1beta1.NetworkPolicy) (*v1beta1.NetworkPolicy, error)
-	Delete(name string, options *v1.DeleteOptions) error
-	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
-	Get(name string, options v1.GetOptions) (*v1beta1.NetworkPolicy, error)
-	List(opts v1.ListOptions) (*v1beta1.NetworkPolicyList, error)
-	Watch(opts v1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.NetworkPolicy, err error)
-	NetworkPolicyExpansion
-}
-
-// networkPolicies implements NetworkPolicyInterface
-type networkPolicies struct {
-	client rest.Interface
-	ns     string
-}
-
-// newNetworkPolicies returns a NetworkPolicies
-func newNetworkPolicies(c *ExtensionsV1beta1Client, namespace string) *networkPolicies {
-	return &networkPolicies{
-		client: c.RESTClient(),
-		ns:     namespace,
-	}
-}
-
-// Get takes name of the networkPolicy, and returns the corresponding networkPolicy object, and an error if there is any.
-func (c *networkPolicies) Get(name string, options v1.GetOptions) (result *v1beta1.NetworkPolicy, err error) {
-	result = &v1beta1.NetworkPolicy{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("networkpolicies").
-		Name(name).
-		VersionedParams(&options, scheme.ParameterCodec).
-		Do().
-		Into(result)
-	return
-}
-
-// List takes label and field selectors, and returns the list of NetworkPolicies that match those selectors.
-func (c *networkPolicies) List(opts v1.ListOptions) (result *v1beta1.NetworkPolicyList, err error) {
-	var timeout time.Duration
-	if opts.TimeoutSeconds != nil {
-		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
-	}
-	result = &v1beta1.NetworkPolicyList{}
-	err = c.client.Get().
-		Namespace(c.ns).
-		Resource("networkpolicies").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Do().
-		Into(result)
-	return
-}
-
-// Watch returns a watch.Interface that watches the requested networkPolicies.
-func (c *networkPolicies) 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("networkpolicies").
-		VersionedParams(&opts, scheme.ParameterCodec).
-		Timeout(timeout).
-		Watch()
-}
-
-// Create takes the representation of a networkPolicy and creates it.  Returns the server's representation of the networkPolicy, and an error, if there is any.
-func (c *networkPolicies) Create(networkPolicy *v1beta1.NetworkPolicy) (result *v1beta1.NetworkPolicy, err error) {
-	result = &v1beta1.NetworkPolicy{}
-	err = c.client.Post().
-		Namespace(c.ns).
-		Resource("networkpolicies").
-		Body(networkPolicy).
-		Do().
-		Into(result)
-	return
-}
-
-// Update takes the representation of a networkPolicy and updates it. Returns the server's representation of the networkPolicy, and an error, if there is any.
-func (c *networkPolicies) Update(networkPolicy *v1beta1.NetworkPolicy) (result *v1beta1.NetworkPolicy, err error) {
-	result = &v1beta1.NetworkPolicy{}
-	err = c.client.Put().
-		Namespace(c.ns).
-		Resource("networkpolicies").
-		Name(networkPolicy.Name).
-		Body(networkPolicy).
-		Do().
-		Into(result)
-	return
-}
-
-// Delete takes name of the networkPolicy and deletes it. Returns an error if one occurs.
-func (c *networkPolicies) Delete(name string, options *v1.DeleteOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("networkpolicies").
-		Name(name).
-		Body(options).
-		Do().
-		Error()
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *networkPolicies) 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("networkpolicies").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
-		Timeout(timeout).
-		Body(options).
-		Do().
-		Error()
-}
-
-// Patch applies the patch and returns the patched networkPolicy.
-func (c *networkPolicies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.NetworkPolicy, err error) {
-	result = &v1beta1.NetworkPolicy{}
-	err = c.client.Patch(pt).
-		Namespace(c.ns).
-		Resource("networkpolicies").
-		SubResource(subresources...).
-		Name(name).
-		Body(data).
-		Do().
-		Into(result)
-	return
-}
--- a/kubernetes/typed/networking/v1/networking_client.go
+++ b/kubernetes/typed/networking/v1/networking_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/networking/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/networking/v1beta1/networking_client.go
+++ b/kubernetes/typed/networking/v1beta1/networking_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/networking/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/node/v1alpha1/node_client.go
+++ b/kubernetes/typed/node/v1alpha1/node_client.go
@@ -20,6 +20,7 @@ package v1alpha1

 import (
 	v1alpha1 "k8s.io/api/node/v1alpha1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/node/v1beta1/node_client.go
+++ b/kubernetes/typed/node/v1beta1/node_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/node/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/policy/v1beta1/policy_client.go
+++ b/kubernetes/typed/policy/v1beta1/policy_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/policy/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -80,7 +81,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/rbac/v1/rbac_client.go
+++ b/kubernetes/typed/rbac/v1/rbac_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/rbac/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -85,7 +86,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/rbac/v1alpha1/rbac_client.go
+++ b/kubernetes/typed/rbac/v1alpha1/rbac_client.go
@@ -20,6 +20,7 @@ package v1alpha1

 import (
 	v1alpha1 "k8s.io/api/rbac/v1alpha1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -85,7 +86,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/rbac/v1beta1/rbac_client.go
+++ b/kubernetes/typed/rbac/v1beta1/rbac_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/rbac/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -85,7 +86,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/scheduling/v1/scheduling_client.go
+++ b/kubernetes/typed/scheduling/v1/scheduling_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/scheduling/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/scheduling/v1alpha1/scheduling_client.go
+++ b/kubernetes/typed/scheduling/v1alpha1/scheduling_client.go
@@ -20,6 +20,7 @@ package v1alpha1

 import (
 	v1alpha1 "k8s.io/api/scheduling/v1alpha1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/scheduling/v1beta1/scheduling_client.go
+++ b/kubernetes/typed/scheduling/v1beta1/scheduling_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/scheduling/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/settings/v1alpha1/settings_client.go
+++ b/kubernetes/typed/settings/v1alpha1/settings_client.go
@@ -20,6 +20,7 @@ package v1alpha1

 import (
 	v1alpha1 "k8s.io/api/settings/v1alpha1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/storage/v1/storage_client.go
+++ b/kubernetes/typed/storage/v1/storage_client.go
@@ -20,6 +20,7 @@ package v1

 import (
 	v1 "k8s.io/api/storage/v1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -75,7 +76,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/storage/v1alpha1/storage_client.go
+++ b/kubernetes/typed/storage/v1alpha1/storage_client.go
@@ -20,6 +20,7 @@ package v1alpha1

 import (
 	v1alpha1 "k8s.io/api/storage/v1alpha1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -70,7 +71,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/kubernetes/typed/storage/v1beta1/storage_client.go
+++ b/kubernetes/typed/storage/v1beta1/storage_client.go
@@ -20,6 +20,7 @@ package v1beta1

 import (
 	v1beta1 "k8s.io/api/storage/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	rest "k8s.io/client-go/rest"
 )
@@ -85,7 +86,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1beta1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}

 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
--- a/listers/extensions/v1beta1/expansion_generated.go
+++ b/listers/extensions/v1beta1/expansion_generated.go
@@ -26,14 +26,6 @@ type IngressListerExpansion interface{}
 // IngressNamespaceLister.
 type IngressNamespaceListerExpansion interface{}

-// NetworkPolicyListerExpansion allows custom methods to be added to
-// NetworkPolicyLister.
-type NetworkPolicyListerExpansion interface{}
-
-// NetworkPolicyNamespaceListerExpansion allows custom methods to be added to
-// NetworkPolicyNamespaceLister.
-type NetworkPolicyNamespaceListerExpansion interface{}
-
 // PodSecurityPolicyListerExpansion allows custom methods to be added to
 // PodSecurityPolicyLister.
 type PodSecurityPolicyListerExpansion interface{}
--- a/listers/extensions/v1beta1/networkpolicy.go
+++ b/listers/extensions/v1beta1/networkpolicy.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/extensions/v1beta1"
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/client-go/tools/cache"
-)
-
-// NetworkPolicyLister helps list NetworkPolicies.
-type NetworkPolicyLister interface {
-	// List lists all NetworkPolicies in the indexer.
-	List(selector labels.Selector) (ret []*v1beta1.NetworkPolicy, err error)
-	// NetworkPolicies returns an object that can list and get NetworkPolicies.
-	NetworkPolicies(namespace string) NetworkPolicyNamespaceLister
-	NetworkPolicyListerExpansion
-}
-
-// networkPolicyLister implements the NetworkPolicyLister interface.
-type networkPolicyLister struct {
-	indexer cache.Indexer
-}
-
-// NewNetworkPolicyLister returns a new NetworkPolicyLister.
-func NewNetworkPolicyLister(indexer cache.Indexer) NetworkPolicyLister {
-	return &networkPolicyLister{indexer: indexer}
-}
-
-// List lists all NetworkPolicies in the indexer.
-func (s *networkPolicyLister) List(selector labels.Selector) (ret []*v1beta1.NetworkPolicy, err error) {
-	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1beta1.NetworkPolicy))
-	})
-	return ret, err
-}
-
-// NetworkPolicies returns an object that can list and get NetworkPolicies.
-func (s *networkPolicyLister) NetworkPolicies(namespace string) NetworkPolicyNamespaceLister {
-	return networkPolicyNamespaceLister{indexer: s.indexer, namespace: namespace}
-}
-
-// NetworkPolicyNamespaceLister helps list and get NetworkPolicies.
-type NetworkPolicyNamespaceLister interface {
-	// List lists all NetworkPolicies in the indexer for a given namespace.
-	List(selector labels.Selector) (ret []*v1beta1.NetworkPolicy, err error)
-	// Get retrieves the NetworkPolicy from the indexer for a given namespace and name.
-	Get(name string) (*v1beta1.NetworkPolicy, error)
-	NetworkPolicyNamespaceListerExpansion
-}
-
-// networkPolicyNamespaceLister implements the NetworkPolicyNamespaceLister
-// interface.
-type networkPolicyNamespaceLister struct {
-	indexer   cache.Indexer
-	namespace string
-}
-
-// List lists all NetworkPolicies in the indexer for a given namespace.
-func (s networkPolicyNamespaceLister) List(selector labels.Selector) (ret []*v1beta1.NetworkPolicy, err error) {
-	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
-		ret = append(ret, m.(*v1beta1.NetworkPolicy))
-	})
-	return ret, err
-}
-
-// Get retrieves the NetworkPolicy from the indexer for a given namespace and name.
-func (s networkPolicyNamespaceLister) Get(name string) (*v1beta1.NetworkPolicy, error) {
-	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(v1beta1.Resource("networkpolicy"), name)
-	}
-	return obj.(*v1beta1.NetworkPolicy), nil
-}
--- a/rest/client_test.go
+++ b/rest/client_test.go
@@ -32,6 +32,7 @@ import (
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/diff"
 	"k8s.io/client-go/kubernetes/scheme"
@@ -54,7 +55,7 @@ func TestSerializer(t *testing.T) {
 	contentConfig := ContentConfig{
 		ContentType:          "application/json",
 		GroupVersion:         &gv,
-		NegotiatedSerializer: scheme.Codecs.WithoutConversion(),
+		NegotiatedSerializer: serializer.DirectCodecFactory{CodecFactory: scheme.Codecs},
 	}

 	serializer, err := createSerializers(contentConfig)
@@ -333,7 +334,7 @@ func restClient(testServer *httptest.Server) (*RESTClient, error) {
 		Host: testServer.URL,
 		ContentConfig: ContentConfig{
 			GroupVersion:         &v1.SchemeGroupVersion,
-			NegotiatedSerializer: scheme.Codecs.WithoutConversion(),
+			NegotiatedSerializer: serializer.DirectCodecFactory{CodecFactory: scheme.Codecs},
 		},
 		Username: "user",
 		Password: "pass",
--- a/rest/config.go
+++ b/rest/config.go
@@ -487,7 +487,7 @@ func AddUserAgent(config *Config, userAgent string) *Config {
 	return config
 }

-// AnonymousClientConfig returns a copy of the given config with all user credentials (cert/key, bearer token, and username/password) and custom transports (WrapTransport, Transport) removed
+// AnonymousClientConfig returns a copy of the given config with all user credentials (cert/key, bearer token, and username/password) removed
 func AnonymousClientConfig(config *Config) *Config {
 	// copy only known safe fields
 	return &Config{
@@ -500,12 +500,14 @@ func AnonymousClientConfig(config *Config) *Config {
 			CAFile:     config.TLSClientConfig.CAFile,
 			CAData:     config.TLSClientConfig.CAData,
 		},
-		RateLimiter: config.RateLimiter,
-		UserAgent:   config.UserAgent,
-		QPS:         config.QPS,
-		Burst:       config.Burst,
-		Timeout:     config.Timeout,
-		Dial:        config.Dial,
+		RateLimiter:   config.RateLimiter,
+		UserAgent:     config.UserAgent,
+		Transport:     config.Transport,
+		WrapTransport: config.WrapTransport,
+		QPS:           config.QPS,
+		Burst:         config.Burst,
+		Timeout:       config.Timeout,
+		Dial:          config.Dial,
 	}
 }

--- a/rest/config_test.go
+++ b/rest/config_test.go
@@ -280,14 +280,20 @@ func TestAnonymousConfig(t *testing.T) {
 		expected.TLSClientConfig.CertFile = ""
 		expected.TLSClientConfig.KeyData = nil
 		expected.TLSClientConfig.KeyFile = ""
-		expected.Transport = nil
-		expected.WrapTransport = nil

+		// The DeepEqual cannot handle the func comparison, so we just verify if the
+		// function return the expected object.
+		if actual.WrapTransport == nil || !reflect.DeepEqual(expected.WrapTransport(nil), &fakeRoundTripper{}) {
+			t.Fatalf("AnonymousClientConfig dropped the WrapTransport field")
+		} else {
+			actual.WrapTransport = nil
+			expected.WrapTransport = nil
+		}
 		if actual.Dial != nil {
 			_, actualError := actual.Dial(context.Background(), "", "")
 			_, expectedError := expected.Dial(context.Background(), "", "")
 			if !reflect.DeepEqual(expectedError, actualError) {
-				t.Fatalf("AnonymousClientConfig dropped the Dial field")
+				t.Fatalf("CopyConfig dropped the Dial field")
 			}
 		} else {
 			actual.Dial = nil
--- a/rest/request.go
+++ b/rest/request.go
@@ -592,15 +592,10 @@ func (r *Request) WatchWithSpecificDecoders(wrapperDecoderFn func(io.ReadCloser)
 		if result := r.transformResponse(resp, req); result.err != nil {
 			return nil, result.err
 		}
-		return nil, fmt.Errorf("for request %s, got status: %v", url, resp.StatusCode)
+		return nil, fmt.Errorf("for request '%+v', got status: %v", url, resp.StatusCode)
 	}
 	wrapperDecoder := wrapperDecoderFn(resp.Body)
-	return watch.NewStreamWatcher(
-		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"),
-	), nil
+	return watch.NewStreamWatcher(restclientwatch.NewDecoder(wrapperDecoder, embeddedDecoder)), nil
 }

 // updateURLMetrics is a convenience function for pushing metrics.
@@ -850,13 +845,13 @@ func (r *Request) transformResponse(resp *http.Response, req *http.Request) Resu
 			// 3. Apiserver closes connection.
 			// 4. client-go should catch this and return an error.
 			klog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err)
-			streamErr := fmt.Errorf("Stream error when reading response body, may be caused by closed connection. Please retry. Original error: %v", err)
+			streamErr := fmt.Errorf("Stream error %#v when reading response body, may be caused by closed connection. Please retry.", err)
 			return Result{
 				err: streamErr,
 			}
 		default:
-			klog.Errorf("Unexpected error when reading response body: %v", err)
-			unexpectedErr := fmt.Errorf("Unexpected error when reading response body. Please retry. Original error: %v", err)
+			klog.Errorf("Unexpected error when reading response body: %#v", err)
+			unexpectedErr := fmt.Errorf("Unexpected error %#v when reading response body. Please retry.", err)
 			return Result{
 				err: unexpectedErr,
 			}
--- a/rest/request_test.go
+++ b/rest/request_test.go
@@ -37,12 +37,13 @@ import (

 	"k8s.io/klog"

-	v1 "k8s.io/api/core/v1"
+	"k8s.io/api/core/v1"
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
 	"k8s.io/apimachinery/pkg/util/clock"
 	"k8s.io/apimachinery/pkg/util/diff"
@@ -282,7 +283,7 @@ func defaultContentConfig() ContentConfig {
 	return ContentConfig{
 		ContentType:          "application/json",
 		GroupVersion:         &gvCopy,
-		NegotiatedSerializer: scheme.Codecs.WithoutConversion(),
+		NegotiatedSerializer: serializer.DirectCodecFactory{CodecFactory: scheme.Codecs},
 	}
 }

@@ -878,17 +879,9 @@ func TestTransformUnstructuredError(t *testing.T) {
 	}
 }

-type errorReader struct {
-	err error
-}
-
-func (r errorReader) Read(data []byte) (int, error) { return 0, r.err }
-func (r errorReader) Close() error                  { return nil }
-
 func TestRequestWatch(t *testing.T) {
 	testCases := []struct {
 		Request *Request
-		Expect  []watch.Event
 		Err     bool
 		ErrFn   func(error) bool
 		Empty   bool
@@ -910,40 +903,6 @@ func TestRequestWatch(t *testing.T) {
 			},
 			Err: true,
 		},
-		{
-			Request: &Request{
-				content:     defaultContentConfig(),
-				serializers: defaultSerializers(t),
-				client: clientFunc(func(req *http.Request) (*http.Response, error) {
-					resp := &http.Response{StatusCode: http.StatusOK, Body: errorReader{err: errors.New("test error")}}
-					return resp, nil
-				}),
-				baseURL: &url.URL{},
-			},
-			Expect: []watch.Event{
-				{
-					Type: watch.Error,
-					Object: &metav1.Status{
-						Status:  "Failure",
-						Code:    500,
-						Reason:  "InternalError",
-						Message: `an error on the server ("unable to decode an event from the watch stream: test error") has prevented the request from succeeding`,
-						Details: &metav1.StatusDetails{
-							Causes: []metav1.StatusCause{
-								{
-									Type:    "UnexpectedServerResponse",
-									Message: "unable to decode an event from the watch stream: test error",
-								},
-								{
-									Type:    "ClientWatchDecoding",
-									Message: "unable to decode an event from the watch stream: test error",
-								},
-							},
-						},
-					},
-				},
-			},
-		},
 		{
 			Request: &Request{
 				content:     defaultContentConfig(),
@@ -1040,37 +999,27 @@ func TestRequestWatch(t *testing.T) {
 		},
 	}
 	for i, testCase := range testCases {
-		t.Run("", func(t *testing.T) {
-			testCase.Request.backoffMgr = &NoBackoff{}
-			watch, err := testCase.Request.Watch()
-			hasErr := err != nil
-			if hasErr != testCase.Err {
-				t.Fatalf("%d: expected %t, got %t: %v", i, testCase.Err, hasErr, err)
+		t.Logf("testcase %v", testCase.Request)
+		testCase.Request.backoffMgr = &NoBackoff{}
+		watch, err := testCase.Request.Watch()
+		hasErr := err != nil
+		if hasErr != testCase.Err {
+			t.Errorf("%d: expected %t, got %t: %v", i, testCase.Err, hasErr, err)
+			continue
+		}
+		if testCase.ErrFn != nil && !testCase.ErrFn(err) {
+			t.Errorf("%d: error not valid: %v", i, err)
+		}
+		if hasErr && watch != nil {
+			t.Errorf("%d: watch should be nil when error is returned", i)
+			continue
+		}
+		if testCase.Empty {
+			_, ok := <-watch.ResultChan()
+			if ok {
+				t.Errorf("%d: expected the watch to be empty: %#v", i, watch)
 			}
-			if testCase.ErrFn != nil && !testCase.ErrFn(err) {
-				t.Errorf("%d: error not valid: %v", i, err)
-			}
-			if hasErr && watch != nil {
-				t.Fatalf("%d: watch should be nil when error is returned", i)
-			}
-			if testCase.Empty {
-				_, ok := <-watch.ResultChan()
-				if ok {
-					t.Errorf("%d: expected the watch to be empty: %#v", i, watch)
-				}
-			}
-			if testCase.Expect != nil {
-				for i, evt := range testCase.Expect {
-					out, ok := <-watch.ResultChan()
-					if !ok {
-						t.Fatalf("Watch closed early, %d/%d read", i, len(testCase.Expect))
-					}
-					if !reflect.DeepEqual(evt, out) {
-						t.Fatalf("Event %d does not match: %s", i, diff.ObjectReflectDiff(evt, out))
-					}
-				}
-			}
-		})
+		}
 	}
 }

--- a/rest/transport.go
+++ b/rest/transport.go
@@ -74,10 +74,9 @@ func (c *Config) TransportConfig() (*transport.Config, error) {
 			KeyFile:    c.KeyFile,
 			KeyData:    c.KeyData,
 		},
-		Username:        c.Username,
-		Password:        c.Password,
-		BearerToken:     c.BearerToken,
-		BearerTokenFile: c.BearerTokenFile,
+		Username:    c.Username,
+		Password:    c.Password,
+		BearerToken: c.BearerToken,
 		Impersonate: transport.ImpersonationConfig{
 			UserName: c.Impersonate.UserName,
 			Groups:   c.Impersonate.Groups,
--- a/rest/watch/decoder.go
+++ b/rest/watch/decoder.go
@@ -54,7 +54,7 @@ func (d *Decoder) Decode() (watch.EventType, runtime.Object, error) {
 		return "", nil, fmt.Errorf("unable to decode to metav1.Event")
 	}
 	switch got.Type {
-	case string(watch.Added), string(watch.Modified), string(watch.Deleted), string(watch.Error), string(watch.Bookmark):
+	case string(watch.Added), string(watch.Modified), string(watch.Deleted), string(watch.Error):
 	default:
 		return "", nil, fmt.Errorf("got invalid watch event type: %v", got.Type)
 	}
--- a/rest/watch/decoder_test.go
+++ b/rest/watch/decoder_test.go
@@ -26,6 +26,7 @@ import (
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
 	runtimejson "k8s.io/apimachinery/pkg/runtime/serializer/json"
 	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
 	"k8s.io/apimachinery/pkg/util/wait"
@@ -37,12 +38,12 @@ import (
 // getDecoder mimics how k8s.io/client-go/rest.createSerializers creates a decoder
 func getDecoder() runtime.Decoder {
 	jsonSerializer := runtimejson.NewSerializer(runtimejson.DefaultMetaFactory, scheme.Scheme, scheme.Scheme, false)
-	directCodecFactory := scheme.Codecs.WithoutConversion()
+	directCodecFactory := serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
 	return directCodecFactory.DecoderToVersion(jsonSerializer, v1.SchemeGroupVersion)
 }

 func TestDecoder(t *testing.T) {
-	table := []watch.EventType{watch.Added, watch.Deleted, watch.Modified, watch.Error, watch.Bookmark}
+	table := []watch.EventType{watch.Added, watch.Deleted, watch.Modified, watch.Error}

 	for _, eventType := range table {
 		out, in := io.Pipe()
--- a/rest/watch/encoder_test.go
+++ b/rest/watch/encoder_test.go
@@ -25,6 +25,7 @@ import (
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
 	runtimejson "k8s.io/apimachinery/pkg/runtime/serializer/json"
 	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
 	"k8s.io/apimachinery/pkg/watch"
@@ -35,7 +36,7 @@ import (
 // getEncoder mimics how k8s.io/client-go/rest.createSerializers creates a encoder
 func getEncoder() runtime.Encoder {
 	jsonSerializer := runtimejson.NewSerializer(runtimejson.DefaultMetaFactory, scheme.Scheme, scheme.Scheme, false)
-	directCodecFactory := scheme.Codecs.WithoutConversion()
+	directCodecFactory := serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
 	return directCodecFactory.EncoderForVersion(jsonSerializer, v1.SchemeGroupVersion)
 }

@@ -56,10 +57,6 @@ func TestEncodeDecodeRoundTrip(t *testing.T) {
 			watch.Deleted,
 			&v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 		},
-		{
-			watch.Bookmark,
-			&v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
-		},
 	}
 	for i, testCase := range testCases {
 		buf := &bytes.Buffer{}
--- a/scale/client.go
+++ b/scale/client.go
@@ -30,6 +30,10 @@ import (
 var scaleConverter = NewScaleConverter()
 var codecs = serializer.NewCodecFactory(scaleConverter.Scheme())

+// restInterfaceProvider turns a restclient.Config into a restclient.Interface.
+// It's overridable for the purposes of testing.
+type restInterfaceProvider func(*restclient.Config) (restclient.Interface, error)
+
 // scaleClient is an implementation of ScalesGetter
 // which makes use of a RESTMapper and a generic REST
 // client to support an discoverable resource.
@@ -50,7 +54,9 @@ func NewForConfig(cfg *restclient.Config, mapper PreferredResourceMapper, resolv
 	// so that the RESTClientFor doesn't complain
 	cfg.GroupVersion = &schema.GroupVersion{}

-	cfg.NegotiatedSerializer = codecs.WithoutConversion()
+	cfg.NegotiatedSerializer = serializer.DirectCodecFactory{
+		CodecFactory: codecs,
+	}
 	if len(cfg.UserAgent) == 0 {
 		cfg.UserAgent = restclient.DefaultKubernetesUserAgent()
 	}
--- a/scale/client_test.go
+++ b/scale/client_test.go
@@ -28,6 +28,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	fakedisco "k8s.io/client-go/discovery/fake"
 	"k8s.io/client-go/dynamic"
 	fakerest "k8s.io/client-go/rest/fake"
@@ -203,10 +204,12 @@ func fakeScaleClient(t *testing.T) (ScalesGetter, []schema.GroupResource) {
 	}

 	fakeClient := &fakerest.RESTClient{
-		Client:               fakerest.CreateHTTPClient(fakeReqHandler),
-		NegotiatedSerializer: codecs.WithoutConversion(),
-		GroupVersion:         schema.GroupVersion{},
-		VersionedAPIPath:     "/not/a/real/path",
+		Client: fakerest.CreateHTTPClient(fakeReqHandler),
+		NegotiatedSerializer: serializer.DirectCodecFactory{
+			CodecFactory: codecs,
+		},
+		GroupVersion:     schema.GroupVersion{},
+		VersionedAPIPath: "/not/a/real/path",
 	}

 	resolver := NewDiscoveryScaleKindResolver(fakeDiscoveryClient)
--- a/scale/scheme/appsint/register.go
+++ b/scale/scheme/appsint/register.go
@@ -40,10 +40,8 @@ func Resource(resource string) schema.GroupResource {
 }

 var (
-	// SchemeBuilder points to a list of functions added to Scheme.
 	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
-	// AddToScheme applies all the stored functions to the scheme.
-	AddToScheme = SchemeBuilder.AddToScheme
+	AddToScheme   = SchemeBuilder.AddToScheme
 )

 // Adds the list of known types to api.Scheme.
--- a/scale/scheme/extensionsint/register.go
+++ b/scale/scheme/extensionsint/register.go
@@ -40,10 +40,8 @@ func Resource(resource string) schema.GroupResource {
 }

 var (
-	// SchemeBuilder points to a list of functions added to Scheme.
 	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
-	// AddToScheme applies all the stored functions to the scheme.
-	AddToScheme = SchemeBuilder.AddToScheme
+	AddToScheme   = SchemeBuilder.AddToScheme
 )

 // Adds the list of known types to api.Scheme.
--- a/scale/scheme/register.go
+++ b/scale/scheme/register.go
@@ -39,10 +39,8 @@ func Resource(resource string) schema.GroupResource {
 }

 var (
-	// SchemeBuilder points to a list of functions added to Scheme.
 	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
-	// AddToScheme applies all the stored functions to the scheme.
-	AddToScheme = SchemeBuilder.AddToScheme
+	AddToScheme   = SchemeBuilder.AddToScheme
 )

 // Adds the list of known types to api.Scheme.
--- a/tools/auth/clientauth.go
+++ b/tools/auth/clientauth.go
@@ -105,7 +105,7 @@ func LoadFromFile(path string) (*Info, error) {
 // The fields of client.Config with a corresponding field in the Info are set
 // with the value from the Info.
 func (info Info) MergeWithConfig(c restclient.Config) (restclient.Config, error) {
-	var config = c
+	var config restclient.Config = c
 	config.Username = info.User
 	config.Password = info.Password
 	config.CAFile = info.CAFile
@@ -118,7 +118,6 @@ func (info Info) MergeWithConfig(c restclient.Config) (restclient.Config, error)
 	return config, nil
 }

-// Complete returns true if the Kubernetes API authorization info is complete.
 func (info Info) Complete() bool {
 	return len(info.User) > 0 ||
 		len(info.CertFile) > 0 ||
--- a/tools/cache/delta_fifo.go
+++ b/tools/cache/delta_fifo.go
@@ -295,6 +295,13 @@ func isDeletionDup(a, b *Delta) *Delta {
 	return b
 }

+// willObjectBeDeletedLocked returns true only if the last delta for the
+// given object is Delete. Caller must lock first.
+func (f *DeltaFIFO) willObjectBeDeletedLocked(id string) bool {
+	deltas := f.items[id]
+	return len(deltas) > 0 && deltas[len(deltas)-1].Type == Deleted
+}
+
 // queueActionLocked appends to the delta list for the object.
 // Caller must lock first.
 func (f *DeltaFIFO) queueActionLocked(actionType DeltaType, obj interface{}) error {
@@ -303,6 +310,13 @@ func (f *DeltaFIFO) queueActionLocked(actionType DeltaType, obj interface{}) err
 		return KeyError{obj, err}
 	}

+	// If object is supposed to be deleted (last event is Deleted),
+	// then we should ignore Sync events, because it would result in
+	// recreation of this object.
+	if actionType == Sync && f.willObjectBeDeletedLocked(id) {
+		return nil
+	}
+
 	newDeltas := append(f.items[id], Delta{actionType, obj})
 	newDeltas = dedupDeltas(newDeltas)

--- a/tools/cache/delta_fifo_test.go
+++ b/tools/cache/delta_fifo_test.go
@@ -85,33 +85,6 @@ func TestDeltaFIFO_basic(t *testing.T) {
 	}
 }

-// TestDeltaFIFO_replaceWithDeleteDeltaIn tests that a `Sync` delta for an
-// object `O` with ID `X` is added when .Replace is called and `O` is among the
-// replacement objects even if the DeltaFIFO already stores in terminal position
-// a delta of type `Delete` for ID `X`. Not adding the `Sync` delta causes
-// SharedIndexInformers to miss `O`'s create notification, see https://github.com/kubernetes/kubernetes/issues/83810
-// for more details.
-func TestDeltaFIFO_replaceWithDeleteDeltaIn(t *testing.T) {
-	oldObj := mkFifoObj("foo", 1)
-	newObj := mkFifoObj("foo", 2)
-
-	f := NewDeltaFIFO(testFifoObjectKeyFunc, keyLookupFunc(func() []testFifoObject {
-		return []testFifoObject{oldObj}
-	}))
-
-	f.Delete(oldObj)
-	f.Replace([]interface{}{newObj}, "")
-
-	actualDeltas := Pop(f)
-	expectedDeltas := Deltas{
-		Delta{Type: Deleted, Object: oldObj},
-		Delta{Type: Sync, Object: newObj},
-	}
-	if !reflect.DeepEqual(expectedDeltas, actualDeltas) {
-		t.Errorf("expected %#v, got %#v", expectedDeltas, actualDeltas)
-	}
-}
-
 func TestDeltaFIFO_requeueOnPop(t *testing.T) {
 	f := NewDeltaFIFO(testFifoObjectKeyFunc, nil)

--- a/tools/cache/expiration_cache.go
+++ b/tools/cache/expiration_cache.go
@@ -48,7 +48,7 @@ type ExpirationCache struct {
 // ExpirationPolicy dictates when an object expires. Currently only abstracted out
 // so unittests don't rely on the system clock.
 type ExpirationPolicy interface {
-	IsExpired(obj *TimestampedEntry) bool
+	IsExpired(obj *timestampedEntry) bool
 }

 // TTLPolicy implements a ttl based ExpirationPolicy.
@@ -63,29 +63,26 @@ type TTLPolicy struct {

 // IsExpired returns true if the given object is older than the ttl, or it can't
 // determine its age.
-func (p *TTLPolicy) IsExpired(obj *TimestampedEntry) bool {
-	return p.Ttl > 0 && p.Clock.Since(obj.Timestamp) > p.Ttl
+func (p *TTLPolicy) IsExpired(obj *timestampedEntry) bool {
+	return p.Ttl > 0 && p.Clock.Since(obj.timestamp) > p.Ttl
 }

-// TimestampedEntry is the only type allowed in a ExpirationCache.
-// Keep in mind that it is not safe to share timestamps between computers.
-// Behavior may be inconsistent if you get a timestamp from the API Server and
-// use it on the client machine as part of your ExpirationCache.
-type TimestampedEntry struct {
-	Obj       interface{}
-	Timestamp time.Time
+// timestampedEntry is the only type allowed in a ExpirationCache.
+type timestampedEntry struct {
+	obj       interface{}
+	timestamp time.Time
 }

-// getTimestampedEntry returns the TimestampedEntry stored under the given key.
-func (c *ExpirationCache) getTimestampedEntry(key string) (*TimestampedEntry, bool) {
+// getTimestampedEntry returns the timestampedEntry stored under the given key.
+func (c *ExpirationCache) getTimestampedEntry(key string) (*timestampedEntry, bool) {
 	item, _ := c.cacheStorage.Get(key)
-	if tsEntry, ok := item.(*TimestampedEntry); ok {
+	if tsEntry, ok := item.(*timestampedEntry); ok {
 		return tsEntry, true
 	}
 	return nil, false
 }

-// getOrExpire retrieves the object from the TimestampedEntry if and only if it hasn't
+// getOrExpire retrieves the object from the timestampedEntry if and only if it hasn't
 // already expired. It holds a write lock across deletion.
 func (c *ExpirationCache) getOrExpire(key string) (interface{}, bool) {
 	// Prevent all inserts from the time we deem an item as "expired" to when we
@@ -98,11 +95,11 @@ func (c *ExpirationCache) getOrExpire(key string) (interface{}, bool) {
 		return nil, false
 	}
 	if c.expirationPolicy.IsExpired(timestampedItem) {
-		klog.V(4).Infof("Entry %v: %+v has expired", key, timestampedItem.Obj)
+		klog.V(4).Infof("Entry %v: %+v has expired", key, timestampedItem.obj)
 		c.cacheStorage.Delete(key)
 		return nil, false
 	}
-	return timestampedItem.Obj, true
+	return timestampedItem.obj, true
 }

 // GetByKey returns the item stored under the key, or sets exists=false.
@@ -129,7 +126,7 @@ func (c *ExpirationCache) List() []interface{} {

 	list := make([]interface{}, 0, len(items))
 	for _, item := range items {
-		obj := item.(*TimestampedEntry).Obj
+		obj := item.(*timestampedEntry).obj
 		if key, err := c.keyFunc(obj); err != nil {
 			list = append(list, obj)
 		} else if obj, exists := c.getOrExpire(key); exists {
@@ -154,7 +151,7 @@ func (c *ExpirationCache) Add(obj interface{}) error {
 	c.expirationLock.Lock()
 	defer c.expirationLock.Unlock()

-	c.cacheStorage.Add(key, &TimestampedEntry{obj, c.clock.Now()})
+	c.cacheStorage.Add(key, &timestampedEntry{obj, c.clock.Now()})
 	return nil
 }

@@ -187,7 +184,7 @@ func (c *ExpirationCache) Replace(list []interface{}, resourceVersion string) er
 		if err != nil {
 			return KeyError{item, err}
 		}
-		items[key] = &TimestampedEntry{item, ts}
+		items[key] = &timestampedEntry{item, ts}
 	}
 	c.expirationLock.Lock()
 	defer c.expirationLock.Unlock()
@@ -202,15 +199,10 @@ func (c *ExpirationCache) Resync() error {

 // NewTTLStore creates and returns a ExpirationCache with a TTLPolicy
 func NewTTLStore(keyFunc KeyFunc, ttl time.Duration) Store {
-	return NewExpirationStore(keyFunc, &TTLPolicy{ttl, clock.RealClock{}})
-}
-
-// NewExpirationStore creates and returns a ExpirationCache for a given policy
-func NewExpirationStore(keyFunc KeyFunc, expirationPolicy ExpirationPolicy) Store {
 	return &ExpirationCache{
 		cacheStorage:     NewThreadSafeStore(Indexers{}, Indices{}),
 		keyFunc:          keyFunc,
 		clock:            clock.RealClock{},
-		expirationPolicy: expirationPolicy,
+		expirationPolicy: &TTLPolicy{ttl, clock.RealClock{}},
 	}
 }
--- a/tools/cache/expiration_cache_fakes.go
+++ b/tools/cache/expiration_cache_fakes.go
@@ -38,7 +38,7 @@ type FakeExpirationPolicy struct {
 	RetrieveKeyFunc KeyFunc
 }

-func (p *FakeExpirationPolicy) IsExpired(obj *TimestampedEntry) bool {
+func (p *FakeExpirationPolicy) IsExpired(obj *timestampedEntry) bool {
 	key, _ := p.RetrieveKeyFunc(obj)
 	return !p.NeverExpire.Has(key)
 }
--- a/tools/cache/expiration_cache_test.go
+++ b/tools/cache/expiration_cache_test.go
@@ -34,7 +34,7 @@ func TestTTLExpirationBasic(t *testing.T) {
 		&FakeExpirationPolicy{
 			NeverExpire: sets.NewString(),
 			RetrieveKeyFunc: func(obj interface{}) (string, error) {
-				return obj.(*TimestampedEntry).Obj.(testStoreObject).id, nil
+				return obj.(*timestampedEntry).obj.(testStoreObject).id, nil
 			},
 		},
 		clock.RealClock{},
@@ -67,7 +67,7 @@ func TestReAddExpiredItem(t *testing.T) {
 	exp := &FakeExpirationPolicy{
 		NeverExpire: sets.NewString(),
 		RetrieveKeyFunc: func(obj interface{}) (string, error) {
-			return obj.(*TimestampedEntry).Obj.(testStoreObject).id, nil
+			return obj.(*timestampedEntry).obj.(testStoreObject).id, nil
 		},
 	}
 	ttlStore := NewFakeExpirationStore(
@@ -130,7 +130,7 @@ func TestTTLList(t *testing.T) {
 		&FakeExpirationPolicy{
 			NeverExpire: sets.NewString(testObjs[1].id),
 			RetrieveKeyFunc: func(obj interface{}) (string, error) {
-				return obj.(*TimestampedEntry).Obj.(testStoreObject).id, nil
+				return obj.(*timestampedEntry).obj.(testStoreObject).id, nil
 			},
 		},
 		clock.RealClock{},
@@ -168,15 +168,15 @@ func TestTTLPolicy(t *testing.T) {
 	expiredTime := fakeTime.Add(-(ttl + 1))

 	policy := TTLPolicy{ttl, clock.NewFakeClock(fakeTime)}
-	fakeTimestampedEntry := &TimestampedEntry{Obj: struct{}{}, Timestamp: exactlyOnTTL}
+	fakeTimestampedEntry := &timestampedEntry{obj: struct{}{}, timestamp: exactlyOnTTL}
 	if policy.IsExpired(fakeTimestampedEntry) {
 		t.Errorf("TTL cache should not expire entries exactly on ttl")
 	}
-	fakeTimestampedEntry.Timestamp = fakeTime
+	fakeTimestampedEntry.timestamp = fakeTime
 	if policy.IsExpired(fakeTimestampedEntry) {
 		t.Errorf("TTL Cache should not expire entries before ttl")
 	}
-	fakeTimestampedEntry.Timestamp = expiredTime
+	fakeTimestampedEntry.timestamp = expiredTime
 	if !policy.IsExpired(fakeTimestampedEntry) {
 		t.Errorf("TTL Cache should expire entries older than ttl")
 	}
--- a/tools/cache/reflector.go
+++ b/tools/cache/reflector.go
@@ -17,7 +17,6 @@ limitations under the License.
 package cache

 import (
-	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -25,6 +24,7 @@ import (
 	"net"
 	"net/url"
 	"reflect"
+	"strings"
 	"sync"
 	"syscall"
 	"time"
@@ -38,7 +38,6 @@ import (
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/tools/pager"
 	"k8s.io/klog"
 	"k8s.io/utils/trace"
 )
@@ -69,9 +68,6 @@ type Reflector struct {
 	lastSyncResourceVersion string
 	// lastSyncResourceVersionMutex guards read/write access to lastSyncResourceVersion
 	lastSyncResourceVersionMutex sync.RWMutex
-	// WatchListPageSize is the requested chunk size of initial and resync watch lists.
-	// Defaults to pager.PageSize.
-	WatchListPageSize int64
 }

 var (
@@ -83,7 +79,7 @@ var (
 // NewNamespaceKeyedIndexerAndReflector creates an Indexer and a Reflector
 // The indexer is configured to key on namespace
 func NewNamespaceKeyedIndexerAndReflector(lw ListerWatcher, expectedType interface{}, resyncPeriod time.Duration) (indexer Indexer, reflector *Reflector) {
-	indexer = NewIndexer(MetaNamespaceKeyFunc, Indexers{NamespaceIndex: MetaNamespaceIndexFunc})
+	indexer = NewIndexer(MetaNamespaceKeyFunc, Indexers{"namespace": MetaNamespaceIndexFunc})
 	reflector = NewReflector(lw, expectedType, indexer, resyncPeriod)
 	return indexer, reflector
 }
@@ -112,6 +108,11 @@ func NewNamedReflector(name string, lw ListerWatcher, expectedType interface{},
 	return r
 }

+func makeValidPrometheusMetricLabel(in string) string {
+	// this isn't perfect, but it removes our common characters
+	return strings.NewReplacer("/", "_", ".", "_", "-", "_", ":", "_").Replace(in)
+}
+
 // internalPackages are packages that ignored when creating a default reflector name. These packages are in the common
 // call chains to NewReflector, so they'd be low entropy names for reflectors
 var internalPackages = []string{"client-go/tools/cache/"}
@@ -178,16 +179,7 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error {
 					panicCh <- r
 				}
 			}()
-			// Attempt to gather list in chunks, if supported by listerWatcher, if not, the first
-			// list request will return the full response.
-			pager := pager.New(pager.SimplePageFunc(func(opts metav1.ListOptions) (runtime.Object, error) {
-				return r.listerWatcher.List(opts)
-			}))
-			if r.WatchListPageSize != 0 {
-				pager.PageSize = r.WatchListPageSize
-			}
-			// Pager falls back to full list if paginated list calls fail due to an "Expired" error.
-			list, err = pager.List(context.Background(), options)
+			list, err = r.listerWatcher.List(options)
 			close(listCh)
 		}()
 		select {
@@ -265,11 +257,6 @@ func (r *Reflector) ListAndWatch(stopCh <-chan struct{}) error {
 			// We want to avoid situations of hanging watchers. Stop any wachers that do not
 			// receive any events within the timeout window.
 			TimeoutSeconds: &timeoutSeconds,
-			// To reduce load on kube-apiserver on watch restarts, you may enable watch bookmarks.
-			// Reflector doesn't assume bookmarks are returned at all (if the server do not support
-			// watch bookmarks, it will ignore this field).
-			// Disabled in Alpha release of watch bookmarks feature.
-			AllowWatchBookmarks: false,
 		}

 		w, err := r.listerWatcher.Watch(options)
@@ -367,8 +354,6 @@ loop:
 				if err != nil {
 					utilruntime.HandleError(fmt.Errorf("%s: unable to delete watch event object (%#v) from store: %v", r.name, event.Object, err))
 				}
-			case watch.Bookmark:
-				// A `Bookmark` means watch has synced here, just update the resourceVersion
 			default:
 				utilruntime.HandleError(fmt.Errorf("%s: unable to understand watch event %#v", r.name, event))
 			}
@@ -378,7 +363,7 @@ loop:
 		}
 	}

-	watchDuration := r.clock.Since(start)
+	watchDuration := r.clock.Now().Sub(start)
 	if watchDuration < 1*time.Second && eventCount == 0 {
 		return fmt.Errorf("very short watch: %s: Unexpected watch close - watch lasted less than a second and no items received", r.name)
 	}
--- a/tools/cache/reflector_metrics.go
+++ b/tools/cache/reflector_metrics.go
@@ -94,6 +94,23 @@ var metricsFactory = struct {
 	metricsProvider: noopMetricsProvider{},
 }

+func newReflectorMetrics(name string) *reflectorMetrics {
+	var ret *reflectorMetrics
+	if len(name) == 0 {
+		return ret
+	}
+	return &reflectorMetrics{
+		numberOfLists:        metricsFactory.metricsProvider.NewListsMetric(name),
+		listDuration:         metricsFactory.metricsProvider.NewListDurationMetric(name),
+		numberOfItemsInList:  metricsFactory.metricsProvider.NewItemsInListMetric(name),
+		numberOfWatches:      metricsFactory.metricsProvider.NewWatchesMetric(name),
+		numberOfShortWatches: metricsFactory.metricsProvider.NewShortWatchesMetric(name),
+		watchDuration:        metricsFactory.metricsProvider.NewWatchDurationMetric(name),
+		numberOfItemsInWatch: metricsFactory.metricsProvider.NewItemsInWatchMetric(name),
+		lastResourceVersion:  metricsFactory.metricsProvider.NewLastResourceVersionMetric(name),
+	}
+}
+
 // SetReflectorMetricsProvider sets the metrics provider
 func SetReflectorMetricsProvider(metricsProvider MetricsProvider) {
 	metricsFactory.setProviders.Do(func() {
--- a/tools/cache/reflector_test.go
+++ b/tools/cache/reflector_test.go
@@ -24,7 +24,7 @@ import (
 	"testing"
 	"time"

-	v1 "k8s.io/api/core/v1"
+	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
@@ -387,46 +387,3 @@ func TestReflectorResync(t *testing.T) {
 		t.Errorf("exactly 2 iterations were expected, got: %v", iteration)
 	}
 }
-
-func TestReflectorWatchListPageSize(t *testing.T) {
-	stopCh := make(chan struct{})
-	s := NewStore(MetaNamespaceKeyFunc)
-
-	lw := &testLW{
-		WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-			// Stop once the reflector begins watching since we're only interested in the list.
-			close(stopCh)
-			fw := watch.NewFake()
-			return fw, nil
-		},
-		ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-			if options.Limit != 4 {
-				t.Fatalf("Expected list Limit of 4 but got %d", options.Limit)
-			}
-			pods := make([]v1.Pod, 10)
-			for i := 0; i < 10; i++ {
-				pods[i] = v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: fmt.Sprintf("pod-%d", i), ResourceVersion: fmt.Sprintf("%d", i)}}
-			}
-			switch options.Continue {
-			case "":
-				return &v1.PodList{ListMeta: metav1.ListMeta{ResourceVersion: "10", Continue: "C1"}, Items: pods[0:4]}, nil
-			case "C1":
-				return &v1.PodList{ListMeta: metav1.ListMeta{ResourceVersion: "10", Continue: "C2"}, Items: pods[4:8]}, nil
-			case "C2":
-				return &v1.PodList{ListMeta: metav1.ListMeta{ResourceVersion: "10"}, Items: pods[8:10]}, nil
-			default:
-				t.Fatalf("Unrecognized continue: %s", options.Continue)
-			}
-			return nil, nil
-		},
-	}
-	r := NewReflector(lw, &v1.Pod{}, s, 0)
-	// Set the reflector to paginate the list request in 4 item chunks.
-	r.WatchListPageSize = 4
-	r.ListAndWatch(stopCh)
-
-	results := s.List()
-	if len(results) != 10 {
-		t.Errorf("Expected 10 results, got %d", len(results))
-	}
-}
--- a/tools/cache/shared_informer.go
+++ b/tools/cache/shared_informer.go
@@ -31,84 +31,31 @@ import (
 	"k8s.io/klog"
 )

-// SharedInformer provides eventually consistent linkage of its
-// clients to the authoritative state of a given collection of
-// objects.  An object is identified by its API group, kind/resource,
-// namespace, and name.  One SharedInfomer provides linkage to objects
-// of a particular API group and kind/resource.  The linked object
-// collection of a SharedInformer may be further restricted to one
-// namespace and/or by label selector and/or field selector.
-//
-// The authoritative state of an object is what apiservers provide
-// access to, and an object goes through a strict sequence of states.
-// A state is either "absent" or present with a ResourceVersion and
-// other appropriate content.
-//
-// A SharedInformer maintains a local cache, exposed by Store(), of
-// the state of each relevant object.  This cache is eventually
-// consistent with the authoritative state.  This means that, unless
-// prevented by persistent communication problems, if ever a
-// particular object ID X is authoritatively associated with a state S
-// then for every SharedInformer I whose collection includes (X, S)
-// eventually either (1) I's cache associates X with S or a later
-// state of X, (2) I is stopped, or (3) the authoritative state
-// service for X terminates.  To be formally complete, we say that the
-// absent state meets any restriction by label selector or field
-// selector.
-//
-// As a simple example, if a collection of objects is henceforeth
-// unchanging and a SharedInformer is created that links to that
-// collection then that SharedInformer's cache eventually holds an
-// exact copy of that collection (unless it is stopped too soon, the
-// authoritative state service ends, or communication problems between
-// the two persistently thwart achievement).
-//
-// As another simple example, if the local cache ever holds a
-// non-absent state for some object ID and the object is eventually
-// removed from the authoritative state then eventually the object is
-// removed from the local cache (unless the SharedInformer is stopped
-// too soon, the authoritative state service emnds, or communication
-// problems persistently thwart the desired result).
-//
-// The keys in Store() are of the form namespace/name for namespaced
-// objects, and are simply the name for non-namespaced objects.
-//
-// A client is identified here by a ResourceEventHandler.  For every
-// update to the SharedInformer's local cache and for every client,
-// eventually either the SharedInformer is stopped or the client is
-// notified of the update.  These notifications happen after the
-// corresponding cache update and, in the case of a
-// SharedIndexInformer, after the corresponding index updates.  It is
-// possible that additional cache and index updates happen before such
-// a prescribed notification.  For a given SharedInformer and client,
-// all notifications are delivered sequentially.  For a given
-// SharedInformer, client, and object ID, the notifications are
-// delivered in order.
-//
-// A delete notification exposes the last locally known non-absent
-// state, except that its ResourceVersion is replaced with a
-// ResourceVersion in which the object is actually absent.
+// SharedInformer has a shared data cache and is capable of distributing notifications for changes
+// to the cache to multiple listeners who registered via AddEventHandler. If you use this, there is
+// one behavior change compared to a standard Informer.  When you receive a notification, the cache
+// will be AT LEAST as fresh as the notification, but it MAY be more fresh.  You should NOT depend
+// on the contents of the cache exactly matching the notification you've received in handler
+// functions.  If there was a create, followed by a delete, the cache may NOT have your item.  This
+// has advantages over the broadcaster since it allows us to share a common cache across many
+// controllers. Extending the broadcaster would have required us keep duplicate caches for each
+// watch.
 type SharedInformer interface {
 	// AddEventHandler adds an event handler to the shared informer using the shared informer's resync
 	// period.  Events to a single handler are delivered sequentially, but there is no coordination
 	// between different handlers.
 	AddEventHandler(handler ResourceEventHandler)
-	// AddEventHandlerWithResyncPeriod adds an event handler to the
-	// shared informer using the specified resync period.  The resync
-	// operation consists of delivering to the handler a create
-	// notification for every object in the informer's local cache; it
-	// does not add any interactions with the authoritative storage.
+	// AddEventHandlerWithResyncPeriod adds an event handler to the shared informer using the
+	// specified resync period.  Events to a single handler are delivered sequentially, but there is
+	// no coordination between different handlers.
 	AddEventHandlerWithResyncPeriod(handler ResourceEventHandler, resyncPeriod time.Duration)
-	// GetStore returns the informer's local cache as a Store.
+	// GetStore returns the Store.
 	GetStore() Store
 	// GetController gives back a synthetic interface that "votes" to start the informer
 	GetController() Controller
-	// Run starts and runs the shared informer, returning after it stops.
-	// The informer will be stopped when stopCh is closed.
+	// Run starts the shared informer, which will be stopped when stopCh is closed.
 	Run(stopCh <-chan struct{})
-	// HasSynced returns true if the shared informer's store has been
-	// informed by at least one full LIST of the authoritative state
-	// of the informer's object collection.  This is unrelated to "resync".
+	// HasSynced returns true if the shared informer's store has synced.
 	HasSynced() bool
 	// LastSyncResourceVersion is the resource version observed when last synced with the underlying
 	// store. The value returned is not synchronized with access to the underlying store and is not
@@ -608,7 +555,7 @@ func (p *processorListener) run() {
 				case deleteNotification:
 					p.handler.OnDelete(notification.oldObj)
 				default:
-					utilruntime.HandleError(fmt.Errorf("unrecognized notification: %T", next))
+					utilruntime.HandleError(fmt.Errorf("unrecognized notification: %#v", next))
 				}
 			}
 			// the only way to get here is if the p.nextCh is empty and closed
--- a/tools/cache/thread_safe_store.go
+++ b/tools/cache/thread_safe_store.go
@@ -185,7 +185,7 @@ func (c *threadSafeMap) ByIndex(indexName, indexKey string) ([]interface{}, erro

 	set := index[indexKey]
 	list := make([]interface{}, 0, set.Len())
-	for key := range set {
+	for _, key := range set.List() {
 		list = append(list, c.items[key])
 	}

--- a/tools/clientcmd/client_config.go
+++ b/tools/clientcmd/client_config.go
@@ -228,7 +228,6 @@ func (config *DirectClientConfig) getUserIdentificationPartialConfig(configAuthI
 	// blindly overwrite existing values based on precedence
 	if len(configAuthInfo.Token) > 0 {
 		mergedConfig.BearerToken = configAuthInfo.Token
-		mergedConfig.BearerTokenFile = configAuthInfo.TokenFile
 	} else if len(configAuthInfo.TokenFile) > 0 {
 		tokenBytes, err := ioutil.ReadFile(configAuthInfo.TokenFile)
 		if err != nil {
@@ -297,6 +296,16 @@ func makeUserIdentificationConfig(info clientauth.Info) *restclient.Config {
 	return config
 }

+// makeUserIdentificationFieldsConfig returns a client.Config capable of being merged using mergo for only server identification information
+func makeServerIdentificationConfig(info clientauth.Info) restclient.Config {
+	config := restclient.Config{}
+	config.CAFile = info.CAFile
+	if info.Insecure != nil {
+		config.Insecure = *info.Insecure
+	}
+	return config
+}
+
 func canIdentifyUser(config restclient.Config) bool {
 	return len(config.Username) > 0 ||
 		(len(config.CertFile) > 0 || len(config.CertData) > 0) ||
@@ -490,9 +499,8 @@ func (config *inClusterClientConfig) ClientConfig() (*restclient.Config, error)
 		if server := config.overrides.ClusterInfo.Server; len(server) > 0 {
 			icc.Host = server
 		}
-		if len(config.overrides.AuthInfo.Token) > 0 || len(config.overrides.AuthInfo.TokenFile) > 0 {
-			icc.BearerToken = config.overrides.AuthInfo.Token
-			icc.BearerTokenFile = config.overrides.AuthInfo.TokenFile
+		if token := config.overrides.AuthInfo.Token; len(token) > 0 {
+			icc.BearerToken = token
 		}
 		if certificateAuthorityFile := config.overrides.ClusterInfo.CertificateAuthority; len(certificateAuthorityFile) > 0 {
 			icc.TLSClientConfig.CAFile = certificateAuthorityFile
--- a/tools/clientcmd/client_config_test.go
+++ b/tools/clientcmd/client_config_test.go
@@ -548,30 +548,6 @@ func TestInClusterClientConfigPrecedence(t *testing.T) {
 				},
 			},
 		},
-		{
-			overrides: &ConfigOverrides{
-				ClusterInfo: clientcmdapi.Cluster{
-					Server:               "https://host-from-overrides.com",
-					CertificateAuthority: "/path/to/ca-from-overrides.crt",
-				},
-				AuthInfo: clientcmdapi.AuthInfo{
-					Token:     "token-from-override",
-					TokenFile: "tokenfile-from-override",
-				},
-			},
-		},
-		{
-			overrides: &ConfigOverrides{
-				ClusterInfo: clientcmdapi.Cluster{
-					Server:               "https://host-from-overrides.com",
-					CertificateAuthority: "/path/to/ca-from-overrides.crt",
-				},
-				AuthInfo: clientcmdapi.AuthInfo{
-					Token:     "",
-					TokenFile: "tokenfile-from-override",
-				},
-			},
-		},
 		{
 			overrides: &ConfigOverrides{},
 		},
@@ -580,15 +556,13 @@ func TestInClusterClientConfigPrecedence(t *testing.T) {
 	for _, tc := range tt {
 		expectedServer := "https://host-from-cluster.com"
 		expectedToken := "token-from-cluster"
-		expectedTokenFile := "tokenfile-from-cluster"
 		expectedCAFile := "/path/to/ca-from-cluster.crt"

 		icc := &inClusterClientConfig{
 			inClusterConfigProvider: func() (*restclient.Config, error) {
 				return &restclient.Config{
-					Host:            expectedServer,
-					BearerToken:     expectedToken,
-					BearerTokenFile: expectedTokenFile,
+					Host:        expectedServer,
+					BearerToken: expectedToken,
 					TLSClientConfig: restclient.TLSClientConfig{
 						CAFile: expectedCAFile,
 					},
@@ -605,9 +579,8 @@ func TestInClusterClientConfigPrecedence(t *testing.T) {
 		if overridenServer := tc.overrides.ClusterInfo.Server; len(overridenServer) > 0 {
 			expectedServer = overridenServer
 		}
-		if len(tc.overrides.AuthInfo.Token) > 0 || len(tc.overrides.AuthInfo.TokenFile) > 0 {
-			expectedToken = tc.overrides.AuthInfo.Token
-			expectedTokenFile = tc.overrides.AuthInfo.TokenFile
+		if overridenToken := tc.overrides.AuthInfo.Token; len(overridenToken) > 0 {
+			expectedToken = overridenToken
 		}
 		if overridenCAFile := tc.overrides.ClusterInfo.CertificateAuthority; len(overridenCAFile) > 0 {
 			expectedCAFile = overridenCAFile
@@ -619,9 +592,6 @@ func TestInClusterClientConfigPrecedence(t *testing.T) {
 		if clientConfig.BearerToken != expectedToken {
 			t.Errorf("Expected token %v, got %v", expectedToken, clientConfig.BearerToken)
 		}
-		if clientConfig.BearerTokenFile != expectedTokenFile {
-			t.Errorf("Expected tokenfile %v, got %v", expectedTokenFile, clientConfig.BearerTokenFile)
-		}
 		if clientConfig.TLSClientConfig.CAFile != expectedCAFile {
 			t.Errorf("Expected Certificate Authority %v, got %v", expectedCAFile, clientConfig.TLSClientConfig.CAFile)
 		}
--- a/tools/clientcmd/loader.go
+++ b/tools/clientcmd/loader.go
@@ -356,7 +356,7 @@ func LoadFromFile(filename string) (*clientcmdapi.Config, error) {
 	if err != nil {
 		return nil, err
 	}
-	klog.V(6).Infoln("Config loaded from file: ", filename)
+	klog.V(6).Infoln("Config loaded from file", filename)

 	// set LocationOfOrigin on every Cluster, User, and Context
 	for key, obj := range config.AuthInfos {
--- a/tools/events/event_broadcaster.go
+++ b/tools/events/event_broadcaster.go
@@ -1,312 +0,0 @@
-/*
-Copyright 2019 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 events
-
-import (
-	"os"
-	"sync"
-	"time"
-
-	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/util/clock"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
-	"k8s.io/apimachinery/pkg/watch"
-	restclient "k8s.io/client-go/rest"
-
-	"k8s.io/api/events/v1beta1"
-	"k8s.io/apimachinery/pkg/util/json"
-	"k8s.io/apimachinery/pkg/util/strategicpatch"
-	"k8s.io/apimachinery/pkg/util/wait"
-	typedv1beta1 "k8s.io/client-go/kubernetes/typed/events/v1beta1"
-	"k8s.io/client-go/tools/record/util"
-	"k8s.io/klog"
-)
-
-const (
-	maxTriesPerEvent = 12
-	finishTime       = 6 * time.Minute
-	refreshTime      = 30 * time.Minute
-	maxQueuedEvents  = 1000
-)
-
-var defaultSleepDuration = 10 * time.Second
-
-// TODO: validate impact of copying and investigate hashing
-type eventKey struct {
-	action              string
-	reason              string
-	reportingController string
-	reportingInstance   string
-	regarding           corev1.ObjectReference
-	related             corev1.ObjectReference
-}
-
-type eventBroadcasterImpl struct {
-	*watch.Broadcaster
-	mu            sync.Mutex
-	eventCache    map[eventKey]*v1beta1.Event
-	sleepDuration time.Duration
-	sink          EventSink
-}
-
-// EventSinkImpl wraps EventInterface to implement EventSink.
-// TODO: this makes it easier for testing purpose and masks the logic of performing API calls.
-// Note that rollbacking to raw clientset should also be transparent.
-type EventSinkImpl struct {
-	Interface typedv1beta1.EventInterface
-}
-
-// Create is the same as CreateWithEventNamespace of the EventExpansion
-func (e *EventSinkImpl) Create(event *v1beta1.Event) (*v1beta1.Event, error) {
-	return e.Interface.CreateWithEventNamespace(event)
-}
-
-// Update is the same as UpdateithEventNamespace of the EventExpansion
-func (e *EventSinkImpl) Update(event *v1beta1.Event) (*v1beta1.Event, error) {
-	return e.Interface.UpdateWithEventNamespace(event)
-}
-
-// Patch is the same as PatchWithEventNamespace of the EventExpansion
-func (e *EventSinkImpl) Patch(event *v1beta1.Event, data []byte) (*v1beta1.Event, error) {
-	return e.Interface.PatchWithEventNamespace(event, data)
-}
-
-// NewBroadcaster Creates a new event broadcaster.
-func NewBroadcaster(sink EventSink) EventBroadcaster {
-	return newBroadcaster(sink, defaultSleepDuration, map[eventKey]*v1beta1.Event{})
-}
-
-// NewBroadcasterForTest Creates a new event broadcaster for test purposes.
-func newBroadcaster(sink EventSink, sleepDuration time.Duration, eventCache map[eventKey]*v1beta1.Event) EventBroadcaster {
-	return &eventBroadcasterImpl{
-		Broadcaster:   watch.NewBroadcaster(maxQueuedEvents, watch.DropIfChannelFull),
-		eventCache:    eventCache,
-		sleepDuration: sleepDuration,
-		sink:          sink,
-	}
-}
-
-// refreshExistingEventSeries refresh events TTL
-func (e *eventBroadcasterImpl) refreshExistingEventSeries() {
-	// TODO: Investigate whether lock contention won't be a problem
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	for isomorphicKey, event := range e.eventCache {
-		if event.Series != nil {
-			if recordedEvent, retry := recordEvent(e.sink, event); !retry {
-				e.eventCache[isomorphicKey] = recordedEvent
-			}
-		}
-	}
-}
-
-// finishSeries checks if a series has ended and either:
-// - write final count to the apiserver
-// - delete a singleton event (i.e. series field is nil) from the cache
-func (e *eventBroadcasterImpl) finishSeries() {
-	// TODO: Investigate whether lock contention won't be a problem
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	for isomorphicKey, event := range e.eventCache {
-		eventSerie := event.Series
-		if eventSerie != nil {
-			if eventSerie.LastObservedTime.Time.Before(time.Now().Add(-finishTime)) {
-				if _, retry := recordEvent(e.sink, event); !retry {
-					delete(e.eventCache, isomorphicKey)
-				}
-			}
-		} else if event.EventTime.Time.Before(time.Now().Add(-finishTime)) {
-			delete(e.eventCache, isomorphicKey)
-		}
-	}
-}
-
-// NewRecorder returns an EventRecorder that records events with the given event source.
-func (e *eventBroadcasterImpl) NewRecorder(scheme *runtime.Scheme, reportingController string) EventRecorder {
-	hostname, _ := os.Hostname()
-	reportingInstance := reportingController + "-" + hostname
-	return &recorderImpl{scheme, reportingController, reportingInstance, e.Broadcaster, clock.RealClock{}}
-}
-
-func (e *eventBroadcasterImpl) recordToSink(event *v1beta1.Event, clock clock.Clock) {
-	// Make a copy before modification, because there could be multiple listeners.
-	eventCopy := event.DeepCopy()
-	go func() {
-		evToRecord := func() *v1beta1.Event {
-			e.mu.Lock()
-			defer e.mu.Unlock()
-			eventKey := getKey(eventCopy)
-			isomorphicEvent, isIsomorphic := e.eventCache[eventKey]
-			if isIsomorphic {
-				if isomorphicEvent.Series != nil {
-					isomorphicEvent.Series.Count++
-					isomorphicEvent.Series.LastObservedTime = metav1.MicroTime{Time: clock.Now()}
-					return nil
-				}
-				isomorphicEvent.Series = &v1beta1.EventSeries{
-					Count:            1,
-					LastObservedTime: metav1.MicroTime{Time: clock.Now()},
-				}
-				return isomorphicEvent
-			}
-			e.eventCache[eventKey] = eventCopy
-			return eventCopy
-		}()
-		if evToRecord != nil {
-			recordedEvent := e.attemptRecording(evToRecord)
-			if recordedEvent != nil {
-				recordedEventKey := getKey(recordedEvent)
-				e.mu.Lock()
-				defer e.mu.Unlock()
-				e.eventCache[recordedEventKey] = recordedEvent
-			}
-		}
-	}()
-}
-
-func (e *eventBroadcasterImpl) attemptRecording(event *v1beta1.Event) *v1beta1.Event {
-	tries := 0
-	for {
-		if recordedEvent, retry := recordEvent(e.sink, event); !retry {
-			return recordedEvent
-		}
-		tries++
-		if tries >= maxTriesPerEvent {
-			klog.Errorf("Unable to write event '%#v' (retry limit exceeded!)", event)
-			return nil
-		}
-		// Randomize sleep so that various clients won't all be
-		// synced up if the master goes down.
-		time.Sleep(wait.Jitter(e.sleepDuration, 0.25))
-	}
-}
-
-func recordEvent(sink EventSink, event *v1beta1.Event) (*v1beta1.Event, bool) {
-	var newEvent *v1beta1.Event
-	var err error
-	isEventSeries := event.Series != nil
-	if isEventSeries {
-		patch, err := createPatchBytesForSeries(event)
-		if err != nil {
-			klog.Errorf("Unable to calculate diff, no merge is possible: %v", err)
-			return nil, false
-		}
-		newEvent, err = sink.Patch(event, patch)
-	}
-	// Update can fail because the event may have been removed and it no longer exists.
-	if !isEventSeries || (isEventSeries && util.IsKeyNotFoundError(err)) {
-		// Making sure that ResourceVersion is empty on creation
-		event.ResourceVersion = ""
-		newEvent, err = sink.Create(event)
-	}
-	if err == nil {
-		return newEvent, false
-	}
-	// If we can't contact the server, then hold everything while we keep trying.
-	// Otherwise, something about the event is malformed and we should abandon it.
-	switch err.(type) {
-	case *restclient.RequestConstructionError:
-		// We will construct the request the same next time, so don't keep trying.
-		klog.Errorf("Unable to construct event '%#v': '%v' (will not retry!)", event, err)
-		return nil, false
-	case *errors.StatusError:
-		if errors.IsAlreadyExists(err) {
-			klog.V(5).Infof("Server rejected event '%#v': '%v' (will not retry!)", event, err)
-		} else {
-			klog.Errorf("Server rejected event '%#v': '%v' (will not retry!)", event, err)
-		}
-		return nil, false
-	case *errors.UnexpectedObjectError:
-		// We don't expect this; it implies the server's response didn't match a
-		// known pattern. Go ahead and retry.
-	default:
-		// This case includes actual http transport errors. Go ahead and retry.
-	}
-	klog.Errorf("Unable to write event: '%v' (may retry after sleeping)", err)
-	return nil, true
-}
-
-func createPatchBytesForSeries(event *v1beta1.Event) ([]byte, error) {
-	oldEvent := event.DeepCopy()
-	oldEvent.Series = nil
-	oldData, err := json.Marshal(oldEvent)
-	if err != nil {
-		return nil, err
-	}
-	newData, err := json.Marshal(event)
-	if err != nil {
-		return nil, err
-	}
-	return strategicpatch.CreateTwoWayMergePatch(oldData, newData, v1beta1.Event{})
-}
-
-func getKey(event *v1beta1.Event) eventKey {
-	key := eventKey{
-		action:              event.Action,
-		reason:              event.Reason,
-		reportingController: event.ReportingController,
-		reportingInstance:   event.ReportingInstance,
-		regarding:           event.Regarding,
-	}
-	if event.Related != nil {
-		key.related = *event.Related
-	}
-	return key
-}
-
-// startEventWatcher starts sending events received from this EventBroadcaster to the given event handler function.
-// The return value is used to stop recording
-func (e *eventBroadcasterImpl) startEventWatcher(eventHandler func(event runtime.Object)) func() {
-	watcher := e.Watch()
-	go func() {
-		defer utilruntime.HandleCrash()
-		for {
-			watchEvent, ok := <-watcher.ResultChan()
-			if !ok {
-				return
-			}
-			eventHandler(watchEvent.Object)
-		}
-	}()
-	return watcher.Stop
-}
-
-// StartRecordingToSink starts sending events received from the specified eventBroadcaster to the given sink.
-func (e *eventBroadcasterImpl) StartRecordingToSink(stopCh <-chan struct{}) {
-	go wait.Until(func() {
-		e.refreshExistingEventSeries()
-	}, refreshTime, stopCh)
-	go wait.Until(func() {
-		e.finishSeries()
-	}, finishTime, stopCh)
-	eventHandler := func(obj runtime.Object) {
-		event, ok := obj.(*v1beta1.Event)
-		if !ok {
-			klog.Errorf("unexpected type, expected v1beta1.Event")
-			return
-		}
-		e.recordToSink(event, clock.RealClock{})
-	}
-	stopWatcher := e.startEventWatcher(eventHandler)
-	go func() {
-		<-stopCh
-		stopWatcher()
-	}()
-}
--- a/tools/events/event_recorder.go
+++ b/tools/events/event_recorder.go
@@ -1,92 +0,0 @@
-/*
-Copyright 2019 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 events
-
-import (
-	"fmt"
-	"time"
-
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/util/clock"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/tools/reference"
-
-	"k8s.io/api/events/v1beta1"
-	"k8s.io/client-go/tools/record/util"
-	"k8s.io/klog"
-)
-
-type recorderImpl struct {
-	scheme              *runtime.Scheme
-	reportingController string
-	reportingInstance   string
-	*watch.Broadcaster
-	clock clock.Clock
-}
-
-func (recorder *recorderImpl) Eventf(regarding runtime.Object, related runtime.Object, eventtype, reason, action, note string, args ...interface{}) {
-	timestamp := metav1.MicroTime{time.Now()}
-	message := fmt.Sprintf(note, args...)
-	refRegarding, err := reference.GetReference(recorder.scheme, regarding)
-	if err != nil {
-		klog.Errorf("Could not construct reference to: '%#v' due to: '%v'. Will not report event: '%v' '%v' '%v'", regarding, err, eventtype, reason, message)
-		return
-	}
-	refRelated, err := reference.GetReference(recorder.scheme, related)
-	if err != nil {
-		klog.Errorf("Could not construct reference to: '%#v' due to: '%v'.", related, err)
-	}
-	if !util.ValidateEventType(eventtype) {
-		klog.Errorf("Unsupported event type: '%v'", eventtype)
-		return
-	}
-	event := recorder.makeEvent(refRegarding, refRelated, timestamp, eventtype, reason, message, recorder.reportingController, recorder.reportingInstance, action)
-	go func() {
-		defer utilruntime.HandleCrash()
-		recorder.Action(watch.Added, event)
-	}()
-}
-
-func (recorder *recorderImpl) makeEvent(refRegarding *v1.ObjectReference, refRelated *v1.ObjectReference, timestamp metav1.MicroTime, eventtype, reason, message string, reportingController string, reportingInstance string, action string) *v1beta1.Event {
-	t := metav1.Time{Time: recorder.clock.Now()}
-	namespace := refRegarding.Namespace
-	if namespace == "" {
-		namespace = metav1.NamespaceSystem
-	}
-	return &v1beta1.Event{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      fmt.Sprintf("%v.%x", refRegarding.Name, t.UnixNano()),
-			Namespace: namespace,
-		},
-		EventTime:           timestamp,
-		Series:              nil,
-		ReportingController: reportingController,
-		ReportingInstance:   reportingInstance,
-		Action:              action,
-		Reason:              reason,
-		Regarding:           *refRegarding,
-		Related:             refRelated,
-		Note:                message,
-		Type:                eventtype,
-		// TODO: remove this when we change conversion to convert eventSource
-		// to reportingController
-		DeprecatedSource: v1.EventSource{Component: reportingController},
-	}
-}
--- a/tools/events/eventseries_test.go
+++ b/tools/events/eventseries_test.go
@@ -1,349 +0,0 @@
-/*
-Copyright 2019 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 events
-
-import (
-	"strconv"
-	"testing"
-	"time"
-
-	"os"
-	"strings"
-
-	v1 "k8s.io/api/core/v1"
-	"k8s.io/api/events/v1beta1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	k8sruntime "k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/client-go/kubernetes/scheme"
-	ref "k8s.io/client-go/tools/reference"
-)
-
-type testEventSeriesSink struct {
-	OnCreate func(e *v1beta1.Event) (*v1beta1.Event, error)
-	OnUpdate func(e *v1beta1.Event) (*v1beta1.Event, error)
-	OnPatch  func(e *v1beta1.Event, p []byte) (*v1beta1.Event, error)
-}
-
-// Create records the event for testing.
-func (t *testEventSeriesSink) Create(e *v1beta1.Event) (*v1beta1.Event, error) {
-	if t.OnCreate != nil {
-		return t.OnCreate(e)
-	}
-	return e, nil
-}
-
-// Update records the event for testing.
-func (t *testEventSeriesSink) Update(e *v1beta1.Event) (*v1beta1.Event, error) {
-	if t.OnUpdate != nil {
-		return t.OnUpdate(e)
-	}
-	return e, nil
-}
-
-// Patch records the event for testing.
-func (t *testEventSeriesSink) Patch(e *v1beta1.Event, p []byte) (*v1beta1.Event, error) {
-	if t.OnPatch != nil {
-		return t.OnPatch(e, p)
-	}
-	return e, nil
-}
-
-func TestEventSeriesf(t *testing.T) {
-	hostname, _ := os.Hostname()
-
-	testPod := &v1.Pod{
-		ObjectMeta: metav1.ObjectMeta{
-			SelfLink:  "/api/version/pods/foo",
-			Name:      "foo",
-			Namespace: "baz",
-			UID:       "bar",
-		},
-	}
-
-	regarding, err := ref.GetPartialReference(scheme.Scheme, testPod, ".spec.containers[1]")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	related, err := ref.GetPartialReference(scheme.Scheme, testPod, ".spec.containers[0]")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expectedEvent := &v1beta1.Event{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "foo",
-			Namespace: "baz",
-		},
-		EventTime:           metav1.MicroTime{time.Now()},
-		ReportingController: "eventTest",
-		ReportingInstance:   "eventTest-" + hostname,
-		Action:              "started",
-		Reason:              "test",
-		Regarding:           *regarding,
-		Related:             related,
-		Note:                "some verbose message: 1",
-		Type:                v1.EventTypeNormal,
-	}
-
-	isomorphicEvent := expectedEvent.DeepCopy()
-
-	nonIsomorphicEvent := expectedEvent.DeepCopy()
-	nonIsomorphicEvent.Action = "stopped"
-
-	expectedEvent.Series = &v1beta1.EventSeries{Count: 1}
-	table := []struct {
-		regarding    k8sruntime.Object
-		related      k8sruntime.Object
-		actual       *v1beta1.Event
-		elements     []interface{}
-		expect       *v1beta1.Event
-		expectUpdate bool
-	}{
-		{
-			regarding:    regarding,
-			related:      related,
-			actual:       isomorphicEvent,
-			elements:     []interface{}{1},
-			expect:       expectedEvent,
-			expectUpdate: true,
-		},
-		{
-			regarding:    regarding,
-			related:      related,
-			actual:       nonIsomorphicEvent,
-			elements:     []interface{}{1},
-			expect:       nonIsomorphicEvent,
-			expectUpdate: false,
-		},
-	}
-
-	stopCh := make(chan struct{})
-
-	createEvent := make(chan *v1beta1.Event)
-	updateEvent := make(chan *v1beta1.Event)
-	patchEvent := make(chan *v1beta1.Event)
-
-	testEvents := testEventSeriesSink{
-		OnCreate: func(event *v1beta1.Event) (*v1beta1.Event, error) {
-			createEvent <- event
-			return event, nil
-		},
-		OnUpdate: func(event *v1beta1.Event) (*v1beta1.Event, error) {
-			updateEvent <- event
-			return event, nil
-		},
-		OnPatch: func(event *v1beta1.Event, patch []byte) (*v1beta1.Event, error) {
-			// event we receive is already patched, usually the sink uses it only to retrieve the name and namespace, here
-			// we'll use it directly
-			patchEvent <- event
-			return event, nil
-		},
-	}
-	eventBroadcaster := newBroadcaster(&testEvents, 0, map[eventKey]*v1beta1.Event{})
-	recorder := eventBroadcaster.NewRecorder(scheme.Scheme, "eventTest")
-	eventBroadcaster.StartRecordingToSink(stopCh)
-	recorder.Eventf(regarding, related, isomorphicEvent.Type, isomorphicEvent.Reason, isomorphicEvent.Action, isomorphicEvent.Note, []interface{}{1})
-	// read from the chan as this was needed only to populate the cache
-	<-createEvent
-	for index, item := range table {
-		actual := item.actual
-		recorder.Eventf(item.regarding, item.related, actual.Type, actual.Reason, actual.Action, actual.Note, item.elements)
-		// validate event
-		if item.expectUpdate {
-			actualEvent := <-patchEvent
-			t.Logf("%v - validating event affected by patch request", index)
-			validateEventSerie(strconv.Itoa(index), true, actualEvent, item.expect, t)
-		} else {
-			actualEvent := <-createEvent
-			t.Logf("%v - validating event affected by a create request", index)
-			validateEventSerie(strconv.Itoa(index), false, actualEvent, item.expect, t)
-		}
-	}
-	close(stopCh)
-}
-
-func validateEventSerie(messagePrefix string, expectedUpdate bool, actualEvent *v1beta1.Event, expectedEvent *v1beta1.Event, t *testing.T) {
-	recvEvent := *actualEvent
-
-	// Just check that the timestamp was set.
-	if recvEvent.EventTime.IsZero() {
-		t.Errorf("%v - timestamp wasn't set: %#v", messagePrefix, recvEvent)
-	}
-
-	if expectedUpdate {
-		if recvEvent.Series == nil {
-			t.Errorf("%v - Series was nil but expected: %#v", messagePrefix, recvEvent.Series)
-
-		} else {
-			if recvEvent.Series.Count != expectedEvent.Series.Count {
-				t.Errorf("%v - Series mismatch actual was: %#v but expected: %#v", messagePrefix, recvEvent.Series, expectedEvent.Series)
-			}
-		}
-
-		// Check that name has the right prefix.
-		if n, en := recvEvent.Name, expectedEvent.Name; !strings.HasPrefix(n, en) {
-			t.Errorf("%v - Name '%v' does not contain prefix '%v'", messagePrefix, n, en)
-		}
-	} else {
-		if recvEvent.Series != nil {
-			t.Errorf("%v - series was expected to be nil but was: %#v", messagePrefix, recvEvent.Series)
-		}
-	}
-
-}
-
-func TestFinishSeries(t *testing.T) {
-	hostname, _ := os.Hostname()
-	testPod := &v1.Pod{
-		ObjectMeta: metav1.ObjectMeta{
-			SelfLink:  "/api/version/pods/foo",
-			Name:      "foo",
-			Namespace: "baz",
-			UID:       "bar",
-		},
-	}
-	regarding, err := ref.GetPartialReference(scheme.Scheme, testPod, ".spec.containers[1]")
-	if err != nil {
-		t.Fatal(err)
-	}
-	related, err := ref.GetPartialReference(scheme.Scheme, testPod, ".spec.containers[0]")
-	if err != nil {
-		t.Fatal(err)
-	}
-	LastObservedTime := metav1.MicroTime{Time: time.Now().Add(-9 * time.Minute)}
-
-	createEvent := make(chan *v1beta1.Event, 10)
-	updateEvent := make(chan *v1beta1.Event, 10)
-	patchEvent := make(chan *v1beta1.Event, 10)
-	testEvents := testEventSeriesSink{
-		OnCreate: func(event *v1beta1.Event) (*v1beta1.Event, error) {
-			createEvent <- event
-			return event, nil
-		},
-		OnUpdate: func(event *v1beta1.Event) (*v1beta1.Event, error) {
-			updateEvent <- event
-			return event, nil
-		},
-		OnPatch: func(event *v1beta1.Event, patch []byte) (*v1beta1.Event, error) {
-			// event we receive is already patched, usually the sink uses it
-			// only to retrieve the name and namespace, here we'll use it directly
-			patchEvent <- event
-			return event, nil
-		},
-	}
-	cache := map[eventKey]*v1beta1.Event{}
-	eventBroadcaster := newBroadcaster(&testEvents, 0, cache).(*eventBroadcasterImpl)
-	recorder := eventBroadcaster.NewRecorder(scheme.Scheme, "k8s.io/kube-foo").(*recorderImpl)
-	cachedEvent := recorder.makeEvent(regarding, related, metav1.MicroTime{time.Now()}, v1.EventTypeNormal, "test", "some verbose message: 1", "eventTest", "eventTest-"+hostname, "started")
-	nonFinishedEvent := cachedEvent.DeepCopy()
-	nonFinishedEvent.ReportingController = "nonFinished-controller"
-	cachedEvent.Series = &v1beta1.EventSeries{
-		Count:            10,
-		LastObservedTime: LastObservedTime,
-	}
-	cache[getKey(cachedEvent)] = cachedEvent
-	cache[getKey(nonFinishedEvent)] = nonFinishedEvent
-	eventBroadcaster.finishSeries()
-	select {
-	case actualEvent := <-patchEvent:
-		t.Logf("validating event affected by patch request")
-		eventBroadcaster.mu.Lock()
-		defer eventBroadcaster.mu.Unlock()
-		if len(cache) != 1 {
-			t.Errorf("cache should be empty, but instead got a size of %v", len(cache))
-		}
-		if !actualEvent.Series.LastObservedTime.Equal(&cachedEvent.Series.LastObservedTime) {
-			t.Errorf("series was expected be seen with LastObservedTime %v, but instead got %v ", cachedEvent.Series.LastObservedTime, actualEvent.Series.LastObservedTime)
-		}
-		// check that we emitted only one event
-		if len(patchEvent) != 0 || len(createEvent) != 0 || len(updateEvent) != 0 {
-			t.Errorf("exactly one event should be emitted, but got %v", len(patchEvent))
-		}
-	case <-time.After(wait.ForeverTestTimeout):
-		t.Fatalf("timeout after %v", wait.ForeverTestTimeout)
-	}
-}
-
-func TestRefreshExistingEventSeries(t *testing.T) {
-	hostname, _ := os.Hostname()
-	testPod := &v1.Pod{
-		ObjectMeta: metav1.ObjectMeta{
-			SelfLink:  "/api/version/pods/foo",
-			Name:      "foo",
-			Namespace: "baz",
-			UID:       "bar",
-		},
-	}
-	regarding, err := ref.GetPartialReference(scheme.Scheme, testPod, ".spec.containers[1]")
-	if err != nil {
-		t.Fatal(err)
-	}
-	related, err := ref.GetPartialReference(scheme.Scheme, testPod, ".spec.containers[0]")
-	if err != nil {
-		t.Fatal(err)
-	}
-	LastObservedTime := metav1.MicroTime{Time: time.Now().Add(-9 * time.Minute)}
-
-	createEvent := make(chan *v1beta1.Event, 10)
-	updateEvent := make(chan *v1beta1.Event, 10)
-	patchEvent := make(chan *v1beta1.Event, 10)
-	testEvents := testEventSeriesSink{
-		OnCreate: func(event *v1beta1.Event) (*v1beta1.Event, error) {
-			createEvent <- event
-			return event, nil
-		},
-		OnUpdate: func(event *v1beta1.Event) (*v1beta1.Event, error) {
-			updateEvent <- event
-			return event, nil
-		},
-		OnPatch: func(event *v1beta1.Event, patch []byte) (*v1beta1.Event, error) {
-			// event we receive is already patched, usually the sink uses it
-			//only to retrieve the name and namespace, here we'll use it directly.
-			patchEvent <- event
-			return event, nil
-		},
-	}
-	cache := map[eventKey]*v1beta1.Event{}
-	eventBroadcaster := newBroadcaster(&testEvents, 0, cache).(*eventBroadcasterImpl)
-	recorder := eventBroadcaster.NewRecorder(scheme.Scheme, "k8s.io/kube-foo").(*recorderImpl)
-	cachedEvent := recorder.makeEvent(regarding, related, metav1.MicroTime{time.Now()}, v1.EventTypeNormal, "test", "some verbose message: 1", "eventTest", "eventTest-"+hostname, "started")
-	cachedEvent.Series = &v1beta1.EventSeries{
-		Count:            10,
-		LastObservedTime: LastObservedTime,
-	}
-	cacheKey := getKey(cachedEvent)
-	cache[cacheKey] = cachedEvent
-
-	eventBroadcaster.refreshExistingEventSeries()
-	select {
-	case <-patchEvent:
-		t.Logf("validating event affected by patch request")
-		eventBroadcaster.mu.Lock()
-		defer eventBroadcaster.mu.Unlock()
-		if len(cache) != 1 {
-			t.Errorf("cache should be with same size, but instead got a size of %v", len(cache))
-		}
-		// check that we emitted only one event
-		if len(patchEvent) != 0 || len(createEvent) != 0 || len(updateEvent) != 0 {
-			t.Errorf("exactly one event should be emitted, but got %v", len(patchEvent))
-		}
-	case <-time.After(wait.ForeverTestTimeout):
-		t.Fatalf("timeout after %v", wait.ForeverTestTimeout)
-	}
-}
--- a/tools/events/interfaces.go
+++ b/tools/events/interfaces.go
@@ -1,58 +0,0 @@
-/*
-Copyright 2019 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 events
-
-import (
-	"k8s.io/api/events/v1beta1"
-	"k8s.io/apimachinery/pkg/runtime"
-)
-
-// EventRecorder knows how to record events on behalf of an EventSource.
-type EventRecorder interface {
-	// Eventf constructs an event from the given information and puts it in the queue for sending.
-	// 'regarding' is the object this event is about. Event will make a reference-- or you may also
-	// pass a reference to the object directly.
-	// 'related' is the secondary object for more complex actions. E.g. when regarding object triggers
-	// a creation or deletion of related object.
-	// 'type' of this event, and can be one of Normal, Warning. New types could be added in future
-	// 'reason' is the reason this event is generated. 'reason' should be short and unique; it
-	// should be in UpperCamelCase format (starting with a capital letter). "reason" will be used
-	// to automate handling of events, so imagine people writing switch statements to handle them.
-	// You want to make that easy.
-	// 'note' is intended to be human readable.
-	Eventf(regarding runtime.Object, related runtime.Object, eventtype, reason, action, note string, args ...interface{})
-}
-
-// EventBroadcaster knows how to receive events and send them to any EventSink, watcher, or log.
-type EventBroadcaster interface {
-	// StartRecordingToSink starts sending events received from the specified eventBroadcaster.
-	StartRecordingToSink(stopCh <-chan struct{})
-
-	// NewRecorder returns an EventRecorder that can be used to send events to this EventBroadcaster
-	// with the event source set to the given event source.
-	NewRecorder(scheme *runtime.Scheme, reportingController string) EventRecorder
-}
-
-// EventSink knows how to store events (client-go implements it.)
-// EventSink must respect the namespace that will be embedded in 'event'.
-// It is assumed that EventSink will return the same sorts of errors as
-// client-go's REST client.
-type EventSink interface {
-	Create(event *v1beta1.Event) (*v1beta1.Event, error)
-	Update(event *v1beta1.Event) (*v1beta1.Event, error)
-	Patch(oldEvent *v1beta1.Event, data []byte) (*v1beta1.Event, error)
-}
--- a/tools/leaderelection/example/main.go
+++ b/tools/leaderelection/example/main.go
@@ -28,7 +28,7 @@ import (
 	"time"

 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	clientset "k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 	"k8s.io/client-go/tools/leaderelection"
@@ -37,59 +37,40 @@ import (
 	"k8s.io/klog"
 )

-func buildConfig(kubeconfig string) (*rest.Config, error) {
-	if kubeconfig != "" {
-		cfg, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
-		if err != nil {
-			return nil, err
-		}
-		return cfg, nil
-	}
-
-	cfg, err := rest.InClusterConfig()
-	if err != nil {
-		return nil, err
-	}
-	return cfg, nil
-}
-
+// main demonstrates a leader elected process that will step down if interrupted.
 func main() {
 	klog.InitFlags(nil)
-
-	var kubeconfig string
-	var leaseLockName string
-	var leaseLockNamespace string
-	var id string
-
-	flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
-	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 id == "" {
-		klog.Fatal("unable to get id (missing id flag).")
+	args := flag.Args()
+	if len(args) != 3 {
+		log.Fatalf("requires three arguments: ID NAMESPACE CONFIG_MAP_NAME (%d)", len(args))
 	}

-	// leader election uses the Kubernetes API by writing to a
-	// lock object, which can be a LeaseLock object (preferred),
-	// a ConfigMap, or an Endpoints (deprecated) object.
-	// Conflicting writes are detected and each client handles those actions
+	// leader election uses the Kubernetes API by writing to a ConfigMap or Endpoints
+	// object. Conflicting writes are detected and each client handles those actions
 	// independently.
-	config, err := buildConfig(kubeconfig)
-	if err != nil {
-		klog.Fatal(err)
+	var config *rest.Config
+	var err error
+	if kubeconfig := os.Getenv("KUBECONFIG"); len(kubeconfig) > 0 {
+		config, err = clientcmd.BuildConfigFromFlags("", kubeconfig)
+	} else {
+		config, err = rest.InClusterConfig()
+	}
+	if err != nil {
+		log.Fatalf("failed to create client: %v", err)
 	}
-	client := clientset.NewForConfigOrDie(config)

-	// 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{
-		LeaseMeta: metav1.ObjectMeta{
-			Name:      leaseLockName,
-			Namespace: leaseLockNamespace,
+	// we use the ConfigMap lock type since edits to ConfigMaps are less common
+	// and fewer objects in the cluster watch "all ConfigMaps" (unlike the older
+	// Endpoints lock type, where quite a few system agents like the kube-proxy
+	// and ingress controllers must watch endpoints).
+	id := args[0]
+	lock := &resourcelock.ConfigMapLock{
+		ConfigMapMeta: metav1.ObjectMeta{
+			Namespace: args[1],
+			Name:      args[2],
 		},
-		Client: client.CoordinationV1(),
+		Client: kubernetes.NewForConfigOrDie(config).CoreV1(),
 		LockConfig: resourcelock.ResourceLockConfig{
 			Identity: id,
 		},
@@ -102,6 +83,7 @@ func main() {

 	// 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")))
+	exampleClient := kubernetes.NewForConfigOrDie(config).CoreV1()

 	// listen for interrupts or the Linux SIGTERM signal and cancel
 	// our context, which the leader election code will observe and
@@ -131,26 +113,18 @@ func main() {
 			OnStartedLeading: func(ctx context.Context) {
 				// we're notified when we start - this is where you would
 				// usually put your code
-				klog.Infof("%s: leading", id)
+				log.Printf("%s: leading", id)
 			},
 			OnStoppedLeading: func() {
 				// 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
-				if identity == id {
-					// I just got the lock
-					return
-				}
-				klog.Infof("new leader elected: %v", identity)
+				log.Printf("%s: lost", id)
 			},
 		},
 	})

 	// because the context is closed, the client should report errors
-	_, err = client.CoordinationV1().Leases(leaseLockNamespace).Get(leaseLockName, metav1.GetOptions{})
+	_, err = exampleClient.ConfigMaps(args[1]).Get(args[2], 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)
 	}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kubernetes Publisher	6ee68ca5fd	Merge remote-tracking branch 'origin/master' into release-1.14 Kubernetes-commit: 1ddce0577ab12daa1f934562debb0563b5c44fe7	2019-03-13 23:57:26 +00:00
Davanum Srinivas	37c2040264	Update to go 1.12 version of golang.org/x/net Change-Id: I3f2fa5d7b6811c9eca58992318d19e44ec9131fd Kubernetes-commit: 2aa1348e6cf4d51f91025c41d41bb7e3b9b9384d	2019-03-12 09:16:45 -04:00
Prasad Ghangal	9f32e39f8b	Update golang.org/x/net/... dependencies to release-branch.go1.11 - latest grpc-ecosystem/go-grpc-middleware Change-Id: Ida7d01e4606f6e0313e1355db6e85be0c0ef1dd1 Kubernetes-commit: 317ecf58cc706c8851834f3b669d80a8628148c6	2019-01-07 18:29:55 +05:30
Kubernetes Publisher	94c2b28f7d	Merge remote-tracking branch 'origin/master' into release-1.14 Kubernetes-commit: b1e389e6f7bd798a8dd162f82b918f509ac5291b	2019-03-12 12:00:14 +00:00
Kubernetes Publisher	541d0b0560	Merge pull request #75167 from tnozicka/fix-retry-watcher-error Handle unstructured status in RetryWatcher Kubernetes-commit: 44e369b000fa9c194b5fda142a9d3f62172f27f6	2019-03-12 11:59:54 +00:00
Kubernetes Publisher	11b3283309	Merge remote-tracking branch 'origin/master' into release-1.14 Kubernetes-commit: 9ef24c9b016648e842673a7f5570de4f6af04439	2019-03-11 16:03:23 +00:00
Joel Smith	ee65211c22	Also update SECURITY_CONTACTS from staging Kubernetes-commit: 7fd6ea47e8fd53dd4e152e59094628ad794e7d4a	2019-03-08 11:23:24 -07:00
Kubernetes Publisher	588ca2044e	Merge remote-tracking branch 'origin/master' into release-1.14 Kubernetes-commit: 2676471cfcb269267a16a2c7cc2df369944ffcc2	2019-03-08 15:55:27 +00:00
Tomas Nozicka	570d5e0778	Handle unstructured status in RetryWatcher Kubernetes-commit: 8302b5b262c506ff7d363338f980ce204d574354	2019-03-08 09:34:56 +01:00
Tim Allclair	dbaaf69ec6	generated files Kubernetes-commit: 428e9fa3299161be420fcfa7987d0e37aca3ea01	2019-03-06 14:36:30 -08:00
Kubernetes Publisher	a5f27269a1	Merge remote-tracking branch 'origin/master' into release-1.14 Kubernetes-commit: 88812c559deec4dd8c6bfdcb0a771269dd78e33c	2019-03-07 08:53:24 +00:00
Kubernetes Publisher	d5894dbfdf	Merge pull request #74837 from mtaufen/godep-klog Update klog dependency Kubernetes-commit: eb95c27a5574e6ac2b166f9a6942226087c351e0	2019-03-07 16:20:43 +00:00
Kubernetes Publisher	ae2e03c815	Merge pull request #74369 from skriss/object-tracker-merge-patch fake client object tracker: support merge patch Kubernetes-commit: 3199da2960768ffb91678038be60d521bb9c1eff	2019-03-07 16:20:20 +00:00
Kubernetes Publisher	7dc950e71c	Merge pull request #74969 from tnozicka/fix-example-flake Fix client-go fake client example flake Kubernetes-commit: d75ddcd0a44e0a66e16a508a868f4501ac3e250d	2019-03-07 16:20:20 +00:00
Kubernetes Publisher	668b48b482	Merge remote-tracking branch 'origin/master' into release-1.14 Kubernetes-commit: d4fa3c1646ec7ab6ac69d3310bf369c2dc0d5994	2019-03-06 09:33:53 +00:00
Kubernetes Publisher	a06557c777	Merge pull request #74153 from ixdy/bazel-kubernetes-src-tarball-new bazel: make kubernetes-src.tar.gz actually include all srcs Kubernetes-commit: 9f7560de70827c69ba42fd6da74c56e5c53397c2	2019-03-07 16:20:19 +00:00
Tomas Nozicka	964f8fefa3	Generated: Update Bazel Kubernetes-commit: 88cab678ea541aa2edda2ef2971415c49edf8f86	2019-03-06 08:36:37 +01:00
Tomas Nozicka	86e6819dc3	Fix client-go fake client example flake Kubernetes-commit: 0b116d915f12181e36f02ed3a87767513074e270	2019-03-06 08:36:15 +01:00
Michael Taufen	0ac4585599	Update klog dependency Kubernetes-commit: 4a4c1a62390d3538dea9610a1af1e67903702a27	2019-03-01 16:39:39 -08:00
Xing Yang	6e9966a82c	Add generated files Kubernetes-commit: 743d3a26e9767340110578f30bc774660b03396c	2019-02-26 20:50:10 -08:00
Kubernetes Publisher	8dcd51b38b	Merge remote-tracking branch 'origin/master' into release-1.14 Kubernetes-commit: 092f2210bfa35daeeb6e1acc174f48422388a3fd	2019-03-07 16:20:18 +00:00
Dr. Stefan Schimanski	1aa26a64a3	Update staging godeps Kubernetes-commit: b7f11084fa563f2b30315afd4fc69a52d2b2434f	2019-03-01 09:52:34 +01:00
Kubernetes Publisher	8fa0a3d9a7	Merge remote-tracking branch 'origin/master' into release-1.14 Kubernetes-commit: b113782cf7c509136fb422743cb663042b3af98c	2019-02-28 09:51:15 +00:00
Kubernetes Publisher	13c52267c3	Merge pull request #74663 from tnozicka/fix-retrywatcher-unit-flake Fix race in RetryWatcher's unit tests Kubernetes-commit: d11baea6f9246163e3eea79f77744e918cd9dc5f	2019-03-07 16:20:17 +00:00
Kubernetes Publisher	b93ec12536	Merge pull request #74344 from Betula-L/fix-dynamic-informer fix dynamic informer mishandles parameter tweakListOptions Kubernetes-commit: 601c2d85500ec9fee9bd3c941f40c4d5e705474b	2019-03-07 16:20:17 +00:00
Kubernetes Publisher	6e68ffcef0	Merge pull request #74636 from logicalhan/reflector-metrics Remove reflector metrics since they are causing a memory leak Kubernetes-commit: a514fa042e49c5b95d6c03351563e54e14bc5e97	2019-03-07 16:20:16 +00:00
Tomas Nozicka	53ec5200c8	Fix race in RetryWatcher's unit tests Kubernetes-commit: b39d079b69a9ae6063204278dcd44d98d2315aa1	2019-02-27 16:35:55 +01:00
Kubernetes Publisher	dc645c6345	Merge remote-tracking branch 'origin/master' into release-1.14. Deleting CHANGELOG-1.12.md Kubernetes-commit: e5777aab95e5c48f6645044f822e891ccbc2dcea	2019-02-27 09:49:00 +00:00
Kubernetes Publisher	326b39868c	Merge pull request #73676 from martin-helmich/bugfix/expose-forwarded-local-port client-go: Dynamically assigned local port number not retrievable when port-forwarding Kubernetes-commit: 38a325250fbefa8785740d00358978eefa160dde	2019-03-07 16:20:16 +00:00
Kubernetes Publisher	16b786c9cd	Merge pull request #67350 from tnozicka/retry-watcher #50102 Task 3: Until, backed by retry watcher Kubernetes-commit: 9059021d9ad9c988672f7663856f9c1b4c90fd01	2019-03-07 16:20:15 +00:00
Han Kang	ed0fa9a6cb	Remove reflector metrics as they currently cause a memory leak Kubernetes-commit: ca096f8069aff73b774c8ef38900dca898c61938	2019-02-26 16:22:24 -08:00
Jordan Liggitt	b729c78e7e	Update client callers to use explicit versions Kubernetes-commit: d1e865ee341ba37469efed8c935e22e2b483eec2	2019-02-22 10:27:46 -05:00
Steve Kriss	34a507b4d2	client-fake object tracker: support merge patch Signed-off-by: Steve Kriss <krisss@vmware.com> Kubernetes-commit: d425fe29bd808db54c59e3e0ecdedbe735b8f68b	2019-02-21 13:47:16 -07:00
Jordan Liggitt	31aec1c448	Regenerate clients Kubernetes-commit: 93be54b28801dbffbc48fcb6018f99beadae51da	2019-02-21 13:50:12 -05:00
Kubernetes Publisher	56f803b746	Merge remote-tracking branch 'origin/master' into release-1.14. Deleting CHANGELOG-1.10.md CHANGELOG-1.11.md CHANGELOG-1.12.md CHANGELOG-1.4.md CHANGELOG-1.7.md CHANGELOG-1.8.md CHANGELOG-1.9.md Kubernetes-commit: 39dac9a88c72865d249d88ffbfa45ebaac0534a1	2019-02-25 09:44:56 +00:00
Kubernetes Publisher	53e30d3ff1	Merge pull request #74328 from daixiang0/delete-blank delete all duplicate empty blanks Kubernetes-commit: 8993fbc543c18e73668793b5d5e234c0a136735c	2019-03-07 16:20:13 +00:00
Kubernetes Publisher	eed918870a	Merge pull request #71896 from awly/client-go-keyutil client-go: extract new keyutil package from util/cert Kubernetes-commit: b5566c781843a1a8c19993632700e476708a9cee	2019-03-07 16:20:13 +00:00
Kubernetes Publisher	6ec80cc44b	Merge pull request #73555 from bsalamat/priority_to_ga Graduate PriorityClass API to GA Kubernetes-commit: 3afa003126ff50092954839efbe10d584c2511ff	2019-03-07 16:20:12 +00:00
Kubernetes Publisher	374c4356cd	Merge pull request #70803 from Adirio/controller-cleanup Remove duplicate code in client-go/tools/cache/controller.go Kubernetes-commit: fba3c54b9e565b276ae495f189155335c297b6ec	2019-03-07 16:19:52 +00:00
Kubernetes Publisher	09020b8c65	Merge remote-tracking branch 'origin/master' into release-1.14. Deleting CHANGELOG-1.8.md CHANGELOG-1.9.md Kubernetes-commit: e203d7493d4fe5a14b997473493fe19fdc450da1	2019-02-22 09:29:28 +00:00
Kubernetes Publisher	b54a99efc1	Merge pull request #74348 from danielqsj/ku update k8s.io/utils to fix keymutex issues Kubernetes-commit: d9f3e96796e2d154b1d4caa156ba95ff9b01e5b2	2019-03-07 16:19:51 +00:00
Kubernetes Publisher	b0802c8fca	Merge pull request #74057 from liggitt/ingress-network-v1beta1 Ingress extensions/v1beta1 -> networking.k8s.io/v1beta1 Kubernetes-commit: 7d75b73e1d72cef7a0f0e2804f8e0a582ccb6b61	2019-03-07 16:19:31 +00:00
Kubernetes Publisher	ba5aaeedee	Merge pull request #74260 from stafot/update-vendor-dependencies Update vendor package github.com/hashicorp/golang-lru Kubernetes-commit: a2592364be3f4f9943f841182b27d0c62050a84a	2019-03-07 16:19:11 +00:00
Kubernetes Publisher	aaf1b0017b	Merge pull request #73601 from munnerz/reactors-shared-copy Use a single deep copied object between all reactors in fake client Kubernetes-commit: a782adfb9d10f3b9aba64864dda1dd7787707019	2019-03-07 16:18:51 +00:00
danielqsj	20e2a89ad1	Update k/utils dependency in staging Kubernetes-commit: b9ef1dd50b8db18fa3a2558289caa4e75f116260	2019-02-22 10:30:38 +08:00
Xiang Dai	f16f247e79	delete all duplicate empty blanks Signed-off-by: Xiang Dai <764524258@qq.com> Kubernetes-commit: 36065c6dd717c14e0a90131041e20345a7e5e324	2019-02-22 09:43:51 +08:00
luhualin	83a8e8f67a	fix dynamic informer tweakListOptions Kubernetes-commit: 94b0bd897d04e1668d96db8d9b5e353b15f2f2da	2019-02-21 19:33:04 +08:00
Bobby (Babak) Salamat	7a36f7e390	generated files Kubernetes-commit: 1dac6d03e3645ddcfdb00d84c158f7995cac94c8	2019-02-20 12:42:15 -08:00
Tomas Nozicka	229c29ef15	Update Bazel Kubernetes-commit: d526dadd12731903ee1418a86d816389ecc40fc6	2019-02-18 18:22:34 +01:00
Tomas Nozicka	f6ca7fe8a3	Upgrade ListWatchUntil Kubernetes-commit: 603dd254ac91b3581f9b431ff91a95d929a97e04	2019-02-18 18:20:23 +01:00
Jeff Grafton	574a25a8d9	Run hack/update-bazel.sh Kubernetes-commit: 26d51164e1d573e80ba4b42a727ad351202b726c	2019-02-15 15:07:25 -08:00
Jordan Liggitt	6374b8b7d5	generated files Kubernetes-commit: f139218ac0711023a85db6ce43d59ad1775a9705	2019-02-14 00:28:24 -05:00
Jordan Liggitt	f3b045ef5f	generated files Kubernetes-commit: 6c0b1b87f0b607199ee468a3fe35d402ecc6ee7c	2019-02-14 01:00:28 -05:00
Martin Helmich	015b6f08fc	client-go: Dynamic local port not accessible when port-forwarding When setting up a port forwarding with the client-go library (using the `k8s.io/client-go/tools/portforward.PortForwarder`) with a non-defined local port (i.e. passing `:80` as `ports` parameter to `portforward.New(...)`), a local port will be assigned dynamically. Currently, the local port will be _always_ 0 if it was not specified initially. This is because the assigned local port is only set on a _copy_ of the actual `ForwardedPort` type that is obtained in a `range` loop. This PR changes this behaviour to set the local port at the correct instance by passing a pointer instead of a copy to the relevant functions. Kubernetes-commit: bbddd27f0dfffe6623763afe2c02c876ba925a7c	2019-02-03 19:01:19 +01:00
Tomas Nozicka	dacfae647c	Add Until based on RetryWatcher Kubernetes-commit: 09af8485f253421cdf0c20a40d12784e8fcffd5a	2019-01-03 13:45:46 +01:00
Andrew Lytvynov	d000da197a	Extract new keyutil package from client-go/util/cert This package contains public/private key utilities copied directly from client-go/util/cert. All imports were updated. Future PRs will actually refactor the libraries. Updates #71004 Kubernetes-commit: 18458392ca24c85c688e655aace1afd04f864cbd	2018-12-09 16:24:38 -08:00
Adrián Orive	92cd65e5b2	Add newInformer documentation Signed-off-by: Adrián Orive <adrian.orive.oneca@gmail.com> Kubernetes-commit: b09c1ce5ddb7473b8b9dd5d63b46267381ed852f	2018-11-14 08:36:38 +01:00
Adrián Orive	fd19152671	Remove duplicate code Signed-off-by: Adrián Orive <adrian.orive.oneca@gmail.com> Kubernetes-commit: b6c3129ac5895db6df61601cfc72e2efa03fd72c	2018-11-08 15:46:56 +01:00
Stavros Foteinopoulos	e4985597f0	Update vendor package github.com/hashicorp/golang-lru Kubernetes-commit: df3fbf9295cb8d650d2e951ae46099d07e2130d2	2018-11-07 15:19:34 +02:00