github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #49370 from sttts/sttts-no-clientset-embedding

Browse Source 
Automatic merge from submit-queue (batch tested with PRs 49370, 49481)

client-gen: stop embedding of GroupVersion client intfs

It is undefined (or at least uncontrollable) which methods of the clientset apigroup
interfaces are actually inherited. Moreover, there might be nameconflicts between the
accessors and inherited methods. This PR removes the embedding to make it unambiguous.

```release-note
Enforce explicit references to API group client interfaces in clientsets to avoid ambiguity.
```
This commit is contained in:
Kubernetes Submit Queue
2017-08-06 08:52:54 -07:00
committed by GitHub
parent 702e506a69 3b310d8989
commit 979c86f3dd
48 changed files with 472 additions and 492 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/kube-apiserver/app/testing/testserver.go
View File

@@ -106,7 +106,7 @@ func StartTestServer(t *testing.T) (result *restclient.Config, tearDownForCaller
default: default:
} }
result := client.CoreV1Client.RESTClient().Get().AbsPath("/healthz").Do() result := client.CoreV1().RESTClient().Get().AbsPath("/healthz").Do()
status := 0 status := 0
result.StatusCode(&status) result.StatusCode(&status)
if status == 200 { if status == 200 {

1
cmd/kubeadm/app/phases/markmaster/BUILD
View File

@@ -20,7 +20,6 @@ go_test(
"//vendor/k8s.io/api/core/v1:go_default_library", "//vendor/k8s.io/api/core/v1:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//vendor/k8s.io/client-go/kubernetes:go_default_library", "//vendor/k8s.io/client-go/kubernetes:go_default_library",
"//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
"//vendor/k8s.io/client-go/rest:go_default_library", "//vendor/k8s.io/client-go/rest:go_default_library",
], ],
) )

12
cmd/kubeadm/app/phases/markmaster/markmaster_test.go
View File

@@ -27,7 +27,6 @@ import (
"k8s.io/api/core/v1" "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
restclient "k8s.io/client-go/rest" restclient "k8s.io/client-go/rest"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants" kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis" kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
@@ -121,7 +120,7 @@ func TestMarkMaster(t *testing.T) {
})) }))
defer s.Close() defer s.Close()
cs, err := clientsetFromTestServer(s) cs, err := clientset.NewForConfig(&restclient.Config{Host: s.URL})
if err != nil { if err != nil {
t.Fatalf("MarkMaster(%s): unexpected error building clientset: %v", tc.name, err) t.Fatalf("MarkMaster(%s): unexpected error building clientset: %v", tc.name, err)
} }
@@ -137,15 +136,6 @@ func TestMarkMaster(t *testing.T) {
} }
} }
func clientsetFromTestServer(s *httptest.Server) (*clientset.Clientset, error) {
rc := &restclient.Config{Host: s.URL}
c, err := corev1.NewForConfig(rc)
if err != nil {
return nil, err
}
return &clientset.Clientset{CoreV1Client: c}, nil
}
func toString(r io.Reader) string { func toString(r io.Reader) string {
buf := new(bytes.Buffer) buf := new(bytes.Buffer)
buf.ReadFrom(r) buf.ReadFrom(r)

4
cmd/kubelet/app/server.go
View File

@@ -203,14 +203,14 @@ func getRemoteKubeletConfig(s *options.KubeletServer, kubeDeps *kubelet.Dependen
return nil, err return nil, err
} }
// look for kubelet-<node-name> configmap from "kube-system" // look for kubelet-<node-name> configmap from "kube-system"
configmap, err := kubeClient.CoreV1Client.ConfigMaps("kube-system").Get(fmt.Sprintf("kubelet-%s", nodename), metav1.GetOptions{}) configmap, err := kubeClient.CoreV1().ConfigMaps("kube-system").Get(fmt.Sprintf("kubelet-%s", nodename), metav1.GetOptions{})
if err != nil { if err != nil {
return nil, err return nil, err
} }
return configmap, nil return configmap, nil
} }
// No cloud provider yet, so can't get the nodename via Cloud.Instances().CurrentNodeName(hostname), try just using the hostname // No cloud provider yet, so can't get the nodename via Cloud.Instances().CurrentNodeName(hostname), try just using the hostname
configmap, err := kubeClient.CoreV1Client.ConfigMaps("kube-system").Get(fmt.Sprintf("kubelet-%s", hostname), metav1.GetOptions{}) configmap, err := kubeClient.CoreV1().ConfigMaps("kube-system").Get(fmt.Sprintf("kubelet-%s", hostname), metav1.GetOptions{})
if err != nil { if err != nil {
return nil, fmt.Errorf("cloud provider was nil, and attempt to use hostname to find config resulted in: %v", err) return nil, fmt.Errorf("cloud provider was nil, and attempt to use hostname to find config resulted in: %v", err)
} }

2
cmd/kubemark/hollow-node.go
View File

@@ -147,7 +147,7 @@ func main() {
hollowProxy, err := kubemark.NewHollowProxyOrDie( hollowProxy, err := kubemark.NewHollowProxyOrDie(
config.NodeName, config.NodeName,
internalClientset, internalClientset,
client.Core(), client.CoreV1(),
iptInterface, iptInterface,
sysctl, sysctl,
execer, execer,

60
federation/client/clientset_generated/federation_clientset/clientset.go
View File

@@ -51,66 +51,66 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*autoscalingv1.AutoscalingV1Client autoscalingV1 *autoscalingv1.AutoscalingV1Client
*batchv1.BatchV1Client batchV1 *batchv1.BatchV1Client
*corev1.CoreV1Client coreV1 *corev1.CoreV1Client
*extensionsv1beta1.ExtensionsV1beta1Client extensionsV1beta1 *extensionsv1beta1.ExtensionsV1beta1Client
*federationv1beta1.FederationV1beta1Client federationV1beta1 *federationv1beta1.FederationV1beta1Client
} }
// AutoscalingV1 retrieves the AutoscalingV1Client // AutoscalingV1 retrieves the AutoscalingV1Client
func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface { func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {
return c.AutoscalingV1Client return c.autoscalingV1
} }
// Deprecated: Autoscaling retrieves the default version of AutoscalingClient. // Deprecated: Autoscaling retrieves the default version of AutoscalingClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface { func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface {
return c.AutoscalingV1Client return c.autoscalingV1
} }
// BatchV1 retrieves the BatchV1Client // BatchV1 retrieves the BatchV1Client
func (c *Clientset) BatchV1() batchv1.BatchV1Interface { func (c *Clientset) BatchV1() batchv1.BatchV1Interface {
return c.BatchV1Client return c.batchV1
} }
// Deprecated: Batch retrieves the default version of BatchClient. // Deprecated: Batch retrieves the default version of BatchClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Batch() batchv1.BatchV1Interface { func (c *Clientset) Batch() batchv1.BatchV1Interface {
return c.BatchV1Client return c.batchV1
} }
// CoreV1 retrieves the CoreV1Client // CoreV1 retrieves the CoreV1Client
func (c *Clientset) CoreV1() corev1.CoreV1Interface { func (c *Clientset) CoreV1() corev1.CoreV1Interface {
return c.CoreV1Client return c.coreV1
} }
// Deprecated: Core retrieves the default version of CoreClient. // Deprecated: Core retrieves the default version of CoreClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Core() corev1.CoreV1Interface { func (c *Clientset) Core() corev1.CoreV1Interface {
return c.CoreV1Client return c.coreV1
} }
// ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client // ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client
func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface { func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface {
return c.ExtensionsV1beta1Client return c.extensionsV1beta1
} }
// Deprecated: Extensions retrieves the default version of ExtensionsClient. // Deprecated: Extensions retrieves the default version of ExtensionsClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface { func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface {
return c.ExtensionsV1beta1Client return c.extensionsV1beta1
} }
// FederationV1beta1 retrieves the FederationV1beta1Client // FederationV1beta1 retrieves the FederationV1beta1Client
func (c *Clientset) FederationV1beta1() federationv1beta1.FederationV1beta1Interface { func (c *Clientset) FederationV1beta1() federationv1beta1.FederationV1beta1Interface {
return c.FederationV1beta1Client return c.federationV1beta1
} }
// Deprecated: Federation retrieves the default version of FederationClient. // Deprecated: Federation retrieves the default version of FederationClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Federation() federationv1beta1.FederationV1beta1Interface { func (c *Clientset) Federation() federationv1beta1.FederationV1beta1Interface {
return c.FederationV1beta1Client return c.federationV1beta1
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -129,23 +129,23 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.AutoscalingV1Client, err = autoscalingv1.NewForConfig(&configShallowCopy) cs.autoscalingV1, err = autoscalingv1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.BatchV1Client, err = batchv1.NewForConfig(&configShallowCopy) cs.batchV1, err = batchv1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.CoreV1Client, err = corev1.NewForConfig(&configShallowCopy) cs.coreV1, err = corev1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.ExtensionsV1beta1Client, err = extensionsv1beta1.NewForConfig(&configShallowCopy) cs.extensionsV1beta1, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.FederationV1beta1Client, err = federationv1beta1.NewForConfig(&configShallowCopy) cs.federationV1beta1, err = federationv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -162,11 +162,11 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.AutoscalingV1Client = autoscalingv1.NewForConfigOrDie(c) cs.autoscalingV1 = autoscalingv1.NewForConfigOrDie(c)
cs.BatchV1Client = batchv1.NewForConfigOrDie(c) cs.batchV1 = batchv1.NewForConfigOrDie(c)
cs.CoreV1Client = corev1.NewForConfigOrDie(c) cs.coreV1 = corev1.NewForConfigOrDie(c)
cs.ExtensionsV1beta1Client = extensionsv1beta1.NewForConfigOrDie(c) cs.extensionsV1beta1 = extensionsv1beta1.NewForConfigOrDie(c)
cs.FederationV1beta1Client = federationv1beta1.NewForConfigOrDie(c) cs.federationV1beta1 = federationv1beta1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -175,11 +175,11 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.AutoscalingV1Client = autoscalingv1.New(c) cs.autoscalingV1 = autoscalingv1.New(c)
cs.BatchV1Client = batchv1.New(c) cs.batchV1 = batchv1.New(c)
cs.CoreV1Client = corev1.New(c) cs.coreV1 = corev1.New(c)
cs.ExtensionsV1beta1Client = extensionsv1beta1.New(c) cs.extensionsV1beta1 = extensionsv1beta1.New(c)
cs.FederationV1beta1Client = federationv1beta1.New(c) cs.federationV1beta1 = federationv1beta1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

150
pkg/client/clientset_generated/internalclientset/clientset.go
View File

