sync: resync vendor folder

Kubernetes-commit: 84dfa6a4e3c655bb3cf63756d1674dff1976fe06

.travis.yml

@@ -0,0 +1,8 @@
+language: go
+
+go_import_path: k8s.io/client-go
+
+go:
+  - 1.8.1
+
+script: go build ./...

CHANGELOG.md

@@ -1,7 +1,45 @@
+
+TODO: This document was neglected and is currently not complete. Working on
+fixing this.
+
+# HEAD (changes that will go into the next release)
+
+# v3.0.0-beta.0
+
+* Added dependency on k8s.io/apimachinery. The impacts include changing import path of API objects like `ListOptions` from `k8s.io/client-go/pkg/api/v1` to `k8s.io/apimachinery/pkg/apis/meta/v1`.
+* Added generated listers (listers/) and informers (informers/)
+* Kubernetes API changes:
+  * Added client support for:
+    * authentication/v1
+    * authorization/v1
+    * autoscaling/v2alpha1
+    * rbac/v1beta1
+    * settings/v1alpha1
+    * storage/v1
+  * Changed client support for:
+    * certificates from v1alpha1 to v1beta1
+    * policy from v1alpha1 to v1beta1
+* CHANGED: pass typed options to dynamic client (https://github.com/kubernetes/kubernetes/pull/41887)
+
+# v2.0.0
+
+* Included bug fixes in k8s.io/kuberentes release-1.5 branch, up to commit 
+  bde8578d9675129b7a2aa08f1b825ec6cc0f3420
+
+# v2.0.0-alpha.1
+
+* Removed top-level version folder (e.g., 1.4 and 1.5), switching to maintaining separate versions
+  in separate branches.
+* Clientset supported multiple versions per API group
+* Added ThirdPartyResources example
+* Kubernetes API changes
+  * Apps API group graduated to v1beta1 
+  * Policy API group graduated to v1beta1
+  * Added support for batch/v2alpha1/cronjob
+  * Renamed PetSet to StatefulSet
+  
+
 # v1.5.0
 
-## Changelog since v1.4.0
-
-### Added
-* Include the auth plugin (https://github.com/kubernetes/kubernetes/pull/33334)
-* Add timeout field to RESTClient config (https://github.com/kubernetes/kubernetes/pull/33958)
+* Included the auth plugin (https://github.com/kubernetes/kubernetes/pull/33334)
+* Added timeout field to RESTClient config (https://github.com/kubernetes/kubernetes/pull/33958)

Godeps/Godeps.json

@@ -1,7 +1,7 @@
 {
 	"ImportPath": "k8s.io/client-go",
-	"GoVersion": "go1.6",
-	"GodepVersion": "v74",
+	"GoVersion": "go1.8",
+	"GodepVersion": "v79",
 	"Packages": [
 		"./..."
 	],
@@ -16,6 +16,26 @@
 			"Comment": "v0.1.0-115-g3b1ae45",
 			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
 		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest",
+			"Comment": "v8.0.0",
+			"Rev": "58f6f26e200fa5dfb40c9cd1c83f3e2c860d779d"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/adal",
+			"Comment": "v8.0.0",
+			"Rev": "58f6f26e200fa5dfb40c9cd1c83f3e2c860d779d"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/azure",
+			"Comment": "v8.0.0",
+			"Rev": "58f6f26e200fa5dfb40c9cd1c83f3e2c860d779d"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/date",
+			"Comment": "v8.0.0",
+			"Rev": "58f6f26e200fa5dfb40c9cd1c83f3e2c860d779d"
+		},
 		{
 			"ImportPath": "github.com/PuerkitoBio/purell",
 			"Comment": "v1.0.0",
@@ -25,30 +45,25 @@
 			"ImportPath": "github.com/PuerkitoBio/urlesc",
 			"Rev": "5bd2802263f21d8788851d5305584c82a5c75d7e"
 		},
-		{
-			"ImportPath": "github.com/blang/semver",
-			"Comment": "v3.0.1",
-			"Rev": "31b736133b98f26d5e078ec9eb591666edfd091f"
-		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/http",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/jose",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/key",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/oauth2",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
 		},
 		{
 			"ImportPath": "github.com/coreos/go-oidc/oidc",
-			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+			"Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
 		},
 		{
 			"ImportPath": "github.com/coreos/pkg/health",
@@ -69,6 +84,11 @@
 			"ImportPath": "github.com/davecgh/go-spew/spew",
 			"Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
 		},
+		{
+			"ImportPath": "github.com/dgrijalva/jwt-go",
+			"Comment": "v3.0.0-4-g01aeca5",
+			"Rev": "01aeca54ebda6e0fbfafd0a524d234159c05ec20"
+		},
 		{
 			"ImportPath": "github.com/docker/distribution/digest",
 			"Comment": "v2.4.0-rc.1-38-gcd27f17",
@@ -89,23 +109,27 @@
 		},
 		{
 			"ImportPath": "github.com/emicklei/go-restful",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+			"Comment": "2.2.0-4-gff4f55a",
+			"Rev": "ff4f55a206334ef123e4f79bbf348980da81ca46"
+		},
+		{
+			"ImportPath": "github.com/emicklei/go-restful-swagger12",
+			"Comment": "1.0.1",
+			"Rev": "dcef7f55730566d41eae5db10e7d6981829720f6"
 		},
 		{
 			"ImportPath": "github.com/emicklei/go-restful/log",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
-		},
-		{
-			"ImportPath": "github.com/emicklei/go-restful/swagger",
-			"Comment": "v1.2-79-g89ef8af",
-			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+			"Comment": "2.2.0-4-gff4f55a",
+			"Rev": "ff4f55a206334ef123e4f79bbf348980da81ca46"
 		},
 		{
 			"ImportPath": "github.com/ghodss/yaml",
 			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
 		},
+		{
+			"ImportPath": "github.com/go-openapi/analysis",
+			"Rev": "b44dc874b601d9e4e2f6e19140e794ba24bead3b"
+		},
 		{
 			"ImportPath": "github.com/go-openapi/jsonpointer",
 			"Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98"
@@ -114,6 +138,10 @@
 			"ImportPath": "github.com/go-openapi/jsonreference",
 			"Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272"
 		},
+		{
+			"ImportPath": "github.com/go-openapi/loads",
+			"Rev": "18441dfa706d924a39a030ee2c3b1d8d81917b38"
+		},
 		{
 			"ImportPath": "github.com/go-openapi/spec",
 			"Rev": "6aced65f8501fe1217321abf0749d354824ba2ff"
@@ -124,13 +152,13 @@
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Comment": "v0.2-33-ge18d7aa",
-			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
+			"Comment": "v0.4-3-gc0656ed",
+			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Comment": "v0.2-33-ge18d7aa",
-			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
+			"Comment": "v0.4-3-gc0656ed",
+			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
@@ -142,15 +170,23 @@
 		},
 		{
 			"ImportPath": "github.com/golang/protobuf/proto",
-			"Rev": "8616e8ee5e20a1704615e6c8d7afcdac06087a67"
+			"Rev": "4bd1920723d7b7c925de087aa32e2187708897f7"
 		},
 		{
 			"ImportPath": "github.com/google/gofuzz",
-			"Rev": "bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5"
+			"Rev": "44d81051d367757e1c7c6a5a86423ece9afcf63c"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/golang-lru",
+			"Rev": "a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"
+		},
+		{
+			"ImportPath": "github.com/hashicorp/golang-lru/simplelru",
+			"Rev": "a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"
 		},
 		{
 			"ImportPath": "github.com/howeyc/gopass",
-			"Rev": "3ca23474a7c7203e0a0a070fd33508f6efdb9b3d"
+			"Rev": "bf9dde6d0d2c004a008c27aaee91170c786f6db8"
 		},
 		{
 			"ImportPath": "github.com/imdario/mergo",
@@ -163,7 +199,7 @@
 		},
 		{
 			"ImportPath": "github.com/juju/ratelimit",
-			"Rev": "77ed1c8a01217656d2080ad51981f6e99adaa177"
+			"Rev": "5b9ff866471762aa2ab2dced63c9fb6f53921342"
 		},
 		{
 			"ImportPath": "github.com/mailru/easyjson/buffer",
@@ -178,64 +214,69 @@
 			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
 		},
 		{
-			"ImportPath": "github.com/pborman/uuid",
-			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
+			"ImportPath": "github.com/pmezard/go-difflib/difflib",
+			"Rev": "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
 		},
 		{
 			"ImportPath": "github.com/spf13/pflag",
-			"Rev": "c7e63cf4530bcd3ba943729cee0efeff2ebea63f"
+			"Rev": "9ff6c6923cfffbcd502984b8e0c80539a94968b7"
+		},
+		{
+			"ImportPath": "github.com/stretchr/testify/assert",
+			"Comment": "v1.0-88-ge3a8ff8",
+			"Rev": "e3a8ff8ce36581f87a15341206f205b1da467059"
 		},
 		{
 			"ImportPath": "github.com/ugorji/go/codec",
-			"Rev": "f1f1a805ed361a0e078bb537e4ea78cd37dcf065"
+			"Rev": "ded73eae5db7e7a0ef6f55aace87a2873c5d2b74"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/ssh/terminal",
-			"Rev": "1f22c0103821b9390939b6776727195525381532"
+			"Rev": "d172538b2cfce0c13cee31e647d0367aa8cd2486"
 		},
 		{
 			"ImportPath": "golang.org/x/net/context",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+			"Rev": "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
 		},
 		{
 			"ImportPath": "golang.org/x/net/context/ctxhttp",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+			"Rev": "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
 		},
 		{
 			"ImportPath": "golang.org/x/net/http2",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+			"Rev": "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
 		},
 		{
 			"ImportPath": "golang.org/x/net/http2/hpack",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+			"Rev": "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
 		},
 		{
 			"ImportPath": "golang.org/x/net/idna",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+			"Rev": "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
 		},
 		{
 			"ImportPath": "golang.org/x/net/lex/httplex",
-			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+			"Rev": "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2/google",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2/internal",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2/jws",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2/jwt",
-			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
 			"ImportPath": "golang.org/x/sys/unix",
@@ -281,38 +322,6 @@
 			"ImportPath": "golang.org/x/text/width",
 			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
 		},
-		{
-			"ImportPath": "google.golang.org/appengine",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/app_identity",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/base",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/datastore",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/log",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/modules",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
-		{
-			"ImportPath": "google.golang.org/appengine/internal/remote_api",
-			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-		},
 		{
 			"ImportPath": "gopkg.in/inf.v0",
 			"Comment": "v0.9.0",
@@ -321,6 +330,214 @@
 		{
 			"ImportPath": "gopkg.in/yaml.v2",
 			"Rev": "53feefa2559fb8dfa8d81baad31be332c97d6c77"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/equality",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/errors",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/meta",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/resource",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/testing",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery/announced",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery/registered",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1alpha1",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/conversion",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/conversion/unstructured",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/fields",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/labels",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/openapi",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/schema",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/selection",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/types",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/cache",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/clock",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/diff",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/errors",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/framer",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream/spdy",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/intstr",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/json",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/net",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/rand",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/remotecommand",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/runtime",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/sets",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/validation",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/validation/field",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/wait",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/yaml",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/version",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/watch",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/netutil",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect",
+			"Rev": "1fd2e63a9a370677308a42f24fd40c86438afddf"
 		}
 	]
 }

INSTALL.md

@@ -0,0 +1,180 @@
+# Installing client-go
+
+## 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
+particular release), then simply:
+
+```sh
+$ go get k8s.io/client-go/...
+```
+
+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/apimachinery/...
+```
+
+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 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 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!
+
+## Dependency management for the serious (or reluctant) user
+
+Reasons why you might need to use a dependency management system:
+* You use a dependency that client-go also uses, and don't want two copies of
+  the dependency compiled into your application. For some dependencies with
+  singletons or global inits (e.g. `glog`) this wouldn't even compile...
+* You want to lock in a particular version (so you don't have to change your
+  code every time we change a public interface).
+* You want your install to be reproducible. For example, for your CI system or
+  for new team members.
+
+There are three tools you could in theory use for this. Instructions
+for each follows.
+
+### Godep
+
+[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.
+
+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
+go get k8s.io/client-go/...
+cd $GOPATH/src/k8s.io/client-go
+git checkout v2.0.0
+# 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.
+
+### Glide
+
+[Glide](https://github.com/Masterminds/glide) is another popular dependency
+management tool for Go. Glide will manage your /vendor directory, but unlike
+godep, will not use or modify your $GOPATH (there's no equivalent of
+`godep restore` or `godep save`).
+
+Generally, it's best to avoid Glide's many subcommands, favoring modifying
+Glide's manifest file (`glide.yaml`) directly, then running
+`glide update --strip-vendor`. First create a `glide.yaml` file at the root of
+your project:
+
+```yaml
+package: ( your project's import path ) # e.g. github.com/foo/bar
+import:
+- package: k8s.io/client-go
+  version: v2.0.0
+```
+
+Second, add a Go file that imports `client-go` somewhere in your project,
+otherwise `client-go`'s dependencies will not be added to your project's
+vendor/. Then run the following command in the same directory as `glide.yaml`:
+
+```sh
+glide update --strip-vendor
+```
+
+This can also be abbreviated as:
+
+```sh
+glide up -v
+```
+
+At this point, `k8s.io/client-go` should be added to your project's vendor/.
+`client-go`'s dependencies should be flattened and be added to your project's
+vendor/ as well.
+
+Glide will detect the versions of dependencies `client-go` specified in
+`client-go`'s Godep.json file, and automatically set the versions of these
+imports in your /vendor directory. It will also record the detected version of
+all dependencies in the `glide.lock` file.
+
+Projects that require a different version of a dependency than `client-go`
+requests can override the version manually in `glide.yaml`. For example:
+
+```yaml
+package: ( your project's import path ) # e.g. github.com/foo/bar
+import:
+- package: k8s.io/client-go
+  version: v2.0.0
+# 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
+```
+
+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.
+
+### Dep
+
+[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. Its
+status is currently alpha. However, it comes the closest to working easily out
+of the box.
+
+```sh
+$ go get github.com/golang/dep
+$ go install github.com/golang/dep/cmd/dep
+
+# Make sure you have a go file in your directory which imports a package of
+# k8s.io/client-go first--I suggest copying one of the examples.
+$ dep init
+$ dep ensure k8s.io/client-go@^2.0.0
+```
+
+Then you can try one of the
+[examples](https://github.com/kubernetes/client-go/tree/v2.0.0/examples/) from
+the 2.0.0 release.
+
+This will set up a `vendor` directory in your current directory, add `k8s.io/client-go`
+to it, and flatten all of `k8s.io/client-go`'s dependencies into that vendor directory,
+so that your code and `client-go` will both get the same copy of each
+dependency.
+
+After installing like this, you could either use dep for your other
+dependencies, or copy everything in the `vendor` directory into your
+`$GOPATH/src` directory and proceed as if you had done a fancy `go get` that
+flattened dependencies sanely.
+
+One thing to note about dep is that it will omit dependencies that aren't
+actually used, and some dependencies of `client-go` are used only if you import
+one of the plugins (for example, the auth plugins). So you may need to run `dep
+ensure` again if you start importing a plugin that you weren't using before.

LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2014 The Kubernetes Authors.
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

OWNERS

@@ -0,0 +1,45 @@
+approvers:
+- caesarxuchao
+- deads2k
+- krousey
+- lavalamp
+- smarterclayton
+- sttts
+reviewers:
+- thockin
+- lavalamp
+- smarterclayton
+- wojtek-t
+- deads2k
+- yujuhong
+- derekwaynecarr
+- caesarxuchao
+- vishh
+- mikedanese
+- liggitt
+- nikhiljindal
+- bprashanth
+- gmarek
+- erictune
+- davidopp
+- pmorie
+- sttts
+- kargakis
+- dchen1107
+- saad-ali
+- zmerlynn
+- luxas
+- janetkuo
+- justinsb
+- roberthbailey
+- ncdc
+- timstclair
+- yifan-gu
+- eparis
+- mwielgus
+- timothysc
+- feiskyer
+- jlowdermilk
+- soltysh
+- piosz
+- jsafrane

README.md

@@ -2,6 +2,13 @@
 
 Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.
 
+We currently recommend using the v2.0.0 tag. See [INSTALL.md](/INSTALL.md) for
+detailed installation instructions. `go get k8s.io/client-go/...` works, but
+will give you head and doesn't handle the dependencies well.
+
+[![Build Status](https://travis-ci.org/kubernetes/client-go.svg?branch=master)](https://travis-ci.org/kubernetes/client-go)
+[![GoDoc](https://godoc.org/k8s.io/client-go?status.svg)](https://godoc.org/k8s.io/client-go)
+
 ## Table of Contents
  
 - [What's included](#whats-included)
@@ -13,7 +20,6 @@ Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.
 - [How to get it](#how-to-get-it)
 - [How to use it](#how-to-use-it)
 - [Dependency management](#dependency-management)
-- [Reporting bugs](#reporting-bugs)
 - [Contributing code](#contributing-code)
 
 ### What's included
@@ -26,40 +32,108 @@ Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.
 
 ### Versioning
 
-`client-go` version numbers are unrelated to Kubernetes version numbers. Please see the [compatibility matrix](#compatibility-matrix) for the compatible Kubernetes clusters.
+`client-go` follows [semver](http://semver.org/). We will not make
+backwards-incompatible changes without incrementing the major version number. A
+change is backwards-incompatible either if it *i)* changes the public interfaces
+of `client-go`, or *ii)* makes `client-go` incompatible with otherwise supported
+versions of Kubernetes clusters.
 
-`client-go` follows [semver](http://semver.org/). We will not make backwards-incompatible changes without incrementing the major version number. A change is backwards-incompatible either if it *i)* changes the public interfaces of `client-go`, or *ii)* makes `client-go` incompatible with otherwise supported versions of Kubernetes clusters.
+Changes that add features in a backwards-compatible way will result in bumping
+the minor version (second digit) number.
 
-We will create a new branch for each increment in the major version number or minor version number. We will create a new tag for each increment in the patch version number. See [semver](http://semver.org/) for definitions of major, minor, and patch.
+Bugfixes will result in the patch version (third digit) changing. PRs that are
+cherry-picked into an older Kubernetes release branch will result in an update
+to the corresponding branch in `client-go`, with a corresponding new tag
+changing the patch version.
 
-The master branch will track the head in the main Kubernetes repo and accumulating changes. We will make a new client-go major/minor/patch version when:
-* A new major (very rare) or a new minor version is released in the Kubernetes main repository.
-* A feature or a bug fix in the master branch is popular and users want it in a stable branch or with a stable tag. 
+A consequence of this is that `client-go` version numbers will be unrelated to
+Kubernetes version numbers.
+
+#### Branches and tags.
+
+We will create a new branch and tag for each increment in the major version number or
+minor version number. We will create only a new tag for each increment in the patch
+version number. See [semver](http://semver.org/) for definitions of major,
+minor, and patch.
+
+The master branch will track HEAD in the main Kubernetes repo and
+accumulate changes. Consider HEAD to have the version `x.(y+1).0-alpha` or
+`(x+1).0.0-alpha` (depending on whether it has accumulated a breaking change or
+not), where `x` and `y` are the current major and minor versions.
 
 #### Compatibility: your code <-> client-go
 
-`client-go` follows [semver](http://semver.org/), so until the major version of client-go gets increased, your code will compile and will continue to work with explicitly supported versions of Kubernetes clusters.
+`client-go` follows [semver](http://semver.org/), so until the major version of
+client-go gets increased, your code will compile and will continue to work with
+explicitly supported versions of Kubernetes clusters. You must use a dependency
+management system and pin a specific major version of `client-go` to get this
+benefit, as HEAD follows the upstream Kubernetes repo.
 
 #### Compatibility: client-go <-> Kubernetes clusters
 
-`client-go` versions will be backwards compatible with many Kubernetes clusters. As we increment `client-go` versions, we will note which Kubernetes versions we expect them to work with. 
+Since Kubernetes is backwards compatible with clients, older `client-go`
+versions will work with many different Kubernetes cluster versions.
+
+We will backport bugfixes--but not new features--into older versions of
+`client-go`.
 
-We do not back-port new Kubernetes features into older clients. If you need a new feature, you are expected to upgrade to the new client. You can check out the [CHANGELOG](./CHANGELOG.md) for notable changes.
 
 #### Compatibility matrix
 
-* **client-go/1.4** is compatible with Kubernetes 1.3 through 1.5; it includes all features provided by Kubernetes 1.4.
-* **client-go/1.5** is compatible with Kubernetes 1.3 through 1.5; it includes all features provided by Kubernetes 1.4.
+|                     | Kubernetes 1.3 | Kubernetes 1.4 | Kubernetes 1.5 | Kubernetes 1.6 |
+|---------------------|----------------|----------------|----------------|----------------|
+| client-go 1.4       | +              | ✓              | -              | -              |
+| client-go 1.5       | +              | +              | -              | -              |
+| client-go 2.0       | +              | +              | ✓              | -              |
+| client-go 3.0 beta  | +              | +              | +              | ✓              |
+| client-go HEAD      | +              | +              | +              | +              |
+
+Key:
+
+* `✓` Exactly the same features / API objects in both client-go and the Kubernetes
+  version.
+* `+` client-go has features or api objects that may not be present in the
+  Kubernetes cluster, but everything they have in common will work.
+* `-` The Kubernetes cluster has features the client-go library can't use
+  (additional API objects, etc).
+
+See the [CHANGELOG](./CHANGELOG.md) for a detailed description of changes
+between client-go versions.
+
+| Branch         | Canonical source code location       | Maintenance status            |
+|----------------|--------------------------------------|-------------------------------|
+| client-go 1.4  | Kubernetes main repo, 1.4 branch     | = -                           |
+| client-go 1.5  | Kubernetes main repo, 1.5 branch     | = -                           |
+| client-go 2.0  | Kubernetes main repo, 1.5 branch     | ✓                             |
+| client-go 3.0  | Kubernetes main repo, 1.6 branch     | ✓                             |
+| client-go HEAD | Kubernetes main repo, master branch  | ✓                             |
+
+Key:
+
+* `✓` Changes in main Kubernetes repo are actively published to client-go by a bot
+* `=` Maintenance is manual, only severe security bugs will be patched.
+* `-` Deprecated; please upgrade.
+
+#### Deprecation policy
+
+We will maintain branches for at least six months after their first stable tag
+is cut. (E.g., the clock for the release-2.0 branch started ticking when we
+tagged v2.0.0, not when we made the first alpha.) This policy applies to
+every version greater than or equal to 2.0.
 
 #### Why do the 1.4 and 1.5 branch contain top-level folder named after the version?
 
-1.4 and 1.5 branch keep the top-level folders so they do not break the import lines of existing users. These top-level folders are deprecated and are removed from the master branch and future branches.
+For the initial release of client-go, we thought it would be easiest to keep
+separate directories for each minor version. That soon proved to be a mistake.
+We are keeping the top-level folders in the 1.4 and 1.5 branches so that
+existing users won't be broken.
 
 ### How to get it
 
-If you use `go get` to get client-go, **you will get the unstable master branch!** You can `git checkout` a stable branch.
-
-We recommend using a vendor tool, like [godep](https://github.com/tools/godep), [glide](https://github.com/Masterminds/glide), or [govendor](https://github.com/kardianos/govendor) to track a stable version of `client-go`.
+You can use `go get k8s.io/client-go/...` to get client-go, but **you will get
+the unstable master branch** and `client-go`'s vendored dependencies will not be
+added to your `$GOPATH`. So we think most users will want to use a dependency
+management system. See [INSTALL.md](/INSTALL.md) for detailed instructions.
 
 ### How to use it
 
@@ -71,9 +145,5 @@ If your application depends on a package that client-go depends on, and you let
 * 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.
 
-### Reporting bugs
-
-Please report bugs to the main Kubernetes [repository](https://github.com/kubernetes/kubernetes/issues/new).
-
 ### Contributing code
 Please send pull requests against the client packages in the Kubernetes main [repository](https://github.com/kubernetes/kubernetes), and run the `/staging/copy.sh` script to update the staging area in the main repository. Changes in the staging area will be published to this repository every day.

discovery/BUILD

@@ -0,0 +1,63 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "discovery_client.go",
+        "helper.go",
+        "restmapper.go",
+        "unstructured.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/emicklei/go-restful-swagger12:go_default_library",
+        "//vendor/github.com/go-openapi/loads:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/version:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_xtest",
+    srcs = [
+        "discovery_client_test.go",
+        "helper_blackbox_test.go",
+        "restmapper_test.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/emicklei/go-restful-swagger12:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/version:go_default_library",
+        "//vendor/k8s.io/client-go/discovery:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/rest/fake:go_default_library",
+    ],
+)

discovery/discovery_client.go

@@ -23,47 +23,63 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/emicklei/go-restful/swagger"
+	"github.com/emicklei/go-restful-swagger12"
 
-	"k8s.io/client-go/pkg/api"
-	"k8s.io/client-go/pkg/api/errors"
-	"k8s.io/client-go/pkg/api/unversioned"
+	"github.com/go-openapi/loads"
+	"github.com/go-openapi/spec"
+	"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/version"
+	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/pkg/runtime"
-	"k8s.io/client-go/pkg/runtime/serializer"
-	"k8s.io/client-go/pkg/version"
-	"k8s.io/client-go/rest"
+	restclient "k8s.io/client-go/rest"
 )
 
+// defaultRetries is the number of times a resource discovery is repeated if an api group disappears on the fly (e.g. ThirdPartyResources).
+const defaultRetries = 2
+
 // DiscoveryInterface holds the methods that discover server-supported API groups,
 // versions and resources.
 type DiscoveryInterface interface {
-	RESTClient() rest.Interface
+	RESTClient() restclient.Interface
 	ServerGroupsInterface
 	ServerResourcesInterface
 	ServerVersionInterface
 	SwaggerSchemaInterface
+	OpenAPISchemaInterface
+}
+
+// CachedDiscoveryInterface is a DiscoveryInterface with cache invalidation and freshness.
+type CachedDiscoveryInterface interface {
+	DiscoveryInterface
+	// Fresh returns true if no cached data was used that had been retrieved before the instantiation.
+	Fresh() bool
+	// Invalidate enforces that no cached data is used in the future that is older than the current time.
+	Invalidate()
 }
 
 // ServerGroupsInterface has methods for obtaining supported groups on the API server
 type ServerGroupsInterface interface {
 	// ServerGroups returns the supported groups, with information like supported versions and the
 	// preferred version.
-	ServerGroups() (*unversioned.APIGroupList, error)
+	ServerGroups() (*metav1.APIGroupList, error)
 }
 
 // ServerResourcesInterface has methods for obtaining supported resources on the API server
 type ServerResourcesInterface interface {
 	// ServerResourcesForGroupVersion returns the supported resources for a group and version.
-	ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error)
+	ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error)
 	// ServerResources returns the supported resources for all groups and versions.
-	ServerResources() (map[string]*unversioned.APIResourceList, error)
+	ServerResources() ([]*metav1.APIResourceList, error)
 	// ServerPreferredResources returns the supported resources with the version preferred by the
 	// server.
-	ServerPreferredResources() ([]unversioned.GroupVersionResource, error)
+	ServerPreferredResources() ([]*metav1.APIResourceList, error)
 	// ServerPreferredNamespacedResources returns the supported namespaced resources with the
 	// version preferred by the server.
-	ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error)
+	ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error)
 }
 
 // ServerVersionInterface has a method for retrieving the server's version.
@@ -75,23 +91,29 @@ type ServerVersionInterface interface {
 // SwaggerSchemaInterface has a method to retrieve the swagger schema.
 type SwaggerSchemaInterface interface {
 	// SwaggerSchema retrieves and parses the swagger API schema the server supports.
-	SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error)
+	SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error)
+}
+
+// OpenAPISchemaInterface has a method to retrieve the open API schema.
+type OpenAPISchemaInterface interface {
+	// OpenAPISchema retrieves and parses the swagger API schema the server supports.
+	OpenAPISchema() (*spec.Swagger, error)
 }
 
 // DiscoveryClient implements the functions that discover server-supported API groups,
 // versions and resources.
 type DiscoveryClient struct {
-	restClient rest.Interface
+	restClient restclient.Interface
 
 	LegacyPrefix string
 }
 
-// Convert unversioned.APIVersions to unversioned.APIGroup. APIVersions is used by legacy v1, so
+// Convert metav1.APIVersions to metav1.APIGroup. APIVersions is used by legacy v1, so
 // group would be "".
-func apiVersionsToAPIGroup(apiVersions *unversioned.APIVersions) (apiGroup unversioned.APIGroup) {
-	groupVersions := []unversioned.GroupVersionForDiscovery{}
+func apiVersionsToAPIGroup(apiVersions *metav1.APIVersions) (apiGroup metav1.APIGroup) {
+	groupVersions := []metav1.GroupVersionForDiscovery{}
 	for _, version := range apiVersions.Versions {
-		groupVersion := unversioned.GroupVersionForDiscovery{
+		groupVersion := metav1.GroupVersionForDiscovery{
 			GroupVersion: version,
 			Version:      version,
 		}
@@ -105,12 +127,12 @@ func apiVersionsToAPIGroup(apiVersions *unversioned.APIVersions) (apiGroup unver
 
 // ServerGroups returns the supported groups, with information like supported versions and the
 // preferred version.
-func (d *DiscoveryClient) ServerGroups() (apiGroupList *unversioned.APIGroupList, err error) {
+func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err error) {
 	// Get the groupVersions exposed at /api
-	v := &unversioned.APIVersions{}
+	v := &metav1.APIVersions{}
 	err = d.restClient.Get().AbsPath(d.LegacyPrefix).Do().Into(v)
-	apiGroup := unversioned.APIGroup{}
-	if err == nil {
+	apiGroup := metav1.APIGroup{}
+	if err == nil && len(v.Versions) != 0 {
 		apiGroup = apiVersionsToAPIGroup(v)
 	}
 	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
@@ -118,23 +140,25 @@ func (d *DiscoveryClient) ServerGroups() (apiGroupList *unversioned.APIGroupList
 	}
 
 	// Get the groupVersions exposed at /apis
-	apiGroupList = &unversioned.APIGroupList{}
+	apiGroupList = &metav1.APIGroupList{}
 	err = d.restClient.Get().AbsPath("/apis").Do().Into(apiGroupList)
 	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
 		return nil, err
 	}
 	// to be compatible with a v1.0 server, if it's a 403 or 404, ignore and return whatever we got from /api
 	if err != nil && (errors.IsNotFound(err) || errors.IsForbidden(err)) {
-		apiGroupList = &unversioned.APIGroupList{}
+		apiGroupList = &metav1.APIGroupList{}
 	}
 
-	// append the group retrieved from /api to the list
-	apiGroupList.Groups = append(apiGroupList.Groups, apiGroup)
+	// append the group retrieved from /api to the list if not empty
+	if len(v.Versions) != 0 {
+		apiGroupList.Groups = append(apiGroupList.Groups, apiGroup)
+	}
 	return apiGroupList, nil
 }
 
 // ServerResourcesForGroupVersion returns the supported resources for a group and version.
-func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (resources *unversioned.APIResourceList, err error) {
+func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (resources *metav1.APIResourceList, err error) {
 	url := url.URL{}
 	if len(groupVersion) == 0 {
 		return nil, fmt.Errorf("groupVersion shouldn't be empty")
@@ -144,7 +168,9 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r
 	} else {
 		url.Path = "/apis/" + groupVersion
 	}
-	resources = &unversioned.APIResourceList{}
+	resources = &metav1.APIResourceList{
+		GroupVersion: groupVersion,
+	}
 	err = d.restClient.Get().AbsPath(url.String()).Do().Into(resources)
 	if err != nil {
 		// ignore 403 or 404 error to be compatible with an v1.0 server.
@@ -156,28 +182,49 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r
 	return resources, nil
 }
 
-// ServerResources returns the supported resources for all groups and versions.
-func (d *DiscoveryClient) ServerResources() (map[string]*unversioned.APIResourceList, error) {
+// serverResources returns the supported resources for all groups and versions.
+func (d *DiscoveryClient) serverResources(failEarly bool) ([]*metav1.APIResourceList, error) {
 	apiGroups, err := d.ServerGroups()
 	if err != nil {
 		return nil, err
 	}
-	groupVersions := unversioned.ExtractGroupVersions(apiGroups)
-	result := map[string]*unversioned.APIResourceList{}
-	for _, groupVersion := range groupVersions {
-		resources, err := d.ServerResourcesForGroupVersion(groupVersion)
-		if err != nil {
-			return nil, err
+
+	result := []*metav1.APIResourceList{}
+	failedGroups := make(map[schema.GroupVersion]error)
+
+	for _, apiGroup := range apiGroups.Groups {
+		for _, version := range apiGroup.Versions {
+			gv := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
+			resources, err := d.ServerResourcesForGroupVersion(version.GroupVersion)
+			if err != nil {
+				// TODO: maybe restrict this to NotFound errors
+				failedGroups[gv] = err
+				if failEarly {
+					return nil, &ErrGroupDiscoveryFailed{Groups: failedGroups}
+				}
+				continue
+			}
+
+			result = append(result, resources)
 		}
-		result[groupVersion] = resources
 	}
-	return result, nil
+
+	if len(failedGroups) == 0 {
+		return result, nil
+	}
+
+	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
+}
+
+// ServerResources returns the supported resources for all groups and versions.
+func (d *DiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
+	return withRetries(defaultRetries, d.serverResources)
 }
 
 // ErrGroupDiscoveryFailed is returned if one or more API groups fail to load.
 type ErrGroupDiscoveryFailed struct {
 	// Groups is a list of the groups that failed to load and the error cause
-	Groups map[unversioned.GroupVersion]error
+	Groups map[schema.GroupVersion]error
 }
 
 // Error implements the error interface
@@ -197,61 +244,86 @@ func IsGroupDiscoveryFailedError(err error) bool {
 	return err != nil && ok
 }
 
-// serverPreferredResources returns the supported resources with the version preferred by the
-// server. If namespaced is true, only namespaced resources will be returned.
-func (d *DiscoveryClient) serverPreferredResources(namespaced bool) ([]unversioned.GroupVersionResource, error) {
-	// retry in case the groups supported by the server change after ServerGroup() returns.
-	const maxRetries = 2
-	var failedGroups map[unversioned.GroupVersion]error
-	var results []unversioned.GroupVersionResource
-RetrieveGroups:
-	for i := 0; i < maxRetries; i++ {
-		results = []unversioned.GroupVersionResource{}
-		failedGroups = make(map[unversioned.GroupVersion]error)
-		serverGroupList, err := d.ServerGroups()
-		if err != nil {
-			return results, err
-		}
+// serverPreferredResources returns the supported resources with the version preferred by the server.
+func (d *DiscoveryClient) serverPreferredResources(failEarly bool) ([]*metav1.APIResourceList, error) {
+	serverGroupList, err := d.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
 
-		for _, apiGroup := range serverGroupList.Groups {
-			preferredVersion := apiGroup.PreferredVersion
-			groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: preferredVersion.Version}
-			apiResourceList, err := d.ServerResourcesForGroupVersion(preferredVersion.GroupVersion)
+	result := []*metav1.APIResourceList{}
+	failedGroups := make(map[schema.GroupVersion]error)
+
+	grVersions := map[schema.GroupResource]string{}                         // selected version of a GroupResource
+	grApiResources := map[schema.GroupResource]*metav1.APIResource{}        // selected APIResource for a GroupResource
+	gvApiResourceLists := map[schema.GroupVersion]*metav1.APIResourceList{} // blueprint for a APIResourceList for later grouping
+
+	for _, apiGroup := range serverGroupList.Groups {
+		for _, version := range apiGroup.Versions {
+			groupVersion := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
+			apiResourceList, err := d.ServerResourcesForGroupVersion(version.GroupVersion)
 			if err != nil {
-				if i < maxRetries-1 {
-					continue RetrieveGroups
-				}
+				// TODO: maybe restrict this to NotFound errors
 				failedGroups[groupVersion] = err
+				if failEarly {
+					return nil, &ErrGroupDiscoveryFailed{Groups: failedGroups}
+				}
 				continue
 			}
-			for _, apiResource := range apiResourceList.APIResources {
-				// ignore the root scoped resources if "namespaced" is true.
-				if namespaced && !apiResource.Namespaced {
-					continue
-				}
+
+			// create empty list which is filled later in another loop
+			emptyApiResourceList := metav1.APIResourceList{
+				GroupVersion: version.GroupVersion,
+			}
+			gvApiResourceLists[groupVersion] = &emptyApiResourceList
+			result = append(result, &emptyApiResourceList)
+
+			for i := range apiResourceList.APIResources {
+				apiResource := &apiResourceList.APIResources[i]
 				if strings.Contains(apiResource.Name, "/") {
 					continue
 				}
-				results = append(results, groupVersion.WithResource(apiResource.Name))
+				gv := schema.GroupResource{Group: apiGroup.Name, Resource: apiResource.Name}
+				if _, ok := grApiResources[gv]; ok && version.Version != apiGroup.PreferredVersion.Version {
+					// only override with preferred version
+					continue
+				}
+				grVersions[gv] = version.Version
+				grApiResources[gv] = apiResource
 			}
 		}
-		if len(failedGroups) == 0 {
-			return results, nil
-		}
 	}
-	return results, &ErrGroupDiscoveryFailed{Groups: failedGroups}
+
+	// group selected APIResources according to GroupVersion into APIResourceLists
+	for groupResource, apiResource := range grApiResources {
+		version := grVersions[groupResource]
+		groupVersion := schema.GroupVersion{Group: groupResource.Group, Version: version}
+		apiResourceList := gvApiResourceLists[groupVersion]
+		apiResourceList.APIResources = append(apiResourceList.APIResources, *apiResource)
+	}
+
+	if len(failedGroups) == 0 {
+		return result, nil
+	}
+
+	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
 }
 
 // ServerPreferredResources returns the supported resources with the version preferred by the
 // server.
-func (d *DiscoveryClient) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
-	return d.serverPreferredResources(false)
+func (d *DiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
+	return withRetries(defaultRetries, func(retryEarly bool) ([]*metav1.APIResourceList, error) {
+		return d.serverPreferredResources(retryEarly)
+	})
 }
 
 // ServerPreferredNamespacedResources returns the supported namespaced resources with the
 // version preferred by the server.
-func (d *DiscoveryClient) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
-	return d.serverPreferredResources(true)
+func (d *DiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
+	all, err := d.ServerPreferredResources()
+	return FilteredBy(ResourcePredicateFunc(func(groupVersion string, r *metav1.APIResource) bool {
+		return r.Namespaced
+	}), all), err
 }
 
 // ServerVersion retrieves and parses the server's version (git version).
@@ -269,7 +341,8 @@ func (d *DiscoveryClient) ServerVersion() (*version.Info, error) {
 }
 
 // SwaggerSchema retrieves and parses the swagger API schema the server supports.
-func (d *DiscoveryClient) SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error) {
+// TODO: Replace usages with Open API.  Tracked in https://github.com/kubernetes/kubernetes/issues/44589
+func (d *DiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
 	if version.Empty() {
 		return nil, fmt.Errorf("groupVersion cannot be empty")
 	}
@@ -278,7 +351,7 @@ func (d *DiscoveryClient) SwaggerSchema(version unversioned.GroupVersion) (*swag
 	if err != nil {
 		return nil, err
 	}
-	groupVersions := unversioned.ExtractGroupVersions(groupList)
+	groupVersions := metav1.ExtractGroupVersions(groupList)
 	// This check also takes care the case that kubectl is newer than the running endpoint
 	if stringDoesntExistIn(version.String(), groupVersions) {
 		return nil, fmt.Errorf("API version: %v is not supported by the server. Use one of: %v", version, groupVersions)
@@ -302,31 +375,63 @@ func (d *DiscoveryClient) SwaggerSchema(version unversioned.GroupVersion) (*swag
 	return &schema, nil
 }
 
-func setDiscoveryDefaults(config *rest.Config) error {
+// OpenAPISchema fetches the open api schema using a rest client and parses the json.
+// Warning: this is very expensive (~1.2s)
+func (d *DiscoveryClient) OpenAPISchema() (*spec.Swagger, error) {
+	data, err := d.restClient.Get().AbsPath("/swagger.json").Do().Raw()
+	if err != nil {
+		return nil, err
+	}
+	msg := json.RawMessage(data)
+	doc, err := loads.Analyzed(msg, "")
+	if err != nil {
+		return nil, err
+	}
+	return doc.Spec(), err
+}
+
+// withRetries retries the given recovery function in case the groups supported by the server change after ServerGroup() returns.
+func withRetries(maxRetries int, f func(failEarly bool) ([]*metav1.APIResourceList, error)) ([]*metav1.APIResourceList, error) {
+	var result []*metav1.APIResourceList
+	var err error
+	for i := 0; i < maxRetries; i++ {
+		failEarly := i < maxRetries-1
+		result, err = f(failEarly)
+		if err == nil {
+			return result, nil
+		}
+		if _, ok := err.(*ErrGroupDiscoveryFailed); !ok {
+			return nil, err
+		}
+	}
+	return result, err
+}
+
+func setDiscoveryDefaults(config *restclient.Config) error {
 	config.APIPath = ""
 	config.GroupVersion = nil
-	codec := runtime.NoopEncoder{Decoder: api.Codecs.UniversalDecoder()}
+	codec := runtime.NoopEncoder{Decoder: scheme.Codecs.UniversalDecoder()}
 	config.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec})
 	if len(config.UserAgent) == 0 {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
+		config.UserAgent = restclient.DefaultKubernetesUserAgent()
 	}
 	return nil
 }
 
 // NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. This client
 // can be used to discover supported resources in the API server.
-func NewDiscoveryClientForConfig(c *rest.Config) (*DiscoveryClient, error) {
+func NewDiscoveryClientForConfig(c *restclient.Config) (*DiscoveryClient, error) {
 	config := *c
 	if err := setDiscoveryDefaults(&config); err != nil {
 		return nil, err
 	}
-	client, err := rest.UnversionedRESTClientFor(&config)
+	client, err := restclient.UnversionedRESTClientFor(&config)
 	return &DiscoveryClient{restClient: client, LegacyPrefix: "/api"}, err
 }
 
 // NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. If
 // there is an error, it panics.
-func NewDiscoveryClientForConfigOrDie(c *rest.Config) *DiscoveryClient {
+func NewDiscoveryClientForConfigOrDie(c *restclient.Config) *DiscoveryClient {
 	client, err := NewDiscoveryClientForConfig(c)
 	if err != nil {
 		panic(err)
@@ -336,7 +441,7 @@ func NewDiscoveryClientForConfigOrDie(c *rest.Config) *DiscoveryClient {
 }
 
 // New creates a new DiscoveryClient for the given RESTClient.
-func NewDiscoveryClient(c rest.Interface) *DiscoveryClient {
+func NewDiscoveryClient(c restclient.Interface) *DiscoveryClient {
 	return &DiscoveryClient{restClient: c, LegacyPrefix: "/api"}
 }
 
@@ -351,7 +456,7 @@ func stringDoesntExistIn(str string, slice []string) bool {
 
 // RESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *DiscoveryClient) RESTClient() rest.Interface {
+func (c *DiscoveryClient) RESTClient() restclient.Interface {
 	if c == nil {
 		return nil
 	}

discovery/discovery_client_test.go

@@ -14,21 +14,26 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package discovery
+package discovery_test
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
 	"testing"
 
-	"github.com/emicklei/go-restful/swagger"
+	"github.com/emicklei/go-restful-swagger12"
 
-	"k8s.io/client-go/pkg/api/unversioned"
+	"github.com/go-openapi/spec"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/version"
+	. "k8s.io/client-go/discovery"
 	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/pkg/version"
-	"k8s.io/client-go/rest"
+	restclient "k8s.io/client-go/rest"
 )
 
 func TestGetServerVersion(t *testing.T) {
@@ -48,7 +53,7 @@ func TestGetServerVersion(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 
 	got, err := client.ServerVersion()
 	if err != nil {
@@ -64,7 +69,7 @@ func TestGetServerGroupsWithV1Server(t *testing.T) {
 		var obj interface{}
 		switch req.URL.Path {
 		case "/api":
-			obj = &unversioned.APIVersions{
+			obj = &metav1.APIVersions{
 				Versions: []string{
 					"v1",
 				},
@@ -83,13 +88,13 @@ func TestGetServerGroupsWithV1Server(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 	// ServerGroups should not return an error even if server returns error at /api and /apis
 	apiGroupList, err := client.ServerGroups()
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	groupVersions := unversioned.ExtractGroupVersions(apiGroupList)
+	groupVersions := metav1.ExtractGroupVersions(apiGroupList)
 	if !reflect.DeepEqual(groupVersions, []string{"v1"}) {
 		t.Errorf("expected: %q, got: %q", []string{"v1"}, groupVersions)
 	}
@@ -101,13 +106,13 @@ func TestGetServerGroupsWithBrokenServer(t *testing.T) {
 			w.WriteHeader(statusCode)
 		}))
 		defer server.Close()
-		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 		// ServerGroups should not return an error even if server returns Not Found or Forbidden error at all end points
 		apiGroupList, err := client.ServerGroups()
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
-		groupVersions := unversioned.ExtractGroupVersions(apiGroupList)
+		groupVersions := metav1.ExtractGroupVersions(apiGroupList)
 		if len(groupVersions) != 0 {
 			t.Errorf("expected empty list, got: %q", groupVersions)
 		}
@@ -119,7 +124,7 @@ func TestGetServerResourcesWithV1Server(t *testing.T) {
 		var obj interface{}
 		switch req.URL.Path {
 		case "/api":
-			obj = &unversioned.APIVersions{
+			obj = &metav1.APIVersions{
 				Versions: []string{
 					"v1",
 				},
@@ -138,37 +143,37 @@ func TestGetServerResourcesWithV1Server(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 	// ServerResources should not return an error even if server returns error at /api/v1.
-	resourceMap, err := client.ServerResources()
+	serverResources, err := client.ServerResources()
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	if _, found := resourceMap["v1"]; !found {
-		t.Errorf("missing v1 in resource map")
+	gvs := groupVersions(serverResources)
+	if !sets.NewString(gvs...).Has("v1") {
+		t.Errorf("missing v1 in resource list: %v", serverResources)
 	}
-
 }
 
 func TestGetServerResources(t *testing.T) {
-	stable := unversioned.APIResourceList{
+	stable := metav1.APIResourceList{
 		GroupVersion: "v1",
-		APIResources: []unversioned.APIResource{
+		APIResources: []metav1.APIResource{
 			{Name: "pods", Namespaced: true, Kind: "Pod"},
 			{Name: "services", Namespaced: true, Kind: "Service"},
 			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
 		},
 	}
-	beta := unversioned.APIResourceList{
-		GroupVersion: "extensions/v1",
-		APIResources: []unversioned.APIResource{
+	beta := metav1.APIResourceList{
+		GroupVersion: "extensions/v1beta1",
+		APIResources: []metav1.APIResource{
 			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
 			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
 			{Name: "jobs", Namespaced: true, Kind: "Job"},
 		},
 	}
 	tests := []struct {
-		resourcesList *unversioned.APIResourceList
+		resourcesList *metav1.APIResourceList
 		path          string
 		request       string
 		expectErr     bool
@@ -200,16 +205,16 @@ func TestGetServerResources(t *testing.T) {
 		case "/apis/extensions/v1beta1":
 			list = &beta
 		case "/api":
-			list = &unversioned.APIVersions{
+			list = &metav1.APIVersions{
 				Versions: []string{
 					"v1",
 				},
 			}
 		case "/apis":
-			list = &unversioned.APIGroupList{
-				Groups: []unversioned.APIGroup{
+			list = &metav1.APIGroupList{
+				Groups: []metav1.APIGroup{
 					{
-						Versions: []unversioned.GroupVersionForDiscovery{
+						Versions: []metav1.GroupVersionForDiscovery{
 							{GroupVersion: "extensions/v1beta1"},
 						},
 					},
@@ -230,7 +235,7 @@ func TestGetServerResources(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 	for _, test := range tests {
 		got, err := client.ServerResourcesForGroupVersion(test.request)
 		if test.expectErr {
@@ -248,13 +253,14 @@ func TestGetServerResources(t *testing.T) {
 		}
 	}
 
-	resourceMap, err := client.ServerResources()
+	serverResources, err := client.ServerResources()
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
+	serverGroupVersions := sets.NewString(groupVersions(serverResources)...)
 	for _, api := range []string{"v1", "extensions/v1beta1"} {
-		if _, found := resourceMap[api]; !found {
-			t.Errorf("missing expected api: %s", api)
+		if !serverGroupVersions.Has(api) {
+			t.Errorf("missing expected api %q in %v", api, serverResources)
 		}
 	}
 }
@@ -266,7 +272,7 @@ func swaggerSchemaFakeServer() (*httptest.Server, error) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		var resp interface{}
 		if request == 1 {
-			resp = unversioned.APIVersions{Versions: []string{"v1", "v2", "v3"}}
+			resp = metav1.APIVersions{Versions: []string{"v1", "v2", "v3"}}
 			request++
 		} else {
 			resp = swagger.ApiDeclaration{}
@@ -292,7 +298,7 @@ func TestGetSwaggerSchema(t *testing.T) {
 	}
 	defer server.Close()
 
-	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 	got, err := client.SwaggerSchema(v1.SchemeGroupVersion)
 	if err != nil {
 		t.Fatalf("unexpected encoding error: %v", err)
@@ -311,8 +317,8 @@ func TestGetSwaggerSchemaFail(t *testing.T) {
 	}
 	defer server.Close()
 
-	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
-	got, err := client.SwaggerSchema(unversioned.GroupVersion{Group: "api.group", Version: "v4"})
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+	got, err := client.SwaggerSchema(schema.GroupVersion{Group: "api.group", Version: "v4"})
 	if got != nil {
 		t.Fatalf("unexpected response: %v", got)
 	}
@@ -321,30 +327,97 @@ func TestGetSwaggerSchemaFail(t *testing.T) {
 	}
 }
 
-func TestGetServerPreferredResources(t *testing.T) {
-	stable := unversioned.APIResourceList{
+var returnedOpenAPI = spec.Swagger{
+	SwaggerProps: spec.SwaggerProps{
+		Definitions: spec.Definitions{
+			"fake.type.1": spec.Schema{
+				SchemaProps: spec.SchemaProps{
+					Properties: map[string]spec.Schema{
+						"count": {
+							SchemaProps: spec.SchemaProps{
+								Type: []string{"integer"},
+							},
+						},
+					},
+				},
+			},
+			"fake.type.2": spec.Schema{
+				SchemaProps: spec.SchemaProps{
+					Properties: map[string]spec.Schema{
+						"count": {
+							SchemaProps: spec.SchemaProps{
+								Type: []string{"array"},
+								Items: &spec.SchemaOrArray{
+									Schema: &spec.Schema{
+										SchemaProps: spec.SchemaProps{
+											Type: []string{"string"},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+}
+
+func openapiSchemaFakeServer() (*httptest.Server, error) {
+	var sErr error
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		if req.URL.Path != "/swagger.json" {
+			sErr = fmt.Errorf("Unexpected url %v", req.URL)
+		}
+		if req.Method != "GET" {
+			sErr = fmt.Errorf("Unexpected method %v", req.Method)
+		}
+
+		output, err := json.Marshal(returnedOpenAPI)
+		if err != nil {
+			sErr = err
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write(output)
+	}))
+	return server, sErr
+}
+
+func TestGetOpenAPISchema(t *testing.T) {
+	server, err := openapiSchemaFakeServer()
+	if err != nil {
+		t.Errorf("unexpected error starting fake server: %v", err)
+	}
+	defer server.Close()
+
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+	got, err := client.OpenAPISchema()
+	if err != nil {
+		t.Fatalf("unexpected error getting openapi: %v", err)
+	}
+	if e, a := returnedOpenAPI, *got; !reflect.DeepEqual(e, a) {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+}
+
+func TestServerPreferredResources(t *testing.T) {
+	stable := metav1.APIResourceList{
 		GroupVersion: "v1",
-		APIResources: []unversioned.APIResource{
+		APIResources: []metav1.APIResource{
 			{Name: "pods", Namespaced: true, Kind: "Pod"},
 			{Name: "services", Namespaced: true, Kind: "Service"},
 			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
 		},
 	}
-	/*beta := unversioned.APIResourceList{
-		GroupVersion: "extensions/v1",
-		APIResources: []unversioned.APIResource{
-			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
-			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
-			{Name: "jobs", Namespaced: true, Kind: "Job"},
-		},
-	}*/
 	tests := []struct {
-		resourcesList *unversioned.APIResourceList
+		resourcesList []*metav1.APIResourceList
 		response      func(w http.ResponseWriter, req *http.Request)
 		expectErr     func(err error) bool
 	}{
 		{
-			resourcesList: &stable,
+			resourcesList: []*metav1.APIResourceList{&stable},
 			expectErr:     IsGroupDiscoveryFailedError,
 			response: func(w http.ResponseWriter, req *http.Request) {
 				var list interface{}
@@ -355,16 +428,16 @@ func TestGetServerPreferredResources(t *testing.T) {
 				case "/api/v1":
 					list = &stable
 				case "/api":
-					list = &unversioned.APIVersions{
+					list = &metav1.APIVersions{
 						Versions: []string{
 							"v1",
 						},
 					}
 				case "/apis":
-					list = &unversioned.APIGroupList{
-						Groups: []unversioned.APIGroup{
+					list = &metav1.APIGroupList{
+						Groups: []metav1.APIGroup{
 							{
-								Versions: []unversioned.GroupVersionForDiscovery{
+								Versions: []metav1.GroupVersionForDiscovery{
 									{GroupVersion: "extensions/v1beta1"},
 								},
 							},
@@ -397,16 +470,16 @@ func TestGetServerPreferredResources(t *testing.T) {
 				case "/api/v1":
 					w.WriteHeader(http.StatusInternalServerError)
 				case "/api":
-					list = &unversioned.APIVersions{
+					list = &metav1.APIVersions{
 						Versions: []string{
 							"v1",
 						},
 					}
 				case "/apis":
-					list = &unversioned.APIGroupList{
-						Groups: []unversioned.APIGroup{
+					list = &metav1.APIGroupList{
+						Groups: []metav1.APIGroup{
 							{
-								Versions: []unversioned.GroupVersionForDiscovery{
+								Versions: []metav1.GroupVersionForDiscovery{
 									{GroupVersion: "extensions/v1beta1"},
 								},
 							},
@@ -427,16 +500,13 @@ func TestGetServerPreferredResources(t *testing.T) {
 				w.Write(output)
 			},
 		},
-		/*{
-			resourcesList: &stable,
-		},*/
 	}
 	for _, test := range tests {
 		server := httptest.NewServer(http.HandlerFunc(test.response))
 		defer server.Close()
 
-		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
-		got, err := client.ServerPreferredResources()
+		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+		resources, err := client.ServerPreferredResources()
 		if test.expectErr != nil {
 			if err == nil {
 				t.Error("unexpected non-error")
@@ -448,23 +518,29 @@ func TestGetServerPreferredResources(t *testing.T) {
 			t.Errorf("unexpected error: %v", err)
 			continue
 		}
-		if !reflect.DeepEqual(got, test.resourcesList) {
+		got, err := GroupVersionResources(resources)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			continue
+		}
+		expected, _ := GroupVersionResources(test.resourcesList)
+		if !reflect.DeepEqual(got, expected) {
 			t.Errorf("expected:\n%v\ngot:\n%v\n", test.resourcesList, got)
 		}
 		server.Close()
 	}
 }
 
-func TestGetServerPreferredResourcesRetries(t *testing.T) {
-	stable := unversioned.APIResourceList{
+func TestServerPreferredResourcesRetries(t *testing.T) {
+	stable := metav1.APIResourceList{
 		GroupVersion: "v1",
-		APIResources: []unversioned.APIResource{
+		APIResources: []metav1.APIResource{
 			{Name: "pods", Namespaced: true, Kind: "Pod"},
 		},
 	}
-	beta := unversioned.APIResourceList{
+	beta := metav1.APIResourceList{
 		GroupVersion: "extensions/v1",
-		APIResources: []unversioned.APIResource{
+		APIResources: []metav1.APIResource{
 			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
 		},
 	}
@@ -484,20 +560,20 @@ func TestGetServerPreferredResourcesRetries(t *testing.T) {
 			case "/api/v1":
 				list = &stable
 			case "/api":
-				list = &unversioned.APIVersions{
+				list = &metav1.APIVersions{
 					Versions: []string{
 						"v1",
 					},
 				}
 			case "/apis":
-				list = &unversioned.APIGroupList{
-					Groups: []unversioned.APIGroup{
+				list = &metav1.APIGroupList{
+					Groups: []metav1.APIGroup{
 						{
 							Name: "extensions",
-							Versions: []unversioned.GroupVersionForDiscovery{
+							Versions: []metav1.GroupVersionForDiscovery{
 								{GroupVersion: "extensions/v1beta1"},
 							},
-							PreferredVersion: unversioned.GroupVersionForDiscovery{
+							PreferredVersion: metav1.GroupVersionForDiscovery{
 								GroupVersion: "extensions/v1beta1",
 								Version:      "v1beta1",
 							},
@@ -542,14 +618,200 @@ func TestGetServerPreferredResourcesRetries(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(response(tc.responseErrors)))
 		defer server.Close()
 
-		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
-		got, err := client.ServerPreferredResources()
+		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+		resources, err := client.ServerPreferredResources()
 		if !tc.expectedError(err) {
 			t.Errorf("case %d: unexpected error: %v", i, err)
 		}
+		got, err := GroupVersionResources(resources)
+		if err != nil {
+			t.Errorf("case %d: unexpected error: %v", i, err)
+		}
 		if len(got) != tc.expectResources {
 			t.Errorf("case %d: expect %d resources, got %#v", i, tc.expectResources, got)
 		}
 		server.Close()
 	}
 }
+
+func TestServerPreferredNamespacedResources(t *testing.T) {
+	stable := metav1.APIResourceList{
+		GroupVersion: "v1",
+		APIResources: []metav1.APIResource{
+			{Name: "pods", Namespaced: true, Kind: "Pod"},
+			{Name: "services", Namespaced: true, Kind: "Service"},
+			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
+		},
+	}
+	batchv1 := metav1.APIResourceList{
+		GroupVersion: "batch/v1",
+		APIResources: []metav1.APIResource{
+			{Name: "jobs", Namespaced: true, Kind: "Job"},
+		},
+	}
+	batchv2alpha1 := metav1.APIResourceList{
+		GroupVersion: "batch/v2alpha1",
+		APIResources: []metav1.APIResource{
+			{Name: "jobs", Namespaced: true, Kind: "Job"},
+			{Name: "cronjobs", Namespaced: true, Kind: "CronJob"},
+		},
+	}
+	batchv3alpha1 := metav1.APIResourceList{
+		GroupVersion: "batch/v3alpha1",
+		APIResources: []metav1.APIResource{
+			{Name: "jobs", Namespaced: true, Kind: "Job"},
+			{Name: "cronjobs", Namespaced: true, Kind: "CronJob"},
+		},
+	}
+	tests := []struct {
+		response func(w http.ResponseWriter, req *http.Request)
+		expected map[schema.GroupVersionResource]struct{}
+	}{
+		{
+			response: func(w http.ResponseWriter, req *http.Request) {
+				var list interface{}
+				switch req.URL.Path {
+				case "/api/v1":
+					list = &stable
+				case "/api":
+					list = &metav1.APIVersions{
+						Versions: []string{
+							"v1",
+						},
+					}
+				default:
+					t.Logf("unexpected request: %s", req.URL.Path)
+					w.WriteHeader(http.StatusNotFound)
+					return
+				}
+				output, err := json.Marshal(list)
+				if err != nil {
+					t.Errorf("unexpected encoding error: %v", err)
+					return
+				}
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusOK)
+				w.Write(output)
+			},
+			expected: map[schema.GroupVersionResource]struct{}{
+				{Group: "", Version: "v1", Resource: "pods"}:     {},
+				{Group: "", Version: "v1", Resource: "services"}: {},
+			},
+		},
+		{
+			response: func(w http.ResponseWriter, req *http.Request) {
+				var list interface{}
+				switch req.URL.Path {
+				case "/apis":
+					list = &metav1.APIGroupList{
+						Groups: []metav1.APIGroup{
+							{
+								Name: "batch",
+								Versions: []metav1.GroupVersionForDiscovery{
+									{GroupVersion: "batch/v1", Version: "v1"},
+									{GroupVersion: "batch/v2alpha1", Version: "v2alpha1"},
+									{GroupVersion: "batch/v3alpha1", Version: "v3alpha1"},
+								},
+								PreferredVersion: metav1.GroupVersionForDiscovery{GroupVersion: "batch/v1", Version: "v1"},
+							},
+						},
+					}
+				case "/apis/batch/v1":
+					list = &batchv1
+				case "/apis/batch/v2alpha1":
+					list = &batchv2alpha1
+				case "/apis/batch/v3alpha1":
+					list = &batchv3alpha1
+				default:
+					t.Logf("unexpected request: %s", req.URL.Path)
+					w.WriteHeader(http.StatusNotFound)
+					return
+				}
+				output, err := json.Marshal(list)
+				if err != nil {
+					t.Errorf("unexpected encoding error: %v", err)
+					return
+				}
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusOK)
+				w.Write(output)
+			},
+			expected: map[schema.GroupVersionResource]struct{}{
+				{Group: "batch", Version: "v1", Resource: "jobs"}:           {},
+				{Group: "batch", Version: "v2alpha1", Resource: "cronjobs"}: {},
+			},
+		},
+		{
+			response: func(w http.ResponseWriter, req *http.Request) {
+				var list interface{}
+				switch req.URL.Path {
+				case "/apis":
+					list = &metav1.APIGroupList{
+						Groups: []metav1.APIGroup{
+							{
+								Name: "batch",
+								Versions: []metav1.GroupVersionForDiscovery{
+									{GroupVersion: "batch/v1", Version: "v1"},
+									{GroupVersion: "batch/v2alpha1", Version: "v2alpha1"},
+									{GroupVersion: "batch/v3alpha1", Version: "v3alpha1"},
+								},
+								PreferredVersion: metav1.GroupVersionForDiscovery{GroupVersion: "batch/v2alpha", Version: "v2alpha1"},
+							},
+						},
+					}
+				case "/apis/batch/v1":
+					list = &batchv1
+				case "/apis/batch/v2alpha1":
+					list = &batchv2alpha1
+				case "/apis/batch/v3alpha1":
+					list = &batchv3alpha1
+				default:
+					t.Logf("unexpected request: %s", req.URL.Path)
+					w.WriteHeader(http.StatusNotFound)
+					return
+				}
+				output, err := json.Marshal(list)
+				if err != nil {
+					t.Errorf("unexpected encoding error: %v", err)
+					return
+				}
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusOK)
+				w.Write(output)
+			},
+			expected: map[schema.GroupVersionResource]struct{}{
+				{Group: "batch", Version: "v2alpha1", Resource: "jobs"}:     {},
+				{Group: "batch", Version: "v2alpha1", Resource: "cronjobs"}: {},
+			},
+		},
+	}
+	for i, test := range tests {
+		server := httptest.NewServer(http.HandlerFunc(test.response))
+		defer server.Close()
+
+		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+		resources, err := client.ServerPreferredNamespacedResources()
+		if err != nil {
+			t.Errorf("[%d] unexpected error: %v", i, err)
+			continue
+		}
+		got, err := GroupVersionResources(resources)
+		if err != nil {
+			t.Errorf("[%d] unexpected error: %v", i, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, test.expected) {
+			t.Errorf("[%d] expected:\n%v\ngot:\n%v\n", i, test.expected, got)
+		}
+		server.Close()
+	}
+}
+
+func groupVersions(resources []*metav1.APIResourceList) []string {
+	result := []string{}
+	for _, resourceList := range resources {
+		result = append(result, resourceList.GroupVersion)
+	}
+	return result
+}

discovery/fake/BUILD

@@ -0,0 +1,25 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["discovery.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/emicklei/go-restful-swagger12:go_default_library",
+        "//vendor/github.com/go-openapi/spec:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/version:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/version:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/testing:go_default_library",
+    ],
+)

discovery/fake/discovery.go

@@ -17,11 +17,17 @@ limitations under the License.
 package fake
 
 import (
-	"github.com/emicklei/go-restful/swagger"
-	"k8s.io/client-go/pkg/api/unversioned"
+	"fmt"
+
+	"github.com/emicklei/go-restful-swagger12"
+
+	"github.com/go-openapi/spec"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/version"
 	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/pkg/version"
-	"k8s.io/client-go/rest"
+	kubeversion "k8s.io/client-go/pkg/version"
+	restclient "k8s.io/client-go/rest"
 	"k8s.io/client-go/testing"
 )
 
@@ -29,59 +35,66 @@ type FakeDiscovery struct {
 	*testing.Fake
 }
 
-func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error) {
+func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
 	action := testing.ActionImpl{
 		Verb:     "get",
-		Resource: unversioned.GroupVersionResource{Resource: "resource"},
+		Resource: schema.GroupVersionResource{Resource: "resource"},
 	}
 	c.Invokes(action, nil)
-	return c.Resources[groupVersion], nil
+	for _, resourceList := range c.Resources {
+		if resourceList.GroupVersion == groupVersion {
+			return resourceList, nil
+		}
+	}
+	return nil, fmt.Errorf("GroupVersion %q not found", groupVersion)
 }
 
-func (c *FakeDiscovery) ServerResources() (map[string]*unversioned.APIResourceList, error) {
+func (c *FakeDiscovery) ServerResources() ([]*metav1.APIResourceList, error) {
 	action := testing.ActionImpl{
 		Verb:     "get",
-		Resource: unversioned.GroupVersionResource{Resource: "resource"},
+		Resource: schema.GroupVersionResource{Resource: "resource"},
 	}
 	c.Invokes(action, nil)
 	return c.Resources, nil
 }
 
-func (c *FakeDiscovery) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
+func (c *FakeDiscovery) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
 	return nil, nil
 }
 
-func (c *FakeDiscovery) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
+func (c *FakeDiscovery) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
 	return nil, nil
 }
 
-func (c *FakeDiscovery) ServerGroups() (*unversioned.APIGroupList, error) {
+func (c *FakeDiscovery) ServerGroups() (*metav1.APIGroupList, error) {
 	return nil, nil
 }
 
 func (c *FakeDiscovery) ServerVersion() (*version.Info, error) {
 	action := testing.ActionImpl{}
 	action.Verb = "get"
-	action.Resource = unversioned.GroupVersionResource{Resource: "version"}
+	action.Resource = schema.GroupVersionResource{Resource: "version"}
 
 	c.Invokes(action, nil)
-	versionInfo := version.Get()
+	versionInfo := kubeversion.Get()
 	return &versionInfo, nil
 }
 
-func (c *FakeDiscovery) SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error) {
+func (c *FakeDiscovery) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
 	action := testing.ActionImpl{}
 	action.Verb = "get"
 	if version == v1.SchemeGroupVersion {
-		action.Resource = unversioned.GroupVersionResource{Resource: "/swaggerapi/api/" + version.Version}
+		action.Resource = schema.GroupVersionResource{Resource: "/swaggerapi/api/" + version.Version}
 	} else {
-		action.Resource = unversioned.GroupVersionResource{Resource: "/swaggerapi/apis/" + version.Group + "/" + version.Version}
+		action.Resource = schema.GroupVersionResource{Resource: "/swaggerapi/apis/" + version.Group + "/" + version.Version}
 	}
 
 	c.Invokes(action, nil)
 	return &swagger.ApiDeclaration{}, nil
 }
 
-func (c *FakeDiscovery) RESTClient() rest.Interface {
+func (c *FakeDiscovery) OpenAPISchema() (*spec.Swagger, error) { return &spec.Swagger{}, nil }
+
+func (c *FakeDiscovery) RESTClient() restclient.Interface {
 	return nil
 }

discovery/helper.go

@@ -19,117 +19,103 @@ package discovery
 import (
 	"fmt"
 
-	"k8s.io/client-go/pkg/api/unversioned"
-	"k8s.io/client-go/pkg/util/sets"
-	"k8s.io/client-go/pkg/version"
-	"k8s.io/client-go/rest"
-	// Import solely to initialize client auth plugins.
-	_ "k8s.io/client-go/plugin/pkg/client/auth"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/sets"
+	apimachineryversion "k8s.io/apimachinery/pkg/version"
 )
 
 // MatchesServerVersion queries the server to compares the build version
 // (git hash) of the client with the server's build version. It returns an error
 // if it failed to contact the server or if the versions are not an exact match.
-func MatchesServerVersion(client DiscoveryInterface, c *rest.Config) error {
-	var err error
-	if client == nil {
-		client, err = NewDiscoveryClientForConfig(c)
-		if err != nil {
-			return err
-		}
-	}
-	cVer := version.Get()
+func MatchesServerVersion(clientVersion apimachineryversion.Info, client DiscoveryInterface) error {
 	sVer, err := client.ServerVersion()
 	if err != nil {
 		return fmt.Errorf("couldn't read version from server: %v\n", err)
 	}
 	// GitVersion includes GitCommit and GitTreeState, but best to be safe?
-	if cVer.GitVersion != sVer.GitVersion || cVer.GitCommit != sVer.GitCommit || cVer.GitTreeState != sVer.GitTreeState {
-		return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", sVer, cVer)
+	if clientVersion.GitVersion != sVer.GitVersion || clientVersion.GitCommit != sVer.GitCommit || clientVersion.GitTreeState != sVer.GitTreeState {
+		return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", sVer, clientVersion)
 	}
 
 	return nil
 }
 
-// NegotiateVersion queries the server's supported api versions to find
-// a version that both client and server support.
-// - If no version is provided, try registered client versions in order of
-//   preference.
-// - If version is provided, but not default config (explicitly requested via
-//   commandline flag), and is unsupported by the server, print a warning to
-//   stderr and try client's registered versions in order of preference.
-// - If version is config default, and the server does not support it,
-//   return an error.
-func NegotiateVersion(client DiscoveryInterface, c *rest.Config, requestedGV *unversioned.GroupVersion, clientRegisteredGVs []unversioned.GroupVersion) (*unversioned.GroupVersion, error) {
-	var err error
-	if client == nil {
-		client, err = NewDiscoveryClientForConfig(c)
-		if err != nil {
-			return nil, err
-		}
-	}
-	clientVersions := sets.String{}
-	for _, gv := range clientRegisteredGVs {
-		clientVersions.Insert(gv.String())
-	}
+// ServerSupportsVersion returns an error if the server doesn't have the required version
+func ServerSupportsVersion(client DiscoveryInterface, requiredGV schema.GroupVersion) error {
 	groups, err := client.ServerGroups()
 	if err != nil {
 		// This is almost always a connection error, and higher level code should treat this as a generic error,
 		// not a negotiation specific error.
-		return nil, err
+		return err
 	}
-	versions := unversioned.ExtractGroupVersions(groups)
+	versions := metav1.ExtractGroupVersions(groups)
 	serverVersions := sets.String{}
 	for _, v := range versions {
 		serverVersions.Insert(v)
 	}
 
-	// If no version requested, use config version (may also be empty).
-	// make a copy of the original so we don't risk mutating input here or in the returned value
-	var preferredGV *unversioned.GroupVersion
-	switch {
-	case requestedGV != nil:
-		t := *requestedGV
-		preferredGV = &t
-	case c.GroupVersion != nil:
-		t := *c.GroupVersion
-		preferredGV = &t
+	if serverVersions.Has(requiredGV.String()) {
+		return nil
 	}
 
-	// If version explicitly requested verify that both client and server support it.
-	// If server does not support warn, but try to negotiate a lower version.
-	if preferredGV != nil {
-		if !clientVersions.Has(preferredGV.String()) {
-			return nil, fmt.Errorf("client does not support API version %q; client supported API versions: %v", preferredGV, clientVersions)
-
-		}
-		// If the server supports no versions, then we should just use the preferredGV
-		// This can happen because discovery fails due to 403 Forbidden errors
-		if len(serverVersions) == 0 {
-			return preferredGV, nil
-		}
-		if serverVersions.Has(preferredGV.String()) {
-			return preferredGV, nil
-		}
-		// If we are using an explicit config version the server does not support, fail.
-		if (c.GroupVersion != nil) && (*preferredGV == *c.GroupVersion) {
-			return nil, fmt.Errorf("server does not support API version %q", preferredGV)
-		}
+	// If the server supports no versions, then we should pretend it has the version because of old servers.
+	// This can happen because discovery fails due to 403 Forbidden errors
+	if len(serverVersions) == 0 {
+		return nil
 	}
 
-	for _, clientGV := range clientRegisteredGVs {
-		if serverVersions.Has(clientGV.String()) {
-			// Version was not explicitly requested in command config (--api-version).
-			// Ok to fall back to a supported version with a warning.
-			// TODO: caesarxuchao: enable the warning message when we have
-			// proper fix. Please refer to issue #14895.
-			// if len(version) != 0 {
-			// 	glog.Warningf("Server does not support API version '%s'. Falling back to '%s'.", version, clientVersion)
-			// }
-			t := clientGV
-			return &t, nil
-		}
-	}
-	return nil, fmt.Errorf("failed to negotiate an api version; server supports: %v, client supports: %v",
-		serverVersions, clientVersions)
+	return fmt.Errorf("server does not support API version %q", requiredGV)
+}
+
+// GroupVersionResources converts APIResourceLists to the GroupVersionResources.
+func GroupVersionResources(rls []*metav1.APIResourceList) (map[schema.GroupVersionResource]struct{}, error) {
+	gvrs := map[schema.GroupVersionResource]struct{}{}
+	for _, rl := range rls {
+		gv, err := schema.ParseGroupVersion(rl.GroupVersion)
+		if err != nil {
+			return nil, err
+		}
+		for i := range rl.APIResources {
+			gvrs[schema.GroupVersionResource{Group: gv.Group, Version: gv.Version, Resource: rl.APIResources[i].Name}] = struct{}{}
+		}
+	}
+	return gvrs, nil
+}
+
+// FilteredBy filters by the given predicate. Empty APIResourceLists are dropped.
+func FilteredBy(pred ResourcePredicate, rls []*metav1.APIResourceList) []*metav1.APIResourceList {
+	result := []*metav1.APIResourceList{}
+	for _, rl := range rls {
+		filtered := *rl
+		filtered.APIResources = nil
+		for i := range rl.APIResources {
+			if pred.Match(rl.GroupVersion, &rl.APIResources[i]) {
+				filtered.APIResources = append(filtered.APIResources, rl.APIResources[i])
+			}
+		}
+		if filtered.APIResources != nil {
+			result = append(result, &filtered)
+		}
+	}
+	return result
+}
+
+type ResourcePredicate interface {
+	Match(groupVersion string, r *metav1.APIResource) bool
+}
+
+type ResourcePredicateFunc func(groupVersion string, r *metav1.APIResource) bool
+
+func (fn ResourcePredicateFunc) Match(groupVersion string, r *metav1.APIResource) bool {
+	return fn(groupVersion, r)
+}
+
+// SupportsAllVerbs is a predicate matching a resource iff all given verbs are supported.
+type SupportsAllVerbs struct {
+	Verbs []string
+}
+
+func (p SupportsAllVerbs) Match(groupVersion string, r *metav1.APIResource) bool {
+	return sets.NewString([]string(r.Verbs)...).HasAll(p.Verbs...)
 }

discovery/helper_blackbox_test.go

@@ -26,13 +26,15 @@ import (
 	"strings"
 	"testing"
 
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	uapi "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/discovery"
-	"k8s.io/client-go/pkg/api"
-	"k8s.io/client-go/pkg/api/testapi"
-	uapi "k8s.io/client-go/pkg/api/unversioned"
-	"k8s.io/client-go/pkg/apimachinery/registered"
-	"k8s.io/client-go/pkg/runtime"
-	"k8s.io/client-go/rest"
+	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/pkg/api/v1"
+	restclient "k8s.io/client-go/rest"
 	"k8s.io/client-go/rest/fake"
 )
 
@@ -44,88 +46,45 @@ func objBody(object interface{}) io.ReadCloser {
 	return ioutil.NopCloser(bytes.NewReader([]byte(output)))
 }
 
-func TestNegotiateVersion(t *testing.T) {
+func TestServerSupportsVersion(t *testing.T) {
 	tests := []struct {
 		name            string
-		version         *uapi.GroupVersion
-		expectedVersion *uapi.GroupVersion
+		requiredVersion schema.GroupVersion
 		serverVersions  []string
-		clientVersions  []uapi.GroupVersion
-		config          *rest.Config
 		expectErr       func(err error) bool
 		sendErr         error
 		statusCode      int
 	}{
-		{
-			name:            "server supports client default",
-			version:         &uapi.GroupVersion{Version: "version1"},
-			config:          &rest.Config{},
-			serverVersions:  []string{"version1", registered.GroupOrDie(api.GroupName).GroupVersion.String()},
-			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &uapi.GroupVersion{Version: "version1"},
-			statusCode:      http.StatusOK,
-		},
-		{
-			name:            "server falls back to client supported",
-			version:         &registered.GroupOrDie(api.GroupName).GroupVersion,
-			config:          &rest.Config{},
-			serverVersions:  []string{"version1"},
-			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &uapi.GroupVersion{Version: "version1"},
-			statusCode:      http.StatusOK,
-		},
 		{
 			name:            "explicit version supported",
-			config:          &rest.Config{ContentConfig: rest.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}},
-			serverVersions:  []string{"/version1", registered.GroupOrDie(api.GroupName).GroupVersion.String()},
-			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &registered.GroupOrDie(api.GroupName).GroupVersion,
+			requiredVersion: schema.GroupVersion{Version: "v1"},
+			serverVersions:  []string{"/version1", v1.SchemeGroupVersion.String()},
 			statusCode:      http.StatusOK,
 		},
 		{
-			name:           "explicit version not supported",
-			config:         &rest.Config{ContentConfig: rest.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}},
-			serverVersions: []string{"version1"},
-			clientVersions: []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
-			expectErr:      func(err error) bool { return strings.Contains(err.Error(), `server does not support API version "v1"`) },
-			statusCode:     http.StatusOK,
+			name:            "explicit version not supported on server",
+			requiredVersion: schema.GroupVersion{Version: "v1"},
+			serverVersions:  []string{"version1"},
+			expectErr:       func(err error) bool { return strings.Contains(err.Error(), `server does not support API version "v1"`) },
+			statusCode:      http.StatusOK,
 		},
 		{
 			name:           "connection refused error",
-			config:         &rest.Config{ContentConfig: rest.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}},
 			serverVersions: []string{"version1"},
-			clientVersions: []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
 			sendErr:        errors.New("connection refused"),
 			expectErr:      func(err error) bool { return strings.Contains(err.Error(), "connection refused") },
 			statusCode:     http.StatusOK,
 		},
-		{
-			name:            "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, use default GroupVersion",
-			config:          &rest.Config{ContentConfig: rest.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}},
-			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &registered.GroupOrDie(api.GroupName).GroupVersion,
-			statusCode:      http.StatusForbidden,
-		},
 		{
 			name:            "discovery fails due to 404 Not Found errors and thus serverVersions is empty, use requested GroupVersion",
-			version:         &uapi.GroupVersion{Version: "version1"},
-			config:          &rest.Config{ContentConfig: rest.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}},
-			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &uapi.GroupVersion{Version: "version1"},
+			requiredVersion: schema.GroupVersion{Version: "version1"},
 			statusCode:      http.StatusNotFound,
 		},
-		{
-			name:           "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, no fallback GroupVersion",
-			config:         &rest.Config{},
-			clientVersions: []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
-			expectErr:      func(err error) bool { return strings.Contains(err.Error(), "failed to negotiate an api version;") },
-			statusCode:     http.StatusForbidden,
-		},
 	}
 
 	for _, test := range tests {
 		fakeClient := &fake.RESTClient{
-			NegotiatedSerializer: testapi.Default.NegotiatedSerializer(),
+			NegotiatedSerializer: scheme.Codecs,
 			Resp: &http.Response{
 				StatusCode: test.statusCode,
 				Body:       objBody(&uapi.APIVersions{Versions: test.serverVersions}),
@@ -139,9 +98,9 @@ func TestNegotiateVersion(t *testing.T) {
 				return &http.Response{StatusCode: test.statusCode, Header: header, Body: objBody(&uapi.APIVersions{Versions: test.serverVersions})}, nil
 			}),
 		}
-		c := discovery.NewDiscoveryClientForConfigOrDie(test.config)
-		c.RESTClient().(*rest.RESTClient).Client = fakeClient.Client
-		response, err := discovery.NegotiateVersion(c, test.config, test.version, test.clientVersions)
+		c := discovery.NewDiscoveryClientForConfigOrDie(&restclient.Config{})
+		c.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+		err := discovery.ServerSupportsVersion(c, test.requiredVersion)
 		if err == nil && test.expectErr != nil {
 			t.Errorf("expected error, got nil for [%s].", test.name)
 		}
@@ -151,8 +110,76 @@ func TestNegotiateVersion(t *testing.T) {
 			}
 			continue
 		}
-		if *response != *test.expectedVersion {
-			t.Errorf("%s: expected version %s, got %s.", test.name, test.expectedVersion, response)
+	}
+}
+
+func TestFilteredBy(t *testing.T) {
+	all := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
+		return true
+	})
+	none := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
+		return false
+	})
+	onlyV2 := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
+		return strings.HasSuffix(gv, "/v2") || gv == "v2"
+	})
+	onlyBar := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
+		return r.Kind == "Bar"
+	})
+
+	foo := []*metav1.APIResourceList{
+		{
+			GroupVersion: "foo/v1",
+			APIResources: []metav1.APIResource{
+				{Name: "bar", Kind: "Bar"},
+				{Name: "test", Kind: "Test"},
+			},
+		},
+		{
+			GroupVersion: "foo/v2",
+			APIResources: []metav1.APIResource{
+				{Name: "bar", Kind: "Bar"},
+				{Name: "test", Kind: "Test"},
+			},
+		},
+		{
+			GroupVersion: "foo/v3",
+			APIResources: []metav1.APIResource{},
+		},
+	}
+
+	tests := []struct {
+		input             []*metav1.APIResourceList
+		pred              discovery.ResourcePredicate
+		expectedResources []string
+	}{
+		{nil, all, []string{}},
+		{[]*metav1.APIResourceList{
+			{GroupVersion: "foo/v1"},
+		}, all, []string{}},
+		{foo, all, []string{"foo/v1.bar", "foo/v1.test", "foo/v2.bar", "foo/v2.test"}},
+		{foo, onlyV2, []string{"foo/v2.bar", "foo/v2.test"}},
+		{foo, onlyBar, []string{"foo/v1.bar", "foo/v2.bar"}},
+		{foo, none, []string{}},
+	}
+	for i, test := range tests {
+		filtered := discovery.FilteredBy(test.pred, test.input)
+
+		if expected, got := sets.NewString(test.expectedResources...), sets.NewString(stringify(filtered)...); !expected.Equal(got) {
+			t.Errorf("[%d] unexpected group versions: expected=%v, got=%v", i, test.expectedResources, stringify(filtered))
 		}
 	}
 }
+
+func stringify(rls []*metav1.APIResourceList) []string {
+	result := []string{}
+	for _, rl := range rls {
+		for _, r := range rl.APIResources {
+			result = append(result, rl.GroupVersion+"."+r.Name)
+		}
+		if len(rl.APIResources) == 0 {
+			result = append(result, rl.GroupVersion)
+		}
+	}
+	return result
+}

discovery/restmapper.go

@@ -20,42 +20,45 @@ import (
 	"fmt"
 	"sync"
 
-	"k8s.io/client-go/pkg/api/errors"
-	"k8s.io/client-go/pkg/api/meta"
-	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+
+	"github.com/golang/glog"
 )
 
 // APIGroupResources is an API group with a mapping of versions to
 // resources.
 type APIGroupResources struct {
-	Group unversioned.APIGroup
+	Group metav1.APIGroup
 	// A mapping of version string to a slice of APIResources for
 	// that version.
-	VersionedResources map[string][]unversioned.APIResource
+	VersionedResources map[string][]metav1.APIResource
 }
 
 // NewRESTMapper returns a PriorityRESTMapper based on the discovered
-// groups and resourced passed in.
+// groups and resources passed in.
 func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.VersionInterfacesFunc) meta.RESTMapper {
 	unionMapper := meta.MultiRESTMapper{}
 
 	var groupPriority []string
-	var resourcePriority []unversioned.GroupVersionResource
-	var kindPriority []unversioned.GroupVersionKind
+	// /v1 is special.  It should always come first
+	resourcePriority := []schema.GroupVersionResource{{Group: "", Version: "v1", Resource: meta.AnyResource}}
+	kindPriority := []schema.GroupVersionKind{{Group: "", Version: "v1", Kind: meta.AnyKind}}
 
 	for _, group := range groupResources {
 		groupPriority = append(groupPriority, group.Group.Name)
 
 		if len(group.Group.PreferredVersion.Version) != 0 {
-			preffered := group.Group.PreferredVersion.Version
-			if _, ok := group.VersionedResources[preffered]; ok {
-				resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
+			preferred := group.Group.PreferredVersion.Version
+			if _, ok := group.VersionedResources[preferred]; ok {
+				resourcePriority = append(resourcePriority, schema.GroupVersionResource{
 					Group:    group.Group.Name,
 					Version:  group.Group.PreferredVersion.Version,
 					Resource: meta.AnyResource,
 				})
 
-				kindPriority = append(kindPriority, unversioned.GroupVersionKind{
+				kindPriority = append(kindPriority, schema.GroupVersionKind{
 					Group:   group.Group.Name,
 					Version: group.Group.PreferredVersion.Version,
 					Kind:    meta.AnyKind,
@@ -69,8 +72,8 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 				continue
 			}
 
-			gv := unversioned.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
-			versionMapper := meta.NewDefaultRESTMapper([]unversioned.GroupVersion{gv}, versionInterfaces)
+			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
+			versionMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv}, versionInterfaces)
 
 			for _, resource := range resources {
 				scope := meta.RESTScopeNamespace
@@ -88,12 +91,12 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 	}
 
 	for _, group := range groupPriority {
-		resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
+		resourcePriority = append(resourcePriority, schema.GroupVersionResource{
 			Group:    group,
 			Version:  meta.AnyVersion,
 			Resource: meta.AnyResource,
 		})
-		kindPriority = append(kindPriority, unversioned.GroupVersionKind{
+		kindPriority = append(kindPriority, schema.GroupVersionKind{
 			Group:   group,
 			Version: meta.AnyVersion,
 			Kind:    meta.AnyKind,
@@ -118,15 +121,14 @@ func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
 	for _, group := range apiGroups.Groups {
 		groupResources := &APIGroupResources{
 			Group:              group,
-			VersionedResources: make(map[string][]unversioned.APIResource),
+			VersionedResources: make(map[string][]metav1.APIResource),
 		}
 		for _, version := range group.Versions {
 			resources, err := cl.ServerResourcesForGroupVersion(version.GroupVersion)
 			if err != nil {
-				if errors.IsNotFound(err) {
-					continue // ignore as this can race with deletion of 3rd party APIs
-				}
-				return nil, err
+				// continue as best we can
+				// TODO track the errors and update callers to handle partial errors.
+				continue
 			}
 			groupResources.VersionedResources[version.Version] = resources.APIResources
 		}
@@ -141,14 +143,14 @@ func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
 type DeferredDiscoveryRESTMapper struct {
 	initMu           sync.Mutex
 	delegate         meta.RESTMapper
-	cl               DiscoveryInterface
+	cl               CachedDiscoveryInterface
 	versionInterface meta.VersionInterfacesFunc
 }
 
 // NewDeferredDiscoveryRESTMapper returns a
 // DeferredDiscoveryRESTMapper that will lazily query the provided
 // client for discovery information to do REST mappings.
-func NewDeferredDiscoveryRESTMapper(cl DiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
+func NewDeferredDiscoveryRESTMapper(cl CachedDiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
 	return &DeferredDiscoveryRESTMapper{
 		cl:               cl,
 		versionInterface: versionInterface,
@@ -175,79 +177,104 @@ func (d *DeferredDiscoveryRESTMapper) getDelegate() (meta.RESTMapper, error) {
 // Reset resets the internally cached Discovery information and will
 // cause the next mapping request to re-discover.
 func (d *DeferredDiscoveryRESTMapper) Reset() {
+	glog.V(5).Info("Invalidating discovery information")
+
 	d.initMu.Lock()
+	defer d.initMu.Unlock()
+
+	d.cl.Invalidate()
 	d.delegate = nil
-	d.initMu.Unlock()
 }
 
 // KindFor takes a partial resource and returns back the single match.
 // It returns an error if there are multiple matches.
-func (d *DeferredDiscoveryRESTMapper) KindFor(resource unversioned.GroupVersionResource) (unversioned.GroupVersionKind, error) {
+func (d *DeferredDiscoveryRESTMapper) KindFor(resource schema.GroupVersionResource) (gvk schema.GroupVersionKind, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
-		return unversioned.GroupVersionKind{}, err
+		return schema.GroupVersionKind{}, err
 	}
-	return del.KindFor(resource)
+	gvk, err = del.KindFor(resource)
+	if err != nil && !d.cl.Fresh() {
+		d.Reset()
+		gvk, err = d.KindFor(resource)
+	}
+	return
 }
 
 // KindsFor takes a partial resource and returns back the list of
 // potential kinds in priority order.
-func (d *DeferredDiscoveryRESTMapper) KindsFor(resource unversioned.GroupVersionResource) ([]unversioned.GroupVersionKind, error) {
+func (d *DeferredDiscoveryRESTMapper) KindsFor(resource schema.GroupVersionResource) (gvks []schema.GroupVersionKind, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	return del.KindsFor(resource)
+	gvks, err = del.KindsFor(resource)
+	if len(gvks) == 0 && !d.cl.Fresh() {
+		d.Reset()
+		gvks, err = d.KindsFor(resource)
+	}
+	return
 }
 
 // ResourceFor takes a partial resource and returns back the single
 // match. It returns an error if there are multiple matches.
-func (d *DeferredDiscoveryRESTMapper) ResourceFor(input unversioned.GroupVersionResource) (unversioned.GroupVersionResource, error) {
+func (d *DeferredDiscoveryRESTMapper) ResourceFor(input schema.GroupVersionResource) (gvr schema.GroupVersionResource, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
-		return unversioned.GroupVersionResource{}, err
+		return schema.GroupVersionResource{}, err
 	}
-	return del.ResourceFor(input)
+	gvr, err = del.ResourceFor(input)
+	if err != nil && !d.cl.Fresh() {
+		d.Reset()
+		gvr, err = d.ResourceFor(input)
+	}
+	return
 }
 
 // ResourcesFor takes a partial resource and returns back the list of
 // potential resource in priority order.
-func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input unversioned.GroupVersionResource) ([]unversioned.GroupVersionResource, error) {
+func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input schema.GroupVersionResource) (gvrs []schema.GroupVersionResource, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	return del.ResourcesFor(input)
+	gvrs, err = del.ResourcesFor(input)
+	if len(gvrs) == 0 && !d.cl.Fresh() {
+		d.Reset()
+		gvrs, err = d.ResourcesFor(input)
+	}
+	return
 }
 
 // RESTMapping identifies a preferred resource mapping for the
 // provided group kind.
-func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (*meta.RESTMapping, error) {
+func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (m *meta.RESTMapping, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	return del.RESTMapping(gk, versions...)
+	m, err = del.RESTMapping(gk, versions...)
+	if err != nil && !d.cl.Fresh() {
+		d.Reset()
+		m, err = d.RESTMapping(gk, versions...)
+	}
+	return
 }
 
 // RESTMappings returns the RESTMappings for the provided group kind
 // in a rough internal preferred order. If no kind is found, it will
 // return a NoResourceMatchError.
-func (d *DeferredDiscoveryRESTMapper) RESTMappings(gk unversioned.GroupKind) ([]*meta.RESTMapping, error) {
+func (d *DeferredDiscoveryRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string) (ms []*meta.RESTMapping, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	return del.RESTMappings(gk)
-}
-
-// AliasesForResource returns whether a resource has an alias or not.
-func (d *DeferredDiscoveryRESTMapper) AliasesForResource(resource string) ([]string, bool) {
-	del, err := d.getDelegate()
-	if err != nil {
-		return nil, false
+	ms, err = del.RESTMappings(gk, versions...)
+	if len(ms) == 0 && !d.cl.Fresh() {
+		d.Reset()
+		ms, err = d.RESTMappings(gk, versions...)
 	}
-	return del.AliasesForResource(resource)
+	return
 }
 
 // ResourceSingularizer converts a resource name from plural to
@@ -257,7 +284,12 @@ func (d *DeferredDiscoveryRESTMapper) ResourceSingularizer(resource string) (sin
 	if err != nil {
 		return resource, err
 	}
-	return del.ResourceSingularizer(resource)
+	singular, err = del.ResourceSingularizer(resource)
+	if err != nil && !d.cl.Fresh() {
+		d.Reset()
+		singular, err = d.ResourceSingularizer(resource)
+	}
+	return
 }
 
 func (d *DeferredDiscoveryRESTMapper) String() string {

discovery/restmapper_test.go

@@ -14,26 +14,51 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package discovery
+package discovery_test
 
 import (
 	"reflect"
 	"testing"
 
-	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/version"
+	. "k8s.io/client-go/discovery"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/rest/fake"
+
+	"github.com/emicklei/go-restful-swagger12"
+	"github.com/go-openapi/spec"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestRESTMapper(t *testing.T) {
 	resources := []*APIGroupResources{
 		{
-			Group: unversioned.APIGroup{
-				Versions: []unversioned.GroupVersionForDiscovery{
+			Group: metav1.APIGroup{
+				Name: "extensions",
+				Versions: []metav1.GroupVersionForDiscovery{
+					{Version: "v1beta"},
+				},
+				PreferredVersion: metav1.GroupVersionForDiscovery{Version: "v1beta"},
+			},
+			VersionedResources: map[string][]metav1.APIResource{
+				"v1beta": {
+					{Name: "jobs", Namespaced: true, Kind: "Job"},
+					{Name: "pods", Namespaced: true, Kind: "Pod"},
+				},
+			},
+		},
+		{
+			Group: metav1.APIGroup{
+				Versions: []metav1.GroupVersionForDiscovery{
 					{Version: "v1"},
 					{Version: "v2"},
 				},
-				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1"},
+				PreferredVersion: metav1.GroupVersionForDiscovery{Version: "v1"},
 			},
-			VersionedResources: map[string][]unversioned.APIResource{
+			VersionedResources: map[string][]metav1.APIResource{
 				"v1": {
 					{Name: "pods", Namespaced: true, Kind: "Pod"},
 				},
@@ -42,62 +67,57 @@ func TestRESTMapper(t *testing.T) {
 				},
 			},
 		},
-		{
-			Group: unversioned.APIGroup{
-				Name: "extensions",
-				Versions: []unversioned.GroupVersionForDiscovery{
-					{Version: "v1beta"},
-				},
-				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1beta"},
-			},
-			VersionedResources: map[string][]unversioned.APIResource{
-				"v1beta": {
-					{Name: "jobs", Namespaced: true, Kind: "Job"},
-				},
-			},
-		},
 	}
 
 	restMapper := NewRESTMapper(resources, nil)
 
 	kindTCs := []struct {
-		input unversioned.GroupVersionResource
-		want  unversioned.GroupVersionKind
+		input schema.GroupVersionResource
+		want  schema.GroupVersionKind
 	}{
 		{
-			input: unversioned.GroupVersionResource{
-				Version:  "v1",
+			input: schema.GroupVersionResource{
 				Resource: "pods",
 			},
-			want: unversioned.GroupVersionKind{
+			want: schema.GroupVersionKind{
 				Version: "v1",
 				Kind:    "Pod",
 			},
 		},
 		{
-			input: unversioned.GroupVersionResource{
+			input: schema.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+			want: schema.GroupVersionKind{
+				Version: "v1",
+				Kind:    "Pod",
+			},
+		},
+		{
+			input: schema.GroupVersionResource{
 				Version:  "v2",
 				Resource: "pods",
 			},
-			want: unversioned.GroupVersionKind{
+			want: schema.GroupVersionKind{
 				Version: "v2",
 				Kind:    "Pod",
 			},
 		},
 		{
-			input: unversioned.GroupVersionResource{
+			input: schema.GroupVersionResource{
 				Resource: "pods",
 			},
-			want: unversioned.GroupVersionKind{
+			want: schema.GroupVersionKind{
 				Version: "v1",
 				Kind:    "Pod",
 			},
 		},
 		{
-			input: unversioned.GroupVersionResource{
+			input: schema.GroupVersionResource{
 				Resource: "jobs",
 			},
-			want: unversioned.GroupVersionKind{
+			want: schema.GroupVersionKind{
 				Group:   "extensions",
 				Version: "v1beta",
 				Kind:    "Job",
@@ -118,43 +138,52 @@ func TestRESTMapper(t *testing.T) {
 	}
 
 	resourceTCs := []struct {
-		input unversioned.GroupVersionResource
-		want  unversioned.GroupVersionResource
+		input schema.GroupVersionResource
+		want  schema.GroupVersionResource
 	}{
 		{
-			input: unversioned.GroupVersionResource{
-				Version:  "v1",
+			input: schema.GroupVersionResource{
 				Resource: "pods",
 			},
-			want: unversioned.GroupVersionResource{
+			want: schema.GroupVersionResource{
 				Version:  "v1",
 				Resource: "pods",
 			},
 		},
 		{
-			input: unversioned.GroupVersionResource{
+			input: schema.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+			want: schema.GroupVersionResource{
+				Version:  "v1",
+				Resource: "pods",
+			},
+		},
+		{
+			input: schema.GroupVersionResource{
 				Version:  "v2",
 				Resource: "pods",
 			},
-			want: unversioned.GroupVersionResource{
+			want: schema.GroupVersionResource{
 				Version:  "v2",
 				Resource: "pods",
 			},
 		},
 		{
-			input: unversioned.GroupVersionResource{
+			input: schema.GroupVersionResource{
 				Resource: "pods",
 			},
-			want: unversioned.GroupVersionResource{
+			want: schema.GroupVersionResource{
 				Version:  "v1",
 				Resource: "pods",
 			},
 		},
 		{
-			input: unversioned.GroupVersionResource{
+			input: schema.GroupVersionResource{
 				Resource: "jobs",
 			},
-			want: unversioned.GroupVersionResource{
+			want: schema.GroupVersionResource{
 				Group:    "extensions",
 				Version:  "v1beta",
 				Resource: "jobs",
@@ -174,3 +203,151 @@ func TestRESTMapper(t *testing.T) {
 		}
 	}
 }
+
+func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
+	assert := assert.New(t)
+
+	cdc := fakeCachedDiscoveryInterface{fresh: false}
+	m := NewDeferredDiscoveryRESTMapper(&cdc, nil)
+	assert.False(cdc.fresh, "should NOT be fresh after instantiation")
+	assert.Zero(cdc.invalidateCalls, "should not have called Invalidate()")
+
+	gvk, err := m.KindFor(schema.GroupVersionResource{
+		Group:    "a",
+		Version:  "v1",
+		Resource: "foo",
+	})
+	assert.NoError(err)
+	assert.True(cdc.fresh, "should be fresh after a cache-miss")
+	assert.Equal(cdc.invalidateCalls, 1, "should have called Invalidate() once")
+	assert.Equal(gvk.Kind, "Foo")
+
+	gvk, err = m.KindFor(schema.GroupVersionResource{
+		Group:    "a",
+		Version:  "v1",
+		Resource: "foo",
+	})
+	assert.NoError(err)
+	assert.Equal(cdc.invalidateCalls, 1, "should NOT have called Invalidate() again")
+
+	gvk, err = m.KindFor(schema.GroupVersionResource{
+		Group:    "a",
+		Version:  "v1",
+		Resource: "bar",
+	})
+	assert.Error(err)
+	assert.Equal(cdc.invalidateCalls, 1, "should NOT have called Invalidate() again after another cache-miss, but with fresh==true")
+
+	cdc.fresh = false
+	gvk, err = m.KindFor(schema.GroupVersionResource{
+		Group:    "a",
+		Version:  "v1",
+		Resource: "bar",
+	})
+	assert.Error(err)
+	assert.Equal(cdc.invalidateCalls, 2, "should HAVE called Invalidate() again after another cache-miss, but with fresh==false")
+}
+
+type fakeCachedDiscoveryInterface struct {
+	invalidateCalls int
+	fresh           bool
+	enabledA        bool
+}
+
+var _ CachedDiscoveryInterface = &fakeCachedDiscoveryInterface{}
+
+func (c *fakeCachedDiscoveryInterface) Fresh() bool {
+	return c.fresh
+}
+
+func (c *fakeCachedDiscoveryInterface) Invalidate() {
+	c.invalidateCalls = c.invalidateCalls + 1
+	c.fresh = true
+	c.enabledA = true
+}
+
+func (c *fakeCachedDiscoveryInterface) RESTClient() restclient.Interface {
+	return &fake.RESTClient{}
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerGroups() (*metav1.APIGroupList, error) {
+	if c.enabledA {
+		return &metav1.APIGroupList{
+			Groups: []metav1.APIGroup{
+				{
+					Name: "a",
+					Versions: []metav1.GroupVersionForDiscovery{
+						{
+							GroupVersion: "a/v1",
+							Version:      "v1",
+						},
+					},
+					PreferredVersion: metav1.GroupVersionForDiscovery{
+						GroupVersion: "a/v1",
+						Version:      "v1",
+					},
+				},
+			},
+		}, nil
+	}
+	return &metav1.APIGroupList{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
+	if c.enabledA && groupVersion == "a/v1" {
+		return &metav1.APIResourceList{
+			GroupVersion: "a/v1",
+			APIResources: []metav1.APIResource{
+				{
+					Name:       "foo",
+					Kind:       "Foo",
+					Namespaced: false,
+				},
+			},
+		}, nil
+	}
+
+	return nil, errors.NewNotFound(schema.GroupResource{}, "")
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerResources() ([]*metav1.APIResourceList, error) {
+	if c.enabledA {
+		av1, _ := c.ServerResourcesForGroupVersion("a/v1")
+		return []*metav1.APIResourceList{av1}, nil
+	}
+	return []*metav1.APIResourceList{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
+	if c.enabledA {
+		return []*metav1.APIResourceList{
+			{
+				GroupVersion: "a/v1",
+				APIResources: []metav1.APIResource{
+					{
+						Name:  "foo",
+						Kind:  "Foo",
+						Verbs: []string{},
+					},
+				},
+			},
+		}, nil
+	}
+	return nil, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
+	return nil, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) ServerVersion() (*version.Info, error) {
+	return &version.Info{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
+	return &swagger.ApiDeclaration{}, nil
+}
+
+func (c *fakeCachedDiscoveryInterface) OpenAPISchema() (*spec.Swagger, error) {
+	return &spec.Swagger{}, nil
+}

discovery/unstructured.go

@@ -19,20 +19,20 @@ package discovery
 import (
 	"fmt"
 
-	"k8s.io/client-go/pkg/api/unversioned"
-	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
 // UnstructuredObjectTyper provides a runtime.ObjectTyper implmentation for
 // runtime.Unstructured object based on discovery information.
 type UnstructuredObjectTyper struct {
-	registered map[unversioned.GroupVersionKind]bool
+	registered map[schema.GroupVersionKind]bool
 }
 
 // NewUnstructuredObjectTyper returns a runtime.ObjectTyper for
 // unstructred objects based on discovery information.
 func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *UnstructuredObjectTyper {
-	dot := &UnstructuredObjectTyper{registered: make(map[unversioned.GroupVersionKind]bool)}
+	dot := &UnstructuredObjectTyper{registered: make(map[schema.GroupVersionKind]bool)}
 	for _, group := range groupResources {
 		for _, discoveryVersion := range group.Group.Versions {
 			resources, ok := group.VersionedResources[discoveryVersion.Version]
@@ -40,7 +40,7 @@ func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *Unstructur
 				continue
 			}
 
-			gv := unversioned.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
+			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
 			for _, resource := range resources {
 				dot.registered[gv.WithKind(resource.Kind)] = true
 			}
@@ -50,39 +50,39 @@ func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *Unstructur
 }
 
 // ObjectKind returns the group,version,kind of the provided object, or an error
-// if the object in not *runtime.Unstructured or has no group,version,kind
+// if the object in not runtime.Unstructured or has no group,version,kind
 // information.
-func (d *UnstructuredObjectTyper) ObjectKind(obj runtime.Object) (unversioned.GroupVersionKind, error) {
-	if _, ok := obj.(*runtime.Unstructured); !ok {
-		return unversioned.GroupVersionKind{}, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
+func (d *UnstructuredObjectTyper) ObjectKind(obj runtime.Object) (schema.GroupVersionKind, error) {
+	if _, ok := obj.(runtime.Unstructured); !ok {
+		return schema.GroupVersionKind{}, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
 	}
 
 	return obj.GetObjectKind().GroupVersionKind(), nil
 }
 
 // ObjectKinds returns a slice of one element with the group,version,kind of the
-// provided object, or an error if the object is not *runtime.Unstructured or
+// provided object, or an error if the object is not runtime.Unstructured or
 // has no group,version,kind information. unversionedType will always be false
 // because runtime.Unstructured object should always have group,version,kind
 // information set.
-func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []unversioned.GroupVersionKind, unversionedType bool, err error) {
+func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []schema.GroupVersionKind, unversionedType bool, err error) {
 	gvk, err := d.ObjectKind(obj)
 	if err != nil {
 		return nil, false, err
 	}
 
-	return []unversioned.GroupVersionKind{gvk}, false, nil
+	return []schema.GroupVersionKind{gvk}, false, nil
 }
 
 // Recognizes returns true if the provided group,version,kind was in the
 // discovery information.
-func (d *UnstructuredObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
+func (d *UnstructuredObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
 	return d.registered[gvk]
 }
 
-// IsUnversioned returns false always because *runtime.Unstructured objects
+// IsUnversioned returns false always because runtime.Unstructured objects
 // should always have group,version,kind information set. ok will be true if the
-// object's group,version,kind is registered.
+// object's group,version,kind is api.Registry.
 func (d *UnstructuredObjectTyper) IsUnversioned(obj runtime.Object) (unversioned bool, ok bool) {
 	gvk, err := d.ObjectKind(obj)
 	if err != nil {

dynamic/BUILD

@@ -0,0 +1,55 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "client_test.go",
+        "dynamic_util_test.go",
+    ],
+    library = ":go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer/streaming:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/rest/watch:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "client.go",
+        "client_pool.go",
+        "dynamic_util.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/conversion/queryparams:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/scheme:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/util/flowcontrol:go_default_library",
+    ],
+)

dynamic/client.go

@@ -26,27 +26,30 @@ import (
 	"net/url"
 	"strings"
 
-	"k8s.io/client-go/pkg/api"
-	"k8s.io/client-go/pkg/api/unversioned"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/conversion/queryparams"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/pkg/conversion/queryparams"
-	"k8s.io/client-go/pkg/runtime"
-	"k8s.io/client-go/pkg/runtime/serializer"
-	"k8s.io/client-go/pkg/util/flowcontrol"
-	"k8s.io/client-go/pkg/watch"
-	"k8s.io/client-go/rest"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/util/flowcontrol"
 )
 
 // Client is a Kubernetes client that allows you to access metadata
 // and manipulate metadata of a Kubernetes API group.
 type Client struct {
-	cl             *rest.RESTClient
+	cl             *restclient.RESTClient
 	parameterCodec runtime.ParameterCodec
 }
 
 // NewClient returns a new client based on the passed in config. The
 // codec is ignored, as the dynamic client uses it's own codec.
-func NewClient(conf *rest.Config) (*Client, error) {
+func NewClient(conf *restclient.Config) (*Client, error) {
 	// avoid changing the original config
 	confCopy := *conf
 	conf = &confCopy
@@ -63,10 +66,10 @@ func NewClient(conf *rest.Config) (*Client, error) {
 	}
 
 	if len(conf.UserAgent) == 0 {
-		conf.UserAgent = rest.DefaultKubernetesUserAgent()
+		conf.UserAgent = restclient.DefaultKubernetesUserAgent()
 	}
 
-	cl, err := rest.RESTClientFor(conf)
+	cl, err := restclient.RESTClientFor(conf)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +85,7 @@ func (c *Client) GetRateLimiter() flowcontrol.RateLimiter {
 // Resource returns an API interface to the specified resource for this client's
 // group and version. If resource is not a namespaced resource, then namespace
 // is ignored. The ResourceClient inherits the parameter codec of c.
-func (c *Client) Resource(resource *unversioned.APIResource, namespace string) *ResourceClient {
+func (c *Client) Resource(resource *metav1.APIResource, namespace string) *ResourceClient {
 	return &ResourceClient{
 		cl:             c.cl,
 		resource:       resource,
@@ -102,14 +105,14 @@ func (c *Client) ParameterCodec(parameterCodec runtime.ParameterCodec) *Client {
 // ResourceClient is an API interface to a specific resource under a
 // dynamic client.
 type ResourceClient struct {
-	cl             *rest.RESTClient
-	resource       *unversioned.APIResource
+	cl             *restclient.RESTClient
+	resource       *metav1.APIResource
 	ns             string
 	parameterCodec runtime.ParameterCodec
 }
 
 // List returns a list of objects for this resource.
-func (rc *ResourceClient) List(opts runtime.Object) (runtime.Object, error) {
+func (rc *ResourceClient) List(opts metav1.ListOptions) (runtime.Object, error) {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
@@ -117,17 +120,22 @@ func (rc *ResourceClient) List(opts runtime.Object) (runtime.Object, error) {
 	return rc.cl.Get().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(opts, parameterEncoder).
+		VersionedParams(&opts, parameterEncoder).
 		Do().
 		Get()
 }
 
 // Get gets the resource with the specified name.
-func (rc *ResourceClient) Get(name string) (*runtime.Unstructured, error) {
-	result := new(runtime.Unstructured)
+func (rc *ResourceClient) Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error) {
+	parameterEncoder := rc.parameterCodec
+	if parameterEncoder == nil {
+		parameterEncoder = defaultParameterEncoder
+	}
+	result := new(unstructured.Unstructured)
 	err := rc.cl.Get().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
+		VersionedParams(&opts, parameterEncoder).
 		Name(name).
 		Do().
 		Into(result)
@@ -135,7 +143,7 @@ func (rc *ResourceClient) Get(name string) (*runtime.Unstructured, error) {
 }
 
 // Delete deletes the resource with the specified name.
-func (rc *ResourceClient) Delete(name string, opts *v1.DeleteOptions) error {
+func (rc *ResourceClient) Delete(name string, opts *metav1.DeleteOptions) error {
 	return rc.cl.Delete().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -146,7 +154,7 @@ func (rc *ResourceClient) Delete(name string, opts *v1.DeleteOptions) error {
 }
 
 // DeleteCollection deletes a collection of objects.
-func (rc *ResourceClient) DeleteCollection(deleteOptions *v1.DeleteOptions, listOptions runtime.Object) error {
+func (rc *ResourceClient) DeleteCollection(deleteOptions *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
@@ -154,15 +162,15 @@ func (rc *ResourceClient) DeleteCollection(deleteOptions *v1.DeleteOptions, list
 	return rc.cl.Delete().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(listOptions, parameterEncoder).
+		VersionedParams(&listOptions, parameterEncoder).
 		Body(deleteOptions).
 		Do().
 		Error()
 }
 
 // Create creates the provided resource.
-func (rc *ResourceClient) Create(obj *runtime.Unstructured) (*runtime.Unstructured, error) {
-	result := new(runtime.Unstructured)
+func (rc *ResourceClient) Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	result := new(unstructured.Unstructured)
 	err := rc.cl.Post().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -173,8 +181,8 @@ func (rc *ResourceClient) Create(obj *runtime.Unstructured) (*runtime.Unstructur
 }
 
 // Update updates the provided resource.
-func (rc *ResourceClient) Update(obj *runtime.Unstructured) (*runtime.Unstructured, error) {
-	result := new(runtime.Unstructured)
+func (rc *ResourceClient) Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	result := new(unstructured.Unstructured)
 	if len(obj.GetName()) == 0 {
 		return result, errors.New("object missing name")
 	}
@@ -189,21 +197,21 @@ func (rc *ResourceClient) Update(obj *runtime.Unstructured) (*runtime.Unstructur
 }
 
 // Watch returns a watch.Interface that watches the resource.
-func (rc *ResourceClient) Watch(opts runtime.Object) (watch.Interface, error) {
+func (rc *ResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
 	}
+	opts.Watch = true
 	return rc.cl.Get().
-		Prefix("watch").
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(opts, parameterEncoder).
+		VersionedParams(&opts, parameterEncoder).
 		Watch()
 }
 
-func (rc *ResourceClient) Patch(name string, pt api.PatchType, data []byte) (*runtime.Unstructured, error) {
-	result := new(runtime.Unstructured)
+func (rc *ResourceClient) Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error) {
+	result := new(unstructured.Unstructured)
 	err := rc.cl.Patch(pt).
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -218,14 +226,14 @@ func (rc *ResourceClient) Patch(name string, pt api.PatchType, data []byte) (*ru
 // with special handling for Status objects.
 type dynamicCodec struct{}
 
-func (dynamicCodec) Decode(data []byte, gvk *unversioned.GroupVersionKind, obj runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
-	obj, gvk, err := runtime.UnstructuredJSONScheme.Decode(data, gvk, obj)
+func (dynamicCodec) Decode(data []byte, gvk *schema.GroupVersionKind, obj runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
+	obj, gvk, err := unstructured.UnstructuredJSONScheme.Decode(data, gvk, obj)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	if _, ok := obj.(*unversioned.Status); !ok && strings.ToLower(gvk.Kind) == "status" {
-		obj = &unversioned.Status{}
+	if _, ok := obj.(*metav1.Status); !ok && strings.ToLower(gvk.Kind) == "status" {
+		obj = &metav1.Status{}
 		err := json.Unmarshal(data, obj)
 		if err != nil {
 			return nil, nil, err
@@ -236,15 +244,15 @@ func (dynamicCodec) Decode(data []byte, gvk *unversioned.GroupVersionKind, obj r
 }
 
 func (dynamicCodec) Encode(obj runtime.Object, w io.Writer) error {
-	return runtime.UnstructuredJSONScheme.Encode(obj, w)
+	return unstructured.UnstructuredJSONScheme.Encode(obj, w)
 }
 
-// ContentConfig returns a rest.ContentConfig for dynamic types.
-func ContentConfig() rest.ContentConfig {
+// ContentConfig returns a restclient.ContentConfig for dynamic types.
+func ContentConfig() restclient.ContentConfig {
 	var jsonInfo runtime.SerializerInfo
-	// TODO: api.Codecs here should become "pkg/apis/server/scheme" which is the minimal core you need
+	// TODO: scheme.Codecs here should become "pkg/apis/server/scheme" which is the minimal core you need
 	// to talk to a kubernetes server
-	for _, info := range api.Codecs.SupportedMediaTypes() {
+	for _, info := range scheme.Codecs.SupportedMediaTypes() {
 		if info.MediaType == runtime.ContentTypeJSON {
 			jsonInfo = info
 			break
@@ -253,7 +261,7 @@ func ContentConfig() rest.ContentConfig {
 
 	jsonInfo.Serializer = dynamicCodec{}
 	jsonInfo.PrettySerializer = nil
-	return rest.ContentConfig{
+	return restclient.ContentConfig{
 		AcceptContentTypes:   runtime.ContentTypeJSON,
 		ContentType:          runtime.ContentTypeJSON,
 		NegotiatedSerializer: serializer.NegotiatedSerializerWrapper(jsonInfo),
@@ -264,11 +272,11 @@ func ContentConfig() rest.ContentConfig {
 // parameters without trying to convert to the target version.
 type parameterCodec struct{}
 
-func (parameterCodec) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
+func (parameterCodec) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
 	return queryparams.Convert(obj)
 }
 
-func (parameterCodec) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
+func (parameterCodec) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
 	return errors.New("DecodeParameters not implemented on dynamic parameterCodec")
 }
 
@@ -276,16 +284,16 @@ var defaultParameterEncoder runtime.ParameterCodec = parameterCodec{}
 
 type versionedParameterEncoderWithV1Fallback struct{}
 
-func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
-	ret, err := api.ParameterCodec.EncodeParameters(obj, to)
+func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
+	ret, err := scheme.ParameterCodec.EncodeParameters(obj, to)
 	if err != nil && runtime.IsNotRegisteredError(err) {
 		// fallback to v1
-		return api.ParameterCodec.EncodeParameters(obj, v1.SchemeGroupVersion)
+		return scheme.ParameterCodec.EncodeParameters(obj, v1.SchemeGroupVersion)
 	}
 	return ret, err
 }
 
-func (versionedParameterEncoderWithV1Fallback) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
+func (versionedParameterEncoderWithV1Fallback) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
 	return errors.New("DecodeParameters not implemented on versionedParameterEncoderWithV1Fallback")
 }
 

dynamic/client_pool.go

@@ -19,27 +19,27 @@ package dynamic
 import (
 	"sync"
 
-	"k8s.io/client-go/pkg/api/meta"
-	"k8s.io/client-go/pkg/api/unversioned"
-	"k8s.io/client-go/rest"
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	restclient "k8s.io/client-go/rest"
 )
 
 // ClientPool manages a pool of dynamic clients.
 type ClientPool interface {
 	// ClientForGroupVersionKind returns a client configured for the specified groupVersionResource.
 	// Resource may be empty.
-	ClientForGroupVersionResource(resource unversioned.GroupVersionResource) (*Client, error)
+	ClientForGroupVersionResource(resource schema.GroupVersionResource) (*Client, error)
 	// ClientForGroupVersionKind returns a client configured for the specified groupVersionKind.
 	// Kind may be empty.
-	ClientForGroupVersionKind(kind unversioned.GroupVersionKind) (*Client, error)
+	ClientForGroupVersionKind(kind schema.GroupVersionKind) (*Client, error)
 }
 
 // APIPathResolverFunc knows how to convert a groupVersion to its API path. The Kind field is
 // optional.
-type APIPathResolverFunc func(kind unversioned.GroupVersionKind) string
+type APIPathResolverFunc func(kind schema.GroupVersionKind) string
 
 // LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
-func LegacyAPIPathResolverFunc(kind unversioned.GroupVersionKind) string {
+func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
 	if len(kind.Group) == 0 {
 		return "/api"
 	}
@@ -50,8 +50,8 @@ func LegacyAPIPathResolverFunc(kind unversioned.GroupVersionKind) string {
 // is asked to retrieve. This type is thread safe.
 type clientPoolImpl struct {
 	lock                sync.RWMutex
-	config              *rest.Config
-	clients             map[unversioned.GroupVersion]*Client
+	config              *restclient.Config
+	clients             map[schema.GroupVersion]*Client
 	apiPathResolverFunc APIPathResolverFunc
 	mapper              meta.RESTMapper
 }
@@ -59,24 +59,31 @@ type clientPoolImpl struct {
 // NewClientPool returns a ClientPool from the specified config. It reuses clients for the the same
 // group version. It is expected this type may be wrapped by specific logic that special cases certain
 // resources or groups.
-func NewClientPool(config *rest.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
+func NewClientPool(config *restclient.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
 	confCopy := *config
 
 	return &clientPoolImpl{
 		config:              &confCopy,
-		clients:             map[unversioned.GroupVersion]*Client{},
+		clients:             map[schema.GroupVersion]*Client{},
 		apiPathResolverFunc: apiPathResolverFunc,
 		mapper:              mapper,
 	}
 }
 
+// Instantiates a new dynamic client pool with the given config.
+func NewDynamicClientPool(cfg *restclient.Config) ClientPool {
+	// restMapper is not needed when using LegacyAPIPathResolverFunc
+	emptyMapper := meta.MultiRESTMapper{}
+	return NewClientPool(cfg, emptyMapper, LegacyAPIPathResolverFunc)
+}
+
 // ClientForGroupVersionResource uses the provided RESTMapper to identify the appropriate resource. Resource may
 // be empty. If no matching kind is found the underlying client for that group is still returned.
-func (c *clientPoolImpl) ClientForGroupVersionResource(resource unversioned.GroupVersionResource) (*Client, error) {
+func (c *clientPoolImpl) ClientForGroupVersionResource(resource schema.GroupVersionResource) (*Client, error) {
 	kinds, err := c.mapper.KindsFor(resource)
 	if err != nil {
 		if meta.IsNoMatchError(err) {
-			return c.ClientForGroupVersionKind(unversioned.GroupVersionKind{Group: resource.Group, Version: resource.Version})
+			return c.ClientForGroupVersionKind(schema.GroupVersionKind{Group: resource.Group, Version: resource.Version})
 		}
 		return nil, err
 	}
@@ -85,7 +92,7 @@ func (c *clientPoolImpl) ClientForGroupVersionResource(resource unversioned.Grou
 
 // ClientForGroupVersion returns a client for the specified groupVersion, creates one if none exists. Kind
 // in the GroupVersionKind may be empty.
-func (c *clientPoolImpl) ClientForGroupVersionKind(kind unversioned.GroupVersionKind) (*Client, error) {
+func (c *clientPoolImpl) ClientForGroupVersionKind(kind schema.GroupVersionKind) (*Client, error) {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 

dynamic/client_test.go

@@ -25,14 +25,15 @@ import (
 	"reflect"
 	"testing"
 
-	"k8s.io/client-go/pkg/api"
-	"k8s.io/client-go/pkg/api/unversioned"
-	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/pkg/runtime"
-	"k8s.io/client-go/pkg/runtime/serializer/streaming"
-	"k8s.io/client-go/pkg/watch"
-	"k8s.io/client-go/pkg/watch/versioned"
-	"k8s.io/client-go/rest"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/watch"
+	restclient "k8s.io/client-go/rest"
+	restclientwatch "k8s.io/client-go/rest/watch"
 )
 
 func getJSON(version, kind, name string) []byte {
@@ -45,8 +46,8 @@ func getListJSON(version, kind string, items ...[]byte) []byte {
 	return []byte(json)
 }
 
-func getObject(version, kind, name string) *runtime.Unstructured {
-	return &runtime.Unstructured{
+func getObject(version, kind, name string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{
 		Object: map[string]interface{}{
 			"apiVersion": version,
 			"kind":       kind,
@@ -57,11 +58,11 @@ func getObject(version, kind, name string) *runtime.Unstructured {
 	}
 }
 
-func getClientServer(gv *unversioned.GroupVersion, h func(http.ResponseWriter, *http.Request)) (*Client, *httptest.Server, error) {
+func getClientServer(gv *schema.GroupVersion, h func(http.ResponseWriter, *http.Request)) (*Client, *httptest.Server, error) {
 	srv := httptest.NewServer(http.HandlerFunc(h))
-	cl, err := NewClient(&rest.Config{
+	cl, err := NewClient(&restclient.Config{
 		Host:          srv.URL,
-		ContentConfig: rest.ContentConfig{GroupVersion: gv},
+		ContentConfig: restclient.ContentConfig{GroupVersion: gv},
 	})
 	if err != nil {
 		srv.Close()
@@ -76,7 +77,7 @@ func TestList(t *testing.T) {
 		namespace string
 		path      string
 		resp      []byte
-		want      *runtime.UnstructuredList
+		want      *unstructured.UnstructuredList
 	}{
 		{
 			name: "normal_list",
@@ -84,14 +85,14 @@ func TestList(t *testing.T) {
 			resp: getListJSON("vTest", "rTestList",
 				getJSON("vTest", "rTest", "item1"),
 				getJSON("vTest", "rTest", "item2")),
-			want: &runtime.UnstructuredList{
+			want: &unstructured.UnstructuredList{
 				Object: map[string]interface{}{
 					"apiVersion": "vTest",
 					"kind":       "rTestList",
 				},
-				Items: []*runtime.Unstructured{
-					getObject("vTest", "rTest", "item1"),
-					getObject("vTest", "rTest", "item2"),
+				Items: []unstructured.Unstructured{
+					*getObject("vTest", "rTest", "item1"),
+					*getObject("vTest", "rTest", "item2"),
 				},
 			},
 		},
@@ -102,21 +103,21 @@ func TestList(t *testing.T) {
 			resp: getListJSON("vTest", "rTestList",
 				getJSON("vTest", "rTest", "item1"),
 				getJSON("vTest", "rTest", "item2")),
-			want: &runtime.UnstructuredList{
+			want: &unstructured.UnstructuredList{
 				Object: map[string]interface{}{
 					"apiVersion": "vTest",
 					"kind":       "rTestList",
 				},
-				Items: []*runtime.Unstructured{
-					getObject("vTest", "rTest", "item1"),
-					getObject("vTest", "rTest", "item2"),
+				Items: []unstructured.Unstructured{
+					*getObject("vTest", "rTest", "item1"),
+					*getObject("vTest", "rTest", "item2"),
 				},
 			},
 		},
 	}
 	for _, tc := range tcs {
-		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("List(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
@@ -135,7 +136,7 @@ func TestList(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource, tc.namespace).List(&v1.ListOptions{})
+		got, err := cl.Resource(resource, tc.namespace).List(metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when listing %q: %v", tc.name, err)
 			continue
@@ -153,7 +154,7 @@ func TestGet(t *testing.T) {
 		name      string
 		path      string
 		resp      []byte
-		want      *runtime.Unstructured
+		want      *unstructured.Unstructured
 	}{
 		{
 			name: "normal_get",
@@ -170,8 +171,8 @@ func TestGet(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("Get(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
@@ -190,7 +191,7 @@ func TestGet(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource, tc.namespace).Get(tc.name)
+		got, err := cl.Resource(resource, tc.namespace).Get(tc.name, metav1.GetOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when getting %q: %v", tc.name, err)
 			continue
@@ -203,9 +204,9 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	statusOK := &unversioned.Status{
-		TypeMeta: unversioned.TypeMeta{Kind: "Status"},
-		Status:   unversioned.StatusSuccess,
+	statusOK := &metav1.Status{
+		TypeMeta: metav1.TypeMeta{Kind: "Status"},
+		Status:   metav1.StatusSuccess,
 	}
 	tcs := []struct {
 		namespace string
@@ -223,8 +224,8 @@ func TestDelete(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "DELETE" {
 				t.Errorf("Delete(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
@@ -235,7 +236,7 @@ func TestDelete(t *testing.T) {
 			}
 
 			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
-			runtime.UnstructuredJSONScheme.Encode(statusOK, w)
+			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
 		})
 		if err != nil {
 			t.Errorf("unexpected error when creating client: %v", err)
@@ -252,9 +253,9 @@ func TestDelete(t *testing.T) {
 }
 
 func TestDeleteCollection(t *testing.T) {
-	statusOK := &unversioned.Status{
-		TypeMeta: unversioned.TypeMeta{Kind: "Status"},
-		Status:   unversioned.StatusSuccess,
+	statusOK := &metav1.Status{
+		TypeMeta: metav1.TypeMeta{Kind: "Status"},
+		Status:   metav1.StatusSuccess,
 	}
 	tcs := []struct {
 		namespace string
@@ -272,8 +273,8 @@ func TestDeleteCollection(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "DELETE" {
 				t.Errorf("DeleteCollection(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
@@ -284,7 +285,7 @@ func TestDeleteCollection(t *testing.T) {
 			}
 
 			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
-			runtime.UnstructuredJSONScheme.Encode(statusOK, w)
+			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
 		})
 		if err != nil {
 			t.Errorf("unexpected error when creating client: %v", err)
@@ -292,7 +293,7 @@ func TestDeleteCollection(t *testing.T) {
 		}
 		defer srv.Close()
 
-		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, &v1.ListOptions{})
+		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when deleting collection %q: %v", tc.name, err)
 			continue
@@ -304,7 +305,7 @@ func TestCreate(t *testing.T) {
 	tcs := []struct {
 		name      string
 		namespace string
-		obj       *runtime.Unstructured
+		obj       *unstructured.Unstructured
 		path      string
 	}{
 		{
@@ -320,8 +321,8 @@ func TestCreate(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "POST" {
 				t.Errorf("Create(%q) got HTTP method %s. wanted POST", tc.name, r.Method)
@@ -363,7 +364,7 @@ func TestUpdate(t *testing.T) {
 	tcs := []struct {
 		name      string
 		namespace string
-		obj       *runtime.Unstructured
+		obj       *unstructured.Unstructured
 		path      string
 	}{
 		{
@@ -379,8 +380,8 @@ func TestUpdate(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "PUT" {
 				t.Errorf("Update(%q) got HTTP method %s. wanted PUT", tc.name, r.Method)
@@ -424,10 +425,12 @@ func TestWatch(t *testing.T) {
 		namespace string
 		events    []watch.Event
 		path      string
+		query     string
 	}{
 		{
-			name: "normal_watch",
-			path: "/api/gtest/vtest/watch/rtest",
+			name:  "normal_watch",
+			path:  "/api/gtest/vtest/rtest",
+			query: "watch=true",
 			events: []watch.Event{
 				{Type: watch.Added, Object: getObject("vTest", "rTest", "normal_watch")},
 				{Type: watch.Modified, Object: getObject("vTest", "rTest", "normal_watch")},
@@ -437,7 +440,8 @@ func TestWatch(t *testing.T) {
 		{
 			name:      "namespaced_watch",
 			namespace: "nstest",
-			path:      "/api/gtest/vtest/watch/namespaces/nstest/rtest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
+			query:     "watch=true",
 			events: []watch.Event{
 				{Type: watch.Added, Object: getObject("vTest", "rTest", "namespaced_watch")},
 				{Type: watch.Modified, Object: getObject("vTest", "rTest", "namespaced_watch")},
@@ -446,8 +450,8 @@ func TestWatch(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("Watch(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
@@ -456,8 +460,11 @@ func TestWatch(t *testing.T) {
 			if r.URL.Path != tc.path {
 				t.Errorf("Watch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
 			}
+			if r.URL.RawQuery != tc.query {
+				t.Errorf("Watch(%q) got query %s. wanted %s", tc.name, r.URL.RawQuery, tc.query)
+			}
 
-			enc := versioned.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
+			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
 			for _, e := range tc.events {
 				enc.Encode(&e)
 			}
@@ -468,7 +475,7 @@ func TestWatch(t *testing.T) {
 		}
 		defer srv.Close()
 
-		watcher, err := cl.Resource(resource, tc.namespace).Watch(&v1.ListOptions{})
+		watcher, err := cl.Resource(resource, tc.namespace).Watch(metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when watching %q: %v", tc.name, err)
 			continue
@@ -488,7 +495,7 @@ func TestPatch(t *testing.T) {
 		name      string
 		namespace string
 		patch     []byte
-		want      *runtime.Unstructured
+		want      *unstructured.Unstructured
 		path      string
 	}{
 		{
@@ -506,8 +513,8 @@ func TestPatch(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &unversioned.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
 		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "PATCH" {
 				t.Errorf("Patch(%q) got HTTP method %s. wanted PATCH", tc.name, r.Method)
@@ -518,8 +525,8 @@ func TestPatch(t *testing.T) {
 			}
 
 			content := r.Header.Get("Content-Type")
-			if content != string(api.StrategicMergePatchType) {
-				t.Errorf("Patch(%q) got Content-Type %s. wanted %s", tc.name, content, api.StrategicMergePatchType)
+			if content != string(types.StrategicMergePatchType) {
+				t.Errorf("Patch(%q) got Content-Type %s. wanted %s", tc.name, content, types.StrategicMergePatchType)
 			}
 
 			data, err := ioutil.ReadAll(r.Body)
@@ -538,7 +545,7 @@ func TestPatch(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, api.StrategicMergePatchType, tc.patch)
+		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, types.StrategicMergePatchType, tc.patch)
 		if err != nil {
 			t.Errorf("unexpected error when patching %q: %v", tc.name, err)
 			continue
@@ -549,3 +556,11 @@ func TestPatch(t *testing.T) {
 		}
 	}
 }
+
+func TestVersionedParameterEncoderWithV1Fallback(t *testing.T) {
+	enc := VersionedParameterEncoderWithV1Fallback
+	_, err := enc.EncodeParameters(&metav1.ListOptions{}, schema.GroupVersion{Group: "foo.bar.com", Version: "v4"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}

dynamic/dynamic_util.go

@@ -19,25 +19,27 @@ package dynamic
 import (
 	"fmt"
 
-	"k8s.io/client-go/pkg/api/meta"
-	"k8s.io/client-go/pkg/api/unversioned"
-	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
 // VersionInterfaces provides an object converter and metadata
 // accessor appropriate for use with unstructured objects.
-func VersionInterfaces(unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
+func VersionInterfaces(schema.GroupVersion) (*meta.VersionInterfaces, error) {
 	return &meta.VersionInterfaces{
-		ObjectConvertor:  &runtime.UnstructuredObjectConverter{},
+		ObjectConvertor:  &unstructured.UnstructuredObjectConverter{},
 		MetadataAccessor: meta.NewAccessor(),
 	}, nil
 }
 
 // NewDiscoveryRESTMapper returns a RESTMapper based on discovery information.
-func NewDiscoveryRESTMapper(resources []*unversioned.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
+func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
 	rm := meta.NewDefaultRESTMapper(nil, versionFunc)
 	for _, resourceList := range resources {
-		gv, err := unversioned.ParseGroupVersion(resourceList.GroupVersion)
+		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
 		if err != nil {
 			return nil, err
 		}
@@ -55,16 +57,16 @@ func NewDiscoveryRESTMapper(resources []*unversioned.APIResourceList, versionFun
 }
 
 // ObjectTyper provides an ObjectTyper implementation for
-// runtime.Unstructured object based on discovery information.
+// unstructured.Unstructured object based on discovery information.
 type ObjectTyper struct {
-	registered map[unversioned.GroupVersionKind]bool
+	registered map[schema.GroupVersionKind]bool
 }
 
 // NewObjectTyper constructs an ObjectTyper from discovery information.
-func NewObjectTyper(resources []*unversioned.APIResourceList) (runtime.ObjectTyper, error) {
-	ot := &ObjectTyper{registered: make(map[unversioned.GroupVersionKind]bool)}
+func NewObjectTyper(resources []*metav1.APIResourceList) (runtime.ObjectTyper, error) {
+	ot := &ObjectTyper{registered: make(map[schema.GroupVersionKind]bool)}
 	for _, resourceList := range resources {
-		gv, err := unversioned.ParseGroupVersion(resourceList.GroupVersion)
+		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
 		if err != nil {
 			return nil, err
 		}
@@ -78,17 +80,17 @@ func NewObjectTyper(resources []*unversioned.APIResourceList) (runtime.ObjectTyp
 
 // ObjectKinds returns a slice of one element with the
 // group,version,kind of the provided object, or an error if the
-// object is not *runtime.Unstructured or has no group,version,kind
+// object is not *unstructured.Unstructured or has no group,version,kind
 // information.
-func (ot *ObjectTyper) ObjectKinds(obj runtime.Object) ([]unversioned.GroupVersionKind, bool, error) {
-	if _, ok := obj.(*runtime.Unstructured); !ok {
+func (ot *ObjectTyper) ObjectKinds(obj runtime.Object) ([]schema.GroupVersionKind, bool, error) {
+	if _, ok := obj.(*unstructured.Unstructured); !ok {
 		return nil, false, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
 	}
-	return []unversioned.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
+	return []schema.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
 }
 
 // Recognizes returns true if the provided group,version,kind was in
 // the discovery information.
-func (ot *ObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
+func (ot *ObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
 	return ot.registered[gvk]
 }

dynamic/dynamic_util_test.go

@@ -19,14 +19,15 @@ package dynamic
 import (
 	"testing"
 
-	"k8s.io/client-go/pkg/api/unversioned"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
 func TestDiscoveryRESTMapper(t *testing.T) {
-	resources := []*unversioned.APIResourceList{
+	resources := []*metav1.APIResourceList{
 		{
 			GroupVersion: "test/beta1",
-			APIResources: []unversioned.APIResource{
+			APIResources: []metav1.APIResource{
 				{
 					Name:       "test_kinds",
 					Namespaced: true,
@@ -36,7 +37,7 @@ func TestDiscoveryRESTMapper(t *testing.T) {
 		},
 	}
 
-	gvk := unversioned.GroupVersionKind{
+	gvk := schema.GroupVersionKind{
 		Group:   "test",
 		Version: "beta1",
 		Kind:    "test_kind",
@@ -47,7 +48,7 @@ func TestDiscoveryRESTMapper(t *testing.T) {
 		t.Fatalf("unexpected error creating mapper: %s", err)
 	}
 
-	for _, res := range []unversioned.GroupVersionResource{
+	for _, res := range []schema.GroupVersionResource{
 		{
 			Group:    "test",
 			Version:  "beta1",

examples/README.md

@@ -0,0 +1,31 @@
+# client-go Examples
+
+This directory contains examples that cover various use cases and functionality
+for client-go.
+
+### Configuration
+
+- [**Authenticate in cluster**](./in-cluster-client-configuration): Configure a
+  client while running inside the Kubernetes cluster.
+- [**Authenticate out of cluster**](./out-of-cluster-client-configuration):
+  Configure a client to access a Kubernetes cluster from outside.
+
+### Basics
+
+- [**Managing resources with API**](./create-update-delete-deployment): Create,
+  get, update, delete a Deployment resource.
+
+### Advanced Concepts
+
+- [**Work queues**](./workqueue): Create a hotloop-free controller with the
+  rate-limited workqueue and the [informer framework][informer].
+- [**Third-party resources (deprecated)**](./third-party-resources-deprecated):
+  Register a third-party resource type with the API, create/update/query this third-party
+  type, and write a controller that drives the cluster state based on the changes to
+  the third-party resources.
+- [**Custom Resource Definition (successor of TPR)**](https://git.k8s.io/apiextensions-apiserver/examples/client-go):
+  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.
+
+[informer]: https://godoc.org/k8s.io/client-go/tools/cache#NewInformer

examples/create-update-delete-deployment/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "create-update-delete-deployment",
+    library = ":go_default_library",
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
+    ],
+)

examples/create-update-delete-deployment/README.md

@@ -0,0 +1,81 @@
+# Create, Update & Delete Deployment
+
+This example program demonstrates the fundamental operations for managing on
+[Deployment][1] resources, such as `Create`, `List`, `Update` and `Delete`.
+
+You can adopt the source code from this example to write programs that manage
+other types of resources through the Kubernetes API.
+
+## Running this example
+
+Make sure you have a Kubernetes cluster and `kubectl` is configured:
+
+    kubectl get nodes
+
+Compile this example on your workstation:
+
+```
+cd create-update-delete-deployment
+go build -o ./app
+```
+
+Now, run this application on your workstation with your local kubeconfig file:
+
+```
+./app -kubeconfig=$HOME/.kube/config
+```
+
+Running this command will execute the following operations on your cluster:
+
+1. **Create Deployment:** This will create a 2 replica Deployment. Verify with
+   `kubectl get pods`.
+2. **Update Deployment:** This will update the Deployment resource created in
+   previous step to set the replica count to 1 and add annotations. You are
+   encouraged to inspect the retry loop that handles conflicts. Verify the new
+   replica count and `foo=bar` annotation with `kubectl describe deployment
+   demo`.
+3. **List Deployments:** This will retrieve Deployments in the `default`
+   namespace and print their names and replica counts.
+4. **Delete Deployment:** This will delete the Deployment object and its
+   dependent ReplicaSet resource. Verify with `kubectl get deployments`.
+
+Each step is separated by an interactive prompt. You must hit the
+<kbd>Return</kbd> key to proceeed to the next step. You can use these prompts as
+a break to take time to  run `kubectl` and inspect the result of the operations
+executed.
+
+You should see an output like the following:
+
+```
+Creating deployment...
+Created deployment "demo-deployment".
+-> Press Return key to continue.
+
+Updating deployment...
+Updated deployment...
+-> Press Return key to continue.
+
+Listing deployments in namespace "default":
+ * demo-deployment (1 replicas)
+-> Press Return key to continue.
+
+Deleting deployment...
+Deleted deployment.
+```
+
+## Cleanup
+
+Successfully running this program will clean the created artifacts. If you
+terminate the program without completing, you can clean up the created
+deployment with:
+
+    kubectl delete deploy demo-deployment
+
+## Troubleshooting
+
+If you are getting the following error, make sure Kubernetes version of your
+cluster is v1.6 or above in `kubectl version`:
+
+    panic: the server could not find the requested resource
+
+[1]: https://kubernetes.io/docs/user-guide/deployments/

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

@@ -0,0 +1,165 @@
+/*
+Copyright 2017 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.
+*/
+
+// Note: the example only works with the code within the same release/branch.
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"os"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	apiv1 "k8s.io/client-go/pkg/api/v1"
+	appsv1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
+	"k8s.io/client-go/tools/clientcmd"
+	// Uncomment the following line to load the gcp plugin (only required to authenticate against GKE clusters).
+	// _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
+)
+
+func main() {
+	kubeconfig := flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
+	flag.Parse()
+	if *kubeconfig == "" {
+		panic("-kubeconfig not specified")
+	}
+	config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
+	if err != nil {
+		panic(err)
+	}
+	clientset, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		panic(err)
+	}
+
+	deploymentsClient := clientset.AppsV1beta1().Deployments(apiv1.NamespaceDefault)
+
+	deployment := &appsv1beta1.Deployment{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "demo-deployment",
+		},
+		Spec: appsv1beta1.DeploymentSpec{
+			Replicas: int32Ptr(2),
+			Template: apiv1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"app": "demo",
+					},
+				},
+				Spec: apiv1.PodSpec{
+					Containers: []apiv1.Container{
+						{
+							Name:  "web",
+							Image: "nginx:1.13",
+							Ports: []apiv1.ContainerPort{
+								{
+									Name:          "http",
+									Protocol:      apiv1.ProtocolTCP,
+									ContainerPort: 80,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	// Create Deployment
+	fmt.Println("Creating deployment...")
+	result, err := deploymentsClient.Create(deployment)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("Created deployment %q.\n", result.GetObjectMeta().GetName())
+
+	// Update Deployment
+	prompt()
+	fmt.Println("Updating deployment...")
+	//    You have two options to Update() this Deployment:
+	//
+	//    1. Modify the "deployment" variable and call: Update(deployment).
+	//       This works like the "kubectl replace" command and it overwrites/loses changes
+	//       made by other clients between you Create() and Update() the object.
+	//    2. Modify the "result" returned by Create()/Get() and retry Update(result) until
+	//       you no longer get a conflict error. This way, you can preserve changes made
+	//       by other clients between Create() and Update(). This is implemented below:
+
+	for {
+		result.Spec.Replicas = int32Ptr(1)                    // reduce replica count
+		result.Spec.Template.Annotations = map[string]string{ // add annotations
+			"foo": "bar",
+		}
+
+		if _, err := deploymentsClient.Update(result); errors.IsConflict(err) {
+			// Deployment is modified in the meanwhile, query the latest version
+			// and modify the retrieved object.
+			fmt.Println("encountered conflict, retrying")
+			result, err = deploymentsClient.Get("demo-deployment", metav1.GetOptions{})
+			if err != nil {
+				panic(fmt.Errorf("Get failed: %+v", err))
+			}
+		} else if err != nil {
+			panic(err)
+		} else {
+			break
+		}
+
+		// TODO: You should sleep here with an exponential backoff to avoid
+		// exhausting the apiserver, and add a limit/timeout on the retries to
+		// avoid getting stuck in this loop indefintiely.
+	}
+	fmt.Println("Updated deployment...")
+
+	// List Deployments
+	prompt()
+	fmt.Printf("Listing deployments in namespace %q:\n", apiv1.NamespaceDefault)
+	list, err := deploymentsClient.List(metav1.ListOptions{})
+	if err != nil {
+		panic(err)
+	}
+	for _, d := range list.Items {
+		fmt.Printf(" * %s (%d replicas)\n", d.Name, *d.Spec.Replicas)
+	}
+
+	// Delete Deployment
+	prompt()
+	fmt.Println("Deleting deployment...")
+	deletePolicy := metav1.DeletePropagationForeground
+	if err := deploymentsClient.Delete("demo-deployment", &metav1.DeleteOptions{
+		PropagationPolicy: &deletePolicy,
+	}); err != nil {
+		panic(err)
+	}
+	fmt.Println("Deleted deployment.")
+}
+
+func prompt() {
+	fmt.Printf("-> Press Return key to continue.")
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		break
+	}
+	if err := scanner.Err(); err != nil {
+		panic(err)
+	}
+	fmt.Println()
+}
+
+func int32Ptr(i int32) *int32 { return &i }

examples/in-cluster-client-configuration/BUILD

@@ -0,0 +1,27 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "in-cluster-client-configuration",
+    library = ":go_default_library",
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+    ],
+)

examples/in-cluster-client-configuration/Dockerfile

@@ -0,0 +1,17 @@
+# Copyright 2017 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.
+
+FROM debian
+COPY ./app /app
+ENTRYPOINT /app

examples/in-cluster-client-configuration/README.md

@@ -0,0 +1,50 @@
+# Authenticating inside the cluster
+
+This example shows you how to configure a client with client-go to authenticate
+to the Kubernetes API from an application running inside the Kubernetes cluster.
+
+client-go uses the [Service Account token][sa] mounted inside the Pod at the
+`/var/run/secrets/kubernetes.io/serviceaccount` path when the
+`rest.InClusterConfig()` is used.
+
+## Running this example
+
+First compile the application for Linux:
+
+    cd in-cluster-client-configuration
+    GOOS=linux go build -o ./app .
+
+Then package it to a docker image using the provided Dockerfile to run it on
+Kubernetes.
+
+If you are running a [Minikube][mk] cluster, you can build this image directly
+on the Docker engine of the Minikube node without pushing it to a registry. To
+build the image on Minikube:
+
+    eval $(minikube docker-env)
+    docker build -t in-cluster .
+
+If you are not using Minikube, you should build this image and push it to a registry
+that your Kubernetes cluster can pull from.
+
+Then, run the image in a Pod with a single instance Deployment:
+
+    $ 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
+    There are 4 pods in the cluster
+    ...
+
+The example now runs on Kubernetes API and successfully queries the number of
+pods in the cluster every 10 seconds.
+
+### Clean up
+
+To stop this example and clean up the pod, press <kbd>Ctrl</kbd>+<kbd>C</kbd> on
+the `kubectl run` command and then run:
+
+    kubectl delete deployment demo
+
+[sa]: https://kubernetes.io/docs/admin/authentication/#service-account-tokens
+[mk]: https://kubernetes.io/docs/getting-started-guides/minikube/

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

@@ -14,15 +14,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// Note: the example only works with the code within the same release/branch.
 package main
 
 import (
 	"fmt"
 	"time"
 
-	"k8s.io/client-go/1.4/kubernetes"
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/rest"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
 )
 
 func main() {
@@ -37,11 +39,26 @@ func main() {
 		panic(err.Error())
 	}
 	for {
-		pods, err := clientset.Core().Pods("").List(api.ListOptions{})
+		pods, err := clientset.CoreV1().Pods("").List(metav1.ListOptions{})
 		if err != nil {
 			panic(err.Error())
 		}
 		fmt.Printf("There are %d pods in the cluster\n", len(pods.Items))
+
+		// Examples for error handling:
+		// - Use helper functions like e.g. errors.IsNotFound()
+		// - And/or cast to StatusError and use its properties like e.g. ErrStatus.Message
+		_, err = clientset.CoreV1().Pods("default").Get("example-xxxxx", metav1.GetOptions{})
+		if errors.IsNotFound(err) {
+			fmt.Printf("Pod not found\n")
+		} else if statusError, isStatus := err.(*errors.StatusError); isStatus {
+			fmt.Printf("Error getting pod %v\n", statusError.ErrStatus.Message)
+		} else if err != nil {
+			panic(err.Error())
+		} else {
+			fmt.Printf("Found pod\n")
+		}
+
 		time.Sleep(10 * time.Second)
 	}
 }

examples/out-of-cluster-client-configuration/BUILD

@@ -0,0 +1,27 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "out-of-cluster-client-configuration",
+    library = ":go_default_library",
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
+    ],
+)

examples/out-of-cluster-client-configuration/README.md

@@ -0,0 +1,35 @@
+# Authenticating outside the cluster
+
+This example shows you how to configure a client with client-go to authenticate
+to the Kubernetes API from an application running outside the Kubernetes
+cluster.
+
+You can use your kubeconfig file that contains the context information
+of your cluster to initialize a client. The kubeconfig file is also used
+by the `kubectl` command to authenticate to the clusters.
+
+## Running this example
+
+Make sure your `kubectl` is configured and pointed to a cluster. Run
+`kubectl get nodes` to confirm.
+
+Run this application with:
+
+    cd out-of-cluster-client-configuration
+    go build -o app .
+    ./app
+
+Running this application will use the kubeconfig file and then authenticate to the
+cluster, and print the number of nodes in the cluster every 10 seconds:
+
+    $ ./app
+    There are 3 pods in the cluster
+    There are 3 pods in the cluster
+    There are 3 pods in the cluster
+    ...
+
+Press <kbd>Ctrl</kbd>+<kbd>C</kbd> to quit this application.
+
+> **Note:** You can use the `-kubeconfig` option to use a different config file. By default
+this program picks up the default file used by kubectl (when `KUBECONFIG`
+environment variable is not set).

examples/out-of-cluster-client-configuration/main.go

@@ -0,0 +1,85 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Note: the example only works with the code within the same release/branch.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/tools/clientcmd"
+	// Uncomment the following line to load the gcp plugin (only required to authenticate against GKE clusters).
+	// _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
+)
+
+func main() {
+	var kubeconfig *string
+	if home := homeDir(); home != "" {
+		kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
+	} else {
+		kubeconfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
+	}
+	flag.Parse()
+
+	// use the current context in kubeconfig
+	config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	// create the clientset
+	clientset, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		panic(err.Error())
+	}
+	for {
+		pods, err := clientset.CoreV1().Pods("").List(metav1.ListOptions{})
+		if err != nil {
+			panic(err.Error())
+		}
+		fmt.Printf("There are %d pods in the cluster\n", len(pods.Items))
+
+		// Examples for error handling:
+		// - Use helper functions like e.g. errors.IsNotFound()
+		// - And/or cast to StatusError and use its properties like e.g. ErrStatus.Message
+		_, err = clientset.CoreV1().Pods("default").Get("example-xxxxx", metav1.GetOptions{})
+		if errors.IsNotFound(err) {
+			fmt.Printf("Pod not found\n")
+		} else if statusError, isStatus := err.(*errors.StatusError); isStatus {
+			fmt.Printf("Error getting pod %v\n", statusError.ErrStatus.Message)
+		} else if err != nil {
+			panic(err.Error())
+		} else {
+			fmt.Printf("Found pod\n")
+		}
+
+		time.Sleep(10 * time.Second)
+	}
+}
+
+func homeDir() string {
+	if h := os.Getenv("HOME"); h != "" {
+		return h
+	}
+	return os.Getenv("USERPROFILE") // windows
+}

examples/out-of-cluster/main.go

@@ -1,53 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"time"
-
-	"k8s.io/client-go/1.4/kubernetes"
-	"k8s.io/client-go/1.4/pkg/api"
-	"k8s.io/client-go/1.4/tools/clientcmd"
-)
-
-var (
-	kubeconfig = flag.String("kubeconfig", "./config", "absolute path to the kubeconfig file")
-)
-
-func main() {
-	flag.Parse()
-	// uses the current context in kubeconfig
-	config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
-	if err != nil {
-		panic(err.Error())
-	}
-	// creates the clientset
-	clientset, err := kubernetes.NewForConfig(config)
-	if err != nil {
-		panic(err.Error())
-	}
-	for {
-		pods, err := clientset.Core().Pods("").List(api.ListOptions{})
-		if err != nil {
-			panic(err.Error())
-		}
-		fmt.Printf("There are %d pods in the cluster\n", len(pods.Items))
-		time.Sleep(10 * time.Second)
-	}
-}

examples/third-party-resources-deprecated/BUILD

@@ -0,0 +1,32 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/client-go/examples/third-party-resources-deprecated/apis/tpr/v1:go_default_library",
+        "//vendor/k8s.io/client-go/examples/third-party-resources-deprecated/client:go_default_library",
+        "//vendor/k8s.io/client-go/examples/third-party-resources-deprecated/controller:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
+    ],
+)
+
+go_binary(
+    name = "third-party-resources-deprecated",
+    library = ":go_default_library",
+    tags = ["automanaged"],
+)

examples/third-party-resources-deprecated/README.md

@@ -0,0 +1,46 @@
+# Third Party Resources Example – Deprecated
+
+**Note:** ThirdPartyResources are deprecated since 1.7. The successor is CustomResourceDefinition in the apiextensions.k8s.io API group.
+
+This particular example demonstrates how to perform basic operations such as:
+
+* How to register a new ThirdPartyResource (custom Resource type)
+* How to create/get/list instances of your new Resource type (update/delete/etc work as well but are not demonstrated) 
+* How to setup a controller on Resource handling create/update/delete events
+
+## Running
+
+```
+# assumes you have a working kubeconfig, not required if operating in-cluster
+go run *.go -kubeconfig=$HOME/.kube/config
+```
+
+## Use Cases
+
+ThirdPartyResources can be used to implement custom Resource types for your Kubernetes cluster.
+These act like most other Resources in Kubernetes, and may be `kubectl apply`'d, etc.
+
+Some example use cases:
+
+* Provisioning/Management of external datastores/databases (eg. CloudSQL/RDS instances)
+* Higher level abstractions around Kubernetes primitives (eg. a single Resource to define an etcd cluster, backed by a Service and a ReplicationController) 
+
+## Defining types
+
+Each instance of your ThirdPartyResource has an attached Spec, which should be defined via a `struct{}` to provide data format validation.
+In practice, this Spec is arbitrary key-value data that specifies the configuration/behavior of your Resource.
+
+For example, if you were implementing a ThirdPartyResource for a Database, you might provide a DatabaseSpec like the following:
+
+``` go
+type DatabaseSpec struct {
+	Databases []string `json:"databases"`
+	Users     []User   `json:"users"`
+	Version   string   `json:"version"`
+}
+
+type User struct {
+	Name     string `json:"name"`
+	Password string `json:"password"`
+}
+```

examples/third-party-resources-deprecated/apis/tpr/v1/BUILD

@@ -0,0 +1,37 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["types_test.go"],
+    library = ":go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/google/gofuzz:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/testing:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "register.go",
+        "types.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+    ],
+)

examples/third-party-resources-deprecated/apis/tpr/v1/register.go

@@ -0,0 +1,49 @@
+/*
+Copyright 2017 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 v1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+var (
+	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
+	AddToScheme   = SchemeBuilder.AddToScheme
+)
+
+// GroupName is the group name use in this package.
+const GroupName = "tpr.client-go.k8s.io"
+
+// SchemeGroupVersion is the group version used to register these objects.
+var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}
+
+// Resource takes an unqualified resource and returns a Group-qualified GroupResource.
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+// addKnownTypes adds the set of types defined in this package to the supplied scheme.
+func addKnownTypes(scheme *runtime.Scheme) error {
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&Example{},
+		&ExampleList{},
+	)
+	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
+	return nil
+}

examples/third-party-resources-deprecated/apis/tpr/v1/types.go

@@ -0,0 +1,53 @@
+/*
+Copyright 2017 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 v1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const ExampleResourcePlural = "examples"
+
+type Example struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata"`
+	Spec              ExampleSpec   `json:"spec"`
+	Status            ExampleStatus `json:"status,omitempty"`
+}
+
+type ExampleSpec struct {
+	Foo string `json:"foo"`
+	Bar bool   `json:"bar"`
+}
+
+type ExampleStatus struct {
+	State   ExampleState `json:"state,omitempty"`
+	Message string       `json:"message,omitempty"`
+}
+
+type ExampleState string
+
+const (
+	ExampleStateCreated   ExampleState = "Created"
+	ExampleStateProcessed ExampleState = "Processed"
+)
+
+type ExampleList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata"`
+	Items           []Example `json:"items"`
+}

examples/third-party-resources-deprecated/apis/tpr/v1/types_test.go

@@ -0,0 +1,63 @@
+/*
+Copyright 2017 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 v1
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/google/gofuzz"
+
+	apitesting "k8s.io/apimachinery/pkg/api/testing"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+)
+
+var _ runtime.Object = &Example{}
+var _ metav1.ObjectMetaAccessor = &Example{}
+
+var _ runtime.Object = &ExampleList{}
+var _ metav1.ListMetaAccessor = &ExampleList{}
+
+func exampleFuzzerFuncs(t apitesting.TestingCommon) []interface{} {
+	return []interface{}{
+		func(obj *ExampleList, c fuzz.Continue) {
+			c.FuzzNoCustom(obj)
+			obj.Items = make([]Example, c.Intn(10))
+			for i := range obj.Items {
+				c.Fuzz(&obj.Items[i])
+			}
+		},
+	}
+}
+
+// TestRoundTrip tests that the third-party kinds can be marshaled and unmarshaled correctly to/from JSON
+// without the loss of information. Moreover, deep copy is tested.
+func TestRoundTrip(t *testing.T) {
+	scheme := runtime.NewScheme()
+	codecs := serializer.NewCodecFactory(scheme)
+
+	AddToScheme(scheme)
+
+	seed := rand.Int63()
+	fuzzerFuncs := apitesting.MergeFuzzerFuncs(t, apitesting.GenericFuzzerFuncs(t, codecs), exampleFuzzerFuncs(t))
+	fuzzer := apitesting.FuzzerFor(fuzzerFuncs, rand.NewSource(seed))
+
+	apitesting.RoundTripSpecificKindWithoutProtobuf(t, SchemeGroupVersion.WithKind("Example"), scheme, codecs, fuzzer, nil)
+	apitesting.RoundTripSpecificKindWithoutProtobuf(t, SchemeGroupVersion.WithKind("ExampleList"), scheme, codecs, fuzzer, nil)
+}

examples/third-party-resources-deprecated/client/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "client.go",
+        "tpr.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/examples/third-party-resources-deprecated/apis/tpr/v1:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+    ],
+)

examples/third-party-resources-deprecated/client/client.go

@@ -0,0 +1,45 @@
+/*
+Copyright 2017 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 client
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+	"k8s.io/client-go/rest"
+
+	tprv1 "k8s.io/client-go/examples/third-party-resources-deprecated/apis/tpr/v1"
+)
+
+func NewClient(cfg *rest.Config) (*rest.RESTClient, *runtime.Scheme, error) {
+	scheme := runtime.NewScheme()
+	if err := tprv1.AddToScheme(scheme); err != nil {
+		return nil, nil, err
+	}
+
+	config := *cfg
+	config.GroupVersion = &tprv1.SchemeGroupVersion
+	config.APIPath = "/apis"
+	config.ContentType = runtime.ContentTypeJSON
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: serializer.NewCodecFactory(scheme)}
+
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return client, scheme, nil
+}

examples/third-party-resources-deprecated/client/tpr.go

@@ -0,0 +1,76 @@
+/*
+Copyright 2017 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 client
+
+import (
+	"time"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+	tprv1 "k8s.io/client-go/examples/third-party-resources-deprecated/apis/tpr/v1"
+	"k8s.io/client-go/kubernetes"
+	apiv1 "k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/pkg/apis/extensions/v1beta1"
+	"k8s.io/client-go/rest"
+	// Uncomment the following line to load the gcp plugin (only required to authenticate against GKE clusters).
+	// _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
+)
+
+func CreateTPR(clientset kubernetes.Interface) error {
+	tpr := &v1beta1.ThirdPartyResource{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "example." + tprv1.GroupName,
+		},
+		Versions: []v1beta1.APIVersion{
+			{Name: tprv1.SchemeGroupVersion.Version},
+		},
+		Description: "An Example ThirdPartyResource",
+	}
+	_, err := clientset.ExtensionsV1beta1().ThirdPartyResources().Create(tpr)
+	return err
+}
+
+func WaitForExampleResource(exampleClient *rest.RESTClient) error {
+	return wait.Poll(100*time.Millisecond, 60*time.Second, func() (bool, error) {
+		_, err := exampleClient.Get().Namespace(apiv1.NamespaceDefault).Resource(tprv1.ExampleResourcePlural).DoRaw()
+		if err == nil {
+			return true, nil
+		}
+		if apierrors.IsNotFound(err) {
+			return false, nil
+		}
+		return false, err
+	})
+}
+
+func WaitForExampleInstanceProcessed(exampleClient *rest.RESTClient, name string) error {
+	return wait.Poll(100*time.Millisecond, 10*time.Second, func() (bool, error) {
+		var example tprv1.Example
+		err := exampleClient.Get().
+			Resource(tprv1.ExampleResourcePlural).
+			Namespace(apiv1.NamespaceDefault).
+			Name(name).
+			Do().Into(&example)
+
+		if err == nil && example.Status.State == tprv1.ExampleStateProcessed {
+			return true, nil
+		}
+
+		return false, err
+	})
+}

examples/third-party-resources-deprecated/controller/BUILD

@@ -0,0 +1,22 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["controller.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/client-go/examples/third-party-resources-deprecated/apis/tpr/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/rest:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

examples/third-party-resources-deprecated/controller/controller.go

@@ -0,0 +1,126 @@
+/*
+Copyright 2017 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 controller
+
+import (
+	"context"
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/apimachinery/pkg/runtime"
+	apiv1 "k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/cache"
+
+	tprv1 "k8s.io/client-go/examples/third-party-resources-deprecated/apis/tpr/v1"
+)
+
+// Watcher is an example of watching on resource create/update/delete events
+type ExampleController struct {
+	ExampleClient *rest.RESTClient
+	ExampleScheme *runtime.Scheme
+}
+
+// Run starts an Example resource controller
+func (c *ExampleController) Run(ctx context.Context) error {
+	fmt.Print("Watch Example objects\n")
+
+	// Watch Example objects
+	_, err := c.watchExamples(ctx)
+	if err != nil {
+		fmt.Printf("Failed to register watch for Example resource: %v\n", err)
+		return err
+	}
+
+	<-ctx.Done()
+	return ctx.Err()
+}
+
+func (c *ExampleController) watchExamples(ctx context.Context) (cache.Controller, error) {
+	source := cache.NewListWatchFromClient(
+		c.ExampleClient,
+		tprv1.ExampleResourcePlural,
+		apiv1.NamespaceAll,
+		fields.Everything())
+
+	_, controller := cache.NewInformer(
+		source,
+
+		// The object type.
+		&tprv1.Example{},
+
+		// resyncPeriod
+		// Every resyncPeriod, all resources in the cache will retrigger events.
+		// Set to 0 to disable the resync.
+		0,
+
+		// Your custom resource event handlers.
+		cache.ResourceEventHandlerFuncs{
+			AddFunc:    c.onAdd,
+			UpdateFunc: c.onUpdate,
+			DeleteFunc: c.onDelete,
+		})
+
+	go controller.Run(ctx.Done())
+	return controller, nil
+}
+
+func (c *ExampleController) onAdd(obj interface{}) {
+	example := obj.(*tprv1.Example)
+	fmt.Printf("[CONTROLLER] OnAdd %s\n", example.ObjectMeta.SelfLink)
+
+	// NEVER modify objects from the store. It's a read-only, local cache.
+	// You can use exampleScheme.Copy() to make a deep copy of original object and modify this copy
+	// Or create a copy manually for better performance
+	copyObj, err := c.ExampleScheme.Copy(example)
+	if err != nil {
+		fmt.Printf("ERROR creating a deep copy of example object: %v\n", err)
+		return
+	}
+
+	exampleCopy := copyObj.(*tprv1.Example)
+	exampleCopy.Status = tprv1.ExampleStatus{
+		State:   tprv1.ExampleStateProcessed,
+		Message: "Successfully processed by controller",
+	}
+
+	err = c.ExampleClient.Put().
+		Name(example.ObjectMeta.Name).
+		Namespace(example.ObjectMeta.Namespace).
+		Resource(tprv1.ExampleResourcePlural).
+		Body(exampleCopy).
+		Do().
+		Error()
+
+	if err != nil {
+		fmt.Printf("ERROR updating status: %v\n", err)
+	} else {
+		fmt.Printf("UPDATED status: %#v\n", exampleCopy)
+	}
+}
+
+func (c *ExampleController) onUpdate(oldObj, newObj interface{}) {
+	oldExample := oldObj.(*tprv1.Example)
+	newExample := newObj.(*tprv1.Example)
+	fmt.Printf("[CONTROLLER] OnUpdate oldObj: %s\n", oldExample.ObjectMeta.SelfLink)
+	fmt.Printf("[CONTROLLER] OnUpdate newObj: %s\n", newExample.ObjectMeta.SelfLink)
+}
+
+func (c *ExampleController) onDelete(obj interface{}) {
+	example := obj.(*tprv1.Example)
+	fmt.Printf("[CONTROLLER] OnDelete %s\n", example.ObjectMeta.SelfLink)
+}

examples/third-party-resources-deprecated/main.go

@@ -0,0 +1,132 @@
+/*
+Copyright 2017 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.
+*/
+
+// Note: the example only works with the code within the same release/branch.
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	apiv1 "k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+
+	// Uncomment the following line to load the gcp plugin (only required to authenticate against GKE clusters).
+	// _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
+
+	tprv1 "k8s.io/client-go/examples/third-party-resources-deprecated/apis/tpr/v1"
+	exampleclient "k8s.io/client-go/examples/third-party-resources-deprecated/client"
+	examplecontroller "k8s.io/client-go/examples/third-party-resources-deprecated/controller"
+)
+
+func main() {
+	kubeconfig := flag.String("kubeconfig", "", "Path to a kube config. Only required if out-of-cluster.")
+	flag.Parse()
+
+	// Create the client config. Use kubeconfig if given, otherwise assume in-cluster.
+	config, err := buildConfig(*kubeconfig)
+	if err != nil {
+		panic(err)
+	}
+
+	clientset, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		panic(err)
+	}
+
+	// initialize third party resource if it does not exist
+	err = exampleclient.CreateTPR(clientset)
+	if err != nil && !apierrors.IsAlreadyExists(err) {
+		panic(err)
+	}
+
+	// make a new config for our extension's API group, using the first config as a baseline
+	exampleClient, exampleScheme, err := exampleclient.NewClient(config)
+	if err != nil {
+		panic(err)
+	}
+
+	// wait until TPR gets processed
+	err = exampleclient.WaitForExampleResource(exampleClient)
+	if err != nil {
+		panic(err)
+	}
+
+	// start a controller on instances of our TPR
+	controller := examplecontroller.ExampleController{
+		ExampleClient: exampleClient,
+		ExampleScheme: exampleScheme,
+	}
+
+	ctx, cancelFunc := context.WithCancel(context.Background())
+	defer cancelFunc()
+	go controller.Run(ctx)
+
+	// Create an instance of our TPR
+	example := &tprv1.Example{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "example1",
+		},
+		Spec: tprv1.ExampleSpec{
+			Foo: "hello",
+			Bar: true,
+		},
+		Status: tprv1.ExampleStatus{
+			State:   tprv1.ExampleStateCreated,
+			Message: "Created, not processed yet",
+		},
+	}
+	var result tprv1.Example
+	err = exampleClient.Post().
+		Resource(tprv1.ExampleResourcePlural).
+		Namespace(apiv1.NamespaceDefault).
+		Body(example).
+		Do().Into(&result)
+	if err == nil {
+		fmt.Printf("CREATED: %#v\n", result)
+	} else if apierrors.IsAlreadyExists(err) {
+		fmt.Printf("ALREADY EXISTS: %#v\n", result)
+	} else {
+		panic(err)
+	}
+
+	// Poll until Example object is handled by controller and gets status updated to "Processed"
+	err = exampleclient.WaitForExampleInstanceProcessed(exampleClient, "example1")
+	if err != nil {
+		panic(err)
+	}
+	fmt.Print("PROCESSED\n")
+
+	// Fetch a list of our TPRs
+	exampleList := tprv1.ExampleList{}
+	err = exampleClient.Get().Resource(tprv1.ExampleResourcePlural).Do().Into(&exampleList)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("LIST: %#v\n", exampleList)
+}
+
+func buildConfig(kubeconfig string) (*rest.Config, error) {
+	if kubeconfig != "" {
+		return clientcmd.BuildConfigFromFlags("", kubeconfig)
+	}
+	return rest.InClusterConfig()
+}

examples/workqueue/BUILD

@@ -0,0 +1,33 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "workqueue",
+    library = ":go_default_library",
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["main.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/github.com/golang/glog:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/fields:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+        "//vendor/k8s.io/client-go/tools/clientcmd:go_default_library",
+        "//vendor/k8s.io/client-go/util/workqueue:go_default_library",
+    ],
+)

