Merge pull request #72860 from liggitt/automated-cherry-pick-of-#72856-upstream-release-1.10

Automated cherry pick of #72856: Fix nil panic propagation

Kubernetes-commit: 954ff68d59e9dc62fa8252ffa9023a90ff8a358c

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,3 +1,2 @@
-Sorry, we do not accept changes directly against this repository, unless the
-change is to the `README.md` itself. Please see
-`CONTRIBUTING.md` for information on where and how to contribute instead.
+Sorry, we do not accept changes directly against this repository. Please see 
+CONTRIBUTING.md for information on where and how to contribute instead.

.travis.yml

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

CHANGELOG.md

@@ -1,582 +1,10 @@
 TODO: This document was manually maintained so might be incomplete. The
 automation effort is tracked in
-https://github.com/kubernetes/test-infra/issues/5843.
+https://github.com/kubernetes/client-go/issues/234.
 
 Changes in `k8s.io/api` and `k8s.io/apimachinery` are mentioned here
 because `k8s.io/client-go` depends on them.
 
-# v10.0.0
-
-**Breaking Changes:**
-
-* Action required: client-go will no longer have bootstrap
-(`k8s.io/client-go/tools/bootstrap`) related code. Any reference to it will
-break. Please redirect all references to `k8s.io/bootstrap` instead.
-([#67356](https://github.com/kubernetes/kubernetes/pull/67356))
-
-* The methods `NewSelfSignedCACert` and `NewSignedCert` now use `crypto.Signer`
-interface instead of `rsa.PrivateKey` for certificate creation. This is done
-to allow different kind of private keys (for example: ecdsa).
-([#69329](https://github.com/kubernetes/kubernetes/pull/69329))
-
-* `GetScale` and `UpdateScale` methods have been added for `apps/v1` clients
-and with this, no-verb scale clients have been removed.
-([#70437](https://github.com/kubernetes/kubernetes/pull/70437))
-
-* `k8s.io/client-go/util/cert/triple` package has been removed.
-([#70966](https://github.com/kubernetes/kubernetes/pull/70966))
-
-**New Features:**
-
-* `unfinished_work_microseconds` is added to the workqueue metrics.
-It can be used to detect stuck worker threads (kube-controller-manager runs many workqueues.).
-([#70884](https://github.com/kubernetes/kubernetes/pull/70884))
-
-* A method `GetPorts` is added to expose the ports that were forwarded.
-This can be used to retrieve the locally-bound port in cases where the input was port 0.
-([#67513](https://github.com/kubernetes/kubernetes/pull/67513))
-
-* Dynamic listers and informers, that work with `runtime.Unstructured` objects,
-are added. These are useful for writing generic, non-generated controllers.
-([68748](https://github.com/kubernetes/kubernetes/pull/68748))
-
-* The dynamic fake client now supports JSONPatch.
-([#69330](https://github.com/kubernetes/kubernetes/pull/69330))
-
-* The `GetBinding` method is added for pods in the fake client.
-([#69412](https://github.com/kubernetes/kubernetes/pull/69412))
-
-**Bug fixes and Improvements:**
-
-* The `apiVersion` and action name values for fake evictions are now set.
-([#69035](https://github.com/kubernetes/kubernetes/pull/69035))
-
-* PEM files containing both TLS certificate and key can now be parsed in
-arbitrary order. Previously key was always required to be first.
-([#69536](https://github.com/kubernetes/kubernetes/pull/69536))
-
-* Go clients created from a kubeconfig that specifies a `TokenFile` now
-periodically reload the token from the specified file.
-([#70606](https://github.com/kubernetes/kubernetes/pull/70606))
-
-* It is now ensured that oversized data frames are not written to
-spdystreams in `remotecommand.NewSPDYExecutor`.
-([#70999](https://github.com/kubernetes/kubernetes/pull/70999))
-
-* A panic occuring on calling `scheme.Convert` is fixed by populating the fake
-dynamic client scheme. ([#69125](https://github.com/kubernetes/kubernetes/pull/69125))
-
-* Add step to correctly setup permissions for the in-cluster-client-configuration example.
-([#69232](https://github.com/kubernetes/kubernetes/pull/69232))
-
-* The function `Parallelize` is deprecated. Use `ParallelizeUntil` instead.
-([#68403](https://github.com/kubernetes/kubernetes/pull/68403))
-
-* [k8s.io/apimachinery] Restrict redirect following from the apiserver to
-same-host redirects, and ignore redirects in some cases.
-([#66516](https://github.com/kubernetes/kubernetes/pull/66516))
-
-## API changes
-
-**New Features:**
-
-* GlusterFS PersistentVolumes sources can now reference endpoints in any
-namespace using the `spec.glusterfs.endpointsNamespace` field.
-Ensure all kubelets are upgraded to 1.13+ before using this capability.
-([#60195](https://github.com/kubernetes/kubernetes/pull/60195))
-
-* The [dynamic audit configuration](https://github.com/kubernetes/community/blob/master/keps/sig-auth/0014-dynamic-audit-configuration.md)
-API is added. ([#67547](https://github.com/kubernetes/kubernetes/pull/67547))
-
-* A new field `EnableServiceLinks` is added to the `PodSpec` to indicate whether
-information about services should be injected into pod's environment variables.
-([#68754](https://github.com/kubernetes/kubernetes/pull/68754))
-
-* `CSIPersistentVolume` feature, i.e. `PersistentVolumes` with
-`CSIPersistentVolumeSource`, is GA. `CSIPersistentVolume` feature gate is now
-deprecated and will be removed according to deprecation policy.
-([#69929](https://github.com/kubernetes/kubernetes/pull/69929))
-
-* Raw block volume support is promoted to beta, and enabled by default.
-This is accessible via the `volumeDevices` container field in pod specs,
-and the `volumeMode` field in persistent volume and persistent volume claims definitions.
-([#71167](https://github.com/kubernetes/kubernetes/pull/71167))
-
-**Bug fixes and Improvements:**
-
-* The default value of extensions/v1beta1 Deployment's `RevisionHistoryLimit`
-is set to `MaxInt32`. ([#66605](https://github.com/kubernetes/kubernetes/pull/66605))
-
-* `procMount` field is no longer incorrectly marked as required in openapi schema.
-([#69694](https://github.com/kubernetes/kubernetes/pull/69694))
-
-* The caBundle and service fields in admission webhook API objects now correctly
-indicate they are optional. ([#70138](https://github.com/kubernetes/kubernetes/pull/70138))
-
-# 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:**
-
-* `KUBE_API_VERSIONS` has been removed.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63165](https://github.com/kubernetes/kubernetes/pull/63165)
-
-* The client-go/discovery `RESTMapper` has been moved to client-go/restmapper.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63507](https://github.com/kubernetes/kubernetes/pull/63507)
-
-* `CachedDiscoveryClient` has been moved from kubectl to client-go.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63550](https://github.com/kubernetes/kubernetes/pull/63550)
-
-* The `EventRecorder` interface is changed to include an `AnnotatedEventf` method, which can add annotations to an event.
-
-    * [https://github.com/kubernetes/kubernetes/pull/64213](https://github.com/kubernetes/kubernetes/pull/64213)
-
-* [k8s.io/apimachinery] The deprecated `RepairMalformedUpdates` flag has been removed.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61455](https://github.com/kubernetes/kubernetes/pull/61455)
-
-**New Features:**
-
-* A new easy-to-use dynamic client is added and the old dynamic client is now deprecated.
-
-    * [https://github.com/kubernetes/kubernetes/pull/62913](https://github.com/kubernetes/kubernetes/pull/62913)
-
-* client-go and kubectl now detect and report an error on duplicated name for user, cluster and context, while loading the kubeconfig.
-
-    * [https://github.com/kubernetes/kubernetes/pull/60464](https://github.com/kubernetes/kubernetes/pull/60464)
-
-* The informer code-generator now allows specifying a custom resync period for certain informer types and uses the default resync period if none is specified.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61400](https://github.com/kubernetes/kubernetes/pull/61400)
-
-* Exec authenticator plugin now supports TLS client certificates.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61803](https://github.com/kubernetes/kubernetes/pull/61803)
-
-* The discovery client now has a default request timeout of 32 seconds.
-
-    * [https://github.com/kubernetes/kubernetes/pull/62733](https://github.com/kubernetes/kubernetes/pull/62733)
-
-* The OpenStack auth config from is now read from the client config. If the client config is not available, it falls back to reading from the environment variables.
-
-    * [https://github.com/kubernetes/kubernetes/pull/60200](https://github.com/kubernetes/kubernetes/pull/60200)
-
-* The in-tree support for openstack credentials is now deprecated. Please use the `client-keystone-auth` from the cloud-provider-openstack repository. Details on how to use this new capability is documented [here](https://github.com/kubernetes/cloud-provider-openstack/blob/master/docs/using-client-keystone-auth.md)
-
-    * [https://github.com/kubernetes/kubernetes/pull/64346](https://github.com/kubernetes/kubernetes/pull/64346)
-
-**Bug fixes and Improvements:**
-
-* 406 mime-type errors are now tolerated while attempting to load new openapi schema. This improves compatibility with older servers when creating/updating API objects.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61949](https://github.com/kubernetes/kubernetes/pull/61949)
-
-* Removes the generated `DeleteCollection()` method for `Services` since the API does not support it.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63861](https://github.com/kubernetes/kubernetes/pull/63861)
-
-* Event object references with apiversion now report an apiversion, instead of just the group.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63913](https://github.com/kubernetes/kubernetes/pull/63913)
-
-    [https://github.com/kubernetes/kubernetes/pull/62462](https://github.com/kubernetes/kubernetes/pull/62462)
-
-* [k8s.io/apimachinery] `runtime.Unstructured.UnstructuredContent()` no longer mutates the source while returning the contents.
-
-    * [https://github.com/kubernetes/kubernetes/pull/62063](https://github.com/kubernetes/kubernetes/pull/62063)
-
-* [k8s.io/apimachinery] Incomplete support for `uint64` is now removed. This fixes a panic encountered while using `DeepCopyJSON` with `uint64`.
-
-    * [https://github.com/kubernetes/kubernetes/pull/62981](https://github.com/kubernetes/kubernetes/pull/62981)
-
-* [k8s.io/apimachinery] API server can now parse `propagationPolicy` when it sent as a query parameter sent with a delete request.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63414](https://github.com/kubernetes/kubernetes/pull/63414)
-
-* [k8s.io/apimachinery] APIServices with kube-like versions (e.g. v1, v2beta1, etc.) will be sorted appropriately within each group.
-
-    * [https://github.com/kubernetes/kubernetes/pull/64004](https://github.com/kubernetes/kubernetes/pull/64004)
-
-* [k8s.io/apimachinery] `int64` is the only allowed integer for printers.
-
-    * [https://github.com/kubernetes/kubernetes/pull/64639](https://github.com/kubernetes/kubernetes/pull/64639)
-
-## API changes
-
-**Breaking Changes:**
-
-* Support for `alpha.kubernetes.io/nvidia-gpu` resource which was deprecated in 1.10 is removed. Please use the resource exposed by `DevicePlugins` instead (`nvidia.com/gpu`).
-
-    * [https://github.com/kubernetes/kubernetes/pull/61498](https://github.com/kubernetes/kubernetes/pull/61498)
-
-* Alpha annotation for `PersistentVolume` node affinity has been removed. Update your `PersistentVolume`s to use the beta `PersistentVolume.nodeAffinity` field before upgrading.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61816](https://github.com/kubernetes/kubernetes/pull/61816)
-
-* `ObjectMeta ` `ListOptions` `DeleteOptions` are removed from the core api group. Please use the ones in `meta/v1` instead.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61809](https://github.com/kubernetes/kubernetes/pull/61809)
-
-* `ExternalID` in `NodeSpec` is deprecated. The externalID of the node is no longer set in the Node spec.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61877](https://github.com/kubernetes/kubernetes/pull/61877)
-
-* PSP-related types in the `extensions/v1beta1` API group are now deprecated. It is suggested to use the `policy/v1beta1` API group instead.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61777](https://github.com/kubernetes/kubernetes/pull/61777)
-
-**New Features:**
-
-* `PodSecurityPolicy` now supports restricting hostPath volume mounts to be readOnly and under specific path prefixes.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58647](https://github.com/kubernetes/kubernetes/pull/58647)
-
-* `Node.Spec.ConfigSource.ConfigMap.KubeletConfigKey` must be specified when using dynamic Kubelet config to tell the Kubelet which key of the `ConfigMap` identifies its config file.
-
-    * [https://github.com/kubernetes/kubernetes/pull/59847](https://github.com/kubernetes/kubernetes/pull/59847)
-
-* `serverAddressByClientCIDRs` in `meta/v1` APIGroup is now optional.
-
-    * [https://github.com/kubernetes/kubernetes/pull/61963](https://github.com/kubernetes/kubernetes/pull/61963)
-
-* A new field `MatchFields` is added to `NodeSelectorTerm`. Currently, it only supports `metadata.name`.
-
-    * [https://github.com/kubernetes/kubernetes/pull/62002](https://github.com/kubernetes/kubernetes/pull/62002)
-
-* The `PriorityClass` API is promoted to `scheduling.k8s.io/v1beta1`.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63100](https://github.com/kubernetes/kubernetes/pull/63100)
-
-* The status of dynamic Kubelet config is now reported via `Node.Status.Config`, rather than the `KubeletConfigOk` node condition.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63314](https://github.com/kubernetes/kubernetes/pull/63314)
-
-* The `GitRepo` volume type is deprecated. To provision a container with a git repo, mount an `EmptyDir` into an `InitContainer` that clones the repo using git, then mount the `EmptyDir` into the Pod's container.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63445](https://github.com/kubernetes/kubernetes/pull/63445)
-
-* The Sysctls experimental feature has been promoted to beta (enabled by default via the `Sysctls` feature flag). `PodSecurityPolicy` and `Pod` objects now have fields for specifying and controlling sysctls. Alpha sysctl annotations will be ignored by 1.11+ kubelets. All alpha sysctl annotations in existing deployments must be converted to API fields to be effective.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63717](https://github.com/kubernetes/kubernetes/pull/63717)
-
-* The annotation `service.alpha.kubernetes.io/tolerate-unready-endpoints` is deprecated.  Users should use `Service.spec.publishNotReadyAddresses` instead.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63742](https://github.com/kubernetes/kubernetes/pull/63742)
-
-* `VerticalPodAutoscaler` has been added to `autoscaling/v1` API group.
-
-    * [https://github.com/kubernetes/kubernetes/pull/63797](https://github.com/kubernetes/kubernetes/pull/63797)
-
-* Alpha support is added for dynamic volume limits based on node type.
-
-    * [https://github.com/kubernetes/kubernetes/pull/64154](https://github.com/kubernetes/kubernetes/pull/64154)
-
-* `ContainersReady` condition is added to the Pod status.
-
-    * [https://github.com/kubernetes/kubernetes/pull/64646](https://github.com/kubernetes/kubernetes/pull/64646)
-
-**Bug fixes and Improvements:**
-
-* Default mount propagation has changed from `HostToContainer` (`rslave` in Linux terminology) to `None` (`private`) to match the behavior in 1.9 and earlier releases. `HostToContainer` as a default caused regressions in some pods.
-
-    * [https://github.com/kubernetes/kubernetes/pull/62462](https://github.com/kubernetes/kubernetes/pull/62462)
-
-# v7.0.0
-
-**Breaking Changes:**
-
-* Google Cloud Service Account email addresses can now be used in RBAC Role bindings since the default scopes now include the `userinfo.email` scope. This is a breaking change if the numeric uniqueIDs of the Google service accounts were being used in RBAC role bindings. The behavior can be overridden by explicitly specifying the scope values as comma-separated string in the `users[*].config.scopes` field in the `KUBECONFIG` file.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58141](https://github.com/kubernetes/kubernetes/pull/58141)
-
-* [k8s.io/api] The `ConfigOK` node condition has been renamed to `KubeletConfigOk`.
-
-    * [https://github.com/kubernetes/kubernetes/pull/59905](https://github.com/kubernetes/kubernetes/pull/59905)
-
-**New Features:**
-
-* Subresource support is added to the dynamic client.
-
-    * [https://github.com/kubernetes/kubernetes/pull/56717](https://github.com/kubernetes/kubernetes/pull/56717)
-
-* A watch method is added to the Fake Client.
-
-    * [https://github.com/kubernetes/kubernetes/pull/57504](https://github.com/kubernetes/kubernetes/pull/57504)
-
-* `ListOptions` can be modified when creating a `ListWatch`.
-
-    * [https://github.com/kubernetes/kubernetes/pull/57508](https://github.com/kubernetes/kubernetes/pull/57508)
-
-* A `/token` subresource for ServiceAccount is added.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58111](https://github.com/kubernetes/kubernetes/pull/58111)
-
-* If an informer delivery fails, the particular notification is skipped and continued the next time.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58394](https://github.com/kubernetes/kubernetes/pull/58394)
-
-* Certificate manager will no longer wait until the initial rotation succeeds or fails before returning from `Start()`.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58930](https://github.com/kubernetes/kubernetes/pull/58930)
-
-* [k8s.io/api] `VolumeScheduling` and `LocalPersistentVolume` features are beta and enabled by default. The PersistentVolume NodeAffinity alpha annotation is deprecated and will be removed in a future release.
-
-    * [https://github.com/kubernetes/kubernetes/pull/59391](https://github.com/kubernetes/kubernetes/pull/59391)
-
-* [k8s.io/api] The `PodSecurityPolicy` API has been moved to the `policy/v1beta1` API group. The `PodSecurityPolicy` API in the `extensions/v1beta1` API group is deprecated and will be removed in a future release.
-
-    * [https://github.com/kubernetes/kubernetes/pull/54933](https://github.com/kubernetes/kubernetes/pull/54933)
-
-* [k8s.io/api] ConfigMap objects now support binary data via a new `binaryData` field.
-
-    * [https://github.com/kubernetes/kubernetes/pull/57938](https://github.com/kubernetes/kubernetes/pull/57938)
-
-* [k8s.io/api] Service account TokenRequest API is added.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58027](https://github.com/kubernetes/kubernetes/pull/58027)
-
-* [k8s.io/api] FSType is added in CSI volume source to specify filesystems.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58209](https://github.com/kubernetes/kubernetes/pull/58209)
-
-* [k8s.io/api] v1beta1 VolumeAttachment API is added.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58462](https://github.com/kubernetes/kubernetes/pull/58462)
-
-* [k8s.io/api] `v1.Pod` now has a field `ShareProcessNamespace` to configure whether a single process namespace should be shared between all containers in a pod. This feature is in alpha preview.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58716](https://github.com/kubernetes/kubernetes/pull/58716)
-
-* [k8s.io/api] Add `NominatedNodeName` field to `PodStatus`. This field is set when a pod preempts other pods on the node.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58990](https://github.com/kubernetes/kubernetes/pull/58990)
-
-* [k8s.io/api] Promote `CSIPersistentVolumeSourc`e to beta.
-
-    * [https://github.com/kubernetes/kubernetes/pull/59157](https://github.com/kubernetes/kubernetes/pull/59157)
-
-* [k8s.io/api] Promote `DNSPolicy` and `DNSConfig` in `PodSpec` to beta.
-
-    * [https://github.com/kubernetes/kubernetes/pull/59771](https://github.com/kubernetes/kubernetes/pull/59771)
-
-* [k8s.io/api] External metric types are added to the HPA API.
-
-    * [https://github.com/kubernetes/kubernetes/pull/60096](https://github.com/kubernetes/kubernetes/pull/60096)
-
-* [k8s.io/apimachinery] The `meta.k8s.io/v1alpha1` objects for retrieving tabular responses from the server (`Table`) or fetching just the `ObjectMeta` for an object (as `PartialObjectMetadata`) are now beta as part of `meta.k8s.io/v1beta1`. Clients may request alternate representations of normal Kubernetes objects by passing an `Accept` header like `application/json;as=Table;g=meta.k8s.io;v=v1beta1` or `application/json;as=PartialObjectMetadata;g=meta.k8s.io;v1=v1beta1`. Older servers will ignore this representation or return an error if it is not available. Clients may request fallback to the normal object by adding a non-qualified mime-type to their `Accept` header like `application/json` - the server will then respond with either the alternate representation if it is supported or the fallback mime-type which is the normal object response.
-
-    * [https://github.com/kubernetes/kubernetes/pull/59059](https://github.com/kubernetes/kubernetes/pull/59059)
-
-
-**Bug fixes and Improvements:**
-
-* Port-forwarding of TCP6 ports is fixed.
-
-    * [https://github.com/kubernetes/kubernetes/pull/57457](https://github.com/kubernetes/kubernetes/pull/57457)
-
-* A race condition in SharedInformer that could violate the sequential delivery guarantee and cause panics on shutdown is fixed.
-
-    * [https://github.com/kubernetes/kubernetes/pull/59828](https://github.com/kubernetes/kubernetes/pull/59828)
-
-* [k8s.io/api] PersistentVolume flexVolume sources can now reference secrets in a namespace other than the PersistentVolumeClaim's namespace.
-
-    * [https://github.com/kubernetes/kubernetes/pull/56460](https://github.com/kubernetes/kubernetes/pull/56460)
-
-* [k8s.io/apimachinery] YAMLDecoder Read can now return the number of bytes read.
-
-    * [https://github.com/kubernetes/kubernetes/pull/57000](https://github.com/kubernetes/kubernetes/pull/57000)
-
-* [k8s.io/apimachinery] YAMLDecoder Read now tracks rest of buffer on `io.ErrShortBuffer`.
-
-    * [https://github.com/kubernetes/kubernetes/pull/58817](https://github.com/kubernetes/kubernetes/pull/58817)
-
-* [k8s.io/apimachinery] Prompt required merge key in the error message while applying a strategic merge patch.
-
-    * [https://github.com/kubernetes/kubernetes/pull/57854](https://github.com/kubernetes/kubernetes/pull/57854)
-
 # v6.0.0
 
 **Breaking Changes:**

CONTRIBUTING.md

@@ -1,7 +1,7 @@
 # Contributing guidelines
 
-Do not open pull requests directly against kubernetes/client-go repository (except for README.md); they will be ignored. Instead, please open pull requests and issues against [kubernetes/kubernetes](https://git.k8s.io/kubernetes/).  Please follow the same [contributing guide](https://git.k8s.io/kubernetes/CONTRIBUTING.md) you would follow for any other pull request made to kubernetes/kubernetes.
+Do not open pull requests directly against this repository, they will be ignored. Instead, please open pull requests against [kubernetes/kubernetes](https://git.k8s.io/kubernetes/).  Please follow the same [contributing guide](https://git.k8s.io/kubernetes/CONTRIBUTING.md) you would follow for any other pull request made to kubernetes/kubernetes.
 
-This repository is published from [kubernetes/kubernetes/staging/src/k8s.io/client-go](https://git.k8s.io/kubernetes/staging/src/k8s.io/client-go) by the [kubernetes publishing-bot](https://git.k8s.io/publishing-bot).
+This repository is published from [kubernetes/kubernetes/staging/src/k8s.io/client-go](https://git.k8s.io/kubernetes/staging/src/k8s.io/client-go) by the [kubernetes publishing-bot](https://git.k8s.io/publishing-bot). 
 
-Please see [Staging Directory and Publishing](https://git.k8s.io/community/contributors/devel/sig-architecture/staging.md) for more information
+Please see [Staging Directory and Publishing](https://git.k8s.io/community/contributors/devel/staging.md) for more information

Godeps/Godeps.json

@@ -1,510 +1,590 @@
 {
 	"ImportPath": "k8s.io/client-go",
-	"GoVersion": "unknown",
-	"GodepVersion": "gen-godeps",
+	"GoVersion": "go1.9",
+	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
 	],
 	"Deps": [
 		{
-			"ImportPath": "cloud.google.com/go",
-			"Rev": "v0.54.0"
+			"ImportPath": "cloud.google.com/go/compute/metadata",
+			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
 		},
 		{
-			"ImportPath": "cloud.google.com/go/bigquery",
-			"Rev": "v1.4.0"
-		},
-		{
-			"ImportPath": "cloud.google.com/go/datastore",
-			"Rev": "v1.1.0"
-		},
-		{
-			"ImportPath": "cloud.google.com/go/pubsub",
-			"Rev": "v1.2.0"
-		},
-		{
-			"ImportPath": "cloud.google.com/go/storage",
-			"Rev": "v1.6.0"
-		},
-		{
-			"ImportPath": "dmitri.shuralyov.com/gpu/mtl",
-			"Rev": "666a987793e9"
-		},
-		{
-			"ImportPath": "github.com/Azure/go-autorest",
-			"Rev": "v14.2.0"
+			"ImportPath": "cloud.google.com/go/internal",
+			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
 		},
 		{
 			"ImportPath": "github.com/Azure/go-autorest/autorest",
-			"Rev": "v0.11.1"
+			"Rev": "d4e6b95c12a08b4de2d48b45d5b4d594e5d32fab"
 		},
 		{
 			"ImportPath": "github.com/Azure/go-autorest/autorest/adal",
-			"Rev": "v0.9.5"
+			"Rev": "d4e6b95c12a08b4de2d48b45d5b4d594e5d32fab"
+		},
+		{
+			"ImportPath": "github.com/Azure/go-autorest/autorest/azure",
+			"Rev": "d4e6b95c12a08b4de2d48b45d5b4d594e5d32fab"
 		},
 		{
 			"ImportPath": "github.com/Azure/go-autorest/autorest/date",
-			"Rev": "v0.3.0"
+			"Rev": "d4e6b95c12a08b4de2d48b45d5b4d594e5d32fab"
 		},
 		{
-			"ImportPath": "github.com/Azure/go-autorest/autorest/mocks",
-			"Rev": "v0.4.1"
-		},
-		{
-			"ImportPath": "github.com/Azure/go-autorest/logger",
-			"Rev": "v0.2.0"
-		},
-		{
-			"ImportPath": "github.com/Azure/go-autorest/tracing",
-			"Rev": "v0.6.0"
-		},
-		{
-			"ImportPath": "github.com/BurntSushi/toml",
-			"Rev": "v0.3.1"
-		},
-		{
-			"ImportPath": "github.com/BurntSushi/xgb",
-			"Rev": "27f122750802"
-		},
-		{
-			"ImportPath": "github.com/NYTimes/gziphandler",
-			"Rev": "56545f4a5d46"
-		},
-		{
-			"ImportPath": "github.com/PuerkitoBio/purell",
-			"Rev": "v1.1.1"
-		},
-		{
-			"ImportPath": "github.com/PuerkitoBio/urlesc",
-			"Rev": "de5bf2ad4578"
-		},
-		{
-			"ImportPath": "github.com/asaskevich/govalidator",
-			"Rev": "f61b66f89f4a"
-		},
-		{
-			"ImportPath": "github.com/census-instrumentation/opencensus-proto",
-			"Rev": "v0.2.1"
-		},
-		{
-			"ImportPath": "github.com/chzyer/logex",
-			"Rev": "v1.1.10"
-		},
-		{
-			"ImportPath": "github.com/chzyer/readline",
-			"Rev": "2972be24d48e"
-		},
-		{
-			"ImportPath": "github.com/chzyer/test",
-			"Rev": "a1ea475d72b1"
-		},
-		{
-			"ImportPath": "github.com/client9/misspell",
-			"Rev": "v0.3.4"
-		},
-		{
-			"ImportPath": "github.com/davecgh/go-spew",
-			"Rev": "v1.1.1"
+			"ImportPath": "github.com/davecgh/go-spew/spew",
+			"Rev": "782f4967f2dc4564575ca782fe2d04090b5faca8"
 		},
 		{
 			"ImportPath": "github.com/dgrijalva/jwt-go",
-			"Rev": "v3.2.0"
+			"Rev": "01aeca54ebda6e0fbfafd0a524d234159c05ec20"
 		},
 		{
 			"ImportPath": "github.com/docker/spdystream",
-			"Rev": "449fdfce4d96"
+			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
 		},
 		{
-			"ImportPath": "github.com/docopt/docopt-go",
-			"Rev": "ee0de3bc6815"
-		},
-		{
-			"ImportPath": "github.com/elazarl/goproxy",
-			"Rev": "947c36da3153"
-		},
-		{
-			"ImportPath": "github.com/emicklei/go-restful",
-			"Rev": "ff4f55a20633"
-		},
-		{
-			"ImportPath": "github.com/envoyproxy/go-control-plane",
-			"Rev": "5f8ba28d4473"
-		},
-		{
-			"ImportPath": "github.com/envoyproxy/protoc-gen-validate",
-			"Rev": "v0.1.0"
-		},
-		{
-			"ImportPath": "github.com/evanphx/json-patch",
-			"Rev": "v4.9.0"
-		},
-		{
-			"ImportPath": "github.com/form3tech-oss/jwt-go",
-			"Rev": "v3.2.2"
-		},
-		{
-			"ImportPath": "github.com/fsnotify/fsnotify",
-			"Rev": "v1.4.9"
+			"ImportPath": "github.com/docker/spdystream/spdy",
+			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
 		},
 		{
 			"ImportPath": "github.com/ghodss/yaml",
-			"Rev": "73d445a93680"
+			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
 		},
 		{
-			"ImportPath": "github.com/go-gl/glfw",
-			"Rev": "e6da0acd62b1"
+			"ImportPath": "github.com/gogo/protobuf/proto",
+			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
 		},
 		{
-			"ImportPath": "github.com/go-gl/glfw/v3.3/glfw",
-			"Rev": "6f7a984d4dc4"
-		},
-		{
-			"ImportPath": "github.com/go-logr/logr",
-			"Rev": "v0.2.0"
-		},
-		{
-			"ImportPath": "github.com/go-openapi/jsonpointer",
-			"Rev": "v0.19.3"
-		},
-		{
-			"ImportPath": "github.com/go-openapi/jsonreference",
-			"Rev": "v0.19.3"
-		},
-		{
-			"ImportPath": "github.com/go-openapi/spec",
-			"Rev": "v0.19.3"
-		},
-		{
-			"ImportPath": "github.com/go-openapi/swag",
-			"Rev": "v0.19.5"
-		},
-		{
-			"ImportPath": "github.com/gogo/protobuf",
-			"Rev": "v1.3.1"
+			"ImportPath": "github.com/gogo/protobuf/sortkeys",
+			"Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7"
 		},
 		{
 			"ImportPath": "github.com/golang/glog",
-			"Rev": "23def4e6c14b"
+			"Rev": "44145f04b68cf362d9c4df2182967c2275eaefed"
 		},
 		{
-			"ImportPath": "github.com/golang/groupcache",
-			"Rev": "8c9f03a8e57e"
+			"ImportPath": "github.com/golang/groupcache/lru",
+			"Rev": "02826c3e79038b59d737d3b1c0a1d937f71a4433"
 		},
 		{
-			"ImportPath": "github.com/golang/mock",
-			"Rev": "v1.4.1"
+			"ImportPath": "github.com/golang/protobuf/proto",
+			"Rev": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9"
 		},
 		{
-			"ImportPath": "github.com/golang/protobuf",
-			"Rev": "v1.4.3"
+			"ImportPath": "github.com/golang/protobuf/ptypes",
+			"Rev": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9"
 		},
 		{
-			"ImportPath": "github.com/google/btree",
-			"Rev": "v1.0.0"
+			"ImportPath": "github.com/golang/protobuf/ptypes/any",
+			"Rev": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9"
 		},
 		{
-			"ImportPath": "github.com/google/go-cmp",
-			"Rev": "v0.5.2"
+			"ImportPath": "github.com/golang/protobuf/ptypes/duration",
+			"Rev": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9"
+		},
+		{
+			"ImportPath": "github.com/golang/protobuf/ptypes/timestamp",
+			"Rev": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9"
 		},
 		{
 			"ImportPath": "github.com/google/gofuzz",
-			"Rev": "v1.1.0"
+			"Rev": "44d81051d367757e1c7c6a5a86423ece9afcf63c"
 		},
 		{
-			"ImportPath": "github.com/google/martian",
-			"Rev": "v2.1.0"
+			"ImportPath": "github.com/googleapis/gnostic/OpenAPIv2",
+			"Rev": "0c5108395e2debce0d731cf0287ddf7242066aba"
 		},
 		{
-			"ImportPath": "github.com/google/pprof",
-			"Rev": "1ebb73c60ed3"
+			"ImportPath": "github.com/googleapis/gnostic/compiler",
+			"Rev": "0c5108395e2debce0d731cf0287ddf7242066aba"
 		},
 		{
-			"ImportPath": "github.com/google/renameio",
-			"Rev": "v0.1.0"
+			"ImportPath": "github.com/googleapis/gnostic/extensions",
+			"Rev": "0c5108395e2debce0d731cf0287ddf7242066aba"
 		},
 		{
-			"ImportPath": "github.com/google/uuid",
-			"Rev": "v1.1.2"
+			"ImportPath": "github.com/gophercloud/gophercloud",
+			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
 		},
 		{
-			"ImportPath": "github.com/googleapis/gax-go/v2",
-			"Rev": "v2.0.5"
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack",
+			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
 		},
 		{
-			"ImportPath": "github.com/googleapis/gnostic",
-			"Rev": "v0.4.1"
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v2/tenants",
+			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
 		},
 		{
-			"ImportPath": "github.com/gregjones/httpcache",
-			"Rev": "9cad4c3443a7"
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v2/tokens",
+			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v3/tokens",
+			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/openstack/utils",
+			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+		},
+		{
+			"ImportPath": "github.com/gophercloud/gophercloud/pagination",
+			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
 		},
 		{
 			"ImportPath": "github.com/hashicorp/golang-lru",
-			"Rev": "v0.5.1"
+			"Rev": "a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"
 		},
 		{
-			"ImportPath": "github.com/hpcloud/tail",
-			"Rev": "v1.0.0"
+			"ImportPath": "github.com/hashicorp/golang-lru/simplelru",
+			"Rev": "a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"
 		},
 		{
-			"ImportPath": "github.com/ianlancetaylor/demangle",
-			"Rev": "5e5cf60278f6"
+			"ImportPath": "github.com/howeyc/gopass",
+			"Rev": "bf9dde6d0d2c004a008c27aaee91170c786f6db8"
 		},
 		{
 			"ImportPath": "github.com/imdario/mergo",
-			"Rev": "v0.3.5"
+			"Rev": "6633656539c1639d9d78127b7d47c622b5d7b6dc"
 		},
 		{
 			"ImportPath": "github.com/json-iterator/go",
-			"Rev": "v1.1.10"
-		},
-		{
-			"ImportPath": "github.com/jstemmer/go-junit-report",
-			"Rev": "v0.9.1"
-		},
-		{
-			"ImportPath": "github.com/kisielk/errcheck",
-			"Rev": "v1.2.0"
-		},
-		{
-			"ImportPath": "github.com/kisielk/gotool",
-			"Rev": "v1.0.0"
-		},
-		{
-			"ImportPath": "github.com/kr/pretty",
-			"Rev": "v0.2.0"
-		},
-		{
-			"ImportPath": "github.com/kr/pty",
-			"Rev": "v1.1.5"
-		},
-		{
-			"ImportPath": "github.com/kr/text",
-			"Rev": "v0.1.0"
-		},
-		{
-			"ImportPath": "github.com/mailru/easyjson",
-			"Rev": "b2ccc519800e"
-		},
-		{
-			"ImportPath": "github.com/mitchellh/mapstructure",
-			"Rev": "v1.1.2"
+			"Rev": "f2b4162afba35581b6d4a50d3b8f34e33c144682"
 		},
 		{
 			"ImportPath": "github.com/modern-go/concurrent",
-			"Rev": "bacd9c7ef1dd"
+			"Rev": "bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94"
 		},
 		{
 			"ImportPath": "github.com/modern-go/reflect2",
-			"Rev": "v1.0.1"
+			"Rev": "05fbef0ca5da472bbf96c9322b84a53edc03c9fd"
 		},
 		{
-			"ImportPath": "github.com/munnerz/goautoneg",
-			"Rev": "a547fc61f48d"
-		},
-		{
-			"ImportPath": "github.com/mxk/go-flowrate",
-			"Rev": "cca7078d478f"
-		},
-		{
-			"ImportPath": "github.com/onsi/ginkgo",
-			"Rev": "v1.11.0"
-		},
-		{
-			"ImportPath": "github.com/onsi/gomega",
-			"Rev": "v1.7.0"
-		},
-		{
-			"ImportPath": "github.com/peterbourgon/diskv",
-			"Rev": "v2.0.1"
-		},
-		{
-			"ImportPath": "github.com/pkg/errors",
-			"Rev": "v0.9.1"
-		},
-		{
-			"ImportPath": "github.com/pmezard/go-difflib",
-			"Rev": "v1.0.0"
-		},
-		{
-			"ImportPath": "github.com/prometheus/client_model",
-			"Rev": "14fe0d1b01d4"
-		},
-		{
-			"ImportPath": "github.com/rogpeppe/go-internal",
-			"Rev": "v1.3.0"
-		},
-		{
-			"ImportPath": "github.com/spf13/afero",
-			"Rev": "v1.2.2"
+			"ImportPath": "github.com/pmezard/go-difflib/difflib",
+			"Rev": "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
 		},
 		{
 			"ImportPath": "github.com/spf13/pflag",
-			"Rev": "v1.0.5"
+			"Rev": "583c0c0531f06d5278b7d917446061adc344b5cd"
 		},
 		{
-			"ImportPath": "github.com/stretchr/objx",
-			"Rev": "v0.2.0"
+			"ImportPath": "github.com/stretchr/testify/assert",
+			"Rev": "f6abca593680b2315d2075e0f5e2a9751e3f431a"
 		},
 		{
-			"ImportPath": "github.com/stretchr/testify",
-			"Rev": "v1.6.1"
+			"ImportPath": "golang.org/x/crypto/ssh/terminal",
+			"Rev": "81e90905daefcd6fd217b62423c0908922eadb30"
 		},
 		{
-			"ImportPath": "go.opencensus.io",
-			"Rev": "v0.22.3"
+			"ImportPath": "golang.org/x/net/context",
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
-			"ImportPath": "golang.org/x/crypto",
-			"Rev": "7f63de1d35b0"
+			"ImportPath": "golang.org/x/net/context/ctxhttp",
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
-			"ImportPath": "golang.org/x/exp",
-			"Rev": "6cc2880d07d6"
+			"ImportPath": "golang.org/x/net/http2",
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
-			"ImportPath": "golang.org/x/image",
-			"Rev": "cff245a6509b"
+			"ImportPath": "golang.org/x/net/http2/hpack",
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
-			"ImportPath": "golang.org/x/lint",
-			"Rev": "738671d3881b"
+			"ImportPath": "golang.org/x/net/idna",
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
-			"ImportPath": "golang.org/x/mobile",
-			"Rev": "d2bd2a29d028"
-		},
-		{
-			"ImportPath": "golang.org/x/mod",
-			"Rev": "v0.2.0"
-		},
-		{
-			"ImportPath": "golang.org/x/net",
-			"Rev": "69a78807bb2b"
+			"ImportPath": "golang.org/x/net/lex/httplex",
+			"Rev": "1c05540f6879653db88113bc4a2b70aec4bd491f"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "bf48bf16ab8d"
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/sync",
-			"Rev": "cd5d95a43a6e"
+			"ImportPath": "golang.org/x/oauth2/google",
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/sys",
-			"Rev": "5cba982894dd"
+			"ImportPath": "golang.org/x/oauth2/internal",
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/text",
-			"Rev": "v0.3.4"
+			"ImportPath": "golang.org/x/oauth2/jws",
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/time",
-			"Rev": "3af7569d3a1e"
+			"ImportPath": "golang.org/x/oauth2/jwt",
+			"Rev": "a6bd8cefa1811bd24b86f8902872e4e8225f74c4"
 		},
 		{
-			"ImportPath": "golang.org/x/tools",
-			"Rev": "95d2e580d8eb"
+			"ImportPath": "golang.org/x/sys/unix",
+			"Rev": "95c6576299259db960f6c5b9b69ea52422860fce"
 		},
 		{
-			"ImportPath": "golang.org/x/xerrors",
-			"Rev": "5ec99f83aff1"
+			"ImportPath": "golang.org/x/sys/windows",
+			"Rev": "95c6576299259db960f6c5b9b69ea52422860fce"
 		},
 		{
-			"ImportPath": "google.golang.org/api",
-			"Rev": "v0.20.0"
+			"ImportPath": "golang.org/x/text/secure/bidirule",
+			"Rev": "b19bf474d317b857955b12035d2c5acb57ce8b01"
 		},
 		{
-			"ImportPath": "google.golang.org/appengine",
-			"Rev": "v1.6.5"
+			"ImportPath": "golang.org/x/text/transform",
+			"Rev": "b19bf474d317b857955b12035d2c5acb57ce8b01"
 		},
 		{
-			"ImportPath": "google.golang.org/genproto",
-			"Rev": "cb27e3aa2013"
+			"ImportPath": "golang.org/x/text/unicode/bidi",
+			"Rev": "b19bf474d317b857955b12035d2c5acb57ce8b01"
 		},
 		{
-			"ImportPath": "google.golang.org/grpc",
-			"Rev": "v1.27.1"
+			"ImportPath": "golang.org/x/text/unicode/norm",
+			"Rev": "b19bf474d317b857955b12035d2c5acb57ce8b01"
 		},
 		{
-			"ImportPath": "google.golang.org/protobuf",
-			"Rev": "v1.25.0"
-		},
-		{
-			"ImportPath": "gopkg.in/check.v1",
-			"Rev": "41f04d3bba15"
-		},
-		{
-			"ImportPath": "gopkg.in/errgo.v2",
-			"Rev": "v2.1.0"
-		},
-		{
-			"ImportPath": "gopkg.in/fsnotify.v1",
-			"Rev": "v1.4.7"
+			"ImportPath": "golang.org/x/time/rate",
+			"Rev": "f51c12702a4d776e4c1fa9b0fabab841babae631"
 		},
 		{
 			"ImportPath": "gopkg.in/inf.v0",
-			"Rev": "v0.9.1"
-		},
-		{
-			"ImportPath": "gopkg.in/tomb.v1",
-			"Rev": "dd632973f1e7"
+			"Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
 		},
 		{
 			"ImportPath": "gopkg.in/yaml.v2",
-			"Rev": "v2.2.8"
+			"Rev": "670d4cfef0544295bc27a114dbac37980d83185a"
 		},
 		{
-			"ImportPath": "gopkg.in/yaml.v3",
-			"Rev": "9f266ea9e77c"
+			"ImportPath": "k8s.io/api/admissionregistration/v1alpha1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "honnef.co/go/tools",
-			"Rev": "v0.0.1-2020.1.3"
+			"ImportPath": "k8s.io/api/admissionregistration/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "k8s.io/api",
-			"Rev": "v0.20.1"
+			"ImportPath": "k8s.io/api/apps/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "k8s.io/apimachinery",
-			"Rev": "v0.20.1"
+			"ImportPath": "k8s.io/api/apps/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "k8s.io/gengo",
-			"Rev": "3a45101e95ac"
+			"ImportPath": "k8s.io/api/apps/v1beta2",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "k8s.io/klog/v2",
-			"Rev": "v2.4.0"
+			"ImportPath": "k8s.io/api/authentication/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "k8s.io/kube-openapi",
-			"Rev": "d219536bb9fd"
+			"ImportPath": "k8s.io/api/authentication/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "k8s.io/utils",
-			"Rev": "67b214c5f920"
+			"ImportPath": "k8s.io/api/authorization/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "rsc.io/binaryregexp",
-			"Rev": "v0.2.0"
+			"ImportPath": "k8s.io/api/authorization/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "rsc.io/quote/v3",
-			"Rev": "v3.1.0"
+			"ImportPath": "k8s.io/api/autoscaling/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "rsc.io/sampler",
-			"Rev": "v1.3.0"
+			"ImportPath": "k8s.io/api/autoscaling/v2beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "sigs.k8s.io/structured-merge-diff/v4",
-			"Rev": "v4.0.2"
+			"ImportPath": "k8s.io/api/batch/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
 		},
 		{
-			"ImportPath": "sigs.k8s.io/yaml",
-			"Rev": "v1.2.0"
+			"ImportPath": "k8s.io/api/batch/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/batch/v2alpha1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/certificates/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/core/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/events/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/extensions/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/imagepolicy/v1alpha1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/networking/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/policy/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/rbac/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/rbac/v1alpha1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/rbac/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/scheduling/v1alpha1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/settings/v1alpha1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/storage/v1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/storage/v1alpha1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/api/storage/v1beta1",
+			"Rev": "c89978d5f86d7427bef2fc7752732c8c60b1d188"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/equality",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/errors",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/meta",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/resource",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/testing",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/testing/fuzzer",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/api/testing/roundtrip",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery/announced",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery/registered",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/fuzzer",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/internalversion",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1beta1",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/conversion",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/fields",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/labels",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/schema",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/selection",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/types",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/cache",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/clock",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/diff",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/errors",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/framer",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream/spdy",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/intstr",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/json",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/net",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/remotecommand",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/runtime",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/sets",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/validation",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/validation/field",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/wait",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/util/yaml",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/version",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/pkg/watch",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/netutil",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect",
+			"Rev": "d49e237a2683fa6dc43a86c7b1b766e0219fb6e7"
+		},
+		{
+			"ImportPath": "k8s.io/kube-openapi/pkg/util/proto",
+			"Rev": "39cb288412c48cb533ba4be5d6c28620b9a0c1b4"
 		}
 	]
-}
+}

Godeps/OWNERS

@@ -1,4 +1,2 @@
-# See the OWNERS docs at https://go.k8s.io/owners
-
 approvers:
 - dep-approvers

INSTALL.md

@@ -3,23 +3,37 @@
 ## For the casual user
 
 If you want to write a simple script, don't care about a reproducible client
-library install, don't mind getting HEAD (which may be less stable than a
+library install, don't mind getting head (which may be less stable than a
 particular release), then simply:
 
 ```sh
-go get k8s.io/client-go@master
+$ go get k8s.io/client-go/...
 ```
 
-This will record a dependency on `k8s.io/client-go` in your go module.
-You can now import and use the `k8s.io/client-go` APIs in your project.
-The next time you `go build`, `go test`, or `go run` your project,
-`k8s.io/client-go` and its dependencies will be downloaded (if needed),
-and detailed dependency version info will be added to your `go.mod` file
-(or you can also run `go mod tidy` to do this directly).
+This will install `k8s.io/client-go` in your `$GOPATH`. `k8s.io/client-go`
+includes most of its own dependencies in its `k8s.io/client-go/vendor` path,
+except for `k8s.io/apimachinery` and `glog`. `go get` will recursively download
+these excluded repos to your `$GOPATH`, if they don't already exist. If
+`k8s.io/apimachinery` preexisted in `$GOPATH`, you also need to:
 
-This assumes you are using go modules with go 1.11+.
-If you get a message like `cannot use path@version syntax in GOPATH mode`,
-see the instructions for [enabling go modules](#enabling-go-modules).
+```sh
+$ go get -u k8s.io/apimachinery/...
+```
+
+because the head of client-go is only guaranteed to work with the head of
+apimachinery.
+
+We excluded `k8s.io/apimachinery` and `glog` from `k8s.io/client-go/vendor` to
+prevent `go get` users from hitting issues like
+[#19](https://github.com/kubernetes/client-go/issues/19) and
+[#83](https://github.com/kubernetes/client-go/issues/83). If your project share
+other dependencies with client-go, and you hit issues similar to #19 or #83,
+then you'll need to look down at the next section.
+
+Note: the official go policy is that libraries should not vendor their
+dependencies. This is unworkable for us, since our dependencies change and HEAD
+on every dependency has not necessarily been tested with client-go. In fact,
+HEAD from all dependencies may not even compile with client-go!
 
 ## Dependency management for the serious (or reluctant) user
 
@@ -32,50 +46,117 @@ Reasons why you might need to use a dependency management system:
 * You want your install to be reproducible. For example, for your CI system or
   for new team members.
 
-### Enabling go modules
+There are three tools you could in theory use for this. Instructions
+for each follows.
 
-Dependency management tools are built into go 1.11+ in the form of [go modules](https://github.com/golang/go/wiki/Modules).
-These are used by the main Kubernetes repo (>= `v1.15.0`) and `client-go` (>= `kubernetes-1.15.0`) to manage dependencies.
-If you are using go 1.11 or 1.12 and are working with a project located within `$GOPATH`,
-you must opt into using go modules:
+### Godep
+
+[godep](https://github.com/tools/godep) is an older dependency management tool, which is
+used by the main Kubernetes repo and `client-go` to manage dependencies.
+
+Before proceeding with the below instructions, you should ensure that your
+$GOPATH is empty except for containing your own package and its dependencies,
+and you have a copy of godep somewhere in your $PATH.
+
+To install `client-go` and place its dependencies in your `$GOPATH`:
 
 ```sh
-export GO111MODULE=on
+go get k8s.io/client-go/...
+cd $GOPATH/src/k8s.io/client-go
+git checkout v6.0.0
+# cd 1.5 # only necessary with 1.5 and 1.4 clients.
+godep restore ./...
 ```
 
-Ensure your project has a `go.mod` file defined at the root of your project.
-If you do not already have one, `go mod init` will create one for you:
+At this point, `client-go`'s dependencies have been placed in your $GOPATH, but
+if you were to build, `client-go` would still see its own copy of its
+dependencies in its `vendor` directory. You have two options at this point.
+
+If you would like to keep dependencies in your own project's vendor directory,
+then you can continue like this:
 
 ```sh
-go mod init
+cd $GOPATH/src/<my-pkg>
+godep save ./...
 ```
 
-### Add client-go as a dependency
+Alternatively, if you want to build using the dependencies in your `$GOPATH`,
+then `rm -rf vendor/` to remove `client-go`'s copy of its dependencies.
 
-Indicate which version of `client-go` your project requires:
+### Glide
 
-- If you are using Kubernetes versions >= `v1.17.0`, use a corresponding
-`v0.x.y` tag. For example, `k8s.io/client-go@v0.17.0` corresponds to Kubernetes `v1.17.0`:
+[Glide](https://github.com/Masterminds/glide) is another popular dependency
+management tool for Go. Glide will manage your /vendor directory, but unlike
+godep, will not use or modify your $GOPATH (there's no equivalent of
+`godep restore` or `godep save`).
+
+Generally, it's best to avoid Glide's many subcommands, favoring modifying
+Glide's manifest file (`glide.yaml`) directly, then running
+`glide update --strip-vendor`. First create a `glide.yaml` file at the root of
+your project:
+
+```yaml
+package: ( your project's import path ) # e.g. github.com/foo/bar
+import:
+- package: k8s.io/client-go
+  version: v6.0.0
+```
+
+Second, add a Go file that imports `client-go` somewhere in your project,
+otherwise `client-go`'s dependencies will not be added to your project's
+vendor/. Then run the following command in the same directory as `glide.yaml`:
 
 ```sh
-go get k8s.io/client-go@v0.17.0
+glide update --strip-vendor
 ```
 
-You can also use a non-semver `kubernetes-1.x.y` tag to refer to a version
-of `client-go` corresponding to a given Kubernetes release. Prior to Kubernetes
-`v1.17.0` these were the only tags available for use with go modules.
-For example, `kubernetes-1.16.3` corresponds to Kubernetes `v1.16.3`.
-However, it is recommended to use semver-like `v0.x.y` tags over non-semver
-`kubernetes-1.x.y` tags to have a seamless experience with go modules.
-
-- If you are using Kubernetes versions < `v1.17.0` (replace `kubernetes-1.16.3` with the desired version):
+This can also be abbreviated as:
 
 ```sh
-go get k8s.io/client-go@kubernetes-1.16.3
+glide up -v
 ```
 
-You can now import and use the `k8s.io/client-go` APIs in your project.
-The next time you `go build`, `go test`, or `go run` your project,
-`k8s.io/client-go` and its dependencies will be downloaded (if needed),
-and detailed dependency version info will be added to your `go.mod` file
-(or you can also run `go mod tidy` to do this directly).
+At this point, `k8s.io/client-go` should be added to your project's vendor/.
+`client-go`'s dependencies should be flattened and be added to your project's
+vendor/ as well.
+
+Glide will detect the versions of dependencies `client-go` specified in
+`client-go`'s Godep.json file, and automatically set the versions of these
+imports in your /vendor directory. It will also record the detected version of
+all dependencies in the `glide.lock` file.
+
+Projects that require a different version of a dependency than `client-go`
+requests can override the version manually in `glide.yaml`. For example:
+
+```yaml
+package: ( your project's import path ) # e.g. github.com/foo/bar
+import:
+- package: k8s.io/client-go
+  version: v6.0.0
+# Use a newer version of go-spew even though client-go wants an old one.
+- package: github.com/davecgh/go-spew
+  version: v1.1.0
+```
+
+After modifying, run `glide up -v` again to re-populate your /vendor directory.
+
+Optionally, Glide users can also use [`glide-vc`](https://github.com/sgotti/glide-vc)
+after running `glide up -v` to remove unused files from /vendor.
+
+### Dep (Not supported yet!)
+
+[dep](https://github.com/golang/dep) is an up-and-coming dependency management
+tool, which has the goal of being accepted as part of the standard go toolchain.
+However, client-go does **NOT** work well with `dep` yet. To support `dep`, we
+need to fix at least two issues:
+1. publish native `Gopkg.toml` in client-go and other k8s.io repos, like `k8s.io/apimachinery`;
+2. find a way to express transitive constraints (see https://github.com/golang/dep/issues/1124).
+
+As a workaround, which may or may not be worthwhile, you can specify all
+client-go dependencies manually as
+[override](https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md#override)
+in Gopkg.toml with the versions listed in [Godeps.json](./Godeps/Godeps.json),
+and manually update them when you upgrade client-go version.
+
+We are actively working on the two issues blocking using `dep`. For the
+meantime, we recommend using `glide` or `godeps`.

OWNERS

@@ -1,19 +1,44 @@
-# See the OWNERS docs at https://go.k8s.io/owners
-
 approvers:
 - caesarxuchao
 - deads2k
+- krousey
 - lavalamp
-- liggitt
 - smarterclayton
 - sttts
-reviewers:
-- caesarxuchao
-- deads2k
-- lavalamp
 - liggitt
-- soltysh
+reviewers:
+- thockin
+- lavalamp
+- smarterclayton
+- wojtek-t
+- deads2k
+- yujuhong
+- derekwaynecarr
+- caesarxuchao
+- vishh
+- mikedanese
+- liggitt
+- nikhiljindal
+- gmarek
+- erictune
+- davidopp
+- pmorie
 - sttts
-- yliaog
-labels:
-- sig/api-machinery
+- dchen1107
+- saad-ali
+- zmerlynn
+- luxas
+- janetkuo
+- justinsb
+- roberthbailey
+- ncdc
+- tallclair
+- yifan-gu
+- eparis
+- mwielgus
+- timothysc
+- feiskyer
+- jlowdermilk
+- soltysh
+- piosz
+- jsafrane

README.md

@@ -2,10 +2,9 @@
 
 Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.
 
-We recommend using the `v0.x.y` tags for Kubernetes releases >= `v1.17.0` and
-`kubernetes-1.x.y` tags for Kubernetes releases < `v1.17.0`.
-See [INSTALL.md](/INSTALL.md) for detailed installation instructions.
-`go get k8s.io/client-go@master` works, but will fetch `master`, which may be less stable than a tagged release.
+We currently recommend using the v6.0.0 tag. See [INSTALL.md](/INSTALL.md) for
+detailed installation instructions. `go get k8s.io/client-go/...` works, but
+will give you head and doesn't handle the dependencies well.
 
 [![BuildStatus Widget]][BuildStatus Result]
 [![GoReport Widget]][GoReport Status]
@@ -39,37 +38,47 @@ See [INSTALL.md](/INSTALL.md) for detailed installation instructions.
 * The `kubernetes` package contains the clientset to access Kubernetes API.
 * The `discovery` package is used to discover APIs supported by a Kubernetes API server.
 * The `dynamic` package contains a dynamic client that can perform generic operations on arbitrary Kubernetes API objects.
-* The `plugin/pkg/client/auth` packages contain optional authentication plugins for obtaining credentials from external sources.
 * The `transport` package is used to set up auth and start a connection.
 * The `tools/cache` package is useful for writing controllers.
 
 ### Versioning
 
-- For each `v1.x.y` Kubernetes release, the major version (first digit)
-would remain `0`.
+`client-go` follows [semver](http://semver.org/). We will not make
+backwards-incompatible changes without incrementing the major version number. A
+change is backwards-incompatible either if it *i)* changes the public interfaces
+of `client-go`, or *ii)* makes `client-go` incompatible with otherwise supported
+versions of Kubernetes clusters.
 
-- Bugfixes will result in the patch version (third digit) changing. PRs that are
+Changes that add features in a backwards-compatible way will result in bumping
+the minor version (second digit) number.
+
+Bugfixes will result in the patch version (third digit) changing. PRs that are
 cherry-picked into an older Kubernetes release branch will result in an update
 to the corresponding branch in `client-go`, with a corresponding new tag
 changing the patch version.
 
+A consequence of this is that `client-go` version numbers will be unrelated to
+Kubernetes version numbers.
+
 #### Branches and tags.
 
-We will create a new branch and tag for each increment in the minor version
-number. We will create only a new tag for each increment in the patch
+We will create a new branch and tag for each increment in the major version number or
+minor version number. We will create only a new tag for each increment in the patch
 version number. See [semver](http://semver.org/) for definitions of major,
 minor, and patch.
 
-The HEAD of the master branch in client-go will track the HEAD of the master
-branch in the main Kubernetes repo.
+The master branch will track HEAD in the main Kubernetes repo and
+accumulate changes. Consider HEAD to have the version `x.(y+1).0-alpha` or
+`(x+1).0.0-alpha` (depending on whether it has accumulated a breaking change or
+not), where `x` and `y` are the current major and minor versions.
 
 #### Compatibility: your code <-> client-go
 
-The `v0.x.y` tags indicate that go APIs may change in incompatible ways in
-different versions.
-
-See [INSTALL.md](INSTALL.md) for guidelines on requiring a specific
-version of client-go.
+`client-go` follows [semver](http://semver.org/), so until the major version of
+client-go gets increased, your code will compile and will continue to work with
+explicitly supported versions of Kubernetes clusters. You must use a dependency
+management system and pin a specific major version of `client-go` to get this
+benefit, as HEAD follows the upstream Kubernetes repo.
 
 #### Compatibility: client-go <-> Kubernetes clusters
 
@@ -82,14 +91,16 @@ We will backport bugfixes--but not new features--into older versions of
 
 #### Compatibility matrix
 
-|                               | Kubernetes 1.15 | Kubernetes 1.16 | Kubernetes 1.17 | Kubernetes 1.18 | Kubernetes 1.19 |
-|-------------------------------|-----------------|-----------------|-----------------|-----------------|-----------------|
-| `kubernetes-1.15.0`           | ✓               | +-              | +-              | +-              | +-              |
-| `kubernetes-1.16.0`           | +-              | ✓               | +-              | +-              | +-              |
-| `kubernetes-1.17.0`/`v0.17.0` | +-              | +-              | ✓               | +-              | +-              |
-| `kubernetes-1.18.0`/`v0.18.0` | +-              | +-              | +-              | ✓               | +-              |
-| `kubernetes-1.19.0`/`v0.19.0` | +-              | +-              | +-              | +-              | ✓               |
-| `HEAD`                        | +-              | +-              | +-              | +-              | +-              |
+|                     | Kubernetes 1.4 | Kubernetes 1.5 | Kubernetes 1.6 | Kubernetes 1.7 | Kubernetes 1.8 | Kubernetes 1.9 |
+|---------------------|----------------|----------------|----------------|----------------|----------------|----------------|
+| client-go 1.4       | ✓              | -              | -              | -              | -              | -              |
+| 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 HEAD      | +-             | +-             | +-             | +-             | +-             | +              |
 
 Key:
 
@@ -110,23 +121,13 @@ between client-go versions.
 
 | Branch         | Canonical source code location       | Maintenance status            |
 |----------------|--------------------------------------|-------------------------------|
-| `release-1.4`  | Kubernetes main repo, 1.4 branch     | = -                           |
-| `release-1.5`  | Kubernetes main repo, 1.5 branch     | = -                           |
-| `release-2.0`  | Kubernetes main repo, 1.5 branch     | = -                           |
-| `release-3.0`  | Kubernetes main repo, 1.6 branch     | = -                           |
-| `release-4.0`  | Kubernetes main repo, 1.7 branch     | = -                           |
-| `release-5.0`  | Kubernetes main repo, 1.8 branch     | = -                           |
-| `release-6.0`  | Kubernetes main repo, 1.9 branch     | = -                           |
-| `release-7.0`  | Kubernetes main repo, 1.10 branch    | = -                           |
-| `release-8.0`  | Kubernetes main repo, 1.11 branch    | =-                            |
-| `release-9.0`  | Kubernetes main repo, 1.12 branch    | =-                            |
-| `release-10.0` | Kubernetes main repo, 1.13 branch    | =-                            |
-| `release-11.0` | Kubernetes main repo, 1.14 branch    | =-                            |
-| `release-12.0` | Kubernetes main repo, 1.15 branch    | =-                            |
-| `release-13.0` | Kubernetes main repo, 1.16 branch    | ✓                             |
-| `release-14.0` | Kubernetes main repo, 1.17 branch    | ✓                             |
-| `release-1.18` | Kubernetes main repo, 1.18 branch    | ✓                             |
-| `release-1.19` | Kubernetes main repo, 1.19 branch    | ✓                             |
+| client-go 1.4  | Kubernetes main repo, 1.4 branch     | = -                           |
+| client-go 1.5  | Kubernetes main repo, 1.5 branch     | = -                           |
+| client-go 2.0  | Kubernetes main repo, 1.5 branch     | = -                           |
+| client-go 3.0  | Kubernetes main repo, 1.6 branch     | = -                           |
+| client-go 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 HEAD | Kubernetes main repo, master branch  | ✓                             |
 
 Key:
@@ -151,21 +152,16 @@ existing users won't be broken.
 
 ### Kubernetes tags
 
-This repository is still a mirror of
+As of October 2017, client-go is still a mirror of
 [k8s.io/kubernetes/staging/src/client-go](https://github.com/kubernetes/kubernetes/tree/master/staging/src/k8s.io/client-go),
-the code development is still done in the staging area.
-
-Since Kubernetes `v1.8.0`, when syncing the code from the staging area,
-we also sync the Kubernetes version tags to client-go, prefixed with
-`kubernetes-`. From Kubernetes `v1.17.0`, we also create matching semver
-`v0.x.y` tags for each `v1.x.y` Kubernetes release.
-
-For example, if you check out the `kubernetes-1.17.0` or the `v0.17.0` tag in
-client-go, the code you get is exactly the same as if you check out the `v1.17.0`
-tag in Kubernetes, and change directory to `staging/src/k8s.io/client-go`.
-
-The purpose is to let users quickly find matching commits among published repos,
-like [sample-apiserver](https://github.com/kubernetes/sample-apiserver),
+the code development is still done in the staging area. Since Kubernetes 1.8
+release, when syncing the code from the staging area, we also sync the Kubernetes
+version tags to client-go, prefixed with "kubernetes-". For example, if you check
+out the `kubernetes-v1.8.0` tag in client-go, the code you get is exactly the
+same as if you check out the `v1.8.0` tag in kubernetes, and change directory to
+`staging/src/k8s.io/client-go`. The purpose is to let users quickly find matching
+commits among published repos, like
+[sample-apiserver](https://github.com/kubernetes/sample-apiserver),
 [apiextension-apiserver](https://github.com/kubernetes/apiextensions-apiserver),
 etc. The Kubernetes version tag does NOT claim any backwards compatibility
 guarantees for client-go. Please check the [semantic versions](#versioning) if
@@ -173,13 +169,10 @@ you care about backwards compatibility.
 
 ### How to get it
 
-Use go1.11+ and fetch the desired version using the `go get` command. For example:
-
-```
-go get k8s.io/client-go@v0.19.0
-```
-
-See [INSTALL.md](/INSTALL.md) for detailed instructions.
+You can use `go get k8s.io/client-go/...` to get client-go, but **you will get
+the unstable master branch** and `client-go`'s vendored dependencies will not be
+added to your `$GOPATH`. So we think most users will want to use a dependency
+management system. See [INSTALL.md](/INSTALL.md) for detailed instructions.
 
 ### How to use it
 
@@ -189,7 +182,9 @@ refer to the out-of-cluster [example](examples/out-of-cluster-client-configurati
 
 ### Dependency management
 
-For details on how to correctly use a dependency management for installing client-go, please see [INSTALL.md](INSTALL.md).
+If your application depends on a package that client-go depends on, and you let the Go compiler find the dependency in `GOPATH`, you will end up with duplicated dependencies: one copy from the `GOPATH`, and one from the vendor folder of client-go. This will cause unexpected runtime error like flag redefinition, since the go compiler ends up importing both packages separately, even if they are exactly the same thing. If this happens, you can either
+* run `godep restore` ([godep](https://github.com/tools/godep)) in the client-go/ folder, then remove the vendor folder of client-go. Then the packages in your GOPATH will be the only copy
+* or run `godep save` in your application folder to flatten all dependencies.
 
 ### Contributing code
 Please send pull requests against the client packages in the Kubernetes main [repository](https://github.com/kubernetes/kubernetes). Changes in the staging area will be published to this repository every day.

SECURITY_CONTACTS

@@ -1,16 +0,0 @@
-# Defined below are the security contacts for this repo.
-#
-# They are the contact point for the Product Security Committee to reach out
-# to for triaging and handling of incoming issues.
-#
-# The below names agree to abide by the
-# [Embargo Policy](https://git.k8s.io/security/private-distributors-list.md#embargo-policy)
-# and will be removed and replaced if they violate that agreement.
-#
-# DO NOT REPORT SECURITY VULNERABILITIES DIRECTLY TO THESE NAMES, FOLLOW THE
-# INSTRUCTIONS AT https://kubernetes.io/security/
-
-caesarxuchao
-deads2k
-lavalamp
-sttts

discovery/cached/disk/cached_discovery.go

@@ -1,298 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package disk
-
-import (
-	"errors"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
-	"k8s.io/klog/v2"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/version"
-	"k8s.io/client-go/discovery"
-	"k8s.io/client-go/kubernetes/scheme"
-	restclient "k8s.io/client-go/rest"
-)
-
-// CachedDiscoveryClient implements the functions that discovery server-supported API groups,
-// versions and resources.
-type CachedDiscoveryClient struct {
-	delegate discovery.DiscoveryInterface
-
-	// cacheDirectory is the directory where discovery docs are held.  It must be unique per host:port combination to work well.
-	cacheDirectory string
-
-	// ttl is how long the cache should be considered valid
-	ttl time.Duration
-
-	// mutex protects the variables below
-	mutex sync.Mutex
-
-	// ourFiles are all filenames of cache files created by this process
-	ourFiles map[string]struct{}
-	// invalidated is true if all cache files should be ignored that are not ours (e.g. after Invalidate() was called)
-	invalidated bool
-	// fresh is true if all used cache files were ours
-	fresh bool
-}
-
-var _ discovery.CachedDiscoveryInterface = &CachedDiscoveryClient{}
-
-// ServerResourcesForGroupVersion returns the supported resources for a group and version.
-func (d *CachedDiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	filename := filepath.Join(d.cacheDirectory, groupVersion, "serverresources.json")
-	cachedBytes, err := d.getCachedFile(filename)
-	// don't fail on errors, we either don't have a file or won't be able to run the cached check. Either way we can fallback.
-	if err == nil {
-		cachedResources := &metav1.APIResourceList{}
-		if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedResources); err == nil {
-			klog.V(10).Infof("returning cached discovery info from %v", filename)
-			return cachedResources, nil
-		}
-	}
-
-	liveResources, err := d.delegate.ServerResourcesForGroupVersion(groupVersion)
-	if err != nil {
-		klog.V(3).Infof("skipped caching discovery info due to %v", err)
-		return liveResources, err
-	}
-	if liveResources == nil || len(liveResources.APIResources) == 0 {
-		klog.V(3).Infof("skipped caching discovery info, no resources found")
-		return liveResources, err
-	}
-
-	if err := d.writeCachedFile(filename, liveResources); err != nil {
-		klog.V(1).Infof("failed to write cache to %v due to %v", filename, err)
-	}
-
-	return liveResources, nil
-}
-
-// ServerResources returns the supported resources for all groups and versions.
-// Deprecated: use ServerGroupsAndResources instead.
-func (d *CachedDiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
-	_, rs, err := discovery.ServerGroupsAndResources(d)
-	return rs, err
-}
-
-// ServerGroupsAndResources returns the supported groups and resources for all groups and versions.
-func (d *CachedDiscoveryClient) ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-	return discovery.ServerGroupsAndResources(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)
-	// don't fail on errors, we either don't have a file or won't be able to run the cached check. Either way we can fallback.
-	if err == nil {
-		cachedGroups := &metav1.APIGroupList{}
-		if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedGroups); err == nil {
-			klog.V(10).Infof("returning cached discovery info from %v", filename)
-			return cachedGroups, nil
-		}
-	}
-
-	liveGroups, err := d.delegate.ServerGroups()
-	if err != nil {
-		klog.V(3).Infof("skipped caching discovery info due to %v", err)
-		return liveGroups, err
-	}
-	if liveGroups == nil || len(liveGroups.Groups) == 0 {
-		klog.V(3).Infof("skipped caching discovery info, no groups found")
-		return liveGroups, err
-	}
-
-	if err := d.writeCachedFile(filename, liveGroups); err != nil {
-		klog.V(1).Infof("failed to write cache to %v due to %v", filename, err)
-	}
-
-	return liveGroups, nil
-}
-
-func (d *CachedDiscoveryClient) getCachedFile(filename string) ([]byte, error) {
-	// after invalidation ignore cache files not created by this process
-	d.mutex.Lock()
-	_, ourFile := d.ourFiles[filename]
-	if d.invalidated && !ourFile {
-		d.mutex.Unlock()
-		return nil, errors.New("cache invalidated")
-	}
-	d.mutex.Unlock()
-
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	fileInfo, err := file.Stat()
-	if err != nil {
-		return nil, err
-	}
-
-	if time.Now().After(fileInfo.ModTime().Add(d.ttl)) {
-		return nil, errors.New("cache expired")
-	}
-
-	// the cache is present and its valid.  Try to read and use it.
-	cachedBytes, err := ioutil.ReadAll(file)
-	if err != nil {
-		return nil, err
-	}
-
-	d.mutex.Lock()
-	defer d.mutex.Unlock()
-	d.fresh = d.fresh && ourFile
-
-	return cachedBytes, nil
-}
-
-func (d *CachedDiscoveryClient) writeCachedFile(filename string, obj runtime.Object) error {
-	if err := os.MkdirAll(filepath.Dir(filename), 0750); err != nil {
-		return err
-	}
-
-	bytes, err := runtime.Encode(scheme.Codecs.LegacyCodec(), obj)
-	if err != nil {
-		return err
-	}
-
-	f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename)+".")
-	if err != nil {
-		return err
-	}
-	defer os.Remove(f.Name())
-	_, err = f.Write(bytes)
-	if err != nil {
-		return err
-	}
-
-	err = os.Chmod(f.Name(), 0660)
-	if err != nil {
-		return err
-	}
-
-	name := f.Name()
-	err = f.Close()
-	if err != nil {
-		return err
-	}
-
-	// atomic rename
-	d.mutex.Lock()
-	defer d.mutex.Unlock()
-	err = os.Rename(name, filename)
-	if err == nil {
-		d.ourFiles[filename] = struct{}{}
-	}
-	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 discovery.ServerPreferredResources(d)
-}
-
-// ServerPreferredNamespacedResources returns the supported namespaced resources with the
-// version preferred by the server.
-func (d *CachedDiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	return discovery.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()
-
-	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()
-
-	d.ourFiles = map[string]struct{}{}
-	d.fresh = true
-	d.invalidated = true
-}
-
-// NewCachedDiscoveryClientForConfig creates a new DiscoveryClient for the given config, and wraps
-// the created client in a CachedDiscoveryClient. The provided configuration is updated with a
-// custom transport that understands cache responses.
-// We receive two distinct cache directories for now, in order to preserve old behavior
-// which makes use of the --cache-dir flag value for storing cache data from the CacheRoundTripper,
-// and makes use of the hardcoded destination (~/.kube/cache/discovery/...) for storing
-// CachedDiscoveryClient cache data. If httpCacheDir is empty, the restconfig's transport will not
-// be updated with a roundtripper that understands cache responses.
-// If discoveryCacheDir is empty, cached server resource data will be looked up in the current directory.
-func NewCachedDiscoveryClientForConfig(config *restclient.Config, discoveryCacheDir, httpCacheDir string, ttl time.Duration) (*CachedDiscoveryClient, error) {
-	if len(httpCacheDir) > 0 {
-		// update the given restconfig with a custom roundtripper that
-		// understands how to handle cache responses.
-		config = restclient.CopyConfig(config)
-		config.Wrap(func(rt http.RoundTripper) http.RoundTripper {
-			return newCacheRoundTripper(httpCacheDir, rt)
-		})
-	}
-
-	discoveryClient, err := discovery.NewDiscoveryClientForConfig(config)
-	if err != nil {
-		return nil, err
-	}
-
-	return newCachedDiscoveryClient(discoveryClient, discoveryCacheDir, ttl), nil
-}
-
-// NewCachedDiscoveryClient creates a new DiscoveryClient.  cacheDirectory is the directory where discovery docs are held.  It must be unique per host:port combination to work well.
-func newCachedDiscoveryClient(delegate discovery.DiscoveryInterface, cacheDirectory string, ttl time.Duration) *CachedDiscoveryClient {
-	return &CachedDiscoveryClient{
-		delegate:       delegate,
-		cacheDirectory: cacheDirectory,
-		ttl:            ttl,
-		ourFiles:       map[string]struct{}{},
-		fresh:          true,
-	}
-}

discovery/cached/disk/cached_discovery_test.go

@@ -1,215 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package disk
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
-	"github.com/stretchr/testify/assert"
-
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/version"
-	"k8s.io/client-go/discovery"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/rest/fake"
-)
-
-func TestCachedDiscoveryClient_Fresh(t *testing.T) {
-	assert := assert.New(t)
-
-	d, err := ioutil.TempDir("", "")
-	assert.NoError(err)
-	defer os.RemoveAll(d)
-
-	c := fakeDiscoveryClient{}
-	cdc := newCachedDiscoveryClient(&c, d, 60*time.Second)
-	assert.True(cdc.Fresh(), "should be fresh after creation")
-
-	cdc.ServerGroups()
-	assert.True(cdc.Fresh(), "should be fresh after groups call without cache")
-	assert.Equal(c.groupCalls, 1)
-
-	cdc.ServerGroups()
-	assert.True(cdc.Fresh(), "should be fresh after another groups call")
-	assert.Equal(c.groupCalls, 1)
-
-	cdc.ServerResources()
-	assert.True(cdc.Fresh(), "should be fresh after resources call")
-	assert.Equal(c.resourceCalls, 1)
-
-	cdc.ServerResources()
-	assert.True(cdc.Fresh(), "should be fresh after another resources call")
-	assert.Equal(c.resourceCalls, 1)
-
-	cdc = newCachedDiscoveryClient(&c, d, 60*time.Second)
-	cdc.ServerGroups()
-	assert.False(cdc.Fresh(), "should NOT be fresh after recreation with existing groups cache")
-	assert.Equal(c.groupCalls, 1)
-
-	cdc.ServerResources()
-	assert.False(cdc.Fresh(), "should NOT be fresh after recreation with existing resources cache")
-	assert.Equal(c.resourceCalls, 1)
-
-	cdc.Invalidate()
-	assert.True(cdc.Fresh(), "should be fresh after cache invalidation")
-
-	cdc.ServerResources()
-	assert.True(cdc.Fresh(), "should ignore existing resources cache after invalidation")
-	assert.Equal(c.resourceCalls, 2)
-}
-
-func TestNewCachedDiscoveryClient_TTL(t *testing.T) {
-	assert := assert.New(t)
-
-	d, err := ioutil.TempDir("", "")
-	assert.NoError(err)
-	defer os.RemoveAll(d)
-
-	c := fakeDiscoveryClient{}
-	cdc := newCachedDiscoveryClient(&c, d, 1*time.Nanosecond)
-	cdc.ServerGroups()
-	assert.Equal(c.groupCalls, 1)
-
-	time.Sleep(1 * time.Second)
-
-	cdc.ServerGroups()
-	assert.Equal(c.groupCalls, 2)
-}
-
-func TestNewCachedDiscoveryClient_PathPerm(t *testing.T) {
-	assert := assert.New(t)
-
-	d, err := ioutil.TempDir("", "")
-	assert.NoError(err)
-	os.RemoveAll(d)
-	defer os.RemoveAll(d)
-
-	c := fakeDiscoveryClient{}
-	cdc := newCachedDiscoveryClient(&c, d, 1*time.Nanosecond)
-	cdc.ServerGroups()
-
-	err = filepath.Walk(d, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if info.IsDir() {
-			assert.Equal(os.FileMode(0750), info.Mode().Perm())
-		} else {
-			assert.Equal(os.FileMode(0660), info.Mode().Perm())
-		}
-		return nil
-	})
-	assert.NoError(err)
-}
-
-type fakeDiscoveryClient struct {
-	groupCalls    int
-	resourceCalls int
-	versionCalls  int
-	openAPICalls  int
-
-	serverResourcesHandler func() ([]*metav1.APIResourceList, error)
-}
-
-var _ discovery.DiscoveryInterface = &fakeDiscoveryClient{}
-
-func (c *fakeDiscoveryClient) RESTClient() restclient.Interface {
-	return &fake.RESTClient{}
-}
-
-func (c *fakeDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) {
-	c.groupCalls = c.groupCalls + 1
-	return c.serverGroups()
-}
-
-func (c *fakeDiscoveryClient) serverGroups() (*metav1.APIGroupList, error) {
-	return &metav1.APIGroupList{
-		Groups: []metav1.APIGroup{
-			{
-				Name: "a",
-				Versions: []metav1.GroupVersionForDiscovery{
-					{
-						GroupVersion: "a/v1",
-						Version:      "v1",
-					},
-				},
-				PreferredVersion: metav1.GroupVersionForDiscovery{
-					GroupVersion: "a/v1",
-					Version:      "v1",
-				},
-			},
-		},
-	}, nil
-}
-
-func (c *fakeDiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	c.resourceCalls = c.resourceCalls + 1
-	if groupVersion == "a/v1" {
-		return &metav1.APIResourceList{APIResources: []metav1.APIResource{{Name: "widgets", Kind: "Widget"}}}, nil
-	}
-
-	return nil, errors.NewNotFound(schema.GroupResource{}, "")
-}
-
-// Deprecated: use ServerGroupsAndResources instead.
-func (c *fakeDiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
-	_, rs, err := c.ServerGroupsAndResources()
-	return rs, err
-}
-
-func (c *fakeDiscoveryClient) ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-	c.resourceCalls = c.resourceCalls + 1
-
-	gs, _ := c.serverGroups()
-	resultGroups := []*metav1.APIGroup{}
-	for i := range gs.Groups {
-		resultGroups = append(resultGroups, &gs.Groups[i])
-	}
-
-	if c.serverResourcesHandler != nil {
-		rs, err := c.serverResourcesHandler()
-		return resultGroups, rs, err
-	}
-	return resultGroups, []*metav1.APIResourceList{}, nil
-}
-
-func (c *fakeDiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	c.resourceCalls = c.resourceCalls + 1
-	return nil, nil
-}
-
-func (c *fakeDiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	c.resourceCalls = c.resourceCalls + 1
-	return nil, nil
-}
-
-func (c *fakeDiscoveryClient) ServerVersion() (*version.Info, error) {
-	c.versionCalls = c.versionCalls + 1
-	return &version.Info{}, nil
-}
-
-func (c *fakeDiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
-	c.openAPICalls = c.openAPICalls + 1
-	return &openapi_v2.Document{}, nil
-}

discovery/cached/disk/round_tripper.go

@@ -1,65 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package disk
-
-import (
-	"net/http"
-	"os"
-	"path/filepath"
-
-	"github.com/gregjones/httpcache"
-	"github.com/gregjones/httpcache/diskcache"
-	"github.com/peterbourgon/diskv"
-	"k8s.io/klog/v2"
-)
-
-type cacheRoundTripper struct {
-	rt *httpcache.Transport
-}
-
-// newCacheRoundTripper creates a roundtripper that reads the ETag on
-// response headers and send the If-None-Match header on subsequent
-// corresponding requests.
-func newCacheRoundTripper(cacheDir string, rt http.RoundTripper) http.RoundTripper {
-	d := diskv.New(diskv.Options{
-		PathPerm: os.FileMode(0750),
-		FilePerm: os.FileMode(0660),
-		BasePath: cacheDir,
-		TempDir:  filepath.Join(cacheDir, ".diskv-temp"),
-	})
-	t := httpcache.NewTransport(diskcache.NewWithDiskv(d))
-	t.Transport = rt
-
-	return &cacheRoundTripper{rt: t}
-}
-
-func (rt *cacheRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	return rt.rt.RoundTrip(req)
-}
-
-func (rt *cacheRoundTripper) CancelRequest(req *http.Request) {
-	type canceler interface {
-		CancelRequest(*http.Request)
-	}
-	if cr, ok := rt.rt.Transport.(canceler); ok {
-		cr.CancelRequest(req)
-	} else {
-		klog.Errorf("CancelRequest not implemented by %T", rt.rt.Transport)
-	}
-}
-
-func (rt *cacheRoundTripper) WrappedRoundTripper() http.RoundTripper { return rt.rt.Transport }

discovery/cached/disk/round_tripper_test.go

@@ -1,147 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package disk
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// copied from k8s.io/client-go/transport/round_trippers_test.go
-type testRoundTripper struct {
-	Request  *http.Request
-	Response *http.Response
-	Err      error
-}
-
-func (rt *testRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	rt.Request = req
-	return rt.Response, rt.Err
-}
-
-func TestCacheRoundTripper(t *testing.T) {
-	rt := &testRoundTripper{}
-	cacheDir, err := ioutil.TempDir("", "cache-rt")
-	defer os.RemoveAll(cacheDir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cache := newCacheRoundTripper(cacheDir, rt)
-
-	// First call, caches the response
-	req := &http.Request{
-		Method: http.MethodGet,
-		URL:    &url.URL{Host: "localhost"},
-	}
-	rt.Response = &http.Response{
-		Header:     http.Header{"ETag": []string{`"123456"`}},
-		Body:       ioutil.NopCloser(bytes.NewReader([]byte("Content"))),
-		StatusCode: http.StatusOK,
-	}
-	resp, err := cache.RoundTrip(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	content, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "Content" {
-		t.Errorf(`Expected Body to be "Content", got %q`, string(content))
-	}
-
-	// Second call, returns cached response
-	req = &http.Request{
-		Method: http.MethodGet,
-		URL:    &url.URL{Host: "localhost"},
-	}
-	rt.Response = &http.Response{
-		StatusCode: http.StatusNotModified,
-		Body:       ioutil.NopCloser(bytes.NewReader([]byte("Other Content"))),
-	}
-
-	resp, err = cache.RoundTrip(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Read body and make sure we have the initial content
-	content, err = ioutil.ReadAll(resp.Body)
-	resp.Body.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "Content" {
-		t.Errorf("Invalid content read from cache %q", string(content))
-	}
-}
-
-func TestCacheRoundTripperPathPerm(t *testing.T) {
-	assert := assert.New(t)
-
-	rt := &testRoundTripper{}
-	cacheDir, err := ioutil.TempDir("", "cache-rt")
-	os.RemoveAll(cacheDir)
-	defer os.RemoveAll(cacheDir)
-
-	if err != nil {
-		t.Fatal(err)
-	}
-	cache := newCacheRoundTripper(cacheDir, rt)
-
-	// First call, caches the response
-	req := &http.Request{
-		Method: http.MethodGet,
-		URL:    &url.URL{Host: "localhost"},
-	}
-	rt.Response = &http.Response{
-		Header:     http.Header{"ETag": []string{`"123456"`}},
-		Body:       ioutil.NopCloser(bytes.NewReader([]byte("Content"))),
-		StatusCode: http.StatusOK,
-	}
-	resp, err := cache.RoundTrip(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	content, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "Content" {
-		t.Errorf(`Expected Body to be "Content", got %q`, string(content))
-	}
-
-	err = filepath.Walk(cacheDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if info.IsDir() {
-			assert.Equal(os.FileMode(0750), info.Mode().Perm())
-		} else {
-			assert.Equal(os.FileMode(0660), info.Mode().Perm())
-		}
-		return nil
-	})
-	assert.NoError(err)
-}

discovery/cached/memcache.go

@@ -14,17 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package memory
+package cached
 
 import (
 	"errors"
 	"fmt"
 	"sync"
-	"syscall"
 
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
+	"github.com/googleapis/gnostic/OpenAPIv2"
 
-	errorsutil "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/version"
@@ -32,99 +30,64 @@ import (
 	restclient "k8s.io/client-go/rest"
 )
 
-type cacheEntry struct {
-	resourceList *metav1.APIResourceList
-	err          error
-}
-
 // memCacheClient can Invalidate() to stay up-to-date with discovery
 // information.
 //
-// TODO: Switch to a watch interface. Right now it will poll after each
-// Invalidate() call.
+// TODO: Switch to a watch interface. Right now it will poll anytime
+// Invalidate() is called.
 type memCacheClient struct {
 	delegate discovery.DiscoveryInterface
 
 	lock                   sync.RWMutex
-	groupToServerResources map[string]*cacheEntry
+	groupToServerResources map[string]*metav1.APIResourceList
 	groupList              *metav1.APIGroupList
 	cacheValid             bool
 }
 
-// Error Constants
 var (
+	ErrCacheEmpty    = errors.New("the cache has not been filled yet")
 	ErrCacheNotFound = errors.New("not found")
 )
 
 var _ discovery.CachedDiscoveryInterface = &memCacheClient{}
 
-// isTransientConnectionError checks whether given error is "Connection refused" or
-// "Connection reset" error which usually means that apiserver is temporarily
-// unavailable.
-func isTransientConnectionError(err error) bool {
-	var errno syscall.Errno
-	if errors.As(err, &errno) {
-		return errno == syscall.ECONNREFUSED || errno == syscall.ECONNRESET
-	}
-	return false
-}
-
-func isTransientError(err error) bool {
-	if isTransientConnectionError(err) {
-		return true
-	}
-
-	if t, ok := err.(errorsutil.APIStatus); ok && t.Status().Code >= 500 {
-		return true
-	}
-
-	return errorsutil.IsTooManyRequests(err)
-}
-
 // ServerResourcesForGroupVersion returns the supported resources for a group and version.
 func (d *memCacheClient) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	d.lock.Lock()
-	defer d.lock.Unlock()
+	d.lock.RLock()
+	defer d.lock.RUnlock()
 	if !d.cacheValid {
-		if err := d.refreshLocked(); err != nil {
-			return nil, err
-		}
+		return nil, ErrCacheEmpty
 	}
 	cachedVal, ok := d.groupToServerResources[groupVersion]
 	if !ok {
 		return nil, ErrCacheNotFound
 	}
-
-	if cachedVal.err != nil && isTransientError(cachedVal.err) {
-		r, err := d.serverResourcesForGroupVersion(groupVersion)
-		if err != nil {
-			utilruntime.HandleError(fmt.Errorf("couldn't get resource list for %v: %v", groupVersion, err))
-		}
-		cachedVal = &cacheEntry{r, err}
-		d.groupToServerResources[groupVersion] = cachedVal
-	}
-
-	return cachedVal.resourceList, cachedVal.err
+	return cachedVal, nil
 }
 
 // ServerResources returns the supported resources for all groups and versions.
-// Deprecated: use ServerGroupsAndResources instead.
 func (d *memCacheClient) ServerResources() ([]*metav1.APIResourceList, error) {
-	return discovery.ServerResources(d)
-}
-
-// ServerGroupsAndResources returns the groups and supported resources for all groups and versions.
-func (d *memCacheClient) ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-	return discovery.ServerGroupsAndResources(d)
+	apiGroups, err := d.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
+	groupVersions := metav1.ExtractGroupVersions(apiGroups)
+	result := []*metav1.APIResourceList{}
+	for _, groupVersion := range groupVersions {
+		resources, err := d.ServerResourcesForGroupVersion(groupVersion)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, resources)
+	}
+	return result, nil
 }
 
 func (d *memCacheClient) ServerGroups() (*metav1.APIGroupList, error) {
-	d.lock.Lock()
-	defer d.lock.Unlock()
-	if !d.cacheValid {
-		if err := d.refreshLocked(); err != nil {
-			return nil, err
-		}
+	d.lock.RLock()
+	defer d.lock.RUnlock()
+	if d.groupList == nil {
+		return nil, ErrCacheEmpty
 	}
 	return d.groupList, nil
 }
@@ -133,12 +96,18 @@ func (d *memCacheClient) RESTClient() restclient.Interface {
 	return d.delegate.RESTClient()
 }
 
+// TODO: Should this also be cached? The results seem more likely to be
+// inconsistent with ServerGroups and ServerResources given the requirement to
+// actively Invalidate.
 func (d *memCacheClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	return discovery.ServerPreferredResources(d)
+	return d.delegate.ServerPreferredResources()
 }
 
+// TODO: Should this also be cached? The results seem more likely to be
+// inconsistent with ServerGroups and ServerResources given the requirement to
+// actively Invalidate.
 func (d *memCacheClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	return discovery.ServerPreferredNamespacedResources(d)
+	return d.delegate.ServerPreferredNamespacedResources()
 }
 
 func (d *memCacheClient) ServerVersion() (*version.Info, error) {
@@ -152,72 +121,49 @@ func (d *memCacheClient) OpenAPISchema() (*openapi_v2.Document, error) {
 func (d *memCacheClient) Fresh() bool {
 	d.lock.RLock()
 	defer d.lock.RUnlock()
-	// Return whether the cache is populated at all. It is still possible that
-	// a single entry is missing due to transient errors and the attempt to read
-	// that entry will trigger retry.
+	// Fresh is supposed to tell the caller whether or not to retry if the cache
+	// fails to find something. The idea here is that Invalidate will be called
+	// periodically and therefore we'll always be returning the latest data. (And
+	// in the future we can watch and stay even more up-to-date.) So we only
+	// return false if the cache has never been filled.
 	return d.cacheValid
 }
 
-// Invalidate enforces that no cached data that is older than the current time
-// is used.
+// Invalidate refreshes the cache, blocking calls until the cache has been
+// refreshed. It would be trivial to make a version that does this in the
+// background while continuing to respond to requests if needed.
 func (d *memCacheClient) Invalidate() {
 	d.lock.Lock()
 	defer d.lock.Unlock()
-	d.cacheValid = false
-	d.groupToServerResources = nil
-	d.groupList = nil
-}
 
-// refreshLocked refreshes the state of cache. The caller must hold d.lock for
-// writing.
-func (d *memCacheClient) refreshLocked() error {
 	// TODO: Could this multiplicative set of calls be replaced by a single call
 	// to ServerResources? If it's possible for more than one resulting
 	// APIResourceList to have the same GroupVersion, the lists would need merged.
 	gl, err := d.delegate.ServerGroups()
 	if err != nil || len(gl.Groups) == 0 {
-		utilruntime.HandleError(fmt.Errorf("couldn't get current server API group list: %v", err))
-		return err
+		utilruntime.HandleError(fmt.Errorf("couldn't get current server API group list; will keep using cached value. (%v)", err))
+		return
 	}
 
-	wg := &sync.WaitGroup{}
-	resultLock := &sync.Mutex{}
-	rl := map[string]*cacheEntry{}
+	rl := map[string]*metav1.APIResourceList{}
 	for _, g := range gl.Groups {
 		for _, v := range g.Versions {
-			gv := v.GroupVersion
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				defer utilruntime.HandleCrash()
-
-				r, err := d.serverResourcesForGroupVersion(gv)
-				if err != nil {
-					utilruntime.HandleError(fmt.Errorf("couldn't get resource list for %v: %v", gv, err))
+			r, err := d.delegate.ServerResourcesForGroupVersion(v.GroupVersion)
+			if err != nil || len(r.APIResources) == 0 {
+				utilruntime.HandleError(fmt.Errorf("couldn't get resource list for %v: %v", v.GroupVersion, err))
+				if cur, ok := d.groupToServerResources[v.GroupVersion]; ok {
+					// retain the existing list, if we had it.
+					r = cur
+				} else {
+					continue
 				}
-
-				resultLock.Lock()
-				defer resultLock.Unlock()
-				rl[gv] = &cacheEntry{r, err}
-			}()
+			}
+			rl[v.GroupVersion] = r
 		}
 	}
-	wg.Wait()
 
 	d.groupToServerResources, d.groupList = rl, gl
 	d.cacheValid = true
-	return nil
-}
-
-func (d *memCacheClient) serverResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	r, err := d.delegate.ServerResourcesForGroupVersion(groupVersion)
-	if err != nil {
-		return r, err
-	}
-	if len(r.APIResources) == 0 {
-		return r, fmt.Errorf("Got empty response for: %v", groupVersion)
-	}
-	return r, nil
 }
 
 // NewMemCacheClient creates a new CachedDiscoveryInterface which caches
@@ -228,6 +174,6 @@ func (d *memCacheClient) serverResourcesForGroupVersion(groupVersion string) (*m
 func NewMemCacheClient(delegate discovery.DiscoveryInterface) discovery.CachedDiscoveryInterface {
 	return &memCacheClient{
 		delegate:               delegate,
-		groupToServerResources: map[string]*cacheEntry{},
+		groupToServerResources: map[string]*metav1.APIResourceList{},
 	}
 }

discovery/cached/memcache_test.go

@@ -0,0 +1,132 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cached
+
+import (
+	"errors"
+	"reflect"
+	"sync"
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/discovery/fake"
+)
+
+type fakeDiscovery struct {
+	*fake.FakeDiscovery
+
+	lock        sync.Mutex
+	groupList   *metav1.APIGroupList
+	resourceMap map[string]*metav1.APIResourceList
+}
+
+func (c *fakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	if rl, ok := c.resourceMap[groupVersion]; ok {
+		return rl, nil
+	}
+	return nil, errors.New("doesn't exist")
+}
+
+func (c *fakeDiscovery) ServerGroups() (*metav1.APIGroupList, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	if c.groupList == nil {
+		return nil, errors.New("doesn't exist")
+	}
+	return c.groupList, nil
+}
+
+func TestClient(t *testing.T) {
+	fake := &fakeDiscovery{
+		groupList: &metav1.APIGroupList{
+			Groups: []metav1.APIGroup{{
+				Name: "astronomy",
+				Versions: []metav1.GroupVersionForDiscovery{{
+					GroupVersion: "astronomy/v8beta1",
+					Version:      "v8beta1",
+				}},
+			}},
+		},
+		resourceMap: map[string]*metav1.APIResourceList{
+			"astronomy/v8beta1": {
+				GroupVersion: "astronomy/v8beta1",
+				APIResources: []metav1.APIResource{{
+					Name:         "dwarfplanets",
+					SingularName: "dwarfplanet",
+					Namespaced:   true,
+					Kind:         "DwarfPlanet",
+					ShortNames:   []string{"dp"},
+				}},
+			},
+		},
+	}
+
+	c := NewMemCacheClient(fake)
+	g, err := c.ServerGroups()
+	if err == nil {
+		t.Errorf("Unexpected non-error.")
+	}
+	if c.Fresh() {
+		t.Errorf("Expected not fresh.")
+	}
+
+	c.Invalidate()
+	if !c.Fresh() {
+		t.Errorf("Expected fresh.")
+	}
+
+	g, err = c.ServerGroups()
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if e, a := fake.groupList, g; !reflect.DeepEqual(e, a) {
+		t.Errorf("Expected %#v, got %#v", e, a)
+	}
+	r, err := c.ServerResourcesForGroupVersion("astronomy/v8beta1")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if e, a := fake.resourceMap["astronomy/v8beta1"], r; !reflect.DeepEqual(e, a) {
+		t.Errorf("Expected %#v, got %#v", e, a)
+	}
+
+	fake.lock.Lock()
+	fake.resourceMap = map[string]*metav1.APIResourceList{
+		"astronomy/v8beta1": {
+			GroupVersion: "astronomy/v8beta1",
+			APIResources: []metav1.APIResource{{
+				Name:         "stars",
+				SingularName: "star",
+				Namespaced:   true,
+				Kind:         "Star",
+				ShortNames:   []string{"s"},
+			}},
+		},
+	}
+	fake.lock.Unlock()
+
+	c.Invalidate()
+	r, err = c.ServerResourcesForGroupVersion("astronomy/v8beta1")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if e, a := fake.resourceMap["astronomy/v8beta1"], r; !reflect.DeepEqual(e, a) {
+		t.Errorf("Expected %#v, got %#v", e, a)
+	}
+}

discovery/cached/memory/memcache_test.go

@@ -1,392 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package memory
-
-import (
-	"errors"
-	"net/http"
-	"reflect"
-	"sync"
-	"testing"
-
-	errorsutil "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/discovery/fake"
-)
-
-type resourceMapEntry struct {
-	list *metav1.APIResourceList
-	err  error
-}
-
-type fakeDiscovery struct {
-	*fake.FakeDiscovery
-
-	lock         sync.Mutex
-	groupList    *metav1.APIGroupList
-	groupListErr error
-	resourceMap  map[string]*resourceMapEntry
-}
-
-func (c *fakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if rl, ok := c.resourceMap[groupVersion]; ok {
-		return rl.list, rl.err
-	}
-	return nil, errors.New("doesn't exist")
-}
-
-func (c *fakeDiscovery) ServerGroups() (*metav1.APIGroupList, error) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if c.groupList == nil {
-		return nil, errors.New("doesn't exist")
-	}
-	return c.groupList, c.groupListErr
-}
-
-func TestClient(t *testing.T) {
-	fake := &fakeDiscovery{
-		groupList: &metav1.APIGroupList{
-			Groups: []metav1.APIGroup{{
-				Name: "astronomy",
-				Versions: []metav1.GroupVersionForDiscovery{{
-					GroupVersion: "astronomy/v8beta1",
-					Version:      "v8beta1",
-				}},
-			}},
-		},
-		resourceMap: map[string]*resourceMapEntry{
-			"astronomy/v8beta1": {
-				list: &metav1.APIResourceList{
-					GroupVersion: "astronomy/v8beta1",
-					APIResources: []metav1.APIResource{{
-						Name:         "dwarfplanets",
-						SingularName: "dwarfplanet",
-						Namespaced:   true,
-						Kind:         "DwarfPlanet",
-						ShortNames:   []string{"dp"},
-					}},
-				},
-			},
-		},
-	}
-
-	c := NewMemCacheClient(fake)
-	if c.Fresh() {
-		t.Errorf("Expected not fresh.")
-	}
-	g, err := c.ServerGroups()
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if e, a := fake.groupList, g; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-	if !c.Fresh() {
-		t.Errorf("Expected fresh.")
-	}
-	c.Invalidate()
-	if c.Fresh() {
-		t.Errorf("Expected not fresh.")
-	}
-
-	g, err = c.ServerGroups()
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if e, a := fake.groupList, g; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-	if !c.Fresh() {
-		t.Errorf("Expected fresh.")
-	}
-	r, err := c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if e, a := fake.resourceMap["astronomy/v8beta1"].list, r; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-
-	fake.lock.Lock()
-	fake.resourceMap = map[string]*resourceMapEntry{
-		"astronomy/v8beta1": {
-			list: &metav1.APIResourceList{
-				GroupVersion: "astronomy/v8beta1",
-				APIResources: []metav1.APIResource{{
-					Name:         "stars",
-					SingularName: "star",
-					Namespaced:   true,
-					Kind:         "Star",
-					ShortNames:   []string{"s"},
-				}},
-			},
-		},
-	}
-	fake.lock.Unlock()
-
-	c.Invalidate()
-	r, err = c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if e, a := fake.resourceMap["astronomy/v8beta1"].list, r; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-}
-
-func TestServerGroupsFails(t *testing.T) {
-	fake := &fakeDiscovery{
-		groupList: &metav1.APIGroupList{
-			Groups: []metav1.APIGroup{{
-				Name: "astronomy",
-				Versions: []metav1.GroupVersionForDiscovery{{
-					GroupVersion: "astronomy/v8beta1",
-					Version:      "v8beta1",
-				}},
-			}},
-		},
-		groupListErr: errors.New("some error"),
-		resourceMap: map[string]*resourceMapEntry{
-			"astronomy/v8beta1": {
-				list: &metav1.APIResourceList{
-					GroupVersion: "astronomy/v8beta1",
-					APIResources: []metav1.APIResource{{
-						Name:         "dwarfplanets",
-						SingularName: "dwarfplanet",
-						Namespaced:   true,
-						Kind:         "DwarfPlanet",
-						ShortNames:   []string{"dp"},
-					}},
-				},
-			},
-		},
-	}
-
-	c := NewMemCacheClient(fake)
-	if c.Fresh() {
-		t.Errorf("Expected not fresh.")
-	}
-	_, err := c.ServerGroups()
-	if err == nil {
-		t.Errorf("Expected error")
-	}
-	if c.Fresh() {
-		t.Errorf("Expected not fresh.")
-	}
-	fake.lock.Lock()
-	fake.groupListErr = nil
-	fake.lock.Unlock()
-	r, err := c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if e, a := fake.resourceMap["astronomy/v8beta1"].list, r; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-	if !c.Fresh() {
-		t.Errorf("Expected not fresh.")
-	}
-}
-
-func TestPartialPermanentFailure(t *testing.T) {
-	fake := &fakeDiscovery{
-		groupList: &metav1.APIGroupList{
-			Groups: []metav1.APIGroup{
-				{
-					Name: "astronomy",
-					Versions: []metav1.GroupVersionForDiscovery{{
-						GroupVersion: "astronomy/v8beta1",
-						Version:      "v8beta1",
-					}},
-				},
-				{
-					Name: "astronomy2",
-					Versions: []metav1.GroupVersionForDiscovery{{
-						GroupVersion: "astronomy2/v8beta1",
-						Version:      "v8beta1",
-					}},
-				},
-			},
-		},
-		resourceMap: map[string]*resourceMapEntry{
-			"astronomy/v8beta1": {
-				err: errors.New("some permanent error"),
-			},
-			"astronomy2/v8beta1": {
-				list: &metav1.APIResourceList{
-					GroupVersion: "astronomy2/v8beta1",
-					APIResources: []metav1.APIResource{{
-						Name:         "dwarfplanets",
-						SingularName: "dwarfplanet",
-						Namespaced:   true,
-						Kind:         "DwarfPlanet",
-						ShortNames:   []string{"dp"},
-					}},
-				},
-			},
-		},
-	}
-
-	c := NewMemCacheClient(fake)
-	if c.Fresh() {
-		t.Errorf("Expected not fresh.")
-	}
-	r, err := c.ServerResourcesForGroupVersion("astronomy2/v8beta1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if e, a := fake.resourceMap["astronomy2/v8beta1"].list, r; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-	_, err = c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err == nil {
-		t.Errorf("Expected error, got nil")
-	}
-
-	fake.lock.Lock()
-	fake.resourceMap["astronomy/v8beta1"] = &resourceMapEntry{
-		list: &metav1.APIResourceList{
-			GroupVersion: "astronomy/v8beta1",
-			APIResources: []metav1.APIResource{{
-				Name:         "dwarfplanets",
-				SingularName: "dwarfplanet",
-				Namespaced:   true,
-				Kind:         "DwarfPlanet",
-				ShortNames:   []string{"dp"},
-			}},
-		},
-		err: nil,
-	}
-	fake.lock.Unlock()
-	// We don't retry permanent errors, so it should fail.
-	_, err = c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err == nil {
-		t.Errorf("Expected error, got nil")
-	}
-	c.Invalidate()
-
-	// After Invalidate, we should retry.
-	r, err = c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if e, a := fake.resourceMap["astronomy/v8beta1"].list, r; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-}
-
-func TestPartialRetryableFailure(t *testing.T) {
-	fake := &fakeDiscovery{
-		groupList: &metav1.APIGroupList{
-			Groups: []metav1.APIGroup{
-				{
-					Name: "astronomy",
-					Versions: []metav1.GroupVersionForDiscovery{{
-						GroupVersion: "astronomy/v8beta1",
-						Version:      "v8beta1",
-					}},
-				},
-				{
-					Name: "astronomy2",
-					Versions: []metav1.GroupVersionForDiscovery{{
-						GroupVersion: "astronomy2/v8beta1",
-						Version:      "v8beta1",
-					}},
-				},
-			},
-		},
-		resourceMap: map[string]*resourceMapEntry{
-			"astronomy/v8beta1": {
-				err: &errorsutil.StatusError{
-					ErrStatus: metav1.Status{
-						Message: "Some retryable error",
-						Code:    int32(http.StatusServiceUnavailable),
-						Reason:  metav1.StatusReasonServiceUnavailable,
-					},
-				},
-			},
-			"astronomy2/v8beta1": {
-				list: &metav1.APIResourceList{
-					GroupVersion: "astronomy2/v8beta1",
-					APIResources: []metav1.APIResource{{
-						Name:         "dwarfplanets",
-						SingularName: "dwarfplanet",
-						Namespaced:   true,
-						Kind:         "DwarfPlanet",
-						ShortNames:   []string{"dp"},
-					}},
-				},
-			},
-		},
-	}
-
-	c := NewMemCacheClient(fake)
-	if c.Fresh() {
-		t.Errorf("Expected not fresh.")
-	}
-	r, err := c.ServerResourcesForGroupVersion("astronomy2/v8beta1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if e, a := fake.resourceMap["astronomy2/v8beta1"].list, r; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-	_, err = c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err == nil {
-		t.Errorf("Expected error, got nil")
-	}
-
-	fake.lock.Lock()
-	fake.resourceMap["astronomy/v8beta1"] = &resourceMapEntry{
-		list: &metav1.APIResourceList{
-			GroupVersion: "astronomy/v8beta1",
-			APIResources: []metav1.APIResource{{
-				Name:         "dwarfplanets",
-				SingularName: "dwarfplanet",
-				Namespaced:   true,
-				Kind:         "DwarfPlanet",
-				ShortNames:   []string{"dp"},
-			}},
-		},
-		err: nil,
-	}
-	fake.lock.Unlock()
-	// We should retry retryable error even without Invalidate() being called,
-	// so no error is expected.
-	r, err = c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err != nil {
-		t.Errorf("Expected no error, got %v", err)
-	}
-	if e, a := fake.resourceMap["astronomy/v8beta1"].list, r; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-
-	// Check that the last result was cached and we don't retry further.
-	fake.lock.Lock()
-	fake.resourceMap["astronomy/v8beta1"].err = errors.New("some permanent error")
-	fake.lock.Unlock()
-	r, err = c.ServerResourcesForGroupVersion("astronomy/v8beta1")
-	if err != nil {
-		t.Errorf("Expected no error, got %v", err)
-	}
-	if e, a := fake.resourceMap["astronomy/v8beta1"].list, r; !reflect.DeepEqual(e, a) {
-		t.Errorf("Expected %#v, got %#v", e, a)
-	}
-}

discovery/discovery_client.go

@@ -17,24 +17,20 @@ limitations under the License.
 package discovery
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"net/url"
 	"sort"
 	"strings"
-	"sync"
-	"time"
 
 	"github.com/golang/protobuf/proto"
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
+	"github.com/googleapis/gnostic/OpenAPIv2"
 
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/version"
 	"k8s.io/client-go/kubernetes/scheme"
 	restclient "k8s.io/client-go/rest"
@@ -45,9 +41,6 @@ const (
 	defaultRetries = 2
 	// protobuf mime type
 	mimePb = "application/com.github.proto-openapi.spec.v2@v1.0+protobuf"
-	// defaultTimeout is the maximum amount of time per request when no timeout has been set on a RESTClient.
-	// Defaults to 32s in order to have a distinguishable length of time, relative to other timeouts that exist.
-	defaultTimeout = 32 * time.Second
 )
 
 // DiscoveryInterface holds the methods that discover server-supported API groups,
@@ -61,9 +54,6 @@ type DiscoveryInterface interface {
 }
 
 // CachedDiscoveryInterface is a DiscoveryInterface with cache invalidation and freshness.
-// Note that If the ServerResourcesForGroupVersion method returns a cache miss
-// error, the user needs to explicitly call Invalidate to clear the cache,
-// otherwise the same cache miss error will be returned next time.
 type CachedDiscoveryInterface interface {
 	DiscoveryInterface
 	// Fresh is supposed to tell the caller whether or not to retry if the cache
@@ -72,8 +62,7 @@ type CachedDiscoveryInterface interface {
 	// TODO: this needs to be revisited, this interface can't be locked properly
 	// and doesn't make a lot of sense.
 	Fresh() bool
-	// Invalidate enforces that no cached data that is older than the current time
-	// is used.
+	// Invalidate enforces that no cached data is used in the future that is older than the current time.
 	Invalidate()
 }
 
@@ -89,28 +78,12 @@ type ServerResourcesInterface interface {
 	// ServerResourcesForGroupVersion returns the supported resources for a group and version.
 	ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error)
 	// ServerResources returns the supported resources for all groups and versions.
-	//
-	// The returned resource list might be non-nil with partial results even in the case of
-	// non-nil error.
-	//
-	// Deprecated: use ServerGroupsAndResources instead.
 	ServerResources() ([]*metav1.APIResourceList, error)
-	// ServerResources returns the supported groups and resources for all groups and versions.
-	//
-	// The returned group and resource lists might be non-nil with partial results even in the
-	// case of non-nil error.
-	ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error)
 	// ServerPreferredResources returns the supported resources with the version preferred by the
 	// server.
-	//
-	// The returned group and resource lists might be non-nil with partial results even in the
-	// case of non-nil error.
 	ServerPreferredResources() ([]*metav1.APIResourceList, error)
 	// ServerPreferredNamespacedResources returns the supported namespaced resources with the
 	// version preferred by the server.
-	//
-	// The returned resource list might be non-nil with partial results even in the case of
-	// non-nil error.
 	ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error)
 }
 
@@ -156,7 +129,7 @@ func apiVersionsToAPIGroup(apiVersions *metav1.APIVersions) (apiGroup metav1.API
 func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err error) {
 	// Get the groupVersions exposed at /api
 	v := &metav1.APIVersions{}
-	err = d.restClient.Get().AbsPath(d.LegacyPrefix).Do(context.TODO()).Into(v)
+	err = d.restClient.Get().AbsPath(d.LegacyPrefix).Do().Into(v)
 	apiGroup := metav1.APIGroup{}
 	if err == nil && len(v.Versions) != 0 {
 		apiGroup = apiVersionsToAPIGroup(v)
@@ -167,7 +140,7 @@ func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err
 
 	// Get the groupVersions exposed at /apis
 	apiGroupList = &metav1.APIGroupList{}
-	err = d.restClient.Get().AbsPath("/apis").Do(context.TODO()).Into(apiGroupList)
+	err = d.restClient.Get().AbsPath("/apis").Do().Into(apiGroupList)
 	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
 		return nil, err
 	}
@@ -197,7 +170,7 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r
 	resources = &metav1.APIResourceList{
 		GroupVersion: groupVersion,
 	}
-	err = d.restClient.Get().AbsPath(url.String()).Do(context.TODO()).Into(resources)
+	err = d.restClient.Get().AbsPath(url.String()).Do().Into(resources)
 	if err != nil {
 		// ignore 403 or 404 error to be compatible with an v1.0 server.
 		if groupVersion == "v1" && (errors.IsNotFound(err) || errors.IsForbidden(err)) {
@@ -208,18 +181,40 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r
 	return resources, nil
 }
 
-// ServerResources returns the supported resources for all groups and versions.
-// Deprecated: use ServerGroupsAndResources instead.
-func (d *DiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
-	_, rs, err := d.ServerGroupsAndResources()
-	return rs, err
+// serverResources returns the supported resources for all groups and versions.
+func (d *DiscoveryClient) serverResources() ([]*metav1.APIResourceList, error) {
+	apiGroups, err := d.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
+
+	result := []*metav1.APIResourceList{}
+	failedGroups := make(map[schema.GroupVersion]error)
+
+	for _, apiGroup := range apiGroups.Groups {
+		for _, version := range apiGroup.Versions {
+			gv := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
+			resources, err := d.ServerResourcesForGroupVersion(version.GroupVersion)
+			if err != nil {
+				// TODO: maybe restrict this to NotFound errors
+				failedGroups[gv] = err
+				continue
+			}
+
+			result = append(result, resources)
+		}
+	}
+
+	if len(failedGroups) == 0 {
+		return result, nil
+	}
+
+	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
 }
 
-// ServerGroupsAndResources returns the supported resources for all groups and versions.
-func (d *DiscoveryClient) ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-	return withRetries(defaultRetries, func() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-		return ServerGroupsAndResources(d)
-	})
+// ServerResources returns the supported resources for all groups and versions.
+func (d *DiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
+	return withRetries(defaultRetries, d.serverResources)
 }
 
 // ErrGroupDiscoveryFailed is returned if one or more API groups fail to load.
@@ -245,72 +240,36 @@ func IsGroupDiscoveryFailedError(err error) bool {
 	return err != nil && ok
 }
 
-// ServerResources uses the provided discovery interface to look up supported resources for all groups and versions.
-// Deprecated: use ServerGroupsAndResources instead.
-func ServerResources(d DiscoveryInterface) ([]*metav1.APIResourceList, error) {
-	_, rs, err := ServerGroupsAndResources(d)
-	return rs, err
-}
-
-func ServerGroupsAndResources(d DiscoveryInterface) ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-	sgs, err := d.ServerGroups()
-	if sgs == nil {
-		return nil, nil, err
-	}
-	resultGroups := []*metav1.APIGroup{}
-	for i := range sgs.Groups {
-		resultGroups = append(resultGroups, &sgs.Groups[i])
-	}
-
-	groupVersionResources, failedGroups := fetchGroupVersionResources(d, sgs)
-
-	// order results by group/version discovery order
-	result := []*metav1.APIResourceList{}
-	for _, apiGroup := range sgs.Groups {
-		for _, version := range apiGroup.Versions {
-			gv := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
-			if resources, ok := groupVersionResources[gv]; ok {
-				result = append(result, resources)
-			}
-		}
-	}
-
-	if len(failedGroups) == 0 {
-		return resultGroups, result, nil
-	}
-
-	return resultGroups, result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
-}
-
-// ServerPreferredResources uses the provided discovery interface to look up preferred resources
-func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList, error) {
+// serverPreferredResources returns the supported resources with the version preferred by the server.
+func (d *DiscoveryClient) serverPreferredResources() ([]*metav1.APIResourceList, error) {
 	serverGroupList, err := d.ServerGroups()
 	if err != nil {
 		return nil, err
 	}
 
-	groupVersionResources, failedGroups := fetchGroupVersionResources(d, serverGroupList)
-
 	result := []*metav1.APIResourceList{}
+	failedGroups := make(map[schema.GroupVersion]error)
+
 	grVersions := map[schema.GroupResource]string{}                         // selected version of a GroupResource
-	grAPIResources := map[schema.GroupResource]*metav1.APIResource{}        // selected APIResource for a GroupResource
-	gvAPIResourceLists := map[schema.GroupVersion]*metav1.APIResourceList{} // blueprint for a APIResourceList for later grouping
+	grApiResources := map[schema.GroupResource]*metav1.APIResource{}        // selected APIResource for a GroupResource
+	gvApiResourceLists := map[schema.GroupVersion]*metav1.APIResourceList{} // blueprint for a APIResourceList for later grouping
 
 	for _, apiGroup := range serverGroupList.Groups {
 		for _, version := range apiGroup.Versions {
 			groupVersion := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
-
-			apiResourceList, ok := groupVersionResources[groupVersion]
-			if !ok {
+			apiResourceList, err := d.ServerResourcesForGroupVersion(version.GroupVersion)
+			if err != nil {
+				// TODO: maybe restrict this to NotFound errors
+				failedGroups[groupVersion] = err
 				continue
 			}
 
 			// 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]
@@ -318,21 +277,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)
 	}
 
@@ -343,62 +302,16 @@ func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList,
 	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
 }
 
-// fetchServerResourcesForGroupVersions uses the discovery client to fetch the resources for the specified groups in parallel.
-func fetchGroupVersionResources(d DiscoveryInterface, apiGroups *metav1.APIGroupList) (map[schema.GroupVersion]*metav1.APIResourceList, map[schema.GroupVersion]error) {
-	groupVersionResources := make(map[schema.GroupVersion]*metav1.APIResourceList)
-	failedGroups := make(map[schema.GroupVersion]error)
-
-	wg := &sync.WaitGroup{}
-	resultLock := &sync.Mutex{}
-	for _, apiGroup := range apiGroups.Groups {
-		for _, version := range apiGroup.Versions {
-			groupVersion := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				defer utilruntime.HandleCrash()
-
-				apiResourceList, err := d.ServerResourcesForGroupVersion(groupVersion.String())
-
-				// lock to record results
-				resultLock.Lock()
-				defer resultLock.Unlock()
-
-				if err != nil {
-					// TODO: maybe restrict this to NotFound errors
-					failedGroups[groupVersion] = err
-				}
-				if apiResourceList != nil {
-					// even in case of error, some fallback might have been returned
-					groupVersionResources[groupVersion] = apiResourceList
-				}
-			}()
-		}
-	}
-	wg.Wait()
-
-	return groupVersionResources, failedGroups
-}
-
 // ServerPreferredResources returns the supported resources with the version preferred by the
 // server.
 func (d *DiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	_, rs, err := withRetries(defaultRetries, func() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-		rs, err := ServerPreferredResources(d)
-		return nil, rs, err
-	})
-	return rs, err
+	return withRetries(defaultRetries, d.serverPreferredResources)
 }
 
 // ServerPreferredNamespacedResources returns the supported namespaced resources with the
 // version preferred by the server.
 func (d *DiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	return ServerPreferredNamespacedResources(d)
-}
-
-// ServerPreferredNamespacedResources uses the provided discovery interface to look up preferred namespaced resources
-func ServerPreferredNamespacedResources(d DiscoveryInterface) ([]*metav1.APIResourceList, error) {
-	all, err := ServerPreferredResources(d)
+	all, err := d.ServerPreferredResources()
 	return FilteredBy(ResourcePredicateFunc(func(groupVersion string, r *metav1.APIResource) bool {
 		return r.Namespaced
 	}), all), err
@@ -406,26 +319,26 @@ func ServerPreferredNamespacedResources(d DiscoveryInterface) ([]*metav1.APIReso
 
 // ServerVersion retrieves and parses the server's version (git version).
 func (d *DiscoveryClient) ServerVersion() (*version.Info, error) {
-	body, err := d.restClient.Get().AbsPath("/version").Do(context.TODO()).Raw()
+	body, err := d.restClient.Get().AbsPath("/version").Do().Raw()
 	if err != nil {
 		return nil, err
 	}
 	var info version.Info
 	err = json.Unmarshal(body, &info)
 	if err != nil {
-		return nil, fmt.Errorf("unable to parse the server version: %v", err)
+		return nil, fmt.Errorf("got '%s': %v", string(body), err)
 	}
 	return &info, nil
 }
 
 // OpenAPISchema fetches the open api schema using a rest client and parses the proto.
 func (d *DiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
-	data, err := d.restClient.Get().AbsPath("/openapi/v2").SetHeader("Accept", mimePb).Do(context.TODO()).Raw()
+	data, err := d.restClient.Get().AbsPath("/openapi/v2").SetHeader("Accept", mimePb).Do().Raw()
 	if err != nil {
 		if errors.IsForbidden(err) || errors.IsNotFound(err) || errors.IsNotAcceptable(err) {
 			// single endpoint not found/registered in old server, try to fetch old endpoint
-			// TODO: remove this when kubectl/client-go don't work with 1.9 server
-			data, err = d.restClient.Get().AbsPath("/swagger-2.0.0.pb-v1").Do(context.TODO()).Raw()
+			// TODO(roycaihw): remove this in 1.11
+			data, err = d.restClient.Get().AbsPath("/swagger-2.0.0.pb-v1").Do().Raw()
 			if err != nil {
 				return nil, err
 			}
@@ -442,35 +355,24 @@ func (d *DiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
 }
 
 // withRetries retries the given recovery function in case the groups supported by the server change after ServerGroup() returns.
-func withRetries(maxRetries int, f func() ([]*metav1.APIGroup, []*metav1.APIResourceList, error)) ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
+func withRetries(maxRetries int, f func() ([]*metav1.APIResourceList, error)) ([]*metav1.APIResourceList, error) {
 	var result []*metav1.APIResourceList
-	var resultGroups []*metav1.APIGroup
 	var err error
 	for i := 0; i < maxRetries; i++ {
-		resultGroups, result, err = f()
+		result, err = f()
 		if err == nil {
-			return resultGroups, result, nil
+			return result, nil
 		}
 		if _, ok := err.(*ErrGroupDiscoveryFailed); !ok {
-			return nil, nil, err
+			return nil, err
 		}
 	}
-	return resultGroups, result, err
+	return result, err
 }
 
 func setDiscoveryDefaults(config *restclient.Config) error {
 	config.APIPath = ""
 	config.GroupVersion = nil
-	if config.Timeout == 0 {
-		config.Timeout = defaultTimeout
-	}
-	if config.Burst == 0 && config.QPS < 100 {
-		// discovery is expected to be bursty, increase the default burst
-		// to accommodate looking up resource info for many API groups.
-		// matches burst set by ConfigFlags#ToDiscoveryClient().
-		// see https://issue.k8s.io/86149
-		config.Burst = 100
-	}
 	codec := runtime.NoopEncoder{Decoder: scheme.Codecs.UniversalDecoder()}
 	config.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec})
 	if len(config.UserAgent) == 0 {
@@ -501,16 +403,16 @@ func NewDiscoveryClientForConfigOrDie(c *restclient.Config) *DiscoveryClient {
 
 }
 
-// NewDiscoveryClient returns a new DiscoveryClient for the given RESTClient.
+// NewDiscoveryClient returns  a new DiscoveryClient for the given RESTClient.
 func NewDiscoveryClient(c restclient.Interface) *DiscoveryClient {
 	return &DiscoveryClient{restClient: c, LegacyPrefix: "/api"}
 }
 
 // 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/discovery_client_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package discovery
+package discovery_test
 
 import (
 	"encoding/json"
@@ -24,17 +24,15 @@ import (
 	"net/http/httptest"
 	"reflect"
 	"testing"
-	"time"
 
 	"github.com/gogo/protobuf/proto"
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
-	"github.com/stretchr/testify/assert"
+	"github.com/googleapis/gnostic/OpenAPIv2"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/diff"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/version"
+	. "k8s.io/client-go/discovery"
 	restclient "k8s.io/client-go/rest"
 )
 
@@ -132,12 +130,6 @@ func TestGetServerGroupsWithBrokenServer(t *testing.T) {
 	}
 }
 
-func TestTimeoutIsSet(t *testing.T) {
-	cfg := &restclient.Config{}
-	setDiscoveryDefaults(cfg)
-	assert.Equal(t, defaultTimeout, cfg.Timeout)
-}
-
 func TestGetServerResourcesWithV1Server(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		var obj interface{}
@@ -191,34 +183,6 @@ func TestGetServerResources(t *testing.T) {
 			{Name: "jobs", Namespaced: true, Kind: "Job"},
 		},
 	}
-	beta2 := metav1.APIResourceList{
-		GroupVersion: "extensions/v1beta2",
-		APIResources: []metav1.APIResource{
-			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
-			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
-			{Name: "jobs", Namespaced: true, Kind: "Job"},
-		},
-	}
-	extensionsbeta3 := metav1.APIResourceList{GroupVersion: "extensions/v1beta3", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta4 := metav1.APIResourceList{GroupVersion: "extensions/v1beta4", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta5 := metav1.APIResourceList{GroupVersion: "extensions/v1beta5", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta6 := metav1.APIResourceList{GroupVersion: "extensions/v1beta6", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta7 := metav1.APIResourceList{GroupVersion: "extensions/v1beta7", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta8 := metav1.APIResourceList{GroupVersion: "extensions/v1beta8", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta9 := metav1.APIResourceList{GroupVersion: "extensions/v1beta9", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	extensionsbeta10 := metav1.APIResourceList{GroupVersion: "extensions/v1beta10", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-
-	appsbeta1 := metav1.APIResourceList{GroupVersion: "apps/v1beta1", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta2 := metav1.APIResourceList{GroupVersion: "apps/v1beta2", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta3 := metav1.APIResourceList{GroupVersion: "apps/v1beta3", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta4 := metav1.APIResourceList{GroupVersion: "apps/v1beta4", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta5 := metav1.APIResourceList{GroupVersion: "apps/v1beta5", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta6 := metav1.APIResourceList{GroupVersion: "apps/v1beta6", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta7 := metav1.APIResourceList{GroupVersion: "apps/v1beta7", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta8 := metav1.APIResourceList{GroupVersion: "apps/v1beta8", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta9 := metav1.APIResourceList{GroupVersion: "apps/v1beta9", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-	appsbeta10 := metav1.APIResourceList{GroupVersion: "apps/v1beta10", APIResources: []metav1.APIResource{{Name: "deployments", Namespaced: true, Kind: "Deployment"}}}
-
 	tests := []struct {
 		resourcesList *metav1.APIResourceList
 		path          string
@@ -251,44 +215,6 @@ func TestGetServerResources(t *testing.T) {
 			list = &stable
 		case "/apis/extensions/v1beta1":
 			list = &beta
-		case "/apis/extensions/v1beta2":
-			list = &beta2
-		case "/apis/extensions/v1beta3":
-			list = &extensionsbeta3
-		case "/apis/extensions/v1beta4":
-			list = &extensionsbeta4
-		case "/apis/extensions/v1beta5":
-			list = &extensionsbeta5
-		case "/apis/extensions/v1beta6":
-			list = &extensionsbeta6
-		case "/apis/extensions/v1beta7":
-			list = &extensionsbeta7
-		case "/apis/extensions/v1beta8":
-			list = &extensionsbeta8
-		case "/apis/extensions/v1beta9":
-			list = &extensionsbeta9
-		case "/apis/extensions/v1beta10":
-			list = &extensionsbeta10
-		case "/apis/apps/v1beta1":
-			list = &appsbeta1
-		case "/apis/apps/v1beta2":
-			list = &appsbeta2
-		case "/apis/apps/v1beta3":
-			list = &appsbeta3
-		case "/apis/apps/v1beta4":
-			list = &appsbeta4
-		case "/apis/apps/v1beta5":
-			list = &appsbeta5
-		case "/apis/apps/v1beta6":
-			list = &appsbeta6
-		case "/apis/apps/v1beta7":
-			list = &appsbeta7
-		case "/apis/apps/v1beta8":
-			list = &appsbeta8
-		case "/apis/apps/v1beta9":
-			list = &appsbeta9
-		case "/apis/apps/v1beta10":
-			list = &appsbeta10
 		case "/api":
 			list = &metav1.APIVersions{
 				Versions: []string{
@@ -299,33 +225,8 @@ func TestGetServerResources(t *testing.T) {
 			list = &metav1.APIGroupList{
 				Groups: []metav1.APIGroup{
 					{
-						Name: "apps",
 						Versions: []metav1.GroupVersionForDiscovery{
-							{GroupVersion: "apps/v1beta1", Version: "v1beta1"},
-							{GroupVersion: "apps/v1beta2", Version: "v1beta2"},
-							{GroupVersion: "apps/v1beta3", Version: "v1beta3"},
-							{GroupVersion: "apps/v1beta4", Version: "v1beta4"},
-							{GroupVersion: "apps/v1beta5", Version: "v1beta5"},
-							{GroupVersion: "apps/v1beta6", Version: "v1beta6"},
-							{GroupVersion: "apps/v1beta7", Version: "v1beta7"},
-							{GroupVersion: "apps/v1beta8", Version: "v1beta8"},
-							{GroupVersion: "apps/v1beta9", Version: "v1beta9"},
-							{GroupVersion: "apps/v1beta10", Version: "v1beta10"},
-						},
-					},
-					{
-						Name: "extensions",
-						Versions: []metav1.GroupVersionForDiscovery{
-							{GroupVersion: "extensions/v1beta1", Version: "v1beta1"},
-							{GroupVersion: "extensions/v1beta2", Version: "v1beta2"},
-							{GroupVersion: "extensions/v1beta3", Version: "v1beta3"},
-							{GroupVersion: "extensions/v1beta4", Version: "v1beta4"},
-							{GroupVersion: "extensions/v1beta5", Version: "v1beta5"},
-							{GroupVersion: "extensions/v1beta6", Version: "v1beta6"},
-							{GroupVersion: "extensions/v1beta7", Version: "v1beta7"},
-							{GroupVersion: "extensions/v1beta8", Version: "v1beta8"},
-							{GroupVersion: "extensions/v1beta9", Version: "v1beta9"},
-							{GroupVersion: "extensions/v1beta10", Version: "v1beta10"},
+							{GroupVersion: "extensions/v1beta1"},
 						},
 					},
 				},
@@ -345,8 +246,8 @@ func TestGetServerResources(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
+	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 	for _, test := range tests {
-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
 		got, err := client.ServerResourcesForGroupVersion(test.request)
 		if test.expectErr {
 			if err == nil {
@@ -363,83 +264,54 @@ func TestGetServerResources(t *testing.T) {
 		}
 	}
 
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	start := time.Now()
 	serverResources, err := client.ServerResources()
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	end := time.Now()
-	if d := end.Sub(start); d > time.Second {
-		t.Errorf("took too long to perform discovery: %s", d)
-	}
-	serverGroupVersions := groupVersions(serverResources)
-	expectedGroupVersions := []string{
-		"v1",
-		"apps/v1beta1",
-		"apps/v1beta2",
-		"apps/v1beta3",
-		"apps/v1beta4",
-		"apps/v1beta5",
-		"apps/v1beta6",
-		"apps/v1beta7",
-		"apps/v1beta8",
-		"apps/v1beta9",
-		"apps/v1beta10",
-		"extensions/v1beta1",
-		"extensions/v1beta2",
-		"extensions/v1beta3",
-		"extensions/v1beta4",
-		"extensions/v1beta5",
-		"extensions/v1beta6",
-		"extensions/v1beta7",
-		"extensions/v1beta8",
-		"extensions/v1beta9",
-		"extensions/v1beta10",
-	}
-	if !reflect.DeepEqual(expectedGroupVersions, serverGroupVersions) {
-		t.Errorf("unexpected group versions: %v", diff.ObjectReflectDiff(expectedGroupVersions, serverGroupVersions))
+	serverGroupVersions := sets.NewString(groupVersions(serverResources)...)
+	for _, api := range []string{"v1", "extensions/v1beta1"} {
+		if !serverGroupVersions.Has(api) {
+			t.Errorf("missing expected api %q in %v", api, serverResources)
+		}
 	}
 }
 
-func returnedOpenAPI() *openapi_v2.Document {
-	return &openapi_v2.Document{
-		Definitions: &openapi_v2.Definitions{
-			AdditionalProperties: []*openapi_v2.NamedSchema{
-				{
-					Name: "fake.type.1",
-					Value: &openapi_v2.Schema{
-						Properties: &openapi_v2.Properties{
-							AdditionalProperties: []*openapi_v2.NamedSchema{
-								{
-									Name: "count",
-									Value: &openapi_v2.Schema{
-										Type: &openapi_v2.TypeItem{
-											Value: []string{"integer"},
-										},
+var returnedOpenAPI = openapi_v2.Document{
+	Definitions: &openapi_v2.Definitions{
+		AdditionalProperties: []*openapi_v2.NamedSchema{
+			{
+				Name: "fake.type.1",
+				Value: &openapi_v2.Schema{
+					Properties: &openapi_v2.Properties{
+						AdditionalProperties: []*openapi_v2.NamedSchema{
+							{
+								Name: "count",
+								Value: &openapi_v2.Schema{
+									Type: &openapi_v2.TypeItem{
+										Value: []string{"integer"},
 									},
 								},
 							},
 						},
 					},
 				},
-				{
-					Name: "fake.type.2",
-					Value: &openapi_v2.Schema{
-						Properties: &openapi_v2.Properties{
-							AdditionalProperties: []*openapi_v2.NamedSchema{
-								{
-									Name: "count",
-									Value: &openapi_v2.Schema{
-										Type: &openapi_v2.TypeItem{
-											Value: []string{"array"},
-										},
-										Items: &openapi_v2.ItemsItem{
-											Schema: []*openapi_v2.Schema{
-												{
-													Type: &openapi_v2.TypeItem{
-														Value: []string{"string"},
-													},
+			},
+			{
+				Name: "fake.type.2",
+				Value: &openapi_v2.Schema{
+					Properties: &openapi_v2.Properties{
+						AdditionalProperties: []*openapi_v2.NamedSchema{
+							{
+								Name: "count",
+								Value: &openapi_v2.Schema{
+									Type: &openapi_v2.TypeItem{
+										Value: []string{"array"},
+									},
+									Items: &openapi_v2.ItemsItem{
+										Schema: []*openapi_v2.Schema{
+											{
+												Type: &openapi_v2.TypeItem{
+													Value: []string{"string"},
 												},
 											},
 										},
@@ -451,10 +323,11 @@ func returnedOpenAPI() *openapi_v2.Document {
 				},
 			},
 		},
-	}
+	},
 }
 
-func openapiSchemaDeprecatedFakeServer(status int, t *testing.T) (*httptest.Server, error) {
+func openapiSchemaDeprecatedFakeServer(status int) (*httptest.Server, error) {
+	var sErr error
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		if req.URL.Path == "/openapi/v2" {
 			// write the error status for the new endpoint request
@@ -462,81 +335,54 @@ func openapiSchemaDeprecatedFakeServer(status int, t *testing.T) (*httptest.Serv
 			return
 		}
 		if req.URL.Path != "/swagger-2.0.0.pb-v1" {
-			errMsg := fmt.Sprintf("Unexpected url %v", req.URL)
-			w.WriteHeader(http.StatusNotFound)
-			w.Write([]byte(errMsg))
-			t.Errorf("testing should fail as %s", errMsg)
-			return
+			sErr = fmt.Errorf("Unexpected url %v", req.URL)
 		}
 		if req.Method != "GET" {
-			errMsg := fmt.Sprintf("Unexpected method %v", req.Method)
-			w.WriteHeader(http.StatusMethodNotAllowed)
-			w.Write([]byte(errMsg))
-			t.Errorf("testing should fail as %s", errMsg)
-			return
+			sErr = fmt.Errorf("Unexpected method %v", req.Method)
 		}
 
 		mime.AddExtensionType(".pb-v1", "application/com.github.googleapis.gnostic.OpenAPIv2@68f4ded+protobuf")
 
-		output, err := proto.Marshal(returnedOpenAPI())
+		output, err := proto.Marshal(&returnedOpenAPI)
 		if err != nil {
-			errMsg := fmt.Sprintf("Unexpected marshal error: %v", err)
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(errMsg))
-			t.Errorf("testing should fail as %s", errMsg)
+			sErr = err
 			return
 		}
 		w.WriteHeader(http.StatusOK)
 		w.Write(output)
 	}))
-
-	return server, nil
+	return server, sErr
 }
 
-func openapiSchemaFakeServer(t *testing.T) (*httptest.Server, error) {
+func openapiSchemaFakeServer() (*httptest.Server, error) {
+	var sErr error
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		if req.URL.Path != "/openapi/v2" {
-			errMsg := fmt.Sprintf("Unexpected url %v", req.URL)
-			w.WriteHeader(http.StatusNotFound)
-			w.Write([]byte(errMsg))
-			t.Errorf("testing should fail as %s", errMsg)
-			return
+			sErr = fmt.Errorf("Unexpected url %v", req.URL)
 		}
 		if req.Method != "GET" {
-			errMsg := fmt.Sprintf("Unexpected method %v", req.Method)
-			w.WriteHeader(http.StatusMethodNotAllowed)
-			w.Write([]byte(errMsg))
-			t.Errorf("testing should fail as %s", errMsg)
-			return
+			sErr = fmt.Errorf("Unexpected method %v", req.Method)
 		}
 		decipherableFormat := req.Header.Get("Accept")
 		if decipherableFormat != "application/com.github.proto-openapi.spec.v2@v1.0+protobuf" {
-			errMsg := fmt.Sprintf("Unexpected accept mime type %v", decipherableFormat)
-			w.WriteHeader(http.StatusUnsupportedMediaType)
-			w.Write([]byte(errMsg))
-			t.Errorf("testing should fail as %s", errMsg)
-			return
+			sErr = fmt.Errorf("Unexpected accept mime type %v", decipherableFormat)
 		}
 
 		mime.AddExtensionType(".pb-v1", "application/com.github.googleapis.gnostic.OpenAPIv2@68f4ded+protobuf")
 
-		output, err := proto.Marshal(returnedOpenAPI())
+		output, err := proto.Marshal(&returnedOpenAPI)
 		if err != nil {
-			errMsg := fmt.Sprintf("Unexpected marshal error: %v", err)
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(errMsg))
-			t.Errorf("testing should fail as %s", errMsg)
+			sErr = err
 			return
 		}
 		w.WriteHeader(http.StatusOK)
 		w.Write(output)
 	}))
-
-	return server, nil
+	return server, sErr
 }
 
 func TestGetOpenAPISchema(t *testing.T) {
-	server, err := openapiSchemaFakeServer(t)
+	server, err := openapiSchemaFakeServer()
 	if err != nil {
 		t.Errorf("unexpected error starting fake server: %v", err)
 	}
@@ -547,13 +393,13 @@ func TestGetOpenAPISchema(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error getting openapi: %v", err)
 	}
-	if e, a := returnedOpenAPI(), got; !reflect.DeepEqual(e, a) {
+	if e, a := returnedOpenAPI, *got; !reflect.DeepEqual(e, a) {
 		t.Errorf("expected %v, got %v", e, a)
 	}
 }
 
 func TestGetOpenAPISchemaForbiddenFallback(t *testing.T) {
-	server, err := openapiSchemaDeprecatedFakeServer(http.StatusForbidden, t)
+	server, err := openapiSchemaDeprecatedFakeServer(http.StatusForbidden)
 	if err != nil {
 		t.Errorf("unexpected error starting fake server: %v", err)
 	}
@@ -564,13 +410,13 @@ func TestGetOpenAPISchemaForbiddenFallback(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error getting openapi: %v", err)
 	}
-	if e, a := returnedOpenAPI(), got; !reflect.DeepEqual(e, a) {
+	if e, a := returnedOpenAPI, *got; !reflect.DeepEqual(e, a) {
 		t.Errorf("expected %v, got %v", e, a)
 	}
 }
 
 func TestGetOpenAPISchemaNotFoundFallback(t *testing.T) {
-	server, err := openapiSchemaDeprecatedFakeServer(http.StatusNotFound, t)
+	server, err := openapiSchemaDeprecatedFakeServer(http.StatusNotFound)
 	if err != nil {
 		t.Errorf("unexpected error starting fake server: %v", err)
 	}
@@ -581,13 +427,13 @@ func TestGetOpenAPISchemaNotFoundFallback(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error getting openapi: %v", err)
 	}
-	if e, a := returnedOpenAPI(), got; !reflect.DeepEqual(e, a) {
+	if e, a := returnedOpenAPI, *got; !reflect.DeepEqual(e, a) {
 		t.Errorf("expected %v, got %v", e, a)
 	}
 }
 
 func TestGetOpenAPISchemaNotAcceptableFallback(t *testing.T) {
-	server, err := openapiSchemaDeprecatedFakeServer(http.StatusNotAcceptable, t)
+	server, err := openapiSchemaDeprecatedFakeServer(http.StatusNotAcceptable)
 	if err != nil {
 		t.Errorf("unexpected error starting fake server: %v", err)
 	}
@@ -598,7 +444,7 @@ func TestGetOpenAPISchemaNotAcceptableFallback(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error getting openapi: %v", err)
 	}
-	if e, a := returnedOpenAPI(), got; !reflect.DeepEqual(e, a) {
+	if e, a := returnedOpenAPI, *got; !reflect.DeepEqual(e, a) {
 		t.Errorf("expected %v, got %v", e, a)
 	}
 }
@@ -772,7 +618,7 @@ func TestServerPreferredResourcesRetries(t *testing.T) {
 						{
 							Name: "extensions",
 							Versions: []metav1.GroupVersionForDiscovery{
-								{GroupVersion: "extensions/v1beta1", Version: "v1beta1"},
+								{GroupVersion: "extensions/v1beta1"},
 							},
 							PreferredVersion: metav1.GroupVersionForDiscovery{
 								GroupVersion: "extensions/v1beta1",

discovery/doc.go

@@ -1,19 +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 discovery provides ways to discover server-supported
-// API groups, versions and resources.
-package discovery // import "k8s.io/client-go/discovery"

discovery/fake/discovery.go

@@ -19,7 +19,7 @@ package fake
 import (
 	"fmt"
 
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
+	"github.com/googleapis/gnostic/OpenAPIv2"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -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,46 +50,23 @@ 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.
-// Deprecated: use ServerGroupsAndResources instead.
 func (c *FakeDiscovery) ServerResources() ([]*metav1.APIResourceList, error) {
-	_, rs, err := c.ServerGroupsAndResources()
-	return rs, err
-}
-
-// ServerGroupsAndResources returns the supported groups and resources for all groups and versions.
-func (c *FakeDiscovery) ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-	sgs, err := c.ServerGroups()
-	if err != nil {
-		return nil, nil, err
-	}
-	resultGroups := []*metav1.APIGroup{}
-	for i := range sgs.Groups {
-		resultGroups = append(resultGroups, &sgs.Groups[i])
-	}
-
 	action := testing.ActionImpl{
 		Verb:     "get",
 		Resource: schema.GroupVersionResource{Resource: "resource"},
 	}
 	c.Invokes(action, nil)
-	return resultGroups, c.Resources, nil
+	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",
@@ -133,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"
@@ -148,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...)
 }

discovery/helper_blackbox_test.go

@@ -26,12 +26,13 @@ import (
 	"strings"
 	"testing"
 
-	v1 "k8s.io/api/core/v1"
+	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/discovery"
+	"k8s.io/client-go/kubernetes/scheme"
 	restclient "k8s.io/client-go/rest"
 	"k8s.io/client-go/rest/fake"
 )
@@ -81,16 +82,23 @@ func TestServerSupportsVersion(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		fakeClient := fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-			if test.sendErr != nil {
-				return nil, test.sendErr
-			}
-			header := http.Header{}
-			header.Set("Content-Type", runtime.ContentTypeJSON)
-			return &http.Response{StatusCode: test.statusCode, Header: header, Body: objBody(&metav1.APIVersions{Versions: test.serverVersions})}, nil
-		})
+		fakeClient := &fake.RESTClient{
+			NegotiatedSerializer: scheme.Codecs,
+			Resp: &http.Response{
+				StatusCode: test.statusCode,
+				Body:       objBody(&metav1.APIVersions{Versions: test.serverVersions}),
+			},
+			Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+				if test.sendErr != nil {
+					return nil, test.sendErr
+				}
+				header := http.Header{}
+				header.Set("Content-Type", runtime.ContentTypeJSON)
+				return &http.Response{StatusCode: test.statusCode, Header: header, Body: objBody(&metav1.APIVersions{Versions: test.serverVersions})}, nil
+			}),
+		}
 		c := discovery.NewDiscoveryClientForConfigOrDie(&restclient.Config{})
-		c.RESTClient().(*restclient.RESTClient).Client = fakeClient
+		c.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
 		err := discovery.ServerSupportsVersion(c, test.requiredVersion)
 		if err == nil && test.expectErr != nil {
 			t.Errorf("expected error, got nil for [%s].", test.name)

discovery/restmapper.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package restmapper
+package discovery
 
 import (
 	"fmt"
@@ -24,9 +24,8 @@ import (
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/discovery"
 
-	"k8s.io/klog/v2"
+	"github.com/golang/glog"
 )
 
 // APIGroupResources is an API group with a mapping of versions to
@@ -38,9 +37,9 @@ type APIGroupResources struct {
 	VersionedResources map[string][]metav1.APIResource
 }
 
-// NewDiscoveryRESTMapper returns a PriorityRESTMapper based on the discovered
+// NewRESTMapper returns a PriorityRESTMapper based on the discovered
 // groups and resources passed in.
-func NewDiscoveryRESTMapper(groupResources []*APIGroupResources) meta.RESTMapper {
+func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.VersionInterfacesFunc) meta.RESTMapper {
 	unionMapper := meta.MultiRESTMapper{}
 
 	var groupPriority []string
@@ -91,7 +90,7 @@ func NewDiscoveryRESTMapper(groupResources []*APIGroupResources) meta.RESTMapper
 			}
 
 			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
-			versionMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv})
+			versionMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv}, versionInterfaces)
 
 			for _, resource := range resources {
 				scope := meta.RESTScopeNamespace
@@ -144,26 +143,22 @@ func NewDiscoveryRESTMapper(groupResources []*APIGroupResources) meta.RESTMapper
 
 // GetAPIGroupResources uses the provided discovery client to gather
 // discovery information and populate a slice of APIGroupResources.
-func GetAPIGroupResources(cl discovery.DiscoveryInterface) ([]*APIGroupResources, error) {
-	gs, rs, err := cl.ServerGroupsAndResources()
-	if rs == nil || gs == nil {
+func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
+	apiGroups, err := cl.ServerGroups()
+	if err != nil {
 		return nil, err
-		// TODO track the errors and update callers to handle partial errors.
 	}
-	rsm := map[string]*metav1.APIResourceList{}
-	for _, r := range rs {
-		rsm[r.GroupVersion] = r
-	}
-
 	var result []*APIGroupResources
-	for _, group := range gs {
+	for _, group := range apiGroups.Groups {
 		groupResources := &APIGroupResources{
-			Group:              *group,
+			Group:              group,
 			VersionedResources: make(map[string][]metav1.APIResource),
 		}
 		for _, version := range group.Versions {
-			resources, ok := rsm[version.GroupVersion]
-			if !ok {
+			resources, err := cl.ServerResourcesForGroupVersion(version.GroupVersion)
+			if err != nil {
+				// continue as best we can
+				// TODO track the errors and update callers to handle partial errors.
 				continue
 			}
 			groupResources.VersionedResources[version.Version] = resources.APIResources
@@ -177,17 +172,19 @@ func GetAPIGroupResources(cl discovery.DiscoveryInterface) ([]*APIGroupResources
 // initialization of the RESTMapper until the first mapping is
 // requested.
 type DeferredDiscoveryRESTMapper struct {
-	initMu   sync.Mutex
-	delegate meta.RESTMapper
-	cl       discovery.CachedDiscoveryInterface
+	initMu           sync.Mutex
+	delegate         meta.RESTMapper
+	cl               CachedDiscoveryInterface
+	versionInterface meta.VersionInterfacesFunc
 }
 
 // NewDeferredDiscoveryRESTMapper returns a
 // DeferredDiscoveryRESTMapper that will lazily query the provided
 // client for discovery information to do REST mappings.
-func NewDeferredDiscoveryRESTMapper(cl discovery.CachedDiscoveryInterface) *DeferredDiscoveryRESTMapper {
+func NewDeferredDiscoveryRESTMapper(cl CachedDiscoveryInterface, versionInterface meta.VersionInterfacesFunc) *DeferredDiscoveryRESTMapper {
 	return &DeferredDiscoveryRESTMapper{
-		cl: cl,
+		cl:               cl,
+		versionInterface: versionInterface,
 	}
 }
 
@@ -204,14 +201,14 @@ func (d *DeferredDiscoveryRESTMapper) getDelegate() (meta.RESTMapper, error) {
 		return nil, err
 	}
 
-	d.delegate = NewDiscoveryRESTMapper(groupResources)
+	d.delegate = NewRESTMapper(groupResources, d.versionInterface)
 	return d.delegate, err
 }
 
 // Reset resets the internally cached Discovery information and will
 // cause the next mapping request to re-discover.
 func (d *DeferredDiscoveryRESTMapper) Reset() {
-	klog.V(5).Info("Invalidating discovery information")
+	glog.V(5).Info("Invalidating discovery information")
 
 	d.initMu.Lock()
 	defer d.initMu.Unlock()

discovery/restmapper_test.go

@@ -14,14 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package restmapper
+package discovery_test
 
 import (
-	"fmt"
 	"reflect"
 	"testing"
 
-	"github.com/davecgh/go-spew/spew"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -30,7 +28,7 @@ import (
 	restclient "k8s.io/client-go/rest"
 	"k8s.io/client-go/rest/fake"
 
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
+	"github.com/googleapis/gnostic/OpenAPIv2"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -96,7 +94,7 @@ func TestRESTMapper(t *testing.T) {
 		},
 	}
 
-	restMapper := NewDiscoveryRESTMapper(resources)
+	restMapper := NewRESTMapper(resources, nil)
 
 	kindTCs := []struct {
 		input schema.GroupVersionResource
@@ -245,7 +243,7 @@ func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
 	assert := assert.New(t)
 
 	cdc := fakeCachedDiscoveryInterface{fresh: false}
-	m := NewDeferredDiscoveryRESTMapper(&cdc)
+	m := NewDeferredDiscoveryRESTMapper(&cdc, nil)
 	assert.False(cdc.fresh, "should NOT be fresh after instantiation")
 	assert.Zero(cdc.invalidateCalls, "should not have called Invalidate()")
 
@@ -285,146 +283,10 @@ func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
 	assert.Equal(cdc.invalidateCalls, 2, "should HAVE called Invalidate() again after another cache-miss, but with fresh==false")
 }
 
-func TestGetAPIGroupResources(t *testing.T) {
-	type Test struct {
-		name string
-
-		discovery DiscoveryInterface
-
-		expected      []*APIGroupResources
-		expectedError error
-	}
-
-	for _, test := range []Test{
-		{"nil", &fakeFailingDiscovery{nil, nil, nil, nil}, nil, nil},
-		{"normal",
-			&fakeFailingDiscovery{
-				[]metav1.APIGroup{aGroup, bGroup}, nil,
-				map[string]*metav1.APIResourceList{"a/v1": &aResources, "b/v1": &bResources}, nil,
-			},
-			[]*APIGroupResources{
-				{aGroup, map[string][]metav1.APIResource{"v1": {aFoo}}},
-				{bGroup, map[string][]metav1.APIResource{"v1": {bBar}}},
-			}, nil,
-		},
-		{"groups failed, but has fallback with a only",
-			&fakeFailingDiscovery{
-				[]metav1.APIGroup{aGroup}, fmt.Errorf("error fetching groups"),
-				map[string]*metav1.APIResourceList{"a/v1": &aResources, "b/v1": &bResources}, nil,
-			},
-			[]*APIGroupResources{
-				{aGroup, map[string][]metav1.APIResource{"v1": {aFoo}}},
-			}, nil,
-		},
-		{"groups failed, but has no fallback",
-			&fakeFailingDiscovery{
-				nil, fmt.Errorf("error fetching groups"),
-				map[string]*metav1.APIResourceList{"a/v1": &aResources, "b/v1": &bResources}, nil,
-			},
-			nil, fmt.Errorf("error fetching groups"),
-		},
-		{"a failed, but has fallback",
-			&fakeFailingDiscovery{
-				[]metav1.APIGroup{aGroup, bGroup}, nil,
-				map[string]*metav1.APIResourceList{"a/v1": &aResources, "b/v1": &bResources}, map[string]error{"a/v1": fmt.Errorf("a failed")},
-			},
-			[]*APIGroupResources{
-				{aGroup, map[string][]metav1.APIResource{"v1": {aFoo}}},
-				{bGroup, map[string][]metav1.APIResource{"v1": {bBar}}},
-			}, nil, // TODO: do we want this?
-		},
-		{"a failed, but has no fallback",
-			&fakeFailingDiscovery{
-				[]metav1.APIGroup{aGroup, bGroup}, nil,
-				map[string]*metav1.APIResourceList{"b/v1": &bResources}, map[string]error{"a/v1": fmt.Errorf("a failed")},
-			},
-			[]*APIGroupResources{
-				{aGroup, map[string][]metav1.APIResource{}},
-				{bGroup, map[string][]metav1.APIResource{"v1": {bBar}}},
-			}, nil, // TODO: do we want this?
-		},
-		{"a and b failed, but have fallbacks",
-			&fakeFailingDiscovery{
-				[]metav1.APIGroup{aGroup, bGroup}, nil,
-				map[string]*metav1.APIResourceList{"a/v1": &aResources, "b/v1": &bResources}, // TODO: both fallbacks are ignored
-				map[string]error{"a/v1": fmt.Errorf("a failed"), "b/v1": fmt.Errorf("b failed")},
-			},
-			[]*APIGroupResources{
-				{aGroup, map[string][]metav1.APIResource{"v1": {aFoo}}},
-				{bGroup, map[string][]metav1.APIResource{"v1": {bBar}}},
-			}, nil, // TODO: do we want this?
-		},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			got, err := GetAPIGroupResources(test.discovery)
-			if err == nil && test.expectedError != nil {
-				t.Fatalf("expected error %q, but got none", test.expectedError)
-			} else if err != nil && test.expectedError == nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if !reflect.DeepEqual(test.expected, got) {
-				t.Errorf("unexpected result:\nexpected = %s\ngot = %s", spew.Sdump(test.expected), spew.Sdump(got))
-			}
-		})
-	}
-
-}
-
-var _ DiscoveryInterface = &fakeFailingDiscovery{}
-
-type fakeFailingDiscovery struct {
-	groups    []metav1.APIGroup
-	groupsErr error
-
-	resourcesForGroupVersion    map[string]*metav1.APIResourceList
-	resourcesForGroupVersionErr map[string]error
-}
-
-func (*fakeFailingDiscovery) RESTClient() restclient.Interface {
-	return nil
-}
-
-func (d *fakeFailingDiscovery) ServerGroups() (*metav1.APIGroupList, error) {
-	if d.groups == nil && d.groupsErr != nil {
-		return nil, d.groupsErr
-	}
-	return &metav1.APIGroupList{Groups: d.groups}, d.groupsErr
-}
-
-func (d *fakeFailingDiscovery) ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-	return ServerGroupsAndResources(d)
-}
-func (d *fakeFailingDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	if rs, found := d.resourcesForGroupVersion[groupVersion]; found {
-		return rs, d.resourcesForGroupVersionErr[groupVersion]
-	}
-	return nil, fmt.Errorf("not found")
-}
-
-func (d *fakeFailingDiscovery) ServerResources() ([]*metav1.APIResourceList, error) {
-	return ServerResources(d)
-}
-
-func (d *fakeFailingDiscovery) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	return ServerPreferredResources(d)
-}
-
-func (d *fakeFailingDiscovery) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	return ServerPreferredNamespacedResources(d)
-}
-
-func (*fakeFailingDiscovery) ServerVersion() (*version.Info, error) {
-	return &version.Info{}, nil
-}
-
-func (*fakeFailingDiscovery) OpenAPISchema() (*openapi_v2.Document, error) {
-	panic("implement me")
-}
-
 type fakeCachedDiscoveryInterface struct {
 	invalidateCalls int
 	fresh           bool
-	enabledGroupA   bool
+	enabledA        bool
 }
 
 var _ CachedDiscoveryInterface = &fakeCachedDiscoveryInterface{}
@@ -436,7 +298,7 @@ func (c *fakeCachedDiscoveryInterface) Fresh() bool {
 func (c *fakeCachedDiscoveryInterface) Invalidate() {
 	c.invalidateCalls = c.invalidateCalls + 1
 	c.fresh = true
-	c.enabledGroupA = true
+	c.enabledA = true
 }
 
 func (c *fakeCachedDiscoveryInterface) RESTClient() restclient.Interface {
@@ -444,33 +306,55 @@ func (c *fakeCachedDiscoveryInterface) RESTClient() restclient.Interface {
 }
 
 func (c *fakeCachedDiscoveryInterface) ServerGroups() (*metav1.APIGroupList, error) {
-	if c.enabledGroupA {
+	if c.enabledA {
 		return &metav1.APIGroupList{
-			Groups: []metav1.APIGroup{aGroup},
+			Groups: []metav1.APIGroup{
+				{
+					Name: "a",
+					Versions: []metav1.GroupVersionForDiscovery{
+						{
+							GroupVersion: "a/v1",
+							Version:      "v1",
+						},
+					},
+					PreferredVersion: metav1.GroupVersionForDiscovery{
+						GroupVersion: "a/v1",
+						Version:      "v1",
+					},
+				},
+			},
 		}, nil
 	}
 	return &metav1.APIGroupList{}, nil
 }
 
-func (c *fakeCachedDiscoveryInterface) ServerGroupsAndResources() ([]*metav1.APIGroup, []*metav1.APIResourceList, error) {
-	return ServerGroupsAndResources(c)
-}
-
 func (c *fakeCachedDiscoveryInterface) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
-	if c.enabledGroupA && groupVersion == "a/v1" {
-		return &aResources, nil
+	if c.enabledA && groupVersion == "a/v1" {
+		return &metav1.APIResourceList{
+			GroupVersion: "a/v1",
+			APIResources: []metav1.APIResource{
+				{
+					Name:       "foo",
+					Kind:       "Foo",
+					Namespaced: false,
+				},
+			},
+		}, nil
 	}
 
 	return nil, errors.NewNotFound(schema.GroupResource{}, "")
 }
 
-// Deprecated: use ServerGroupsAndResources instead.
 func (c *fakeCachedDiscoveryInterface) ServerResources() ([]*metav1.APIResourceList, error) {
-	return ServerResources(c)
+	if c.enabledA {
+		av1, _ := c.ServerResourcesForGroupVersion("a/v1")
+		return []*metav1.APIResourceList{av1}, nil
+	}
+	return []*metav1.APIResourceList{}, nil
 }
 
 func (c *fakeCachedDiscoveryInterface) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	if c.enabledGroupA {
+	if c.enabledA {
 		return []*metav1.APIResourceList{
 			{
 				GroupVersion: "a/v1",
@@ -498,50 +382,3 @@ func (c *fakeCachedDiscoveryInterface) ServerVersion() (*version.Info, error) {
 func (c *fakeCachedDiscoveryInterface) OpenAPISchema() (*openapi_v2.Document, error) {
 	return &openapi_v2.Document{}, nil
 }
-
-var (
-	aGroup = metav1.APIGroup{
-		Name: "a",
-		Versions: []metav1.GroupVersionForDiscovery{
-			{
-				GroupVersion: "a/v1",
-				Version:      "v1",
-			},
-		},
-		PreferredVersion: metav1.GroupVersionForDiscovery{
-			GroupVersion: "a/v1",
-			Version:      "v1",
-		},
-	}
-	bGroup = metav1.APIGroup{
-		Name: "b",
-		Versions: []metav1.GroupVersionForDiscovery{
-			{
-				GroupVersion: "b/v1",
-				Version:      "v1",
-			},
-		},
-		PreferredVersion: metav1.GroupVersionForDiscovery{
-			GroupVersion: "b/v1",
-			Version:      "v1",
-		},
-	}
-	aResources = metav1.APIResourceList{
-		GroupVersion: "a/v1",
-		APIResources: []metav1.APIResource{aFoo},
-	}
-	aFoo = metav1.APIResource{
-		Name:       "foo",
-		Kind:       "Foo",
-		Namespaced: false,
-	}
-	bResources = metav1.APIResourceList{
-		GroupVersion: "b/v1",
-		APIResources: []metav1.APIResource{bBar},
-	}
-	bBar = metav1.APIResource{
-		Name:       "bar",
-		Kind:       "Bar",
-		Namespaced: true,
-	}
-)

discovery/unstructured.go

@@ -0,0 +1,95 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package discovery
+
+import (
+	"reflect"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// UnstructuredObjectTyper provides a runtime.ObjectTyper implementation for
+// runtime.Unstructured object based on discovery information.
+type UnstructuredObjectTyper struct {
+	registered map[schema.GroupVersionKind]bool
+	typers     []runtime.ObjectTyper
+}
+
+// NewUnstructuredObjectTyper returns a runtime.ObjectTyper for
+// unstructured objects based on discovery information. It accepts a list of fallback typers
+// for handling objects that are not runtime.Unstructured. It does not delegate the Recognizes
+// check, only ObjectKinds.
+func NewUnstructuredObjectTyper(groupResources []*APIGroupResources, typers ...runtime.ObjectTyper) *UnstructuredObjectTyper {
+	dot := &UnstructuredObjectTyper{
+		registered: make(map[schema.GroupVersionKind]bool),
+		typers:     typers,
+	}
+	for _, group := range groupResources {
+		for _, discoveryVersion := range group.Group.Versions {
+			resources, ok := group.VersionedResources[discoveryVersion.Version]
+			if !ok {
+				continue
+			}
+
+			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
+			for _, resource := range resources {
+				dot.registered[gv.WithKind(resource.Kind)] = true
+			}
+		}
+	}
+	return dot
+}
+
+// ObjectKinds returns a slice of one element with the group,version,kind of the
+// provided object, or an error if the object is not runtime.Unstructured or
+// has no group,version,kind information. unversionedType will always be false
+// because runtime.Unstructured object should always have group,version,kind
+// information set.
+func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []schema.GroupVersionKind, unversionedType bool, err error) {
+	if _, ok := obj.(runtime.Unstructured); ok {
+		gvk := obj.GetObjectKind().GroupVersionKind()
+		if len(gvk.Kind) == 0 {
+			return nil, false, runtime.NewMissingKindErr("object has no kind field ")
+		}
+		if len(gvk.Version) == 0 {
+			return nil, false, runtime.NewMissingVersionErr("object has no apiVersion field")
+		}
+		return []schema.GroupVersionKind{gvk}, false, nil
+	}
+	var lastErr error
+	for _, typer := range d.typers {
+		gvks, unversioned, err := typer.ObjectKinds(obj)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		return gvks, unversioned, nil
+	}
+	if lastErr == nil {
+		lastErr = runtime.NewNotRegisteredErrForType(reflect.TypeOf(obj))
+	}
+	return nil, false, lastErr
+}
+
+// Recognizes returns true if the provided group,version,kind was in the
+// discovery information.
+func (d *UnstructuredObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
+	return d.registered[gvk]
+}
+
+var _ runtime.ObjectTyper = &UnstructuredObjectTyper{}

dynamic/client.go

@@ -0,0 +1,379 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package dynamic provides a client interface to arbitrary Kubernetes
+// APIs that exposes common high level operations and exposes common
+// metadata.
+package dynamic
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"net/url"
+	"strings"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/conversion/queryparams"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/kubernetes/scheme"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/util/flowcontrol"
+)
+
+// Interface is a Kubernetes client that allows you to access metadata
+// and manipulate metadata of a Kubernetes API group.
+type Interface interface {
+	// GetRateLimiter returns the rate limiter for this client.
+	GetRateLimiter() flowcontrol.RateLimiter
+	// Resource returns an API interface to the specified resource for this client's
+	// group and version.  If resource is not a namespaced resource, then namespace
+	// is ignored.  The ResourceInterface inherits the parameter codec of this client.
+	Resource(resource *metav1.APIResource, namespace string) ResourceInterface
+	// ParameterCodec returns a client with the provided parameter codec.
+	ParameterCodec(parameterCodec runtime.ParameterCodec) Interface
+}
+
+// ResourceInterface is an API interface to a specific resource under a
+// dynamic client.
+type ResourceInterface interface {
+	// List returns a list of objects for this resource.
+	List(opts metav1.ListOptions) (runtime.Object, error)
+	// Get gets the resource with the specified name.
+	Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error)
+	// Delete deletes the resource with the specified name.
+	Delete(name string, opts *metav1.DeleteOptions) error
+	// DeleteCollection deletes a collection of objects.
+	DeleteCollection(deleteOptions *metav1.DeleteOptions, listOptions metav1.ListOptions) error
+	// Create creates the provided resource.
+	Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error)
+	// Update updates the provided resource.
+	Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error)
+	// Watch returns a watch.Interface that watches the resource.
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	// Patch patches the provided resource.
+	Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error)
+}
+
+// Client is a Kubernetes client that allows you to access metadata
+// and manipulate metadata of a Kubernetes API group, and implements Interface.
+type Client struct {
+	cl             *restclient.RESTClient
+	parameterCodec runtime.ParameterCodec
+}
+
+// NewClient returns a new client based on the passed in config. The
+// codec is ignored, as the dynamic client uses it's own codec.
+func NewClient(conf *restclient.Config) (*Client, error) {
+	// avoid changing the original config
+	confCopy := *conf
+	conf = &confCopy
+
+	contentConfig := ContentConfig()
+	contentConfig.GroupVersion = conf.GroupVersion
+	if conf.NegotiatedSerializer != nil {
+		contentConfig.NegotiatedSerializer = conf.NegotiatedSerializer
+	}
+	conf.ContentConfig = contentConfig
+
+	if conf.APIPath == "" {
+		conf.APIPath = "/api"
+	}
+
+	if len(conf.UserAgent) == 0 {
+		conf.UserAgent = restclient.DefaultKubernetesUserAgent()
+	}
+
+	cl, err := restclient.RESTClientFor(conf)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Client{cl: cl}, nil
+}
+
+// GetRateLimiter returns rate limier.
+func (c *Client) GetRateLimiter() flowcontrol.RateLimiter {
+	return c.cl.GetRateLimiter()
+}
+
+// Resource returns an API interface to the specified resource for this client's
+// group and version. If resource is not a namespaced resource, then namespace
+// is ignored. The ResourceInterface inherits the parameter codec of c.
+func (c *Client) Resource(resource *metav1.APIResource, namespace string) ResourceInterface {
+	return &ResourceClient{
+		cl:             c.cl,
+		resource:       resource,
+		ns:             namespace,
+		parameterCodec: c.parameterCodec,
+	}
+}
+
+// ParameterCodec returns a client with the provided parameter codec.
+func (c *Client) ParameterCodec(parameterCodec runtime.ParameterCodec) Interface {
+	return &Client{
+		cl:             c.cl,
+		parameterCodec: parameterCodec,
+	}
+}
+
+// ResourceClient is an API interface to a specific resource under a
+// dynamic client, and implements ResourceInterface.
+type ResourceClient struct {
+	cl             *restclient.RESTClient
+	resource       *metav1.APIResource
+	ns             string
+	parameterCodec runtime.ParameterCodec
+}
+
+func (rc *ResourceClient) parseResourceSubresourceName() (string, []string) {
+	var resourceName string
+	var subresourceName []string
+	if strings.Contains(rc.resource.Name, "/") {
+		resourceName = strings.Split(rc.resource.Name, "/")[0]
+		subresourceName = strings.Split(rc.resource.Name, "/")[1:]
+	} else {
+		resourceName = rc.resource.Name
+	}
+
+	return resourceName, subresourceName
+}
+
+// List returns a list of objects for this resource.
+func (rc *ResourceClient) List(opts metav1.ListOptions) (runtime.Object, error) {
+	parameterEncoder := rc.parameterCodec
+	if parameterEncoder == nil {
+		parameterEncoder = defaultParameterEncoder
+	}
+	return rc.cl.Get().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		VersionedParams(&opts, parameterEncoder).
+		Do().
+		Get()
+}
+
+// Get gets the resource with the specified name.
+func (rc *ResourceClient) Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error) {
+	parameterEncoder := rc.parameterCodec
+	if parameterEncoder == nil {
+		parameterEncoder = defaultParameterEncoder
+	}
+	result := new(unstructured.Unstructured)
+	resourceName, subresourceName := rc.parseResourceSubresourceName()
+	err := rc.cl.Get().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(resourceName).
+		SubResource(subresourceName...).
+		VersionedParams(&opts, parameterEncoder).
+		Name(name).
+		Do().
+		Into(result)
+	return result, err
+}
+
+// Delete deletes the resource with the specified name.
+func (rc *ResourceClient) Delete(name string, opts *metav1.DeleteOptions) error {
+	return rc.cl.Delete().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		Name(name).
+		Body(opts).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (rc *ResourceClient) DeleteCollection(deleteOptions *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
+	parameterEncoder := rc.parameterCodec
+	if parameterEncoder == nil {
+		parameterEncoder = defaultParameterEncoder
+	}
+	return rc.cl.Delete().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		VersionedParams(&listOptions, parameterEncoder).
+		Body(deleteOptions).
+		Do().
+		Error()
+}
+
+// Create creates the provided resource.
+func (rc *ResourceClient) Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	result := new(unstructured.Unstructured)
+	resourceName, subresourceName := rc.parseResourceSubresourceName()
+	req := rc.cl.Post().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(resourceName).
+		Body(obj)
+	if len(subresourceName) > 0 {
+		// If the provided resource is a subresource, the POST request should contain
+		// object name. Examples of subresources that support Create operation:
+		//	core/v1/pods/{name}/binding
+		//	core/v1/pods/{name}/eviction
+		//	extensions/v1beta1/deployments/{name}/rollback
+		//	apps/v1beta1/deployments/{name}/rollback
+		// NOTE: Currently our system assumes every subresource object has the same
+		//	 name as the parent resource object. E.g. a pods/binding object having
+		//	 metadada.name "foo" means pod "foo" is being bound. We may need to
+		//	 change this if we break the assumption in the future.
+		req = req.SubResource(subresourceName...).
+			Name(obj.GetName())
+	}
+	err := req.Do().
+		Into(result)
+	return result, err
+}
+
+// Update updates the provided resource.
+func (rc *ResourceClient) Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	result := new(unstructured.Unstructured)
+	if len(obj.GetName()) == 0 {
+		return result, errors.New("object missing name")
+	}
+	resourceName, subresourceName := rc.parseResourceSubresourceName()
+	err := rc.cl.Put().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(resourceName).
+		SubResource(subresourceName...).
+		// NOTE: Currently our system assumes every subresource object has the same
+		//	 name as the parent resource object. E.g. a pods/binding object having
+		//	 metadada.name "foo" means pod "foo" is being bound. We may need to
+		//	 change this if we break the assumption in the future.
+		Name(obj.GetName()).
+		Body(obj).
+		Do().
+		Into(result)
+	return result, err
+}
+
+// Watch returns a watch.Interface that watches the resource.
+func (rc *ResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	parameterEncoder := rc.parameterCodec
+	if parameterEncoder == nil {
+		parameterEncoder = defaultParameterEncoder
+	}
+	opts.Watch = true
+	return rc.cl.Get().
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(rc.resource.Name).
+		VersionedParams(&opts, parameterEncoder).
+		Watch()
+}
+
+// Patch applies the patch and returns the patched resource.
+func (rc *ResourceClient) Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error) {
+	result := new(unstructured.Unstructured)
+	resourceName, subresourceName := rc.parseResourceSubresourceName()
+	err := rc.cl.Patch(pt).
+		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
+		Resource(resourceName).
+		SubResource(subresourceName...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return result, err
+}
+
+// dynamicCodec is a codec that wraps the standard unstructured codec
+// with special handling for Status objects.
+type dynamicCodec struct{}
+
+func (dynamicCodec) Decode(data []byte, gvk *schema.GroupVersionKind, obj runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
+	obj, gvk, err := unstructured.UnstructuredJSONScheme.Decode(data, gvk, obj)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if _, ok := obj.(*metav1.Status); !ok && strings.ToLower(gvk.Kind) == "status" {
+		obj = &metav1.Status{}
+		err := json.Unmarshal(data, obj)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	return obj, gvk, nil
+}
+
+func (dynamicCodec) Encode(obj runtime.Object, w io.Writer) error {
+	return unstructured.UnstructuredJSONScheme.Encode(obj, w)
+}
+
+// ContentConfig returns a restclient.ContentConfig for dynamic types.
+func ContentConfig() restclient.ContentConfig {
+	var jsonInfo runtime.SerializerInfo
+	// TODO: scheme.Codecs here should become "pkg/apis/server/scheme" which is the minimal core you need
+	// to talk to a kubernetes server
+	for _, info := range scheme.Codecs.SupportedMediaTypes() {
+		if info.MediaType == runtime.ContentTypeJSON {
+			jsonInfo = info
+			break
+		}
+	}
+
+	jsonInfo.Serializer = dynamicCodec{}
+	jsonInfo.PrettySerializer = nil
+	return restclient.ContentConfig{
+		AcceptContentTypes:   runtime.ContentTypeJSON,
+		ContentType:          runtime.ContentTypeJSON,
+		NegotiatedSerializer: serializer.NegotiatedSerializerWrapper(jsonInfo),
+	}
+}
+
+// paramaterCodec is a codec converts an API object to query
+// parameters without trying to convert to the target version.
+type parameterCodec struct{}
+
+func (parameterCodec) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
+	return queryparams.Convert(obj)
+}
+
+func (parameterCodec) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
+	return errors.New("DecodeParameters not implemented on dynamic parameterCodec")
+}
+
+var defaultParameterEncoder runtime.ParameterCodec = parameterCodec{}
+
+type versionedParameterEncoderWithV1Fallback struct{}
+
+func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
+	ret, err := scheme.ParameterCodec.EncodeParameters(obj, to)
+	if err != nil && runtime.IsNotRegisteredError(err) {
+		// fallback to v1
+		return scheme.ParameterCodec.EncodeParameters(obj, v1.SchemeGroupVersion)
+	}
+	return ret, err
+}
+
+func (versionedParameterEncoderWithV1Fallback) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
+	return errors.New("DecodeParameters not implemented on versionedParameterEncoderWithV1Fallback")
+}
+
+// VersionedParameterEncoderWithV1Fallback is useful for encoding query
+// parameters for custom resources. It tries to convert object to the
+// specified version before converting it to query parameters, and falls back to
+// converting to v1 if the object is not registered in the specified version.
+// For the record, currently API server always treats query parameters sent to a
+// custom resource endpoint as v1.
+var VersionedParameterEncoderWithV1Fallback runtime.ParameterCodec = versionedParameterEncoderWithV1Fallback{}

dynamic/client_pool.go

@@ -0,0 +1,122 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package dynamic
+
+import (
+	"sync"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	restclient "k8s.io/client-go/rest"
+)
+
+// ClientPool manages a pool of dynamic clients.
+type ClientPool interface {
+	// ClientForGroupVersionResource returns a client configured for the specified groupVersionResource.
+	// Resource may be empty.
+	ClientForGroupVersionResource(resource schema.GroupVersionResource) (Interface, error)
+	// ClientForGroupVersionKind returns a client configured for the specified groupVersionKind.
+	// Kind may be empty.
+	ClientForGroupVersionKind(kind schema.GroupVersionKind) (Interface, error)
+}
+
+// APIPathResolverFunc knows how to convert a groupVersion to its API path. The Kind field is
+// optional.
+type APIPathResolverFunc func(kind schema.GroupVersionKind) string
+
+// LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
+func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
+	if len(kind.Group) == 0 {
+		return "/api"
+	}
+	return "/apis"
+}
+
+// clientPoolImpl implements ClientPool and caches clients for the resource group versions
+// is asked to retrieve. This type is thread safe.
+type clientPoolImpl struct {
+	lock                sync.RWMutex
+	config              *restclient.Config
+	clients             map[schema.GroupVersion]*Client
+	apiPathResolverFunc APIPathResolverFunc
+	mapper              meta.RESTMapper
+}
+
+// NewClientPool returns a ClientPool from the specified config. It reuses clients for the same
+// group version. It is expected this type may be wrapped by specific logic that special cases certain
+// resources or groups.
+func NewClientPool(config *restclient.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
+	confCopy := *config
+
+	return &clientPoolImpl{
+		config:              &confCopy,
+		clients:             map[schema.GroupVersion]*Client{},
+		apiPathResolverFunc: apiPathResolverFunc,
+		mapper:              mapper,
+	}
+}
+
+// Instantiates a new dynamic client pool with the given config.
+func NewDynamicClientPool(cfg *restclient.Config) ClientPool {
+	// restMapper is not needed when using LegacyAPIPathResolverFunc
+	emptyMapper := meta.MultiRESTMapper{}
+	return NewClientPool(cfg, emptyMapper, LegacyAPIPathResolverFunc)
+}
+
+// ClientForGroupVersionResource uses the provided RESTMapper to identify the appropriate resource. Resource may
+// be empty. If no matching kind is found the underlying client for that group is still returned.
+func (c *clientPoolImpl) ClientForGroupVersionResource(resource schema.GroupVersionResource) (Interface, error) {
+	kinds, err := c.mapper.KindsFor(resource)
+	if err != nil {
+		if meta.IsNoMatchError(err) {
+			return c.ClientForGroupVersionKind(schema.GroupVersionKind{Group: resource.Group, Version: resource.Version})
+		}
+		return nil, err
+	}
+	return c.ClientForGroupVersionKind(kinds[0])
+}
+
+// ClientForGroupVersion returns a client for the specified groupVersion, creates one if none exists. Kind
+// in the GroupVersionKind may be empty.
+func (c *clientPoolImpl) ClientForGroupVersionKind(kind schema.GroupVersionKind) (Interface, error) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	gv := kind.GroupVersion()
+
+	// do we have a client already configured?
+	if existingClient, found := c.clients[gv]; found {
+		return existingClient, nil
+	}
+
+	// avoid changing the original config
+	confCopy := *c.config
+	conf := &confCopy
+
+	// we need to set the api path based on group version, if no group, default to legacy path
+	conf.APIPath = c.apiPathResolverFunc(kind)
+
+	// we need to make a client
+	conf.GroupVersion = &gv
+
+	dynamicClient, err := NewClient(conf)
+	if err != nil {
+		return nil, err
+	}
+	c.clients[gv] = dynamicClient
+	return dynamicClient, nil
+}

dynamic/client_test.go

@@ -18,7 +18,6 @@ package dynamic
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -59,10 +58,11 @@ func getObject(version, kind, name string) *unstructured.Unstructured {
 	}
 }
 
-func getClientServer(h func(http.ResponseWriter, *http.Request)) (Interface, *httptest.Server, error) {
+func getClientServer(gv *schema.GroupVersion, h func(http.ResponseWriter, *http.Request)) (Interface, *httptest.Server, error) {
 	srv := httptest.NewServer(http.HandlerFunc(h))
-	cl, err := NewForConfig(&restclient.Config{
-		Host: srv.URL,
+	cl, err := NewClient(&restclient.Config{
+		Host:          srv.URL,
+		ContentConfig: restclient.ContentConfig{GroupVersion: gv},
 	})
 	if err != nil {
 		srv.Close()
@@ -81,7 +81,7 @@ func TestList(t *testing.T) {
 	}{
 		{
 			name: "normal_list",
-			path: "/apis/gtest/vtest/rtest",
+			path: "/api/gtest/vtest/rtest",
 			resp: getListJSON("vTest", "rTestList",
 				getJSON("vTest", "rTest", "item1"),
 				getJSON("vTest", "rTest", "item2")),
@@ -99,7 +99,7 @@ func TestList(t *testing.T) {
 		{
 			name:      "namespaced_list",
 			namespace: "nstest",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
 			resp: getListJSON("vTest", "rTestList",
 				getJSON("vTest", "rTest", "item1"),
 				getJSON("vTest", "rTest", "item2")),
@@ -116,8 +116,9 @@ func TestList(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: "rtest"}
-		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("List(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
 			}
@@ -135,7 +136,7 @@ func TestList(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource).Namespace(tc.namespace).List(context.TODO(), metav1.ListOptions{})
+		got, err := cl.Resource(resource, tc.namespace).List(metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when listing %q: %v", tc.name, err)
 			continue
@@ -149,18 +150,17 @@ func TestList(t *testing.T) {
 
 func TestGet(t *testing.T) {
 	tcs := []struct {
-		resource    string
-		subresource []string
-		namespace   string
-		name        string
-		path        string
-		resp        []byte
-		want        *unstructured.Unstructured
+		resource  string
+		namespace string
+		name      string
+		path      string
+		resp      []byte
+		want      *unstructured.Unstructured
 	}{
 		{
 			resource: "rtest",
 			name:     "normal_get",
-			path:     "/apis/gtest/vtest/rtest/normal_get",
+			path:     "/api/gtest/vtest/rtest/normal_get",
 			resp:     getJSON("vTest", "rTest", "normal_get"),
 			want:     getObject("vTest", "rTest", "normal_get"),
 		},
@@ -168,31 +168,30 @@ func TestGet(t *testing.T) {
 			resource:  "rtest",
 			namespace: "nstest",
 			name:      "namespaced_get",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_get",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_get",
 			resp:      getJSON("vTest", "rTest", "namespaced_get"),
 			want:      getObject("vTest", "rTest", "namespaced_get"),
 		},
 		{
-			resource:    "rtest",
-			subresource: []string{"srtest"},
-			name:        "normal_subresource_get",
-			path:        "/apis/gtest/vtest/rtest/normal_subresource_get/srtest",
-			resp:        getJSON("vTest", "srTest", "normal_subresource_get"),
-			want:        getObject("vTest", "srTest", "normal_subresource_get"),
+			resource: "rtest/srtest",
+			name:     "normal_subresource_get",
+			path:     "/api/gtest/vtest/rtest/normal_subresource_get/srtest",
+			resp:     getJSON("vTest", "srTest", "normal_subresource_get"),
+			want:     getObject("vTest", "srTest", "normal_subresource_get"),
 		},
 		{
-			resource:    "rtest",
-			subresource: []string{"srtest"},
-			namespace:   "nstest",
-			name:        "namespaced_subresource_get",
-			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_get/srtest",
-			resp:        getJSON("vTest", "srTest", "namespaced_subresource_get"),
-			want:        getObject("vTest", "srTest", "namespaced_subresource_get"),
+			resource:  "rtest/srtest",
+			namespace: "nstest",
+			name:      "namespaced_subresource_get",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_get/srtest",
+			resp:      getJSON("vTest", "srTest", "namespaced_subresource_get"),
+			want:      getObject("vTest", "srTest", "namespaced_subresource_get"),
 		},
 	}
 	for _, tc := range tcs {
-		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: tc.resource}
-		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("Get(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
 			}
@@ -210,7 +209,7 @@ func TestGet(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource).Namespace(tc.namespace).Get(context.TODO(), tc.name, metav1.GetOptions{}, tc.subresource...)
+		got, err := cl.Resource(resource, tc.namespace).Get(tc.name, metav1.GetOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when getting %q: %v", tc.name, err)
 			continue
@@ -223,50 +222,29 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	background := metav1.DeletePropagationBackground
-	uid := types.UID("uid")
-
 	statusOK := &metav1.Status{
 		TypeMeta: metav1.TypeMeta{Kind: "Status"},
 		Status:   metav1.StatusSuccess,
 	}
 	tcs := []struct {
-		subresource   []string
-		namespace     string
-		name          string
-		path          string
-		deleteOptions metav1.DeleteOptions
+		namespace string
+		name      string
+		path      string
 	}{
 		{
 			name: "normal_delete",
-			path: "/apis/gtest/vtest/rtest/normal_delete",
+			path: "/api/gtest/vtest/rtest/normal_delete",
 		},
 		{
 			namespace: "nstest",
 			name:      "namespaced_delete",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete",
-		},
-		{
-			subresource: []string{"srtest"},
-			name:        "normal_delete",
-			path:        "/apis/gtest/vtest/rtest/normal_delete/srtest",
-		},
-		{
-			subresource: []string{"srtest"},
-			namespace:   "nstest",
-			name:        "namespaced_delete",
-			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete/srtest",
-		},
-		{
-			namespace:     "nstest",
-			name:          "namespaced_delete_with_options",
-			path:          "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete_with_options",
-			deleteOptions: metav1.DeleteOptions{Preconditions: &metav1.Preconditions{UID: &uid}, PropagationPolicy: &background},
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_delete",
 		},
 	}
 	for _, tc := range tcs {
-		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: "rtest"}
-		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "DELETE" {
 				t.Errorf("Delete(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
 			}
@@ -284,7 +262,7 @@ func TestDelete(t *testing.T) {
 		}
 		defer srv.Close()
 
-		err = cl.Resource(resource).Namespace(tc.namespace).Delete(context.TODO(), tc.name, tc.deleteOptions, tc.subresource...)
+		err = cl.Resource(resource, tc.namespace).Delete(tc.name, nil)
 		if err != nil {
 			t.Errorf("unexpected error when deleting %q: %v", tc.name, err)
 			continue
@@ -304,17 +282,18 @@ func TestDeleteCollection(t *testing.T) {
 	}{
 		{
 			name: "normal_delete_collection",
-			path: "/apis/gtest/vtest/rtest",
+			path: "/api/gtest/vtest/rtest",
 		},
 		{
 			namespace: "nstest",
 			name:      "namespaced_delete_collection",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
 		},
 	}
 	for _, tc := range tcs {
-		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: "rtest"}
-		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "DELETE" {
 				t.Errorf("DeleteCollection(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
 			}
@@ -332,7 +311,7 @@ func TestDeleteCollection(t *testing.T) {
 		}
 		defer srv.Close()
 
-		err = cl.Resource(resource).Namespace(tc.namespace).DeleteCollection(context.TODO(), metav1.DeleteOptions{}, metav1.ListOptions{})
+		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when deleting collection %q: %v", tc.name, err)
 			continue
@@ -342,45 +321,43 @@ func TestDeleteCollection(t *testing.T) {
 
 func TestCreate(t *testing.T) {
 	tcs := []struct {
-		resource    string
-		subresource []string
-		name        string
-		namespace   string
-		obj         *unstructured.Unstructured
-		path        string
+		resource  string
+		name      string
+		namespace string
+		obj       *unstructured.Unstructured
+		path      string
 	}{
 		{
 			resource: "rtest",
 			name:     "normal_create",
-			path:     "/apis/gtest/vtest/rtest",
-			obj:      getObject("gtest/vTest", "rTest", "normal_create"),
+			path:     "/api/gtest/vtest/rtest",
+			obj:      getObject("vTest", "rTest", "normal_create"),
 		},
 		{
 			resource:  "rtest",
 			name:      "namespaced_create",
 			namespace: "nstest",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
-			obj:       getObject("gtest/vTest", "rTest", "namespaced_create"),
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
+			obj:       getObject("vTest", "rTest", "namespaced_create"),
 		},
 		{
-			resource:    "rtest",
-			subresource: []string{"srtest"},
-			name:        "normal_subresource_create",
-			path:        "/apis/gtest/vtest/rtest/normal_subresource_create/srtest",
-			obj:         getObject("vTest", "srTest", "normal_subresource_create"),
+			resource: "rtest/srtest",
+			name:     "normal_subresource_create",
+			path:     "/api/gtest/vtest/rtest/normal_subresource_create/srtest",
+			obj:      getObject("vTest", "srTest", "normal_subresource_create"),
 		},
 		{
-			resource:    "rtest/",
-			subresource: []string{"srtest"},
-			name:        "namespaced_subresource_create",
-			namespace:   "nstest",
-			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_create/srtest",
-			obj:         getObject("vTest", "srTest", "namespaced_subresource_create"),
+			resource:  "rtest/srtest",
+			name:      "namespaced_subresource_create",
+			namespace: "nstest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_create/srtest",
+			obj:       getObject("vTest", "srTest", "namespaced_subresource_create"),
 		},
 	}
 	for _, tc := range tcs {
-		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: tc.resource}
-		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "POST" {
 				t.Errorf("Create(%q) got HTTP method %s. wanted POST", tc.name, r.Method)
 			}
@@ -405,7 +382,7 @@ func TestCreate(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource).Namespace(tc.namespace).Create(context.TODO(), tc.obj, metav1.CreateOptions{}, tc.subresource...)
+		got, err := cl.Resource(resource, tc.namespace).Create(tc.obj)
 		if err != nil {
 			t.Errorf("unexpected error when creating %q: %v", tc.name, err)
 			continue
@@ -419,45 +396,43 @@ func TestCreate(t *testing.T) {
 
 func TestUpdate(t *testing.T) {
 	tcs := []struct {
-		resource    string
-		subresource []string
-		name        string
-		namespace   string
-		obj         *unstructured.Unstructured
-		path        string
+		resource  string
+		name      string
+		namespace string
+		obj       *unstructured.Unstructured
+		path      string
 	}{
 		{
 			resource: "rtest",
 			name:     "normal_update",
-			path:     "/apis/gtest/vtest/rtest/normal_update",
-			obj:      getObject("gtest/vTest", "rTest", "normal_update"),
+			path:     "/api/gtest/vtest/rtest/normal_update",
+			obj:      getObject("vTest", "rTest", "normal_update"),
 		},
 		{
 			resource:  "rtest",
 			name:      "namespaced_update",
 			namespace: "nstest",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_update",
-			obj:       getObject("gtest/vTest", "rTest", "namespaced_update"),
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_update",
+			obj:       getObject("vTest", "rTest", "namespaced_update"),
 		},
 		{
-			resource:    "rtest",
-			subresource: []string{"srtest"},
-			name:        "normal_subresource_update",
-			path:        "/apis/gtest/vtest/rtest/normal_update/srtest",
-			obj:         getObject("gtest/vTest", "srTest", "normal_update"),
+			resource: "rtest/srtest",
+			name:     "normal_subresource_update",
+			path:     "/api/gtest/vtest/rtest/normal_update/srtest",
+			obj:      getObject("vTest", "srTest", "normal_update"),
 		},
 		{
-			resource:    "rtest",
-			subresource: []string{"srtest"},
-			name:        "namespaced_subresource_update",
-			namespace:   "nstest",
-			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_update/srtest",
-			obj:         getObject("gtest/vTest", "srTest", "namespaced_update"),
+			resource:  "rtest/srtest",
+			name:      "namespaced_subresource_update",
+			namespace: "nstest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_update/srtest",
+			obj:       getObject("vTest", "srTest", "namespaced_update"),
 		},
 	}
 	for _, tc := range tcs {
-		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: tc.resource}
-		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "PUT" {
 				t.Errorf("Update(%q) got HTTP method %s. wanted PUT", tc.name, r.Method)
 			}
@@ -482,7 +457,7 @@ func TestUpdate(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource).Namespace(tc.namespace).Update(context.TODO(), tc.obj, metav1.UpdateOptions{}, tc.subresource...)
+		got, err := cl.Resource(resource, tc.namespace).Update(tc.obj)
 		if err != nil {
 			t.Errorf("unexpected error when updating %q: %v", tc.name, err)
 			continue
@@ -504,29 +479,30 @@ func TestWatch(t *testing.T) {
 	}{
 		{
 			name:  "normal_watch",
-			path:  "/apis/gtest/vtest/rtest",
+			path:  "/api/gtest/vtest/rtest",
 			query: "watch=true",
 			events: []watch.Event{
-				{Type: watch.Added, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
-				{Type: watch.Modified, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
-				{Type: watch.Deleted, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
+				{Type: watch.Added, Object: getObject("vTest", "rTest", "normal_watch")},
+				{Type: watch.Modified, Object: getObject("vTest", "rTest", "normal_watch")},
+				{Type: watch.Deleted, Object: getObject("vTest", "rTest", "normal_watch")},
 			},
 		},
 		{
 			name:      "namespaced_watch",
 			namespace: "nstest",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
 			query:     "watch=true",
 			events: []watch.Event{
-				{Type: watch.Added, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
-				{Type: watch.Modified, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
-				{Type: watch.Deleted, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Added, Object: getObject("vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Modified, Object: getObject("vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Deleted, Object: getObject("vTest", "rTest", "namespaced_watch")},
 			},
 		},
 	}
 	for _, tc := range tcs {
-		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: "rtest"}
-		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("Watch(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
 			}
@@ -538,9 +514,7 @@ func TestWatch(t *testing.T) {
 				t.Errorf("Watch(%q) got query %s. wanted %s", tc.name, r.URL.RawQuery, tc.query)
 			}
 
-			w.Header().Set("Content-Type", "application/json")
-
-			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, unstructured.UnstructuredJSONScheme), unstructured.UnstructuredJSONScheme)
+			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
 			for _, e := range tc.events {
 				enc.Encode(&e)
 			}
@@ -551,7 +525,7 @@ func TestWatch(t *testing.T) {
 		}
 		defer srv.Close()
 
-		watcher, err := cl.Resource(resource).Namespace(tc.namespace).Watch(context.TODO(), metav1.ListOptions{})
+		watcher, err := cl.Resource(resource, tc.namespace).Watch(metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when watching %q: %v", tc.name, err)
 			continue
@@ -568,50 +542,48 @@ func TestWatch(t *testing.T) {
 
 func TestPatch(t *testing.T) {
 	tcs := []struct {
-		resource    string
-		subresource []string
-		name        string
-		namespace   string
-		patch       []byte
-		want        *unstructured.Unstructured
-		path        string
+		resource  string
+		name      string
+		namespace string
+		patch     []byte
+		want      *unstructured.Unstructured
+		path      string
 	}{
 		{
 			resource: "rtest",
 			name:     "normal_patch",
-			path:     "/apis/gtest/vtest/rtest/normal_patch",
-			patch:    getJSON("gtest/vTest", "rTest", "normal_patch"),
-			want:     getObject("gtest/vTest", "rTest", "normal_patch"),
+			path:     "/api/gtest/vtest/rtest/normal_patch",
+			patch:    getJSON("vTest", "rTest", "normal_patch"),
+			want:     getObject("vTest", "rTest", "normal_patch"),
 		},
 		{
 			resource:  "rtest",
 			name:      "namespaced_patch",
 			namespace: "nstest",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_patch",
-			patch:     getJSON("gtest/vTest", "rTest", "namespaced_patch"),
-			want:      getObject("gtest/vTest", "rTest", "namespaced_patch"),
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_patch",
+			patch:     getJSON("vTest", "rTest", "namespaced_patch"),
+			want:      getObject("vTest", "rTest", "namespaced_patch"),
 		},
 		{
-			resource:    "rtest",
-			subresource: []string{"srtest"},
-			name:        "normal_subresource_patch",
-			path:        "/apis/gtest/vtest/rtest/normal_subresource_patch/srtest",
-			patch:       getJSON("gtest/vTest", "srTest", "normal_subresource_patch"),
-			want:        getObject("gtest/vTest", "srTest", "normal_subresource_patch"),
+			resource: "rtest/srtest",
+			name:     "normal_subresource_patch",
+			path:     "/api/gtest/vtest/rtest/normal_subresource_patch/srtest",
+			patch:    getJSON("vTest", "srTest", "normal_subresource_patch"),
+			want:     getObject("vTest", "srTest", "normal_subresource_patch"),
 		},
 		{
-			resource:    "rtest",
-			subresource: []string{"srtest"},
-			name:        "namespaced_subresource_patch",
-			namespace:   "nstest",
-			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_patch/srtest",
-			patch:       getJSON("gtest/vTest", "srTest", "namespaced_subresource_patch"),
-			want:        getObject("gtest/vTest", "srTest", "namespaced_subresource_patch"),
+			resource:  "rtest/srtest",
+			name:      "namespaced_subresource_patch",
+			namespace: "nstest",
+			path:      "/api/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_patch/srtest",
+			patch:     getJSON("vTest", "srTest", "namespaced_subresource_patch"),
+			want:      getObject("vTest", "srTest", "namespaced_subresource_patch"),
 		},
 	}
 	for _, tc := range tcs {
-		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: tc.resource}
-		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "PATCH" {
 				t.Errorf("Patch(%q) got HTTP method %s. wanted PATCH", tc.name, r.Method)
 			}
@@ -641,7 +613,7 @@ func TestPatch(t *testing.T) {
 		}
 		defer srv.Close()
 
-		got, err := cl.Resource(resource).Namespace(tc.namespace).Patch(context.TODO(), tc.name, types.StrategicMergePatchType, tc.patch, metav1.PatchOptions{}, tc.subresource...)
+		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, types.StrategicMergePatchType, tc.patch)
 		if err != nil {
 			t.Errorf("unexpected error when patching %q: %v", tc.name, err)
 			continue
@@ -652,3 +624,11 @@ func TestPatch(t *testing.T) {
 		}
 	}
 }
+
+func TestVersionedParameterEncoderWithV1Fallback(t *testing.T) {
+	enc := VersionedParameterEncoderWithV1Fallback
+	_, err := enc.EncodeParameters(&metav1.ListOptions{}, schema.GroupVersion{Group: "foo.bar.com", Version: "v4"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}

dynamic/dynamic_util.go

@@ -0,0 +1,96 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package dynamic
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// VersionInterfaces provides an object converter and metadata
+// accessor appropriate for use with unstructured objects.
+func VersionInterfaces(schema.GroupVersion) (*meta.VersionInterfaces, error) {
+	return &meta.VersionInterfaces{
+		ObjectConvertor:  &unstructured.UnstructuredObjectConverter{},
+		MetadataAccessor: meta.NewAccessor(),
+	}, nil
+}
+
+// NewDiscoveryRESTMapper returns a RESTMapper based on discovery information.
+func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
+	rm := meta.NewDefaultRESTMapper(nil, versionFunc)
+	for _, resourceList := range resources {
+		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, resource := range resourceList.APIResources {
+			gvk := gv.WithKind(resource.Kind)
+			scope := meta.RESTScopeRoot
+			if resource.Namespaced {
+				scope = meta.RESTScopeNamespace
+			}
+			rm.Add(gvk, scope)
+		}
+	}
+	return rm, nil
+}
+
+// ObjectTyper provides an ObjectTyper implementation for
+// unstructured.Unstructured object based on discovery information.
+type ObjectTyper struct {
+	registered map[schema.GroupVersionKind]bool
+}
+
+// NewObjectTyper constructs an ObjectTyper from discovery information.
+func NewObjectTyper(resources []*metav1.APIResourceList) (runtime.ObjectTyper, error) {
+	ot := &ObjectTyper{registered: make(map[schema.GroupVersionKind]bool)}
+	for _, resourceList := range resources {
+		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, resource := range resourceList.APIResources {
+			ot.registered[gv.WithKind(resource.Kind)] = true
+		}
+	}
+	return ot, nil
+}
+
+// ObjectKinds returns a slice of one element with the
+// group,version,kind of the provided object, or an error if the
+// object is not *unstructured.Unstructured or has no group,version,kind
+// information.
+func (ot *ObjectTyper) ObjectKinds(obj runtime.Object) ([]schema.GroupVersionKind, bool, error) {
+	if _, ok := obj.(*unstructured.Unstructured); !ok {
+		return nil, false, fmt.Errorf("type %T is invalid for determining dynamic object types", obj)
+	}
+	return []schema.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
+}
+
+// Recognizes returns true if the provided group,version,kind was in
+// the discovery information.
+func (ot *ObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
+	return ot.registered[gvk]
+}

dynamic/dynamic_util_test.go

@@ -0,0 +1,79 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package dynamic
+
+import (
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+func TestDiscoveryRESTMapper(t *testing.T) {
+	resources := []*metav1.APIResourceList{
+		{
+			GroupVersion: "test/beta1",
+			APIResources: []metav1.APIResource{
+				{
+					Name:       "test_kinds",
+					Namespaced: true,
+					Kind:       "test_kind",
+				},
+			},
+		},
+	}
+
+	gvk := schema.GroupVersionKind{
+		Group:   "test",
+		Version: "beta1",
+		Kind:    "test_kind",
+	}
+
+	mapper, err := NewDiscoveryRESTMapper(resources, VersionInterfaces)
+	if err != nil {
+		t.Fatalf("unexpected error creating mapper: %s", err)
+	}
+
+	for _, res := range []schema.GroupVersionResource{
+		{
+			Group:    "test",
+			Version:  "beta1",
+			Resource: "test_kinds",
+		},
+		{
+			Version:  "beta1",
+			Resource: "test_kinds",
+		},
+		{
+			Group:    "test",
+			Resource: "test_kinds",
+		},
+		{
+			Resource: "test_kinds",
+		},
+	} {
+		got, err := mapper.KindFor(res)
+		if err != nil {
+			t.Errorf("KindFor(%#v) unexpected error: %s", res, err)
+			continue
+		}
+
+		if got != gvk {
+			t.Errorf("KindFor(%#v) = %#v; want %#v", res, got, gvk)
+		}
+	}
+}

dynamic/dynamicinformer/informer.go

@@ -1,158 +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 (
-	"context"
-	"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:        namespace,
-		informers:        map[schema.GroupVersionResource]informers.GenericInformer{},
-		startedInformers: make(map[schema.GroupVersionResource]bool),
-		tweakListOptions: tweakListOptions,
-	}
-}
-
-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
-	tweakListOptions TweakListOptionsFunc
-}
-
-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}, f.tweakListOptions)
-	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(context.TODO(), options)
-				},
-				WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-					if tweakListOptions != nil {
-						tweakListOptions(&options)
-					}
-					return client.Resource(gvr).Namespace(namespace).Watch(context.TODO(), 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,263 +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"
-)
-
-type triggerFunc func(gvr schema.GroupVersionResource, ns string, fakeClient *fake.FakeDynamicClient, testObject *unstructured.Unstructured) *unstructured.Unstructured
-
-func triggerFactory(t *testing.T) triggerFunc {
-	return func(gvr schema.GroupVersionResource, ns string, fakeClient *fake.FakeDynamicClient, _ *unstructured.Unstructured) *unstructured.Unstructured {
-		testObject := newUnstructured("apps/v1", "Deployment", "ns-foo", "name-foo")
-		createdObj, err := fakeClient.Resource(gvr).Namespace(ns).Create(context.TODO(), testObject, metav1.CreateOptions{})
-		if err != nil {
-			t.Error(err)
-		}
-		return createdObj
-	}
-}
-
-func handler(rcvCh chan<- *unstructured.Unstructured) *cache.ResourceEventHandlerFuncs {
-	return &cache.ResourceEventHandlerFuncs{
-		AddFunc: func(obj interface{}) {
-			rcvCh <- obj.(*unstructured.Unstructured)
-		},
-	}
-}
-
-func TestFilteredDynamicSharedInformerFactory(t *testing.T) {
-	scenarios := []struct {
-		name        string
-		existingObj *unstructured.Unstructured
-		gvr         schema.GroupVersionResource
-		informNS    string
-		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 adding an object in different namespace should not trigger AddFunc",
-			informNS: "ns-bar",
-			ns:       "ns-foo",
-			gvr:      schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"},
-			trigger:  triggerFactory(t),
-			handler:  handler,
-		},
-		// scenario 2
-		{
-			name:     "scenario 2: test adding an object should trigger AddFunc",
-			informNS: "ns-foo",
-			ns:       "ns-foo",
-			gvr:      schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"},
-			trigger:  triggerFactory(t),
-			handler:  handler,
-		},
-	}
-
-	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)
-			}
-			// don't adjust the scheme to include deploymentlist. This is testing whether an informer can be created against using
-			// a client that doesn't have a type registered in the scheme.
-			gvrToListKind := map[schema.GroupVersionResource]string{
-				{Group: "apps", Version: "v1", Resource: "deployments"}: "DeploymentList",
-			}
-			fakeClient := fake.NewSimpleDynamicClientWithCustomListKinds(scheme, gvrToListKind, objs...)
-			target := dynamicinformer.NewFilteredDynamicSharedInformerFactory(fakeClient, 0, ts.informNS, nil)
-
-			// 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 ts.ns != ts.informNS {
-					t.Errorf("informer received an object for namespace %s when watching namespace %s", ts.ns, ts.informNS)
-				}
-				if !equality.Semantic.DeepEqual(testObject, objFromInformer) {
-					t.Fatalf("%v", diff.ObjectDiff(testObject, objFromInformer))
-				}
-			case <-ctx.Done():
-				if ts.ns == ts.informNS {
-					t.Errorf("tested informer haven't received an object, waited %v", timeout)
-				}
-			}
-		})
-	}
-
-}
-
-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(context.TODO(), 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(context.TODO(), 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(context.TODO(), 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)
-			}
-			// don't adjust the scheme to include deploymentlist. This is testing whether an informer can be created against using
-			// a client that doesn't have a type registered in the scheme.
-			gvrToListKind := map[schema.GroupVersionResource]string{
-				{Group: "extensions", Version: "v1beta1", Resource: "deployments"}: "DeploymentList",
-			}
-			fakeClient := fake.NewSimpleDynamicClientWithCustomListKinds(scheme, gvrToListKind, 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/client.go

@@ -0,0 +1,163 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package fake provides a fake client interface to arbitrary Kubernetes
+// APIs that exposes common high level operations and exposes common
+// metadata.
+package fake
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"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/types"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/testing"
+	"k8s.io/client-go/util/flowcontrol"
+)
+
+// FakeClient is a fake implementation of dynamic.Interface.
+type FakeClient struct {
+	GroupVersion schema.GroupVersion
+
+	*testing.Fake
+}
+
+// GetRateLimiter returns the rate limiter for this client.
+func (c *FakeClient) GetRateLimiter() flowcontrol.RateLimiter {
+	return nil
+}
+
+// Resource returns an API interface to the specified resource for this client's
+// group and version.  If resource is not a namespaced resource, then namespace
+// is ignored.  The ResourceClient inherits the parameter codec of this client
+func (c *FakeClient) Resource(resource *metav1.APIResource, namespace string) dynamic.ResourceInterface {
+	return &FakeResourceClient{
+		Resource:  c.GroupVersion.WithResource(resource.Name),
+		Kind:      c.GroupVersion.WithKind(resource.Kind),
+		Namespace: namespace,
+
+		Fake: c.Fake,
+	}
+}
+
+// ParameterCodec returns a client with the provided parameter codec.
+func (c *FakeClient) ParameterCodec(parameterCodec runtime.ParameterCodec) dynamic.Interface {
+	return &FakeClient{
+		Fake: c.Fake,
+	}
+}
+
+// FakeResourceClient is a fake implementation of dynamic.ResourceInterface
+type FakeResourceClient struct {
+	Resource  schema.GroupVersionResource
+	Kind      schema.GroupVersionKind
+	Namespace string
+
+	*testing.Fake
+}
+
+// List returns a list of objects for this resource.
+func (c *FakeResourceClient) List(opts metav1.ListOptions) (runtime.Object, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(c.Resource, c.Kind, c.Namespace, opts), &unstructured.UnstructuredList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &unstructured.UnstructuredList{}
+	for _, item := range obj.(*unstructured.UnstructuredList).Items {
+		if label.Matches(labels.Set(item.GetLabels())) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Get gets the resource with the specified name.
+func (c *FakeResourceClient) Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(c.Resource, c.Namespace, name), &unstructured.Unstructured{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	return obj.(*unstructured.Unstructured), err
+}
+
+// Delete deletes the resource with the specified name.
+func (c *FakeResourceClient) Delete(name string, opts *metav1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(c.Resource, c.Namespace, name), &unstructured.Unstructured{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeResourceClient) DeleteCollection(deleteOptions *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteCollectionAction(c.Resource, c.Namespace, listOptions), &unstructured.Unstructured{})
+
+	return err
+}
+
+// Create creates the provided resource.
+func (c *FakeResourceClient) Create(inObj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(c.Resource, c.Namespace, inObj), &unstructured.Unstructured{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*unstructured.Unstructured), err
+}
+
+// Update updates the provided resource.
+func (c *FakeResourceClient) Update(inObj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(c.Resource, c.Namespace, inObj), &unstructured.Unstructured{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*unstructured.Unstructured), err
+}
+
+// Watch returns a watch.Interface that watches the resource.
+func (c *FakeResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(c.Resource, c.Namespace, opts))
+}
+
+// Patch patches the provided resource.
+func (c *FakeResourceClient) Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchAction(c.Resource, c.Namespace, name, data), &unstructured.Unstructured{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*unstructured.Unstructured), err
+}

dynamic/fake/client_pool.go

@@ -0,0 +1,48 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package fake provides a fake client interface to arbitrary Kubernetes
+// APIs that exposes common high level operations and exposes common
+// metadata.
+package fake
+
+import (
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/testing"
+)
+
+// FakeClientPool provides a fake implementation of dynamic.ClientPool.
+// It assumes resource GroupVersions are the same as their corresponding kind GroupVersions.
+type FakeClientPool struct {
+	testing.Fake
+}
+
+// ClientForGroupVersionKind returns a client configured for the specified groupVersionResource.
+// Resource may be empty.
+func (p *FakeClientPool) ClientForGroupVersionResource(resource schema.GroupVersionResource) (dynamic.Interface, error) {
+	return p.ClientForGroupVersionKind(resource.GroupVersion().WithKind(""))
+}
+
+// ClientForGroupVersionKind returns a client configured for the specified groupVersionKind.
+// Kind may be empty.
+func (p *FakeClientPool) ClientForGroupVersionKind(kind schema.GroupVersionKind) (dynamic.Interface, error) {
+	// we can just create a new client every time for testing purposes
+	return &FakeClient{
+		GroupVersion: kind.GroupVersion(),
+		Fake:         &p.Fake,
+	}, nil
+}

dynamic/fake/simple.go

@@ -1,419 +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 fake
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/client-go/testing"
-)
-
-func NewSimpleDynamicClient(scheme *runtime.Scheme, objects ...runtime.Object) *FakeDynamicClient {
-	return NewSimpleDynamicClientWithCustomListKinds(scheme, nil, objects...)
-}
-
-// NewSimpleDynamicClientWithCustomListKinds try not to use this.  In general you want to have the scheme have the List types registered
-// and allow the default guessing for resources match.  Sometimes that doesn't work, so you can specify a custom mapping here.
-func NewSimpleDynamicClientWithCustomListKinds(scheme *runtime.Scheme, gvrToListKind map[schema.GroupVersionResource]string, objects ...runtime.Object) *FakeDynamicClient {
-	// In order to use List with this client, you have to have your lists registered so that the object tracker will find them
-	// in the scheme to support the t.scheme.New(listGVK) call when it's building the return value.
-	// Since the base fake client needs the listGVK passed through the action (in cases where there are no instances, it
-	// cannot look up the actual hits), we need to know a mapping of GVR to listGVK here.  For GETs and other types of calls,
-	// there is no return value that contains a GVK, so it doesn't have to know the mapping in advance.
-
-	// first we attempt to invert known List types from the scheme to auto guess the resource with unsafe guesses
-	// this covers common usage of registering types in scheme and passing them
-	completeGVRToListKind := map[schema.GroupVersionResource]string{}
-	for listGVK := range scheme.AllKnownTypes() {
-		if !strings.HasSuffix(listGVK.Kind, "List") {
-			continue
-		}
-		nonListGVK := listGVK.GroupVersion().WithKind(listGVK.Kind[:len(listGVK.Kind)-4])
-		plural, _ := meta.UnsafeGuessKindToResource(nonListGVK)
-		completeGVRToListKind[plural] = listGVK.Kind
-	}
-
-	for gvr, listKind := range gvrToListKind {
-		if !strings.HasSuffix(listKind, "List") {
-			panic("coding error, listGVK must end in List or this fake client doesn't work right")
-		}
-		listGVK := gvr.GroupVersion().WithKind(listKind)
-
-		// if we already have this type registered, just skip it
-		if _, err := scheme.New(listGVK); err == nil {
-			completeGVRToListKind[gvr] = listKind
-			continue
-		}
-
-		scheme.AddKnownTypeWithName(listGVK, &unstructured.UnstructuredList{})
-		completeGVRToListKind[gvr] = listKind
-	}
-
-	codecs := serializer.NewCodecFactory(scheme)
-	o := testing.NewObjectTracker(scheme, codecs.UniversalDecoder())
-	for _, obj := range objects {
-		if err := o.Add(obj); err != nil {
-			panic(err)
-		}
-	}
-
-	cs := &FakeDynamicClient{scheme: scheme, gvrToListKind: completeGVRToListKind}
-	cs.AddReactor("*", "*", testing.ObjectReaction(o))
-	cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
-		gvr := action.GetResource()
-		ns := action.GetNamespace()
-		watch, err := o.Watch(gvr, ns)
-		if err != nil {
-			return false, nil, err
-		}
-		return true, watch, nil
-	})
-
-	return cs
-}
-
-// Clientset implements clientset.Interface. Meant to be embedded into a
-// struct to get a default implementation. This makes faking out just the method
-// you want to test easier.
-type FakeDynamicClient struct {
-	testing.Fake
-	scheme        *runtime.Scheme
-	gvrToListKind map[schema.GroupVersionResource]string
-}
-
-type dynamicResourceClient struct {
-	client    *FakeDynamicClient
-	namespace string
-	resource  schema.GroupVersionResource
-	listKind  string
-}
-
-var _ dynamic.Interface = &FakeDynamicClient{}
-
-func (c *FakeDynamicClient) Resource(resource schema.GroupVersionResource) dynamic.NamespaceableResourceInterface {
-	return &dynamicResourceClient{client: c, resource: resource, listKind: c.gvrToListKind[resource]}
-}
-
-func (c *dynamicResourceClient) Namespace(ns string) dynamic.ResourceInterface {
-	ret := *c
-	ret.namespace = ns
-	return &ret
-}
-
-func (c *dynamicResourceClient) Create(ctx context.Context, obj *unstructured.Unstructured, opts metav1.CreateOptions, 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.NewRootCreateAction(c.resource, obj), obj)
-
-	case len(c.namespace) == 0 && len(subresources) > 0:
-		var accessor metav1.Object // avoid shadowing err
-		accessor, err = meta.Accessor(obj)
-		if err != nil {
-			return nil, err
-		}
-		name := accessor.GetName()
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewRootCreateSubresourceAction(c.resource, name, strings.Join(subresources, "/"), obj), obj)
-
-	case len(c.namespace) > 0 && len(subresources) == 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewCreateAction(c.resource, c.namespace, obj), obj)
-
-	case len(c.namespace) > 0 && len(subresources) > 0:
-		var accessor metav1.Object // avoid shadowing err
-		accessor, err = meta.Accessor(obj)
-		if err != nil {
-			return nil, err
-		}
-		name := accessor.GetName()
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewCreateSubresourceAction(c.resource, name, strings.Join(subresources, "/"), c.namespace, obj), obj)
-
-	}
-
-	if err != nil {
-		return nil, err
-	}
-	if uncastRet == nil {
-		return nil, err
-	}
-
-	ret := &unstructured.Unstructured{}
-	if err := c.client.scheme.Convert(uncastRet, ret, nil); err != nil {
-		return nil, err
-	}
-	return ret, err
-}
-
-func (c *dynamicResourceClient) Update(ctx context.Context, obj *unstructured.Unstructured, 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.NewRootUpdateAction(c.resource, obj), obj)
-
-	case len(c.namespace) == 0 && len(subresources) > 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewRootUpdateSubresourceAction(c.resource, strings.Join(subresources, "/"), obj), obj)
-
-	case len(c.namespace) > 0 && len(subresources) == 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewUpdateAction(c.resource, c.namespace, obj), obj)
-
-	case len(c.namespace) > 0 && len(subresources) > 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewUpdateSubresourceAction(c.resource, strings.Join(subresources, "/"), c.namespace, obj), obj)
-
-	}
-
-	if err != nil {
-		return nil, err
-	}
-	if uncastRet == nil {
-		return nil, err
-	}
-
-	ret := &unstructured.Unstructured{}
-	if err := c.client.scheme.Convert(uncastRet, ret, nil); err != nil {
-		return nil, err
-	}
-	return ret, err
-}
-
-func (c *dynamicResourceClient) UpdateStatus(ctx context.Context, obj *unstructured.Unstructured, opts metav1.UpdateOptions) (*unstructured.Unstructured, error) {
-	var uncastRet runtime.Object
-	var err error
-	switch {
-	case len(c.namespace) == 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewRootUpdateSubresourceAction(c.resource, "status", obj), obj)
-
-	case len(c.namespace) > 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewUpdateSubresourceAction(c.resource, "status", c.namespace, obj), obj)
-
-	}
-
-	if err != nil {
-		return nil, err
-	}
-	if uncastRet == nil {
-		return nil, err
-	}
-
-	ret := &unstructured.Unstructured{}
-	if err := c.client.scheme.Convert(uncastRet, ret, nil); err != nil {
-		return nil, err
-	}
-	return ret, err
-}
-
-func (c *dynamicResourceClient) Delete(ctx context.Context, name string, opts metav1.DeleteOptions, subresources ...string) error {
-	var err error
-	switch {
-	case len(c.namespace) == 0 && len(subresources) == 0:
-		_, err = c.client.Fake.
-			Invokes(testing.NewRootDeleteAction(c.resource, name), &metav1.Status{Status: "dynamic delete fail"})
-
-	case len(c.namespace) == 0 && len(subresources) > 0:
-		_, err = c.client.Fake.
-			Invokes(testing.NewRootDeleteSubresourceAction(c.resource, strings.Join(subresources, "/"), name), &metav1.Status{Status: "dynamic delete fail"})
-
-	case len(c.namespace) > 0 && len(subresources) == 0:
-		_, err = c.client.Fake.
-			Invokes(testing.NewDeleteAction(c.resource, c.namespace, name), &metav1.Status{Status: "dynamic delete fail"})
-
-	case len(c.namespace) > 0 && len(subresources) > 0:
-		_, err = c.client.Fake.
-			Invokes(testing.NewDeleteSubresourceAction(c.resource, strings.Join(subresources, "/"), c.namespace, name), &metav1.Status{Status: "dynamic delete fail"})
-	}
-
-	return err
-}
-
-func (c *dynamicResourceClient) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOptions metav1.ListOptions) error {
-	var err error
-	switch {
-	case len(c.namespace) == 0:
-		action := testing.NewRootDeleteCollectionAction(c.resource, listOptions)
-		_, err = c.client.Fake.Invokes(action, &metav1.Status{Status: "dynamic deletecollection fail"})
-
-	case len(c.namespace) > 0:
-		action := testing.NewDeleteCollectionAction(c.resource, c.namespace, listOptions)
-		_, err = c.client.Fake.Invokes(action, &metav1.Status{Status: "dynamic deletecollection fail"})
-
-	}
-
-	return err
-}
-
-func (c *dynamicResourceClient) Get(ctx context.Context, name string, opts metav1.GetOptions, 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.NewRootGetAction(c.resource, name), &metav1.Status{Status: "dynamic get fail"})
-
-	case len(c.namespace) == 0 && len(subresources) > 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewRootGetSubresourceAction(c.resource, strings.Join(subresources, "/"), name), &metav1.Status{Status: "dynamic get fail"})
-
-	case len(c.namespace) > 0 && len(subresources) == 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewGetAction(c.resource, c.namespace, name), &metav1.Status{Status: "dynamic get fail"})
-
-	case len(c.namespace) > 0 && len(subresources) > 0:
-		uncastRet, err = c.client.Fake.
-			Invokes(testing.NewGetSubresourceAction(c.resource, c.namespace, strings.Join(subresources, "/"), name), &metav1.Status{Status: "dynamic get fail"})
-	}
-
-	if err != nil {
-		return nil, err
-	}
-	if uncastRet == nil {
-		return nil, err
-	}
-
-	ret := &unstructured.Unstructured{}
-	if err := c.client.scheme.Convert(uncastRet, ret, nil); err != nil {
-		return nil, err
-	}
-	return ret, err
-}
-
-func (c *dynamicResourceClient) List(ctx context.Context, opts metav1.ListOptions) (*unstructured.UnstructuredList, error) {
-	if len(c.listKind) == 0 {
-		panic(fmt.Sprintf("coding error: you must register resource to list kind for every resource you're going to LIST when creating the client.  See NewSimpleDynamicClientWithCustomListKinds or register the list into the scheme: %v out of %v", c.resource, c.client.gvrToListKind))
-	}
-	listGVK := c.resource.GroupVersion().WithKind(c.listKind)
-	listForFakeClientGVK := c.resource.GroupVersion().WithKind(c.listKind[:len(c.listKind)-4]) /*base library appends List*/
-
-	var obj runtime.Object
-	var err error
-	switch {
-	case len(c.namespace) == 0:
-		obj, err = c.client.Fake.
-			Invokes(testing.NewRootListAction(c.resource, listForFakeClientGVK, opts), &metav1.Status{Status: "dynamic list fail"})
-
-	case len(c.namespace) > 0:
-		obj, err = c.client.Fake.
-			Invokes(testing.NewListAction(c.resource, listForFakeClientGVK, c.namespace, opts), &metav1.Status{Status: "dynamic list fail"})
-
-	}
-
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-
-	retUnstructured := &unstructured.Unstructured{}
-	if err := c.client.scheme.Convert(obj, retUnstructured, nil); err != nil {
-		return nil, err
-	}
-	entireList, err := retUnstructured.ToList()
-	if err != nil {
-		return nil, err
-	}
-
-	list := &unstructured.UnstructuredList{}
-	list.SetResourceVersion(entireList.GetResourceVersion())
-	list.GetObjectKind().SetGroupVersionKind(listGVK)
-	for i := range entireList.Items {
-		item := &entireList.Items[i]
-		metadata, err := meta.Accessor(item)
-		if err != nil {
-			return nil, err
-		}
-		if label.Matches(labels.Set(metadata.GetLabels())) {
-			list.Items = append(list.Items, *item)
-		}
-	}
-	return list, nil
-}
-
-func (c *dynamicResourceClient) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
-	switch {
-	case len(c.namespace) == 0:
-		return c.client.Fake.
-			InvokesWatch(testing.NewRootWatchAction(c.resource, opts))
-
-	case len(c.namespace) > 0:
-		return c.client.Fake.
-			InvokesWatch(testing.NewWatchAction(c.resource, c.namespace, opts))
-
-	}
-
-	panic("math broke")
-}
-
-// TODO: opts are currently ignored.
-func (c *dynamicResourceClient) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, 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"})
-
-	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"})
-
-	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"})
-
-	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"})
-
-	}
-
-	if err != nil {
-		return nil, err
-	}
-	if uncastRet == nil {
-		return nil, err
-	}
-
-	ret := &unstructured.Unstructured{}
-	if err := c.client.scheme.Convert(uncastRet, ret, nil); err != nil {
-		return nil, err
-	}
-	return ret, err
-}

dynamic/fake/simple_test.go

@@ -1,305 +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 fake
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"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/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{}{
-			"apiVersion": apiVersion,
-			"kind":       kind,
-			"metadata": map[string]interface{}{
-				"namespace": namespace,
-				"name":      name,
-			},
-		},
-	}
-}
-
-func newUnstructuredWithSpec(spec map[string]interface{}) *unstructured.Unstructured {
-	u := newUnstructured(testAPIVersion, testKind, testNamespace, testName)
-	u.Object["spec"] = spec
-	return u
-}
-
-func TestGet(t *testing.T) {
-	scheme := runtime.NewScheme()
-
-	client := NewSimpleDynamicClient(scheme, newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"))
-	get, err := client.Resource(schema.GroupVersionResource{Group: "group", Version: "version", Resource: "thekinds"}).Namespace("ns-foo").Get(context.TODO(), "name-foo", metav1.GetOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expected := &unstructured.Unstructured{
-		Object: map[string]interface{}{
-			"apiVersion": "group/version",
-			"kind":       "TheKind",
-			"metadata": map[string]interface{}{
-				"name":      "name-foo",
-				"namespace": "ns-foo",
-			},
-		},
-	}
-	if !equality.Semantic.DeepEqual(get, expected) {
-		t.Fatal(diff.ObjectGoPrintDiff(expected, get))
-	}
-}
-
-func TestListDecoding(t *testing.T) {
-	// this the duplication of logic from the real List API.  This will prove that our dynamic client actually returns the gvk
-	uncastObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, []byte(`{"apiVersion": "group/version", "kind": "TheKindList", "items":[]}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	list := uncastObj.(*unstructured.UnstructuredList)
-	expectedList := &unstructured.UnstructuredList{
-		Object: map[string]interface{}{
-			"apiVersion": "group/version",
-			"kind":       "TheKindList",
-		},
-		Items: []unstructured.Unstructured{},
-	}
-	if !equality.Semantic.DeepEqual(list, expectedList) {
-		t.Fatal(diff.ObjectGoPrintDiff(expectedList, list))
-	}
-}
-
-func TestGetDecoding(t *testing.T) {
-	// this the duplication of logic from the real Get API.  This will prove that our dynamic client actually returns the gvk
-	uncastObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, []byte(`{"apiVersion": "group/version", "kind": "TheKind"}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	get := uncastObj.(*unstructured.Unstructured)
-	expectedObj := &unstructured.Unstructured{
-		Object: map[string]interface{}{
-			"apiVersion": "group/version",
-			"kind":       "TheKind",
-		},
-	}
-	if !equality.Semantic.DeepEqual(get, expectedObj) {
-		t.Fatal(diff.ObjectGoPrintDiff(expectedObj, get))
-	}
-}
-
-func TestList(t *testing.T) {
-	scheme := runtime.NewScheme()
-
-	client := NewSimpleDynamicClientWithCustomListKinds(scheme,
-		map[schema.GroupVersionResource]string{
-			{Group: "group", Version: "version", Resource: "thekinds"}: "TheKindList",
-		},
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-		newUnstructured("group2/version", "TheKind", "ns-foo", "name2-foo"),
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-bar"),
-		newUnstructured("group/version", "TheKind", "ns-foo", "name-baz"),
-		newUnstructured("group2/version", "TheKind", "ns-foo", "name2-baz"),
-	)
-	listFirst, err := client.Resource(schema.GroupVersionResource{Group: "group", Version: "version", Resource: "thekinds"}).List(context.TODO(), metav1.ListOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expected := []unstructured.Unstructured{
-		*newUnstructured("group/version", "TheKind", "ns-foo", "name-bar"),
-		*newUnstructured("group/version", "TheKind", "ns-foo", "name-baz"),
-		*newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-	}
-	if !equality.Semantic.DeepEqual(listFirst.Items, expected) {
-		t.Fatal(diff.ObjectGoPrintDiff(expected, listFirst.Items))
-	}
-}
-
-func Test_ListKind(t *testing.T) {
-	scheme := runtime.NewScheme()
-
-	client := NewSimpleDynamicClientWithCustomListKinds(scheme,
-		map[schema.GroupVersionResource]string{
-			{Group: "group", Version: "version", Resource: "thekinds"}: "TheKindList",
-		},
-		&unstructured.UnstructuredList{
-			Object: map[string]interface{}{
-				"apiVersion": "group/version",
-				"kind":       "TheKindList",
-			},
-			Items: []unstructured.Unstructured{
-				*newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-				*newUnstructured("group/version", "TheKind", "ns-foo", "name-bar"),
-				*newUnstructured("group/version", "TheKind", "ns-foo", "name-baz"),
-			},
-		},
-	)
-	listFirst, err := client.Resource(schema.GroupVersionResource{Group: "group", Version: "version", Resource: "thekinds"}).List(context.TODO(), metav1.ListOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expectedList := &unstructured.UnstructuredList{
-		Object: map[string]interface{}{
-			"apiVersion": "group/version",
-			"kind":       "TheKindList",
-			"metadata": map[string]interface{}{
-				"resourceVersion": "",
-			},
-		},
-		Items: []unstructured.Unstructured{
-			*newUnstructured("group/version", "TheKind", "ns-foo", "name-bar"),
-			*newUnstructured("group/version", "TheKind", "ns-foo", "name-baz"),
-			*newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
-		},
-	}
-	if !equality.Semantic.DeepEqual(listFirst, expectedList) {
-		t.Fatal(diff.ObjectGoPrintDiff(expectedList, listFirst))
-	}
-}
-
-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(context.TODO(), testName, tc.patchType, tc.patchBytes, metav1.PatchOptions{})
-
-	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 works with simple replacement",
-			object:                newUnstructuredWithSpec(map[string]interface{}{"foo": "bar"}),
-			patchType:             types.MergePatchType,
-			patchBytes:            []byte(`{ "spec": { "foo": "baz" } }`),
-			expectedPatchedObject: newUnstructuredWithSpec(map[string]interface{}{"foo": "baz"}),
-		},
-		// 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)
-	}
-}

dynamic/interface.go

@@ -1,61 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package dynamic
-
-import (
-	"context"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/watch"
-)
-
-type Interface interface {
-	Resource(resource schema.GroupVersionResource) NamespaceableResourceInterface
-}
-
-type ResourceInterface interface {
-	Create(ctx context.Context, obj *unstructured.Unstructured, options metav1.CreateOptions, subresources ...string) (*unstructured.Unstructured, error)
-	Update(ctx context.Context, obj *unstructured.Unstructured, options metav1.UpdateOptions, subresources ...string) (*unstructured.Unstructured, error)
-	UpdateStatus(ctx context.Context, obj *unstructured.Unstructured, options metav1.UpdateOptions) (*unstructured.Unstructured, error)
-	Delete(ctx context.Context, name string, options metav1.DeleteOptions, subresources ...string) error
-	DeleteCollection(ctx context.Context, options metav1.DeleteOptions, listOptions metav1.ListOptions) error
-	Get(ctx context.Context, name string, options metav1.GetOptions, subresources ...string) (*unstructured.Unstructured, error)
-	List(ctx context.Context, opts metav1.ListOptions) (*unstructured.UnstructuredList, error)
-	Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error)
-	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, options metav1.PatchOptions, subresources ...string) (*unstructured.Unstructured, error)
-}
-
-type NamespaceableResourceInterface interface {
-	Namespace(string) ResourceInterface
-	ResourceInterface
-}
-
-// APIPathResolverFunc knows how to convert a groupVersion to its API path. The Kind field is optional.
-// TODO find a better place to move this for existing callers
-type APIPathResolverFunc func(kind schema.GroupVersionKind) string
-
-// LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
-// TODO find a better place to move this for existing callers
-func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
-	if len(kind.Group) == 0 {
-		return "/api"
-	}
-	return "/apis"
-}

dynamic/scheme.go

@@ -1,108 +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 dynamic
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/apimachinery/pkg/runtime/serializer/json"
-)
-
-var watchScheme = runtime.NewScheme()
-var basicScheme = runtime.NewScheme()
-var deleteScheme = runtime.NewScheme()
-var parameterScheme = runtime.NewScheme()
-var deleteOptionsCodec = serializer.NewCodecFactory(deleteScheme)
-var dynamicParameterCodec = runtime.NewParameterCodec(parameterScheme)
-
-var versionV1 = schema.GroupVersion{Version: "v1"}
-
-func init() {
-	metav1.AddToGroupVersion(watchScheme, versionV1)
-	metav1.AddToGroupVersion(basicScheme, versionV1)
-	metav1.AddToGroupVersion(parameterScheme, versionV1)
-	metav1.AddToGroupVersion(deleteScheme, versionV1)
-}
-
-// basicNegotiatedSerializer is used to handle discovery and error handling serialization
-type basicNegotiatedSerializer struct{}
-
-func (s basicNegotiatedSerializer) SupportedMediaTypes() []runtime.SerializerInfo {
-	return []runtime.SerializerInfo{
-		{
-			MediaType:        "application/json",
-			MediaTypeType:    "application",
-			MediaTypeSubType: "json",
-			EncodesAsText:    true,
-			Serializer:       json.NewSerializer(json.DefaultMetaFactory, unstructuredCreater{basicScheme}, unstructuredTyper{basicScheme}, false),
-			PrettySerializer: json.NewSerializer(json.DefaultMetaFactory, unstructuredCreater{basicScheme}, unstructuredTyper{basicScheme}, true),
-			StreamSerializer: &runtime.StreamSerializerInfo{
-				EncodesAsText: true,
-				Serializer:    json.NewSerializer(json.DefaultMetaFactory, basicScheme, basicScheme, false),
-				Framer:        json.Framer,
-			},
-		},
-	}
-}
-
-func (s basicNegotiatedSerializer) EncoderForVersion(encoder runtime.Encoder, gv runtime.GroupVersioner) runtime.Encoder {
-	return runtime.WithVersionEncoder{
-		Version:     gv,
-		Encoder:     encoder,
-		ObjectTyper: unstructuredTyper{basicScheme},
-	}
-}
-
-func (s basicNegotiatedSerializer) DecoderToVersion(decoder runtime.Decoder, gv runtime.GroupVersioner) runtime.Decoder {
-	return decoder
-}
-
-type unstructuredCreater struct {
-	nested runtime.ObjectCreater
-}
-
-func (c unstructuredCreater) New(kind schema.GroupVersionKind) (runtime.Object, error) {
-	out, err := c.nested.New(kind)
-	if err == nil {
-		return out, nil
-	}
-	out = &unstructured.Unstructured{}
-	out.GetObjectKind().SetGroupVersionKind(kind)
-	return out, nil
-}
-
-type unstructuredTyper struct {
-	nested runtime.ObjectTyper
-}
-
-func (t unstructuredTyper) ObjectKinds(obj runtime.Object) ([]schema.GroupVersionKind, bool, error) {
-	kinds, unversioned, err := t.nested.ObjectKinds(obj)
-	if err == nil {
-		return kinds, unversioned, nil
-	}
-	if _, ok := obj.(runtime.Unstructured); ok && !obj.GetObjectKind().GroupVersionKind().Empty() {
-		return []schema.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
-	}
-	return nil, false, err
-}
-
-func (t unstructuredTyper) Recognizes(gvk schema.GroupVersionKind) bool {
-	return true
-}

dynamic/simple.go

@@ -1,327 +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 dynamic
-
-import (
-	"context"
-	"fmt"
-
-	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/rest"
-)
-
-type dynamicClient struct {
-	client *rest.RESTClient
-}
-
-var _ Interface = &dynamicClient{}
-
-// ConfigFor returns a copy of the provided config with the
-// appropriate dynamic client defaults set.
-func ConfigFor(inConfig *rest.Config) *rest.Config {
-	config := rest.CopyConfig(inConfig)
-	config.AcceptContentTypes = "application/json"
-	config.ContentType = "application/json"
-	config.NegotiatedSerializer = basicNegotiatedSerializer{} // this gets used for discovery and error handling types
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	return config
-}
-
-// NewForConfigOrDie creates a new Interface for the given config and
-// panics if there is an error in the config.
-func NewForConfigOrDie(c *rest.Config) Interface {
-	ret, err := NewForConfig(c)
-	if err != nil {
-		panic(err)
-	}
-	return ret
-}
-
-// NewForConfig creates a new dynamic client or returns an error.
-func NewForConfig(inConfig *rest.Config) (Interface, error) {
-	config := ConfigFor(inConfig)
-	// for serializing the options
-	config.GroupVersion = &schema.GroupVersion{}
-	config.APIPath = "/if-you-see-this-search-for-the-break"
-
-	restClient, err := rest.RESTClientFor(config)
-	if err != nil {
-		return nil, err
-	}
-
-	return &dynamicClient{client: restClient}, nil
-}
-
-type dynamicResourceClient struct {
-	client    *dynamicClient
-	namespace string
-	resource  schema.GroupVersionResource
-}
-
-func (c *dynamicClient) Resource(resource schema.GroupVersionResource) NamespaceableResourceInterface {
-	return &dynamicResourceClient{client: c, resource: resource}
-}
-
-func (c *dynamicResourceClient) Namespace(ns string) ResourceInterface {
-	ret := *c
-	ret.namespace = ns
-	return &ret
-}
-
-func (c *dynamicResourceClient) Create(ctx context.Context, obj *unstructured.Unstructured, opts metav1.CreateOptions, subresources ...string) (*unstructured.Unstructured, error) {
-	outBytes, err := runtime.Encode(unstructured.UnstructuredJSONScheme, obj)
-	if err != nil {
-		return nil, err
-	}
-	name := ""
-	if len(subresources) > 0 {
-		accessor, err := meta.Accessor(obj)
-		if err != nil {
-			return nil, err
-		}
-		name = accessor.GetName()
-		if len(name) == 0 {
-			return nil, fmt.Errorf("name is required")
-		}
-	}
-
-	result := c.client.client.
-		Post().
-		AbsPath(append(c.makeURLSegments(name), subresources...)...).
-		Body(outBytes).
-		SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
-		Do(ctx)
-	if err := result.Error(); err != nil {
-		return nil, err
-	}
-
-	retBytes, err := result.Raw()
-	if err != nil {
-		return nil, err
-	}
-	uncastObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, retBytes)
-	if err != nil {
-		return nil, err
-	}
-	return uncastObj.(*unstructured.Unstructured), nil
-}
-
-func (c *dynamicResourceClient) Update(ctx context.Context, obj *unstructured.Unstructured, opts metav1.UpdateOptions, subresources ...string) (*unstructured.Unstructured, error) {
-	accessor, err := meta.Accessor(obj)
-	if err != nil {
-		return nil, err
-	}
-	name := accessor.GetName()
-	if len(name) == 0 {
-		return nil, fmt.Errorf("name is required")
-	}
-	outBytes, err := runtime.Encode(unstructured.UnstructuredJSONScheme, obj)
-	if err != nil {
-		return nil, err
-	}
-
-	result := c.client.client.
-		Put().
-		AbsPath(append(c.makeURLSegments(name), subresources...)...).
-		Body(outBytes).
-		SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
-		Do(ctx)
-	if err := result.Error(); err != nil {
-		return nil, err
-	}
-
-	retBytes, err := result.Raw()
-	if err != nil {
-		return nil, err
-	}
-	uncastObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, retBytes)
-	if err != nil {
-		return nil, err
-	}
-	return uncastObj.(*unstructured.Unstructured), nil
-}
-
-func (c *dynamicResourceClient) UpdateStatus(ctx context.Context, obj *unstructured.Unstructured, opts metav1.UpdateOptions) (*unstructured.Unstructured, error) {
-	accessor, err := meta.Accessor(obj)
-	if err != nil {
-		return nil, err
-	}
-	name := accessor.GetName()
-	if len(name) == 0 {
-		return nil, fmt.Errorf("name is required")
-	}
-
-	outBytes, err := runtime.Encode(unstructured.UnstructuredJSONScheme, obj)
-	if err != nil {
-		return nil, err
-	}
-
-	result := c.client.client.
-		Put().
-		AbsPath(append(c.makeURLSegments(name), "status")...).
-		Body(outBytes).
-		SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
-		Do(ctx)
-	if err := result.Error(); err != nil {
-		return nil, err
-	}
-
-	retBytes, err := result.Raw()
-	if err != nil {
-		return nil, err
-	}
-	uncastObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, retBytes)
-	if err != nil {
-		return nil, err
-	}
-	return uncastObj.(*unstructured.Unstructured), nil
-}
-
-func (c *dynamicResourceClient) Delete(ctx context.Context, name string, opts metav1.DeleteOptions, subresources ...string) error {
-	if len(name) == 0 {
-		return fmt.Errorf("name is required")
-	}
-	deleteOptionsByte, err := runtime.Encode(deleteOptionsCodec.LegacyCodec(schema.GroupVersion{Version: "v1"}), &opts)
-	if err != nil {
-		return err
-	}
-
-	result := c.client.client.
-		Delete().
-		AbsPath(append(c.makeURLSegments(name), subresources...)...).
-		Body(deleteOptionsByte).
-		Do(ctx)
-	return result.Error()
-}
-
-func (c *dynamicResourceClient) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOptions metav1.ListOptions) error {
-	deleteOptionsByte, err := runtime.Encode(deleteOptionsCodec.LegacyCodec(schema.GroupVersion{Version: "v1"}), &opts)
-	if err != nil {
-		return err
-	}
-
-	result := c.client.client.
-		Delete().
-		AbsPath(c.makeURLSegments("")...).
-		Body(deleteOptionsByte).
-		SpecificallyVersionedParams(&listOptions, dynamicParameterCodec, versionV1).
-		Do(ctx)
-	return result.Error()
-}
-
-func (c *dynamicResourceClient) Get(ctx context.Context, name string, opts metav1.GetOptions, subresources ...string) (*unstructured.Unstructured, error) {
-	if len(name) == 0 {
-		return nil, fmt.Errorf("name is required")
-	}
-	result := c.client.client.Get().AbsPath(append(c.makeURLSegments(name), subresources...)...).SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).Do(ctx)
-	if err := result.Error(); err != nil {
-		return nil, err
-	}
-	retBytes, err := result.Raw()
-	if err != nil {
-		return nil, err
-	}
-	uncastObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, retBytes)
-	if err != nil {
-		return nil, err
-	}
-	return uncastObj.(*unstructured.Unstructured), nil
-}
-
-func (c *dynamicResourceClient) List(ctx context.Context, opts metav1.ListOptions) (*unstructured.UnstructuredList, error) {
-	result := c.client.client.Get().AbsPath(c.makeURLSegments("")...).SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).Do(ctx)
-	if err := result.Error(); err != nil {
-		return nil, err
-	}
-	retBytes, err := result.Raw()
-	if err != nil {
-		return nil, err
-	}
-	uncastObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, retBytes)
-	if err != nil {
-		return nil, err
-	}
-	if list, ok := uncastObj.(*unstructured.UnstructuredList); ok {
-		return list, nil
-	}
-
-	list, err := uncastObj.(*unstructured.Unstructured).ToList()
-	if err != nil {
-		return nil, err
-	}
-	return list, nil
-}
-
-func (c *dynamicResourceClient) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) {
-	opts.Watch = true
-	return c.client.client.Get().AbsPath(c.makeURLSegments("")...).
-		SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
-		Watch(ctx)
-}
-
-func (c *dynamicResourceClient) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*unstructured.Unstructured, error) {
-	if len(name) == 0 {
-		return nil, fmt.Errorf("name is required")
-	}
-	result := c.client.client.
-		Patch(pt).
-		AbsPath(append(c.makeURLSegments(name), subresources...)...).
-		Body(data).
-		SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).
-		Do(ctx)
-	if err := result.Error(); err != nil {
-		return nil, err
-	}
-	retBytes, err := result.Raw()
-	if err != nil {
-		return nil, err
-	}
-	uncastObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, retBytes)
-	if err != nil {
-		return nil, err
-	}
-	return uncastObj.(*unstructured.Unstructured), nil
-}
-
-func (c *dynamicResourceClient) makeURLSegments(name string) []string {
-	url := []string{}
-	if len(c.resource.Group) == 0 {
-		url = append(url, "api")
-	} else {
-		url = append(url, "apis", c.resource.Group)
-	}
-	url = append(url, c.resource.Version)
-
-	if len(c.namespace) > 0 {
-		url = append(url, "namespaces", c.namespace)
-	}
-	url = append(url, c.resource.Resource)
-
-	if len(name) > 0 {
-		url = append(url, name)
-	}
-
-	return url
-}

examples/README.md

@@ -3,25 +3,6 @@
 This directory contains examples that cover various use cases and functionality
 for client-go.
 
-### Auth plugins
-
-Client configuration is typically loaded from kubeconfig files containing server and credential configuration.
-Several plugins for obtaining credentials from external sources are available, but are not loaded by default.
-To enable these plugins in your program, import them in your main package.
-
-You can load all auth plugins:
-```go
-import _ "k8s.io/client-go/plugin/pkg/client/auth"
-```
-
-Or you can load specific auth plugins:
-```go
-import _ "k8s.io/client-go/plugin/pkg/client/auth/azure"
-import _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
-import _ "k8s.io/client-go/plugin/pkg/client/auth/oidc"
-import _ "k8s.io/client-go/plugin/pkg/client/auth/openstack"
-```
-
 ### Configuration
 
 - [**Authenticate in cluster**](./in-cluster-client-configuration): Configure a
@@ -42,10 +23,5 @@ import _ "k8s.io/client-go/plugin/pkg/client/auth/openstack"
   Register a custom resource type with the API, create/update/query this custom
   type, and write a controller that drives the cluster state based on the changes to
   the custom resources.
-- [**Leader election**](./leader-election): Demonstrates the use of the leader election package, which can be used to implement HA controllers.
 
 [informer]: https://godoc.org/k8s.io/client-go/tools/cache#NewInformer
-
-### Testing
-
-- [**Fake Client**](./fake-client): Use a fake client in tests.

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

@@ -36,14 +36,20 @@ Running this command will execute the following operations on your cluster:
    image to `nginx:1.13`. You are encouraged to inspect the retry loop that
    handles conflicts. Verify the new replica count and container image with
    `kubectl describe deployment demo`.
-3. **List Deployments:** This will retrieve Deployments in the `default`
+3. **Rollback Deployment:** This will rollback the Deployment to the last
+   revision. In this case, it's the revision that was created in Step 1.
+   Use `kubectl describe` to verify the container image is now `nginx:1.12`.
+   Also note that the Deployment's replica count is still 1; this is because a
+   Deployment revision is created if and only if the Deployment's pod template
+   (`.spec.template`) is changed.
+4. **List Deployments:** This will retrieve Deployments in the `default`
    namespace and print their names and replica counts.
-4. **Delete Deployment:** This will delete the Deployment object and its
+5. **Delete Deployment:** This will delete the Deployment object and its
    dependent ReplicaSet resource. Verify with `kubectl get deployments`.
 
 Each step is separated by an interactive prompt. You must hit the
 <kbd>Return</kbd> key to proceed to the next step. You can use these prompts as
-a break to take time to run `kubectl` and inspect the result of the operations
+a break to take time to  run `kubectl` and inspect the result of the operations
 executed.
 
 You should see an output like the following:
@@ -57,6 +63,10 @@ Updating deployment...
 Updated deployment...
 -> Press Return key to continue.
 
+Rolling back deployment...
+Rolled back deployment...
+-> Press Return key to continue.
+
 Listing deployments in namespace "default":
  * demo-deployment (1 replicas)
 -> Press Return key to continue.

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

@@ -19,28 +19,20 @@ package main
 
 import (
 	"bufio"
-	"context"
 	"flag"
 	"fmt"
 	"os"
 	"path/filepath"
 
-	appsv1 "k8s.io/api/apps/v1"
+	appsv1beta1 "k8s.io/api/apps/v1beta1"
 	apiv1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/tools/clientcmd"
 	"k8s.io/client-go/util/homedir"
 	"k8s.io/client-go/util/retry"
-	//
-	// Uncomment to load all auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth"
-	//
-	// Or uncomment to load specific auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/azure"
+	// Uncomment the following line to load the gcp plugin (only required to authenticate against GKE clusters).
 	// _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/oidc"
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/openstack"
 )
 
 func main() {
@@ -61,19 +53,14 @@ func main() {
 		panic(err)
 	}
 
-	deploymentsClient := clientset.AppsV1().Deployments(apiv1.NamespaceDefault)
+	deploymentsClient := clientset.AppsV1beta1().Deployments(apiv1.NamespaceDefault)
 
-	deployment := &appsv1.Deployment{
+	deployment := &appsv1beta1.Deployment{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: "demo-deployment",
 		},
-		Spec: appsv1.DeploymentSpec{
+		Spec: appsv1beta1.DeploymentSpec{
 			Replicas: int32Ptr(2),
-			Selector: &metav1.LabelSelector{
-				MatchLabels: map[string]string{
-					"app": "demo",
-				},
-			},
 			Template: apiv1.PodTemplateSpec{
 				ObjectMeta: metav1.ObjectMeta{
 					Labels: map[string]string{
@@ -101,7 +88,7 @@ func main() {
 
 	// Create Deployment
 	fmt.Println("Creating deployment...")
-	result, err := deploymentsClient.Create(context.TODO(), deployment, metav1.CreateOptions{})
+	result, err := deploymentsClient.Create(deployment)
 	if err != nil {
 		panic(err)
 	}
@@ -121,19 +108,19 @@ func main() {
 	//			 using the retry utility package included with client-go. (RECOMMENDED)
 	//
 	// More Info:
-	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
+	// https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#concurrency-control-and-consistency
 
 	retryErr := retry.RetryOnConflict(retry.DefaultRetry, func() error {
 		// Retrieve the latest version of Deployment before attempting update
 		// RetryOnConflict uses exponential backoff to avoid exhausting the apiserver
-		result, getErr := deploymentsClient.Get(context.TODO(), "demo-deployment", metav1.GetOptions{})
+		result, getErr := deploymentsClient.Get("demo-deployment", metav1.GetOptions{})
 		if getErr != nil {
 			panic(fmt.Errorf("Failed to get latest version of Deployment: %v", getErr))
 		}
 
 		result.Spec.Replicas = int32Ptr(1)                           // reduce replica count
 		result.Spec.Template.Spec.Containers[0].Image = "nginx:1.13" // change nginx version
-		_, updateErr := deploymentsClient.Update(context.TODO(), result, metav1.UpdateOptions{})
+		_, updateErr := deploymentsClient.Update(result)
 		return updateErr
 	})
 	if retryErr != nil {
@@ -141,10 +128,31 @@ func main() {
 	}
 	fmt.Println("Updated deployment...")
 
+	// Rollback Deployment
+	prompt()
+	fmt.Println("Rolling back deployment...")
+	// Once again use RetryOnConflict to avoid update conflicts
+	retryErr = retry.RetryOnConflict(retry.DefaultRetry, func() error {
+		result, getErr := deploymentsClient.Get("demo-deployment", metav1.GetOptions{})
+		if getErr != nil {
+			panic(fmt.Errorf("Failed to get latest version of Deployment: %v", getErr))
+		}
+
+		result.Spec.RollbackTo = &appsv1beta1.RollbackConfig{
+			Revision: 0, // can be specific revision number, or 0 for last revision
+		}
+		_, updateErr := deploymentsClient.Update(result)
+		return updateErr
+	})
+	if retryErr != nil {
+		panic(fmt.Errorf("Rollback failed: %v", retryErr))
+	}
+	fmt.Println("Rolled back deployment...")
+
 	// List Deployments
 	prompt()
 	fmt.Printf("Listing deployments in namespace %q:\n", apiv1.NamespaceDefault)
-	list, err := deploymentsClient.List(context.TODO(), metav1.ListOptions{})
+	list, err := deploymentsClient.List(metav1.ListOptions{})
 	if err != nil {
 		panic(err)
 	}
@@ -156,7 +164,7 @@ func main() {
 	prompt()
 	fmt.Println("Deleting deployment...")
 	deletePolicy := metav1.DeletePropagationForeground
-	if err := deploymentsClient.Delete(context.TODO(), "demo-deployment", metav1.DeleteOptions{
+	if err := deploymentsClient.Delete("demo-deployment", &metav1.DeleteOptions{
 		PropagationPolicy: &deletePolicy,
 	}); err != nil {
 		panic(err)

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

@@ -1,93 +0,0 @@
-# Create, Update & Delete Deployment with the Dynamic Package
-
-This example program demonstrates the fundamental operations for managing on
-[Deployment][1] resources, such as `Create`, `List`, `Update` and `Delete` using client-go's `dynamic` package.
-
-## Typed Vs. Dynamic
-The code in this directory is based on a similar [example that uses Kubernetes typed client sets][2]. The typed client sets make it simple to communicate with the API server using pre-generated local API objects to achieve an RPC-like programming experience.  Typed clients uses program compilations to enforce data safety and some validation.  However, when using typed clients, programs are forced to be tightly coupled with the version and the types used.
-
-
-The `dynamic` package on the other hand, uses a simple type, `unstructured.Unstructured`, to represent all object values from the API server. Type `Unstructured` uses a collection of nested `map[string]interface{}` values to create an internal structure that closely resemble the REST payload from the server.  
-
-The dynamic package defers all data bindings until runtime.  This means programs that use the dynamic client will not get any of the benefits of type validation until the program is running.  This may be a problem for certain types of applications that require strong data type check and validation.
-
-Being loosely coupled, however, means that programs that uses the `dynamic` package do not require recompilation when the client API changes.  The client program has more flexibility in handling updates to the API surface without knowing ahead of time what those changes are. 
-
-
-## Running this example
-
-Make sure you have a Kubernetes cluster and `kubectl` is configured:
-```
-kubectl get nodes
-```
-
-Compile this example on your workstation:
-
-```
-cd dynamic-create-update-delete-deployment
-go build -o ./app
-```
-
-Now, run this application on your workstation with your local kubeconfig file:
-
-```
-./app
-# or specify a kubeconfig file with flag
-./app -kubeconfig=$HOME/.kube/config
-```
-
-Running this command will execute the following operations on your cluster:
-
-1. **Create Deployment:** This will create a 2 replica Deployment. Verify with
-   `kubectl get pods`.
-2. **Update Deployment:** This will update the Deployment resource created in
-   previous step by setting the replica count to 1 and changing the container
-   image to `nginx:1.13`. You are encouraged to inspect the retry loop that
-   handles conflicts. Verify the new replica count and container image with
-   `kubectl describe deployment demo`.
-3. **List Deployments:** This will retrieve Deployments in the `default`
-   namespace and print their names and replica counts.
-4. **Delete Deployment:** This will delete the Deployment object and its
-   dependent ReplicaSet resource. Verify with `kubectl get deployments`.
-
-Each step is separated by an interactive prompt. You must hit the
-<kbd>Return</kbd> key to proceed to the next step. You can use these prompts as
-a break to take time to run `kubectl` and inspect the result of the operations
-executed.
-
-You should see an output like the following:
-
-```
-Creating deployment...
-Created deployment "demo-deployment".
--> Press Return key to continue.
-
-Updating deployment...
-Updated deployment...
--> Press Return key to continue.
-
-Listing deployments in namespace "default":
- * demo-deployment (1 replicas)
--> Press Return key to continue.
-
-Deleting deployment...
-Deleted deployment.
-```
-
-## Cleanup
-
-Successfully running this program will clean the created artifacts. If you
-terminate the program without completing, you can clean up the created
-deployment with:
-
-    kubectl delete deploy demo-deployment
-
-## Troubleshooting
-
-If you are getting the following error, make sure Kubernetes version of your
-cluster is v1.13 or higher in `kubectl version`:
-
-    panic: the server could not find the requested resource
-
-[1]: https://kubernetes.io/docs/user-guide/deployments/
-[2]: ../create-update-delete-deployment

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

@@ -1,209 +0,0 @@
-/*
-Copyright 2019 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Note: the example only works with the code within the same release/branch.
-package main
-
-import (
-	"bufio"
-	"context"
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	apiv1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/client-go/util/homedir"
-	"k8s.io/client-go/util/retry"
-	//
-	// Uncomment to load all auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth"
-	//
-	// Or uncomment to load specific auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/azure"
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/oidc"
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/openstack"
-)
-
-func main() {
-	var kubeconfig *string
-	if home := homedir.HomeDir(); home != "" {
-		kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
-	} else {
-		kubeconfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
-	}
-	flag.Parse()
-
-	namespace := "default"
-
-	config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
-	if err != nil {
-		panic(err)
-	}
-	client, err := dynamic.NewForConfig(config)
-	if err != nil {
-		panic(err)
-	}
-
-	deploymentRes := schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}
-
-	deployment := &unstructured.Unstructured{
-		Object: map[string]interface{}{
-			"apiVersion": "apps/v1",
-			"kind":       "Deployment",
-			"metadata": map[string]interface{}{
-				"name": "demo-deployment",
-			},
-			"spec": map[string]interface{}{
-				"replicas": 2,
-				"selector": map[string]interface{}{
-					"matchLabels": map[string]interface{}{
-						"app": "demo",
-					},
-				},
-				"template": map[string]interface{}{
-					"metadata": map[string]interface{}{
-						"labels": map[string]interface{}{
-							"app": "demo",
-						},
-					},
-
-					"spec": map[string]interface{}{
-						"containers": []map[string]interface{}{
-							{
-								"name":  "web",
-								"image": "nginx:1.12",
-								"ports": []map[string]interface{}{
-									{
-										"name":          "http",
-										"protocol":      "TCP",
-										"containerPort": 80,
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-
-	// Create Deployment
-	fmt.Println("Creating deployment...")
-	result, err := client.Resource(deploymentRes).Namespace(namespace).Create(context.TODO(), deployment, metav1.CreateOptions{})
-	if err != nil {
-		panic(err)
-	}
-	fmt.Printf("Created deployment %q.\n", result.GetName())
-
-	// Update Deployment
-	prompt()
-	fmt.Println("Updating deployment...")
-	//    You have two options to Update() this Deployment:
-	//
-	//    1. Modify the "deployment" variable and call: Update(deployment).
-	//       This works like the "kubectl replace" command and it overwrites/loses changes
-	//       made by other clients between you Create() and Update() the object.
-	//    2. Modify the "result" returned by Get() and retry Update(result) until
-	//       you no longer get a conflict error. This way, you can preserve changes made
-	//       by other clients between Create() and Update(). This is implemented below
-	//			 using the retry utility package included with client-go. (RECOMMENDED)
-	//
-	// More Info:
-	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
-
-	retryErr := retry.RetryOnConflict(retry.DefaultRetry, func() error {
-		// Retrieve the latest version of Deployment before attempting update
-		// RetryOnConflict uses exponential backoff to avoid exhausting the apiserver
-		result, getErr := client.Resource(deploymentRes).Namespace(namespace).Get(context.TODO(), "demo-deployment", metav1.GetOptions{})
-		if getErr != nil {
-			panic(fmt.Errorf("failed to get latest version of Deployment: %v", getErr))
-		}
-
-		// update replicas to 1
-		if err := unstructured.SetNestedField(result.Object, int64(1), "spec", "replicas"); err != nil {
-			panic(fmt.Errorf("failed to set replica value: %v", err))
-		}
-
-		// extract spec containers
-		containers, found, err := unstructured.NestedSlice(result.Object, "spec", "template", "spec", "containers")
-		if err != nil || !found || containers == nil {
-			panic(fmt.Errorf("deployment containers not found or error in spec: %v", err))
-		}
-
-		// update container[0] image
-		if err := unstructured.SetNestedField(containers[0].(map[string]interface{}), "nginx:1.13", "image"); err != nil {
-			panic(err)
-		}
-		if err := unstructured.SetNestedField(result.Object, containers, "spec", "template", "spec", "containers"); err != nil {
-			panic(err)
-		}
-
-		_, updateErr := client.Resource(deploymentRes).Namespace(namespace).Update(context.TODO(), result, metav1.UpdateOptions{})
-		return updateErr
-	})
-	if retryErr != nil {
-		panic(fmt.Errorf("update failed: %v", retryErr))
-	}
-	fmt.Println("Updated deployment...")
-
-	// List Deployments
-	prompt()
-	fmt.Printf("Listing deployments in namespace %q:\n", apiv1.NamespaceDefault)
-	list, err := client.Resource(deploymentRes).Namespace(namespace).List(context.TODO(), metav1.ListOptions{})
-	if err != nil {
-		panic(err)
-	}
-	for _, d := range list.Items {
-		replicas, found, err := unstructured.NestedInt64(d.Object, "spec", "replicas")
-		if err != nil || !found {
-			fmt.Printf("Replicas not found for deployment %s: error=%s", d.GetName(), err)
-			continue
-		}
-		fmt.Printf(" * %s (%d replicas)\n", d.GetName(), replicas)
-	}
-
-	// Delete Deployment
-	prompt()
-	fmt.Println("Deleting deployment...")
-	deletePolicy := metav1.DeletePropagationForeground
-	deleteOptions := metav1.DeleteOptions{
-		PropagationPolicy: &deletePolicy,
-	}
-	if err := client.Resource(deploymentRes).Namespace(namespace).Delete(context.TODO(), "demo-deployment", deleteOptions); err != nil {
-		panic(err)
-	}
-
-	fmt.Println("Deleted deployment.")
-}
-
-func prompt() {
-	fmt.Printf("-> Press Return key to continue.")
-	scanner := bufio.NewScanner(os.Stdin)
-	for scanner.Scan() {
-		break
-	}
-	if err := scanner.Err(); err != nil {
-		panic(err)
-	}
-	fmt.Println()
-}

examples/fake-client/README.md

@@ -1,14 +0,0 @@
-# Fake Client Example
-
-This example demonstrates how to use a fake client with SharedInformerFactory in tests.
-
-It covers:
- * Creating the fake client
- * Setting up real informers
- * Injecting events into those informers
-
-## Running
-
-```
-go test -v k8s.io/client-go/examples/fake-client
-```

examples/fake-client/main_test.go

@@ -1,73 +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 fakeclient
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/client-go/informers"
-	"k8s.io/client-go/kubernetes/fake"
-	"k8s.io/client-go/tools/cache"
-)
-
-// TestFakeClient demonstrates how to use a fake client with SharedInformerFactory in tests.
-func TestFakeClient(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// Create the fake client.
-	client := fake.NewSimpleClientset()
-
-	// We will create an informer that writes added pods to a channel.
-	pods := make(chan *v1.Pod, 1)
-	informers := informers.NewSharedInformerFactory(client, 0)
-	podInformer := informers.Core().V1().Pods().Informer()
-	podInformer.AddEventHandler(&cache.ResourceEventHandlerFuncs{
-		AddFunc: func(obj interface{}) {
-			pod := obj.(*v1.Pod)
-			t.Logf("pod added: %s/%s", pod.Namespace, pod.Name)
-			pods <- pod
-		},
-	})
-
-	// Make sure informers are running.
-	informers.Start(ctx.Done())
-
-	// This is not required in tests, but it serves as a proof-of-concept by
-	// ensuring that the informer goroutine have warmed up and called List before
-	// we send any events to it.
-	cache.WaitForCacheSync(ctx.Done(), podInformer.HasSynced)
-
-	// Inject an event into the fake client.
-	p := &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "my-pod"}}
-	_, err := client.CoreV1().Pods("test-ns").Create(context.TODO(), p, metav1.CreateOptions{})
-	if err != nil {
-		t.Fatalf("error injecting pod add: %v", err)
-	}
-
-	select {
-	case pod := <-pods:
-		t.Logf("Got pod from channel: %s/%s", pod.Namespace, pod.Name)
-	case <-time.After(wait.ForeverTestTimeout):
-		t.Error("Informer did not get the added pod")
-	}
-}

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

@@ -27,17 +27,9 @@ build the image on Minikube:
 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 on your cluster, 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
-```
-
 Then, run the image in a Pod with a single instance Deployment:
 
-    kubectl run --rm -i demo --image=in-cluster
+    $ kubectl run --rm -i demo --image=in-cluster --image-pull-policy=Never
 
     There are 4 pods in the cluster
     There are 4 pods in the cluster

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

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

examples/leader-election/README.md

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

examples/leader-election/main.go

@@ -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 main
-
-import (
-	"context"
-	"flag"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
-
-	"github.com/google/uuid"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	clientset "k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/client-go/tools/leaderelection"
-	"k8s.io/client-go/tools/leaderelection/resourcelock"
-	"k8s.io/klog/v2"
-)
-
-func buildConfig(kubeconfig string) (*rest.Config, error) {
-	if kubeconfig != "" {
-		cfg, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
-		if err != nil {
-			return nil, err
-		}
-		return cfg, nil
-	}
-
-	cfg, err := rest.InClusterConfig()
-	if err != nil {
-		return nil, err
-	}
-	return cfg, nil
-}
-
-func main() {
-	klog.InitFlags(nil)
-
-	var kubeconfig string
-	var leaseLockName string
-	var leaseLockNamespace string
-	var id string
-
-	flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
-	flag.StringVar(&id, "id", uuid.New().String(), "the holder identity name")
-	flag.StringVar(&leaseLockName, "lease-lock-name", "", "the lease lock resource name")
-	flag.StringVar(&leaseLockNamespace, "lease-lock-namespace", "", "the lease lock resource namespace")
-	flag.Parse()
-
-	if leaseLockName == "" {
-		klog.Fatal("unable to get lease lock resource name (missing lease-lock-name flag).")
-	}
-	if leaseLockNamespace == "" {
-		klog.Fatal("unable to get lease lock resource namespace (missing lease-lock-namespace flag).")
-	}
-
-	// leader election uses the Kubernetes API by writing to a
-	// lock object, which can be a LeaseLock object (preferred),
-	// a ConfigMap, or an Endpoints (deprecated) object.
-	// Conflicting writes are detected and each client handles those actions
-	// independently.
-	config, err := buildConfig(kubeconfig)
-	if err != nil {
-		klog.Fatal(err)
-	}
-	client := clientset.NewForConfigOrDie(config)
-
-	run := func(ctx context.Context) {
-		// complete your controller loop here
-		klog.Info("Controller loop...")
-
-		select {}
-	}
-
-	// use a Go context so we can tell the leaderelection code when we
-	// want to step down
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// listen for interrupts or the Linux SIGTERM signal and cancel
-	// our context, which the leader election code will observe and
-	// step down
-	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
-	go func() {
-		<-ch
-		klog.Info("Received termination, signaling shutdown")
-		cancel()
-	}()
-
-	// we use the Lease lock type since edits to Leases are less common
-	// and fewer objects in the cluster watch "all Leases".
-	lock := &resourcelock.LeaseLock{
-		LeaseMeta: metav1.ObjectMeta{
-			Name:      leaseLockName,
-			Namespace: leaseLockNamespace,
-		},
-		Client: client.CoordinationV1(),
-		LockConfig: resourcelock.ResourceLockConfig{
-			Identity: id,
-		},
-	}
-
-	// start the leader election code loop
-	leaderelection.RunOrDie(ctx, leaderelection.LeaderElectionConfig{
-		Lock: lock,
-		// IMPORTANT: you MUST ensure that any code you have that
-		// is protected by the lease must terminate **before**
-		// you call cancel. Otherwise, you could have a background
-		// loop still running and another process could
-		// get elected before your background loop finished, violating
-		// the stated goal of the lease.
-		ReleaseOnCancel: true,
-		LeaseDuration:   60 * time.Second,
-		RenewDeadline:   15 * time.Second,
-		RetryPeriod:     5 * time.Second,
-		Callbacks: leaderelection.LeaderCallbacks{
-			OnStartedLeading: func(ctx context.Context) {
-				// we're notified when we start - this is where you would
-				// usually put your code
-				run(ctx)
-			},
-			OnStoppedLeading: func() {
-				// we can do cleanup here
-				klog.Infof("leader lost: %s", id)
-				os.Exit(0)
-			},
-			OnNewLeader: func(identity string) {
-				// we're notified when new leader elected
-				if identity == id {
-					// I just got the lock
-					return
-				}
-				klog.Infof("new leader elected: %s", identity)
-			},
-		},
-	})
-}

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

@@ -20,9 +20,9 @@ Run this application with:
     ./app
 
 Running this application will use the kubeconfig file and then authenticate to the
-cluster, and print the number of pods in the cluster every 10 seconds:
+cluster, and print the number of nodes in the cluster every 10 seconds:
 
-    ./app
+    $ ./app
     There are 3 pods in the cluster
     There are 3 pods in the cluster
     There are 3 pods in the cluster

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

@@ -18,9 +18,9 @@ limitations under the License.
 package main
 
 import (
-	"context"
 	"flag"
 	"fmt"
+	"os"
 	"path/filepath"
 	"time"
 
@@ -28,21 +28,13 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/client-go/util/homedir"
-	//
-	// Uncomment to load all auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth"
-	//
-	// Or uncomment to load specific auth plugins
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/azure"
+	// Uncomment the following line to load the gcp plugin (only required to authenticate against GKE clusters).
 	// _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/oidc"
-	// _ "k8s.io/client-go/plugin/pkg/client/auth/openstack"
 )
 
 func main() {
 	var kubeconfig *string
-	if home := homedir.HomeDir(); home != "" {
+	if home := homeDir(); home != "" {
 		kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
 	} else {
 		kubeconfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
@@ -61,7 +53,7 @@ func main() {
 		panic(err.Error())
 	}
 	for {
-		pods, err := clientset.CoreV1().Pods("").List(context.TODO(), metav1.ListOptions{})
+		pods, err := clientset.CoreV1().Pods("").List(metav1.ListOptions{})
 		if err != nil {
 			panic(err.Error())
 		}
@@ -72,7 +64,7 @@ func main() {
 		// - And/or cast to StatusError and use its properties like e.g. ErrStatus.Message
 		namespace := "default"
 		pod := "example-xxxxx"
-		_, err = clientset.CoreV1().Pods(namespace).Get(context.TODO(), pod, metav1.GetOptions{})
+		_, err = clientset.CoreV1().Pods(namespace).Get(pod, metav1.GetOptions{})
 		if errors.IsNotFound(err) {
 			fmt.Printf("Pod %s in namespace %s not found\n", pod, namespace)
 		} else if statusError, isStatus := err.(*errors.StatusError); isStatus {
@@ -87,3 +79,10 @@ func main() {
 		time.Sleep(10 * time.Second)
 	}
 }
+
+func homeDir() string {
+	if h := os.Getenv("HOME"); h != "" {
+		return h
+	}
+	return os.Getenv("USERPROFILE") // windows
+}

examples/workqueue/README.md

@@ -7,7 +7,7 @@ It demonstrates how to:
  * combine the workqueue with a cache to a full controller
  * synchronize the controller on startup
 
-The example is based on https://git.k8s.io/community/contributors/devel/sig-api-machinery/controllers.md.
+The example is based on https://git.k8s.io/community/contributors/devel/controllers.md.
 
 ## Running
 

examples/workqueue/main.go

@@ -21,9 +21,9 @@ import (
 	"fmt"
 	"time"
 
-	"k8s.io/klog/v2"
+	"github.com/golang/glog"
 
-	v1 "k8s.io/api/core/v1"
+	"k8s.io/api/core/v1"
 	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/util/runtime"
@@ -34,14 +34,12 @@ import (
 	"k8s.io/client-go/util/workqueue"
 )
 
-// Controller demonstrates how to implement a controller with client-go.
 type Controller struct {
 	indexer  cache.Indexer
 	queue    workqueue.RateLimitingInterface
 	informer cache.Controller
 }
 
-// NewController creates a new Controller.
 func NewController(queue workqueue.RateLimitingInterface, indexer cache.Indexer, informer cache.Controller) *Controller {
 	return &Controller{
 		informer: informer,
@@ -74,7 +72,7 @@ func (c *Controller) processNextItem() bool {
 func (c *Controller) syncToStdout(key string) error {
 	obj, exists, err := c.indexer.GetByKey(key)
 	if err != nil {
-		klog.Errorf("Fetching object with key %s from store failed with %v", key, err)
+		glog.Errorf("Fetching object with key %s from store failed with %v", key, err)
 		return err
 	}
 
@@ -101,7 +99,7 @@ func (c *Controller) handleErr(err error, key interface{}) {
 
 	// This controller retries 5 times if something goes wrong. After that, it stops trying.
 	if c.queue.NumRequeues(key) < 5 {
-		klog.Infof("Error syncing pod %v: %v", key, err)
+		glog.Infof("Error syncing pod %v: %v", key, err)
 
 		// Re-enqueue the key rate limited. Based on the rate limiter on the
 		// queue and the re-enqueue history, the key will be processed later again.
@@ -112,16 +110,15 @@ func (c *Controller) handleErr(err error, key interface{}) {
 	c.queue.Forget(key)
 	// Report to an external entity that, even after several retries, we could not successfully process this key
 	runtime.HandleError(err)
-	klog.Infof("Dropping pod %q out of the queue: %v", key, err)
+	glog.Infof("Dropping pod %q out of the queue: %v", key, err)
 }
 
-// Run begins watching and syncing.
 func (c *Controller) Run(threadiness int, stopCh chan struct{}) {
 	defer runtime.HandleCrash()
 
 	// Let the workers stop when we are done
 	defer c.queue.ShutDown()
-	klog.Info("Starting Pod controller")
+	glog.Info("Starting Pod controller")
 
 	go c.informer.Run(stopCh)
 
@@ -136,7 +133,7 @@ func (c *Controller) Run(threadiness int, stopCh chan struct{}) {
 	}
 
 	<-stopCh
-	klog.Info("Stopping Pod controller")
+	glog.Info("Stopping Pod controller")
 }
 
 func (c *Controller) runWorker() {
@@ -155,13 +152,13 @@ func main() {
 	// creates the connection
 	config, err := clientcmd.BuildConfigFromFlags(master, kubeconfig)
 	if err != nil {
-		klog.Fatal(err)
+		glog.Fatal(err)
 	}
 
 	// creates the clientset
 	clientset, err := kubernetes.NewForConfig(config)
 	if err != nil {
-		klog.Fatal(err)
+		glog.Fatal(err)
 	}
 
 	// create the pod watcher

go.mod

@@ -1,39 +0,0 @@
-// This is a generated file. Do not edit directly.
-
-module k8s.io/client-go
-
-go 1.15
-
-require (
-	cloud.google.com/go v0.54.0 // indirect
-	github.com/Azure/go-autorest/autorest v0.11.1
-	github.com/Azure/go-autorest/autorest/adal v0.9.5
-	github.com/davecgh/go-spew v1.1.1
-	github.com/evanphx/json-patch v4.9.0+incompatible
-	github.com/gogo/protobuf v1.3.1
-	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e
-	github.com/golang/protobuf v1.4.3
-	github.com/google/go-cmp v0.5.2
-	github.com/google/gofuzz v1.1.0
-	github.com/google/uuid v1.1.2
-	github.com/googleapis/gnostic v0.4.1
-	github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7
-	github.com/imdario/mergo v0.3.5
-	github.com/peterbourgon/diskv v2.0.1+incompatible
-	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.6.1
-	golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0
-	golang.org/x/net v0.0.0-20201110031124-69a78807bb2b
-	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
-	golang.org/x/time v0.0.0-20200630173020-3af7569d3a1e
-	k8s.io/api v0.20.1
-	k8s.io/apimachinery v0.20.1
-	k8s.io/klog/v2 v2.4.0
-	k8s.io/utils v0.0.0-20201110183641-67b214c5f920
-	sigs.k8s.io/yaml v1.2.0
-)
-
-replace (
-	k8s.io/api => k8s.io/api v0.20.1
-	k8s.io/apimachinery => k8s.io/apimachinery v0.20.1
-)

go.sum

@@ -1,453 +0,0 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
-cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
-cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
-cloud.google.com/go v0.54.0 h1:3ithwDMr7/3vpAMXiH+ZQnYbuIsh+OPhUPMFC9enmn0=
-cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
-cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
-cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
-cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
-cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
-cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
-cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
-cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
-cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
-cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
-cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-github.com/Azure/go-autorest v14.2.0+incompatible h1:V5VMDjClD3GiElqLWO7mz2MxNAK/vTfRHdAubSIPRgs=
-github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
-github.com/Azure/go-autorest/autorest v0.11.1 h1:eVvIXUKiTgv++6YnWb42DUA1YL7qDugnKP0HljexdnQ=
-github.com/Azure/go-autorest/autorest v0.11.1/go.mod h1:JFgpikqFJ/MleTTxwepExTKnFUKKszPS8UavbQYUMuw=
-github.com/Azure/go-autorest/autorest/adal v0.9.0 h1:SigMbuFNuKgc1xcGhaeapbh+8fgsu+GxgDRFyg7f5lM=
-github.com/Azure/go-autorest/autorest/adal v0.9.0/go.mod h1:/c022QCutn2P7uY+/oQWWNcK9YU+MH96NgK+jErpbcg=
-github.com/Azure/go-autorest/autorest/adal v0.9.5 h1:Y3bBUV4rTuxenJJs41HU3qmqsb+auo+a3Lz+PlJPpL0=
-github.com/Azure/go-autorest/autorest/adal v0.9.5/go.mod h1:B7KF7jKIeC9Mct5spmyCB/A8CG/sEz1vwIRGv/bbw7A=
-github.com/Azure/go-autorest/autorest/date v0.3.0 h1:7gUk1U5M/CQbp9WoqinNzJar+8KY+LPI6wiWrP/myHw=
-github.com/Azure/go-autorest/autorest/date v0.3.0/go.mod h1:BI0uouVdmngYNUzGWeSYnokU+TrmwEsOqdt8Y6sso74=
-github.com/Azure/go-autorest/autorest/mocks v0.4.0 h1:z20OWOSG5aCye0HEkDp6TPmP17ZcfeMxPi6HnSALa8c=
-github.com/Azure/go-autorest/autorest/mocks v0.4.0/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k=
-github.com/Azure/go-autorest/autorest/mocks v0.4.1 h1:K0laFcLE6VLTOwNgSxaGbUcLPuGXlNkbVvq4cW4nIHk=
-github.com/Azure/go-autorest/autorest/mocks v0.4.1/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k=
-github.com/Azure/go-autorest/logger v0.2.0 h1:e4RVHVZKC5p6UANLJHkM4OfR1UKZPj8Wt8Pcx+3oqrE=
-github.com/Azure/go-autorest/logger v0.2.0/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8=
-github.com/Azure/go-autorest/tracing v0.6.0 h1:TYi4+3m5t6K48TGI9AUdb+IzbnSxvnvUMfuitfgcfuo=
-github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
-github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
-github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
-github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
-github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96 h1:cenwrSVm+Z7QLSV/BsnenAOcDXdX4cMv4wP0B/5QbPg=
-github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM=
-github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
-github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153 h1:yUdfgN0XgIJw7foRItutHYUIhlcKzcSf5vDpdhQAKTc=
-github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
-github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/evanphx/json-patch v4.9.0+incompatible h1:kLcOMZeuLAJvL2BPWLMIj5oaZQobrkAqrL+WFZwQses=
-github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
-github.com/form3tech-oss/jwt-go v3.2.2+incompatible h1:TcekIExNqud5crz4xD2pavyTgWiPvpYe4Xau31I0PRk=
-github.com/form3tech-oss/jwt-go v3.2.2+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k=
-github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-logr/logr v0.1.0 h1:M1Tv3VzNlEHg6uyACnRdtrploV2P7wZqH8BoQMtz0cg=
-github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
-github.com/go-logr/logr v0.2.0 h1:QvGt2nLcHH0WK9orKa+ppBPAxREcH364nPUedEpK0TY=
-github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
-github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg=
-github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
-github.com/go-openapi/jsonreference v0.19.2/go.mod h1:jMjeRr2HHw6nAVajTXJ4eiUwohSTlpa0o73RUL1owJc=
-github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8=
-github.com/go-openapi/spec v0.19.3/go.mod h1:FpwSN1ksY1eteniUU7X0N/BgJ7a4WvBFVA8Lj9mJglo=
-github.com/go-openapi/swag v0.19.2/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
-github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
-github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
-github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7 h1:5ZkaAPbicIKTF2I64qf5Fh8Aa83Q/dnOafMYV0OMwjA=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
-github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/gofuzz v1.1.0 h1:Hsa8mG0dQ46ij8Sl2AYJDUv1oA9/d6Vk+3LG99Oe02g=
-github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
-github.com/googleapis/gnostic v0.4.1 h1:DLJCy1n/vrD4HPjOvYcT8aYQXpPIzoRZONaYwyycI+I=
-github.com/googleapis/gnostic v0.4.1/go.mod h1:LRhVm6pbyptWbWbuZ38d1eyptfvIytN3ir6b65WBswg=
-github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7 h1:pdN6V1QBWetyv/0+wjACpqVH+eVULgEjkurDLq3goeM=
-github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
-github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU=
-github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/imdario/mergo v0.3.5 h1:JboBksRwiiAJWvIYJVo46AfV+IAIKZpfrSzVKj42R4Q=
-github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
-github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
-github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
-github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
-github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.11.0 h1:JAKSXpt1YjtLA7YpPiqO9ss6sNXEsPfSGdwN0UHqzrw=
-github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
-github.com/onsi/gomega v1.7.0 h1:XPnZz8VVBHjVsy1vzJmRwIcSwiUO+JFfrv/xGiigmME=
-github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI=
-github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
-github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
-go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0 h1:hb9wdF1z5waM+dSIICn1l0DkLVDT3hqhhQsDNUmHPRE=
-golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
-golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
-golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
-golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
-golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
-golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
-golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME=
-golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6 h1:pE8b58s1HRDMi8RDc79m0HISf9D4TzseP40cEA6IGfs=
-golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190616124812-15dcb6c0061f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201112073958-5cba982894dd h1:5CtCZbICpIOFdgO940moixOPjc0178IU44m4EjOO5IY=
-golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.4 h1:0YWbFKbhXG/wIiuHDSKpS0Iy7FSA+u45VtBMfQcFTTc=
-golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20200630173020-3af7569d3a1e h1:EHBhcS0mlXEAVwNyO2dLfjToGsyY4j24pTs2ScHnX7s=
-golang.org/x/time v0.0.0-20200630173020-3af7569d3a1e/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190614205625-5aca471b1d59/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
-google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
-google.golang.org/appengine v1.6.5 h1:tycE03LOZYQNhDpS27tcQdAzLCVMaj7QT2SXxebnpCM=
-google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
-google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
-google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
-google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
-gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-k8s.io/api v0.20.1/go.mod h1:KqwcCVogGxQY3nBlRpwt+wpAMF/KjaCc7RpywacvqUo=
-k8s.io/apimachinery v0.20.1/go.mod h1:WlLqWAHZGg07AeltaI0MV5uk1Omp8xaN0JGLY6gkRpU=
-k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
-k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE=
-k8s.io/klog/v2 v2.4.0 h1:7+X0fUguPyrKEC4WjH8iGDg3laWgMo5tMnRTIGTTxGQ=
-k8s.io/klog/v2 v2.4.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y=
-k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd h1:sOHNzJIkytDF6qadMNKhhDRpc6ODik8lVC6nOur7B2c=
-k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd/go.mod h1:WOJ3KddDSol4tAGcJo0Tvi+dK12EcqSLqcWsryKMpfM=
-k8s.io/utils v0.0.0-20201110183641-67b214c5f920 h1:CbnUZsM497iRC5QMVkHwyl8s2tB3g7yaSHkYPkpgelw=
-k8s.io/utils v0.0.0-20201110183641-67b214c5f920/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
-rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
-rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
-sigs.k8s.io/structured-merge-diff/v4 v4.0.2 h1:YHQV7Dajm86OuqnIR6zAelnDWBRjo+YhYV9PmGrh1s8=
-sigs.k8s.io/structured-merge-diff/v4 v4.0.2/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw=
-sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
-sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=
-sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=

informers/admissionregistration/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,15 +19,15 @@ limitations under the License.
 package admissionregistration
 
 import (
-	v1 "k8s.io/client-go/informers/admissionregistration/v1"
+	v1alpha1 "k8s.io/client-go/informers/admissionregistration/v1alpha1"
 	v1beta1 "k8s.io/client-go/informers/admissionregistration/v1beta1"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
 )
 
 // Interface provides access to each of this group's versions.
 type Interface interface {
-	// V1 provides access to shared informers for resources in V1.
-	V1() v1.Interface
+	// V1alpha1 provides access to shared informers for resources in V1alpha1.
+	V1alpha1() v1alpha1.Interface
 	// V1beta1 provides access to shared informers for resources in V1beta1.
 	V1beta1() v1beta1.Interface
 }
@@ -43,9 +43,9 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
 	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
 }
 
-// V1 returns a new v1.Interface.
-func (g *group) V1() v1.Interface {
-	return v1.New(g.factory, g.namespace, g.tweakListOptions)
+// V1alpha1 returns a new v1alpha1.Interface.
+func (g *group) V1alpha1() v1alpha1.Interface {
+	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
 }
 
 // V1beta1 returns a new v1beta1.Interface.

informers/admissionregistration/v1/interface.go

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

informers/admissionregistration/v1/mutatingwebhookconfiguration.go

@@ -1,89 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by informer-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	"context"
-	time "time"
-
-	admissionregistrationv1 "k8s.io/api/admissionregistration/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	watch "k8s.io/apimachinery/pkg/watch"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	kubernetes "k8s.io/client-go/kubernetes"
-	v1 "k8s.io/client-go/listers/admissionregistration/v1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// MutatingWebhookConfigurationInformer provides access to a shared informer and lister for
-// MutatingWebhookConfigurations.
-type MutatingWebhookConfigurationInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.MutatingWebhookConfigurationLister
-}
-
-type mutatingWebhookConfigurationInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// NewMutatingWebhookConfigurationInformer constructs a new informer for MutatingWebhookConfiguration 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 NewMutatingWebhookConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredMutatingWebhookConfigurationInformer(client, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredMutatingWebhookConfigurationInformer constructs a new informer for MutatingWebhookConfiguration 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 NewFilteredMutatingWebhookConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.AdmissionregistrationV1().MutatingWebhookConfigurations().List(context.TODO(), options)
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.AdmissionregistrationV1().MutatingWebhookConfigurations().Watch(context.TODO(), options)
-			},
-		},
-		&admissionregistrationv1.MutatingWebhookConfiguration{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *mutatingWebhookConfigurationInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredMutatingWebhookConfigurationInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *mutatingWebhookConfigurationInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&admissionregistrationv1.MutatingWebhookConfiguration{}, f.defaultInformer)
-}
-
-func (f *mutatingWebhookConfigurationInformer) Lister() v1.MutatingWebhookConfigurationLister {
-	return v1.NewMutatingWebhookConfigurationLister(f.Informer().GetIndexer())
-}

informers/admissionregistration/v1/validatingwebhookconfiguration.go

@@ -1,89 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by informer-gen. DO NOT EDIT.
-
-package v1
-
-import (
-	"context"
-	time "time"
-
-	admissionregistrationv1 "k8s.io/api/admissionregistration/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	watch "k8s.io/apimachinery/pkg/watch"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	kubernetes "k8s.io/client-go/kubernetes"
-	v1 "k8s.io/client-go/listers/admissionregistration/v1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// ValidatingWebhookConfigurationInformer provides access to a shared informer and lister for
-// ValidatingWebhookConfigurations.
-type ValidatingWebhookConfigurationInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.ValidatingWebhookConfigurationLister
-}
-
-type validatingWebhookConfigurationInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// NewValidatingWebhookConfigurationInformer constructs a new informer for ValidatingWebhookConfiguration 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 NewValidatingWebhookConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredValidatingWebhookConfigurationInformer(client, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredValidatingWebhookConfigurationInformer constructs a new informer for ValidatingWebhookConfiguration 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 NewFilteredValidatingWebhookConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.AdmissionregistrationV1().ValidatingWebhookConfigurations().List(context.TODO(), options)
-			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.AdmissionregistrationV1().ValidatingWebhookConfigurations().Watch(context.TODO(), options)
-			},
-		},
-		&admissionregistrationv1.ValidatingWebhookConfiguration{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *validatingWebhookConfigurationInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredValidatingWebhookConfigurationInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *validatingWebhookConfigurationInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&admissionregistrationv1.ValidatingWebhookConfiguration{}, f.defaultInformer)
-}
-
-func (f *validatingWebhookConfigurationInformer) Lister() v1.ValidatingWebhookConfigurationLister {
-	return v1.NewValidatingWebhookConfigurationLister(f.Informer().GetIndexer())
-}

informers/admissionregistration/v1alpha1/initializerconfiguration.go

@@ -0,0 +1,88 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	time "time"
+
+	admissionregistration_v1alpha1 "k8s.io/api/admissionregistration/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/admissionregistration/v1alpha1"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// InitializerConfigurationInformer provides access to a shared informer and lister for
+// InitializerConfigurations.
+type InitializerConfigurationInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.InitializerConfigurationLister
+}
+
+type initializerConfigurationInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// NewInitializerConfigurationInformer constructs a new informer for InitializerConfiguration 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 NewInitializerConfigurationInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredInitializerConfigurationInformer(client, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredInitializerConfigurationInformer constructs a new informer for InitializerConfiguration 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 NewFilteredInitializerConfigurationInformer(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.AdmissionregistrationV1alpha1().InitializerConfigurations().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.AdmissionregistrationV1alpha1().InitializerConfigurations().Watch(options)
+			},
+		},
+		&admissionregistration_v1alpha1.InitializerConfiguration{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *initializerConfigurationInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredInitializerConfigurationInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *initializerConfigurationInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&admissionregistration_v1alpha1.InitializerConfiguration{}, f.defaultInformer)
+}
+
+func (f *initializerConfigurationInformer) Lister() v1alpha1.InitializerConfigurationLister {
+	return v1alpha1.NewInitializerConfigurationLister(f.Informer().GetIndexer())
+}

informers/admissionregistration/v1alpha1/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@ limitations under the License.
 
 // Code generated by informer-gen. DO NOT EDIT.
 
-package v1beta1
+package v1alpha1
 
 import (
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
@@ -24,8 +24,8 @@ import (
 
 // Interface provides access to all the informers in this group version.
 type Interface interface {
-	// RuntimeClasses returns a RuntimeClassInformer.
-	RuntimeClasses() RuntimeClassInformer
+	// InitializerConfigurations returns a InitializerConfigurationInformer.
+	InitializerConfigurations() InitializerConfigurationInformer
 }
 
 type version struct {
@@ -39,7 +39,7 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
 	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
 }
 
-// RuntimeClasses returns a RuntimeClassInformer.
-func (v *version) RuntimeClasses() RuntimeClassInformer {
-	return &runtimeClassInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+// InitializerConfigurations returns a InitializerConfigurationInformer.
+func (v *version) InitializerConfigurations() InitializerConfigurationInformer {
+	return &initializerConfigurationInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
 }

informers/admissionregistration/v1beta1/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/admissionregistration/v1beta1/mutatingwebhookconfiguration.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
 	time "time"
 
-	admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1"
+	admissionregistration_v1beta1 "k8s.io/api/admissionregistration/v1beta1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -61,16 +60,16 @@ func NewFilteredMutatingWebhookConfigurationInformer(client kubernetes.Interface
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AdmissionregistrationV1beta1().MutatingWebhookConfigurations().List(context.TODO(), options)
+				return client.AdmissionregistrationV1beta1().MutatingWebhookConfigurations().List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AdmissionregistrationV1beta1().MutatingWebhookConfigurations().Watch(context.TODO(), options)
+				return client.AdmissionregistrationV1beta1().MutatingWebhookConfigurations().Watch(options)
 			},
 		},
-		&admissionregistrationv1beta1.MutatingWebhookConfiguration{},
+		&admissionregistration_v1beta1.MutatingWebhookConfiguration{},
 		resyncPeriod,
 		indexers,
 	)
@@ -81,7 +80,7 @@ func (f *mutatingWebhookConfigurationInformer) defaultInformer(client kubernetes
 }
 
 func (f *mutatingWebhookConfigurationInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&admissionregistrationv1beta1.MutatingWebhookConfiguration{}, f.defaultInformer)
+	return f.factory.InformerFor(&admissionregistration_v1beta1.MutatingWebhookConfiguration{}, f.defaultInformer)
 }
 
 func (f *mutatingWebhookConfigurationInformer) Lister() v1beta1.MutatingWebhookConfigurationLister {

informers/admissionregistration/v1beta1/validatingwebhookconfiguration.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
 	time "time"
 
-	admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1"
+	admissionregistration_v1beta1 "k8s.io/api/admissionregistration/v1beta1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -61,16 +60,16 @@ func NewFilteredValidatingWebhookConfigurationInformer(client kubernetes.Interfa
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AdmissionregistrationV1beta1().ValidatingWebhookConfigurations().List(context.TODO(), options)
+				return client.AdmissionregistrationV1beta1().ValidatingWebhookConfigurations().List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AdmissionregistrationV1beta1().ValidatingWebhookConfigurations().Watch(context.TODO(), options)
+				return client.AdmissionregistrationV1beta1().ValidatingWebhookConfigurations().Watch(options)
 			},
 		},
-		&admissionregistrationv1beta1.ValidatingWebhookConfiguration{},
+		&admissionregistration_v1beta1.ValidatingWebhookConfiguration{},
 		resyncPeriod,
 		indexers,
 	)
@@ -81,7 +80,7 @@ func (f *validatingWebhookConfigurationInformer) defaultInformer(client kubernet
 }
 
 func (f *validatingWebhookConfigurationInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&admissionregistrationv1beta1.ValidatingWebhookConfiguration{}, f.defaultInformer)
+	return f.factory.InformerFor(&admissionregistration_v1beta1.ValidatingWebhookConfiguration{}, f.defaultInformer)
 }
 
 func (f *validatingWebhookConfigurationInformer) Lister() v1beta1.ValidatingWebhookConfigurationLister {

informers/apiserverinternal/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 {
-	// StorageVersions returns a StorageVersionInformer.
-	StorageVersions() StorageVersionInformer
-}
-
-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}
-}
-
-// StorageVersions returns a StorageVersionInformer.
-func (v *version) StorageVersions() StorageVersionInformer {
-	return &storageVersionInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
-}

informers/apiserverinternal/v1alpha1/storageversion.go

@@ -1,89 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by informer-gen. DO NOT EDIT.
-
-package v1alpha1
-
-import (
-	"context"
-	time "time"
-
-	apiserverinternalv1alpha1 "k8s.io/api/apiserverinternal/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/apiserverinternal/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// StorageVersionInformer provides access to a shared informer and lister for
-// StorageVersions.
-type StorageVersionInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.StorageVersionLister
-}
-
-type storageVersionInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-}
-
-// NewStorageVersionInformer constructs a new informer for StorageVersion 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 NewStorageVersionInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredStorageVersionInformer(client, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredStorageVersionInformer constructs a new informer for StorageVersion 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 NewFilteredStorageVersionInformer(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.InternalV1alpha1().StorageVersions().List(context.TODO(), options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.InternalV1alpha1().StorageVersions().Watch(context.TODO(), options)
-			},
-		},
-		&apiserverinternalv1alpha1.StorageVersion{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *storageVersionInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredStorageVersionInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *storageVersionInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&apiserverinternalv1alpha1.StorageVersion{}, f.defaultInformer)
-}
-
-func (f *storageVersionInformer) Lister() v1alpha1.StorageVersionLister {
-	return v1alpha1.NewStorageVersionLister(f.Informer().GetIndexer())
-}

informers/apps/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/apps/v1/controllerrevision.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,11 +19,10 @@ limitations under the License.
 package v1
 
 import (
-	"context"
 	time "time"
 
-	appsv1 "k8s.io/api/apps/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	apps_v1 "k8s.io/api/apps/v1"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
@@ -58,20 +57,20 @@ func NewControllerRevisionInformer(client kubernetes.Interface, namespace string
 func NewFilteredControllerRevisionInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().ControllerRevisions(namespace).List(context.TODO(), options)
+				return client.AppsV1().ControllerRevisions(namespace).List(options)
 			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().ControllerRevisions(namespace).Watch(context.TODO(), options)
+				return client.AppsV1().ControllerRevisions(namespace).Watch(options)
 			},
 		},
-		&appsv1.ControllerRevision{},
+		&apps_v1.ControllerRevision{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *controllerRevisionInformer) defaultInformer(client kubernetes.Interface
 }
 
 func (f *controllerRevisionInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1.ControllerRevision{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1.ControllerRevision{}, f.defaultInformer)
 }
 
 func (f *controllerRevisionInformer) Lister() v1.ControllerRevisionLister {

informers/apps/v1/daemonset.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,11 +19,10 @@ limitations under the License.
 package v1
 
 import (
-	"context"
 	time "time"
 
-	appsv1 "k8s.io/api/apps/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	apps_v1 "k8s.io/api/apps/v1"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
@@ -58,20 +57,20 @@ func NewDaemonSetInformer(client kubernetes.Interface, namespace string, resyncP
 func NewFilteredDaemonSetInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().DaemonSets(namespace).List(context.TODO(), options)
+				return client.AppsV1().DaemonSets(namespace).List(options)
 			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().DaemonSets(namespace).Watch(context.TODO(), options)
+				return client.AppsV1().DaemonSets(namespace).Watch(options)
 			},
 		},
-		&appsv1.DaemonSet{},
+		&apps_v1.DaemonSet{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *daemonSetInformer) defaultInformer(client kubernetes.Interface, resyncP
 }
 
 func (f *daemonSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1.DaemonSet{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1.DaemonSet{}, f.defaultInformer)
 }
 
 func (f *daemonSetInformer) Lister() v1.DaemonSetLister {

informers/apps/v1/deployment.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,11 +19,10 @@ limitations under the License.
 package v1
 
 import (
-	"context"
 	time "time"
 
-	appsv1 "k8s.io/api/apps/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	apps_v1 "k8s.io/api/apps/v1"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
@@ -58,20 +57,20 @@ func NewDeploymentInformer(client kubernetes.Interface, namespace string, resync
 func NewFilteredDeploymentInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().Deployments(namespace).List(context.TODO(), options)
+				return client.AppsV1().Deployments(namespace).List(options)
 			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().Deployments(namespace).Watch(context.TODO(), options)
+				return client.AppsV1().Deployments(namespace).Watch(options)
 			},
 		},
-		&appsv1.Deployment{},
+		&apps_v1.Deployment{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *deploymentInformer) defaultInformer(client kubernetes.Interface, resync
 }
 
 func (f *deploymentInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1.Deployment{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1.Deployment{}, f.defaultInformer)
 }
 
 func (f *deploymentInformer) Lister() v1.DeploymentLister {

informers/apps/v1/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/apps/v1/replicaset.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,11 +19,10 @@ limitations under the License.
 package v1
 
 import (
-	"context"
 	time "time"
 
-	appsv1 "k8s.io/api/apps/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	apps_v1 "k8s.io/api/apps/v1"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
@@ -58,20 +57,20 @@ func NewReplicaSetInformer(client kubernetes.Interface, namespace string, resync
 func NewFilteredReplicaSetInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().ReplicaSets(namespace).List(context.TODO(), options)
+				return client.AppsV1().ReplicaSets(namespace).List(options)
 			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().ReplicaSets(namespace).Watch(context.TODO(), options)
+				return client.AppsV1().ReplicaSets(namespace).Watch(options)
 			},
 		},
-		&appsv1.ReplicaSet{},
+		&apps_v1.ReplicaSet{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *replicaSetInformer) defaultInformer(client kubernetes.Interface, resync
 }
 
 func (f *replicaSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1.ReplicaSet{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1.ReplicaSet{}, f.defaultInformer)
 }
 
 func (f *replicaSetInformer) Lister() v1.ReplicaSetLister {

informers/apps/v1/statefulset.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,11 +19,10 @@ limitations under the License.
 package v1
 
 import (
-	"context"
 	time "time"
 
-	appsv1 "k8s.io/api/apps/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	apps_v1 "k8s.io/api/apps/v1"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
@@ -58,20 +57,20 @@ func NewStatefulSetInformer(client kubernetes.Interface, namespace string, resyn
 func NewFilteredStatefulSetInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().StatefulSets(namespace).List(context.TODO(), options)
+				return client.AppsV1().StatefulSets(namespace).List(options)
 			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1().StatefulSets(namespace).Watch(context.TODO(), options)
+				return client.AppsV1().StatefulSets(namespace).Watch(options)
 			},
 		},
-		&appsv1.StatefulSet{},
+		&apps_v1.StatefulSet{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *statefulSetInformer) defaultInformer(client kubernetes.Interface, resyn
 }
 
 func (f *statefulSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1.StatefulSet{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1.StatefulSet{}, f.defaultInformer)
 }
 
 func (f *statefulSetInformer) Lister() v1.StatefulSetLister {

informers/apps/v1beta1/controllerrevision.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
 	time "time"
 
-	appsv1beta1 "k8s.io/api/apps/v1beta1"
+	apps_v1beta1 "k8s.io/api/apps/v1beta1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredControllerRevisionInformer(client kubernetes.Interface, namespac
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta1().ControllerRevisions(namespace).List(context.TODO(), options)
+				return client.AppsV1beta1().ControllerRevisions(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta1().ControllerRevisions(namespace).Watch(context.TODO(), options)
+				return client.AppsV1beta1().ControllerRevisions(namespace).Watch(options)
 			},
 		},
-		&appsv1beta1.ControllerRevision{},
+		&apps_v1beta1.ControllerRevision{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *controllerRevisionInformer) defaultInformer(client kubernetes.Interface
 }
 
 func (f *controllerRevisionInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1beta1.ControllerRevision{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1beta1.ControllerRevision{}, f.defaultInformer)
 }
 
 func (f *controllerRevisionInformer) Lister() v1beta1.ControllerRevisionLister {

informers/apps/v1beta1/deployment.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
 	time "time"
 
-	appsv1beta1 "k8s.io/api/apps/v1beta1"
+	apps_v1beta1 "k8s.io/api/apps/v1beta1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredDeploymentInformer(client kubernetes.Interface, namespace string
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta1().Deployments(namespace).List(context.TODO(), options)
+				return client.AppsV1beta1().Deployments(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta1().Deployments(namespace).Watch(context.TODO(), options)
+				return client.AppsV1beta1().Deployments(namespace).Watch(options)
 			},
 		},
-		&appsv1beta1.Deployment{},
+		&apps_v1beta1.Deployment{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *deploymentInformer) defaultInformer(client kubernetes.Interface, resync
 }
 
 func (f *deploymentInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1beta1.Deployment{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1beta1.Deployment{}, f.defaultInformer)
 }
 
 func (f *deploymentInformer) Lister() v1beta1.DeploymentLister {

informers/apps/v1beta1/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/apps/v1beta1/statefulset.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta1
 
 import (
-	"context"
 	time "time"
 
-	appsv1beta1 "k8s.io/api/apps/v1beta1"
+	apps_v1beta1 "k8s.io/api/apps/v1beta1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredStatefulSetInformer(client kubernetes.Interface, namespace strin
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta1().StatefulSets(namespace).List(context.TODO(), options)
+				return client.AppsV1beta1().StatefulSets(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta1().StatefulSets(namespace).Watch(context.TODO(), options)
+				return client.AppsV1beta1().StatefulSets(namespace).Watch(options)
 			},
 		},
-		&appsv1beta1.StatefulSet{},
+		&apps_v1beta1.StatefulSet{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *statefulSetInformer) defaultInformer(client kubernetes.Interface, resyn
 }
 
 func (f *statefulSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1beta1.StatefulSet{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1beta1.StatefulSet{}, f.defaultInformer)
 }
 
 func (f *statefulSetInformer) Lister() v1beta1.StatefulSetLister {

informers/apps/v1beta2/controllerrevision.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta2
 
 import (
-	"context"
 	time "time"
 
-	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	apps_v1beta2 "k8s.io/api/apps/v1beta2"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredControllerRevisionInformer(client kubernetes.Interface, namespac
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().ControllerRevisions(namespace).List(context.TODO(), options)
+				return client.AppsV1beta2().ControllerRevisions(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().ControllerRevisions(namespace).Watch(context.TODO(), options)
+				return client.AppsV1beta2().ControllerRevisions(namespace).Watch(options)
 			},
 		},
-		&appsv1beta2.ControllerRevision{},
+		&apps_v1beta2.ControllerRevision{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *controllerRevisionInformer) defaultInformer(client kubernetes.Interface
 }
 
 func (f *controllerRevisionInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1beta2.ControllerRevision{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1beta2.ControllerRevision{}, f.defaultInformer)
 }
 
 func (f *controllerRevisionInformer) Lister() v1beta2.ControllerRevisionLister {

informers/apps/v1beta2/daemonset.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta2
 
 import (
-	"context"
 	time "time"
 
-	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	apps_v1beta2 "k8s.io/api/apps/v1beta2"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredDaemonSetInformer(client kubernetes.Interface, namespace string,
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().DaemonSets(namespace).List(context.TODO(), options)
+				return client.AppsV1beta2().DaemonSets(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().DaemonSets(namespace).Watch(context.TODO(), options)
+				return client.AppsV1beta2().DaemonSets(namespace).Watch(options)
 			},
 		},
-		&appsv1beta2.DaemonSet{},
+		&apps_v1beta2.DaemonSet{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *daemonSetInformer) defaultInformer(client kubernetes.Interface, resyncP
 }
 
 func (f *daemonSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1beta2.DaemonSet{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1beta2.DaemonSet{}, f.defaultInformer)
 }
 
 func (f *daemonSetInformer) Lister() v1beta2.DaemonSetLister {

informers/apps/v1beta2/deployment.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta2
 
 import (
-	"context"
 	time "time"
 
-	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	apps_v1beta2 "k8s.io/api/apps/v1beta2"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredDeploymentInformer(client kubernetes.Interface, namespace string
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().Deployments(namespace).List(context.TODO(), options)
+				return client.AppsV1beta2().Deployments(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().Deployments(namespace).Watch(context.TODO(), options)
+				return client.AppsV1beta2().Deployments(namespace).Watch(options)
 			},
 		},
-		&appsv1beta2.Deployment{},
+		&apps_v1beta2.Deployment{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *deploymentInformer) defaultInformer(client kubernetes.Interface, resync
 }
 
 func (f *deploymentInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1beta2.Deployment{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1beta2.Deployment{}, f.defaultInformer)
 }
 
 func (f *deploymentInformer) Lister() v1beta2.DeploymentLister {

informers/apps/v1beta2/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/apps/v1beta2/replicaset.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta2
 
 import (
-	"context"
 	time "time"
 
-	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	apps_v1beta2 "k8s.io/api/apps/v1beta2"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredReplicaSetInformer(client kubernetes.Interface, namespace string
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().ReplicaSets(namespace).List(context.TODO(), options)
+				return client.AppsV1beta2().ReplicaSets(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().ReplicaSets(namespace).Watch(context.TODO(), options)
+				return client.AppsV1beta2().ReplicaSets(namespace).Watch(options)
 			},
 		},
-		&appsv1beta2.ReplicaSet{},
+		&apps_v1beta2.ReplicaSet{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *replicaSetInformer) defaultInformer(client kubernetes.Interface, resync
 }
 
 func (f *replicaSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1beta2.ReplicaSet{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1beta2.ReplicaSet{}, f.defaultInformer)
 }
 
 func (f *replicaSetInformer) Lister() v1beta2.ReplicaSetLister {

informers/apps/v1beta2/statefulset.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v1beta2
 
 import (
-	"context"
 	time "time"
 
-	appsv1beta2 "k8s.io/api/apps/v1beta2"
+	apps_v1beta2 "k8s.io/api/apps/v1beta2"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredStatefulSetInformer(client kubernetes.Interface, namespace strin
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().StatefulSets(namespace).List(context.TODO(), options)
+				return client.AppsV1beta2().StatefulSets(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AppsV1beta2().StatefulSets(namespace).Watch(context.TODO(), options)
+				return client.AppsV1beta2().StatefulSets(namespace).Watch(options)
 			},
 		},
-		&appsv1beta2.StatefulSet{},
+		&apps_v1beta2.StatefulSet{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *statefulSetInformer) defaultInformer(client kubernetes.Interface, resyn
 }
 
 func (f *statefulSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&appsv1beta2.StatefulSet{}, f.defaultInformer)
+	return f.factory.InformerFor(&apps_v1beta2.StatefulSet{}, f.defaultInformer)
 }
 
 func (f *statefulSetInformer) Lister() v1beta2.StatefulSetLister {

informers/autoscaling/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -21,7 +21,6 @@ package autoscaling
 import (
 	v1 "k8s.io/client-go/informers/autoscaling/v1"
 	v2beta1 "k8s.io/client-go/informers/autoscaling/v2beta1"
-	v2beta2 "k8s.io/client-go/informers/autoscaling/v2beta2"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
 )
 
@@ -31,8 +30,6 @@ type Interface interface {
 	V1() v1.Interface
 	// V2beta1 provides access to shared informers for resources in V2beta1.
 	V2beta1() v2beta1.Interface
-	// V2beta2 provides access to shared informers for resources in V2beta2.
-	V2beta2() v2beta2.Interface
 }
 
 type group struct {
@@ -55,8 +52,3 @@ func (g *group) V1() v1.Interface {
 func (g *group) V2beta1() v2beta1.Interface {
 	return v2beta1.New(g.factory, g.namespace, g.tweakListOptions)
 }
-
-// V2beta2 returns a new v2beta2.Interface.
-func (g *group) V2beta2() v2beta2.Interface {
-	return v2beta2.New(g.factory, g.namespace, g.tweakListOptions)
-}

informers/autoscaling/v1/horizontalpodautoscaler.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,11 +19,10 @@ limitations under the License.
 package v1
 
 import (
-	"context"
 	time "time"
 
-	autoscalingv1 "k8s.io/api/autoscaling/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	autoscaling_v1 "k8s.io/api/autoscaling/v1"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
@@ -58,20 +57,20 @@ func NewHorizontalPodAutoscalerInformer(client kubernetes.Interface, namespace s
 func NewFilteredHorizontalPodAutoscalerInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AutoscalingV1().HorizontalPodAutoscalers(namespace).List(context.TODO(), options)
+				return client.AutoscalingV1().HorizontalPodAutoscalers(namespace).List(options)
 			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AutoscalingV1().HorizontalPodAutoscalers(namespace).Watch(context.TODO(), options)
+				return client.AutoscalingV1().HorizontalPodAutoscalers(namespace).Watch(options)
 			},
 		},
-		&autoscalingv1.HorizontalPodAutoscaler{},
+		&autoscaling_v1.HorizontalPodAutoscaler{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *horizontalPodAutoscalerInformer) defaultInformer(client kubernetes.Inte
 }
 
 func (f *horizontalPodAutoscalerInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&autoscalingv1.HorizontalPodAutoscaler{}, f.defaultInformer)
+	return f.factory.InformerFor(&autoscaling_v1.HorizontalPodAutoscaler{}, f.defaultInformer)
 }
 
 func (f *horizontalPodAutoscalerInformer) Lister() v1.HorizontalPodAutoscalerLister {

informers/autoscaling/v1/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/autoscaling/v2beta1/horizontalpodautoscaler.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,10 +19,9 @@ limitations under the License.
 package v2beta1
 
 import (
-	"context"
 	time "time"
 
-	autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1"
+	autoscaling_v2beta1 "k8s.io/api/autoscaling/v2beta1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
@@ -62,16 +61,16 @@ func NewFilteredHorizontalPodAutoscalerInformer(client kubernetes.Interface, nam
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AutoscalingV2beta1().HorizontalPodAutoscalers(namespace).List(context.TODO(), options)
+				return client.AutoscalingV2beta1().HorizontalPodAutoscalers(namespace).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.AutoscalingV2beta1().HorizontalPodAutoscalers(namespace).Watch(context.TODO(), options)
+				return client.AutoscalingV2beta1().HorizontalPodAutoscalers(namespace).Watch(options)
 			},
 		},
-		&autoscalingv2beta1.HorizontalPodAutoscaler{},
+		&autoscaling_v2beta1.HorizontalPodAutoscaler{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *horizontalPodAutoscalerInformer) defaultInformer(client kubernetes.Inte
 }
 
 func (f *horizontalPodAutoscalerInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&autoscalingv2beta1.HorizontalPodAutoscaler{}, f.defaultInformer)
+	return f.factory.InformerFor(&autoscaling_v2beta1.HorizontalPodAutoscaler{}, f.defaultInformer)
 }
 
 func (f *horizontalPodAutoscalerInformer) Lister() v2beta1.HorizontalPodAutoscalerLister {

informers/autoscaling/v2beta1/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/autoscaling/v2beta2/horizontalpodautoscaler.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 informer-gen. DO NOT EDIT.
-
-package v2beta2
-
-import (
-	"context"
-	time "time"
-
-	autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2"
-	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"
-	v2beta2 "k8s.io/client-go/listers/autoscaling/v2beta2"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// HorizontalPodAutoscalerInformer provides access to a shared informer and lister for
-// HorizontalPodAutoscalers.
-type HorizontalPodAutoscalerInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v2beta2.HorizontalPodAutoscalerLister
-}
-
-type horizontalPodAutoscalerInformer struct {
-	factory          internalinterfaces.SharedInformerFactory
-	tweakListOptions internalinterfaces.TweakListOptionsFunc
-	namespace        string
-}
-
-// NewHorizontalPodAutoscalerInformer constructs a new informer for HorizontalPodAutoscaler 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 NewHorizontalPodAutoscalerInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
-	return NewFilteredHorizontalPodAutoscalerInformer(client, namespace, resyncPeriod, indexers, nil)
-}
-
-// NewFilteredHorizontalPodAutoscalerInformer constructs a new informer for HorizontalPodAutoscaler 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 NewFilteredHorizontalPodAutoscalerInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
-	return cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.AutoscalingV2beta2().HorizontalPodAutoscalers(namespace).List(context.TODO(), options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				if tweakListOptions != nil {
-					tweakListOptions(&options)
-				}
-				return client.AutoscalingV2beta2().HorizontalPodAutoscalers(namespace).Watch(context.TODO(), options)
-			},
-		},
-		&autoscalingv2beta2.HorizontalPodAutoscaler{},
-		resyncPeriod,
-		indexers,
-	)
-}
-
-func (f *horizontalPodAutoscalerInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	return NewFilteredHorizontalPodAutoscalerInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
-}
-
-func (f *horizontalPodAutoscalerInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&autoscalingv2beta2.HorizontalPodAutoscaler{}, f.defaultInformer)
-}
-
-func (f *horizontalPodAutoscalerInformer) Lister() v2beta2.HorizontalPodAutoscalerLister {
-	return v2beta2.NewHorizontalPodAutoscalerLister(f.Informer().GetIndexer())
-}

informers/autoscaling/v2beta2/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 v2beta2
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
-	HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer
-}
-
-type version struct {
-	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}
-}
-
-// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
-func (v *version) HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer {
-	return &horizontalPodAutoscalerInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
-}

informers/batch/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/batch/v1/interface.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

informers/batch/v1/job.go

@@ -1,5 +1,5 @@
 /*
-Copyright The Kubernetes Authors.
+Copyright 2019 The Kubernetes Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -19,11 +19,10 @@ limitations under the License.
 package v1
 
 import (
-	"context"
 	time "time"
 
-	batchv1 "k8s.io/api/batch/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	batch_v1 "k8s.io/api/batch/v1"
+	meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 	watch "k8s.io/apimachinery/pkg/watch"
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
@@ -58,20 +57,20 @@ func NewJobInformer(client kubernetes.Interface, namespace string, resyncPeriod
 func NewFilteredJobInformer(client kubernetes.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
 	return cache.NewSharedIndexInformer(
 		&cache.ListWatch{
-			ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
+			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.BatchV1().Jobs(namespace).List(context.TODO(), options)
+				return client.BatchV1().Jobs(namespace).List(options)
 			},
-			WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
+			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
 				if tweakListOptions != nil {
 					tweakListOptions(&options)
 				}
-				return client.BatchV1().Jobs(namespace).Watch(context.TODO(), options)
+				return client.BatchV1().Jobs(namespace).Watch(options)
 			},
 		},
-		&batchv1.Job{},
+		&batch_v1.Job{},
 		resyncPeriod,
 		indexers,
 	)
@@ -82,7 +81,7 @@ func (f *jobInformer) defaultInformer(client kubernetes.Interface, resyncPeriod
 }
 
 func (f *jobInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&batchv1.Job{}, f.defaultInformer)
+	return f.factory.InformerFor(&batch_v1.Job{}, f.defaultInformer)
 }
 
 func (f *jobInformer) Lister() v1.JobLister {