@@ -61,96 +61,96 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*admissionregistrationinternalversion.AdmissionregistrationClient admissionregistration *admissionregistrationinternalversion.AdmissionregistrationClient
*coreinternalversion.CoreClient core *coreinternalversion.CoreClient
*appsinternalversion.AppsClient apps *appsinternalversion.AppsClient
*authenticationinternalversion.AuthenticationClient authentication *authenticationinternalversion.AuthenticationClient
*authorizationinternalversion.AuthorizationClient authorization *authorizationinternalversion.AuthorizationClient
*autoscalinginternalversion.AutoscalingClient autoscaling *autoscalinginternalversion.AutoscalingClient
*batchinternalversion.BatchClient batch *batchinternalversion.BatchClient
*certificatesinternalversion.CertificatesClient certificates *certificatesinternalversion.CertificatesClient
*extensionsinternalversion.ExtensionsClient extensions *extensionsinternalversion.ExtensionsClient
*networkinginternalversion.NetworkingClient networking *networkinginternalversion.NetworkingClient
*policyinternalversion.PolicyClient policy *policyinternalversion.PolicyClient
*rbacinternalversion.RbacClient rbac *rbacinternalversion.RbacClient
*schedulinginternalversion.SchedulingClient scheduling *schedulinginternalversion.SchedulingClient
*settingsinternalversion.SettingsClient settings *settingsinternalversion.SettingsClient
*storageinternalversion.StorageClient storage *storageinternalversion.StorageClient
} }
// Admissionregistration retrieves the AdmissionregistrationClient // Admissionregistration retrieves the AdmissionregistrationClient
func (c *Clientset) Admissionregistration() admissionregistrationinternalversion.AdmissionregistrationInterface { func (c *Clientset) Admissionregistration() admissionregistrationinternalversion.AdmissionregistrationInterface {
return c.AdmissionregistrationClient return c.admissionregistration
} }
// Core retrieves the CoreClient // Core retrieves the CoreClient
func (c *Clientset) Core() coreinternalversion.CoreInterface { func (c *Clientset) Core() coreinternalversion.CoreInterface {
return c.CoreClient return c.core
} }
// Apps retrieves the AppsClient // Apps retrieves the AppsClient
func (c *Clientset) Apps() appsinternalversion.AppsInterface { func (c *Clientset) Apps() appsinternalversion.AppsInterface {
return c.AppsClient return c.apps
} }
// Authentication retrieves the AuthenticationClient // Authentication retrieves the AuthenticationClient
func (c *Clientset) Authentication() authenticationinternalversion.AuthenticationInterface { func (c *Clientset) Authentication() authenticationinternalversion.AuthenticationInterface {
return c.AuthenticationClient return c.authentication
} }
// Authorization retrieves the AuthorizationClient // Authorization retrieves the AuthorizationClient
func (c *Clientset) Authorization() authorizationinternalversion.AuthorizationInterface { func (c *Clientset) Authorization() authorizationinternalversion.AuthorizationInterface {
return c.AuthorizationClient return c.authorization
} }
// Autoscaling retrieves the AutoscalingClient // Autoscaling retrieves the AutoscalingClient
func (c *Clientset) Autoscaling() autoscalinginternalversion.AutoscalingInterface { func (c *Clientset) Autoscaling() autoscalinginternalversion.AutoscalingInterface {
return c.AutoscalingClient return c.autoscaling
} }
// Batch retrieves the BatchClient // Batch retrieves the BatchClient
func (c *Clientset) Batch() batchinternalversion.BatchInterface { func (c *Clientset) Batch() batchinternalversion.BatchInterface {
return c.BatchClient return c.batch
} }
// Certificates retrieves the CertificatesClient // Certificates retrieves the CertificatesClient
func (c *Clientset) Certificates() certificatesinternalversion.CertificatesInterface { func (c *Clientset) Certificates() certificatesinternalversion.CertificatesInterface {
return c.CertificatesClient return c.certificates
} }
// Extensions retrieves the ExtensionsClient // Extensions retrieves the ExtensionsClient
func (c *Clientset) Extensions() extensionsinternalversion.ExtensionsInterface { func (c *Clientset) Extensions() extensionsinternalversion.ExtensionsInterface {
return c.ExtensionsClient return c.extensions
} }
// Networking retrieves the NetworkingClient // Networking retrieves the NetworkingClient
func (c *Clientset) Networking() networkinginternalversion.NetworkingInterface { func (c *Clientset) Networking() networkinginternalversion.NetworkingInterface {
return c.NetworkingClient return c.networking
} }
// Policy retrieves the PolicyClient // Policy retrieves the PolicyClient
func (c *Clientset) Policy() policyinternalversion.PolicyInterface { func (c *Clientset) Policy() policyinternalversion.PolicyInterface {
return c.PolicyClient return c.policy
} }
// Rbac retrieves the RbacClient // Rbac retrieves the RbacClient
func (c *Clientset) Rbac() rbacinternalversion.RbacInterface { func (c *Clientset) Rbac() rbacinternalversion.RbacInterface {
return c.RbacClient return c.rbac
} }
// Scheduling retrieves the SchedulingClient // Scheduling retrieves the SchedulingClient
func (c *Clientset) Scheduling() schedulinginternalversion.SchedulingInterface { func (c *Clientset) Scheduling() schedulinginternalversion.SchedulingInterface {
return c.SchedulingClient return c.scheduling
} }
// Settings retrieves the SettingsClient // Settings retrieves the SettingsClient
func (c *Clientset) Settings() settingsinternalversion.SettingsInterface { func (c *Clientset) Settings() settingsinternalversion.SettingsInterface {
return c.SettingsClient return c.settings
} }
// Storage retrieves the StorageClient // Storage retrieves the StorageClient
func (c *Clientset) Storage() storageinternalversion.StorageInterface { func (c *Clientset) Storage() storageinternalversion.StorageInterface {
return c.StorageClient return c.storage
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -169,63 +169,63 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.AdmissionregistrationClient, err = admissionregistrationinternalversion.NewForConfig(&configShallowCopy) cs.admissionregistration, err = admissionregistrationinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.CoreClient, err = coreinternalversion.NewForConfig(&configShallowCopy) cs.core, err = coreinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AppsClient, err = appsinternalversion.NewForConfig(&configShallowCopy) cs.apps, err = appsinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AuthenticationClient, err = authenticationinternalversion.NewForConfig(&configShallowCopy) cs.authentication, err = authenticationinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AuthorizationClient, err = authorizationinternalversion.NewForConfig(&configShallowCopy) cs.authorization, err = authorizationinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AutoscalingClient, err = autoscalinginternalversion.NewForConfig(&configShallowCopy) cs.autoscaling, err = autoscalinginternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.BatchClient, err = batchinternalversion.NewForConfig(&configShallowCopy) cs.batch, err = batchinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.CertificatesClient, err = certificatesinternalversion.NewForConfig(&configShallowCopy) cs.certificates, err = certificatesinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.ExtensionsClient, err = extensionsinternalversion.NewForConfig(&configShallowCopy) cs.extensions, err = extensionsinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.NetworkingClient, err = networkinginternalversion.NewForConfig(&configShallowCopy) cs.networking, err = networkinginternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.PolicyClient, err = policyinternalversion.NewForConfig(&configShallowCopy) cs.policy, err = policyinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.RbacClient, err = rbacinternalversion.NewForConfig(&configShallowCopy) cs.rbac, err = rbacinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.SchedulingClient, err = schedulinginternalversion.NewForConfig(&configShallowCopy) cs.scheduling, err = schedulinginternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.SettingsClient, err = settingsinternalversion.NewForConfig(&configShallowCopy) cs.settings, err = settingsinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.StorageClient, err = storageinternalversion.NewForConfig(&configShallowCopy) cs.storage, err = storageinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -242,21 +242,21 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.AdmissionregistrationClient = admissionregistrationinternalversion.NewForConfigOrDie(c) cs.admissionregistration = admissionregistrationinternalversion.NewForConfigOrDie(c)
cs.CoreClient = coreinternalversion.NewForConfigOrDie(c) cs.core = coreinternalversion.NewForConfigOrDie(c)
cs.AppsClient = appsinternalversion.NewForConfigOrDie(c) cs.apps = appsinternalversion.NewForConfigOrDie(c)
cs.AuthenticationClient = authenticationinternalversion.NewForConfigOrDie(c) cs.authentication = authenticationinternalversion.NewForConfigOrDie(c)
cs.AuthorizationClient = authorizationinternalversion.NewForConfigOrDie(c) cs.authorization = authorizationinternalversion.NewForConfigOrDie(c)
cs.AutoscalingClient = autoscalinginternalversion.NewForConfigOrDie(c) cs.autoscaling = autoscalinginternalversion.NewForConfigOrDie(c)
cs.BatchClient = batchinternalversion.NewForConfigOrDie(c) cs.batch = batchinternalversion.NewForConfigOrDie(c)
cs.CertificatesClient = certificatesinternalversion.NewForConfigOrDie(c) cs.certificates = certificatesinternalversion.NewForConfigOrDie(c)
cs.ExtensionsClient = extensionsinternalversion.NewForConfigOrDie(c) cs.extensions = extensionsinternalversion.NewForConfigOrDie(c)
cs.NetworkingClient = networkinginternalversion.NewForConfigOrDie(c) cs.networking = networkinginternalversion.NewForConfigOrDie(c)
cs.PolicyClient = policyinternalversion.NewForConfigOrDie(c) cs.policy = policyinternalversion.NewForConfigOrDie(c)
cs.RbacClient = rbacinternalversion.NewForConfigOrDie(c) cs.rbac = rbacinternalversion.NewForConfigOrDie(c)
cs.SchedulingClient = schedulinginternalversion.NewForConfigOrDie(c) cs.scheduling = schedulinginternalversion.NewForConfigOrDie(c)
cs.SettingsClient = settingsinternalversion.NewForConfigOrDie(c) cs.settings = settingsinternalversion.NewForConfigOrDie(c)
cs.StorageClient = storageinternalversion.NewForConfigOrDie(c) cs.storage = storageinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -265,21 +265,21 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.AdmissionregistrationClient = admissionregistrationinternalversion.New(c) cs.admissionregistration = admissionregistrationinternalversion.New(c)
cs.CoreClient = coreinternalversion.New(c) cs.core = coreinternalversion.New(c)
cs.AppsClient = appsinternalversion.New(c) cs.apps = appsinternalversion.New(c)
cs.AuthenticationClient = authenticationinternalversion.New(c) cs.authentication = authenticationinternalversion.New(c)
cs.AuthorizationClient = authorizationinternalversion.New(c) cs.authorization = authorizationinternalversion.New(c)
cs.AutoscalingClient = autoscalinginternalversion.New(c) cs.autoscaling = autoscalinginternalversion.New(c)
cs.BatchClient = batchinternalversion.New(c) cs.batch = batchinternalversion.New(c)
cs.CertificatesClient = certificatesinternalversion.New(c) cs.certificates = certificatesinternalversion.New(c)
cs.ExtensionsClient = extensionsinternalversion.New(c) cs.extensions = extensionsinternalversion.New(c)
cs.NetworkingClient = networkinginternalversion.New(c) cs.networking = networkinginternalversion.New(c)
cs.PolicyClient = policyinternalversion.New(c) cs.policy = policyinternalversion.New(c)
cs.RbacClient = rbacinternalversion.New(c) cs.rbac = rbacinternalversion.New(c)
cs.SchedulingClient = schedulinginternalversion.New(c) cs.scheduling = schedulinginternalversion.New(c)
cs.SettingsClient = settingsinternalversion.New(c) cs.settings = settingsinternalversion.New(c)
cs.StorageClient = storageinternalversion.New(c) cs.storage = storageinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

2
pkg/controller/deployment/deployment_controller.go
View File

@@ -355,7 +355,7 @@ func (dc *DeploymentController) deletePod(obj interface{}) {
glog.V(4).Infof("Pod %s deleted.", pod.Name) glog.V(4).Infof("Pod %s deleted.", pod.Name)
if d := dc.getDeploymentForPod(pod); d != nil && d.Spec.Strategy.Type == extensions.RecreateDeploymentStrategyType { if d := dc.getDeploymentForPod(pod); d != nil && d.Spec.Strategy.Type == extensions.RecreateDeploymentStrategyType {
// Sync if this Deployment now has no more Pods. // Sync if this Deployment now has no more Pods.
rsList, err := util.ListReplicaSets(d, util.RsListFromClient(dc.client)) rsList, err := util.ListReplicaSets(d, util.RsListFromClient(dc.client.ExtensionsV1beta1()))
if err != nil { if err != nil {
return return
} }

11
pkg/controller/deployment/util/deployment_util.go
View File

@@ -37,6 +37,7 @@ import (
"k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/util/wait"
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
"k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/kubernetes/scheme"
extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
corelisters "k8s.io/client-go/listers/core/v1" corelisters "k8s.io/client-go/listers/core/v1"
extensionslisters "k8s.io/client-go/listers/extensions/v1beta1" extensionslisters "k8s.io/client-go/listers/extensions/v1beta1"
"k8s.io/client-go/util/integer" "k8s.io/client-go/util/integer"
@@ -497,7 +498,7 @@ func getReplicaSetFraction(rs extensions.ReplicaSet, d extensions.Deployment) in
// GetAllReplicaSets returns the old and new replica sets targeted by the given Deployment. It gets PodList and ReplicaSetList from client interface. // GetAllReplicaSets returns the old and new replica sets targeted by the given Deployment. It gets PodList and ReplicaSetList from client interface.
// Note that the first set of old replica sets doesn't include the ones with no pods, and the second set of old replica sets include all old replica sets. // Note that the first set of old replica sets doesn't include the ones with no pods, and the second set of old replica sets include all old replica sets.
// The third returned value is the new replica set, and it may be nil if it doesn't exist yet. // The third returned value is the new replica set, and it may be nil if it doesn't exist yet.
func GetAllReplicaSets(deployment *extensions.Deployment, c clientset.Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, *extensions.ReplicaSet, error) { func GetAllReplicaSets(deployment *extensions.Deployment, c extensionsv1beta1.ExtensionsV1beta1Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, *extensions.ReplicaSet, error) {
rsList, err := ListReplicaSets(deployment, RsListFromClient(c)) rsList, err := ListReplicaSets(deployment, RsListFromClient(c))
if err != nil { if err != nil {
return nil, nil, nil, err return nil, nil, nil, err
@@ -515,7 +516,7 @@ func GetAllReplicaSets(deployment *extensions.Deployment, c clientset.Interface)
// GetOldReplicaSets returns the old replica sets targeted by the given Deployment; get PodList and ReplicaSetList from client interface. // GetOldReplicaSets returns the old replica sets targeted by the given Deployment; get PodList and ReplicaSetList from client interface.
// Note that the first set of old replica sets doesn't include the ones with no pods, and the second set of old replica sets include all old replica sets. // Note that the first set of old replica sets doesn't include the ones with no pods, and the second set of old replica sets include all old replica sets.
func GetOldReplicaSets(deployment *extensions.Deployment, c clientset.Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, error) { func GetOldReplicaSets(deployment *extensions.Deployment, c extensionsv1beta1.ExtensionsV1beta1Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, error) {
rsList, err := ListReplicaSets(deployment, RsListFromClient(c)) rsList, err := ListReplicaSets(deployment, RsListFromClient(c))
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
@@ -525,7 +526,7 @@ func GetOldReplicaSets(deployment *extensions.Deployment, c clientset.Interface)
// GetNewReplicaSet returns a replica set that matches the intent of the given deployment; get ReplicaSetList from client interface. // GetNewReplicaSet returns a replica set that matches the intent of the given deployment; get ReplicaSetList from client interface.
// Returns nil if the new replica set doesn't exist yet. // Returns nil if the new replica set doesn't exist yet.
func GetNewReplicaSet(deployment *extensions.Deployment, c clientset.Interface) (*extensions.ReplicaSet, error) { func GetNewReplicaSet(deployment *extensions.Deployment, c extensionsv1beta1.ExtensionsV1beta1Interface) (*extensions.ReplicaSet, error) {
rsList, err := ListReplicaSets(deployment, RsListFromClient(c)) rsList, err := ListReplicaSets(deployment, RsListFromClient(c))
if err != nil { if err != nil {
return nil, err return nil, err
@@ -534,9 +535,9 @@ func GetNewReplicaSet(deployment *extensions.Deployment, c clientset.Interface)
} }
// RsListFromClient returns an rsListFunc that wraps the given client. // RsListFromClient returns an rsListFunc that wraps the given client.
func RsListFromClient(c clientset.Interface) RsListFunc { func RsListFromClient(c extensionsv1beta1.ExtensionsV1beta1Interface) RsListFunc {
return func(namespace string, options metav1.ListOptions) ([]*extensions.ReplicaSet, error) { return func(namespace string, options metav1.ListOptions) ([]*extensions.ReplicaSet, error) {
rsList, err := c.Extensions().ReplicaSets(namespace).List(options) rsList, err := c.ReplicaSets(namespace).List(options)
if err != nil { if err != nil {
return nil, err return nil, err
} }

4
pkg/controller/deployment/util/deployment_util_test.go
View File

@@ -288,7 +288,7 @@ func TestGetNewRS(t *testing.T) {
fakeClient = addListRSReactor(fakeClient, test.objs[1]) fakeClient = addListRSReactor(fakeClient, test.objs[1])
fakeClient = addUpdatePodsReactor(fakeClient) fakeClient = addUpdatePodsReactor(fakeClient)
fakeClient = addUpdateRSReactor(fakeClient) fakeClient = addUpdateRSReactor(fakeClient)
rs, err := GetNewReplicaSet(&newDeployment, fakeClient) rs, err := GetNewReplicaSet(&newDeployment, fakeClient.ExtensionsV1beta1())
if err != nil { if err != nil {
t.Errorf("In test case %s, got unexpected error %v", test.Name, err) t.Errorf("In test case %s, got unexpected error %v", test.Name, err)
} }
@@ -361,7 +361,7 @@ func TestGetOldRSs(t *testing.T) {
fakeClient = addListRSReactor(fakeClient, test.objs[0]) fakeClient = addListRSReactor(fakeClient, test.objs[0])
fakeClient = addGetRSReactor(fakeClient, test.objs[0]) fakeClient = addGetRSReactor(fakeClient, test.objs[0])
fakeClient = addUpdateRSReactor(fakeClient) fakeClient = addUpdateRSReactor(fakeClient)
_, rss, err := GetOldReplicaSets(&newDeployment, fakeClient) _, rss, err := GetOldReplicaSets(&newDeployment, fakeClient.ExtensionsV1beta1())
if err != nil { if err != nil {
t.Errorf("In test case %s, got unexpected error %v", test.Name, err) t.Errorf("In test case %s, got unexpected error %v", test.Name, err)
} }

2
pkg/kubectl/BUILD
View File

@@ -172,9 +172,7 @@ go_library(
"//vendor/k8s.io/apimachinery/pkg/util/validation:go_default_library", "//vendor/k8s.io/apimachinery/pkg/util/validation:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library", "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/watch:go_default_library", "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
"//vendor/k8s.io/client-go/kubernetes:go_default_library",
"//vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta1:go_default_library", "//vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta1:go_default_library",
"//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
"//vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1:go_default_library", "//vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1:go_default_library",
"//vendor/k8s.io/client-go/rest:go_default_library", "//vendor/k8s.io/client-go/rest:go_default_library",
"//vendor/k8s.io/client-go/util/integer:go_default_library", "//vendor/k8s.io/client-go/util/integer:go_default_library",

22
pkg/kubectl/cmd/testing/fake.go
View File

@@ -587,17 +587,17 @@ func (f *fakeAPIFactory) ClientSet() (internalclientset.Interface, error) {
// version. // version.
fakeClient := f.tf.Client.(*fake.RESTClient) fakeClient := f.tf.Client.(*fake.RESTClient)
clientset := internalclientset.NewForConfigOrDie(f.tf.ClientConfig) clientset := internalclientset.NewForConfigOrDie(f.tf.ClientConfig)
clientset.CoreClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Core().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.AuthenticationClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Authentication().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.AuthorizationClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Authorization().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.AutoscalingClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Autoscaling().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.BatchClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Batch().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.CertificatesClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Certificates().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.ExtensionsClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Extensions().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.RbacClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Rbac().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.StorageClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Storage().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.AppsClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Apps().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.PolicyClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.Policy().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.DiscoveryClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client clientset.DiscoveryClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
return clientset, f.tf.Err return clientset, f.tf.Err
} }

20
pkg/kubectl/history.go
View File

@@ -31,7 +31,8 @@ import (
"k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/json" "k8s.io/apimachinery/pkg/util/json"
"k8s.io/apimachinery/pkg/util/strategicpatch" "k8s.io/apimachinery/pkg/util/strategicpatch"
externalclientset "k8s.io/client-go/kubernetes" clientappsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
clientextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
k8s_api_v1 "k8s.io/kubernetes/pkg/api/v1" k8s_api_v1 "k8s.io/kubernetes/pkg/api/v1"
"k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/apps"
@@ -71,12 +72,12 @@ type DeploymentHistoryViewer struct {
// ViewHistory returns a revision-to-replicaset map as the revision history of a deployment // ViewHistory returns a revision-to-replicaset map as the revision history of a deployment
// TODO: this should be a describer // TODO: this should be a describer
func (h *DeploymentHistoryViewer) ViewHistory(namespace, name string, revision int64) (string, error) { func (h *DeploymentHistoryViewer) ViewHistory(namespace, name string, revision int64) (string, error) {
versionedClient := versionedClientsetForDeployment(h.c) versionedExtensionsClient := versionedExtensionsClientV1beta1(h.c)
deployment, err := versionedClient.Extensions().Deployments(namespace).Get(name, metav1.GetOptions{}) deployment, err := versionedExtensionsClient.Deployments(namespace).Get(name, metav1.GetOptions{})
if err != nil { if err != nil {
return "", fmt.Errorf("failed to retrieve deployment %s: %v", name, err) return "", fmt.Errorf("failed to retrieve deployment %s: %v", name, err)
} }
_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, versionedClient) _, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, versionedExtensionsClient)
if err != nil { if err != nil {
return "", fmt.Errorf("failed to retrieve replica sets from deployment %s: %v", name, err) return "", fmt.Errorf("failed to retrieve replica sets from deployment %s: %v", name, err)
} }
@@ -153,8 +154,9 @@ type DaemonSetHistoryViewer struct {
// ViewHistory returns a revision-to-history map as the revision history of a deployment // ViewHistory returns a revision-to-history map as the revision history of a deployment
// TODO: this should be a describer // TODO: this should be a describer
func (h *DaemonSetHistoryViewer) ViewHistory(namespace, name string, revision int64) (string, error) { func (h *DaemonSetHistoryViewer) ViewHistory(namespace, name string, revision int64) (string, error) {
versionedClient := versionedClientsetForDaemonSet(h.c) versionedExtensionsClient := versionedExtensionsClientV1beta1(h.c)
ds, allHistory, err := controlledHistories(versionedClient, namespace, name) versionedAppsClient := versionedAppsClientV1beta1(h.c)
ds, allHistory, err := controlledHistories(versionedExtensionsClient, versionedAppsClient, namespace, name)
if err != nil { if err != nil {
return "", fmt.Errorf("unable to find history controlled by DaemonSet %s: %v", name, err) return "", fmt.Errorf("unable to find history controlled by DaemonSet %s: %v", name, err)
} }
@@ -256,8 +258,8 @@ func (h *StatefulSetHistoryViewer) ViewHistory(namespace, name string, revision
} }
// controlledHistories returns all ControllerRevisions controlled by the given DaemonSet // controlledHistories returns all ControllerRevisions controlled by the given DaemonSet
func controlledHistories(c externalclientset.Interface, namespace, name string) (*extensionsv1beta1.DaemonSet, []*appsv1beta1.ControllerRevision, error) { func controlledHistories(extensions clientextensionsv1beta1.ExtensionsV1beta1Interface, apps clientappsv1beta1.AppsV1beta1Interface, namespace, name string) (*extensionsv1beta1.DaemonSet, []*appsv1beta1.ControllerRevision, error) {
ds, err := c.ExtensionsV1beta1().DaemonSets(namespace).Get(name, metav1.GetOptions{}) ds, err := extensions.DaemonSets(namespace).Get(name, metav1.GetOptions{})
if err != nil { if err != nil {
return nil, nil, fmt.Errorf("failed to retrieve DaemonSet %s: %v", name, err) return nil, nil, fmt.Errorf("failed to retrieve DaemonSet %s: %v", name, err)
} }
@@ -266,7 +268,7 @@ func controlledHistories(c externalclientset.Interface, namespace, name string)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
historyList, err := c.AppsV1beta1().ControllerRevisions(ds.Namespace).List(metav1.ListOptions{LabelSelector: selector.String()}) historyList, err := apps.ControllerRevisions(ds.Namespace).List(metav1.ListOptions{LabelSelector: selector.String()})
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }

11
pkg/kubectl/rollback.go
View File

@@ -151,8 +151,8 @@ func simpleDryRun(deployment *extensions.Deployment, c clientset.Interface, toRe
if err := api.Scheme.Convert(deployment, externalDeployment, nil); err != nil { if err := api.Scheme.Convert(deployment, externalDeployment, nil); err != nil {
return "", fmt.Errorf("failed to convert deployment, %v", err) return "", fmt.Errorf("failed to convert deployment, %v", err)
} }
versionedClient := versionedClientsetForDeployment(c) versionedExtensionsClient := versionedExtensionsClientV1beta1(c)
_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(externalDeployment, versionedClient) _, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(externalDeployment, versionedExtensionsClient)
if err != nil { if err != nil {
return "", fmt.Errorf("failed to retrieve replica sets from deployment %s: %v", deployment.Name, err) return "", fmt.Errorf("failed to retrieve replica sets from deployment %s: %v", deployment.Name, err)
} }
@@ -221,8 +221,9 @@ func (r *DaemonSetRollbacker) Rollback(obj runtime.Object, updatedAnnotations ma
if !ok { if !ok {
return "", fmt.Errorf("passed object is not a DaemonSet: %#v", obj) return "", fmt.Errorf("passed object is not a DaemonSet: %#v", obj)
} }
versionedClient := versionedClientsetForDaemonSet(r.c) versionedExtensionsClient := versionedExtensionsClientV1beta1(r.c)
versionedDS, allHistory, err := controlledHistories(versionedClient, ds.Namespace, ds.Name) versionedAppsClient := versionedAppsClientV1beta1(r.c)
versionedDS, allHistory, err := controlledHistories(versionedExtensionsClient, versionedAppsClient, ds.Namespace, ds.Name)
if err != nil { if err != nil {
return "", fmt.Errorf("unable to find history controlled by DaemonSet %s: %v", ds.Name, err) return "", fmt.Errorf("unable to find history controlled by DaemonSet %s: %v", ds.Name, err)
} }
@@ -275,7 +276,7 @@ func (r *DaemonSetRollbacker) Rollback(obj runtime.Object, updatedAnnotations ma
} }
// Restore revision // Restore revision
if _, err = versionedClient.ExtensionsV1beta1().DaemonSets(ds.Namespace).Patch(ds.Name, types.StrategicMergePatchType, toHistory.Data.Raw); err != nil { if _, err = versionedExtensionsClient.DaemonSets(ds.Namespace).Patch(ds.Name, types.StrategicMergePatchType, toHistory.Data.Raw); err != nil {
return "", fmt.Errorf("failed restoring revision %d: %v", toRevision, err) return "", fmt.Errorf("failed restoring revision %d: %v", toRevision, err)
} }

2
pkg/kubectl/rolling_updater_test.go
View File

@@ -1501,7 +1501,7 @@ func TestUpdateRcWithRetries(t *testing.T) {
clientset := internalclientset.New(restClient) clientset := internalclientset.New(restClient)
if rc, err := updateRcWithRetries( if rc, err := updateRcWithRetries(
clientset, "default", rc, func(c *api.ReplicationController) { clientset.Core(), "default", rc, func(c *api.ReplicationController) {
c.Spec.Selector["baz"] = "foobar" c.Spec.Selector["baz"] = "foobar"
}); err != nil { }); err != nil {
t.Errorf("unexpected error: %v", err) t.Errorf("unexpected error: %v", err)

26
pkg/kubectl/versioned_client.go
View File

@@ -17,29 +17,23 @@ limitations under the License.
package kubectl package kubectl
import ( import (
externalclientset "k8s.io/client-go/kubernetes" clientappsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
apps "k8s.io/client-go/kubernetes/typed/apps/v1beta1" clientextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
core "k8s.io/client-go/kubernetes/typed/core/v1"
extensions "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
internalclientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" internalclientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
) )
func versionedClientsetForDeployment(internalClient internalclientset.Interface) externalclientset.Interface { // TODO: get rid of this and plumb the caller correctly
func versionedExtensionsClientV1beta1(internalClient internalclientset.Interface) clientextensionsv1beta1.ExtensionsV1beta1Interface {
if internalClient == nil { if internalClient == nil {
return &externalclientset.Clientset{} return &clientextensionsv1beta1.ExtensionsV1beta1Client{}
}
return &externalclientset.Clientset{
CoreV1Client: core.New(internalClient.Core().RESTClient()),
ExtensionsV1beta1Client: extensions.New(internalClient.Extensions().RESTClient()),
} }
return clientextensionsv1beta1.New(internalClient.Extensions().RESTClient())
} }
func versionedClientsetForDaemonSet(internalClient internalclientset.Interface) externalclientset.Interface { // TODO: get rid of this and plumb the caller correctly
func versionedAppsClientV1beta1(internalClient internalclientset.Interface) clientappsv1beta1.AppsV1beta1Interface {
if internalClient == nil { if internalClient == nil {
return &externalclientset.Clientset{} return &clientappsv1beta1.AppsV1beta1Client{}
}
return &externalclientset.Clientset{
AppsV1beta1Client: apps.New(internalClient.Apps().RESTClient()),
ExtensionsV1beta1Client: extensions.New(internalClient.Extensions().RESTClient()),
} }
return clientappsv1beta1.New(internalClient.Apps().RESTClient())
} }

2
pkg/printers/internalversion/BUILD
View File

@@ -112,8 +112,6 @@ go_library(
"//vendor/k8s.io/apimachinery/pkg/util/intstr:go_default_library", "//vendor/k8s.io/apimachinery/pkg/util/intstr:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library", "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
"//vendor/k8s.io/client-go/dynamic:go_default_library", "//vendor/k8s.io/client-go/dynamic:go_default_library",
"//vendor/k8s.io/client-go/kubernetes:go_default_library",
"//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
"//vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1:go_default_library", "//vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1:go_default_library",
], ],
) )

24
pkg/printers/internalversion/describe.go
View File

@@ -46,9 +46,7 @@ import (
"k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/sets"
"k8s.io/client-go/dynamic" "k8s.io/client-go/dynamic"
versionedclientset "k8s.io/client-go/kubernetes" clientextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
coreclientset "k8s.io/client-go/kubernetes/typed/core/v1"
extensionsclientset "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
federation "k8s.io/kubernetes/federation/apis/federation/v1beta1" federation "k8s.io/kubernetes/federation/apis/federation/v1beta1"
fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_clientset" fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_clientset"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
@@ -141,12 +139,12 @@ func describerMap(c clientset.Interface) map[schema.GroupKind]printers.Describer
extensions.Kind("PodSecurityPolicy"): &PodSecurityPolicyDescriber{c}, extensions.Kind("PodSecurityPolicy"): &PodSecurityPolicyDescriber{c},
autoscaling.Kind("HorizontalPodAutoscaler"): &HorizontalPodAutoscalerDescriber{c}, autoscaling.Kind("HorizontalPodAutoscaler"): &HorizontalPodAutoscalerDescriber{c},
extensions.Kind("DaemonSet"): &DaemonSetDescriber{c}, extensions.Kind("DaemonSet"): &DaemonSetDescriber{c},
extensions.Kind("Deployment"): &DeploymentDescriber{c, versionedClientsetForDeployment(c)}, extensions.Kind("Deployment"): &DeploymentDescriber{c, versionedExtensionsClientV1beta1(c)},
extensions.Kind("Ingress"): &IngressDescriber{c}, extensions.Kind("Ingress"): &IngressDescriber{c},
batch.Kind("Job"): &JobDescriber{c}, batch.Kind("Job"): &JobDescriber{c},
batch.Kind("CronJob"): &CronJobDescriber{c}, batch.Kind("CronJob"): &CronJobDescriber{c},
apps.Kind("StatefulSet"): &StatefulSetDescriber{c}, apps.Kind("StatefulSet"): &StatefulSetDescriber{c},
apps.Kind("Deployment"): &DeploymentDescriber{c, versionedClientsetForDeployment(c)}, apps.Kind("Deployment"): &DeploymentDescriber{c, versionedExtensionsClientV1beta1(c)},
apps.Kind("DaemonSet"): &DaemonSetDescriber{c}, apps.Kind("DaemonSet"): &DaemonSetDescriber{c},
certificates.Kind("CertificateSigningRequest"): &CertificateSigningRequestDescriber{c}, certificates.Kind("CertificateSigningRequest"): &CertificateSigningRequestDescriber{c},
storage.Kind("StorageClass"): &StorageClassDescriber{c}, storage.Kind("StorageClass"): &StorageClassDescriber{c},
@@ -2836,11 +2834,11 @@ func DescribeEvents(el *api.EventList, w PrefixWriter) {
// DeploymentDescriber generates information about a deployment. // DeploymentDescriber generates information about a deployment.
type DeploymentDescriber struct { type DeploymentDescriber struct {
clientset.Interface clientset.Interface
versionedClient versionedclientset.Interface extensionV1beta1Client clientextensionsv1beta1.ExtensionsV1beta1Interface
} }
func (dd *DeploymentDescriber) Describe(namespace, name string, describerSettings printers.DescriberSettings) (string, error) { func (dd *DeploymentDescriber) Describe(namespace, name string, describerSettings printers.DescriberSettings) (string, error) {
d, err := dd.versionedClient.Extensions().Deployments(namespace).Get(name, metav1.GetOptions{}) d, err := dd.extensionV1beta1Client.Deployments(namespace).Get(name, metav1.GetOptions{})
if err != nil { if err != nil {
return "", err return "", err
} }
@@ -2885,7 +2883,7 @@ func describeDeployment(d *versionedextension.Deployment, selector labels.Select
w.Write(LEVEL_1, "%v \t%v\t%v\n", c.Type, c.Status, c.Reason) w.Write(LEVEL_1, "%v \t%v\t%v\n", c.Type, c.Status, c.Reason)
} }
} }
oldRSs, _, newRS, err := deploymentutil.GetAllReplicaSets(d, dd.versionedClient) oldRSs, _, newRS, err := deploymentutil.GetAllReplicaSets(d, dd.extensionV1beta1Client)
if err == nil { if err == nil {
w.Write(LEVEL_0, "OldReplicaSets:\t%s\n", printReplicaSetsByLabels(oldRSs)) w.Write(LEVEL_0, "OldReplicaSets:\t%s\n", printReplicaSetsByLabels(oldRSs))
var newRSs []*versionedextension.ReplicaSet var newRSs []*versionedextension.ReplicaSet
@@ -3650,14 +3648,12 @@ func (list SortableVolumeMounts) Less(i, j int) bool {
return list[i].MountPath < list[j].MountPath return list[i].MountPath < list[j].MountPath
} }
func versionedClientsetForDeployment(internalClient clientset.Interface) versionedclientset.Interface { // TODO: get rid of this and plumb the caller correctly
func versionedExtensionsClientV1beta1(internalClient clientset.Interface) clientextensionsv1beta1.ExtensionsV1beta1Interface {
if internalClient == nil { if internalClient == nil {
return &versionedclientset.Clientset{} return &clientextensionsv1beta1.ExtensionsV1beta1Client{}
}
return &versionedclientset.Clientset{
CoreV1Client: coreclientset.New(internalClient.Core().RESTClient()),
ExtensionsV1beta1Client: extensionsclientset.New(internalClient.Extensions().RESTClient()),
} }
return clientextensionsv1beta1.New(internalClient.Extensions().RESTClient())
} }
var maxAnnotationLen = 200 var maxAnnotationLen = 200

4
pkg/printers/internalversion/describe_test.go
View File

@@ -774,7 +774,7 @@ func TestDescribeDeployment(t *testing.T) {
}, },
}, },
}) })
d := DeploymentDescriber{fake, versionedFake} d := DeploymentDescriber{fake, versionedFake.ExtensionsV1beta1()}
out, err := d.Describe("foo", "bar", printers.DescriberSettings{ShowEvents: true}) out, err := d.Describe("foo", "bar", printers.DescriberSettings{ShowEvents: true})
if err != nil { if err != nil {
t.Errorf("unexpected error: %v", err) t.Errorf("unexpected error: %v", err)
@@ -1267,7 +1267,7 @@ func TestDescribeEvents(t *testing.T) {
Replicas: utilpointer.Int32Ptr(1), Replicas: utilpointer.Int32Ptr(1),
Selector: &metav1.LabelSelector{}, Selector: &metav1.LabelSelector{},
}, },
}), }).ExtensionsV1beta1(),
}, },
"EndpointsDescriber": &EndpointsDescriber{ "EndpointsDescriber": &EndpointsDescriber{
fake.NewSimpleClientset(&api.Endpoints{ fake.NewSimpleClientset(&api.Endpoints{

4
staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go
View File

@@ -184,10 +184,10 @@ func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget)
} }
crdController := NewDiscoveryController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), versionDiscoveryHandler, groupDiscoveryHandler, c.GenericConfig.RequestContextMapper) crdController := NewDiscoveryController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), versionDiscoveryHandler, groupDiscoveryHandler, c.GenericConfig.RequestContextMapper)
namingController := status.NewNamingConditionController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), crdClient) namingController := status.NewNamingConditionController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), crdClient.Apiextensions())
finalizingController := finalizer.NewCRDFinalizer( finalizingController := finalizer.NewCRDFinalizer(
s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(),
crdClient, crdClient.Apiextensions(),
crdHandler, crdHandler,
) )

12
staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go
View File

@@ -35,18 +35,18 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*apiextensionsv1beta1.ApiextensionsV1beta1Client apiextensionsV1beta1 *apiextensionsv1beta1.ApiextensionsV1beta1Client
} }
// ApiextensionsV1beta1 retrieves the ApiextensionsV1beta1Client // ApiextensionsV1beta1 retrieves the ApiextensionsV1beta1Client
func (c *Clientset) ApiextensionsV1beta1() apiextensionsv1beta1.ApiextensionsV1beta1Interface { func (c *Clientset) ApiextensionsV1beta1() apiextensionsv1beta1.ApiextensionsV1beta1Interface {
return c.ApiextensionsV1beta1Client return c.apiextensionsV1beta1
} }
// Deprecated: Apiextensions retrieves the default version of ApiextensionsClient. // Deprecated: Apiextensions retrieves the default version of ApiextensionsClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Apiextensions() apiextensionsv1beta1.ApiextensionsV1beta1Interface { func (c *Clientset) Apiextensions() apiextensionsv1beta1.ApiextensionsV1beta1Interface {
return c.ApiextensionsV1beta1Client return c.apiextensionsV1beta1
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.ApiextensionsV1beta1Client, err = apiextensionsv1beta1.NewForConfig(&configShallowCopy) cs.apiextensionsV1beta1, err = apiextensionsv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.ApiextensionsV1beta1Client = apiextensionsv1beta1.NewForConfigOrDie(c) cs.apiextensionsV1beta1 = apiextensionsv1beta1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.ApiextensionsV1beta1Client = apiextensionsv1beta1.New(c) cs.apiextensionsV1beta1 = apiextensionsv1beta1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

10
staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/internalclientset/clientset.go
View File

@@ -33,12 +33,12 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*apiextensionsinternalversion.ApiextensionsClient apiextensions *apiextensionsinternalversion.ApiextensionsClient
} }
// Apiextensions retrieves the ApiextensionsClient // Apiextensions retrieves the ApiextensionsClient
func (c *Clientset) Apiextensions() apiextensionsinternalversion.ApiextensionsInterface { func (c *Clientset) Apiextensions() apiextensionsinternalversion.ApiextensionsInterface {
return c.ApiextensionsClient return c.apiextensions
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.ApiextensionsClient, err = apiextensionsinternalversion.NewForConfig(&configShallowCopy) cs.apiextensions, err = apiextensionsinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.ApiextensionsClient = apiextensionsinternalversion.NewForConfigOrDie(c) cs.apiextensions = apiextensionsinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.ApiextensionsClient = apiextensionsinternalversion.New(c) cs.apiextensions = apiextensionsinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

250
staging/src/k8s.io/client-go/kubernetes/clientset.go
View File

@@ -105,228 +105,228 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Client admissionregistrationV1alpha1 *admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Client
*appsv1beta1.AppsV1beta1Client appsV1beta1 *appsv1beta1.AppsV1beta1Client
*appsv1beta2.AppsV1beta2Client appsV1beta2 *appsv1beta2.AppsV1beta2Client
*authenticationv1.AuthenticationV1Client authenticationV1 *authenticationv1.AuthenticationV1Client
*authenticationv1beta1.AuthenticationV1beta1Client authenticationV1beta1 *authenticationv1beta1.AuthenticationV1beta1Client
*authorizationv1.AuthorizationV1Client authorizationV1 *authorizationv1.AuthorizationV1Client
*authorizationv1beta1.AuthorizationV1beta1Client authorizationV1beta1 *authorizationv1beta1.AuthorizationV1beta1Client
*autoscalingv1.AutoscalingV1Client autoscalingV1 *autoscalingv1.AutoscalingV1Client
*autoscalingv2alpha1.AutoscalingV2alpha1Client autoscalingV2alpha1 *autoscalingv2alpha1.AutoscalingV2alpha1Client
*batchv1.BatchV1Client batchV1 *batchv1.BatchV1Client
*batchv2alpha1.BatchV2alpha1Client batchV2alpha1 *batchv2alpha1.BatchV2alpha1Client
*certificatesv1beta1.CertificatesV1beta1Client certificatesV1beta1 *certificatesv1beta1.CertificatesV1beta1Client
*corev1.CoreV1Client coreV1 *corev1.CoreV1Client
*extensionsv1beta1.ExtensionsV1beta1Client extensionsV1beta1 *extensionsv1beta1.ExtensionsV1beta1Client
*networkingv1.NetworkingV1Client networkingV1 *networkingv1.NetworkingV1Client
*policyv1beta1.PolicyV1beta1Client policyV1beta1 *policyv1beta1.PolicyV1beta1Client
*rbacv1beta1.RbacV1beta1Client rbacV1beta1 *rbacv1beta1.RbacV1beta1Client
*rbacv1alpha1.RbacV1alpha1Client rbacV1alpha1 *rbacv1alpha1.RbacV1alpha1Client
*schedulingv1alpha1.SchedulingV1alpha1Client schedulingV1alpha1 *schedulingv1alpha1.SchedulingV1alpha1Client
*settingsv1alpha1.SettingsV1alpha1Client settingsV1alpha1 *settingsv1alpha1.SettingsV1alpha1Client
*storagev1beta1.StorageV1beta1Client storageV1beta1 *storagev1beta1.StorageV1beta1Client
*storagev1.StorageV1Client storageV1 *storagev1.StorageV1Client
} }
// AdmissionregistrationV1alpha1 retrieves the AdmissionregistrationV1alpha1Client // AdmissionregistrationV1alpha1 retrieves the AdmissionregistrationV1alpha1Client
func (c *Clientset) AdmissionregistrationV1alpha1() admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Interface { func (c *Clientset) AdmissionregistrationV1alpha1() admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Interface {
return c.AdmissionregistrationV1alpha1Client return c.admissionregistrationV1alpha1
} }
// Deprecated: Admissionregistration retrieves the default version of AdmissionregistrationClient. // Deprecated: Admissionregistration retrieves the default version of AdmissionregistrationClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Admissionregistration() admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Interface { func (c *Clientset) Admissionregistration() admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Interface {
return c.AdmissionregistrationV1alpha1Client return c.admissionregistrationV1alpha1
} }
// AppsV1beta1 retrieves the AppsV1beta1Client // AppsV1beta1 retrieves the AppsV1beta1Client
func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface { func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {
return c.AppsV1beta1Client return c.appsV1beta1
} }
// AppsV1beta2 retrieves the AppsV1beta2Client // AppsV1beta2 retrieves the AppsV1beta2Client
func (c *Clientset) AppsV1beta2() appsv1beta2.AppsV1beta2Interface { func (c *Clientset) AppsV1beta2() appsv1beta2.AppsV1beta2Interface {
return c.AppsV1beta2Client return c.appsV1beta2
} }
// Deprecated: Apps retrieves the default version of AppsClient. // Deprecated: Apps retrieves the default version of AppsClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Apps() appsv1beta2.AppsV1beta2Interface { func (c *Clientset) Apps() appsv1beta2.AppsV1beta2Interface {
return c.AppsV1beta2Client return c.appsV1beta2
} }
// AuthenticationV1 retrieves the AuthenticationV1Client // AuthenticationV1 retrieves the AuthenticationV1Client
func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface { func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
return c.AuthenticationV1Client return c.authenticationV1
} }
// Deprecated: Authentication retrieves the default version of AuthenticationClient. // Deprecated: Authentication retrieves the default version of AuthenticationClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Authentication() authenticationv1.AuthenticationV1Interface { func (c *Clientset) Authentication() authenticationv1.AuthenticationV1Interface {
return c.AuthenticationV1Client return c.authenticationV1
} }
// AuthenticationV1beta1 retrieves the AuthenticationV1beta1Client // AuthenticationV1beta1 retrieves the AuthenticationV1beta1Client
func (c *Clientset) AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface { func (c *Clientset) AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface {
return c.AuthenticationV1beta1Client return c.authenticationV1beta1
} }
// AuthorizationV1 retrieves the AuthorizationV1Client // AuthorizationV1 retrieves the AuthorizationV1Client
func (c *Clientset) AuthorizationV1() authorizationv1.AuthorizationV1Interface { func (c *Clientset) AuthorizationV1() authorizationv1.AuthorizationV1Interface {
return c.AuthorizationV1Client return c.authorizationV1
} }
// Deprecated: Authorization retrieves the default version of AuthorizationClient. // Deprecated: Authorization retrieves the default version of AuthorizationClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Authorization() authorizationv1.AuthorizationV1Interface { func (c *Clientset) Authorization() authorizationv1.AuthorizationV1Interface {
return c.AuthorizationV1Client return c.authorizationV1
} }
// AuthorizationV1beta1 retrieves the AuthorizationV1beta1Client // AuthorizationV1beta1 retrieves the AuthorizationV1beta1Client
func (c *Clientset) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface { func (c *Clientset) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface {
return c.AuthorizationV1beta1Client return c.authorizationV1beta1
} }
// AutoscalingV1 retrieves the AutoscalingV1Client // AutoscalingV1 retrieves the AutoscalingV1Client
func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface { func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {
return c.AutoscalingV1Client return c.autoscalingV1
} }
// Deprecated: Autoscaling retrieves the default version of AutoscalingClient. // Deprecated: Autoscaling retrieves the default version of AutoscalingClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface { func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface {
return c.AutoscalingV1Client return c.autoscalingV1
} }
// AutoscalingV2alpha1 retrieves the AutoscalingV2alpha1Client // AutoscalingV2alpha1 retrieves the AutoscalingV2alpha1Client
func (c *Clientset) AutoscalingV2alpha1() autoscalingv2alpha1.AutoscalingV2alpha1Interface { func (c *Clientset) AutoscalingV2alpha1() autoscalingv2alpha1.AutoscalingV2alpha1Interface {
return c.AutoscalingV2alpha1Client return c.autoscalingV2alpha1
} }
// BatchV1 retrieves the BatchV1Client // BatchV1 retrieves the BatchV1Client
func (c *Clientset) BatchV1() batchv1.BatchV1Interface { func (c *Clientset) BatchV1() batchv1.BatchV1Interface {
return c.BatchV1Client return c.batchV1
} }
// Deprecated: Batch retrieves the default version of BatchClient. // Deprecated: Batch retrieves the default version of BatchClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Batch() batchv1.BatchV1Interface { func (c *Clientset) Batch() batchv1.BatchV1Interface {
return c.BatchV1Client return c.batchV1
} }
// BatchV2alpha1 retrieves the BatchV2alpha1Client // BatchV2alpha1 retrieves the BatchV2alpha1Client
func (c *Clientset) BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface { func (c *Clientset) BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface {
return c.BatchV2alpha1Client return c.batchV2alpha1
} }
// CertificatesV1beta1 retrieves the CertificatesV1beta1Client // CertificatesV1beta1 retrieves the CertificatesV1beta1Client
func (c *Clientset) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface { func (c *Clientset) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface {
return c.CertificatesV1beta1Client return c.certificatesV1beta1
} }
// Deprecated: Certificates retrieves the default version of CertificatesClient. // Deprecated: Certificates retrieves the default version of CertificatesClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Certificates() certificatesv1beta1.CertificatesV1beta1Interface { func (c *Clientset) Certificates() certificatesv1beta1.CertificatesV1beta1Interface {
return c.CertificatesV1beta1Client return c.certificatesV1beta1
} }
// CoreV1 retrieves the CoreV1Client // CoreV1 retrieves the CoreV1Client
func (c *Clientset) CoreV1() corev1.CoreV1Interface { func (c *Clientset) CoreV1() corev1.CoreV1Interface {
return c.CoreV1Client return c.coreV1
} }
// Deprecated: Core retrieves the default version of CoreClient. // Deprecated: Core retrieves the default version of CoreClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Core() corev1.CoreV1Interface { func (c *Clientset) Core() corev1.CoreV1Interface {
return c.CoreV1Client return c.coreV1
} }
// ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client // ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client
func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface { func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface {
return c.ExtensionsV1beta1Client return c.extensionsV1beta1
} }
// Deprecated: Extensions retrieves the default version of ExtensionsClient. // Deprecated: Extensions retrieves the default version of ExtensionsClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface { func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface {
return c.ExtensionsV1beta1Client return c.extensionsV1beta1
} }
// NetworkingV1 retrieves the NetworkingV1Client // NetworkingV1 retrieves the NetworkingV1Client
func (c *Clientset) NetworkingV1() networkingv1.NetworkingV1Interface { func (c *Clientset) NetworkingV1() networkingv1.NetworkingV1Interface {
return c.NetworkingV1Client return c.networkingV1
} }
// Deprecated: Networking retrieves the default version of NetworkingClient. // Deprecated: Networking retrieves the default version of NetworkingClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Networking() networkingv1.NetworkingV1Interface { func (c *Clientset) Networking() networkingv1.NetworkingV1Interface {
return c.NetworkingV1Client return c.networkingV1
} }
// PolicyV1beta1 retrieves the PolicyV1beta1Client // PolicyV1beta1 retrieves the PolicyV1beta1Client
func (c *Clientset) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface { func (c *Clientset) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface {
return c.PolicyV1beta1Client return c.policyV1beta1
} }
// Deprecated: Policy retrieves the default version of PolicyClient. // Deprecated: Policy retrieves the default version of PolicyClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Policy() policyv1beta1.PolicyV1beta1Interface { func (c *Clientset) Policy() policyv1beta1.PolicyV1beta1Interface {
return c.PolicyV1beta1Client return c.policyV1beta1
} }
// RbacV1beta1 retrieves the RbacV1beta1Client // RbacV1beta1 retrieves the RbacV1beta1Client
func (c *Clientset) RbacV1beta1() rbacv1beta1.RbacV1beta1Interface { func (c *Clientset) RbacV1beta1() rbacv1beta1.RbacV1beta1Interface {
return c.RbacV1beta1Client return c.rbacV1beta1
} }
// Deprecated: Rbac retrieves the default version of RbacClient. // Deprecated: Rbac retrieves the default version of RbacClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Rbac() rbacv1beta1.RbacV1beta1Interface { func (c *Clientset) Rbac() rbacv1beta1.RbacV1beta1Interface {
return c.RbacV1beta1Client return c.rbacV1beta1
} }
// RbacV1alpha1 retrieves the RbacV1alpha1Client // RbacV1alpha1 retrieves the RbacV1alpha1Client
func (c *Clientset) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface { func (c *Clientset) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface {
return c.RbacV1alpha1Client return c.rbacV1alpha1
} }
// SchedulingV1alpha1 retrieves the SchedulingV1alpha1Client // SchedulingV1alpha1 retrieves the SchedulingV1alpha1Client
func (c *Clientset) SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1Interface { func (c *Clientset) SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1Interface {
return c.SchedulingV1alpha1Client return c.schedulingV1alpha1
} }
// Deprecated: Scheduling retrieves the default version of SchedulingClient. // Deprecated: Scheduling retrieves the default version of SchedulingClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Scheduling() schedulingv1alpha1.SchedulingV1alpha1Interface { func (c *Clientset) Scheduling() schedulingv1alpha1.SchedulingV1alpha1Interface {
return c.SchedulingV1alpha1Client return c.schedulingV1alpha1
} }
// SettingsV1alpha1 retrieves the SettingsV1alpha1Client // SettingsV1alpha1 retrieves the SettingsV1alpha1Client
func (c *Clientset) SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface { func (c *Clientset) SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface {
return c.SettingsV1alpha1Client return c.settingsV1alpha1
} }
// Deprecated: Settings retrieves the default version of SettingsClient. // Deprecated: Settings retrieves the default version of SettingsClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Settings() settingsv1alpha1.SettingsV1alpha1Interface { func (c *Clientset) Settings() settingsv1alpha1.SettingsV1alpha1Interface {
return c.SettingsV1alpha1Client return c.settingsV1alpha1
} }
// StorageV1beta1 retrieves the StorageV1beta1Client // StorageV1beta1 retrieves the StorageV1beta1Client
func (c *Clientset) StorageV1beta1() storagev1beta1.StorageV1beta1Interface { func (c *Clientset) StorageV1beta1() storagev1beta1.StorageV1beta1Interface {
return c.StorageV1beta1Client return c.storageV1beta1
} }
// StorageV1 retrieves the StorageV1Client // StorageV1 retrieves the StorageV1Client
func (c *Clientset) StorageV1() storagev1.StorageV1Interface { func (c *Clientset) StorageV1() storagev1.StorageV1Interface {
return c.StorageV1Client return c.storageV1
} }
// Deprecated: Storage retrieves the default version of StorageClient. // Deprecated: Storage retrieves the default version of StorageClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Storage() storagev1.StorageV1Interface { func (c *Clientset) Storage() storagev1.StorageV1Interface {
return c.StorageV1Client return c.storageV1
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -345,91 +345,91 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.AdmissionregistrationV1alpha1Client, err = admissionregistrationv1alpha1.NewForConfig(&configShallowCopy) cs.admissionregistrationV1alpha1, err = admissionregistrationv1alpha1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AppsV1beta1Client, err = appsv1beta1.NewForConfig(&configShallowCopy) cs.appsV1beta1, err = appsv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AppsV1beta2Client, err = appsv1beta2.NewForConfig(&configShallowCopy) cs.appsV1beta2, err = appsv1beta2.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AuthenticationV1Client, err = authenticationv1.NewForConfig(&configShallowCopy) cs.authenticationV1, err = authenticationv1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AuthenticationV1beta1Client, err = authenticationv1beta1.NewForConfig(&configShallowCopy) cs.authenticationV1beta1, err = authenticationv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AuthorizationV1Client, err = authorizationv1.NewForConfig(&configShallowCopy) cs.authorizationV1, err = authorizationv1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AuthorizationV1beta1Client, err = authorizationv1beta1.NewForConfig(&configShallowCopy) cs.authorizationV1beta1, err = authorizationv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AutoscalingV1Client, err = autoscalingv1.NewForConfig(&configShallowCopy) cs.autoscalingV1, err = autoscalingv1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.AutoscalingV2alpha1Client, err = autoscalingv2alpha1.NewForConfig(&configShallowCopy) cs.autoscalingV2alpha1, err = autoscalingv2alpha1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.BatchV1Client, err = batchv1.NewForConfig(&configShallowCopy) cs.batchV1, err = batchv1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.BatchV2alpha1Client, err = batchv2alpha1.NewForConfig(&configShallowCopy) cs.batchV2alpha1, err = batchv2alpha1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.CertificatesV1beta1Client, err = certificatesv1beta1.NewForConfig(&configShallowCopy) cs.certificatesV1beta1, err = certificatesv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.CoreV1Client, err = corev1.NewForConfig(&configShallowCopy) cs.coreV1, err = corev1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.ExtensionsV1beta1Client, err = extensionsv1beta1.NewForConfig(&configShallowCopy) cs.extensionsV1beta1, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.NetworkingV1Client, err = networkingv1.NewForConfig(&configShallowCopy) cs.networkingV1, err = networkingv1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.PolicyV1beta1Client, err = policyv1beta1.NewForConfig(&configShallowCopy) cs.policyV1beta1, err = policyv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.RbacV1beta1Client, err = rbacv1beta1.NewForConfig(&configShallowCopy) cs.rbacV1beta1, err = rbacv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.RbacV1alpha1Client, err = rbacv1alpha1.NewForConfig(&configShallowCopy) cs.rbacV1alpha1, err = rbacv1alpha1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.SchedulingV1alpha1Client, err = schedulingv1alpha1.NewForConfig(&configShallowCopy) cs.schedulingV1alpha1, err = schedulingv1alpha1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.SettingsV1alpha1Client, err = settingsv1alpha1.NewForConfig(&configShallowCopy) cs.settingsV1alpha1, err = settingsv1alpha1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.StorageV1beta1Client, err = storagev1beta1.NewForConfig(&configShallowCopy) cs.storageV1beta1, err = storagev1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
cs.StorageV1Client, err = storagev1.NewForConfig(&configShallowCopy) cs.storageV1, err = storagev1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -446,28 +446,28 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.AdmissionregistrationV1alpha1Client = admissionregistrationv1alpha1.NewForConfigOrDie(c) cs.admissionregistrationV1alpha1 = admissionregistrationv1alpha1.NewForConfigOrDie(c)
cs.AppsV1beta1Client = appsv1beta1.NewForConfigOrDie(c) cs.appsV1beta1 = appsv1beta1.NewForConfigOrDie(c)
cs.AppsV1beta2Client = appsv1beta2.NewForConfigOrDie(c) cs.appsV1beta2 = appsv1beta2.NewForConfigOrDie(c)
cs.AuthenticationV1Client = authenticationv1.NewForConfigOrDie(c) cs.authenticationV1 = authenticationv1.NewForConfigOrDie(c)
cs.AuthenticationV1beta1Client = authenticationv1beta1.NewForConfigOrDie(c) cs.authenticationV1beta1 = authenticationv1beta1.NewForConfigOrDie(c)
cs.AuthorizationV1Client = authorizationv1.NewForConfigOrDie(c) cs.authorizationV1 = authorizationv1.NewForConfigOrDie(c)
cs.AuthorizationV1beta1Client = authorizationv1beta1.NewForConfigOrDie(c) cs.authorizationV1beta1 = authorizationv1beta1.NewForConfigOrDie(c)
cs.AutoscalingV1Client = autoscalingv1.NewForConfigOrDie(c) cs.autoscalingV1 = autoscalingv1.NewForConfigOrDie(c)
cs.AutoscalingV2alpha1Client = autoscalingv2alpha1.NewForConfigOrDie(c) cs.autoscalingV2alpha1 = autoscalingv2alpha1.NewForConfigOrDie(c)
cs.BatchV1Client = batchv1.NewForConfigOrDie(c) cs.batchV1 = batchv1.NewForConfigOrDie(c)
cs.BatchV2alpha1Client = batchv2alpha1.NewForConfigOrDie(c) cs.batchV2alpha1 = batchv2alpha1.NewForConfigOrDie(c)
cs.CertificatesV1beta1Client = certificatesv1beta1.NewForConfigOrDie(c) cs.certificatesV1beta1 = certificatesv1beta1.NewForConfigOrDie(c)
cs.CoreV1Client = corev1.NewForConfigOrDie(c) cs.coreV1 = corev1.NewForConfigOrDie(c)
cs.ExtensionsV1beta1Client = extensionsv1beta1.NewForConfigOrDie(c) cs.extensionsV1beta1 = extensionsv1beta1.NewForConfigOrDie(c)
cs.NetworkingV1Client = networkingv1.NewForConfigOrDie(c) cs.networkingV1 = networkingv1.NewForConfigOrDie(c)
cs.PolicyV1beta1Client = policyv1beta1.NewForConfigOrDie(c) cs.policyV1beta1 = policyv1beta1.NewForConfigOrDie(c)
cs.RbacV1beta1Client = rbacv1beta1.NewForConfigOrDie(c) cs.rbacV1beta1 = rbacv1beta1.NewForConfigOrDie(c)
cs.RbacV1alpha1Client = rbacv1alpha1.NewForConfigOrDie(c) cs.rbacV1alpha1 = rbacv1alpha1.NewForConfigOrDie(c)
cs.SchedulingV1alpha1Client = schedulingv1alpha1.NewForConfigOrDie(c) cs.schedulingV1alpha1 = schedulingv1alpha1.NewForConfigOrDie(c)
cs.SettingsV1alpha1Client = settingsv1alpha1.NewForConfigOrDie(c) cs.settingsV1alpha1 = settingsv1alpha1.NewForConfigOrDie(c)
cs.StorageV1beta1Client = storagev1beta1.NewForConfigOrDie(c) cs.storageV1beta1 = storagev1beta1.NewForConfigOrDie(c)
cs.StorageV1Client = storagev1.NewForConfigOrDie(c) cs.storageV1 = storagev1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -476,28 +476,28 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.AdmissionregistrationV1alpha1Client = admissionregistrationv1alpha1.New(c) cs.admissionregistrationV1alpha1 = admissionregistrationv1alpha1.New(c)
cs.AppsV1beta1Client = appsv1beta1.New(c) cs.appsV1beta1 = appsv1beta1.New(c)
cs.AppsV1beta2Client = appsv1beta2.New(c) cs.appsV1beta2 = appsv1beta2.New(c)
cs.AuthenticationV1Client = authenticationv1.New(c) cs.authenticationV1 = authenticationv1.New(c)
cs.AuthenticationV1beta1Client = authenticationv1beta1.New(c) cs.authenticationV1beta1 = authenticationv1beta1.New(c)
cs.AuthorizationV1Client = authorizationv1.New(c) cs.authorizationV1 = authorizationv1.New(c)
cs.AuthorizationV1beta1Client = authorizationv1beta1.New(c) cs.authorizationV1beta1 = authorizationv1beta1.New(c)
cs.AutoscalingV1Client = autoscalingv1.New(c) cs.autoscalingV1 = autoscalingv1.New(c)
cs.AutoscalingV2alpha1Client = autoscalingv2alpha1.New(c) cs.autoscalingV2alpha1 = autoscalingv2alpha1.New(c)
cs.BatchV1Client = batchv1.New(c) cs.batchV1 = batchv1.New(c)
cs.BatchV2alpha1Client = batchv2alpha1.New(c) cs.batchV2alpha1 = batchv2alpha1.New(c)
cs.CertificatesV1beta1Client = certificatesv1beta1.New(c) cs.certificatesV1beta1 = certificatesv1beta1.New(c)
cs.CoreV1Client = corev1.New(c) cs.coreV1 = corev1.New(c)
cs.ExtensionsV1beta1Client = extensionsv1beta1.New(c) cs.extensionsV1beta1 = extensionsv1beta1.New(c)
cs.NetworkingV1Client = networkingv1.New(c) cs.networkingV1 = networkingv1.New(c)
cs.PolicyV1beta1Client = policyv1beta1.New(c) cs.policyV1beta1 = policyv1beta1.New(c)
cs.RbacV1beta1Client = rbacv1beta1.New(c) cs.rbacV1beta1 = rbacv1beta1.New(c)
cs.RbacV1alpha1Client = rbacv1alpha1.New(c) cs.rbacV1alpha1 = rbacv1alpha1.New(c)
cs.SchedulingV1alpha1Client = schedulingv1alpha1.New(c) cs.schedulingV1alpha1 = schedulingv1alpha1.New(c)
cs.SettingsV1alpha1Client = settingsv1alpha1.New(c) cs.settingsV1alpha1 = settingsv1alpha1.New(c)
cs.StorageV1beta1Client = storagev1beta1.New(c) cs.storageV1beta1 = storagev1beta1.New(c)
cs.StorageV1Client = storagev1.New(c) cs.storageV1 = storagev1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