examples/workqueue/README.md

@@ -0,0 +1,17 @@
+# Workqueue Example
+
+This example demonstrates how to write a controller which follows the states
+of watched resources.
+
+It demonstrates how to:
+ * combine the workqueue with a cache to a full controller
+ * synchronize the controller on startup
+
+The example is based on https://git.k8s.io/community/contributors/devel/controllers.md.
+
+## Running
+
+```
+# if outside of the cluster
+go run *.go -kubeconfig=/my/config -logtostderr=true
+```

examples/workqueue/main.go

@@ -0,0 +1,217 @@
+/*
+Copyright 2017 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 main
+
+import (
+	"flag"
+	"fmt"
+	"time"
+
+	"github.com/golang/glog"
+
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/client-go/util/workqueue"
+)
+
+type Controller struct {
+	indexer  cache.Indexer
+	queue    workqueue.RateLimitingInterface
+	informer cache.Controller
+}
+
+func NewController(queue workqueue.RateLimitingInterface, indexer cache.Indexer, informer cache.Controller) *Controller {
+	return &Controller{
+		informer: informer,
+		indexer:  indexer,
+		queue:    queue,
+	}
+}
+
+func (c *Controller) processNextItem() bool {
+	// Wait until there is a new item in the working queue
+	key, quit := c.queue.Get()
+	if quit {
+		return false
+	}
+	// Tell the queue that we are done with processing this key. This unblocks the key for other workers
+	// This allows safe parallel processing because two pods with the same key are never processed in
+	// parallel.
+	defer c.queue.Done(key)
+
+	// Invoke the method containing the business logic
+	err := c.syncToStdout(key.(string))
+	// Handle the error if something went wrong during the execution of the business logic
+	c.handleErr(err, key)
+	return true
+}
+
+// syncToStdout is the business logic of the controller. In this controller it simply prints
+// information about the pod to stdout. In case an error happened, it has to simply return the error.
+// The retry logic should not be part of the business logic.
+func (c *Controller) syncToStdout(key string) error {
+	obj, exists, err := c.indexer.GetByKey(key)
+	if err != nil {
+		glog.Errorf("Fetching object with key %s from store failed with %v", key, err)
+		return err
+	}
+
+	if !exists {
+		// Below we will warm up our cache with a Pod, so that we will see a delete for one pod
+		fmt.Printf("Pod %s does not exist anymore\n", key)
+	} else {
+		// Note that you also have to check the uid if you have a local controlled resource, which
+		// is dependent on the actual instance, to detect that a Pod was recreated with the same name
+		fmt.Printf("Sync/Add/Update for Pod %s\n", obj.(*v1.Pod).GetName())
+	}
+	return nil
+}
+
+// handleErr checks if an error happened and makes sure we will retry later.
+func (c *Controller) handleErr(err error, key interface{}) {
+	if err == nil {
+		// Forget about the #AddRateLimited history of the key on every successful synchronization.
+		// This ensures that future processing of updates for this key is not delayed because of
+		// an outdated error history.
+		c.queue.Forget(key)
+		return
+	}
+
+	// This controller retries 5 times if something goes wrong. After that, it stops trying.
+	if c.queue.NumRequeues(key) < 5 {
+		glog.Infof("Error syncing pod %v: %v", key, err)
+
+		// Re-enqueue the key rate limited. Based on the rate limiter on the
+		// queue and the re-enqueue history, the key will be processed later again.
+		c.queue.AddRateLimited(key)
+		return
+	}
+
+	c.queue.Forget(key)
+	// Report to an external entity that, even after several retries, we could not successfully process this key
+	runtime.HandleError(err)
+	glog.Infof("Dropping pod %q out of the queue: %v", key, err)
+}
+
+func (c *Controller) Run(threadiness int, stopCh chan struct{}) {
+	defer runtime.HandleCrash()
+
+	// Let the workers stop when we are done
+	defer c.queue.ShutDown()
+	glog.Info("Starting Pod controller")
+
+	go c.informer.Run(stopCh)
+
+	// Wait for all involved caches to be synced, before processing items from the queue is started
+	if !cache.WaitForCacheSync(stopCh, c.informer.HasSynced) {
+		runtime.HandleError(fmt.Errorf("Timed out waiting for caches to sync"))
+		return
+	}
+
+	for i := 0; i < threadiness; i++ {
+		go wait.Until(c.runWorker, time.Second, stopCh)
+	}
+
+	<-stopCh
+	glog.Info("Stopping Pod controller")
+}
+
+func (c *Controller) runWorker() {
+	for c.processNextItem() {
+	}
+}
+
+func main() {
+	var kubeconfig string
+	var master string
+
+	flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
+	flag.StringVar(&master, "master", "", "master url")
+	flag.Parse()
+
+	// creates the connection
+	config, err := clientcmd.BuildConfigFromFlags(master, kubeconfig)
+	if err != nil {
+		glog.Fatal(err)
+	}
+
+	// creates the clientset
+	clientset, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		glog.Fatal(err)
+	}
+
+	// create the pod watcher
+	podListWatcher := cache.NewListWatchFromClient(clientset.Core().RESTClient(), "pods", v1.NamespaceDefault, fields.Everything())
+
+	// create the workqueue
+	queue := workqueue.NewRateLimitingQueue(workqueue.DefaultControllerRateLimiter())
+
+	// Bind the workqueue to a cache with the help of an informer. This way we make sure that
+	// whenever the cache is updated, the pod key is added to the workqueue.
+	// Note that when we finally process the item from the workqueue, we might see a newer version
+	// of the Pod than the version which was responsible for triggering the update.
+	indexer, informer := cache.NewIndexerInformer(podListWatcher, &v1.Pod{}, 0, cache.ResourceEventHandlerFuncs{
+		AddFunc: func(obj interface{}) {
+			key, err := cache.MetaNamespaceKeyFunc(obj)
+			if err == nil {
+				queue.Add(key)
+			}
+		},
+		UpdateFunc: func(old interface{}, new interface{}) {
+			key, err := cache.MetaNamespaceKeyFunc(new)
+			if err == nil {
+				queue.Add(key)
+			}
+		},
+		DeleteFunc: func(obj interface{}) {
+			// IndexerInformer uses a delta queue, therefore for deletes we have to use this
+			// key function.
+			key, err := cache.DeletionHandlingMetaNamespaceKeyFunc(obj)
+			if err == nil {
+				queue.Add(key)
+			}
+		},
+	}, cache.Indexers{})
+
+	controller := NewController(queue, indexer, informer)
+
+	// We can now warm up the cache for initial synchronization.
+	// Let's suppose that we knew about a pod "mypod" on our last run, therefore add it to the cache.
+	// If this pod is not there anymore, the controller will be notified about the removal after the
+	// cache has synchronized.
+	indexer.Add(&v1.Pod{
+		ObjectMeta: meta_v1.ObjectMeta{
+			Name:      "mypod",
+			Namespace: v1.NamespaceDefault,
+		},
+	})
+
+	// Now let's start the controller
+	stop := make(chan struct{})
+	defer close(stop)
+	go controller.Run(1, stop)
+
+	// Wait forever
+	select {}
+}

informers/BUILD

@@ -0,0 +1,52 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "factory.go",
+        "generic.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/client-go/informers/admissionregistration:go_default_library",
+        "//vendor/k8s.io/client-go/informers/apps:go_default_library",
+        "//vendor/k8s.io/client-go/informers/autoscaling:go_default_library",
+        "//vendor/k8s.io/client-go/informers/batch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/certificates:go_default_library",
+        "//vendor/k8s.io/client-go/informers/core:go_default_library",
+        "//vendor/k8s.io/client-go/informers/extensions:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/informers/networking:go_default_library",
+        "//vendor/k8s.io/client-go/informers/policy:go_default_library",
+        "//vendor/k8s.io/client-go/informers/rbac:go_default_library",
+        "//vendor/k8s.io/client-go/informers/settings:go_default_library",
+        "//vendor/k8s.io/client-go/informers/storage:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/admissionregistration/v1alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/autoscaling/v2alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/batch/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/batch/v2alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/certificates/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/networking/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/policy/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/rbac/v1alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/rbac/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/settings/v1alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/storage/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/storage/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/admissionregistration/BUILD

@@ -0,0 +1,18 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["interface.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/client-go/informers/admissionregistration/v1alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+    ],
+)

informers/admissionregistration/interface.go

@@ -0,0 +1,44 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package admissionregistration
+
+import (
+	v1alpha1 "k8s.io/client-go/informers/admissionregistration/v1alpha1"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1alpha1 provides access to shared informers for resources in V1alpha1.
+	V1alpha1() v1alpha1.Interface
+}
+
+type group struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &group{f}
+}
+
+// V1alpha1 returns a new v1alpha1.Interface.
+func (g *group) V1alpha1() v1alpha1.Interface {
+	return v1alpha1.New(g.SharedInformerFactory)
+}

informers/admissionregistration/v1alpha1/BUILD

@@ -0,0 +1,28 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "externaladmissionhookconfiguration.go",
+        "initializerconfiguration.go",
+        "interface.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/admissionregistration/v1alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/admissionregistration/v1alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/admissionregistration/v1alpha1/externaladmissionhookconfiguration.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1alpha1
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+	kubernetes "k8s.io/client-go/kubernetes"
+	v1alpha1 "k8s.io/client-go/listers/admissionregistration/v1alpha1"
+	admissionregistration_v1alpha1 "k8s.io/client-go/pkg/apis/admissionregistration/v1alpha1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// ExternalAdmissionHookConfigurationInformer provides access to a shared informer and lister for
+// ExternalAdmissionHookConfigurations.
+type ExternalAdmissionHookConfigurationInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.ExternalAdmissionHookConfigurationLister
+}
+
+type externalAdmissionHookConfigurationInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newExternalAdmissionHookConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.AdmissionregistrationV1alpha1().ExternalAdmissionHookConfigurations().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.AdmissionregistrationV1alpha1().ExternalAdmissionHookConfigurations().Watch(options)
+			},
+		},
+		&admissionregistration_v1alpha1.ExternalAdmissionHookConfiguration{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *externalAdmissionHookConfigurationInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&admissionregistration_v1alpha1.ExternalAdmissionHookConfiguration{}, newExternalAdmissionHookConfigurationInformer)
+}
+
+func (f *externalAdmissionHookConfigurationInformer) Lister() v1alpha1.ExternalAdmissionHookConfigurationLister {
+	return v1alpha1.NewExternalAdmissionHookConfigurationLister(f.Informer().GetIndexer())
+}

informers/admissionregistration/v1alpha1/initializerconfiguration.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1alpha1
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+	kubernetes "k8s.io/client-go/kubernetes"
+	v1alpha1 "k8s.io/client-go/listers/admissionregistration/v1alpha1"
+	admissionregistration_v1alpha1 "k8s.io/client-go/pkg/apis/admissionregistration/v1alpha1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// InitializerConfigurationInformer provides access to a shared informer and lister for
+// InitializerConfigurations.
+type InitializerConfigurationInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.InitializerConfigurationLister
+}
+
+type initializerConfigurationInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newInitializerConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.AdmissionregistrationV1alpha1().InitializerConfigurations().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.AdmissionregistrationV1alpha1().InitializerConfigurations().Watch(options)
+			},
+		},
+		&admissionregistration_v1alpha1.InitializerConfiguration{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *initializerConfigurationInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&admissionregistration_v1alpha1.InitializerConfiguration{}, newInitializerConfigurationInformer)
+}
+
+func (f *initializerConfigurationInformer) Lister() v1alpha1.InitializerConfigurationLister {
+	return v1alpha1.NewInitializerConfigurationLister(f.Informer().GetIndexer())
+}

informers/admissionregistration/v1alpha1/interface.go

@@ -0,0 +1,50 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1alpha1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// ExternalAdmissionHookConfigurations returns a ExternalAdmissionHookConfigurationInformer.
+	ExternalAdmissionHookConfigurations() ExternalAdmissionHookConfigurationInformer
+	// InitializerConfigurations returns a InitializerConfigurationInformer.
+	InitializerConfigurations() InitializerConfigurationInformer
+}
+
+type version struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &version{f}
+}
+
+// ExternalAdmissionHookConfigurations returns a ExternalAdmissionHookConfigurationInformer.
+func (v *version) ExternalAdmissionHookConfigurations() ExternalAdmissionHookConfigurationInformer {
+	return &externalAdmissionHookConfigurationInformer{factory: v.SharedInformerFactory}
+}
+
+// InitializerConfigurations returns a InitializerConfigurationInformer.
+func (v *version) InitializerConfigurations() InitializerConfigurationInformer {
+	return &initializerConfigurationInformer{factory: v.SharedInformerFactory}
+}

informers/apps/BUILD

@@ -0,0 +1,18 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["interface.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/client-go/informers/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+    ],
+)

informers/apps/interface.go

@@ -0,0 +1,44 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package apps
+
+import (
+	v1beta1 "k8s.io/client-go/informers/apps/v1beta1"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1beta1 provides access to shared informers for resources in V1beta1.
+	V1beta1() v1beta1.Interface
+}
+
+type group struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &group{f}
+}
+
+// V1beta1 returns a new v1beta1.Interface.
+func (g *group) V1beta1() v1beta1.Interface {
+	return v1beta1.New(g.SharedInformerFactory)
+}

informers/apps/v1beta1/BUILD

@@ -0,0 +1,29 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "controllerrevision.go",
+        "deployment.go",
+        "interface.go",
+        "statefulset.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/apps/v1beta1/controllerrevision.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1beta1
+
+import (
+	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/apps/v1beta1"
+	apps_v1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// ControllerRevisionInformer provides access to a shared informer and lister for
+// ControllerRevisions.
+type ControllerRevisionInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1beta1.ControllerRevisionLister
+}
+
+type controllerRevisionInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newControllerRevisionInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.AppsV1beta1().ControllerRevisions(v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.AppsV1beta1().ControllerRevisions(v1.NamespaceAll).Watch(options)
+			},
+		},
+		&apps_v1beta1.ControllerRevision{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *controllerRevisionInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&apps_v1beta1.ControllerRevision{}, newControllerRevisionInformer)
+}
+
+func (f *controllerRevisionInformer) Lister() v1beta1.ControllerRevisionLister {
+	return v1beta1.NewControllerRevisionLister(f.Informer().GetIndexer())
+}

informers/apps/v1beta1/deployment.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1beta1
+
+import (
+	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/apps/v1beta1"
+	apps_v1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// DeploymentInformer provides access to a shared informer and lister for
+// Deployments.
+type DeploymentInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1beta1.DeploymentLister
+}
+
+type deploymentInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newDeploymentInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.AppsV1beta1().Deployments(v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.AppsV1beta1().Deployments(v1.NamespaceAll).Watch(options)
+			},
+		},
+		&apps_v1beta1.Deployment{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *deploymentInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&apps_v1beta1.Deployment{}, newDeploymentInformer)
+}
+
+func (f *deploymentInformer) Lister() v1beta1.DeploymentLister {
+	return v1beta1.NewDeploymentLister(f.Informer().GetIndexer())
+}

informers/apps/v1beta1/interface.go

@@ -0,0 +1,57 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1beta1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// ControllerRevisions returns a ControllerRevisionInformer.
+	ControllerRevisions() ControllerRevisionInformer
+	// Deployments returns a DeploymentInformer.
+	Deployments() DeploymentInformer
+	// StatefulSets returns a StatefulSetInformer.
+	StatefulSets() StatefulSetInformer
+}
+
+type version struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &version{f}
+}
+
+// ControllerRevisions returns a ControllerRevisionInformer.
+func (v *version) ControllerRevisions() ControllerRevisionInformer {
+	return &controllerRevisionInformer{factory: v.SharedInformerFactory}
+}
+
+// Deployments returns a DeploymentInformer.
+func (v *version) Deployments() DeploymentInformer {
+	return &deploymentInformer{factory: v.SharedInformerFactory}
+}
+
+// StatefulSets returns a StatefulSetInformer.
+func (v *version) StatefulSets() StatefulSetInformer {
+	return &statefulSetInformer{factory: v.SharedInformerFactory}
+}

informers/apps/v1beta1/statefulset.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1beta1
+
+import (
+	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/apps/v1beta1"
+	apps_v1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// StatefulSetInformer provides access to a shared informer and lister for
+// StatefulSets.
+type StatefulSetInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1beta1.StatefulSetLister
+}
+
+type statefulSetInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newStatefulSetInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.AppsV1beta1().StatefulSets(v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.AppsV1beta1().StatefulSets(v1.NamespaceAll).Watch(options)
+			},
+		},
+		&apps_v1beta1.StatefulSet{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *statefulSetInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&apps_v1beta1.StatefulSet{}, newStatefulSetInformer)
+}
+
+func (f *statefulSetInformer) Lister() v1beta1.StatefulSetLister {
+	return v1beta1.NewStatefulSetLister(f.Informer().GetIndexer())
+}

informers/autoscaling/BUILD

@@ -0,0 +1,19 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["interface.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/client-go/informers/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/autoscaling/v2alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+    ],
+)

informers/autoscaling/interface.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package autoscaling
+
+import (
+	v1 "k8s.io/client-go/informers/autoscaling/v1"
+	v2alpha1 "k8s.io/client-go/informers/autoscaling/v2alpha1"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1 provides access to shared informers for resources in V1.
+	V1() v1.Interface
+	// V2alpha1 provides access to shared informers for resources in V2alpha1.
+	V2alpha1() v2alpha1.Interface
+}
+
+type group struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &group{f}
+}
+
+// V1 returns a new v1.Interface.
+func (g *group) V1() v1.Interface {
+	return v1.New(g.SharedInformerFactory)
+}
+
+// V2alpha1 returns a new v2alpha1.Interface.
+func (g *group) V2alpha1() v2alpha1.Interface {
+	return v2alpha1.New(g.SharedInformerFactory)
+}

informers/autoscaling/v1/BUILD

@@ -0,0 +1,27 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "horizontalpodautoscaler.go",
+        "interface.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/autoscaling/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/autoscaling/v1/horizontalpodautoscaler.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/autoscaling/v1"
+	autoscaling_v1 "k8s.io/client-go/pkg/apis/autoscaling/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// HorizontalPodAutoscalerInformer provides access to a shared informer and lister for
+// HorizontalPodAutoscalers.
+type HorizontalPodAutoscalerInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.HorizontalPodAutoscalerLister
+}
+
+type horizontalPodAutoscalerInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newHorizontalPodAutoscalerInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.AutoscalingV1().HorizontalPodAutoscalers(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.AutoscalingV1().HorizontalPodAutoscalers(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&autoscaling_v1.HorizontalPodAutoscaler{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *horizontalPodAutoscalerInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&autoscaling_v1.HorizontalPodAutoscaler{}, newHorizontalPodAutoscalerInformer)
+}
+
+func (f *horizontalPodAutoscalerInformer) Lister() v1.HorizontalPodAutoscalerLister {
+	return v1.NewHorizontalPodAutoscalerLister(f.Informer().GetIndexer())
+}

informers/autoscaling/v1/interface.go

@@ -0,0 +1,43 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
+	HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer
+}
+
+type version struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &version{f}
+}
+
+// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
+func (v *version) HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer {
+	return &horizontalPodAutoscalerInformer{factory: v.SharedInformerFactory}
+}

informers/autoscaling/v2alpha1/BUILD

@@ -0,0 +1,27 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "horizontalpodautoscaler.go",
+        "interface.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/autoscaling/v2alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/autoscaling/v2alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/autoscaling/v2alpha1/horizontalpodautoscaler.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v2alpha1
+
+import (
+	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"
+	v2alpha1 "k8s.io/client-go/listers/autoscaling/v2alpha1"
+	autoscaling_v2alpha1 "k8s.io/client-go/pkg/apis/autoscaling/v2alpha1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// HorizontalPodAutoscalerInformer provides access to a shared informer and lister for
+// HorizontalPodAutoscalers.
+type HorizontalPodAutoscalerInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v2alpha1.HorizontalPodAutoscalerLister
+}
+
+type horizontalPodAutoscalerInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newHorizontalPodAutoscalerInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.AutoscalingV2alpha1().HorizontalPodAutoscalers(v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.AutoscalingV2alpha1().HorizontalPodAutoscalers(v1.NamespaceAll).Watch(options)
+			},
+		},
+		&autoscaling_v2alpha1.HorizontalPodAutoscaler{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *horizontalPodAutoscalerInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&autoscaling_v2alpha1.HorizontalPodAutoscaler{}, newHorizontalPodAutoscalerInformer)
+}
+
+func (f *horizontalPodAutoscalerInformer) Lister() v2alpha1.HorizontalPodAutoscalerLister {
+	return v2alpha1.NewHorizontalPodAutoscalerLister(f.Informer().GetIndexer())
+}

informers/autoscaling/v2alpha1/interface.go

@@ -0,0 +1,43 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v2alpha1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
+	HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer
+}
+
+type version struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &version{f}
+}
+
+// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
+func (v *version) HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer {
+	return &horizontalPodAutoscalerInformer{factory: v.SharedInformerFactory}
+}

informers/batch/BUILD

@@ -0,0 +1,19 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["interface.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/client-go/informers/batch/v1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/batch/v2alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+    ],
+)

informers/batch/interface.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package batch
+
+import (
+	v1 "k8s.io/client-go/informers/batch/v1"
+	v2alpha1 "k8s.io/client-go/informers/batch/v2alpha1"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1 provides access to shared informers for resources in V1.
+	V1() v1.Interface
+	// V2alpha1 provides access to shared informers for resources in V2alpha1.
+	V2alpha1() v2alpha1.Interface
+}
+
+type group struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &group{f}
+}
+
+// V1 returns a new v1.Interface.
+func (g *group) V1() v1.Interface {
+	return v1.New(g.SharedInformerFactory)
+}
+
+// V2alpha1 returns a new v2alpha1.Interface.
+func (g *group) V2alpha1() v2alpha1.Interface {
+	return v2alpha1.New(g.SharedInformerFactory)
+}

informers/batch/v1/BUILD

@@ -0,0 +1,27 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "interface.go",
+        "job.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/batch/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/batch/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/batch/v1/interface.go

@@ -0,0 +1,43 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// Jobs returns a JobInformer.
+	Jobs() JobInformer
+}
+
+type version struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &version{f}
+}
+
+// Jobs returns a JobInformer.
+func (v *version) Jobs() JobInformer {
+	return &jobInformer{factory: v.SharedInformerFactory}
+}

informers/batch/v1/job.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/batch/v1"
+	batch_v1 "k8s.io/client-go/pkg/apis/batch/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// JobInformer provides access to a shared informer and lister for
+// Jobs.
+type JobInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.JobLister
+}
+
+type jobInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newJobInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.BatchV1().Jobs(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.BatchV1().Jobs(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&batch_v1.Job{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *jobInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&batch_v1.Job{}, newJobInformer)
+}
+
+func (f *jobInformer) Lister() v1.JobLister {
+	return v1.NewJobLister(f.Informer().GetIndexer())
+}

informers/batch/v2alpha1/BUILD

@@ -0,0 +1,27 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cronjob.go",
+        "interface.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/batch/v2alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/batch/v2alpha1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/batch/v2alpha1/cronjob.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v2alpha1
+
+import (
+	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"
+	v2alpha1 "k8s.io/client-go/listers/batch/v2alpha1"
+	batch_v2alpha1 "k8s.io/client-go/pkg/apis/batch/v2alpha1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// CronJobInformer provides access to a shared informer and lister for
+// CronJobs.
+type CronJobInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v2alpha1.CronJobLister
+}
+
+type cronJobInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newCronJobInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.BatchV2alpha1().CronJobs(v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.BatchV2alpha1().CronJobs(v1.NamespaceAll).Watch(options)
+			},
+		},
+		&batch_v2alpha1.CronJob{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *cronJobInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&batch_v2alpha1.CronJob{}, newCronJobInformer)
+}
+
+func (f *cronJobInformer) Lister() v2alpha1.CronJobLister {
+	return v2alpha1.NewCronJobLister(f.Informer().GetIndexer())
+}

informers/batch/v2alpha1/interface.go

@@ -0,0 +1,43 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v2alpha1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// CronJobs returns a CronJobInformer.
+	CronJobs() CronJobInformer
+}
+
+type version struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &version{f}
+}
+
+// CronJobs returns a CronJobInformer.
+func (v *version) CronJobs() CronJobInformer {
+	return &cronJobInformer{factory: v.SharedInformerFactory}
+}

informers/certificates/BUILD

@@ -0,0 +1,18 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["interface.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/client-go/informers/certificates/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+    ],
+)

informers/certificates/interface.go

@@ -0,0 +1,44 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package certificates
+
+import (
+	v1beta1 "k8s.io/client-go/informers/certificates/v1beta1"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1beta1 provides access to shared informers for resources in V1beta1.
+	V1beta1() v1beta1.Interface
+}
+
+type group struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &group{f}
+}
+
+// V1beta1 returns a new v1beta1.Interface.
+func (g *group) V1beta1() v1beta1.Interface {
+	return v1beta1.New(g.SharedInformerFactory)
+}

informers/certificates/v1beta1/BUILD

@@ -0,0 +1,27 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "certificatesigningrequest.go",
+        "interface.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/certificates/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/apis/certificates/v1beta1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/certificates/v1beta1/certificatesigningrequest.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1beta1
+
+import (
+	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/certificates/v1beta1"
+	certificates_v1beta1 "k8s.io/client-go/pkg/apis/certificates/v1beta1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// CertificateSigningRequestInformer provides access to a shared informer and lister for
+// CertificateSigningRequests.
+type CertificateSigningRequestInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1beta1.CertificateSigningRequestLister
+}
+
+type certificateSigningRequestInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newCertificateSigningRequestInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				return client.CertificatesV1beta1().CertificateSigningRequests().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				return client.CertificatesV1beta1().CertificateSigningRequests().Watch(options)
+			},
+		},
+		&certificates_v1beta1.CertificateSigningRequest{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *certificateSigningRequestInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&certificates_v1beta1.CertificateSigningRequest{}, newCertificateSigningRequestInformer)
+}
+
+func (f *certificateSigningRequestInformer) Lister() v1beta1.CertificateSigningRequestLister {
+	return v1beta1.NewCertificateSigningRequestLister(f.Informer().GetIndexer())
+}

informers/certificates/v1beta1/interface.go

@@ -0,0 +1,43 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1beta1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// CertificateSigningRequests returns a CertificateSigningRequestInformer.
+	CertificateSigningRequests() CertificateSigningRequestInformer
+}
+
+type version struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &version{f}
+}
+
+// CertificateSigningRequests returns a CertificateSigningRequestInformer.
+func (v *version) CertificateSigningRequests() CertificateSigningRequestInformer {
+	return &certificateSigningRequestInformer{factory: v.SharedInformerFactory}
+}

informers/core/BUILD

@@ -0,0 +1,18 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["interface.go"],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/client-go/informers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+    ],
+)

informers/core/interface.go

@@ -0,0 +1,44 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package core
+
+import (
+	v1 "k8s.io/client-go/informers/core/v1"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1 provides access to shared informers for resources in V1.
+	V1() v1.Interface
+}
+
+type group struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &group{f}
+}
+
+// V1 returns a new v1.Interface.
+func (g *group) V1() v1.Interface {
+	return v1.New(g.SharedInformerFactory)
+}

informers/core/v1/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "componentstatus.go",
+        "configmap.go",
+        "endpoints.go",
+        "event.go",
+        "interface.go",
+        "limitrange.go",
+        "namespace.go",
+        "node.go",
+        "persistentvolume.go",
+        "persistentvolumeclaim.go",
+        "pod.go",
+        "podtemplate.go",
+        "replicationcontroller.go",
+        "resourcequota.go",
+        "secret.go",
+        "service.go",
+        "serviceaccount.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/informers/internalinterfaces:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
+        "//vendor/k8s.io/client-go/listers/core/v1:go_default_library",
+        "//vendor/k8s.io/client-go/pkg/api/v1:go_default_library",
+        "//vendor/k8s.io/client-go/tools/cache:go_default_library",
+    ],
+)

informers/core/v1/componentstatus.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// ComponentStatusInformer provides access to a shared informer and lister for
+// ComponentStatuses.
+type ComponentStatusInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.ComponentStatusLister
+}
+
+type componentStatusInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newComponentStatusInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().ComponentStatuses().List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().ComponentStatuses().Watch(options)
+			},
+		},
+		&api_v1.ComponentStatus{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *componentStatusInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.ComponentStatus{}, newComponentStatusInformer)
+}
+
+func (f *componentStatusInformer) Lister() v1.ComponentStatusLister {
+	return v1.NewComponentStatusLister(f.Informer().GetIndexer())
+}

informers/core/v1/configmap.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// ConfigMapInformer provides access to a shared informer and lister for
+// ConfigMaps.
+type ConfigMapInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.ConfigMapLister
+}
+
+type configMapInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newConfigMapInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().ConfigMaps(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().ConfigMaps(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&api_v1.ConfigMap{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *configMapInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.ConfigMap{}, newConfigMapInformer)
+}
+
+func (f *configMapInformer) Lister() v1.ConfigMapLister {
+	return v1.NewConfigMapLister(f.Informer().GetIndexer())
+}

informers/core/v1/endpoints.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// EndpointsInformer provides access to a shared informer and lister for
+// Endpoints.
+type EndpointsInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.EndpointsLister
+}
+
+type endpointsInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newEndpointsInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().Endpoints(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().Endpoints(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&api_v1.Endpoints{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *endpointsInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.Endpoints{}, newEndpointsInformer)
+}
+
+func (f *endpointsInformer) Lister() v1.EndpointsLister {
+	return v1.NewEndpointsLister(f.Informer().GetIndexer())
+}

informers/core/v1/event.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// EventInformer provides access to a shared informer and lister for
+// Events.
+type EventInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.EventLister
+}
+
+type eventInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newEventInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().Events(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().Events(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&api_v1.Event{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *eventInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.Event{}, newEventInformer)
+}
+
+func (f *eventInformer) Lister() v1.EventLister {
+	return v1.NewEventLister(f.Informer().GetIndexer())
+}

informers/core/v1/interface.go

@@ -0,0 +1,148 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// ComponentStatuses returns a ComponentStatusInformer.
+	ComponentStatuses() ComponentStatusInformer
+	// ConfigMaps returns a ConfigMapInformer.
+	ConfigMaps() ConfigMapInformer
+	// Endpoints returns a EndpointsInformer.
+	Endpoints() EndpointsInformer
+	// Events returns a EventInformer.
+	Events() EventInformer
+	// LimitRanges returns a LimitRangeInformer.
+	LimitRanges() LimitRangeInformer
+	// Namespaces returns a NamespaceInformer.
+	Namespaces() NamespaceInformer
+	// Nodes returns a NodeInformer.
+	Nodes() NodeInformer
+	// PersistentVolumes returns a PersistentVolumeInformer.
+	PersistentVolumes() PersistentVolumeInformer
+	// PersistentVolumeClaims returns a PersistentVolumeClaimInformer.
+	PersistentVolumeClaims() PersistentVolumeClaimInformer
+	// Pods returns a PodInformer.
+	Pods() PodInformer
+	// PodTemplates returns a PodTemplateInformer.
+	PodTemplates() PodTemplateInformer
+	// ReplicationControllers returns a ReplicationControllerInformer.
+	ReplicationControllers() ReplicationControllerInformer
+	// ResourceQuotas returns a ResourceQuotaInformer.
+	ResourceQuotas() ResourceQuotaInformer
+	// Secrets returns a SecretInformer.
+	Secrets() SecretInformer
+	// Services returns a ServiceInformer.
+	Services() ServiceInformer
+	// ServiceAccounts returns a ServiceAccountInformer.
+	ServiceAccounts() ServiceAccountInformer
+}
+
+type version struct {
+	internalinterfaces.SharedInformerFactory
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory) Interface {
+	return &version{f}
+}
+
+// ComponentStatuses returns a ComponentStatusInformer.
+func (v *version) ComponentStatuses() ComponentStatusInformer {
+	return &componentStatusInformer{factory: v.SharedInformerFactory}
+}
+
+// ConfigMaps returns a ConfigMapInformer.
+func (v *version) ConfigMaps() ConfigMapInformer {
+	return &configMapInformer{factory: v.SharedInformerFactory}
+}
+
+// Endpoints returns a EndpointsInformer.
+func (v *version) Endpoints() EndpointsInformer {
+	return &endpointsInformer{factory: v.SharedInformerFactory}
+}
+
+// Events returns a EventInformer.
+func (v *version) Events() EventInformer {
+	return &eventInformer{factory: v.SharedInformerFactory}
+}
+
+// LimitRanges returns a LimitRangeInformer.
+func (v *version) LimitRanges() LimitRangeInformer {
+	return &limitRangeInformer{factory: v.SharedInformerFactory}
+}
+
+// Namespaces returns a NamespaceInformer.
+func (v *version) Namespaces() NamespaceInformer {
+	return &namespaceInformer{factory: v.SharedInformerFactory}
+}
+
+// Nodes returns a NodeInformer.
+func (v *version) Nodes() NodeInformer {
+	return &nodeInformer{factory: v.SharedInformerFactory}
+}
+
+// PersistentVolumes returns a PersistentVolumeInformer.
+func (v *version) PersistentVolumes() PersistentVolumeInformer {
+	return &persistentVolumeInformer{factory: v.SharedInformerFactory}
+}
+
+// PersistentVolumeClaims returns a PersistentVolumeClaimInformer.
+func (v *version) PersistentVolumeClaims() PersistentVolumeClaimInformer {
+	return &persistentVolumeClaimInformer{factory: v.SharedInformerFactory}
+}
+
+// Pods returns a PodInformer.
+func (v *version) Pods() PodInformer {
+	return &podInformer{factory: v.SharedInformerFactory}
+}
+
+// PodTemplates returns a PodTemplateInformer.
+func (v *version) PodTemplates() PodTemplateInformer {
+	return &podTemplateInformer{factory: v.SharedInformerFactory}
+}
+
+// ReplicationControllers returns a ReplicationControllerInformer.
+func (v *version) ReplicationControllers() ReplicationControllerInformer {
+	return &replicationControllerInformer{factory: v.SharedInformerFactory}
+}
+
+// ResourceQuotas returns a ResourceQuotaInformer.
+func (v *version) ResourceQuotas() ResourceQuotaInformer {
+	return &resourceQuotaInformer{factory: v.SharedInformerFactory}
+}
+
+// Secrets returns a SecretInformer.
+func (v *version) Secrets() SecretInformer {
+	return &secretInformer{factory: v.SharedInformerFactory}
+}
+
+// Services returns a ServiceInformer.
+func (v *version) Services() ServiceInformer {
+	return &serviceInformer{factory: v.SharedInformerFactory}
+}
+
+// ServiceAccounts returns a ServiceAccountInformer.
+func (v *version) ServiceAccounts() ServiceAccountInformer {
+	return &serviceAccountInformer{factory: v.SharedInformerFactory}
+}

informers/core/v1/limitrange.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// LimitRangeInformer provides access to a shared informer and lister for
+// LimitRanges.
+type LimitRangeInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.LimitRangeLister
+}
+
+type limitRangeInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newLimitRangeInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().LimitRanges(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().LimitRanges(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&api_v1.LimitRange{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *limitRangeInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.LimitRange{}, newLimitRangeInformer)
+}
+
+func (f *limitRangeInformer) Lister() v1.LimitRangeLister {
+	return v1.NewLimitRangeLister(f.Informer().GetIndexer())
+}

informers/core/v1/namespace.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// NamespaceInformer provides access to a shared informer and lister for
+// Namespaces.
+type NamespaceInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.NamespaceLister
+}
+
+type namespaceInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newNamespaceInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().Namespaces().List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().Namespaces().Watch(options)
+			},
+		},
+		&api_v1.Namespace{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *namespaceInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.Namespace{}, newNamespaceInformer)
+}
+
+func (f *namespaceInformer) Lister() v1.NamespaceLister {
+	return v1.NewNamespaceLister(f.Informer().GetIndexer())
+}

informers/core/v1/node.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// NodeInformer provides access to a shared informer and lister for
+// Nodes.
+type NodeInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.NodeLister
+}
+
+type nodeInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newNodeInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().Nodes().List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().Nodes().Watch(options)
+			},
+		},
+		&api_v1.Node{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *nodeInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.Node{}, newNodeInformer)
+}
+
+func (f *nodeInformer) Lister() v1.NodeLister {
+	return v1.NewNodeLister(f.Informer().GetIndexer())
+}

informers/core/v1/persistentvolume.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// PersistentVolumeInformer provides access to a shared informer and lister for
+// PersistentVolumes.
+type PersistentVolumeInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.PersistentVolumeLister
+}
+
+type persistentVolumeInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newPersistentVolumeInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().PersistentVolumes().List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().PersistentVolumes().Watch(options)
+			},
+		},
+		&api_v1.PersistentVolume{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *persistentVolumeInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.PersistentVolume{}, newPersistentVolumeInformer)
+}
+
+func (f *persistentVolumeInformer) Lister() v1.PersistentVolumeLister {
+	return v1.NewPersistentVolumeLister(f.Informer().GetIndexer())
+}

informers/core/v1/persistentvolumeclaim.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// PersistentVolumeClaimInformer provides access to a shared informer and lister for
+// PersistentVolumeClaims.
+type PersistentVolumeClaimInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.PersistentVolumeClaimLister
+}
+
+type persistentVolumeClaimInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newPersistentVolumeClaimInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().PersistentVolumeClaims(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().PersistentVolumeClaims(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&api_v1.PersistentVolumeClaim{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *persistentVolumeClaimInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.PersistentVolumeClaim{}, newPersistentVolumeClaimInformer)
+}
+
+func (f *persistentVolumeClaimInformer) Lister() v1.PersistentVolumeClaimLister {
+	return v1.NewPersistentVolumeClaimLister(f.Informer().GetIndexer())
+}

informers/core/v1/pod.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// PodInformer provides access to a shared informer and lister for
+// Pods.
+type PodInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.PodLister
+}
+
+type podInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newPodInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().Pods(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().Pods(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&api_v1.Pod{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *podInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.Pod{}, newPodInformer)
+}
+
+func (f *podInformer) Lister() v1.PodLister {
+	return v1.NewPodLister(f.Informer().GetIndexer())
+}

informers/core/v1/podtemplate.go

@@ -0,0 +1,68 @@
+/*
+Copyright 2017 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.
+*/
+
+// This file was automatically generated by informer-gen
+
+package v1
+
+import (
+	meta_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"
+	v1 "k8s.io/client-go/listers/core/v1"
+	api_v1 "k8s.io/client-go/pkg/api/v1"
+	cache "k8s.io/client-go/tools/cache"
+	time "time"
+)
+
+// PodTemplateInformer provides access to a shared informer and lister for
+// PodTemplates.
+type PodTemplateInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1.PodTemplateLister
+}
+
+type podTemplateInformer struct {
+	factory internalinterfaces.SharedInformerFactory
+}
+
+func newPodTemplateInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	sharedIndexInformer := cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
+				return client.CoreV1().PodTemplates(meta_v1.NamespaceAll).List(options)
+			},
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
+				return client.CoreV1().PodTemplates(meta_v1.NamespaceAll).Watch(options)
+			},
+		},
+		&api_v1.PodTemplate{},
+		resyncPeriod,
+		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
+	)
+
+	return sharedIndexInformer
+}
+
+func (f *podTemplateInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&api_v1.PodTemplate{}, newPodTemplateInformer)
+}
+
+func (f *podTemplateInformer) Lister() v1.PodTemplateLister {
+	return v1.NewPodTemplateLister(f.Informer().GetIndexer())
+}