Fix Godeps.json to point to kubernetes-1.12.2-beta.0 tags

Kubernetes-commit: 4e599c848401470c3c10eb52252c5e3bb5463d3b

.travis.yml

@@ -3,8 +3,6 @@ language: go
 go_import_path: k8s.io/client-go
 
 go:
-  - 1.11.1
+  - 1.10.2
 
-script:
-  - if [ "$TRAVIS_BRANCH" != "master" ]; then godep restore; fi
-  - go build ./...
+script: go build ./...

CHANGELOG.md

@@ -5,187 +5,6 @@ https://github.com/kubernetes/test-infra/issues/5843.
 Changes in `k8s.io/api` and `k8s.io/apimachinery` are mentioned here
 because `k8s.io/client-go` depends on them.
 
-# v9.0.0
-
-**Breaking Changes:**
-
-* client-go now supports additional non-alpha-numeric characters in UserInfo
-"extra" data keys. It should be updated in order to properly support extra
-data containing "/" characters or other characters disallowed in HTTP headers.
-Old clients sending keys which were `%`-escaped by the user will have their
-values unescaped by new API servers.
-([#65799](https://github.com/kubernetes/kubernetes/pull/65799))
-
-* `apimachinery/pkg/watch.Until` has been moved to
-`client-go/tools/watch.UntilWithoutRetry`. While switching please consider
-using the new `client-go/tools/watch.UntilWithSync` or `client-go/tools/watch.Until`.
-([#66906](https://github.com/kubernetes/kubernetes/pull/66906))
-
-* [k8s.io/apimachinery] `Unstructured` metadata accessors now respect omitempty semantics
-i.e. a field having zero value will now be removed from the unstructured metadata map.
-([#67635](https://github.com/kubernetes/kubernetes/pull/67635))
-
-* [k8s.io/apimachinery] The `ObjectConvertor` interface is now changed such that
-`ConvertFieldLabel` func takes GroupVersionKind as an argument instead of just
-version and kind. ([#65780](https://github.com/kubernetes/kubernetes/pull/65780))
-
-* [k8s.io/apimachinery] componentconfig `ClientConnectionConfiguration` is
-moved to `k8s.io/apimachinery/pkg/apis/config`.
-([#66058](https://github.com/kubernetes/kubernetes/pull/66058))
-
-* [k8s.io/apimachinery] Renamed ` KubeConfigFile` to `Kubeconfig` in
-`ClientConnectionConfiguration`.
-([#67149](https://github.com/kubernetes/kubernetes/pull/67149))
-
-* [k8s.io/apimachinery] JSON patch no longer supports `int`.
-([#63522](https://github.com/kubernetes/kubernetes/pull/63522))
-
-**New Features:**
-
-* Add ability to cancel leader election.
-This also proves useful in integration tests where the whole app is started and
-stopped in each test. ([#57932](https://github.com/kubernetes/kubernetes/pull/57932))
-
-* An example showing how to use fake clients in tests is added.
-([#65291](https://github.com/kubernetes/kubernetes/pull/65291))
-
-* [k8s.io/apimachinery] Create and Update now support `CreateOptions` and `UpdateOptions`.
-([#65105](https://github.com/kubernetes/kubernetes/pull/65105))
-
-**Bug fixes and Improvements:**
-
-* Decrease the amount of time it takes to modify kubeconfig
-files with large amounts of contexts.
-([#67093](https://github.com/kubernetes/kubernetes/pull/67093))
-
-* The leader election client now renews timeout.
-([#65094](https://github.com/kubernetes/kubernetes/pull/65094))
-
-* Switched certificate data replacement from `REDACTED` to `DATA+OMITTED`.
-([#66023](https://github.com/kubernetes/kubernetes/pull/66023))
-
-* Fix listing in the fake dynamic client.
-([#66078](https://github.com/kubernetes/kubernetes/pull/66078))
-
-* Fix discovery so that plural names are no longer ignored if a singular name is not specified.
-([#66249](https://github.com/kubernetes/kubernetes/pull/66249))
-
-* Fix kubelet startup failure when using `ExecPlugin` in kubeconfig.
-([#66395](https://github.com/kubernetes/kubernetes/pull/66395))
-
-* Fix panic in the fake `SubjectAccessReview` client when object is nil.
-([#66837](https://github.com/kubernetes/kubernetes/pull/66837))
-
-* Periodically reload `InClusterConfig` token.
-([#67359](https://github.com/kubernetes/kubernetes/pull/67359))
-
-* [k8s.io/apimachinery] Report parsing error in json serializer.
-([#63668](https://github.com/kubernetes/kubernetes/pull/63668))
-
-* [k8s.io/apimachinery] The `metav1.ObjectMeta` accessor does not deepcopy
-owner references anymore. In general, the accessor interface does not enforce
-deepcopy nor does it forbid it (e.g. for `unstructured.Unstructured`).
-([#64915](https://github.com/kubernetes/kubernetes/pull/64915))
-
-* [k8s.io/apimachinery] Utility functions `SetTransportDefaults` and `DialerFor`
-once again respect custom Dial functions set on transports.
-([#65547](https://github.com/kubernetes/kubernetes/pull/65547))
-
-* [k8s.io/apimachinery] Speed-up conversion function invocation by avoiding
-`reflect.Call`. Action required: regenerated conversion with conversion-gen.
-([#65771](https://github.com/kubernetes/kubernetes/pull/65771))
-
-* [k8s.io/apimachinery] Establish "406 Not Acceptable" response for
-unmarshable protobuf serialization error.
-([#67041](https://github.com/kubernetes/kubernetes/pull/67041))
-
-* [k8s.io/apimachinery] Immediately close the other side of the connection by
-exiting once one side closes when proxying.
-([#67288](https://github.com/kubernetes/kubernetes/pull/67288))
-
-
-## API changes
-
-**Breaking Changes:**
-
-* Volume dynamic provisioning scheduling has been promoted to beta.
-ACTION REQUIRED: The DynamicProvisioningScheduling alpha feature gate has been removed.
-The VolumeScheduling beta feature gate is still required for this feature.
-([#67432](https://github.com/kubernetes/kubernetes/pull/67432))
-
-* The CSI file system type is no longer defaulted to ext4.
-All the production drivers listed under https://kubernetes-csi.github.io/docs/Drivers.html
-were inspected and should not be impacted after this change.
-If you are using a driver not in that list,
-please test the drivers on an updated test cluster first.
-([#65499](https://github.com/kubernetes/kubernetes/pull/65499))
-
-**New Features:**
-
-* Support annotations for remote admission webhooks.
-([#58679](https://github.com/kubernetes/kubernetes/pull/58679))
-
-* Support both directory and block device for local volume
-plugin `FileSystem` `VolumeMode`.
-([#63011](https://github.com/kubernetes/kubernetes/pull/63011))
-
-* Introduce `autoscaling/v2beta2` and `custom_metrics/v1beta2`,
-which implement metric selectors for Object and Pods metrics,
-as well as allowing AverageValue targets on Objects, similar to External metrics.
-([#64097](https://github.com/kubernetes/kubernetes/pull/64097))
-
-*  Add `Lease` API in the `coordination.k8s.io` API group.
-([#64246](https://github.com/kubernetes/kubernetes/pull/64246))
-
-* `ProcMount` added to `SecurityContext` and `AllowedProcMounts` added to `PodSecurityPolicy`
-to allow paths in the container's `/proc` to not be masked.
-([#64283](https://github.com/kubernetes/kubernetes/pull/64283))
-
-* Add the `AuditAnnotations` field to `ImageReviewStatus` to allow the
-`ImageReview` backend to return annotations to be added to the created pod.
-([#64597](https://github.com/kubernetes/kubernetes/pull/64597))
-
-* SCTP is now supported as additional protocol (alpha) alongside TCP and UDP in
-Pod, Service, Endpoint, and NetworkPolicy.
-([#64973](https://github.com/kubernetes/kubernetes/pull/64973))
-
-* The `PodShareProcessNamespace` feature to configure PID namespace sharing
-within a pod has been promoted to beta.
-([#66507](https://github.com/kubernetes/kubernetes/pull/66507))
-
-* Add `TTLSecondsAfterFinished` to `JobSpec` for cleaning up Jobs after they finish.
-([#66840](https://github.com/kubernetes/kubernetes/pull/66840))
-
-* Add `DataSource` and `TypedLocalObjectReference` fields to support
-restoring a volume from a volume snapshot data source.
-([#67087](https://github.com/kubernetes/kubernetes/pull/67087))
-
-* `RuntimeClass` is a new API resource for defining different classes of runtimes
-that may be used to run containers in the cluster.
-Pods can select a `RunitmeClass` to use via the `RuntimeClassName` field.
-This feature is in alpha, and the `RuntimeClass` feature gate must be enabled
-in order to use it. ([#67737](https://github.com/kubernetes/kubernetes/pull/67737))
-
-* To address the possibility dry-run requests overwhelming admission webhooks
-that rely on side effects and a reconciliation mechanism, a new field is being
-added to `admissionregistration.k8s.io/v1beta1.ValidatingWebhookConfiguration`
-and `admissionregistration.k8s.io/v1beta1.MutatingWebhookConfiguration` so that
-webhooks can explicitly register as having dry-run support.
-If a dry-run request is made on a resource that triggers a non dry-run supporting
-webhook, the request will be completely rejected, with "400: Bad Request".
-Additionally, a new field is being added to the
-`admission.k8s.io/v1beta1.AdmissionReview` API object, exposing to webhooks
-whether or not the request being reviewed is a dry-run.
-([#66936](https://github.com/kubernetes/kubernetes/pull/66936))
-
-**Bug fixes and Improvements:**
-
-* The `DisruptedPods` field in `PodDisruptionBudgetStatus` is now optional.
-([#63757](https://github.com/kubernetes/kubernetes/pull/63757))
-
-* `extensions/v1beta1` Deployment's `ProgressDeadlineSeconds` now defaults to `MaxInt32`.
-([#66581](https://github.com/kubernetes/kubernetes/pull/66581))
-
 # v8.0.0
 
 **Breaking Changes:**

Godeps/Godeps.json

@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/client-go",
-	"GoVersion": "go1.11",
+	"GoVersion": "go1.10",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -16,27 +16,23 @@
 		},
 		{
 			"ImportPath": "github.com/Azure/go-autorest/autorest",
-			"Rev": "a88c19ef2016e095f0b6c3b451074b4663f53bed"
+			"Rev": "bca49d5b51a50dc5bb17bbf6204c711c6dbded06"
 		},
 		{
 			"ImportPath": "github.com/Azure/go-autorest/autorest/adal",
-			"Rev": "a88c19ef2016e095f0b6c3b451074b4663f53bed"
+			"Rev": "bca49d5b51a50dc5bb17bbf6204c711c6dbded06"
 		},
 		{
 			"ImportPath": "github.com/Azure/go-autorest/autorest/azure",
-			"Rev": "a88c19ef2016e095f0b6c3b451074b4663f53bed"
+			"Rev": "bca49d5b51a50dc5bb17bbf6204c711c6dbded06"
 		},
 		{
 			"ImportPath": "github.com/Azure/go-autorest/autorest/date",
-			"Rev": "a88c19ef2016e095f0b6c3b451074b4663f53bed"
-		},
-		{
-			"ImportPath": "github.com/Azure/go-autorest/logger",
-			"Rev": "a88c19ef2016e095f0b6c3b451074b4663f53bed"
+			"Rev": "bca49d5b51a50dc5bb17bbf6204c711c6dbded06"
 		},
 		{
 			"ImportPath": "github.com/Azure/go-autorest/version",
-			"Rev": "a88c19ef2016e095f0b6c3b451074b4663f53bed"
+			"Rev": "bca49d5b51a50dc5bb17bbf6204c711c6dbded06"
 		},
 		{
 			"ImportPath": "github.com/davecgh/go-spew/spew",
@@ -54,21 +50,17 @@
 			"ImportPath": "github.com/docker/spdystream/spdy",
 			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
 		},
-		{
-			"ImportPath": "github.com/evanphx/json-patch",
-			"Rev": "36442dbdb585210f8d5a1b45e67aa323c197d5c4"
-		},
 		{
 			"ImportPath": "github.com/ghodss/yaml",
-			"Rev": "c7ce16629ff4cd059ed96ed06419dd3856fd3577"
+			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/proto",
-			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
 		},
 		{
 			"ImportPath": "github.com/gogo/protobuf/sortkeys",
-			"Rev": "342cbe0a04158f6dcb03ca0079991a51a4248c02"
+			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
@@ -176,7 +168,7 @@
 		},
 		{
 			"ImportPath": "github.com/modern-go/reflect2",
-			"Rev": "94122c33edd36123c84d5368cfb2b69df93a0ec8"
+			"Rev": "05fbef0ca5da472bbf96c9322b84a53edc03c9fd"
 		},
 		{
 			"ImportPath": "github.com/peterbourgon/diskv",
@@ -276,343 +268,339 @@
 		},
 		{
 			"ImportPath": "gopkg.in/yaml.v2",
-			"Rev": "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+			"Rev": "670d4cfef0544295bc27a114dbac37980d83185a"
 		},
 		{
 			"ImportPath": "k8s.io/api/admissionregistration/v1alpha1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/admissionregistration/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1beta2",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
-		},
-		{
-			"ImportPath": "k8s.io/api/auditregistration/v1alpha1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/authentication/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/authentication/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/authorization/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/authorization/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/autoscaling/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/autoscaling/v2beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/autoscaling/v2beta2",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v2alpha1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/certificates/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/coordination/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/core/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/events/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/extensions/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/imagepolicy/v1alpha1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/networking/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/policy/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1alpha1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/scheduling/v1alpha1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/scheduling/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/settings/v1alpha1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1alpha1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1beta1",
-			"Rev": "f85f583258bb22a478ae8c22f8443a860f6e185f"
+			"Rev": "9cba0c11325e2c55211139d8b0b8ab343db0612a"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/apitesting",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/apitesting/fuzzer",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/apitesting/roundtrip",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/equality",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/errors",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/meta",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/resource",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/fuzzer",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/internalversion",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1beta1",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/conversion",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/fields",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/labels",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/schema",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/selection",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/types",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/cache",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/clock",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/diff",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/errors",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/framer",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream/spdy",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/intstr",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/json",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/naming",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/net",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/remotecommand",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/runtime",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/sets",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/validation",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/validation/field",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/wait",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/yaml",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/version",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/watch",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/netutil",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect",
-			"Rev": "55821619f83efe2281fc86e530b472bdbc8afa3e"
+			"Rev": "6dd46049f39503a1fc8d65de4bd566829e95faff"
 		},
 		{
 			"ImportPath": "k8s.io/kube-openapi/pkg/util/proto",

README.md

@@ -2,7 +2,7 @@
 
 Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.
 
-We currently recommend using the v9.0.0 tag. See [INSTALL.md](/INSTALL.md) for
+We currently recommend using the v8.0.0 tag. See [INSTALL.md](/INSTALL.md) for
 detailed installation instructions. `go get k8s.io/client-go/...` works, but
 will build `master`, which doesn't handle the dependencies well.
 
@@ -91,16 +91,17 @@ We will backport bugfixes--but not new features--into older versions of
 
 #### Compatibility matrix
 
-|                     | Kubernetes 1.6 | Kubernetes 1.7 | Kubernetes 1.8 | Kubernetes 1.9 | Kubernetes 1.10 | Kubernetes 1.11 | Kubernetes 1.12 |
-|---------------------|----------------|----------------|----------------|----------------|-----------------|-----------------|-----------------|
-| client-go 3.0       | ✓              | -              | +-             | +-             | +-              | +-              | +-              |
-| client-go 4.0       | +-             | ✓              | +-             | +-             | +-              | +-              | +-              |
-| client-go 5.0       | +-             | +-             | ✓              | +-             | +-              | +-              | +-              |
-| client-go 6.0       | +-             | +-             | +-             | ✓              | +-              | +-              | +-              |
-| client-go 7.0       | +-             | +-             | +-             | +-             | ✓               | +-              | +-              |
-| client-go 8.0       | +-             | +-             | +-             | +-             | +-              | ✓               | +-              |
-| client-go 9.0       | +-             | +-             | +-             | +-             | +-              | +-              | ✓               |
-| client-go HEAD      | +-             | +-             | +-             | +-             | +-              | +-              | +-              |
+|                     | Kubernetes 1.5 | Kubernetes 1.6 | Kubernetes 1.7 | Kubernetes 1.8 | Kubernetes 1.9 | Kubernetes 1.10 | Kubernetes 1.11 |
+|---------------------|----------------|----------------|----------------|----------------|----------------|-----------------|-----------------|
+| client-go 1.5       | -              | -              | -              | -              | -              | -               | -               |
+| client-go 2.0       | ✓              | +-             | +-             | +-             | +-             | +-              | +-              |
+| client-go 3.0       | +-             | ✓              | -              | +-             | +-             | +-              | +-              |
+| client-go 4.0       | +-             | +-             | ✓              | +-             | +-             | +-              | +-              |
+| client-go 5.0       | +-             | +-             | +-             | ✓              | +-             | +-              | +-              |
+| client-go 6.0       | +-             | +-             | +-             | +-             | ✓              | +-              | +-              |
+| client-go 7.0       | +-             | +-             | +-             | +-             | +-             | ✓               | +-              |
+| client-go 8.0       | +-             | +-             | +-             | +-             | +-             | +-              | ✓               |
+| client-go HEAD      | +-             | +-             | +-             | +-             | +-             | +-              | +-              |
 
 Key:
 
@@ -127,10 +128,9 @@ between client-go versions.
 | client-go 3.0  | Kubernetes main repo, 1.6 branch     | = -                           |
 | client-go 4.0  | Kubernetes main repo, 1.7 branch     | = -                           |
 | client-go 5.0  | Kubernetes main repo, 1.8 branch     | = -                           |
-| client-go 6.0  | Kubernetes main repo, 1.9 branch     | = -                           |
+| client-go 6.0  | Kubernetes main repo, 1.9 branch     | ✓                             |
 | client-go 7.0  | Kubernetes main repo, 1.10 branch    | ✓                             |
 | client-go 8.0  | Kubernetes main repo, 1.11 branch    | ✓                             |
-| client-go 9.0  | Kubernetes main repo, 1.12 branch    | ✓                             |
 | client-go HEAD | Kubernetes main repo, master branch  | ✓                             |
 
 Key:

discovery/cached/memcache.go

@@ -44,7 +44,6 @@ type memCacheClient struct {
 	cacheValid             bool
 }
 
-// Error Constants
 var (
 	ErrCacheEmpty    = errors.New("the cache has not been filled yet")
 	ErrCacheNotFound = errors.New("not found")

discovery/cached_discovery.go

@@ -94,8 +94,6 @@ func (d *CachedDiscoveryClient) ServerResources() ([]*metav1.APIResourceList, er
 	return ServerResources(d)
 }
 
-// ServerGroups returns the supported groups, with information like supported versions and the
-// preferred version.
 func (d *CachedDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) {
 	filename := filepath.Join(d.cacheDirectory, "servergroups.json")
 	cachedBytes, err := d.getCachedFile(filename)
@@ -204,36 +202,26 @@ func (d *CachedDiscoveryClient) writeCachedFile(filename string, obj runtime.Obj
 	return err
 }
 
-// RESTClient returns a RESTClient that is used to communicate with API server
-// by this client implementation.
 func (d *CachedDiscoveryClient) RESTClient() restclient.Interface {
 	return d.delegate.RESTClient()
 }
 
-// ServerPreferredResources returns the supported resources with the version preferred by the
-// server.
 func (d *CachedDiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
 	return ServerPreferredResources(d)
 }
 
-// ServerPreferredNamespacedResources returns the supported namespaced resources with the
-// version preferred by the server.
 func (d *CachedDiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
 	return ServerPreferredNamespacedResources(d)
 }
 
-// ServerVersion retrieves and parses the server's version (git version).
 func (d *CachedDiscoveryClient) ServerVersion() (*version.Info, error) {
 	return d.delegate.ServerVersion()
 }
 
-// OpenAPISchema retrieves and parses the swagger API schema the server supports.
 func (d *CachedDiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
 	return d.delegate.OpenAPISchema()
 }
 
-// Fresh is supposed to tell the caller whether or not to retry if the cache
-// fails to find something (false = retry, true = no need to retry).
 func (d *CachedDiscoveryClient) Fresh() bool {
 	d.mutex.Lock()
 	defer d.mutex.Unlock()
@@ -241,7 +229,6 @@ func (d *CachedDiscoveryClient) Fresh() bool {
 	return d.fresh
 }
 
-// Invalidate enforces that no cached data is used in the future that is older than the current time.
 func (d *CachedDiscoveryClient) Invalidate() {
 	d.mutex.Lock()
 	defer d.mutex.Unlock()

discovery/discovery_client.go

@@ -263,8 +263,8 @@ func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList,
 
 	result := []*metav1.APIResourceList{}
 	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
+	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 {
@@ -276,11 +276,11 @@ func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList,
 			}
 
 			// create empty list which is filled later in another loop
-			emptyAPIResourceList := metav1.APIResourceList{
+			emptyApiResourceList := metav1.APIResourceList{
 				GroupVersion: version.GroupVersion,
 			}
-			gvAPIResourceLists[groupVersion] = &emptyAPIResourceList
-			result = append(result, &emptyAPIResourceList)
+			gvApiResourceLists[groupVersion] = &emptyApiResourceList
+			result = append(result, &emptyApiResourceList)
 
 			for i := range apiResourceList.APIResources {
 				apiResource := &apiResourceList.APIResources[i]
@@ -288,21 +288,21 @@ func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList,
 					continue
 				}
 				gv := schema.GroupResource{Group: apiGroup.Name, Resource: apiResource.Name}
-				if _, ok := grAPIResources[gv]; ok && version.Version != apiGroup.PreferredVersion.Version {
+				if _, ok := grApiResources[gv]; ok && version.Version != apiGroup.PreferredVersion.Version {
 					// only override with preferred version
 					continue
 				}
 				grVersions[gv] = version.Version
-				grAPIResources[gv] = apiResource
+				grApiResources[gv] = apiResource
 			}
 		}
 	}
 
 	// group selected APIResources according to GroupVersion into APIResourceLists
-	for groupResource, apiResource := range grAPIResources {
+	for groupResource, apiResource := range grApiResources {
 		version := grVersions[groupResource]
 		groupVersion := schema.GroupVersion{Group: groupResource.Group, Version: version}
-		apiResourceList := gvAPIResourceLists[groupVersion]
+		apiResourceList := gvApiResourceLists[groupVersion]
 		apiResourceList.APIResources = append(apiResourceList.APIResources, *apiResource)
 	}
 
@@ -464,9 +464,9 @@ func NewDiscoveryClient(c restclient.Interface) *DiscoveryClient {
 
 // RESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (d *DiscoveryClient) RESTClient() restclient.Interface {
-	if d == nil {
+func (c *DiscoveryClient) RESTClient() restclient.Interface {
+	if c == nil {
 		return nil
 	}
-	return d.restClient
+	return c.restClient
 }

discovery/fake/discovery.go

@@ -36,8 +36,6 @@ type FakeDiscovery struct {
 	FakedServerVersion *version.Info
 }
 
-// ServerResourcesForGroupVersion returns the supported resources for a group
-// and version.
 func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
 	action := testing.ActionImpl{
 		Verb:     "get",
@@ -52,7 +50,6 @@ func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*me
 	return nil, fmt.Errorf("GroupVersion %q not found", groupVersion)
 }
 
-// ServerResources returns the supported resources for all groups and versions.
 func (c *FakeDiscovery) ServerResources() ([]*metav1.APIResourceList, error) {
 	action := testing.ActionImpl{
 		Verb:     "get",
@@ -62,20 +59,14 @@ func (c *FakeDiscovery) ServerResources() ([]*metav1.APIResourceList, error) {
 	return c.Resources, nil
 }
 
-// ServerPreferredResources returns the supported resources with the version
-// preferred by the server.
 func (c *FakeDiscovery) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
 	return nil, nil
 }
 
-// ServerPreferredNamespacedResources returns the supported namespaced resources
-// with the version preferred by the server.
 func (c *FakeDiscovery) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
 	return nil, nil
 }
 
-// ServerGroups returns the supported groups, with information like supported
-// versions and the preferred version.
 func (c *FakeDiscovery) ServerGroups() (*metav1.APIGroupList, error) {
 	action := testing.ActionImpl{
 		Verb:     "get",
@@ -117,7 +108,6 @@ func (c *FakeDiscovery) ServerGroups() (*metav1.APIGroupList, error) {
 
 }
 
-// ServerVersion retrieves and parses the server's version.
 func (c *FakeDiscovery) ServerVersion() (*version.Info, error) {
 	action := testing.ActionImpl{}
 	action.Verb = "get"
@@ -132,13 +122,10 @@ func (c *FakeDiscovery) ServerVersion() (*version.Info, error) {
 	return &versionInfo, nil
 }
 
-// OpenAPISchema retrieves and parses the swagger API schema the server supports.
 func (c *FakeDiscovery) OpenAPISchema() (*openapi_v2.Document, error) {
 	return &openapi_v2.Document{}, nil
 }
 
-// RESTClient returns a RESTClient that is used to communicate with API server
-// by this client implementation.
 func (c *FakeDiscovery) RESTClient() restclient.Interface {
 	return nil
 }

discovery/helper.go

@@ -31,11 +31,11 @@ import (
 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", err)
+		return fmt.Errorf("couldn't read version from server: %v\n", err)
 	}
 	// GitVersion includes GitCommit and GitTreeState, but best to be safe?
 	if clientVersion.GitVersion != sVer.GitVersion || clientVersion.GitCommit != sVer.GitCommit || clientVersion.GitTreeState != sVer.GitTreeState {
-		return fmt.Errorf("server version (%#v) differs from client version (%#v)", sVer, clientVersion)
+		return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", sVer, clientVersion)
 	}
 
 	return nil
@@ -101,15 +101,12 @@ func FilteredBy(pred ResourcePredicate, rls []*metav1.APIResourceList) []*metav1
 	return result
 }
 
-// ResourcePredicate has a method to check if a resource matches a given condition.
 type ResourcePredicate interface {
 	Match(groupVersion string, r *metav1.APIResource) bool
 }
 
-// ResourcePredicateFunc returns true if it matches a resource based on a custom condition.
 type ResourcePredicateFunc func(groupVersion string, r *metav1.APIResource) bool
 
-// Match is a wrapper around ResourcePredicateFunc.
 func (fn ResourcePredicateFunc) Match(groupVersion string, r *metav1.APIResource) bool {
 	return fn(groupVersion, r)
 }
@@ -119,7 +116,6 @@ type SupportsAllVerbs struct {
 	Verbs []string
 }
 
-// Match checks if a resource contains all the given verbs.
 func (p SupportsAllVerbs) Match(groupVersion string, r *metav1.APIResource) bool {
 	return sets.NewString([]string(r.Verbs)...).HasAll(p.Verbs...)
 }

dynamic/dynamicinformer/informer.go

@@ -1,155 +0,0 @@
-/*
-Copyright 2018 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 dynamicinformer
-
-import (
-	"sync"
-	"time"
-
-	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/watch"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/client-go/dynamic/dynamiclister"
-	"k8s.io/client-go/informers"
-	"k8s.io/client-go/tools/cache"
-)
-
-// NewDynamicSharedInformerFactory constructs a new instance of dynamicSharedInformerFactory for all namespaces.
-func NewDynamicSharedInformerFactory(client dynamic.Interface, defaultResync time.Duration) DynamicSharedInformerFactory {
-	return NewFilteredDynamicSharedInformerFactory(client, defaultResync, metav1.NamespaceAll, nil)
-}
-
-// NewFilteredDynamicSharedInformerFactory constructs a new instance of dynamicSharedInformerFactory.
-// Listers obtained via this factory will be subject to the same filters as specified here.
-func NewFilteredDynamicSharedInformerFactory(client dynamic.Interface, defaultResync time.Duration, namespace string, tweakListOptions TweakListOptionsFunc) DynamicSharedInformerFactory {
-	return &dynamicSharedInformerFactory{
-		client:           client,
-		defaultResync:    defaultResync,
-		namespace:        metav1.NamespaceAll,
-		informers:        map[schema.GroupVersionResource]informers.GenericInformer{},
-		startedInformers: make(map[schema.GroupVersionResource]bool),
-	}
-}
-
-type dynamicSharedInformerFactory struct {
-	client        dynamic.Interface
-	defaultResync time.Duration
-	namespace     string
-
-	lock      sync.Mutex
-	informers map[schema.GroupVersionResource]informers.GenericInformer
-	// startedInformers is used for tracking which informers have been started.
-	// This allows Start() to be called multiple times safely.
-	startedInformers map[schema.GroupVersionResource]bool
-}
-
-var _ DynamicSharedInformerFactory = &dynamicSharedInformerFactory{}
-
-func (f *dynamicSharedInformerFactory) ForResource(gvr schema.GroupVersionResource) informers.GenericInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	key := gvr
-	informer, exists := f.informers[key]
-	if exists {
-		return informer
-	}
-
-	informer = NewFilteredDynamicInformer(f.client, gvr, f.namespace, f.defaultResync, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, nil)
-	f.informers[key] = informer
-
-	return informer
-}
-
-// Start initializes all requested informers.
-func (f *dynamicSharedInformerFactory) Start(stopCh <-chan struct{}) {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	for informerType, informer := range f.informers {
-		if !f.startedInformers[informerType] {
-			go informer.Informer().Run(stopCh)
-			f.startedInformers[informerType] = true
-		}
-	}
-}
-
-// WaitForCacheSync waits for all started informers' cache were synced.
-func (f *dynamicSharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[schema.GroupVersionResource]bool {
-	informers := func() map[schema.GroupVersionResource]cache.SharedIndexInformer {
-		f.lock.Lock()
-		defer f.lock.Unlock()
-
-		informers := map[schema.GroupVersionResource]cache.SharedIndexInformer{}
-		for informerType, informer := range f.informers {
-			if f.startedInformers[informerType] {
-				informers[informerType] = informer.Informer()
-			}
-		}
-		return informers
-	}()
-
-	res := map[schema.GroupVersionResource]bool{}
-	for informType, informer := range informers {
-		res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced)
-	}
-	return res
-}
-
-// NewFilteredDynamicInformer constructs a new informer for a dynamic type.
-func NewFilteredDynamicInformer(client dynamic.Interface, gvr schema.GroupVersionResource, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions TweakListOptionsFunc) informers.GenericInformer {
-	return &dynamicInformer{
-		gvr: gvr,
-		informer: cache.NewSharedIndexInformer(
-			&cache.ListWatch{
-				ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-					if tweakListOptions != nil {
-						tweakListOptions(&options)
-					}
-					return client.Resource(gvr).Namespace(namespace).List(options)
-				},
-				WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-					if tweakListOptions != nil {
-						tweakListOptions(&options)
-					}
-					return client.Resource(gvr).Namespace(namespace).Watch(options)
-				},
-			},
-			&unstructured.Unstructured{},
-			resyncPeriod,
-			indexers,
-		),
-	}
-}
-
-type dynamicInformer struct {
-	informer cache.SharedIndexInformer
-	gvr      schema.GroupVersionResource
-}
-
-var _ informers.GenericInformer = &dynamicInformer{}
-
-func (d *dynamicInformer) Informer() cache.SharedIndexInformer {
-	return d.informer
-}
-
-func (d *dynamicInformer) Lister() cache.GenericLister {
-	return dynamiclister.NewRuntimeObjectShim(dynamiclister.New(d.informer.GetIndexer(), d.gvr))
-}

dynamic/dynamicinformer/informer_test.go

@@ -1,160 +0,0 @@
-/*
-Copyright 2018 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 dynamicinformer_test
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"k8s.io/apimachinery/pkg/api/equality"
-	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/util/diff"
-	"k8s.io/client-go/dynamic/dynamicinformer"
-	"k8s.io/client-go/dynamic/fake"
-	"k8s.io/client-go/tools/cache"
-)
-
-func TestDynamicSharedInformerFactory(t *testing.T) {
-	scenarios := []struct {
-		name        string
-		existingObj *unstructured.Unstructured
-		gvr         schema.GroupVersionResource
-		ns          string
-		trigger     func(gvr schema.GroupVersionResource, ns string, fakeClient *fake.FakeDynamicClient, testObject *unstructured.Unstructured) *unstructured.Unstructured
-		handler     func(rcvCh chan<- *unstructured.Unstructured) *cache.ResourceEventHandlerFuncs
-	}{
-		// scenario 1
-		{
-			name: "scenario 1: test if adding an object triggers AddFunc",
-			ns:   "ns-foo",
-			gvr:  schema.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "deployments"},
-			trigger: func(gvr schema.GroupVersionResource, ns string, fakeClient *fake.FakeDynamicClient, _ *unstructured.Unstructured) *unstructured.Unstructured {
-				testObject := newUnstructured("extensions/v1beta1", "Deployment", "ns-foo", "name-foo")
-				createdObj, err := fakeClient.Resource(gvr).Namespace(ns).Create(testObject, metav1.CreateOptions{})
-				if err != nil {
-					t.Error(err)
-				}
-				return createdObj
-			},
-			handler: func(rcvCh chan<- *unstructured.Unstructured) *cache.ResourceEventHandlerFuncs {
-				return &cache.ResourceEventHandlerFuncs{
-					AddFunc: func(obj interface{}) {
-						rcvCh <- obj.(*unstructured.Unstructured)
-					},
-				}
-			},
-		},
-
-		// scenario 2
-		{
-			name:        "scenario 2: tests if updating an object triggers UpdateFunc",
-			ns:          "ns-foo",
-			gvr:         schema.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "deployments"},
-			existingObj: newUnstructured("extensions/v1beta1", "Deployment", "ns-foo", "name-foo"),
-			trigger: func(gvr schema.GroupVersionResource, ns string, fakeClient *fake.FakeDynamicClient, testObject *unstructured.Unstructured) *unstructured.Unstructured {
-				testObject.Object["spec"] = "updatedName"
-				updatedObj, err := fakeClient.Resource(gvr).Namespace(ns).Update(testObject, metav1.UpdateOptions{})
-				if err != nil {
-					t.Error(err)
-				}
-				return updatedObj
-			},
-			handler: func(rcvCh chan<- *unstructured.Unstructured) *cache.ResourceEventHandlerFuncs {
-				return &cache.ResourceEventHandlerFuncs{
-					UpdateFunc: func(old, updated interface{}) {
-						rcvCh <- updated.(*unstructured.Unstructured)
-					},
-				}
-			},
-		},
-
-		// scenario 3
-		{
-			name:        "scenario 3: test if deleting an object triggers DeleteFunc",
-			ns:          "ns-foo",
-			gvr:         schema.GroupVersionResource{Group: "extensions", Version: "v1beta1", Resource: "deployments"},
-			existingObj: newUnstructured("extensions/v1beta1", "Deployment", "ns-foo", "name-foo"),
-			trigger: func(gvr schema.GroupVersionResource, ns string, fakeClient *fake.FakeDynamicClient, testObject *unstructured.Unstructured) *unstructured.Unstructured {
-				err := fakeClient.Resource(gvr).Namespace(ns).Delete(testObject.GetName(), &metav1.DeleteOptions{})
-				if err != nil {
-					t.Error(err)
-				}
-				return testObject
-			},
-			handler: func(rcvCh chan<- *unstructured.Unstructured) *cache.ResourceEventHandlerFuncs {
-				return &cache.ResourceEventHandlerFuncs{
-					DeleteFunc: func(obj interface{}) {
-						rcvCh <- obj.(*unstructured.Unstructured)
-					},
-				}
-			},
-		},
-	}
-
-	for _, ts := range scenarios {
-		t.Run(ts.name, func(t *testing.T) {
-			// test data
-			timeout := time.Duration(3 * time.Second)
-			ctx, cancel := context.WithTimeout(context.Background(), timeout)
-			defer cancel()
-			scheme := runtime.NewScheme()
-			informerReciveObjectCh := make(chan *unstructured.Unstructured, 1)
-			objs := []runtime.Object{}
-			if ts.existingObj != nil {
-				objs = append(objs, ts.existingObj)
-			}
-			fakeClient := fake.NewSimpleDynamicClient(scheme, objs...)
-			target := dynamicinformer.NewDynamicSharedInformerFactory(fakeClient, 0)
-
-			// act
-			informerListerForGvr := target.ForResource(ts.gvr)
-			informerListerForGvr.Informer().AddEventHandler(ts.handler(informerReciveObjectCh))
-			target.Start(ctx.Done())
-			if synced := target.WaitForCacheSync(ctx.Done()); !synced[ts.gvr] {
-				t.Errorf("informer for %s hasn't synced", ts.gvr)
-			}
-
-			testObject := ts.trigger(ts.gvr, ts.ns, fakeClient, ts.existingObj)
-			select {
-			case objFromInformer := <-informerReciveObjectCh:
-				if !equality.Semantic.DeepEqual(testObject, objFromInformer) {
-					t.Fatalf("%v", diff.ObjectDiff(testObject, objFromInformer))
-				}
-			case <-ctx.Done():
-				t.Errorf("tested informer haven't received an object, waited %v", timeout)
-			}
-		})
-	}
-}
-
-func newUnstructured(apiVersion, kind, namespace, name string) *unstructured.Unstructured {
-	return &unstructured.Unstructured{
-		Object: map[string]interface{}{
-			"apiVersion": apiVersion,
-			"kind":       kind,
-			"metadata": map[string]interface{}{
-				"namespace": namespace,
-				"name":      name,
-			},
-			"spec": name,
-		},
-	}
-}

dynamic/dynamicinformer/interface.go

@@ -1,34 +0,0 @@
-/*
-Copyright 2018 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 dynamicinformer
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/informers"
-)
-
-// DynamicSharedInformerFactory provides access to a shared informer and lister for dynamic client
-type DynamicSharedInformerFactory interface {
-	Start(stopCh <-chan struct{})
-	ForResource(gvr schema.GroupVersionResource) informers.GenericInformer
-	WaitForCacheSync(stopCh <-chan struct{}) map[schema.GroupVersionResource]bool
-}
-
-// TweakListOptionsFunc defines the signature of a helper function
-// that wants to provide more listing options to API
-type TweakListOptionsFunc func(*metav1.ListOptions)

dynamic/dynamiclister/interface.go

@@ -1,40 +0,0 @@
-/*
-Copyright 2018 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 dynamiclister
-
-import (
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/labels"
-)
-
-// Lister helps list resources.
-type Lister interface {
-	// List lists all resources in the indexer.
-	List(selector labels.Selector) (ret []*unstructured.Unstructured, err error)
-	// Get retrieves a resource from the indexer with the given name
-	Get(name string) (*unstructured.Unstructured, error)
-	// Namespace returns an object that can list and get resources in a given namespace.
-	Namespace(namespace string) NamespaceLister
-}
-
-// NamespaceLister helps list and get resources.
-type NamespaceLister interface {
-	// List lists all resources in the indexer for a given namespace.
-	List(selector labels.Selector) (ret []*unstructured.Unstructured, err error)
-	// Get retrieves a resource from the indexer for a given namespace and name.
-	Get(name string) (*unstructured.Unstructured, error)
-}

dynamic/dynamiclister/lister.go

@@ -1,91 +0,0 @@
-/*
-Copyright 2018 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 dynamiclister
-
-import (
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/tools/cache"
-)
-
-var _ Lister = &dynamicLister{}
-var _ NamespaceLister = &dynamicNamespaceLister{}
-
-// dynamicLister implements the Lister interface.
-type dynamicLister struct {
-	indexer cache.Indexer
-	gvr     schema.GroupVersionResource
-}
-
-// New returns a new Lister.
-func New(indexer cache.Indexer, gvr schema.GroupVersionResource) Lister {
-	return &dynamicLister{indexer: indexer, gvr: gvr}
-}
-
-// List lists all resources in the indexer.
-func (l *dynamicLister) List(selector labels.Selector) (ret []*unstructured.Unstructured, err error) {
-	err = cache.ListAll(l.indexer, selector, func(m interface{}) {
-		ret = append(ret, m.(*unstructured.Unstructured))
-	})
-	return ret, err
-}
-
-// Get retrieves a resource from the indexer with the given name
-func (l *dynamicLister) Get(name string) (*unstructured.Unstructured, error) {
-	obj, exists, err := l.indexer.GetByKey(name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(l.gvr.GroupResource(), name)
-	}
-	return obj.(*unstructured.Unstructured), nil
-}
-
-// Namespace returns an object that can list and get resources from a given namespace.
-func (l *dynamicLister) Namespace(namespace string) NamespaceLister {
-	return &dynamicNamespaceLister{indexer: l.indexer, namespace: namespace, gvr: l.gvr}
-}
-
-// dynamicNamespaceLister implements the NamespaceLister interface.
-type dynamicNamespaceLister struct {
-	indexer   cache.Indexer
-	namespace string
-	gvr       schema.GroupVersionResource
-}
-
-// List lists all resources in the indexer for a given namespace.
-func (l *dynamicNamespaceLister) List(selector labels.Selector) (ret []*unstructured.Unstructured, err error) {
-	err = cache.ListAllByNamespace(l.indexer, l.namespace, selector, func(m interface{}) {
-		ret = append(ret, m.(*unstructured.Unstructured))
-	})
-	return ret, err
-}
-
-// Get retrieves a resource from the indexer for a given namespace and name.
-func (l *dynamicNamespaceLister) Get(name string) (*unstructured.Unstructured, error) {
-	obj, exists, err := l.indexer.GetByKey(l.namespace + "/" + name)
-	if err != nil {
-		return nil, err
-	}
-	if !exists {
-		return nil, errors.NewNotFound(l.gvr.GroupResource(), name)
-	}
-	return obj.(*unstructured.Unstructured), nil
-}

dynamic/dynamiclister/lister_test.go

@@ -1,257 +0,0 @@
-/*
-Copyright 2018 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 dynamiclister_test
-
-import (
-	"reflect"
-	"testing"
-
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/diff"
-	"k8s.io/client-go/dynamic/dynamiclister"
-	"k8s.io/client-go/tools/cache"
-)
-
-func TestNamespaceGetMethod(t *testing.T) {
-	tests := []struct {
-		name            string
-		existingObjects []runtime.Object
-		namespaceToSync string
-		gvrToSync       schema.GroupVersionResource
-		objectToGet     string
-		expectedObject  *unstructured.Unstructured
-		expectError     bool
-	}{
-		{
-			name: "scenario 1: gets name-foo1 resource from the indexer from ns-foo namespace",
-			existingObjects: []runtime.Object{
-				newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-				newUnstructured("group/version", "TheKind", "ns-foo", "name-foo1"),
-				newUnstructured("group/version", "TheKind", "ns-bar", "name-bar"),
-			},
-			namespaceToSync: "ns-foo",
-			gvrToSync:       schema.GroupVersionResource{Group: "group", Version: "version", Resource: "TheKinds"},
-			objectToGet:     "name-foo1",
-			expectedObject:  newUnstructured("group/version", "TheKind", "ns-foo", "name-foo1"),
-		},
-		{
-			name: "scenario 2: gets name-foo-non-existing resource from the indexer from ns-foo namespace",
-			existingObjects: []runtime.Object{
-				newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-				newUnstructured("group/version", "TheKind", "ns-foo", "name-foo1"),
-				newUnstructured("group/version", "TheKind", "ns-bar", "name-bar"),
-			},
-			namespaceToSync: "ns-foo",
-			gvrToSync:       schema.GroupVersionResource{Group: "group", Version: "version", Resource: "TheKinds"},
-			objectToGet:     "name-foo-non-existing",
-			expectError:     true,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			// test data
-			indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})
-			for _, obj := range test.existingObjects {
-				err := indexer.Add(obj)
-				if err != nil {
-					t.Fatal(err)
-				}
-			}
-			// act
-			target := dynamiclister.New(indexer, test.gvrToSync).Namespace(test.namespaceToSync)
-			actualObject, err := target.Get(test.objectToGet)
-
-			// validate
-			if test.expectError {
-				if err == nil {
-					t.Fatal("expected to get an error but non was returned")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatal(err)
-			}
-			if !reflect.DeepEqual(test.expectedObject, actualObject) {
-				t.Fatalf("unexpected object has been returned expected = %v actual = %v, diff = %v", test.expectedObject, actualObject, diff.ObjectDiff(test.expectedObject, actualObject))
-			}
-		})
-	}
-}
-
-func TestNamespaceListMethod(t *testing.T) {
-	// test data
-	objs := []runtime.Object{
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-foo1"),
-		newUnstructured("group/version", "TheKind", "ns-bar", "name-bar"),
-	}
-	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})
-	for _, obj := range objs {
-		err := indexer.Add(obj)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-	expectedOutput := []*unstructured.Unstructured{
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-foo1"),
-	}
-	namespaceToList := "ns-foo"
-
-	// act
-	target := dynamiclister.New(indexer, schema.GroupVersionResource{Group: "group", Version: "version", Resource: "TheKinds"}).Namespace(namespaceToList)
-	actualOutput, err := target.List(labels.Everything())
-
-	// validate
-	if err != nil {
-		t.Fatal(err)
-	}
-	assertListOrDie(expectedOutput, actualOutput, t)
-}
-
-func TestListerGetMethod(t *testing.T) {
-	tests := []struct {
-		name            string
-		existingObjects []runtime.Object
-		namespaceToSync string
-		gvrToSync       schema.GroupVersionResource
-		objectToGet     string
-		expectedObject  *unstructured.Unstructured
-		expectError     bool
-	}{
-		{
-			name: "scenario 1: gets name-foo1 resource from the indexer",
-			existingObjects: []runtime.Object{
-				newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-				newUnstructured("group/version", "TheKind", "", "name-foo1"),
-				newUnstructured("group/version", "TheKind", "ns-bar", "name-bar"),
-			},
-			namespaceToSync: "",
-			gvrToSync:       schema.GroupVersionResource{Group: "group", Version: "version", Resource: "TheKinds"},
-			objectToGet:     "name-foo1",
-			expectedObject:  newUnstructured("group/version", "TheKind", "", "name-foo1"),
-		},
-		{
-			name: "scenario 2: doesn't get name-foo resource from the indexer from ns-foo namespace",
-			existingObjects: []runtime.Object{
-				newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-				newUnstructured("group/version", "TheKind", "ns-foo", "name-foo1"),
-				newUnstructured("group/version", "TheKind", "ns-bar", "name-bar"),
-			},
-			namespaceToSync: "ns-foo",
-			gvrToSync:       schema.GroupVersionResource{Group: "group", Version: "version", Resource: "TheKinds"},
-			objectToGet:     "name-foo",
-			expectError:     true,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			// test data
-			indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})
-			for _, obj := range test.existingObjects {
-				err := indexer.Add(obj)
-				if err != nil {
-					t.Fatal(err)
-				}
-			}
-			// act
-			target := dynamiclister.New(indexer, test.gvrToSync)
-			actualObject, err := target.Get(test.objectToGet)
-
-			// validate
-			if test.expectError {
-				if err == nil {
-					t.Fatal("expected to get an error but non was returned")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatal(err)
-			}
-			if !reflect.DeepEqual(test.expectedObject, actualObject) {
-				t.Fatalf("unexpected object has been returned expected = %v actual = %v, diff = %v", test.expectedObject, actualObject, diff.ObjectDiff(test.expectedObject, actualObject))
-			}
-		})
-	}
-}
-
-func TestListerListMethod(t *testing.T) {
-	// test data
-	objs := []runtime.Object{
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-bar"),
-	}
-	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})
-	for _, obj := range objs {
-		err := indexer.Add(obj)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-	expectedOutput := []*unstructured.Unstructured{
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-bar"),
-	}
-
-	// act
-	target := dynamiclister.New(indexer, schema.GroupVersionResource{Group: "group", Version: "version", Resource: "TheKinds"})
-	actualOutput, err := target.List(labels.Everything())
-
-	// validate
-	if err != nil {
-		t.Fatal(err)
-	}
-	assertListOrDie(expectedOutput, actualOutput, t)
-}
-
-func newUnstructured(apiVersion, kind, namespace, name string) *unstructured.Unstructured {
-	return &unstructured.Unstructured{
-		Object: map[string]interface{}{
-			"apiVersion": apiVersion,
-			"kind":       kind,
-			"metadata": map[string]interface{}{
-				"namespace": namespace,
-				"name":      name,
-			},
-		},
-	}
-}
-
-func assertListOrDie(expected, actual []*unstructured.Unstructured, t *testing.T) {
-	if len(actual) != len(expected) {
-		t.Fatalf("unexpected number of items returned, expected = %d, actual = %d", len(expected), len(actual))
-	}
-	for _, expectedObject := range expected {
-		found := false
-		for _, actualObject := range actual {
-			if actualObject.GetName() == expectedObject.GetName() {
-				if !reflect.DeepEqual(expectedObject, actualObject) {
-					t.Fatalf("unexpected object has been returned expected = %v actual = %v, diff = %v", expectedObject, actualObject, diff.ObjectDiff(expectedObject, actualObject))
-				}
-				found = true
-			}
-		}
-		if !found {
-			t.Fatalf("the resource with the name = %s was not found in the returned output", expectedObject.GetName())
-		}
-	}
-}

dynamic/dynamiclister/shim.go

@@ -1,87 +0,0 @@
-/*
-Copyright 2018 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 dynamiclister
-
-import (
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/client-go/tools/cache"
-)
-
-var _ cache.GenericLister = &dynamicListerShim{}
-var _ cache.GenericNamespaceLister = &dynamicNamespaceListerShim{}
-
-// dynamicListerShim implements the cache.GenericLister interface.
-type dynamicListerShim struct {
-	lister Lister
-}
-
-// NewRuntimeObjectShim returns a new shim for Lister.
-// It wraps Lister so that it implements cache.GenericLister interface
-func NewRuntimeObjectShim(lister Lister) cache.GenericLister {
-	return &dynamicListerShim{lister: lister}
-}
-
-// List will return all objects across namespaces
-func (s *dynamicListerShim) List(selector labels.Selector) (ret []runtime.Object, err error) {
-	objs, err := s.lister.List(selector)
-	if err != nil {
-		return nil, err
-	}
-
-	ret = make([]runtime.Object, len(objs))
-	for index, obj := range objs {
-		ret[index] = obj
-	}
-	return ret, err
-}
-
-// Get will attempt to retrieve assuming that name==key
-func (s *dynamicListerShim) Get(name string) (runtime.Object, error) {
-	return s.lister.Get(name)
-}
-
-func (s *dynamicListerShim) ByNamespace(namespace string) cache.GenericNamespaceLister {
-	return &dynamicNamespaceListerShim{
-		namespaceLister: s.lister.Namespace(namespace),
-	}
-}
-
-// dynamicNamespaceListerShim implements the NamespaceLister interface.
-// It wraps NamespaceLister so that it implements cache.GenericNamespaceLister interface
-type dynamicNamespaceListerShim struct {
-	namespaceLister NamespaceLister
-}
-
-// List will return all objects in this namespace
-func (ns *dynamicNamespaceListerShim) List(selector labels.Selector) (ret []runtime.Object, err error) {
-	objs, err := ns.namespaceLister.List(selector)
-	if err != nil {
-		return nil, err
-	}
-
-	ret = make([]runtime.Object, len(objs))
-	for index, obj := range objs {
-		ret[index] = obj
-	}
-	return ret, err
-}
-
-// Get will attempt to retrieve by namespace and name
-func (ns *dynamicNamespaceListerShim) Get(name string) (runtime.Object, error) {
-	return ns.namespaceLister.Get(name)
-}

dynamic/fake/simple.go

@@ -45,7 +45,7 @@ func NewSimpleDynamicClient(scheme *runtime.Scheme, objects ...runtime.Object) *
 		}
 	}
 
-	cs := &FakeDynamicClient{scheme: scheme}
+	cs := &FakeDynamicClient{}
 	cs.AddReactor("*", "*", testing.ObjectReaction(o))
 	cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
 		gvr := action.GetResource()
@@ -331,26 +331,25 @@ func (c *dynamicResourceClient) Watch(opts metav1.ListOptions) (watch.Interface,
 	panic("math broke")
 }
 
-// TODO: opts are currently ignored.
 func (c *dynamicResourceClient) Patch(name string, pt types.PatchType, data []byte, opts metav1.UpdateOptions, subresources ...string) (*unstructured.Unstructured, error) {
 	var uncastRet runtime.Object
 	var err error
 	switch {
 	case len(c.namespace) == 0 && len(subresources) == 0:
 		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewRootPatchAction(c.resource, name, pt, data), &metav1.Status{Status: "dynamic patch fail"})
+			Invokes(testing.NewRootPatchAction(c.resource, name, data), &metav1.Status{Status: "dynamic patch fail"})
 
 	case len(c.namespace) == 0 && len(subresources) > 0:
 		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewRootPatchSubresourceAction(c.resource, name, pt, data, subresources...), &metav1.Status{Status: "dynamic patch fail"})
+			Invokes(testing.NewRootPatchSubresourceAction(c.resource, name, data, subresources...), &metav1.Status{Status: "dynamic patch fail"})
 
 	case len(c.namespace) > 0 && len(subresources) == 0:
 		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewPatchAction(c.resource, c.namespace, name, pt, data), &metav1.Status{Status: "dynamic patch fail"})
+			Invokes(testing.NewPatchAction(c.resource, c.namespace, name, data), &metav1.Status{Status: "dynamic patch fail"})
 
 	case len(c.namespace) > 0 && len(subresources) > 0:
 		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewPatchSubresourceAction(c.resource, c.namespace, name, pt, data, subresources...), &metav1.Status{Status: "dynamic patch fail"})
+			Invokes(testing.NewPatchSubresourceAction(c.resource, c.namespace, name, data, subresources...), &metav1.Status{Status: "dynamic patch fail"})
 
 	}
 

dynamic/fake/simple_test.go

@@ -17,7 +17,6 @@ limitations under the License.
 package fake
 
 import (
-	"fmt"
 	"testing"
 
 	"k8s.io/apimachinery/pkg/api/equality"
@@ -25,20 +24,9 @@ import (
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/diff"
 )
 
-const (
-	testGroup      = "testgroup"
-	testVersion    = "testversion"
-	testResource   = "testkinds"
-	testNamespace  = "testns"
-	testName       = "testname"
-	testKind       = "TestKind"
-	testAPIVersion = "testgroup/testversion"
-)
-
 func newUnstructured(apiVersion, kind, namespace, name string) *unstructured.Unstructured {
 	return &unstructured.Unstructured{
 		Object: map[string]interface{}{
@@ -52,12 +40,6 @@ func newUnstructured(apiVersion, kind, namespace, name string) *unstructured.Uns
 	}
 }
 
-func newUnstructuredWithSpec(spec map[string]interface{}) *unstructured.Unstructured {
-	u := newUnstructured(testAPIVersion, testKind, testNamespace, testName)
-	u.Object["spec"] = spec
-	return u
-}
-
 func TestList(t *testing.T) {
 	scheme := runtime.NewScheme()
 
@@ -82,116 +64,3 @@ func TestList(t *testing.T) {
 		t.Fatal(diff.ObjectGoPrintDiff(expected, listFirst.Items))
 	}
 }
-
-type patchTestCase struct {
-	name                  string
-	object                runtime.Object
-	patchType             types.PatchType
-	patchBytes            []byte
-	wantErrMsg            string
-	expectedPatchedObject runtime.Object
-}
-
-func (tc *patchTestCase) runner(t *testing.T) {
-	client := NewSimpleDynamicClient(runtime.NewScheme(), tc.object)
-	resourceInterface := client.Resource(schema.GroupVersionResource{Group: testGroup, Version: testVersion, Resource: testResource}).Namespace(testNamespace)
-
-	got, recErr := resourceInterface.Patch(testName, tc.patchType, tc.patchBytes, metav1.UpdateOptions{})
-
-	if err := tc.verifyErr(recErr); err != nil {
-		t.Error(err)
-	}
-
-	if err := tc.verifyResult(got); err != nil {
-		t.Error(err)
-	}
-
-}
-
-// verifyErr verifies that the given error returned from Patch is the error
-// expected by the test case.
-func (tc *patchTestCase) verifyErr(err error) error {
-	if tc.wantErrMsg != "" && err == nil {
-		return fmt.Errorf("want error, got nil")
-	}
-
-	if tc.wantErrMsg == "" && err != nil {
-		return fmt.Errorf("want no error, got %v", err)
-	}
-
-	if err != nil {
-		if want, got := tc.wantErrMsg, err.Error(); want != got {
-			return fmt.Errorf("incorrect error: want: %q got: %q", want, got)
-		}
-	}
-	return nil
-}
-
-func (tc *patchTestCase) verifyResult(result *unstructured.Unstructured) error {
-	if tc.expectedPatchedObject == nil && result == nil {
-		return nil
-	}
-	if !equality.Semantic.DeepEqual(result, tc.expectedPatchedObject) {
-		return fmt.Errorf("unexpected diff in received object: %s", diff.ObjectGoPrintDiff(tc.expectedPatchedObject, result))
-	}
-	return nil
-}
-
-func TestPatch(t *testing.T) {
-	testCases := []patchTestCase{
-		{
-			name:       "jsonpatch fails with merge type",
-			object:     newUnstructuredWithSpec(map[string]interface{}{"foo": "bar"}),
-			patchType:  types.StrategicMergePatchType,
-			patchBytes: []byte(`[]`),
-			wantErrMsg: "invalid JSON document",
-		}, {
-			name:      "jsonpatch works with empty patch",
-			object:    newUnstructuredWithSpec(map[string]interface{}{"foo": "bar"}),
-			patchType: types.JSONPatchType,
-			// No-op
-			patchBytes:            []byte(`[]`),
-			expectedPatchedObject: newUnstructuredWithSpec(map[string]interface{}{"foo": "bar"}),
-		}, {
-			name:      "jsonpatch works with simple change patch",
-			object:    newUnstructuredWithSpec(map[string]interface{}{"foo": "bar"}),
-			patchType: types.JSONPatchType,
-			// change spec.foo from bar to foobar
-			patchBytes:            []byte(`[{"op": "replace", "path": "/spec/foo", "value": "foobar"}]`),
-			expectedPatchedObject: newUnstructuredWithSpec(map[string]interface{}{"foo": "foobar"}),
-		}, {
-			name:      "jsonpatch works with simple addition",
-			object:    newUnstructuredWithSpec(map[string]interface{}{"foo": "bar"}),
-			patchType: types.JSONPatchType,
-			// add spec.newvalue = dummy
-			patchBytes:            []byte(`[{"op": "add", "path": "/spec/newvalue", "value": "dummy"}]`),
-			expectedPatchedObject: newUnstructuredWithSpec(map[string]interface{}{"foo": "bar", "newvalue": "dummy"}),
-		}, {
-			name:      "jsonpatch works with simple deletion",
-			object:    newUnstructuredWithSpec(map[string]interface{}{"foo": "bar", "toremove": "shouldnotbehere"}),
-			patchType: types.JSONPatchType,
-			// remove spec.newvalue = dummy
-			patchBytes:            []byte(`[{"op": "remove", "path": "/spec/toremove"}]`),
-			expectedPatchedObject: newUnstructuredWithSpec(map[string]interface{}{"foo": "bar"}),
-		}, {
-			name:      "strategic merge patch fails with JSONPatch",
-			object:    newUnstructuredWithSpec(map[string]interface{}{"foo": "bar"}),
-			patchType: types.StrategicMergePatchType,
-			// add spec.newvalue = dummy
-			patchBytes: []byte(`[{"op": "add", "path": "/spec/newvalue", "value": "dummy"}]`),
-			wantErrMsg: "invalid JSON document",
-		}, {
-			name:       "merge patch fails as unsupported",
-			object:     newUnstructured(testAPIVersion, testKind, testNamespace, testName),
-			patchType:  types.MergePatchType,
-			patchBytes: []byte(`{}`),
-			wantErrMsg: "PatchType is not supported",
-		},
-		// TODO: Add tests for strategic merge using v1.Pod for example to ensure the test cases
-		// demonstrate expected use cases.
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, tc.runner)
-	}
-}

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

@@ -25,13 +25,7 @@ build the image on Minikube:
     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. If you have RBAC enabled, use the following
-snippet to create role binding which will grant the default service account view
-permissions.
-
-```
-kubectl create clusterrolebinding default-view --clusterrole=view --serviceaccount=default:default
-```
+that your Kubernetes cluster can pull from.
 
 Then, run the image in a Pod with a single instance Deployment:
 

informers/auditregistration/interface.go

@@ -1,46 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by informer-gen. DO NOT EDIT.
-
-package auditregistration
-
-import (
-	v1alpha1 "k8s.io/client-go/informers/auditregistration/v1alpha1"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1alpha1 provides access to shared informers for resources in V1alpha1.
-	V1alpha1() v1alpha1.Interface
-}
-
-type group struct {
-	factory          internalinterfaces.SharedInformerFactory
-	namespace        string
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
-	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
-}
-
-// V1alpha1 returns a new v1alpha1.Interface.
-func (g *group) V1alpha1() v1alpha1.Interface {
-	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
-}

informers/auditregistration/v1alpha1/auditsink.go

@@ -1,88 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by informer-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	time "time"
-
-	auditregistrationv1alpha1 "k8s.io/api/auditregistration/v1alpha1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	watch "k8s.io/apimachinery/pkg/watch"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	kubernetes "k8s.io/client-go/kubernetes"
-	v1alpha1 "k8s.io/client-go/listers/auditregistration/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// AuditSinkInformer provides access to a shared informer and lister for
-// AuditSinks.
-type AuditSinkInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.AuditSinkLister
-}
-
-type auditSinkInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// NewAuditSinkInformer constructs a new informer for AuditSink type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewAuditSinkInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredAuditSinkInformer(client, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredAuditSinkInformer constructs a new informer for AuditSink type.
-// Always prefer using an informer factory to get a shared informer instead of getting an independent
-// one. This reduces memory footprint and number of connections to the server.
-func NewFilteredAuditSinkInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.AuditregistrationV1alpha1().AuditSinks().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.AuditregistrationV1alpha1().AuditSinks().Watch(options)
-			},
-		},
-		&auditregistrationv1alpha1.AuditSink{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *auditSinkInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredAuditSinkInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *auditSinkInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&auditregistrationv1alpha1.AuditSink{}, f.defaultInformer)
-}
-
-func (f *auditSinkInformer) Lister() v1alpha1.AuditSinkLister {
-	return v1alpha1.NewAuditSinkLister(f.Informer().GetIndexer())
-}

informers/auditregistration/v1alpha1/interface.go

@@ -1,45 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by informer-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// AuditSinks returns a AuditSinkInformer.
-	AuditSinks() AuditSinkInformer
-}
-
-type version struct {
-	factory          internalinterfaces.SharedInformerFactory
-	namespace        string
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
-	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
-}
-
-// AuditSinks returns a AuditSinkInformer.
-func (v *version) AuditSinks() AuditSinkInformer {
-	return &auditSinkInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
-}

informers/factory.go

@@ -28,7 +28,6 @@ import (
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
 	admissionregistration "k8s.io/client-go/informers/admissionregistration"
 	apps "k8s.io/client-go/informers/apps"
-	auditregistration "k8s.io/client-go/informers/auditregistration"
 	autoscaling "k8s.io/client-go/informers/autoscaling"
 	batch "k8s.io/client-go/informers/batch"
 	certificates "k8s.io/client-go/informers/certificates"
@@ -189,7 +188,6 @@ type SharedInformerFactory interface {
 
 	Admissionregistration() admissionregistration.Interface
 	Apps() apps.Interface
-	Auditregistration() auditregistration.Interface
 	Autoscaling() autoscaling.Interface
 	Batch() batch.Interface
 	Certificates() certificates.Interface
@@ -213,10 +211,6 @@ func (f *sharedInformerFactory) Apps() apps.Interface {
 	return apps.New(f, f.namespace, f.tweakListOptions)
 }
 
-func (f *sharedInformerFactory) Auditregistration() auditregistration.Interface {
-	return auditregistration.New(f, f.namespace, f.tweakListOptions)
-}
-
 func (f *sharedInformerFactory) Autoscaling() autoscaling.Interface {
 	return autoscaling.New(f, f.namespace, f.tweakListOptions)
 }

informers/generic.go

@@ -26,7 +26,6 @@ import (
 	v1 "k8s.io/api/apps/v1"
 	appsv1beta1 "k8s.io/api/apps/v1beta1"
 	v1beta2 "k8s.io/api/apps/v1beta2"
-	auditregistrationv1alpha1 "k8s.io/api/auditregistration/v1alpha1"
 	autoscalingv1 "k8s.io/api/autoscaling/v1"
 	v2beta1 "k8s.io/api/autoscaling/v2beta1"
 	v2beta2 "k8s.io/api/autoscaling/v2beta2"
@@ -121,10 +120,6 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 	case v1beta2.SchemeGroupVersion.WithResource("statefulsets"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Apps().V1beta2().StatefulSets().Informer()}, nil
 
-		// Group=auditregistration.k8s.io, Version=v1alpha1
-	case auditregistrationv1alpha1.SchemeGroupVersion.WithResource("auditsinks"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Auditregistration().V1alpha1().AuditSinks().Informer()}, nil
-
 		// Group=autoscaling, Version=v1
 	case autoscalingv1.SchemeGroupVersion.WithResource("horizontalpodautoscalers"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Autoscaling().V1().HorizontalPodAutoscalers().Informer()}, nil

informers/internalinterfaces/factory_interfaces.go

@@ -27,7 +27,6 @@ import (
 	cache "k8s.io/client-go/tools/cache"
 )
 
-// NewInformerFunc takes kubernetes.Interface and time.Duration to return a SharedIndexInformer.
 type NewInformerFunc func(kubernetes.Interface, time.Duration) cache.SharedIndexInformer
 
 // SharedInformerFactory a small interface to allow for adding an informer without an import cycle
@@ -36,5 +35,4 @@ type SharedInformerFactory interface {
 	InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
 }
 
-// TweakListOptionsFunc is a function that transforms a v1.ListOptions.
 type TweakListOptionsFunc func(*v1.ListOptions)

kubernetes/clientset.go

@@ -25,7 +25,6 @@ import (
 	appsv1 "k8s.io/client-go/kubernetes/typed/apps/v1"
 	appsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
 	appsv1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2"
-	auditregistrationv1alpha1 "k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1"
 	authenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1"
 	authenticationv1beta1 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
 	authorizationv1 "k8s.io/client-go/kubernetes/typed/authorization/v1"
@@ -67,9 +66,6 @@ type Interface interface {
 	AppsV1() appsv1.AppsV1Interface
 	// Deprecated: please explicitly pick a version if possible.
 	Apps() appsv1.AppsV1Interface
-	AuditregistrationV1alpha1() auditregistrationv1alpha1.AuditregistrationV1alpha1Interface
-	// Deprecated: please explicitly pick a version if possible.
-	Auditregistration() auditregistrationv1alpha1.AuditregistrationV1alpha1Interface
 	AuthenticationV1() authenticationv1.AuthenticationV1Interface
 	// Deprecated: please explicitly pick a version if possible.
 	Authentication() authenticationv1.AuthenticationV1Interface
@@ -137,7 +133,6 @@ type Clientset struct {
 	appsV1beta1                   *appsv1beta1.AppsV1beta1Client
 	appsV1beta2                   *appsv1beta2.AppsV1beta2Client
 	appsV1                        *appsv1.AppsV1Client
-	auditregistrationV1alpha1     *auditregistrationv1alpha1.AuditregistrationV1alpha1Client
 	authenticationV1              *authenticationv1.AuthenticationV1Client
 	authenticationV1beta1         *authenticationv1beta1.AuthenticationV1beta1Client
 	authorizationV1               *authorizationv1.AuthorizationV1Client
@@ -203,17 +198,6 @@ func (c *Clientset) Apps() appsv1.AppsV1Interface {
 	return c.appsV1
 }
 
-// AuditregistrationV1alpha1 retrieves the AuditregistrationV1alpha1Client
-func (c *Clientset) AuditregistrationV1alpha1() auditregistrationv1alpha1.AuditregistrationV1alpha1Interface {
-	return c.auditregistrationV1alpha1
-}
-
-// Deprecated: Auditregistration retrieves the default version of AuditregistrationClient.
-// Please explicitly pick a version.
-func (c *Clientset) Auditregistration() auditregistrationv1alpha1.AuditregistrationV1alpha1Interface {
-	return c.auditregistrationV1alpha1
-}
-
 // AuthenticationV1 retrieves the AuthenticationV1Client
 func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
 	return c.authenticationV1
@@ -470,10 +454,6 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
-	cs.auditregistrationV1alpha1, err = auditregistrationv1alpha1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
 	cs.authenticationV1, err = authenticationv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
@@ -595,7 +575,6 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 	cs.appsV1beta1 = appsv1beta1.NewForConfigOrDie(c)
 	cs.appsV1beta2 = appsv1beta2.NewForConfigOrDie(c)
 	cs.appsV1 = appsv1.NewForConfigOrDie(c)
-	cs.auditregistrationV1alpha1 = auditregistrationv1alpha1.NewForConfigOrDie(c)
 	cs.authenticationV1 = authenticationv1.NewForConfigOrDie(c)
 	cs.authenticationV1beta1 = authenticationv1beta1.NewForConfigOrDie(c)
 	cs.authorizationV1 = authorizationv1.NewForConfigOrDie(c)
@@ -635,7 +614,6 @@ func New(c rest.Interface) *Clientset {
 	cs.appsV1beta1 = appsv1beta1.New(c)
 	cs.appsV1beta2 = appsv1beta2.New(c)
 	cs.appsV1 = appsv1.New(c)
-	cs.auditregistrationV1alpha1 = auditregistrationv1alpha1.New(c)
 	cs.authenticationV1 = authenticationv1.New(c)
 	cs.authenticationV1beta1 = authenticationv1beta1.New(c)
 	cs.authorizationV1 = authorizationv1.New(c)

kubernetes/fake/clientset_generated.go

@@ -34,8 +34,6 @@ import (
 	fakeappsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1/fake"
 	appsv1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2"
 	fakeappsv1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2/fake"
-	auditregistrationv1alpha1 "k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1"
-	fakeauditregistrationv1alpha1 "k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1/fake"
 	authenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1"
 	fakeauthenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1/fake"
 	authenticationv1beta1 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
@@ -168,16 +166,6 @@ func (c *Clientset) Apps() appsv1.AppsV1Interface {
 	return &fakeappsv1.FakeAppsV1{Fake: &c.Fake}
 }
 
-// AuditregistrationV1alpha1 retrieves the AuditregistrationV1alpha1Client
-func (c *Clientset) AuditregistrationV1alpha1() auditregistrationv1alpha1.AuditregistrationV1alpha1Interface {
-	return &fakeauditregistrationv1alpha1.FakeAuditregistrationV1alpha1{Fake: &c.Fake}
-}
-
-// Auditregistration retrieves the AuditregistrationV1alpha1Client
-func (c *Clientset) Auditregistration() auditregistrationv1alpha1.AuditregistrationV1alpha1Interface {
-	return &fakeauditregistrationv1alpha1.FakeAuditregistrationV1alpha1{Fake: &c.Fake}
-}
-
 // AuthenticationV1 retrieves the AuthenticationV1Client
 func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
 	return &fakeauthenticationv1.FakeAuthenticationV1{Fake: &c.Fake}

kubernetes/fake/register.go

@@ -24,7 +24,6 @@ import (
 	appsv1 "k8s.io/api/apps/v1"
 	appsv1beta1 "k8s.io/api/apps/v1beta1"
 	appsv1beta2 "k8s.io/api/apps/v1beta2"
-	auditregistrationv1alpha1 "k8s.io/api/auditregistration/v1alpha1"
 	authenticationv1 "k8s.io/api/authentication/v1"
 	authenticationv1beta1 "k8s.io/api/authentication/v1beta1"
 	authorizationv1 "k8s.io/api/authorization/v1"
@@ -67,7 +66,6 @@ var localSchemeBuilder = runtime.SchemeBuilder{
 	appsv1beta1.AddToScheme,
 	appsv1beta2.AddToScheme,
 	appsv1.AddToScheme,
-	auditregistrationv1alpha1.AddToScheme,
 	authenticationv1.AddToScheme,
 	authenticationv1beta1.AddToScheme,
 	authorizationv1.AddToScheme,

kubernetes/scheme/register.go

@@ -24,7 +24,6 @@ import (
 	appsv1 "k8s.io/api/apps/v1"
 	appsv1beta1 "k8s.io/api/apps/v1beta1"
 	appsv1beta2 "k8s.io/api/apps/v1beta2"
-	auditregistrationv1alpha1 "k8s.io/api/auditregistration/v1alpha1"
 	authenticationv1 "k8s.io/api/authentication/v1"
 	authenticationv1beta1 "k8s.io/api/authentication/v1beta1"
 	authorizationv1 "k8s.io/api/authorization/v1"
@@ -67,7 +66,6 @@ var localSchemeBuilder = runtime.SchemeBuilder{
 	appsv1beta1.AddToScheme,
 	appsv1beta2.AddToScheme,
 	appsv1.AddToScheme,
-	auditregistrationv1alpha1.AddToScheme,
 	authenticationv1.AddToScheme,
 	authenticationv1beta1.AddToScheme,
 	authorizationv1.AddToScheme,

kubernetes/typed/admissionregistration/v1alpha1/fake/fake_initializerconfiguration.go

@@ -112,7 +112,7 @@ func (c *FakeInitializerConfigurations) DeleteCollection(options *v1.DeleteOptio
 // Patch applies the patch and returns the patched initializerConfiguration.
 func (c *FakeInitializerConfigurations) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.InitializerConfiguration, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(initializerconfigurationsResource, name, pt, data, subresources...), &v1alpha1.InitializerConfiguration{})
+		Invokes(testing.NewRootPatchSubresourceAction(initializerconfigurationsResource, name, data, subresources...), &v1alpha1.InitializerConfiguration{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/admissionregistration/v1beta1/fake/fake_mutatingwebhookconfiguration.go

@@ -112,7 +112,7 @@ func (c *FakeMutatingWebhookConfigurations) DeleteCollection(options *v1.DeleteO
 // Patch applies the patch and returns the patched mutatingWebhookConfiguration.
 func (c *FakeMutatingWebhookConfigurations) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.MutatingWebhookConfiguration, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(mutatingwebhookconfigurationsResource, name, pt, data, subresources...), &v1beta1.MutatingWebhookConfiguration{})
+		Invokes(testing.NewRootPatchSubresourceAction(mutatingwebhookconfigurationsResource, name, data, subresources...), &v1beta1.MutatingWebhookConfiguration{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/admissionregistration/v1beta1/fake/fake_validatingwebhookconfiguration.go

@@ -112,7 +112,7 @@ func (c *FakeValidatingWebhookConfigurations) DeleteCollection(options *v1.Delet
 // Patch applies the patch and returns the patched validatingWebhookConfiguration.
 func (c *FakeValidatingWebhookConfigurations) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ValidatingWebhookConfiguration, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(validatingwebhookconfigurationsResource, name, pt, data, subresources...), &v1beta1.ValidatingWebhookConfiguration{})
+		Invokes(testing.NewRootPatchSubresourceAction(validatingwebhookconfigurationsResource, name, data, subresources...), &v1beta1.ValidatingWebhookConfiguration{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/apps/v1/fake/fake_controllerrevision.go

@@ -119,7 +119,7 @@ func (c *FakeControllerRevisions) DeleteCollection(options *v1.DeleteOptions, li
 // Patch applies the patch and returns the patched controllerRevision.
 func (c *FakeControllerRevisions) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *appsv1.ControllerRevision, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(controllerrevisionsResource, c.ns, name, pt, data, subresources...), &appsv1.ControllerRevision{})
+		Invokes(testing.NewPatchSubresourceAction(controllerrevisionsResource, c.ns, name, data, subresources...), &appsv1.ControllerRevision{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1/fake/fake_daemonset.go

@@ -131,7 +131,7 @@ func (c *FakeDaemonSets) DeleteCollection(options *v1.DeleteOptions, listOptions
 // Patch applies the patch and returns the patched daemonSet.
 func (c *FakeDaemonSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *appsv1.DaemonSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(daemonsetsResource, c.ns, name, pt, data, subresources...), &appsv1.DaemonSet{})
+		Invokes(testing.NewPatchSubresourceAction(daemonsetsResource, c.ns, name, data, subresources...), &appsv1.DaemonSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1/fake/fake_deployment.go

@@ -131,7 +131,7 @@ func (c *FakeDeployments) DeleteCollection(options *v1.DeleteOptions, listOption
 // Patch applies the patch and returns the patched deployment.
 func (c *FakeDeployments) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *appsv1.Deployment, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, pt, data, subresources...), &appsv1.Deployment{})
+		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, data, subresources...), &appsv1.Deployment{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1/fake/fake_replicaset.go

@@ -131,7 +131,7 @@ func (c *FakeReplicaSets) DeleteCollection(options *v1.DeleteOptions, listOption
 // Patch applies the patch and returns the patched replicaSet.
 func (c *FakeReplicaSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *appsv1.ReplicaSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(replicasetsResource, c.ns, name, pt, data, subresources...), &appsv1.ReplicaSet{})
+		Invokes(testing.NewPatchSubresourceAction(replicasetsResource, c.ns, name, data, subresources...), &appsv1.ReplicaSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1/fake/fake_statefulset.go

@@ -131,7 +131,7 @@ func (c *FakeStatefulSets) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched statefulSet.
 func (c *FakeStatefulSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *appsv1.StatefulSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(statefulsetsResource, c.ns, name, pt, data, subresources...), &appsv1.StatefulSet{})
+		Invokes(testing.NewPatchSubresourceAction(statefulsetsResource, c.ns, name, data, subresources...), &appsv1.StatefulSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1beta1/fake/fake_controllerrevision.go

@@ -119,7 +119,7 @@ func (c *FakeControllerRevisions) DeleteCollection(options *v1.DeleteOptions, li
 // Patch applies the patch and returns the patched controllerRevision.
 func (c *FakeControllerRevisions) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ControllerRevision, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(controllerrevisionsResource, c.ns, name, pt, data, subresources...), &v1beta1.ControllerRevision{})
+		Invokes(testing.NewPatchSubresourceAction(controllerrevisionsResource, c.ns, name, data, subresources...), &v1beta1.ControllerRevision{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1beta1/fake/fake_deployment.go

@@ -131,7 +131,7 @@ func (c *FakeDeployments) DeleteCollection(options *v1.DeleteOptions, listOption
 // Patch applies the patch and returns the patched deployment.
 func (c *FakeDeployments) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Deployment, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, pt, data, subresources...), &v1beta1.Deployment{})
+		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, data, subresources...), &v1beta1.Deployment{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1beta1/fake/fake_statefulset.go

@@ -131,7 +131,7 @@ func (c *FakeStatefulSets) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched statefulSet.
 func (c *FakeStatefulSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.StatefulSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(statefulsetsResource, c.ns, name, pt, data, subresources...), &v1beta1.StatefulSet{})
+		Invokes(testing.NewPatchSubresourceAction(statefulsetsResource, c.ns, name, data, subresources...), &v1beta1.StatefulSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1beta2/fake/fake_controllerrevision.go

@@ -119,7 +119,7 @@ func (c *FakeControllerRevisions) DeleteCollection(options *v1.DeleteOptions, li
 // Patch applies the patch and returns the patched controllerRevision.
 func (c *FakeControllerRevisions) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.ControllerRevision, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(controllerrevisionsResource, c.ns, name, pt, data, subresources...), &v1beta2.ControllerRevision{})
+		Invokes(testing.NewPatchSubresourceAction(controllerrevisionsResource, c.ns, name, data, subresources...), &v1beta2.ControllerRevision{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1beta2/fake/fake_daemonset.go

@@ -131,7 +131,7 @@ func (c *FakeDaemonSets) DeleteCollection(options *v1.DeleteOptions, listOptions
 // Patch applies the patch and returns the patched daemonSet.
 func (c *FakeDaemonSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.DaemonSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(daemonsetsResource, c.ns, name, pt, data, subresources...), &v1beta2.DaemonSet{})
+		Invokes(testing.NewPatchSubresourceAction(daemonsetsResource, c.ns, name, data, subresources...), &v1beta2.DaemonSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1beta2/fake/fake_deployment.go

@@ -131,7 +131,7 @@ func (c *FakeDeployments) DeleteCollection(options *v1.DeleteOptions, listOption
 // Patch applies the patch and returns the patched deployment.
 func (c *FakeDeployments) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.Deployment, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, pt, data, subresources...), &v1beta2.Deployment{})
+		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, data, subresources...), &v1beta2.Deployment{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1beta2/fake/fake_replicaset.go

@@ -131,7 +131,7 @@ func (c *FakeReplicaSets) DeleteCollection(options *v1.DeleteOptions, listOption
 // Patch applies the patch and returns the patched replicaSet.
 func (c *FakeReplicaSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.ReplicaSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(replicasetsResource, c.ns, name, pt, data, subresources...), &v1beta2.ReplicaSet{})
+		Invokes(testing.NewPatchSubresourceAction(replicasetsResource, c.ns, name, data, subresources...), &v1beta2.ReplicaSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/apps/v1beta2/fake/fake_statefulset.go

@@ -131,7 +131,7 @@ func (c *FakeStatefulSets) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched statefulSet.
 func (c *FakeStatefulSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.StatefulSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(statefulsetsResource, c.ns, name, pt, data, subresources...), &v1beta2.StatefulSet{})
+		Invokes(testing.NewPatchSubresourceAction(statefulsetsResource, c.ns, name, data, subresources...), &v1beta2.StatefulSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/auditregistration/v1alpha1/auditregistration_client.go

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

kubernetes/typed/auditregistration/v1alpha1/auditsink.go

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

kubernetes/typed/auditregistration/v1alpha1/fake/doc.go

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

kubernetes/typed/auditregistration/v1alpha1/fake/fake_auditregistration_client.go

@@ -1,40 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package fake
-
-import (
-	v1alpha1 "k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1"
-	rest "k8s.io/client-go/rest"
-	testing "k8s.io/client-go/testing"
-)
-
-type FakeAuditregistrationV1alpha1 struct {
-	*testing.Fake
-}
-
-func (c *FakeAuditregistrationV1alpha1) AuditSinks() v1alpha1.AuditSinkInterface {
-	return &FakeAuditSinks{c}
-}
-
-// RESTClient returns a RESTClient that is used to communicate
-// with API server by this client implementation.
-func (c *FakeAuditregistrationV1alpha1) RESTClient() rest.Interface {
-	var ret *rest.RESTClient
-	return ret
-}

kubernetes/typed/auditregistration/v1alpha1/fake/fake_auditsink.go

@@ -1,120 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by client-gen. DO NOT EDIT.
-
-package fake
-
-import (
-	v1alpha1 "k8s.io/api/auditregistration/v1alpha1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	labels "k8s.io/apimachinery/pkg/labels"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	types "k8s.io/apimachinery/pkg/types"
-	watch "k8s.io/apimachinery/pkg/watch"
-	testing "k8s.io/client-go/testing"
-)
-
-// FakeAuditSinks implements AuditSinkInterface
-type FakeAuditSinks struct {
-	Fake *FakeAuditregistrationV1alpha1
-}
-
-var auditsinksResource = schema.GroupVersionResource{Group: "auditregistration.k8s.io", Version: "v1alpha1", Resource: "auditsinks"}
-
-var auditsinksKind = schema.GroupVersionKind{Group: "auditregistration.k8s.io", Version: "v1alpha1", Kind: "AuditSink"}
-
-// Get takes name of the auditSink, and returns the corresponding auditSink object, and an error if there is any.
-func (c *FakeAuditSinks) Get(name string, options v1.GetOptions) (result *v1alpha1.AuditSink, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootGetAction(auditsinksResource, name), &v1alpha1.AuditSink{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.AuditSink), err
-}
-
-// List takes label and field selectors, and returns the list of AuditSinks that match those selectors.
-func (c *FakeAuditSinks) List(opts v1.ListOptions) (result *v1alpha1.AuditSinkList, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootListAction(auditsinksResource, auditsinksKind, opts), &v1alpha1.AuditSinkList{})
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &v1alpha1.AuditSinkList{ListMeta: obj.(*v1alpha1.AuditSinkList).ListMeta}
-	for _, item := range obj.(*v1alpha1.AuditSinkList).Items {
-		if label.Matches(labels.Set(item.Labels)) {
-			list.Items = append(list.Items, item)
-		}
-	}
-	return list, err
-}
-
-// Watch returns a watch.Interface that watches the requested auditSinks.
-func (c *FakeAuditSinks) Watch(opts v1.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewRootWatchAction(auditsinksResource, opts))
-}
-
-// Create takes the representation of a auditSink and creates it.  Returns the server's representation of the auditSink, and an error, if there is any.
-func (c *FakeAuditSinks) Create(auditSink *v1alpha1.AuditSink) (result *v1alpha1.AuditSink, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootCreateAction(auditsinksResource, auditSink), &v1alpha1.AuditSink{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.AuditSink), err
-}
-
-// Update takes the representation of a auditSink and updates it. Returns the server's representation of the auditSink, and an error, if there is any.
-func (c *FakeAuditSinks) Update(auditSink *v1alpha1.AuditSink) (result *v1alpha1.AuditSink, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootUpdateAction(auditsinksResource, auditSink), &v1alpha1.AuditSink{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.AuditSink), err
-}
-
-// Delete takes name of the auditSink and deletes it. Returns an error if one occurs.
-func (c *FakeAuditSinks) Delete(name string, options *v1.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewRootDeleteAction(auditsinksResource, name), &v1alpha1.AuditSink{})
-	return err
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *FakeAuditSinks) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	action := testing.NewRootDeleteCollectionAction(auditsinksResource, listOptions)
-
-	_, err := c.Fake.Invokes(action, &v1alpha1.AuditSinkList{})
-	return err
-}
-
-// Patch applies the patch and returns the patched auditSink.
-func (c *FakeAuditSinks) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.AuditSink, err error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(auditsinksResource, name, pt, data, subresources...), &v1alpha1.AuditSink{})
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1alpha1.AuditSink), err
-}

kubernetes/typed/auditregistration/v1alpha1/generated_expansion.go

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

kubernetes/typed/autoscaling/v1/fake/fake_horizontalpodautoscaler.go

@@ -131,7 +131,7 @@ func (c *FakeHorizontalPodAutoscalers) DeleteCollection(options *v1.DeleteOption
 // Patch applies the patch and returns the patched horizontalPodAutoscaler.
 func (c *FakeHorizontalPodAutoscalers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *autoscalingv1.HorizontalPodAutoscaler, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(horizontalpodautoscalersResource, c.ns, name, pt, data, subresources...), &autoscalingv1.HorizontalPodAutoscaler{})
+		Invokes(testing.NewPatchSubresourceAction(horizontalpodautoscalersResource, c.ns, name, data, subresources...), &autoscalingv1.HorizontalPodAutoscaler{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/autoscaling/v2beta1/fake/fake_horizontalpodautoscaler.go

@@ -131,7 +131,7 @@ func (c *FakeHorizontalPodAutoscalers) DeleteCollection(options *v1.DeleteOption
 // Patch applies the patch and returns the patched horizontalPodAutoscaler.
 func (c *FakeHorizontalPodAutoscalers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v2beta1.HorizontalPodAutoscaler, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(horizontalpodautoscalersResource, c.ns, name, pt, data, subresources...), &v2beta1.HorizontalPodAutoscaler{})
+		Invokes(testing.NewPatchSubresourceAction(horizontalpodautoscalersResource, c.ns, name, data, subresources...), &v2beta1.HorizontalPodAutoscaler{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/autoscaling/v2beta2/fake/fake_horizontalpodautoscaler.go

@@ -131,7 +131,7 @@ func (c *FakeHorizontalPodAutoscalers) DeleteCollection(options *v1.DeleteOption
 // Patch applies the patch and returns the patched horizontalPodAutoscaler.
 func (c *FakeHorizontalPodAutoscalers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v2beta2.HorizontalPodAutoscaler, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(horizontalpodautoscalersResource, c.ns, name, pt, data, subresources...), &v2beta2.HorizontalPodAutoscaler{})
+		Invokes(testing.NewPatchSubresourceAction(horizontalpodautoscalersResource, c.ns, name, data, subresources...), &v2beta2.HorizontalPodAutoscaler{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/batch/v1/fake/fake_job.go

@@ -131,7 +131,7 @@ func (c *FakeJobs) DeleteCollection(options *v1.DeleteOptions, listOptions v1.Li
 // Patch applies the patch and returns the patched job.
 func (c *FakeJobs) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *batchv1.Job, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(jobsResource, c.ns, name, pt, data, subresources...), &batchv1.Job{})
+		Invokes(testing.NewPatchSubresourceAction(jobsResource, c.ns, name, data, subresources...), &batchv1.Job{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/batch/v1beta1/fake/fake_cronjob.go

@@ -131,7 +131,7 @@ func (c *FakeCronJobs) DeleteCollection(options *v1.DeleteOptions, listOptions v
 // Patch applies the patch and returns the patched cronJob.
 func (c *FakeCronJobs) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.CronJob, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(cronjobsResource, c.ns, name, pt, data, subresources...), &v1beta1.CronJob{})
+		Invokes(testing.NewPatchSubresourceAction(cronjobsResource, c.ns, name, data, subresources...), &v1beta1.CronJob{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/batch/v2alpha1/fake/fake_cronjob.go

@@ -131,7 +131,7 @@ func (c *FakeCronJobs) DeleteCollection(options *v1.DeleteOptions, listOptions v
 // Patch applies the patch and returns the patched cronJob.
 func (c *FakeCronJobs) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v2alpha1.CronJob, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(cronjobsResource, c.ns, name, pt, data, subresources...), &v2alpha1.CronJob{})
+		Invokes(testing.NewPatchSubresourceAction(cronjobsResource, c.ns, name, data, subresources...), &v2alpha1.CronJob{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/certificates/v1beta1/fake/fake_certificatesigningrequest.go

@@ -123,7 +123,7 @@ func (c *FakeCertificateSigningRequests) DeleteCollection(options *v1.DeleteOpti
 // Patch applies the patch and returns the patched certificateSigningRequest.
 func (c *FakeCertificateSigningRequests) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.CertificateSigningRequest, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(certificatesigningrequestsResource, name, pt, data, subresources...), &v1beta1.CertificateSigningRequest{})
+		Invokes(testing.NewRootPatchSubresourceAction(certificatesigningrequestsResource, name, data, subresources...), &v1beta1.CertificateSigningRequest{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/coordination/v1beta1/fake/fake_lease.go

@@ -119,7 +119,7 @@ func (c *FakeLeases) DeleteCollection(options *v1.DeleteOptions, listOptions v1.
 // Patch applies the patch and returns the patched lease.
 func (c *FakeLeases) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Lease, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(leasesResource, c.ns, name, pt, data, subresources...), &v1beta1.Lease{})
+		Invokes(testing.NewPatchSubresourceAction(leasesResource, c.ns, name, data, subresources...), &v1beta1.Lease{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_componentstatus.go

@@ -112,7 +112,7 @@ func (c *FakeComponentStatuses) DeleteCollection(options *v1.DeleteOptions, list
 // Patch applies the patch and returns the patched componentStatus.
 func (c *FakeComponentStatuses) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ComponentStatus, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(componentstatusesResource, name, pt, data, subresources...), &corev1.ComponentStatus{})
+		Invokes(testing.NewRootPatchSubresourceAction(componentstatusesResource, name, data, subresources...), &corev1.ComponentStatus{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/core/v1/fake/fake_configmap.go

@@ -119,7 +119,7 @@ func (c *FakeConfigMaps) DeleteCollection(options *v1.DeleteOptions, listOptions
 // Patch applies the patch and returns the patched configMap.
 func (c *FakeConfigMaps) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ConfigMap, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(configmapsResource, c.ns, name, pt, data, subresources...), &corev1.ConfigMap{})
+		Invokes(testing.NewPatchSubresourceAction(configmapsResource, c.ns, name, data, subresources...), &corev1.ConfigMap{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_endpoints.go

@@ -119,7 +119,7 @@ func (c *FakeEndpoints) DeleteCollection(options *v1.DeleteOptions, listOptions
 // Patch applies the patch and returns the patched endpoints.
 func (c *FakeEndpoints) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Endpoints, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(endpointsResource, c.ns, name, pt, data, subresources...), &corev1.Endpoints{})
+		Invokes(testing.NewPatchSubresourceAction(endpointsResource, c.ns, name, data, subresources...), &corev1.Endpoints{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_event.go

@@ -119,7 +119,7 @@ func (c *FakeEvents) DeleteCollection(options *v1.DeleteOptions, listOptions v1.
 // Patch applies the patch and returns the patched event.
 func (c *FakeEvents) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Event, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(eventsResource, c.ns, name, pt, data, subresources...), &corev1.Event{})
+		Invokes(testing.NewPatchSubresourceAction(eventsResource, c.ns, name, data, subresources...), &corev1.Event{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_event_expansion.go

@@ -21,7 +21,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/runtime"
-	types "k8s.io/apimachinery/pkg/types"
 	core "k8s.io/client-go/testing"
 )
 
@@ -53,13 +52,10 @@ func (c *FakeEvents) UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error
 }
 
 // PatchWithEventNamespace patches an existing event. Returns the copy of the event the server returns, or an error.
-// TODO: Should take a PatchType as an argument probably.
 func (c *FakeEvents) PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.Event, error) {
-	// TODO: Should be configurable to support additional patch strategies.
-	pt := types.StrategicMergePatchType
-	action := core.NewRootPatchAction(eventsResource, event.Name, pt, data)
+	action := core.NewRootPatchAction(eventsResource, event.Name, data)
 	if c.ns != "" {
-		action = core.NewPatchAction(eventsResource, c.ns, event.Name, pt, data)
+		action = core.NewPatchAction(eventsResource, c.ns, event.Name, data)
 	}
 	obj, err := c.Fake.Invokes(action, event)
 	if obj == nil {

kubernetes/typed/core/v1/fake/fake_limitrange.go

@@ -119,7 +119,7 @@ func (c *FakeLimitRanges) DeleteCollection(options *v1.DeleteOptions, listOption
 // Patch applies the patch and returns the patched limitRange.
 func (c *FakeLimitRanges) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.LimitRange, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(limitrangesResource, c.ns, name, pt, data, subresources...), &corev1.LimitRange{})
+		Invokes(testing.NewPatchSubresourceAction(limitrangesResource, c.ns, name, data, subresources...), &corev1.LimitRange{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_namespace.go

@@ -115,7 +115,7 @@ func (c *FakeNamespaces) Delete(name string, options *v1.DeleteOptions) error {
 // Patch applies the patch and returns the patched namespace.
 func (c *FakeNamespaces) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Namespace, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(namespacesResource, name, pt, data, subresources...), &corev1.Namespace{})
+		Invokes(testing.NewRootPatchSubresourceAction(namespacesResource, name, data, subresources...), &corev1.Namespace{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/core/v1/fake/fake_node.go

@@ -123,7 +123,7 @@ func (c *FakeNodes) DeleteCollection(options *v1.DeleteOptions, listOptions v1.L
 // Patch applies the patch and returns the patched node.
 func (c *FakeNodes) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Node, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(nodesResource, name, pt, data, subresources...), &corev1.Node{})
+		Invokes(testing.NewRootPatchSubresourceAction(nodesResource, name, data, subresources...), &corev1.Node{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/core/v1/fake/fake_node_expansion.go

@@ -18,16 +18,12 @@ package fake
 
 import (
 	"k8s.io/api/core/v1"
-	types "k8s.io/apimachinery/pkg/types"
 	core "k8s.io/client-go/testing"
 )
 
-// TODO: Should take a PatchType as an argument probably.
 func (c *FakeNodes) PatchStatus(nodeName string, data []byte) (*v1.Node, error) {
-	// TODO: Should be configurable to support additional patch strategies.
-	pt := types.StrategicMergePatchType
 	obj, err := c.Fake.Invokes(
-		core.NewRootPatchSubresourceAction(nodesResource, nodeName, pt, data, "status"), &v1.Node{})
+		core.NewRootPatchSubresourceAction(nodesResource, nodeName, data, "status"), &v1.Node{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/core/v1/fake/fake_persistentvolume.go

@@ -123,7 +123,7 @@ func (c *FakePersistentVolumes) DeleteCollection(options *v1.DeleteOptions, list
 // Patch applies the patch and returns the patched persistentVolume.
 func (c *FakePersistentVolumes) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.PersistentVolume, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(persistentvolumesResource, name, pt, data, subresources...), &corev1.PersistentVolume{})
+		Invokes(testing.NewRootPatchSubresourceAction(persistentvolumesResource, name, data, subresources...), &corev1.PersistentVolume{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/core/v1/fake/fake_persistentvolumeclaim.go

@@ -131,7 +131,7 @@ func (c *FakePersistentVolumeClaims) DeleteCollection(options *v1.DeleteOptions,
 // Patch applies the patch and returns the patched persistentVolumeClaim.
 func (c *FakePersistentVolumeClaims) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.PersistentVolumeClaim, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(persistentvolumeclaimsResource, c.ns, name, pt, data, subresources...), &corev1.PersistentVolumeClaim{})
+		Invokes(testing.NewPatchSubresourceAction(persistentvolumeclaimsResource, c.ns, name, data, subresources...), &corev1.PersistentVolumeClaim{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_pod.go

@@ -131,7 +131,7 @@ func (c *FakePods) DeleteCollection(options *v1.DeleteOptions, listOptions v1.Li
 // Patch applies the patch and returns the patched pod.
 func (c *FakePods) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Pod, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(podsResource, c.ns, name, pt, data, subresources...), &corev1.Pod{})
+		Invokes(testing.NewPatchSubresourceAction(podsResource, c.ns, name, data, subresources...), &corev1.Pod{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_pod_expansion.go

@@ -26,31 +26,20 @@ import (
 func (c *FakePods) Bind(binding *v1.Binding) error {
 	action := core.CreateActionImpl{}
 	action.Verb = "create"
-	action.Namespace = binding.Namespace
 	action.Resource = podsResource
-	action.Subresource = "binding"
+	action.Subresource = "bindings"
 	action.Object = binding
 
 	_, err := c.Fake.Invokes(action, binding)
 	return err
 }
 
-func (c *FakePods) GetBinding(name string) (result *v1.Binding, err error) {
-	obj, err := c.Fake.
-		Invokes(core.NewGetSubresourceAction(podsResource, c.ns, "binding", name), &v1.Binding{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*v1.Binding), err
-}
-
 func (c *FakePods) GetLogs(name string, opts *v1.PodLogOptions) *restclient.Request {
 	action := core.GenericActionImpl{}
 	action.Verb = "get"
 	action.Namespace = c.ns
 	action.Resource = podsResource
-	action.Subresource = "log"
+	action.Subresource = "logs"
 	action.Value = opts
 
 	_, _ = c.Fake.Invokes(action, &v1.Pod{})

kubernetes/typed/core/v1/fake/fake_podtemplate.go

@@ -119,7 +119,7 @@ func (c *FakePodTemplates) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched podTemplate.
 func (c *FakePodTemplates) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.PodTemplate, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(podtemplatesResource, c.ns, name, pt, data, subresources...), &corev1.PodTemplate{})
+		Invokes(testing.NewPatchSubresourceAction(podtemplatesResource, c.ns, name, data, subresources...), &corev1.PodTemplate{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_replicationcontroller.go

@@ -132,7 +132,7 @@ func (c *FakeReplicationControllers) DeleteCollection(options *v1.DeleteOptions,
 // Patch applies the patch and returns the patched replicationController.
 func (c *FakeReplicationControllers) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ReplicationController, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(replicationcontrollersResource, c.ns, name, pt, data, subresources...), &corev1.ReplicationController{})
+		Invokes(testing.NewPatchSubresourceAction(replicationcontrollersResource, c.ns, name, data, subresources...), &corev1.ReplicationController{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_resourcequota.go

@@ -131,7 +131,7 @@ func (c *FakeResourceQuotas) DeleteCollection(options *v1.DeleteOptions, listOpt
 // Patch applies the patch and returns the patched resourceQuota.
 func (c *FakeResourceQuotas) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ResourceQuota, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(resourcequotasResource, c.ns, name, pt, data, subresources...), &corev1.ResourceQuota{})
+		Invokes(testing.NewPatchSubresourceAction(resourcequotasResource, c.ns, name, data, subresources...), &corev1.ResourceQuota{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_secret.go

@@ -119,7 +119,7 @@ func (c *FakeSecrets) DeleteCollection(options *v1.DeleteOptions, listOptions v1
 // Patch applies the patch and returns the patched secret.
 func (c *FakeSecrets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Secret, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(secretsResource, c.ns, name, pt, data, subresources...), &corev1.Secret{})
+		Invokes(testing.NewPatchSubresourceAction(secretsResource, c.ns, name, data, subresources...), &corev1.Secret{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_service.go

@@ -123,7 +123,7 @@ func (c *FakeServices) Delete(name string, options *v1.DeleteOptions) error {
 // Patch applies the patch and returns the patched service.
 func (c *FakeServices) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.Service, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(servicesResource, c.ns, name, pt, data, subresources...), &corev1.Service{})
+		Invokes(testing.NewPatchSubresourceAction(servicesResource, c.ns, name, data, subresources...), &corev1.Service{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/core/v1/fake/fake_serviceaccount.go

@@ -119,7 +119,7 @@ func (c *FakeServiceAccounts) DeleteCollection(options *v1.DeleteOptions, listOp
 // Patch applies the patch and returns the patched serviceAccount.
 func (c *FakeServiceAccounts) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *corev1.ServiceAccount, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(serviceaccountsResource, c.ns, name, pt, data, subresources...), &corev1.ServiceAccount{})
+		Invokes(testing.NewPatchSubresourceAction(serviceaccountsResource, c.ns, name, data, subresources...), &corev1.ServiceAccount{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/events/v1beta1/fake/fake_event.go

@@ -119,7 +119,7 @@ func (c *FakeEvents) DeleteCollection(options *v1.DeleteOptions, listOptions v1.
 // Patch applies the patch and returns the patched event.
 func (c *FakeEvents) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Event, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(eventsResource, c.ns, name, pt, data, subresources...), &v1beta1.Event{})
+		Invokes(testing.NewPatchSubresourceAction(eventsResource, c.ns, name, data, subresources...), &v1beta1.Event{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/extensions/v1beta1/fake/fake_daemonset.go

@@ -131,7 +131,7 @@ func (c *FakeDaemonSets) DeleteCollection(options *v1.DeleteOptions, listOptions
 // Patch applies the patch and returns the patched daemonSet.
 func (c *FakeDaemonSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.DaemonSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(daemonsetsResource, c.ns, name, pt, data, subresources...), &v1beta1.DaemonSet{})
+		Invokes(testing.NewPatchSubresourceAction(daemonsetsResource, c.ns, name, data, subresources...), &v1beta1.DaemonSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/extensions/v1beta1/fake/fake_deployment.go

@@ -131,7 +131,7 @@ func (c *FakeDeployments) DeleteCollection(options *v1.DeleteOptions, listOption
 // Patch applies the patch and returns the patched deployment.
 func (c *FakeDeployments) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Deployment, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, pt, data, subresources...), &v1beta1.Deployment{})
+		Invokes(testing.NewPatchSubresourceAction(deploymentsResource, c.ns, name, data, subresources...), &v1beta1.Deployment{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/extensions/v1beta1/fake/fake_ingress.go

@@ -131,7 +131,7 @@ func (c *FakeIngresses) DeleteCollection(options *v1.DeleteOptions, listOptions
 // Patch applies the patch and returns the patched ingress.
 func (c *FakeIngresses) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Ingress, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(ingressesResource, c.ns, name, pt, data, subresources...), &v1beta1.Ingress{})
+		Invokes(testing.NewPatchSubresourceAction(ingressesResource, c.ns, name, data, subresources...), &v1beta1.Ingress{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/extensions/v1beta1/fake/fake_podsecuritypolicy.go

@@ -112,7 +112,7 @@ func (c *FakePodSecurityPolicies) DeleteCollection(options *v1.DeleteOptions, li
 // Patch applies the patch and returns the patched podSecurityPolicy.
 func (c *FakePodSecurityPolicies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.PodSecurityPolicy, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(podsecuritypoliciesResource, name, pt, data, subresources...), &v1beta1.PodSecurityPolicy{})
+		Invokes(testing.NewRootPatchSubresourceAction(podsecuritypoliciesResource, name, data, subresources...), &v1beta1.PodSecurityPolicy{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/extensions/v1beta1/fake/fake_replicaset.go

@@ -131,7 +131,7 @@ func (c *FakeReplicaSets) DeleteCollection(options *v1.DeleteOptions, listOption
 // Patch applies the patch and returns the patched replicaSet.
 func (c *FakeReplicaSets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ReplicaSet, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(replicasetsResource, c.ns, name, pt, data, subresources...), &v1beta1.ReplicaSet{})
+		Invokes(testing.NewPatchSubresourceAction(replicasetsResource, c.ns, name, data, subresources...), &v1beta1.ReplicaSet{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/networking/v1/fake/fake_networkpolicy.go

@@ -119,7 +119,7 @@ func (c *FakeNetworkPolicies) DeleteCollection(options *v1.DeleteOptions, listOp
 // Patch applies the patch and returns the patched networkPolicy.
 func (c *FakeNetworkPolicies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *networkingv1.NetworkPolicy, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(networkpoliciesResource, c.ns, name, pt, data, subresources...), &networkingv1.NetworkPolicy{})
+		Invokes(testing.NewPatchSubresourceAction(networkpoliciesResource, c.ns, name, data, subresources...), &networkingv1.NetworkPolicy{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/policy/v1beta1/fake/fake_eviction_expansion.go

@@ -26,9 +26,8 @@ func (c *FakeEvictions) Evict(eviction *policy.Eviction) error {
 	action := core.GetActionImpl{}
 	action.Verb = "post"
 	action.Namespace = c.ns
-	action.Resource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
+	action.Resource = schema.GroupVersionResource{Group: "", Version: "", Resource: "pods"}
 	action.Subresource = "eviction"
-	action.Name = eviction.Name
 	_, err := c.Fake.Invokes(action, eviction)
 	return err
 }

kubernetes/typed/policy/v1beta1/fake/fake_poddisruptionbudget.go

@@ -131,7 +131,7 @@ func (c *FakePodDisruptionBudgets) DeleteCollection(options *v1.DeleteOptions, l
 // Patch applies the patch and returns the patched podDisruptionBudget.
 func (c *FakePodDisruptionBudgets) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.PodDisruptionBudget, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(poddisruptionbudgetsResource, c.ns, name, pt, data, subresources...), &v1beta1.PodDisruptionBudget{})
+		Invokes(testing.NewPatchSubresourceAction(poddisruptionbudgetsResource, c.ns, name, data, subresources...), &v1beta1.PodDisruptionBudget{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/policy/v1beta1/fake/fake_podsecuritypolicy.go

@@ -112,7 +112,7 @@ func (c *FakePodSecurityPolicies) DeleteCollection(options *v1.DeleteOptions, li
 // Patch applies the patch and returns the patched podSecurityPolicy.
 func (c *FakePodSecurityPolicies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.PodSecurityPolicy, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(podsecuritypoliciesResource, name, pt, data, subresources...), &v1beta1.PodSecurityPolicy{})
+		Invokes(testing.NewRootPatchSubresourceAction(podsecuritypoliciesResource, name, data, subresources...), &v1beta1.PodSecurityPolicy{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/rbac/v1/fake/fake_clusterrole.go

@@ -112,7 +112,7 @@ func (c *FakeClusterRoles) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched clusterRole.
 func (c *FakeClusterRoles) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *rbacv1.ClusterRole, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(clusterrolesResource, name, pt, data, subresources...), &rbacv1.ClusterRole{})
+		Invokes(testing.NewRootPatchSubresourceAction(clusterrolesResource, name, data, subresources...), &rbacv1.ClusterRole{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/rbac/v1/fake/fake_clusterrolebinding.go

@@ -112,7 +112,7 @@ func (c *FakeClusterRoleBindings) DeleteCollection(options *v1.DeleteOptions, li
 // Patch applies the patch and returns the patched clusterRoleBinding.
 func (c *FakeClusterRoleBindings) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *rbacv1.ClusterRoleBinding, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(clusterrolebindingsResource, name, pt, data, subresources...), &rbacv1.ClusterRoleBinding{})
+		Invokes(testing.NewRootPatchSubresourceAction(clusterrolebindingsResource, name, data, subresources...), &rbacv1.ClusterRoleBinding{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/rbac/v1/fake/fake_role.go

@@ -119,7 +119,7 @@ func (c *FakeRoles) DeleteCollection(options *v1.DeleteOptions, listOptions v1.L
 // Patch applies the patch and returns the patched role.
 func (c *FakeRoles) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *rbacv1.Role, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(rolesResource, c.ns, name, pt, data, subresources...), &rbacv1.Role{})
+		Invokes(testing.NewPatchSubresourceAction(rolesResource, c.ns, name, data, subresources...), &rbacv1.Role{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/rbac/v1/fake/fake_rolebinding.go

@@ -119,7 +119,7 @@ func (c *FakeRoleBindings) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched roleBinding.
 func (c *FakeRoleBindings) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *rbacv1.RoleBinding, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(rolebindingsResource, c.ns, name, pt, data, subresources...), &rbacv1.RoleBinding{})
+		Invokes(testing.NewPatchSubresourceAction(rolebindingsResource, c.ns, name, data, subresources...), &rbacv1.RoleBinding{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/rbac/v1alpha1/fake/fake_clusterrole.go

@@ -112,7 +112,7 @@ func (c *FakeClusterRoles) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched clusterRole.
 func (c *FakeClusterRoles) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.ClusterRole, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(clusterrolesResource, name, pt, data, subresources...), &v1alpha1.ClusterRole{})
+		Invokes(testing.NewRootPatchSubresourceAction(clusterrolesResource, name, data, subresources...), &v1alpha1.ClusterRole{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/rbac/v1alpha1/fake/fake_clusterrolebinding.go

@@ -112,7 +112,7 @@ func (c *FakeClusterRoleBindings) DeleteCollection(options *v1.DeleteOptions, li
 // Patch applies the patch and returns the patched clusterRoleBinding.
 func (c *FakeClusterRoleBindings) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.ClusterRoleBinding, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(clusterrolebindingsResource, name, pt, data, subresources...), &v1alpha1.ClusterRoleBinding{})
+		Invokes(testing.NewRootPatchSubresourceAction(clusterrolebindingsResource, name, data, subresources...), &v1alpha1.ClusterRoleBinding{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/rbac/v1alpha1/fake/fake_role.go

@@ -119,7 +119,7 @@ func (c *FakeRoles) DeleteCollection(options *v1.DeleteOptions, listOptions v1.L
 // Patch applies the patch and returns the patched role.
 func (c *FakeRoles) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.Role, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(rolesResource, c.ns, name, pt, data, subresources...), &v1alpha1.Role{})
+		Invokes(testing.NewPatchSubresourceAction(rolesResource, c.ns, name, data, subresources...), &v1alpha1.Role{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/rbac/v1alpha1/fake/fake_rolebinding.go

@@ -119,7 +119,7 @@ func (c *FakeRoleBindings) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched roleBinding.
 func (c *FakeRoleBindings) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.RoleBinding, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(rolebindingsResource, c.ns, name, pt, data, subresources...), &v1alpha1.RoleBinding{})
+		Invokes(testing.NewPatchSubresourceAction(rolebindingsResource, c.ns, name, data, subresources...), &v1alpha1.RoleBinding{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/rbac/v1beta1/fake/fake_clusterrole.go

@@ -112,7 +112,7 @@ func (c *FakeClusterRoles) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched clusterRole.
 func (c *FakeClusterRoles) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterRole, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(clusterrolesResource, name, pt, data, subresources...), &v1beta1.ClusterRole{})
+		Invokes(testing.NewRootPatchSubresourceAction(clusterrolesResource, name, data, subresources...), &v1beta1.ClusterRole{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/rbac/v1beta1/fake/fake_clusterrolebinding.go

@@ -112,7 +112,7 @@ func (c *FakeClusterRoleBindings) DeleteCollection(options *v1.DeleteOptions, li
 // Patch applies the patch and returns the patched clusterRoleBinding.
 func (c *FakeClusterRoleBindings) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.ClusterRoleBinding, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewRootPatchSubresourceAction(clusterrolebindingsResource, name, pt, data, subresources...), &v1beta1.ClusterRoleBinding{})
+		Invokes(testing.NewRootPatchSubresourceAction(clusterrolebindingsResource, name, data, subresources...), &v1beta1.ClusterRoleBinding{})
 	if obj == nil {
 		return nil, err
 	}

kubernetes/typed/rbac/v1beta1/fake/fake_role.go

@@ -119,7 +119,7 @@ func (c *FakeRoles) DeleteCollection(options *v1.DeleteOptions, listOptions v1.L
 // Patch applies the patch and returns the patched role.
 func (c *FakeRoles) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.Role, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(rolesResource, c.ns, name, pt, data, subresources...), &v1beta1.Role{})
+		Invokes(testing.NewPatchSubresourceAction(rolesResource, c.ns, name, data, subresources...), &v1beta1.Role{})
 
 	if obj == nil {
 		return nil, err

kubernetes/typed/rbac/v1beta1/fake/fake_rolebinding.go

@@ -119,7 +119,7 @@ func (c *FakeRoleBindings) DeleteCollection(options *v1.DeleteOptions, listOptio
 // Patch applies the patch and returns the patched roleBinding.
 func (c *FakeRoleBindings) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.RoleBinding, err error) {
 	obj, err := c.Fake.
-		Invokes(testing.NewPatchSubresourceAction(rolebindingsResource, c.ns, name, pt, data, subresources...), &v1beta1.RoleBinding{})
+		Invokes(testing.NewPatchSubresourceAction(rolebindingsResource, c.ns, name, data, subresources...), &v1beta1.RoleBinding{})
 
 	if obj == nil {
 		return nil, err