12
staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go
View File

@@ -35,18 +35,18 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*apiregistrationv1beta1.ApiregistrationV1beta1Client apiregistrationV1beta1 *apiregistrationv1beta1.ApiregistrationV1beta1Client
} }
// ApiregistrationV1beta1 retrieves the ApiregistrationV1beta1Client // ApiregistrationV1beta1 retrieves the ApiregistrationV1beta1Client
func (c *Clientset) ApiregistrationV1beta1() apiregistrationv1beta1.ApiregistrationV1beta1Interface { func (c *Clientset) ApiregistrationV1beta1() apiregistrationv1beta1.ApiregistrationV1beta1Interface {
return c.ApiregistrationV1beta1Client return c.apiregistrationV1beta1
} }
// Deprecated: Apiregistration retrieves the default version of ApiregistrationClient. // Deprecated: Apiregistration retrieves the default version of ApiregistrationClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Apiregistration() apiregistrationv1beta1.ApiregistrationV1beta1Interface { func (c *Clientset) Apiregistration() apiregistrationv1beta1.ApiregistrationV1beta1Interface {
return c.ApiregistrationV1beta1Client return c.apiregistrationV1beta1
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.ApiregistrationV1beta1Client, err = apiregistrationv1beta1.NewForConfig(&configShallowCopy) cs.apiregistrationV1beta1, err = apiregistrationv1beta1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.ApiregistrationV1beta1Client = apiregistrationv1beta1.NewForConfigOrDie(c) cs.apiregistrationV1beta1 = apiregistrationv1beta1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.ApiregistrationV1beta1Client = apiregistrationv1beta1.New(c) cs.apiregistrationV1beta1 = apiregistrationv1beta1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

10
staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/internalclientset/clientset.go
View File

@@ -33,12 +33,12 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*apiregistrationinternalversion.ApiregistrationClient apiregistration *apiregistrationinternalversion.ApiregistrationClient
} }
// Apiregistration retrieves the ApiregistrationClient // Apiregistration retrieves the ApiregistrationClient
func (c *Clientset) Apiregistration() apiregistrationinternalversion.ApiregistrationInterface { func (c *Clientset) Apiregistration() apiregistrationinternalversion.ApiregistrationInterface {
return c.ApiregistrationClient return c.apiregistration
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.ApiregistrationClient, err = apiregistrationinternalversion.NewForConfig(&configShallowCopy) cs.apiregistration, err = apiregistrationinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.ApiregistrationClient = apiregistrationinternalversion.NewForConfigOrDie(c) cs.apiregistration = apiregistrationinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.ApiregistrationClient = apiregistrationinternalversion.New(c) cs.apiregistration = apiregistrationinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

13
staging/src/k8s.io/kube-gen/cmd/client-gen/generators/generator_for_clientset.go
View File

@@ -70,7 +70,6 @@ func (g *genClientset) GenerateType(c *generator.Context, t *types.Type, w io.Wr
sw := generator.NewSnippetWriter(w, c, "$", "$") sw := generator.NewSnippetWriter(w, c, "$", "$")
allGroups := clientgentypes.ToGroupVersionPackages(g.groups) allGroups := clientgentypes.ToGroupVersionPackages(g.groups)
m := map[string]interface{}{ m := map[string]interface{}{
"allGroups": allGroups, "allGroups": allGroups,
"Config": c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Config"}), "Config": c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Config"}),
@@ -116,7 +115,7 @@ var clientsetTemplate = `
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*$.DiscoveryClient|raw$ *$.DiscoveryClient|raw$
$range .allGroups$*$.PackageName$.$.GroupVersion$Client $range .allGroups$$.LowerCaseGroupVersion$ *$.PackageName$.$.GroupVersion$Client
$end$ $end$
} }
` `
@@ -124,7 +123,7 @@ type Clientset struct {
var clientsetInterfaceImplTemplate = ` var clientsetInterfaceImplTemplate = `
// $.GroupVersion$ retrieves the $.GroupVersion$Client // $.GroupVersion$ retrieves the $.GroupVersion$Client
func (c *Clientset) $.GroupVersion$() $.PackageName$.$.GroupVersion$Interface { func (c *Clientset) $.GroupVersion$() $.PackageName$.$.GroupVersion$Interface {
return c.$.GroupVersion$Client return c.$.LowerCaseGroupVersion$
} }
` `
@@ -132,7 +131,7 @@ var clientsetInterfaceDefaultVersionImpl = `
// Deprecated: $.Group$ retrieves the default version of $.Group$Client. // Deprecated: $.Group$ retrieves the default version of $.Group$Client.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) $.Group$() $.PackageName$.$.GroupVersion$Interface { func (c *Clientset) $.Group$() $.PackageName$.$.GroupVersion$Interface {
return c.$.GroupVersion$Client return c.$.LowerCaseGroupVersion$
} }
` `
@@ -155,7 +154,7 @@ func NewForConfig(c *$.Config|raw$) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
$range .allGroups$ cs.$.GroupVersion$Client, err =$.PackageName$.NewForConfig(&configShallowCopy) $range .allGroups$ cs.$.LowerCaseGroupVersion$, err =$.PackageName$.NewForConfig(&configShallowCopy)
if err!=nil { if err!=nil {
return nil, err return nil, err
} }
@@ -174,7 +173,7 @@ var newClientsetForConfigOrDieTemplate = `
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *$.Config|raw$) *Clientset { func NewForConfigOrDie(c *$.Config|raw$) *Clientset {
var cs Clientset var cs Clientset
$range .allGroups$ cs.$.GroupVersion$Client =$.PackageName$.NewForConfigOrDie(c) $range .allGroups$ cs.$.LowerCaseGroupVersion$ =$.PackageName$.NewForConfigOrDie(c)
$end$ $end$
cs.DiscoveryClient = $.NewDiscoveryClientForConfigOrDie|raw$(c) cs.DiscoveryClient = $.NewDiscoveryClientForConfigOrDie|raw$(c)
return &cs return &cs
@@ -185,7 +184,7 @@ var newClientsetForRESTClientTemplate = `
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c $.RESTClientInterface|raw$) *Clientset { func New(c $.RESTClientInterface|raw$) *Clientset {
var cs Clientset var cs Clientset
$range .allGroups$ cs.$.GroupVersion$Client =$.PackageName$.New(c) $range .allGroups$ cs.$.LowerCaseGroupVersion$ =$.PackageName$.New(c)
$end$ $end$
cs.DiscoveryClient = $.NewDiscoveryClient|raw$(c) cs.DiscoveryClient = $.NewDiscoveryClient|raw$(c)
return &cs return &cs

11
staging/src/k8s.io/kube-gen/cmd/client-gen/types/helpers.go
View File

@@ -91,11 +91,12 @@ func ToGroupVersionPackages(groups []GroupVersions) []GroupVersionPackage {
defaultVersion := defaultVersion(group.Versions) defaultVersion := defaultVersion(group.Versions)
for _, version := range group.Versions { for _, version := range group.Versions {
groupVersionPackages = append(groupVersionPackages, GroupVersionPackage{ groupVersionPackages = append(groupVersionPackages, GroupVersionPackage{
Group: Group(namer.IC(group.Group.NonEmpty())), Group: Group(namer.IC(group.Group.NonEmpty())),
Version: Version(namer.IC(version.String())), Version: Version(namer.IC(version.String())),
GroupVersion: namer.IC(group.Group.NonEmpty()) + namer.IC(version.String()), GroupVersion: namer.IC(group.Group.NonEmpty()) + namer.IC(version.String()),
PackageName: strings.ToLower(group.Group.NonEmpty() + version.NonEmpty()), LowerCaseGroupVersion: namer.IL(group.Group.NonEmpty()) + namer.IC(version.String()),
IsDefaultVersion: version == defaultVersion && version != "", PackageName: strings.ToLower(group.Group.NonEmpty() + version.NonEmpty()),
IsDefaultVersion: version == defaultVersion && version != "",
}) })
} }
} }

7
staging/src/k8s.io/kube-gen/cmd/client-gen/types/types.go
View File

@@ -58,9 +58,10 @@ type GroupVersionPackage struct {
Version Version Version Version
// If a user calls a group client without specifying the version (e.g., // If a user calls a group client without specifying the version (e.g.,
// c.Core(), instead of c.CoreV1()), the default version will be returned. // c.Core(), instead of c.CoreV1()), the default version will be returned.
IsDefaultVersion bool IsDefaultVersion bool
GroupVersion string GroupVersion string
PackageName string LowerCaseGroupVersion string
PackageName string
} }
type GroupInstallPackage struct { type GroupInstallPackage struct {

10
staging/src/k8s.io/kube-gen/test/clientset/internal/clientset.go
View File

@@ -33,12 +33,12 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*testgroupinternalversion.TestgroupClient testgroup *testgroupinternalversion.TestgroupClient
} }
// Testgroup retrieves the TestgroupClient // Testgroup retrieves the TestgroupClient
func (c *Clientset) Testgroup() testgroupinternalversion.TestgroupInterface { func (c *Clientset) Testgroup() testgroupinternalversion.TestgroupInterface {
return c.TestgroupClient return c.testgroup
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.TestgroupClient, err = testgroupinternalversion.NewForConfig(&configShallowCopy) cs.testgroup, err = testgroupinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.TestgroupClient = testgroupinternalversion.NewForConfigOrDie(c) cs.testgroup = testgroupinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.TestgroupClient = testgroupinternalversion.New(c) cs.testgroup = testgroupinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

12
staging/src/k8s.io/kube-gen/test/clientset/versioned/clientset.go
View File

@@ -35,18 +35,18 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*testgroupv1.TestgroupV1Client testgroupV1 *testgroupv1.TestgroupV1Client
} }
// TestgroupV1 retrieves the TestgroupV1Client // TestgroupV1 retrieves the TestgroupV1Client
func (c *Clientset) TestgroupV1() testgroupv1.TestgroupV1Interface { func (c *Clientset) TestgroupV1() testgroupv1.TestgroupV1Interface {
return c.TestgroupV1Client return c.testgroupV1
} }
// Deprecated: Testgroup retrieves the default version of TestgroupClient. // Deprecated: Testgroup retrieves the default version of TestgroupClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Testgroup() testgroupv1.TestgroupV1Interface { func (c *Clientset) Testgroup() testgroupv1.TestgroupV1Interface {
return c.TestgroupV1Client return c.testgroupV1
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.TestgroupV1Client, err = testgroupv1.NewForConfig(&configShallowCopy) cs.testgroupV1, err = testgroupv1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.TestgroupV1Client = testgroupv1.NewForConfigOrDie(c) cs.testgroupV1 = testgroupv1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.TestgroupV1Client = testgroupv1.New(c) cs.testgroupV1 = testgroupv1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

12
staging/src/k8s.io/metrics/pkg/client/clientset_generated/clientset/clientset.go
View File

@@ -35,18 +35,18 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*metricsv1alpha1.MetricsV1alpha1Client metricsV1alpha1 *metricsv1alpha1.MetricsV1alpha1Client
} }
// MetricsV1alpha1 retrieves the MetricsV1alpha1Client // MetricsV1alpha1 retrieves the MetricsV1alpha1Client
func (c *Clientset) MetricsV1alpha1() metricsv1alpha1.MetricsV1alpha1Interface { func (c *Clientset) MetricsV1alpha1() metricsv1alpha1.MetricsV1alpha1Interface {
return c.MetricsV1alpha1Client return c.metricsV1alpha1
} }
// Deprecated: Metrics retrieves the default version of MetricsClient. // Deprecated: Metrics retrieves the default version of MetricsClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Metrics() metricsv1alpha1.MetricsV1alpha1Interface { func (c *Clientset) Metrics() metricsv1alpha1.MetricsV1alpha1Interface {
return c.MetricsV1alpha1Client return c.metricsV1alpha1
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.MetricsV1alpha1Client, err = metricsv1alpha1.NewForConfig(&configShallowCopy) cs.metricsV1alpha1, err = metricsv1alpha1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.MetricsV1alpha1Client = metricsv1alpha1.NewForConfigOrDie(c) cs.metricsV1alpha1 = metricsv1alpha1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.MetricsV1alpha1Client = metricsv1alpha1.New(c) cs.metricsV1alpha1 = metricsv1alpha1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

12
staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/clientset/clientset.go
View File

@@ -35,18 +35,18 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*wardlev1alpha1.WardleV1alpha1Client wardleV1alpha1 *wardlev1alpha1.WardleV1alpha1Client
} }
// WardleV1alpha1 retrieves the WardleV1alpha1Client // WardleV1alpha1 retrieves the WardleV1alpha1Client
func (c *Clientset) WardleV1alpha1() wardlev1alpha1.WardleV1alpha1Interface { func (c *Clientset) WardleV1alpha1() wardlev1alpha1.WardleV1alpha1Interface {
return c.WardleV1alpha1Client return c.wardleV1alpha1
} }
// Deprecated: Wardle retrieves the default version of WardleClient. // Deprecated: Wardle retrieves the default version of WardleClient.
// Please explicitly pick a version. // Please explicitly pick a version.
func (c *Clientset) Wardle() wardlev1alpha1.WardleV1alpha1Interface { func (c *Clientset) Wardle() wardlev1alpha1.WardleV1alpha1Interface {
return c.WardleV1alpha1Client return c.wardleV1alpha1
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.WardleV1alpha1Client, err = wardlev1alpha1.NewForConfig(&configShallowCopy) cs.wardleV1alpha1, err = wardlev1alpha1.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.WardleV1alpha1Client = wardlev1alpha1.NewForConfigOrDie(c) cs.wardleV1alpha1 = wardlev1alpha1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.WardleV1alpha1Client = wardlev1alpha1.New(c) cs.wardleV1alpha1 = wardlev1alpha1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

10
staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/internalclientset/clientset.go
View File

@@ -33,12 +33,12 @@ type Interface interface {
// version included in a Clientset. // version included in a Clientset.
type Clientset struct { type Clientset struct {
*discovery.DiscoveryClient *discovery.DiscoveryClient
*wardleinternalversion.WardleClient wardle *wardleinternalversion.WardleClient
} }
// Wardle retrieves the WardleClient // Wardle retrieves the WardleClient
func (c *Clientset) Wardle() wardleinternalversion.WardleInterface { func (c *Clientset) Wardle() wardleinternalversion.WardleInterface {
return c.WardleClient return c.wardle
} }
// Discovery retrieves the DiscoveryClient // Discovery retrieves the DiscoveryClient
@@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
} }
var cs Clientset var cs Clientset
var err error var err error
cs.WardleClient, err = wardleinternalversion.NewForConfig(&configShallowCopy) cs.wardle, err = wardleinternalversion.NewForConfig(&configShallowCopy)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config. // panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset { func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset var cs Clientset
cs.WardleClient = wardleinternalversion.NewForConfigOrDie(c) cs.wardle = wardleinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs return &cs
@@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient. // New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset { func New(c rest.Interface) *Clientset {
var cs Clientset var cs Clientset
cs.WardleClient = wardleinternalversion.New(c) cs.wardle = wardleinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
return &cs return &cs

30
test/e2e/apps/deployment.go
View File

@@ -132,7 +132,7 @@ func failureTrap(c clientset.Interface, ns string) {
d := deployments.Items[i] d := deployments.Items[i]
framework.Logf(spew.Sprintf("Deployment %q:\n%+v\n", d.Name, d)) framework.Logf(spew.Sprintf("Deployment %q:\n%+v\n", d.Name, d))
_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(&d, c) _, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(&d, c.ExtensionsV1beta1())
if err != nil { if err != nil {
framework.Logf("Could not list ReplicaSets for Deployment %q: %v", d.Name, err) framework.Logf("Could not list ReplicaSets for Deployment %q: %v", d.Name, err)
return return
@@ -186,7 +186,7 @@ func checkDeploymentRevision(c clientset.Interface, ns, deploymentName, revision
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{}) deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
// Check revision of the new replica set of this deployment // Check revision of the new replica set of this deployment
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c) newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(newRS).NotTo(Equal(nilRs)) Expect(newRS).NotTo(Equal(nilRs))
Expect(newRS.Annotations).NotTo(Equal(nil)) Expect(newRS.Annotations).NotTo(Equal(nil))
@@ -268,7 +268,7 @@ func testDeleteDeployment(f *framework.Framework) {
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{}) deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c) newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(newRS).NotTo(Equal(nilRs)) Expect(newRS).NotTo(Equal(nilRs))
stopDeployment(c, internalClient, ns, deploymentName) stopDeployment(c, internalClient, ns, deploymentName)
@@ -318,7 +318,7 @@ func testRollingUpdateDeployment(f *framework.Framework) {
framework.Logf("Ensuring deployment %q has one old replica set (the one it adopted)", deploy.Name) framework.Logf("Ensuring deployment %q has one old replica set (the one it adopted)", deploy.Name)
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{}) deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
_, allOldRSs, err := deploymentutil.GetOldReplicaSets(deployment, c) _, allOldRSs, err := deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(len(allOldRSs)).Should(Equal(1)) Expect(len(allOldRSs)).Should(Equal(1))
// The old RS should contain pod-template-hash in its selector, label, and template label // The old RS should contain pod-template-hash in its selector, label, and template label
@@ -542,7 +542,7 @@ func testPausedDeployment(f *framework.Framework) {
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
// Verify that there is no latest state realized for the new deployment. // Verify that there is no latest state realized for the new deployment.
rs, err := deploymentutil.GetNewReplicaSet(deployment, c) rs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(rs).To(Equal(nilRs)) Expect(rs).To(Equal(nilRs))
@@ -594,11 +594,11 @@ func testPausedDeployment(f *framework.Framework) {
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
framework.Logf("Looking for new replicaset for paused deployment %q (there should be none)", deploymentName) framework.Logf("Looking for new replicaset for paused deployment %q (there should be none)", deploymentName)
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c) newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(newRS).To(Equal(nilRs)) Expect(newRS).To(Equal(nilRs))
_, allOldRs, err := deploymentutil.GetOldReplicaSets(deployment, c) _, allOldRs, err := deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
if len(allOldRs) != 1 { if len(allOldRs) != 1 {
err = fmt.Errorf("expected an old replica set") err = fmt.Errorf("expected an old replica set")
@@ -887,7 +887,7 @@ func testDeploymentLabelAdopted(f *framework.Framework) {
// There should be no old RSs (overlapping RS) // There should be no old RSs (overlapping RS)
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{}) deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
oldRSs, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c) oldRSs, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(len(oldRSs)).Should(Equal(0)) Expect(len(oldRSs)).Should(Equal(0))
Expect(len(allOldRSs)).Should(Equal(0)) Expect(len(allOldRSs)).Should(Equal(0))
@@ -951,7 +951,7 @@ func testScalePausedDeployment(f *framework.Framework) {
err = framework.WaitForObservedDeployment(c, ns, deploymentName, deployment.Generation) err = framework.WaitForObservedDeployment(c, ns, deploymentName, deployment.Generation)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
rs, err := deploymentutil.GetNewReplicaSet(deployment, c) rs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(*(rs.Spec.Replicas)).Should(Equal(newReplicas)) Expect(*(rs.Spec.Replicas)).Should(Equal(newReplicas))
} }
@@ -985,7 +985,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
framework.Logf("Waiting for deployment %q to complete", deployment.Name) framework.Logf("Waiting for deployment %q to complete", deployment.Name)
Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred()) Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred())
first, err := deploymentutil.GetNewReplicaSet(deployment, c) first, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
// Update the deployment with a non-existent image so that the new replica set will be blocked. // Update the deployment with a non-existent image so that the new replica set will be blocked.
@@ -1007,7 +1007,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
} }
framework.Logf("Checking that the replica sets for %q are synced", deploymentName) framework.Logf("Checking that the replica sets for %q are synced", deploymentName)
second, err := deploymentutil.GetNewReplicaSet(deployment, c) second, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
first, err = c.Extensions().ReplicaSets(first.Namespace).Get(first.Name, metav1.GetOptions{}) first, err = c.Extensions().ReplicaSets(first.Namespace).Get(first.Name, metav1.GetOptions{})
@@ -1035,7 +1035,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
framework.Logf("Waiting for deployment status to sync (current available: %d, minimum available: %d)", deployment.Status.AvailableReplicas, deploymentutil.MinAvailable(deployment)) framework.Logf("Waiting for deployment status to sync (current available: %d, minimum available: %d)", deployment.Status.AvailableReplicas, deploymentutil.MinAvailable(deployment))
Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred()) Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred())
oldRSs, _, rs, err := deploymentutil.GetAllReplicaSets(deployment, c) oldRSs, _, rs, err := deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
for _, rs := range append(oldRSs, rs) { for _, rs := range append(oldRSs, rs) {
@@ -1070,7 +1070,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
oldRs, err := c.Extensions().ReplicaSets(rs.Namespace).Get(rs.Name, metav1.GetOptions{}) oldRs, err := c.Extensions().ReplicaSets(rs.Namespace).Get(rs.Name, metav1.GetOptions{})
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
newRs, err := deploymentutil.GetNewReplicaSet(deployment, c) newRs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
oldCond := replicaSetHasDesiredReplicas(c.Extensions(), oldRs) oldCond := replicaSetHasDesiredReplicas(c.Extensions(), oldRs)
@@ -1095,7 +1095,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
framework.Logf("Waiting for deployment status to sync (current available: %d, minimum available: %d)", deployment.Status.AvailableReplicas, deploymentutil.MinAvailable(deployment)) framework.Logf("Waiting for deployment status to sync (current available: %d, minimum available: %d)", deployment.Status.AvailableReplicas, deploymentutil.MinAvailable(deployment))
Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred()) Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred())
oldRSs, _, rs, err = deploymentutil.GetAllReplicaSets(deployment, c) oldRSs, _, rs, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
for _, rs := range append(oldRSs, rs) { for _, rs := range append(oldRSs, rs) {
@@ -1433,7 +1433,7 @@ func testDeploymentHashCollisionAvoidance(f *framework.Framework) {
// once it has no owner reference, then recreate the Deployment if we ever proceed with // once it has no owner reference, then recreate the Deployment if we ever proceed with
// https://github.com/kubernetes/kubernetes/issues/44237 // https://github.com/kubernetes/kubernetes/issues/44237
framework.Logf("Mock a hash collision") framework.Logf("Mock a hash collision")
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c) newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
var nilRs *extensions.ReplicaSet var nilRs *extensions.ReplicaSet
Expect(newRS).NotTo(Equal(nilRs)) Expect(newRS).NotTo(Equal(nilRs))

8
test/e2e/apps/disruption.go
View File

@@ -163,7 +163,7 @@ var _ = SIGDescribe("DisruptionController", func() {
// Locate a running pod. // Locate a running pod.
var pod v1.Pod var pod v1.Pod
err := wait.PollImmediate(framework.Poll, schedulingTimeout, func() (bool, error) { err := wait.PollImmediate(framework.Poll, schedulingTimeout, func() (bool, error) {
podList, err := cs.Pods(ns).List(metav1.ListOptions{}) podList, err := cs.CoreV1().Pods(ns).List(metav1.ListOptions{})
if err != nil { if err != nil {
return false, err return false, err
} }
@@ -191,7 +191,7 @@ var _ = SIGDescribe("DisruptionController", func() {
// this gives the controller enough time to have truly set the status. // this gives the controller enough time to have truly set the status.
time.Sleep(timeout) time.Sleep(timeout)
err = cs.Pods(ns).Evict(e) err = cs.CoreV1().Pods(ns).Evict(e)
Expect(err).Should(MatchError("Cannot evict pod as it would violate the pod's disruption budget.")) Expect(err).Should(MatchError("Cannot evict pod as it would violate the pod's disruption budget."))
} else { } else {
// Only wait for running pods in the "allow" case // Only wait for running pods in the "allow" case
@@ -202,7 +202,7 @@ var _ = SIGDescribe("DisruptionController", func() {
// Since disruptionAllowed starts out false, if an eviction is ever allowed, // Since disruptionAllowed starts out false, if an eviction is ever allowed,
// that means the controller is working. // that means the controller is working.
err = wait.PollImmediate(framework.Poll, timeout, func() (bool, error) { err = wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
err = cs.Pods(ns).Evict(e) err = cs.CoreV1().Pods(ns).Evict(e)
if err != nil { if err != nil {
return false, nil return false, nil
} else { } else {
@@ -264,7 +264,7 @@ func createPodsOrDie(cs *kubernetes.Clientset, ns string, n int) {
}, },
} }
_, err := cs.Pods(ns).Create(pod) _, err := cs.CoreV1().Pods(ns).Create(pod)
framework.ExpectNoError(err, "Creating pod %q in namespace %q", pod.Name, ns) framework.ExpectNoError(err, "Creating pod %q in namespace %q", pod.Name, ns)
} }
} }

10
test/e2e/framework/deployment_util.go
View File

@@ -72,7 +72,7 @@ func WaitForDeploymentOldRSsNum(c clientset.Interface, ns, deploymentName string
} }
d = deployment d = deployment
_, oldRSs, err = deploymentutil.GetOldReplicaSets(deployment, c) _, oldRSs, err = deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
if err != nil { if err != nil {
return false, err return false, err
} }
@@ -108,7 +108,7 @@ func WaitForDeploymentWithCondition(c clientset.Interface, ns, deploymentName, r
}) })
if pollErr == wait.ErrWaitTimeout { if pollErr == wait.ErrWaitTimeout {
pollErr = fmt.Errorf("deployment %q never updated with the desired condition and reason: %v", deployment.Name, deployment.Status.Conditions) pollErr = fmt.Errorf("deployment %q never updated with the desired condition and reason: %v", deployment.Name, deployment.Status.Conditions)
_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c) _, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
if err == nil { if err == nil {
logReplicaSetsOfDeployment(deployment, allOldRSs, newRS) logReplicaSetsOfDeployment(deployment, allOldRSs, newRS)
logPodsOfDeployment(c, deployment, append(allOldRSs, newRS)) logPodsOfDeployment(c, deployment, append(allOldRSs, newRS))
@@ -176,7 +176,7 @@ func WaitForDeploymentStatus(c clientset.Interface, d *extensions.Deployment) er
if err != nil { if err != nil {
return false, err return false, err
} }
oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c) oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
if err != nil { if err != nil {
return false, err return false, err
} }
@@ -276,8 +276,8 @@ func WatchRecreateDeployment(c clientset.Interface, d *extensions.Deployment) er
status = d.Status status = d.Status
if d.Status.UpdatedReplicas > 0 && d.Status.Replicas != d.Status.UpdatedReplicas { if d.Status.UpdatedReplicas > 0 && d.Status.Replicas != d.Status.UpdatedReplicas {
_, allOldRSs, err := deploymentutil.GetOldReplicaSets(d, c) _, allOldRSs, err := deploymentutil.GetOldReplicaSets(d, c.ExtensionsV1beta1())
newRS, nerr := deploymentutil.GetNewReplicaSet(d, c) newRS, nerr := deploymentutil.GetNewReplicaSet(d, c.ExtensionsV1beta1())
if err == nil && nerr == nil { if err == nil && nerr == nil {
Logf("%+v", d) Logf("%+v", d)
logReplicaSetsOfDeployment(d, allOldRSs, newRS) logReplicaSetsOfDeployment(d, allOldRSs, newRS)

2
test/e2e/framework/rs_util.go
View File

@@ -63,7 +63,7 @@ func CheckNewRSAnnotations(c clientset.Interface, ns, deploymentName string, exp
if err != nil { if err != nil {
return err return err
} }
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c) newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
if err != nil { if err != nil {
return err return err
} }

6
test/e2e/upgrades/apps/deployments.go
View File

@@ -81,7 +81,7 @@ func (t *DeploymentUpgradeTest) Setup(f *framework.Framework) {
By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName)) By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName))
framework.ExpectNoError(framework.WaitForDeploymentStatusValid(c, deployment)) framework.ExpectNoError(framework.WaitForDeploymentStatusValid(c, deployment))
rs, err := deploymentutil.GetNewReplicaSet(deployment, c) rs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
framework.ExpectNoError(err) framework.ExpectNoError(err)
if rs == nil { if rs == nil {
framework.ExpectNoError(fmt.Errorf("expected a new replica set for deployment %q, found none", deployment.Name)) framework.ExpectNoError(fmt.Errorf("expected a new replica set for deployment %q, found none", deployment.Name))
@@ -108,7 +108,7 @@ func (t *DeploymentUpgradeTest) Setup(f *framework.Framework) {
By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName)) By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName))
framework.ExpectNoError(framework.WaitForDeploymentStatus(c, deployment)) framework.ExpectNoError(framework.WaitForDeploymentStatus(c, deployment))
rs, err = deploymentutil.GetNewReplicaSet(deployment, c) rs, err = deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
framework.ExpectNoError(err) framework.ExpectNoError(err)
if rs == nil { if rs == nil {
framework.ExpectNoError(fmt.Errorf("expected a new replica set for deployment %q", deployment.Name)) framework.ExpectNoError(fmt.Errorf("expected a new replica set for deployment %q", deployment.Name))
@@ -141,7 +141,7 @@ func (t *DeploymentUpgradeTest) Test(f *framework.Framework, done <-chan struct{
framework.ExpectNoError(framework.WaitForDeploymentStatus(c, deployment)) framework.ExpectNoError(framework.WaitForDeploymentStatus(c, deployment))
By(fmt.Sprintf("Checking that replica sets for deployment %q are the same as prior to the upgrade", t.updatedD.Name)) By(fmt.Sprintf("Checking that replica sets for deployment %q are the same as prior to the upgrade", t.updatedD.Name))
_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(t.updatedD, c) _, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(t.updatedD, c.ExtensionsV1beta1())
framework.ExpectNoError(err) framework.ExpectNoError(err)
if newRS == nil { if newRS == nil {
By(t.spewDeploymentAndReplicaSets(newRS, allOldRSs)) By(t.spewDeploymentAndReplicaSets(newRS, allOldRSs))

8
test/e2e_federation/ingress.go
View File

@@ -327,7 +327,7 @@ func waitForIngressOrFail(clientset *kubeclientset.Clientset, namespace string,
var clusterIngress *v1beta1.Ingress var clusterIngress *v1beta1.Ingress
err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) { err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
var err error var err error
clusterIngress, err = clientset.Ingresses(namespace).Get(ingress.Name, metav1.GetOptions{}) clusterIngress, err = clientset.ExtensionsV1beta1().Ingresses(namespace).Get(ingress.Name, metav1.GetOptions{})
if (!present) && errors.IsNotFound(err) { // We want it gone, and it's gone. if (!present) && errors.IsNotFound(err) { // We want it gone, and it's gone.
By(fmt.Sprintf("Success: shard of federated ingress %q in namespace %q in cluster is absent", ingress.Name, namespace)) By(fmt.Sprintf("Success: shard of federated ingress %q in namespace %q in cluster is absent", ingress.Name, namespace))
return true, nil // Success return true, nil // Success
@@ -367,7 +367,7 @@ func waitForIngressShardsUpdatedOrFail(namespace string, ingress *v1beta1.Ingres
func waitForIngressUpdateOrFail(clientset *kubeclientset.Clientset, namespace string, ingress *v1beta1.Ingress, timeout time.Duration) { func waitForIngressUpdateOrFail(clientset *kubeclientset.Clientset, namespace string, ingress *v1beta1.Ingress, timeout time.Duration) {
By(fmt.Sprintf("Fetching a federated ingress shard of ingress %q in namespace %q from cluster", ingress.Name, namespace)) By(fmt.Sprintf("Fetching a federated ingress shard of ingress %q in namespace %q from cluster", ingress.Name, namespace))
err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) { err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
clusterIngress, err := clientset.Ingresses(namespace).Get(ingress.Name, metav1.GetOptions{}) clusterIngress, err := clientset.ExtensionsV1beta1().Ingresses(namespace).Get(ingress.Name, metav1.GetOptions{})
if err == nil { // We want it present, and the Get succeeded, so we're all good. if err == nil { // We want it present, and the Get succeeded, so we're all good.
if equivalentIngress(*clusterIngress, *ingress) { if equivalentIngress(*clusterIngress, *ingress) {
By(fmt.Sprintf("Success: shard of federated ingress %q in namespace %q in cluster is updated", ingress.Name, namespace)) By(fmt.Sprintf("Success: shard of federated ingress %q in namespace %q in cluster is updated", ingress.Name, namespace))
@@ -394,7 +394,7 @@ func deleteIngressOrFail(clientset *fedclientset.Clientset, namespace string, in
if clientset == nil || len(namespace) == 0 || len(ingressName) == 0 { if clientset == nil || len(namespace) == 0 || len(ingressName) == 0 {
Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteIngressOrFail: clientset: %v, namespace: %v, ingress: %v", clientset, namespace, ingressName)) Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteIngressOrFail: clientset: %v, namespace: %v, ingress: %v", clientset, namespace, ingressName))
} }
err := clientset.Ingresses(namespace).Delete(ingressName, &metav1.DeleteOptions{OrphanDependents: orphanDependents}) err := clientset.ExtensionsV1beta1().Ingresses(namespace).Delete(ingressName, &metav1.DeleteOptions{OrphanDependents: orphanDependents})
framework.ExpectNoError(err, "Error deleting ingress %q from namespace %q", ingressName, namespace) framework.ExpectNoError(err, "Error deleting ingress %q from namespace %q", ingressName, namespace)
// Wait for the ingress to be deleted. // Wait for the ingress to be deleted.
err = wait.Poll(framework.Poll, FederatedIngressDeleteTimeout, func() (bool, error) { err = wait.Poll(framework.Poll, FederatedIngressDeleteTimeout, func() (bool, error) {
@@ -414,7 +414,7 @@ func deleteClusterIngressOrFail(clusterName string, clientset *kubeclientset.Cli
if clientset == nil || len(namespace) == 0 || len(ingressName) == 0 { if clientset == nil || len(namespace) == 0 || len(ingressName) == 0 {
Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteClusterIngressOrFail: cluster: %q, clientset: %v, namespace: %v, ingress: %v", clusterName, clientset, namespace, ingressName)) Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteClusterIngressOrFail: cluster: %q, clientset: %v, namespace: %v, ingress: %v", clusterName, clientset, namespace, ingressName))
} }
err := clientset.Ingresses(namespace).Delete(ingressName, metav1.NewDeleteOptions(0)) err := clientset.ExtensionsV1beta1().Ingresses(namespace).Delete(ingressName, metav1.NewDeleteOptions(0))
framework.ExpectNoError(err, "Error deleting cluster ingress %q/%q from cluster %q", namespace, ingressName, clusterName) framework.ExpectNoError(err, "Error deleting cluster ingress %q/%q from cluster %q", namespace, ingressName, clusterName)
} }

4
test/e2e_federation/replicaset.go
View File

@@ -311,7 +311,7 @@ func waitForReplicaSetOrFail(c *fedclientset.Clientset, namespace string, replic
func waitForReplicaSet(c *fedclientset.Clientset, namespace string, replicaSetName string, clusters fedframework.ClusterSlice, expect map[string]int32) error { func waitForReplicaSet(c *fedclientset.Clientset, namespace string, replicaSetName string, clusters fedframework.ClusterSlice, expect map[string]int32) error {
framework.Logf("waitForReplicaSet: %s/%s; clusters: %v; expect: %v", namespace, replicaSetName, clusters, expect) framework.Logf("waitForReplicaSet: %s/%s; clusters: %v; expect: %v", namespace, replicaSetName, clusters, expect)
err := wait.Poll(10*time.Second, fedframework.FederatedDefaultTestTimeout, func() (bool, error) { err := wait.Poll(10*time.Second, fedframework.FederatedDefaultTestTimeout, func() (bool, error) {
frs, err := c.ReplicaSets(namespace).Get(replicaSetName, metav1.GetOptions{}) frs, err := c.ExtensionsV1beta1().ReplicaSets(namespace).Get(replicaSetName, metav1.GetOptions{})
if err != nil { if err != nil {
return false, err return false, err
} }
@@ -392,7 +392,7 @@ func updateReplicaSetOrFail(clientset *fedclientset.Clientset, replicaset *v1bet
} }
By(fmt.Sprintf("Updating federation replicaset %q in namespace %q", replicaset.Name, namespace)) By(fmt.Sprintf("Updating federation replicaset %q in namespace %q", replicaset.Name, namespace))
newRS, err := clientset.ReplicaSets(namespace).Update(replicaset) newRS, err := clientset.ExtensionsV1beta1().ReplicaSets(namespace).Update(replicaset)
framework.ExpectNoError(err, "Updating replicaset %q in namespace %q", replicaset.Name, namespace) framework.ExpectNoError(err, "Updating replicaset %q in namespace %q", replicaset.Name, namespace)
By(fmt.Sprintf("Successfully updated federation replicaset %q in namespace %q", replicaset.Name, namespace)) By(fmt.Sprintf("Successfully updated federation replicaset %q in namespace %q", replicaset.Name, namespace))

14
test/e2e_federation/service.go
View File

@@ -68,7 +68,7 @@ var _ = framework.KubeDescribe("Federated Services [Feature:Federation]", func()
By(fmt.Sprintf("Creation of service %q in namespace %q succeeded. Deleting service.", service.Name, nsName)) By(fmt.Sprintf("Creation of service %q in namespace %q succeeded. Deleting service.", service.Name, nsName))
// Cleanup // Cleanup
err := f.FederationClientset.Services(nsName).Delete(service.Name, &metav1.DeleteOptions{}) err := f.FederationClientset.CoreV1().Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, service.Namespace) framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, service.Namespace)
By(fmt.Sprintf("Deletion of service %q in namespace %q succeeded.", service.Name, nsName)) By(fmt.Sprintf("Deletion of service %q in namespace %q succeeded.", service.Name, nsName))
}) })
@@ -113,7 +113,7 @@ var _ = framework.KubeDescribe("Federated Services [Feature:Federation]", func()
service = createServiceOrFail(f.FederationClientset, nsName, FederatedServiceName) service = createServiceOrFail(f.FederationClientset, nsName, FederatedServiceName)
defer func() { // Cleanup defer func() { // Cleanup
By(fmt.Sprintf("Deleting service %q in namespace %q", service.Name, nsName)) By(fmt.Sprintf("Deleting service %q in namespace %q", service.Name, nsName))
err := f.FederationClientset.Services(nsName).Delete(service.Name, &metav1.DeleteOptions{}) err := f.FederationClientset.CoreV1().Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, nsName) framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, nsName)
}() }()
By(fmt.Sprintf("Wait for service shards to be created in all clusters for service \"%s/%s\"", nsName, service.Name)) By(fmt.Sprintf("Wait for service shards to be created in all clusters for service \"%s/%s\"", nsName, service.Name))
@@ -151,7 +151,7 @@ var _ = framework.KubeDescribe("Federated Services [Feature:Federation]", func()
defer func() { defer func() {
// Cleanup // Cleanup
By(fmt.Sprintf("Deleting service %q in namespace %q", service.Name, nsName)) By(fmt.Sprintf("Deleting service %q in namespace %q", service.Name, nsName))
err := f.FederationClientset.Services(nsName).Delete(service.Name, &metav1.DeleteOptions{}) err := f.FederationClientset.CoreV1().Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, nsName) framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, nsName)
}() }()
By(fmt.Sprintf("Wait for service shards to be created in all clusters for service \"%s/%s\"", nsName, service.Name)) By(fmt.Sprintf("Wait for service shards to be created in all clusters for service \"%s/%s\"", nsName, service.Name))
@@ -258,7 +258,7 @@ var _ = framework.KubeDescribe("Federated Services [Feature:Federation]", func()
By("Verified that DNS rules are working as expected") By("Verified that DNS rules are working as expected")
By("Deleting the service to verify that DNS rules still work") By("Deleting the service to verify that DNS rules still work")
err := f.FederationClientset.Services(nsName).Delete(FederatedServiceName, &metav1.DeleteOptions{}) err := f.FederationClientset.CoreV1().Services(nsName).Delete(FederatedServiceName, &metav1.DeleteOptions{})
framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, service.Namespace) framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, service.Namespace)
// Service is deleted, unset the test block-global service variable. // Service is deleted, unset the test block-global service variable.
service = nil service = nil
@@ -359,16 +359,16 @@ func verifyCascadingDeletionForService(clientset *fedclientset.Clientset, cluste
} }
func updateServiceOrFail(clientset *fedclientset.Clientset, namespace, name string) *v1.Service { func updateServiceOrFail(clientset *fedclientset.Clientset, namespace, name string) *v1.Service {
service, err := clientset.Services(namespace).Get(name, metav1.GetOptions{}) service, err := clientset.CoreV1().Services(namespace).Get(name, metav1.GetOptions{})
framework.ExpectNoError(err, "Getting service %q in namespace %q", name, namespace) framework.ExpectNoError(err, "Getting service %q in namespace %q", name, namespace)
service.Spec.Selector["name"] = "update-demo" service.Spec.Selector["name"] = "update-demo"
newService, err := clientset.Services(namespace).Update(service) newService, err := clientset.CoreV1().Services(namespace).Update(service)
By(fmt.Sprintf("Successfully updated federated service %q in namespace %q", name, namespace)) By(fmt.Sprintf("Successfully updated federated service %q in namespace %q", name, namespace))
return newService return newService
} }
func deleteServiceShard(c *fedframework.Cluster, namespace, service string) error { func deleteServiceShard(c *fedframework.Cluster, namespace, service string) error {
err := c.Clientset.Services(namespace).Delete(service, &metav1.DeleteOptions{}) err := c.Clientset.CoreV1().Services(namespace).Delete(service, &metav1.DeleteOptions{})
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
framework.Logf("Failed to delete service %q in namespace %q, in cluster %q", service, namespace, c.Name) framework.Logf("Failed to delete service %q in namespace %q, in cluster %q", service, namespace, c.Name)
return err return err

12
test/e2e_federation/util.go
View File

@@ -88,7 +88,7 @@ func createClusterObjectOrFail(f *fedframework.Framework, context *fedframework.
func waitForServiceOrFail(clientset *kubeclientset.Clientset, namespace string, service *v1.Service, present bool, timeout time.Duration) { func waitForServiceOrFail(clientset *kubeclientset.Clientset, namespace string, service *v1.Service, present bool, timeout time.Duration) {
By(fmt.Sprintf("Fetching a federated service shard of service %q in namespace %q from cluster", service.Name, namespace)) By(fmt.Sprintf("Fetching a federated service shard of service %q in namespace %q from cluster", service.Name, namespace))
err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) { err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
clusterService, err := clientset.Services(namespace).Get(service.Name, metav1.GetOptions{}) clusterService, err := clientset.CoreV1().Services(namespace).Get(service.Name, metav1.GetOptions{})
if (!present) && errors.IsNotFound(err) { // We want it gone, and it's gone. if (!present) && errors.IsNotFound(err) { // We want it gone, and it's gone.
By(fmt.Sprintf("Success: shard of federated service %q in namespace %q in cluster is absent", service.Name, namespace)) By(fmt.Sprintf("Success: shard of federated service %q in namespace %q in cluster is absent", service.Name, namespace))
return true, nil // Success return true, nil // Success
@@ -141,7 +141,7 @@ func createService(clientset *fedclientset.Clientset, namespace, name string) (*
} }
By(fmt.Sprintf("Trying to create service %q in namespace %q", service.Name, namespace)) By(fmt.Sprintf("Trying to create service %q in namespace %q", service.Name, namespace))
return clientset.Services(namespace).Create(service) return clientset.CoreV1().Services(namespace).Create(service)
} }
func createLBService(clientset *fedclientset.Clientset, namespace, name string) (*v1.Service, error) { func createLBService(clientset *fedclientset.Clientset, namespace, name string) (*v1.Service, error) {
@@ -178,7 +178,7 @@ func createLBService(clientset *fedclientset.Clientset, namespace, name string)
} }
By(fmt.Sprintf("Trying to create service %q in namespace %q", service.Name, namespace)) By(fmt.Sprintf("Trying to create service %q in namespace %q", service.Name, namespace))
return clientset.Services(namespace).Create(service) return clientset.CoreV1().Services(namespace).Create(service)
} }
func createServiceOrFail(clientset *fedclientset.Clientset, namespace, name string) *v1.Service { func createServiceOrFail(clientset *fedclientset.Clientset, namespace, name string) *v1.Service {
@@ -200,7 +200,7 @@ func deleteServiceOrFail(clientset *fedclientset.Clientset, namespace string, se
Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteServiceOrFail: clientset: %v, namespace: %v, service: %v", clientset, namespace, serviceName)) Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteServiceOrFail: clientset: %v, namespace: %v, service: %v", clientset, namespace, serviceName))
} }
framework.Logf("Deleting service %q in namespace %v", serviceName, namespace) framework.Logf("Deleting service %q in namespace %v", serviceName, namespace)
err := clientset.Services(namespace).Delete(serviceName, &metav1.DeleteOptions{OrphanDependents: orphanDependents}) err := clientset.CoreV1().Services(namespace).Delete(serviceName, &metav1.DeleteOptions{OrphanDependents: orphanDependents})
framework.ExpectNoError(err, "Error deleting service %q from namespace %q", serviceName, namespace) framework.ExpectNoError(err, "Error deleting service %q from namespace %q", serviceName, namespace)
// Wait for the service to be deleted. // Wait for the service to be deleted.
err = wait.Poll(5*time.Second, fedframework.FederatedDefaultTestTimeout, func() (bool, error) { err = wait.Poll(5*time.Second, fedframework.FederatedDefaultTestTimeout, func() (bool, error) {
@@ -224,7 +224,7 @@ func cleanupServiceShardsAndProviderResources(namespace string, service *v1.Serv
err := wait.PollImmediate(framework.Poll, fedframework.FederatedDefaultTestTimeout, func() (bool, error) { err := wait.PollImmediate(framework.Poll, fedframework.FederatedDefaultTestTimeout, func() (bool, error) {
var err error var err error
cSvc, err = c.Clientset.Services(namespace).Get(service.Name, metav1.GetOptions{}) cSvc, err = c.Clientset.CoreV1().Services(namespace).Get(service.Name, metav1.GetOptions{})
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
// Get failed with an error, try again. // Get failed with an error, try again.
framework.Logf("Failed to find service %q in namespace %q, in cluster %q: %v. Trying again in %s", service.Name, namespace, name, err, framework.Poll) framework.Logf("Failed to find service %q in namespace %q, in cluster %q: %v. Trying again in %s", service.Name, namespace, name, err, framework.Poll)
@@ -260,7 +260,7 @@ func cleanupServiceShardsAndProviderResources(namespace string, service *v1.Serv
func cleanupServiceShard(clientset *kubeclientset.Clientset, clusterName, namespace string, service *v1.Service, timeout time.Duration) error { func cleanupServiceShard(clientset *kubeclientset.Clientset, clusterName, namespace string, service *v1.Service, timeout time.Duration) error {
err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) { err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
err := clientset.Services(namespace).Delete(service.Name, &metav1.DeleteOptions{}) err := clientset.CoreV1().Services(namespace).Delete(service.Name, &metav1.DeleteOptions{})
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
// Deletion failed with an error, try again. // Deletion failed with an error, try again.
framework.Logf("Failed to delete service %q in namespace %q, in cluster %q", service.Name, namespace, clusterName) framework.Logf("Failed to delete service %q in namespace %q, in cluster %q", service.Name, namespace, clusterName)

2
test/e2e_node/e2e_node_suite_test.go
View File

@@ -265,7 +265,7 @@ func updateTestContext() error {
// getNode gets node object from the apiserver. // getNode gets node object from the apiserver.
func getNode(c *clientset.Clientset) (*v1.Node, error) { func getNode(c *clientset.Clientset) (*v1.Node, error) {
nodes, err := c.Nodes().List(metav1.ListOptions{}) nodes, err := c.CoreV1().Nodes().List(metav1.ListOptions{})
Expect(err).NotTo(HaveOccurred(), "should be able to list nodes.") Expect(err).NotTo(HaveOccurred(), "should be able to list nodes.")
if nodes == nil { if nodes == nil {
return nil, fmt.Errorf("the node list is nil.") return nil, fmt.Errorf("the node list is nil.")

2
test/integration/deployment/deployment_test.go
View File

@@ -58,7 +58,7 @@ func TestNewDeployment(t *testing.T) {
tester.waitForDeploymentStatusValidAndMarkPodsReady() tester.waitForDeploymentStatusValidAndMarkPodsReady()
// Check new RS annotations // Check new RS annotations
newRS, err := deploymentutil.GetNewReplicaSet(deploy, c) newRS, err := deploymentutil.GetNewReplicaSet(deploy, c.ExtensionsV1beta1())
if err != nil { if err != nil {
t.Fatalf("failed to get new ReplicaSet of Deployment %s: %v", deploy.Name, err) t.Fatalf("failed to get new ReplicaSet of Deployment %s: %v", deploy.Name, err)
} }

2
test/integration/master/master_test.go
View File

@@ -99,7 +99,7 @@ func TestKubernetesService(t *testing.T) {
_, _, closeFn := framework.RunAMaster(config) _, _, closeFn := framework.RunAMaster(config)
defer closeFn() defer closeFn()
coreClient := clientset.NewForConfigOrDie(config.GenericConfig.LoopbackClientConfig) coreClient := clientset.NewForConfigOrDie(config.GenericConfig.LoopbackClientConfig)
if _, err := coreClient.Services(metav1.NamespaceDefault).Get("kubernetes", metav1.GetOptions{}); err != nil { if _, err := coreClient.Core().Services(metav1.NamespaceDefault).Get("kubernetes", metav1.GetOptions{}); err != nil {
t.Fatalf("Expected kubernetes service to exists, got: %v", err) t.Fatalf("Expected kubernetes service to exists, got: %v", err)
} }
} }

98
test/integration/volume/persistent_volumes_test.go
View File

@@ -127,13 +127,13 @@ func TestPersistentVolumeRecycler(t *testing.T) {
pv := createPV("fake-pv-recycler", "/tmp/foo", "10G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, v1.PersistentVolumeReclaimRecycle) pv := createPV("fake-pv-recycler", "/tmp/foo", "10G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, v1.PersistentVolumeReclaimRecycle)
pvc := createPVC("fake-pvc-recycler", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "") pvc := createPVC("fake-pvc-recycler", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "")
_, err := testClient.PersistentVolumes().Create(pv) _, err := testClient.CoreV1().PersistentVolumes().Create(pv)
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolume: %v", err) t.Errorf("Failed to create PersistentVolume: %v", err)
} }
glog.V(2).Infof("TestPersistentVolumeRecycler pvc created") glog.V(2).Infof("TestPersistentVolumeRecycler pvc created")
_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) _, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolumeClaim: %v", err) t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
} }
@@ -146,7 +146,7 @@ func TestPersistentVolumeRecycler(t *testing.T) {
glog.V(2).Infof("TestPersistentVolumeRecycler pvc bound") glog.V(2).Infof("TestPersistentVolumeRecycler pvc bound")
// deleting a claim releases the volume, after which it can be recycled // deleting a claim releases the volume, after which it can be recycled
if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil { if err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
t.Errorf("error deleting claim %s", pvc.Name) t.Errorf("error deleting claim %s", pvc.Name)
} }
glog.V(2).Infof("TestPersistentVolumeRecycler pvc deleted") glog.V(2).Infof("TestPersistentVolumeRecycler pvc deleted")
@@ -182,12 +182,12 @@ func TestPersistentVolumeDeleter(t *testing.T) {
pv := createPV("fake-pv-deleter", "/tmp/foo", "10G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, v1.PersistentVolumeReclaimDelete) pv := createPV("fake-pv-deleter", "/tmp/foo", "10G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, v1.PersistentVolumeReclaimDelete)
pvc := createPVC("fake-pvc-deleter", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "") pvc := createPVC("fake-pvc-deleter", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "")
_, err := testClient.PersistentVolumes().Create(pv) _, err := testClient.CoreV1().PersistentVolumes().Create(pv)
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolume: %v", err) t.Errorf("Failed to create PersistentVolume: %v", err)
} }
glog.V(2).Infof("TestPersistentVolumeDeleter pv created") glog.V(2).Infof("TestPersistentVolumeDeleter pv created")
_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) _, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolumeClaim: %v", err) t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
} }
@@ -198,7 +198,7 @@ func TestPersistentVolumeDeleter(t *testing.T) {
glog.V(2).Infof("TestPersistentVolumeDeleter pvc bound") glog.V(2).Infof("TestPersistentVolumeDeleter pvc bound")
// deleting a claim releases the volume, after which it can be recycled // deleting a claim releases the volume, after which it can be recycled
if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil { if err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
t.Errorf("error deleting claim %s", pvc.Name) t.Errorf("error deleting claim %s", pvc.Name)
} }
glog.V(2).Infof("TestPersistentVolumeDeleter pvc deleted") glog.V(2).Infof("TestPersistentVolumeDeleter pvc deleted")
@@ -248,7 +248,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
clone, _ := api.Scheme.DeepCopy(pvc) clone, _ := api.Scheme.DeepCopy(pvc)
newPvc, _ := clone.(*v1.PersistentVolumeClaim) newPvc, _ := clone.(*v1.PersistentVolumeClaim)
newPvc.ObjectMeta = metav1.ObjectMeta{Name: fmt.Sprintf("fake-pvc-race-%d", counter)} newPvc.ObjectMeta = metav1.ObjectMeta{Name: fmt.Sprintf("fake-pvc-race-%d", counter)}
claim, err := testClient.PersistentVolumeClaims(ns.Name).Create(newPvc) claim, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(newPvc)
if err != nil { if err != nil {
t.Fatalf("Error creating newPvc: %v", err) t.Fatalf("Error creating newPvc: %v", err)
} }
@@ -266,7 +266,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
pv.Spec.ClaimRef = claimRef pv.Spec.ClaimRef = claimRef
pv.Spec.ClaimRef.UID = "" pv.Spec.ClaimRef.UID = ""
pv, err = testClient.PersistentVolumes().Create(pv) pv, err = testClient.CoreV1().PersistentVolumes().Create(pv)
if err != nil { if err != nil {
t.Fatalf("Unexpected error creating pv: %v", err) t.Fatalf("Unexpected error creating pv: %v", err)
} }
@@ -277,7 +277,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
waitForAnyPersistentVolumeClaimPhase(watchPVC, v1.ClaimBound) waitForAnyPersistentVolumeClaimPhase(watchPVC, v1.ClaimBound)
glog.V(2).Infof("TestPersistentVolumeBindRace pvc bound") glog.V(2).Infof("TestPersistentVolumeBindRace pvc bound")
pv, err = testClient.PersistentVolumes().Get(pv.Name, metav1.GetOptions{}) pv, err = testClient.CoreV1().PersistentVolumes().Get(pv.Name, metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
@@ -323,11 +323,11 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) {
pv_true.ObjectMeta.SetLabels(map[string]string{"foo": "true"}) pv_true.ObjectMeta.SetLabels(map[string]string{"foo": "true"})
pv_false.ObjectMeta.SetLabels(map[string]string{"foo": "false"}) pv_false.ObjectMeta.SetLabels(map[string]string{"foo": "false"})
_, err = testClient.PersistentVolumes().Create(pv_true) _, err = testClient.CoreV1().PersistentVolumes().Create(pv_true)
if err != nil { if err != nil {
t.Fatalf("Failed to create PersistentVolume: %v", err) t.Fatalf("Failed to create PersistentVolume: %v", err)
} }
_, err = testClient.PersistentVolumes().Create(pv_false) _, err = testClient.CoreV1().PersistentVolumes().Create(pv_false)
if err != nil { if err != nil {
t.Fatalf("Failed to create PersistentVolume: %v", err) t.Fatalf("Failed to create PersistentVolume: %v", err)
} }
@@ -339,7 +339,7 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) {
}, },
} }
_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) _, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil { if err != nil {
t.Fatalf("Failed to create PersistentVolumeClaim: %v", err) t.Fatalf("Failed to create PersistentVolumeClaim: %v", err)
} }
@@ -350,14 +350,14 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) {
waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, v1.ClaimBound) waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, v1.ClaimBound)
t.Log("claim bound") t.Log("claim bound")
pv, err := testClient.PersistentVolumes().Get("pv-false", metav1.GetOptions{}) pv, err := testClient.CoreV1().PersistentVolumes().Get("pv-false", metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
if pv.Spec.ClaimRef != nil { if pv.Spec.ClaimRef != nil {
t.Fatalf("False PV shouldn't be bound") t.Fatalf("False PV shouldn't be bound")
} }
pv, err = testClient.PersistentVolumes().Get("pv-true", metav1.GetOptions{}) pv, err = testClient.CoreV1().PersistentVolumes().Get("pv-true", metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
@@ -404,11 +404,11 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) {
pv_true.ObjectMeta.SetLabels(map[string]string{"foo": "valA", "bar": ""}) pv_true.ObjectMeta.SetLabels(map[string]string{"foo": "valA", "bar": ""})
pv_false.ObjectMeta.SetLabels(map[string]string{"foo": "valB", "baz": ""}) pv_false.ObjectMeta.SetLabels(map[string]string{"foo": "valB", "baz": ""})
_, err = testClient.PersistentVolumes().Create(pv_true) _, err = testClient.CoreV1().PersistentVolumes().Create(pv_true)
if err != nil { if err != nil {
t.Fatalf("Failed to create PersistentVolume: %v", err) t.Fatalf("Failed to create PersistentVolume: %v", err)
} }
_, err = testClient.PersistentVolumes().Create(pv_false) _, err = testClient.CoreV1().PersistentVolumes().Create(pv_false)
if err != nil { if err != nil {
t.Fatalf("Failed to create PersistentVolume: %v", err) t.Fatalf("Failed to create PersistentVolume: %v", err)
} }
@@ -439,7 +439,7 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) {
}, },
} }
_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) _, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil { if err != nil {
t.Fatalf("Failed to create PersistentVolumeClaim: %v", err) t.Fatalf("Failed to create PersistentVolumeClaim: %v", err)
} }
@@ -450,14 +450,14 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) {
waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, v1.ClaimBound) waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, v1.ClaimBound)
t.Log("claim bound") t.Log("claim bound")
pv, err := testClient.PersistentVolumes().Get("pv-false", metav1.GetOptions{}) pv, err := testClient.CoreV1().PersistentVolumes().Get("pv-false", metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
if pv.Spec.ClaimRef != nil { if pv.Spec.ClaimRef != nil {
t.Fatalf("False PV shouldn't be bound") t.Fatalf("False PV shouldn't be bound")
} }
pv, err = testClient.PersistentVolumes().Get("pv-true", metav1.GetOptions{}) pv, err = testClient.CoreV1().PersistentVolumes().Get("pv-true", metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
@@ -502,7 +502,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
pvc := createPVC("pvc-2", ns.Name, strconv.Itoa(maxPVs/2)+"G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "") pvc := createPVC("pvc-2", ns.Name, strconv.Itoa(maxPVs/2)+"G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "")
for i := 0; i < maxPVs; i++ { for i := 0; i < maxPVs; i++ {
_, err := testClient.PersistentVolumes().Create(pvs[i]) _, err := testClient.CoreV1().PersistentVolumes().Create(pvs[i])
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolume %d: %v", i, err) t.Errorf("Failed to create PersistentVolume %d: %v", i, err)
} }
@@ -510,7 +510,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
} }
t.Log("volumes created") t.Log("volumes created")
_, err := testClient.PersistentVolumeClaims(ns.Name).Create(pvc) _, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolumeClaim: %v", err) t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
} }
@@ -525,7 +525,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
// only one PV is bound // only one PV is bound
bound := 0 bound := 0
for i := 0; i < maxPVs; i++ { for i := 0; i < maxPVs; i++ {
pv, err := testClient.PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{}) pv, err := testClient.CoreV1().PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
@@ -550,7 +550,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
} }
// deleting a claim releases the volume // deleting a claim releases the volume
if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil { if err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
t.Errorf("error deleting claim %s", pvc.Name) t.Errorf("error deleting claim %s", pvc.Name)
} }
t.Log("claim deleted") t.Log("claim deleted")
@@ -599,7 +599,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// with >3000 volumes. // with >3000 volumes.
go func() { go func() {
for i := 0; i < objCount; i++ { for i := 0; i < objCount; i++ {
_, _ = testClient.PersistentVolumes().Create(pvs[i]) _, _ = testClient.CoreV1().PersistentVolumes().Create(pvs[i])
} }
}() }()
// Wait for them to get Available // Wait for them to get Available
@@ -620,7 +620,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// Modify PV // Modify PV
i := rand.Intn(objCount) i := rand.Intn(objCount)
name := "pv-" + strconv.Itoa(i) name := "pv-" + strconv.Itoa(i)
pv, err := testClient.PersistentVolumes().Get(name, metav1.GetOptions{}) pv, err := testClient.CoreV1().PersistentVolumes().Get(name, metav1.GetOptions{})
if err != nil { if err != nil {
// Silently ignore error, the PV may have be already deleted // Silently ignore error, the PV may have be already deleted
// or not exists yet. // or not exists yet.
@@ -632,7 +632,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
} else { } else {
pv.Annotations["TestAnnotation"] = fmt.Sprint(rand.Int()) pv.Annotations["TestAnnotation"] = fmt.Sprint(rand.Int())
} }
_, err = testClient.PersistentVolumes().Update(pv) _, err = testClient.CoreV1().PersistentVolumes().Update(pv)
if err != nil { if err != nil {
// Silently ignore error, the PV may have been updated by // Silently ignore error, the PV may have been updated by
// the controller. // the controller.
@@ -644,7 +644,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// Modify PVC // Modify PVC
i := rand.Intn(objCount) i := rand.Intn(objCount)
name := "pvc-" + strconv.Itoa(i) name := "pvc-" + strconv.Itoa(i)
pvc, err := testClient.PersistentVolumeClaims(metav1.NamespaceDefault).Get(name, metav1.GetOptions{}) pvc, err := testClient.CoreV1().PersistentVolumeClaims(metav1.NamespaceDefault).Get(name, metav1.GetOptions{})
if err != nil { if err != nil {
// Silently ignore error, the PVC may have be already // Silently ignore error, the PVC may have be already
// deleted or not exists yet. // deleted or not exists yet.
@@ -656,7 +656,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
} else { } else {
pvc.Annotations["TestAnnotation"] = fmt.Sprint(rand.Int()) pvc.Annotations["TestAnnotation"] = fmt.Sprint(rand.Int())
} }
_, err = testClient.PersistentVolumeClaims(metav1.NamespaceDefault).Update(pvc) _, err = testClient.CoreV1().PersistentVolumeClaims(metav1.NamespaceDefault).Update(pvc)
if err != nil { if err != nil {
// Silently ignore error, the PVC may have been updated by // Silently ignore error, the PVC may have been updated by
// the controller. // the controller.
@@ -679,7 +679,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// Create the claims, again in a separate goroutine. // Create the claims, again in a separate goroutine.
go func() { go func() {
for i := 0; i < objCount; i++ { for i := 0; i < objCount; i++ {
_, _ = testClient.PersistentVolumeClaims(ns.Name).Create(pvcs[i]) _, _ = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvcs[i])
} }
}() }()
@@ -699,7 +699,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// check that everything is bound to something // check that everything is bound to something
for i := 0; i < objCount; i++ { for i := 0; i < objCount; i++ {
pv, err := testClient.PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{}) pv, err := testClient.CoreV1().PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
@@ -708,7 +708,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
} }
glog.V(2).Infof("PV %q is bound to PVC %q", pv.Name, pv.Spec.ClaimRef.Name) glog.V(2).Infof("PV %q is bound to PVC %q", pv.Name, pv.Spec.ClaimRef.Name)
pvc, err := testClient.PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name, metav1.GetOptions{}) pvc, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name, metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pvc: %v", err) t.Fatalf("Unexpected error getting pvc: %v", err)
} }
@@ -748,13 +748,13 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
pvc := createPVC(pvcName, ns.Name, "1G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "") pvc := createPVC(pvcName, ns.Name, "1G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "")
pvc.Annotations = map[string]string{"annBindCompleted": ""} pvc.Annotations = map[string]string{"annBindCompleted": ""}
pvc.Spec.VolumeName = pvName pvc.Spec.VolumeName = pvName
newPVC, err := testClient.PersistentVolumeClaims(ns.Name).Create(pvc) newPVC, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil { if err != nil {
t.Fatalf("Cannot create claim %q: %v", pvc.Name, err) t.Fatalf("Cannot create claim %q: %v", pvc.Name, err)
} }
// Save Bound status as a separate transaction // Save Bound status as a separate transaction
newPVC.Status.Phase = v1.ClaimBound newPVC.Status.Phase = v1.ClaimBound
newPVC, err = testClient.PersistentVolumeClaims(ns.Name).UpdateStatus(newPVC) newPVC, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).UpdateStatus(newPVC)
if err != nil { if err != nil {
t.Fatalf("Cannot update claim status %q: %v", pvc.Name, err) t.Fatalf("Cannot update claim status %q: %v", pvc.Name, err)
} }
@@ -772,13 +772,13 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
return return
} }
pv.Spec.ClaimRef = claimRef pv.Spec.ClaimRef = claimRef
newPV, err := testClient.PersistentVolumes().Create(pv) newPV, err := testClient.CoreV1().PersistentVolumes().Create(pv)
if err != nil { if err != nil {
t.Fatalf("Cannot create volume %q: %v", pv.Name, err) t.Fatalf("Cannot create volume %q: %v", pv.Name, err)
} }
// Save Bound status as a separate transaction // Save Bound status as a separate transaction
newPV.Status.Phase = v1.VolumeBound newPV.Status.Phase = v1.VolumeBound
newPV, err = testClient.PersistentVolumes().UpdateStatus(newPV) newPV, err = testClient.CoreV1().PersistentVolumes().UpdateStatus(newPV)
if err != nil { if err != nil {
t.Fatalf("Cannot update volume status %q: %v", pv.Name, err) t.Fatalf("Cannot update volume status %q: %v", pv.Name, err)
} }
@@ -829,7 +829,7 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
// check that everything is bound to something // check that everything is bound to something
for i := 0; i < objCount; i++ { for i := 0; i < objCount; i++ {
pv, err := testClient.PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{}) pv, err := testClient.CoreV1().PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
@@ -838,7 +838,7 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
} }
glog.V(2).Infof("PV %q is bound to PVC %q", pv.Name, pv.Spec.ClaimRef.Name) glog.V(2).Infof("PV %q is bound to PVC %q", pv.Name, pv.Spec.ClaimRef.Name)
pvc, err := testClient.PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name, metav1.GetOptions{}) pvc, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name, metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pvc: %v", err) t.Fatalf("Unexpected error getting pvc: %v", err)
} }
@@ -895,7 +895,7 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
// early. It gets stuck with >3000 claims. // early. It gets stuck with >3000 claims.
go func() { go func() {
for i := 0; i < objCount; i++ { for i := 0; i < objCount; i++ {
_, _ = testClient.PersistentVolumeClaims(ns.Name).Create(pvcs[i]) _, _ = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvcs[i])
} }
}() }()
@@ -907,7 +907,7 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
glog.V(2).Infof("TestPersistentVolumeProvisionMultiPVCs: claims are bound") glog.V(2).Infof("TestPersistentVolumeProvisionMultiPVCs: claims are bound")
// check that we have enough bound PVs // check that we have enough bound PVs
pvList, err := testClient.PersistentVolumes().List(metav1.ListOptions{}) pvList, err := testClient.CoreV1().PersistentVolumes().List(metav1.ListOptions{})
if err != nil { if err != nil {
t.Fatalf("Failed to list volumes: %s", err) t.Fatalf("Failed to list volumes: %s", err)
} }
@@ -924,13 +924,13 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
// Delete the claims // Delete the claims
for i := 0; i < objCount; i++ { for i := 0; i < objCount; i++ {
_ = testClient.PersistentVolumeClaims(ns.Name).Delete(pvcs[i].Name, nil) _ = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvcs[i].Name, nil)
} }
// Wait for the PVs to get deleted by listing remaining volumes // Wait for the PVs to get deleted by listing remaining volumes
// (delete events were unreliable) // (delete events were unreliable)
for { for {
volumes, err := testClient.PersistentVolumes().List(metav1.ListOptions{}) volumes, err := testClient.CoreV1().PersistentVolumes().List(metav1.ListOptions{})
if err != nil { if err != nil {
t.Fatalf("Failed to list volumes: %v", err) t.Fatalf("Failed to list volumes: %v", err)
} }
@@ -974,17 +974,17 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
pvc := createPVC("pvc-rwm", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteMany}, "") pvc := createPVC("pvc-rwm", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteMany}, "")
_, err := testClient.PersistentVolumes().Create(pv_rwm) _, err := testClient.CoreV1().PersistentVolumes().Create(pv_rwm)
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolume: %v", err) t.Errorf("Failed to create PersistentVolume: %v", err)
} }
_, err = testClient.PersistentVolumes().Create(pv_rwo) _, err = testClient.CoreV1().PersistentVolumes().Create(pv_rwo)
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolume: %v", err) t.Errorf("Failed to create PersistentVolume: %v", err)
} }
t.Log("volumes created") t.Log("volumes created")
_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc) _, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil { if err != nil {
t.Errorf("Failed to create PersistentVolumeClaim: %v", err) t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
} }
@@ -997,14 +997,14 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
t.Log("claim bound") t.Log("claim bound")
// only RWM PV is bound // only RWM PV is bound
pv, err := testClient.PersistentVolumes().Get("pv-rwo", metav1.GetOptions{}) pv, err := testClient.CoreV1().PersistentVolumes().Get("pv-rwo", metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
if pv.Spec.ClaimRef != nil { if pv.Spec.ClaimRef != nil {
t.Fatalf("ReadWriteOnce PV shouldn't be bound") t.Fatalf("ReadWriteOnce PV shouldn't be bound")
} }
pv, err = testClient.PersistentVolumes().Get("pv-rwm", metav1.GetOptions{}) pv, err = testClient.CoreV1().PersistentVolumes().Get("pv-rwm", metav1.GetOptions{})
if err != nil { if err != nil {
t.Fatalf("Unexpected error getting pv: %v", err) t.Fatalf("Unexpected error getting pv: %v", err)
} }
@@ -1016,7 +1016,7 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
} }
// deleting a claim releases the volume // deleting a claim releases the volume
if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil { if err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
t.Errorf("error deleting claim %s", pvc.Name) t.Errorf("error deleting claim %s", pvc.Name)
} }
t.Log("claim deleted") t.Log("claim deleted")
@@ -1142,11 +1142,11 @@ func createClients(ns *v1.Namespace, t *testing.T, s *httptest.Server, syncPerio
t.Fatalf("Failed to construct PersistentVolumes: %v", err) t.Fatalf("Failed to construct PersistentVolumes: %v", err)
} }
watchPV, err := testClient.PersistentVolumes().Watch(metav1.ListOptions{}) watchPV, err := testClient.CoreV1().PersistentVolumes().Watch(metav1.ListOptions{})
if err != nil { if err != nil {
t.Fatalf("Failed to watch PersistentVolumes: %v", err) t.Fatalf("Failed to watch PersistentVolumes: %v", err)
} }
watchPVC, err := testClient.PersistentVolumeClaims(ns.Name).Watch(metav1.ListOptions{}) watchPVC, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Watch(metav1.ListOptions{})
if err != nil { if err != nil {
t.Fatalf("Failed to watch PersistentVolumeClaims: %v", err) t.Fatalf("Failed to watch PersistentVolumeClaims: %v", err)
} }

16
test/soak/serve_hostnames/serve_hostnames.go
View File

@@ -92,7 +92,7 @@ func main() {
var nodes *v1.NodeList var nodes *v1.NodeList
for start := time.Now(); time.Since(start) < nodeListTimeout; time.Sleep(2 * time.Second) { for start := time.Now(); time.Since(start) < nodeListTimeout; time.Sleep(2 * time.Second) {
nodes, err = client.Nodes().List(metav1.ListOptions{}) nodes, err = client.CoreV1().Nodes().List(metav1.ListOptions{})
if err == nil { if err == nil {
break break
} }
@@ -114,7 +114,7 @@ func main() {
queries := *queriesAverage * len(nodes.Items) * *podsPerNode queries := *queriesAverage * len(nodes.Items) * *podsPerNode
// Create the namespace // Create the namespace
got, err := client.Namespaces().Create(&v1.Namespace{ObjectMeta: metav1.ObjectMeta{GenerateName: "serve-hostnames-"}}) got, err := client.CoreV1().Namespaces().Create(&v1.Namespace{ObjectMeta: metav1.ObjectMeta{GenerateName: "serve-hostnames-"}})
if err != nil { if err != nil {
glog.Fatalf("Failed to create namespace: %v", err) glog.Fatalf("Failed to create namespace: %v", err)
} }
@@ -125,7 +125,7 @@ func main() {
} else { } else {
// wait until the namespace disappears // wait until the namespace disappears
for i := 0; i < int(namespaceDeleteTimeout/time.Second); i++ { for i := 0; i < int(namespaceDeleteTimeout/time.Second); i++ {
if _, err := client.Namespaces().Get(ns, metav1.GetOptions{}); err != nil { if _, err := client.CoreV1().Namespaces().Get(ns, metav1.GetOptions{}); err != nil {
if errors.IsNotFound(err) { if errors.IsNotFound(err) {
return return
} }
@@ -142,7 +142,7 @@ func main() {
var svc *v1.Service var svc *v1.Service
for start := time.Now(); time.Since(start) < serviceCreateTimeout; time.Sleep(2 * time.Second) { for start := time.Now(); time.Since(start) < serviceCreateTimeout; time.Sleep(2 * time.Second) {
t := time.Now() t := time.Now()
svc, err = client.Services(ns).Create(&v1.Service{ svc, err = client.CoreV1().Services(ns).Create(&v1.Service{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Name: "serve-hostnames", Name: "serve-hostnames",
Labels: map[string]string{ Labels: map[string]string{
@@ -175,7 +175,7 @@ func main() {
glog.Infof("Cleaning up service %s/serve-hostnames", ns) glog.Infof("Cleaning up service %s/serve-hostnames", ns)
// Make several attempts to delete the service. // Make several attempts to delete the service.
for start := time.Now(); time.Since(start) < deleteTimeout; time.Sleep(1 * time.Second) { for start := time.Now(); time.Since(start) < deleteTimeout; time.Sleep(1 * time.Second) {
if err := client.Services(ns).Delete(svc.Name, nil); err == nil { if err := client.CoreV1().Services(ns).Delete(svc.Name, nil); err == nil {
return return
} }
glog.Warningf("After %v unable to delete service %s/%s: %v", time.Since(start), ns, svc.Name, err) glog.Warningf("After %v unable to delete service %s/%s: %v", time.Since(start), ns, svc.Name, err)
@@ -192,7 +192,7 @@ func main() {
for start := time.Now(); time.Since(start) < podCreateTimeout; time.Sleep(2 * time.Second) { for start := time.Now(); time.Since(start) < podCreateTimeout; time.Sleep(2 * time.Second) {
glog.Infof("Creating pod %s/%s on node %s", ns, podName, node.Name) glog.Infof("Creating pod %s/%s on node %s", ns, podName, node.Name)
t := time.Now() t := time.Now()
_, err = client.Pods(ns).Create(&v1.Pod{ _, err = client.CoreV1().Pods(ns).Create(&v1.Pod{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Name: podName, Name: podName,
Labels: map[string]string{ Labels: map[string]string{
@@ -228,7 +228,7 @@ func main() {
// Make several attempts to delete the pods. // Make several attempts to delete the pods.
for _, podName := range podNames { for _, podName := range podNames {
for start := time.Now(); time.Since(start) < deleteTimeout; time.Sleep(1 * time.Second) { for start := time.Now(); time.Since(start) < deleteTimeout; time.Sleep(1 * time.Second) {
if err = client.Pods(ns).Delete(podName, nil); err == nil { if err = client.CoreV1().Pods(ns).Delete(podName, nil); err == nil {
break break
} }
glog.Warningf("After %v failed to delete pod %s/%s: %v", time.Since(start), ns, podName, err) glog.Warningf("After %v failed to delete pod %s/%s: %v", time.Since(start), ns, podName, err)
@@ -240,7 +240,7 @@ func main() {
for _, podName := range podNames { for _, podName := range podNames {
var pod *v1.Pod var pod *v1.Pod
for start := time.Now(); time.Since(start) < podStartTimeout; time.Sleep(5 * time.Second) { for start := time.Now(); time.Since(start) < podStartTimeout; time.Sleep(5 * time.Second) {
pod, err = client.Pods(ns).Get(podName, metav1.GetOptions{}) pod, err = client.CoreV1().Pods(ns).Get(podName, metav1.GetOptions{})
if err != nil { if err != nil {
glog.Warningf("Get pod %s/%s failed, ignoring for %v: %v", ns, podName, err, podStartTimeout) glog.Warningf("Get pod %s/%s failed, ignoring for %v: %v", ns, podName, err, podStartTimeout)
continue continue

4
test/utils/deployment.go
View File

@@ -85,7 +85,7 @@ func WaitForDeploymentStatusValid(c clientset.Interface, d *extensions.Deploymen
if err != nil { if err != nil {
return false, err return false, err
} }
oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c) oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
if err != nil { if err != nil {
return false, err return false, err
} }
@@ -154,7 +154,7 @@ func WaitForDeploymentRevisionAndImage(c clientset.Interface, ns, deploymentName
} }
// The new ReplicaSet needs to be non-nil and contain the pod-template-hash label // The new ReplicaSet needs to be non-nil and contain the pod-template-hash label
newRS, err = deploymentutil.GetNewReplicaSet(deployment, c) newRS, err = deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
if err != nil { if err != nil {
return false, err return false, err