github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-29 22:46:12 +00:00
Code Issues 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
commit 979c86f3dd
48 changed files with 472 additions and 492 deletions
Show Stats 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:
}
result := client.CoreV1Client.RESTClient().Get().AbsPath("/healthz").Do()
result := client.CoreV1().RESTClient().Get().AbsPath("/healthz").Do()
status := 0
result.StatusCode(&status)
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/apimachinery/pkg/apis/meta/v1: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",
],
)

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

@ -27,7 +27,6 @@ import (
"k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
clientset "k8s.io/client-go/kubernetes"
corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
restclient "k8s.io/client-go/rest"
kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
@ -121,7 +120,7 @@ func TestMarkMaster(t *testing.T) {
}))
defer s.Close()
cs, err := clientsetFromTestServer(s)
cs, err := clientset.NewForConfig(&restclient.Config{Host: s.URL})
if err != nil {
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 {
buf := new(bytes.Buffer)
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
}
// 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 {
return nil, err
}
return configmap, nil
}
// 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 {
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(
config.NodeName,
internalClientset,
client.Core(),
client.CoreV1(),
iptInterface,
sysctl,
execer,

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

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

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

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

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

@ -37,6 +37,7 @@ import (
"k8s.io/apimachinery/pkg/util/wait"
clientset "k8s.io/client-go/kubernetes"
"k8s.io/client-go/kubernetes/scheme"
extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
corelisters "k8s.io/client-go/listers/core/v1"
extensionslisters "k8s.io/client-go/listers/extensions/v1beta1"
"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.
// 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.
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))
if err != nil {
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.
// 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))
if err != nil {
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.
// 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))
if err != nil {
return nil, err
@ -534,9 +535,9 @@ func GetNewReplicaSet(deployment *extensions.Deployment, c clientset.Interface)
}
// 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) {
rsList, err := c.Extensions().ReplicaSets(namespace).List(options)
rsList, err := c.ReplicaSets(namespace).List(options)
if err != nil {
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 = addUpdatePodsReactor(fakeClient)
fakeClient = addUpdateRSReactor(fakeClient)
rs, err := GetNewReplicaSet(&newDeployment, fakeClient)
rs, err := GetNewReplicaSet(&newDeployment, fakeClient.ExtensionsV1beta1())
if err != nil {
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 = addGetRSReactor(fakeClient, test.objs[0])
fakeClient = addUpdateRSReactor(fakeClient)
_, rss, err := GetOldReplicaSets(&newDeployment, fakeClient)
_, rss, err := GetOldReplicaSets(&newDeployment, fakeClient.ExtensionsV1beta1())
if err != nil {
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/wait: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/core/v1: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/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.
fakeClient := f.tf.Client.(*fake.RESTClient)
clientset := internalclientset.NewForConfigOrDie(f.tf.ClientConfig)
clientset.CoreClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.AuthenticationClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.AuthorizationClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.AutoscalingClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.BatchClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.CertificatesClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.ExtensionsClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.RbacClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.StorageClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.AppsClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.PolicyClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Core().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Authentication().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Authorization().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Autoscaling().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Batch().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Certificates().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Extensions().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Rbac().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Storage().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Apps().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.Policy().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
clientset.DiscoveryClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
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/util/json"
"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_api_v1 "k8s.io/kubernetes/pkg/api/v1"
"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
// TODO: this should be a describer
func (h *DeploymentHistoryViewer) ViewHistory(namespace, name string, revision int64) (string, error) {
versionedClient := versionedClientsetForDeployment(h.c)
deployment, err := versionedClient.Extensions().Deployments(namespace).Get(name, metav1.GetOptions{})
versionedExtensionsClient := versionedExtensionsClientV1beta1(h.c)
deployment, err := versionedExtensionsClient.Deployments(namespace).Get(name, metav1.GetOptions{})
if err != nil {
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 {
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
// TODO: this should be a describer
func (h *DaemonSetHistoryViewer) ViewHistory(namespace, name string, revision int64) (string, error) {
versionedClient := versionedClientsetForDaemonSet(h.c)
ds, allHistory, err := controlledHistories(versionedClient, namespace, name)
versionedExtensionsClient := versionedExtensionsClientV1beta1(h.c)
versionedAppsClient := versionedAppsClientV1beta1(h.c)
ds, allHistory, err := controlledHistories(versionedExtensionsClient, versionedAppsClient, namespace, name)
if err != nil {
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
func controlledHistories(c externalclientset.Interface, namespace, name string) (*extensionsv1beta1.DaemonSet, []*appsv1beta1.ControllerRevision, error) {
ds, err := c.ExtensionsV1beta1().DaemonSets(namespace).Get(name, metav1.GetOptions{})
func controlledHistories(extensions clientextensionsv1beta1.ExtensionsV1beta1Interface, apps clientappsv1beta1.AppsV1beta1Interface, namespace, name string) (*extensionsv1beta1.DaemonSet, []*appsv1beta1.ControllerRevision, error) {
ds, err := extensions.DaemonSets(namespace).Get(name, metav1.GetOptions{})
if err != nil {
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 {
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 {
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 {
return "", fmt.Errorf("failed to convert deployment, %v", err)
}
versionedClient := versionedClientsetForDeployment(c)
_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(externalDeployment, versionedClient)
versionedExtensionsClient := versionedExtensionsClientV1beta1(c)
_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(externalDeployment, versionedExtensionsClient)
if err != nil {
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 {
return "", fmt.Errorf("passed object is not a DaemonSet: %#v", obj)
}
versionedClient := versionedClientsetForDaemonSet(r.c)
versionedDS, allHistory, err := controlledHistories(versionedClient, ds.Namespace, ds.Name)
versionedExtensionsClient := versionedExtensionsClientV1beta1(r.c)
versionedAppsClient := versionedAppsClientV1beta1(r.c)
versionedDS, allHistory, err := controlledHistories(versionedExtensionsClient, versionedAppsClient, ds.Namespace, ds.Name)
if err != nil {
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
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)
}

2
pkg/kubectl/rolling_updater_test.go
View File

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

26
pkg/kubectl/versioned_client.go
View File

@ -17,29 +17,23 @@ limitations under the License.
package kubectl
import (
externalclientset "k8s.io/client-go/kubernetes"
apps "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
core "k8s.io/client-go/kubernetes/typed/core/v1"
extensions "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
clientappsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
clientextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
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 {
return &externalclientset.Clientset{}
}
return &externalclientset.Clientset{
CoreV1Client: core.New(internalClient.Core().RESTClient()),
ExtensionsV1beta1Client: extensions.New(internalClient.Extensions().RESTClient()),
return &clientextensionsv1beta1.ExtensionsV1beta1Client{}
}
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 {
return &externalclientset.Clientset{}
}
return &externalclientset.Clientset{
AppsV1beta1Client: apps.New(internalClient.Apps().RESTClient()),
ExtensionsV1beta1Client: extensions.New(internalClient.Extensions().RESTClient()),
return &clientappsv1beta1.AppsV1beta1Client{}
}
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/sets: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",
],
)

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

@ -46,9 +46,7 @@ import (
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/client-go/dynamic"
versionedclientset "k8s.io/client-go/kubernetes"
coreclientset "k8s.io/client-go/kubernetes/typed/core/v1"
extensionsclientset "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
clientextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
federation "k8s.io/kubernetes/federation/apis/federation/v1beta1"
fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_clientset"
"k8s.io/kubernetes/pkg/api"
@ -141,12 +139,12 @@ func describerMap(c clientset.Interface) map[schema.GroupKind]printers.Describer
extensions.Kind("PodSecurityPolicy"): &PodSecurityPolicyDescriber{c},
autoscaling.Kind("HorizontalPodAutoscaler"): &HorizontalPodAutoscalerDescriber{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},
batch.Kind("Job"): &JobDescriber{c},
batch.Kind("CronJob"): &CronJobDescriber{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},
certificates.Kind("CertificateSigningRequest"): &CertificateSigningRequestDescriber{c},
storage.Kind("StorageClass"): &StorageClassDescriber{c},
@ -2836,11 +2834,11 @@ func DescribeEvents(el *api.EventList, w PrefixWriter) {
// DeploymentDescriber generates information about a deployment.
type DeploymentDescriber struct {
clientset.Interface
versionedClient versionedclientset.Interface
extensionV1beta1Client clientextensionsv1beta1.ExtensionsV1beta1Interface
}
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 {
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)
}
}
oldRSs, _, newRS, err := deploymentutil.GetAllReplicaSets(d, dd.versionedClient)
oldRSs, _, newRS, err := deploymentutil.GetAllReplicaSets(d, dd.extensionV1beta1Client)
if err == nil {
w.Write(LEVEL_0, "OldReplicaSets:\t%s\n", printReplicaSetsByLabels(oldRSs))
var newRSs []*versionedextension.ReplicaSet
@ -3650,14 +3648,12 @@ func (list SortableVolumeMounts) Less(i, j int) bool {
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 {
return &versionedclientset.Clientset{}
}
return &versionedclientset.Clientset{
CoreV1Client: coreclientset.New(internalClient.Core().RESTClient()),
ExtensionsV1beta1Client: extensionsclientset.New(internalClient.Extensions().RESTClient()),
return &clientextensionsv1beta1.ExtensionsV1beta1Client{}
}
return clientextensionsv1beta1.New(internalClient.Extensions().RESTClient())
}
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})
if err != nil {
t.Errorf("unexpected error: %v", err)
@ -1267,7 +1267,7 @@ func TestDescribeEvents(t *testing.T) {
Replicas: utilpointer.Int32Ptr(1),
Selector: &metav1.LabelSelector{},
},
}),
}).ExtensionsV1beta1(),
},
"EndpointsDescriber": &EndpointsDescriber{
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)
namingController := status.NewNamingConditionController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), crdClient)
namingController := status.NewNamingConditionController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), crdClient.Apiextensions())
finalizingController := finalizer.NewCRDFinalizer(
s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(),
crdClient,
crdClient.Apiextensions(),
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.
type Clientset struct {
*discovery.DiscoveryClient
*apiextensionsv1beta1.ApiextensionsV1beta1Client
apiextensionsV1beta1 *apiextensionsv1beta1.ApiextensionsV1beta1Client
}
// ApiextensionsV1beta1 retrieves the ApiextensionsV1beta1Client
func (c *Clientset) ApiextensionsV1beta1() apiextensionsv1beta1.ApiextensionsV1beta1Interface {
return c.ApiextensionsV1beta1Client
return c.apiextensionsV1beta1
}
// Deprecated: Apiextensions retrieves the default version of ApiextensionsClient.
// Please explicitly pick a version.
func (c *Clientset) Apiextensions() apiextensionsv1beta1.ApiextensionsV1beta1Interface {
return c.ApiextensionsV1beta1Client
return c.apiextensionsV1beta1
}
// Discovery retrieves the DiscoveryClient
@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.ApiextensionsV1beta1Client, err = apiextensionsv1beta1.NewForConfig(&configShallowCopy)
cs.apiextensionsV1beta1, err = apiextensionsv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.ApiextensionsV1beta1Client = apiextensionsv1beta1.NewForConfigOrDie(c)
cs.apiextensionsV1beta1 = apiextensionsv1beta1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.ApiextensionsV1beta1Client = apiextensionsv1beta1.New(c)
cs.apiextensionsV1beta1 = apiextensionsv1beta1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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.
type Clientset struct {
*discovery.DiscoveryClient
*apiextensionsinternalversion.ApiextensionsClient
apiextensions *apiextensionsinternalversion.ApiextensionsClient
}
// Apiextensions retrieves the ApiextensionsClient
func (c *Clientset) Apiextensions() apiextensionsinternalversion.ApiextensionsInterface {
return c.ApiextensionsClient
return c.apiextensions
}
// Discovery retrieves the DiscoveryClient
@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.ApiextensionsClient, err = apiextensionsinternalversion.NewForConfig(&configShallowCopy)
cs.apiextensions, err = apiextensionsinternalversion.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.ApiextensionsClient = apiextensionsinternalversion.NewForConfigOrDie(c)
cs.apiextensions = apiextensionsinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.ApiextensionsClient = apiextensionsinternalversion.New(c)
cs.apiextensions = apiextensionsinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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.
type Clientset struct {
*discovery.DiscoveryClient
*admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Client
*appsv1beta1.AppsV1beta1Client
*appsv1beta2.AppsV1beta2Client
*authenticationv1.AuthenticationV1Client
*authenticationv1beta1.AuthenticationV1beta1Client
*authorizationv1.AuthorizationV1Client
*authorizationv1beta1.AuthorizationV1beta1Client
*autoscalingv1.AutoscalingV1Client
*autoscalingv2alpha1.AutoscalingV2alpha1Client
*batchv1.BatchV1Client
*batchv2alpha1.BatchV2alpha1Client
*certificatesv1beta1.CertificatesV1beta1Client
*corev1.CoreV1Client
*extensionsv1beta1.ExtensionsV1beta1Client
*networkingv1.NetworkingV1Client
*policyv1beta1.PolicyV1beta1Client
*rbacv1beta1.RbacV1beta1Client
*rbacv1alpha1.RbacV1alpha1Client
*schedulingv1alpha1.SchedulingV1alpha1Client
*settingsv1alpha1.SettingsV1alpha1Client
*storagev1beta1.StorageV1beta1Client
*storagev1.StorageV1Client
admissionregistrationV1alpha1 *admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Client
appsV1beta1 *appsv1beta1.AppsV1beta1Client
appsV1beta2 *appsv1beta2.AppsV1beta2Client
authenticationV1 *authenticationv1.AuthenticationV1Client
authenticationV1beta1 *authenticationv1beta1.AuthenticationV1beta1Client
authorizationV1 *authorizationv1.AuthorizationV1Client
authorizationV1beta1 *authorizationv1beta1.AuthorizationV1beta1Client
autoscalingV1 *autoscalingv1.AutoscalingV1Client
autoscalingV2alpha1 *autoscalingv2alpha1.AutoscalingV2alpha1Client
batchV1 *batchv1.BatchV1Client
batchV2alpha1 *batchv2alpha1.BatchV2alpha1Client
certificatesV1beta1 *certificatesv1beta1.CertificatesV1beta1Client
coreV1 *corev1.CoreV1Client
extensionsV1beta1 *extensionsv1beta1.ExtensionsV1beta1Client
networkingV1 *networkingv1.NetworkingV1Client
policyV1beta1 *policyv1beta1.PolicyV1beta1Client
rbacV1beta1 *rbacv1beta1.RbacV1beta1Client
rbacV1alpha1 *rbacv1alpha1.RbacV1alpha1Client
schedulingV1alpha1 *schedulingv1alpha1.SchedulingV1alpha1Client
settingsV1alpha1 *settingsv1alpha1.SettingsV1alpha1Client
storageV1beta1 *storagev1beta1.StorageV1beta1Client
storageV1 *storagev1.StorageV1Client
}
// AdmissionregistrationV1alpha1 retrieves the AdmissionregistrationV1alpha1Client
func (c *Clientset) AdmissionregistrationV1alpha1() admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Interface {
return c.AdmissionregistrationV1alpha1Client
return c.admissionregistrationV1alpha1
}
// Deprecated: Admissionregistration retrieves the default version of AdmissionregistrationClient.
// Please explicitly pick a version.
func (c *Clientset) Admissionregistration() admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Interface {
return c.AdmissionregistrationV1alpha1Client
return c.admissionregistrationV1alpha1
}
// AppsV1beta1 retrieves the AppsV1beta1Client
func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {
return c.AppsV1beta1Client
return c.appsV1beta1
}
// AppsV1beta2 retrieves the AppsV1beta2Client
func (c *Clientset) AppsV1beta2() appsv1beta2.AppsV1beta2Interface {
return c.AppsV1beta2Client
return c.appsV1beta2
}
// Deprecated: Apps retrieves the default version of AppsClient.
// Please explicitly pick a version.
func (c *Clientset) Apps() appsv1beta2.AppsV1beta2Interface {
return c.AppsV1beta2Client
return c.appsV1beta2
}
// AuthenticationV1 retrieves the AuthenticationV1Client
func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
return c.AuthenticationV1Client
return c.authenticationV1
}
// Deprecated: Authentication retrieves the default version of AuthenticationClient.
// Please explicitly pick a version.
func (c *Clientset) Authentication() authenticationv1.AuthenticationV1Interface {
return c.AuthenticationV1Client
return c.authenticationV1
}
// AuthenticationV1beta1 retrieves the AuthenticationV1beta1Client
func (c *Clientset) AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface {
return c.AuthenticationV1beta1Client
return c.authenticationV1beta1
}
// AuthorizationV1 retrieves the AuthorizationV1Client
func (c *Clientset) AuthorizationV1() authorizationv1.AuthorizationV1Interface {
return c.AuthorizationV1Client
return c.authorizationV1
}
// Deprecated: Authorization retrieves the default version of AuthorizationClient.
// Please explicitly pick a version.
func (c *Clientset) Authorization() authorizationv1.AuthorizationV1Interface {
return c.AuthorizationV1Client
return c.authorizationV1
}
// AuthorizationV1beta1 retrieves the AuthorizationV1beta1Client
func (c *Clientset) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface {
return c.AuthorizationV1beta1Client
return c.authorizationV1beta1
}
// AutoscalingV1 retrieves the AutoscalingV1Client
func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {
return c.AutoscalingV1Client
return c.autoscalingV1
}
// Deprecated: Autoscaling retrieves the default version of AutoscalingClient.
// Please explicitly pick a version.
func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface {
return c.AutoscalingV1Client
return c.autoscalingV1
}
// AutoscalingV2alpha1 retrieves the AutoscalingV2alpha1Client
func (c *Clientset) AutoscalingV2alpha1() autoscalingv2alpha1.AutoscalingV2alpha1Interface {
return c.AutoscalingV2alpha1Client
return c.autoscalingV2alpha1
}
// BatchV1 retrieves the BatchV1Client
func (c *Clientset) BatchV1() batchv1.BatchV1Interface {
return c.BatchV1Client
return c.batchV1
}
// Deprecated: Batch retrieves the default version of BatchClient.
// Please explicitly pick a version.
func (c *Clientset) Batch() batchv1.BatchV1Interface {
return c.BatchV1Client
return c.batchV1
}
// BatchV2alpha1 retrieves the BatchV2alpha1Client
func (c *Clientset) BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface {
return c.BatchV2alpha1Client
return c.batchV2alpha1
}
// CertificatesV1beta1 retrieves the CertificatesV1beta1Client
func (c *Clientset) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface {
return c.CertificatesV1beta1Client
return c.certificatesV1beta1
}
// Deprecated: Certificates retrieves the default version of CertificatesClient.
// Please explicitly pick a version.
func (c *Clientset) Certificates() certificatesv1beta1.CertificatesV1beta1Interface {
return c.CertificatesV1beta1Client
return c.certificatesV1beta1
}
// CoreV1 retrieves the CoreV1Client
func (c *Clientset) CoreV1() corev1.CoreV1Interface {
return c.CoreV1Client
return c.coreV1
}
// Deprecated: Core retrieves the default version of CoreClient.
// Please explicitly pick a version.
func (c *Clientset) Core() corev1.CoreV1Interface {
return c.CoreV1Client
return c.coreV1
}
// ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client
func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface {
return c.ExtensionsV1beta1Client
return c.extensionsV1beta1
}
// Deprecated: Extensions retrieves the default version of ExtensionsClient.
// Please explicitly pick a version.
func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface {
return c.ExtensionsV1beta1Client
return c.extensionsV1beta1
}
// NetworkingV1 retrieves the NetworkingV1Client
func (c *Clientset) NetworkingV1() networkingv1.NetworkingV1Interface {
return c.NetworkingV1Client
return c.networkingV1
}
// Deprecated: Networking retrieves the default version of NetworkingClient.
// Please explicitly pick a version.
func (c *Clientset) Networking() networkingv1.NetworkingV1Interface {
return c.NetworkingV1Client
return c.networkingV1
}
// PolicyV1beta1 retrieves the PolicyV1beta1Client
func (c *Clientset) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface {
return c.PolicyV1beta1Client
return c.policyV1beta1
}
// Deprecated: Policy retrieves the default version of PolicyClient.
// Please explicitly pick a version.
func (c *Clientset) Policy() policyv1beta1.PolicyV1beta1Interface {
return c.PolicyV1beta1Client
return c.policyV1beta1
}
// RbacV1beta1 retrieves the RbacV1beta1Client
func (c *Clientset) RbacV1beta1() rbacv1beta1.RbacV1beta1Interface {
return c.RbacV1beta1Client
return c.rbacV1beta1
}
// Deprecated: Rbac retrieves the default version of RbacClient.
// Please explicitly pick a version.
func (c *Clientset) Rbac() rbacv1beta1.RbacV1beta1Interface {
return c.RbacV1beta1Client
return c.rbacV1beta1
}
// RbacV1alpha1 retrieves the RbacV1alpha1Client
func (c *Clientset) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface {
return c.RbacV1alpha1Client
return c.rbacV1alpha1
}
// SchedulingV1alpha1 retrieves the SchedulingV1alpha1Client
func (c *Clientset) SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1Interface {
return c.SchedulingV1alpha1Client
return c.schedulingV1alpha1
}
// Deprecated: Scheduling retrieves the default version of SchedulingClient.
// Please explicitly pick a version.
func (c *Clientset) Scheduling() schedulingv1alpha1.SchedulingV1alpha1Interface {
return c.SchedulingV1alpha1Client
return c.schedulingV1alpha1
}
// SettingsV1alpha1 retrieves the SettingsV1alpha1Client
func (c *Clientset) SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface {
return c.SettingsV1alpha1Client
return c.settingsV1alpha1
}
// Deprecated: Settings retrieves the default version of SettingsClient.
// Please explicitly pick a version.
func (c *Clientset) Settings() settingsv1alpha1.SettingsV1alpha1Interface {
return c.SettingsV1alpha1Client
return c.settingsV1alpha1
}
// StorageV1beta1 retrieves the StorageV1beta1Client
func (c *Clientset) StorageV1beta1() storagev1beta1.StorageV1beta1Interface {
return c.StorageV1beta1Client
return c.storageV1beta1
}
// StorageV1 retrieves the StorageV1Client
func (c *Clientset) StorageV1() storagev1.StorageV1Interface {
return c.StorageV1Client
return c.storageV1
}
// Deprecated: Storage retrieves the default version of StorageClient.
// Please explicitly pick a version.
func (c *Clientset) Storage() storagev1.StorageV1Interface {
return c.StorageV1Client
return c.storageV1
}
// Discovery retrieves the DiscoveryClient
@ -345,91 +345,91 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.AdmissionregistrationV1alpha1Client, err = admissionregistrationv1alpha1.NewForConfig(&configShallowCopy)
cs.admissionregistrationV1alpha1, err = admissionregistrationv1alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.AppsV1beta1Client, err = appsv1beta1.NewForConfig(&configShallowCopy)
cs.appsV1beta1, err = appsv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.AppsV1beta2Client, err = appsv1beta2.NewForConfig(&configShallowCopy)
cs.appsV1beta2, err = appsv1beta2.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.AuthenticationV1Client, err = authenticationv1.NewForConfig(&configShallowCopy)
cs.authenticationV1, err = authenticationv1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.AuthenticationV1beta1Client, err = authenticationv1beta1.NewForConfig(&configShallowCopy)
cs.authenticationV1beta1, err = authenticationv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.AuthorizationV1Client, err = authorizationv1.NewForConfig(&configShallowCopy)
cs.authorizationV1, err = authorizationv1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.AuthorizationV1beta1Client, err = authorizationv1beta1.NewForConfig(&configShallowCopy)
cs.authorizationV1beta1, err = authorizationv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.AutoscalingV1Client, err = autoscalingv1.NewForConfig(&configShallowCopy)
cs.autoscalingV1, err = autoscalingv1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.AutoscalingV2alpha1Client, err = autoscalingv2alpha1.NewForConfig(&configShallowCopy)
cs.autoscalingV2alpha1, err = autoscalingv2alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.BatchV1Client, err = batchv1.NewForConfig(&configShallowCopy)
cs.batchV1, err = batchv1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.BatchV2alpha1Client, err = batchv2alpha1.NewForConfig(&configShallowCopy)
cs.batchV2alpha1, err = batchv2alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.CertificatesV1beta1Client, err = certificatesv1beta1.NewForConfig(&configShallowCopy)
cs.certificatesV1beta1, err = certificatesv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.CoreV1Client, err = corev1.NewForConfig(&configShallowCopy)
cs.coreV1, err = corev1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.ExtensionsV1beta1Client, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
cs.extensionsV1beta1, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.NetworkingV1Client, err = networkingv1.NewForConfig(&configShallowCopy)
cs.networkingV1, err = networkingv1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.PolicyV1beta1Client, err = policyv1beta1.NewForConfig(&configShallowCopy)
cs.policyV1beta1, err = policyv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.RbacV1beta1Client, err = rbacv1beta1.NewForConfig(&configShallowCopy)
cs.rbacV1beta1, err = rbacv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.RbacV1alpha1Client, err = rbacv1alpha1.NewForConfig(&configShallowCopy)
cs.rbacV1alpha1, err = rbacv1alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.SchedulingV1alpha1Client, err = schedulingv1alpha1.NewForConfig(&configShallowCopy)
cs.schedulingV1alpha1, err = schedulingv1alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.SettingsV1alpha1Client, err = settingsv1alpha1.NewForConfig(&configShallowCopy)
cs.settingsV1alpha1, err = settingsv1alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.StorageV1beta1Client, err = storagev1beta1.NewForConfig(&configShallowCopy)
cs.storageV1beta1, err = storagev1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
cs.StorageV1Client, err = storagev1.NewForConfig(&configShallowCopy)
cs.storageV1, err = storagev1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -446,28 +446,28 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.AdmissionregistrationV1alpha1Client = admissionregistrationv1alpha1.NewForConfigOrDie(c)
cs.AppsV1beta1Client = appsv1beta1.NewForConfigOrDie(c)
cs.AppsV1beta2Client = appsv1beta2.NewForConfigOrDie(c)
cs.AuthenticationV1Client = authenticationv1.NewForConfigOrDie(c)
cs.AuthenticationV1beta1Client = authenticationv1beta1.NewForConfigOrDie(c)
cs.AuthorizationV1Client = authorizationv1.NewForConfigOrDie(c)
cs.AuthorizationV1beta1Client = authorizationv1beta1.NewForConfigOrDie(c)
cs.AutoscalingV1Client = autoscalingv1.NewForConfigOrDie(c)
cs.AutoscalingV2alpha1Client = autoscalingv2alpha1.NewForConfigOrDie(c)
cs.BatchV1Client = batchv1.NewForConfigOrDie(c)
cs.BatchV2alpha1Client = batchv2alpha1.NewForConfigOrDie(c)
cs.CertificatesV1beta1Client = certificatesv1beta1.NewForConfigOrDie(c)
cs.CoreV1Client = corev1.NewForConfigOrDie(c)
cs.ExtensionsV1beta1Client = extensionsv1beta1.NewForConfigOrDie(c)
cs.NetworkingV1Client = networkingv1.NewForConfigOrDie(c)
cs.PolicyV1beta1Client = policyv1beta1.NewForConfigOrDie(c)
cs.RbacV1beta1Client = rbacv1beta1.NewForConfigOrDie(c)
cs.RbacV1alpha1Client = rbacv1alpha1.NewForConfigOrDie(c)
cs.SchedulingV1alpha1Client = schedulingv1alpha1.NewForConfigOrDie(c)
cs.SettingsV1alpha1Client = settingsv1alpha1.NewForConfigOrDie(c)
cs.StorageV1beta1Client = storagev1beta1.NewForConfigOrDie(c)
cs.StorageV1Client = storagev1.NewForConfigOrDie(c)
cs.admissionregistrationV1alpha1 = admissionregistrationv1alpha1.NewForConfigOrDie(c)
cs.appsV1beta1 = appsv1beta1.NewForConfigOrDie(c)
cs.appsV1beta2 = appsv1beta2.NewForConfigOrDie(c)
cs.authenticationV1 = authenticationv1.NewForConfigOrDie(c)
cs.authenticationV1beta1 = authenticationv1beta1.NewForConfigOrDie(c)
cs.authorizationV1 = authorizationv1.NewForConfigOrDie(c)
cs.authorizationV1beta1 = authorizationv1beta1.NewForConfigOrDie(c)
cs.autoscalingV1 = autoscalingv1.NewForConfigOrDie(c)
cs.autoscalingV2alpha1 = autoscalingv2alpha1.NewForConfigOrDie(c)
cs.batchV1 = batchv1.NewForConfigOrDie(c)
cs.batchV2alpha1 = batchv2alpha1.NewForConfigOrDie(c)
cs.certificatesV1beta1 = certificatesv1beta1.NewForConfigOrDie(c)
cs.coreV1 = corev1.NewForConfigOrDie(c)
cs.extensionsV1beta1 = extensionsv1beta1.NewForConfigOrDie(c)
cs.networkingV1 = networkingv1.NewForConfigOrDie(c)
cs.policyV1beta1 = policyv1beta1.NewForConfigOrDie(c)
cs.rbacV1beta1 = rbacv1beta1.NewForConfigOrDie(c)
cs.rbacV1alpha1 = rbacv1alpha1.NewForConfigOrDie(c)
cs.schedulingV1alpha1 = schedulingv1alpha1.NewForConfigOrDie(c)
cs.settingsV1alpha1 = settingsv1alpha1.NewForConfigOrDie(c)
cs.storageV1beta1 = storagev1beta1.NewForConfigOrDie(c)
cs.storageV1 = storagev1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -476,28 +476,28 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.AdmissionregistrationV1alpha1Client = admissionregistrationv1alpha1.New(c)
cs.AppsV1beta1Client = appsv1beta1.New(c)
cs.AppsV1beta2Client = appsv1beta2.New(c)
cs.AuthenticationV1Client = authenticationv1.New(c)
cs.AuthenticationV1beta1Client = authenticationv1beta1.New(c)
cs.AuthorizationV1Client = authorizationv1.New(c)
cs.AuthorizationV1beta1Client = authorizationv1beta1.New(c)
cs.AutoscalingV1Client = autoscalingv1.New(c)
cs.AutoscalingV2alpha1Client = autoscalingv2alpha1.New(c)
cs.BatchV1Client = batchv1.New(c)
cs.BatchV2alpha1Client = batchv2alpha1.New(c)
cs.CertificatesV1beta1Client = certificatesv1beta1.New(c)
cs.CoreV1Client = corev1.New(c)
cs.ExtensionsV1beta1Client = extensionsv1beta1.New(c)
cs.NetworkingV1Client = networkingv1.New(c)
cs.PolicyV1beta1Client = policyv1beta1.New(c)
cs.RbacV1beta1Client = rbacv1beta1.New(c)
cs.RbacV1alpha1Client = rbacv1alpha1.New(c)
cs.SchedulingV1alpha1Client = schedulingv1alpha1.New(c)
cs.SettingsV1alpha1Client = settingsv1alpha1.New(c)
cs.StorageV1beta1Client = storagev1beta1.New(c)
cs.StorageV1Client = storagev1.New(c)
cs.admissionregistrationV1alpha1 = admissionregistrationv1alpha1.New(c)
cs.appsV1beta1 = appsv1beta1.New(c)
cs.appsV1beta2 = appsv1beta2.New(c)
cs.authenticationV1 = authenticationv1.New(c)
cs.authenticationV1beta1 = authenticationv1beta1.New(c)
cs.authorizationV1 = authorizationv1.New(c)
cs.authorizationV1beta1 = authorizationv1beta1.New(c)
cs.autoscalingV1 = autoscalingv1.New(c)
cs.autoscalingV2alpha1 = autoscalingv2alpha1.New(c)
cs.batchV1 = batchv1.New(c)
cs.batchV2alpha1 = batchv2alpha1.New(c)
cs.certificatesV1beta1 = certificatesv1beta1.New(c)
cs.coreV1 = corev1.New(c)
cs.extensionsV1beta1 = extensionsv1beta1.New(c)
cs.networkingV1 = networkingv1.New(c)
cs.policyV1beta1 = policyv1beta1.New(c)
cs.rbacV1beta1 = rbacv1beta1.New(c)
cs.rbacV1alpha1 = rbacv1alpha1.New(c)
cs.schedulingV1alpha1 = schedulingv1alpha1.New(c)
cs.settingsV1alpha1 = settingsv1alpha1.New(c)
cs.storageV1beta1 = storagev1beta1.New(c)
cs.storageV1 = storagev1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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.
type Clientset struct {
*discovery.DiscoveryClient
*apiregistrationv1beta1.ApiregistrationV1beta1Client
apiregistrationV1beta1 *apiregistrationv1beta1.ApiregistrationV1beta1Client
}
// ApiregistrationV1beta1 retrieves the ApiregistrationV1beta1Client
func (c *Clientset) ApiregistrationV1beta1() apiregistrationv1beta1.ApiregistrationV1beta1Interface {
return c.ApiregistrationV1beta1Client
return c.apiregistrationV1beta1
}
// Deprecated: Apiregistration retrieves the default version of ApiregistrationClient.
// Please explicitly pick a version.
func (c *Clientset) Apiregistration() apiregistrationv1beta1.ApiregistrationV1beta1Interface {
return c.ApiregistrationV1beta1Client
return c.apiregistrationV1beta1
}
// Discovery retrieves the DiscoveryClient
@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.ApiregistrationV1beta1Client, err = apiregistrationv1beta1.NewForConfig(&configShallowCopy)
cs.apiregistrationV1beta1, err = apiregistrationv1beta1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.ApiregistrationV1beta1Client = apiregistrationv1beta1.NewForConfigOrDie(c)
cs.apiregistrationV1beta1 = apiregistrationv1beta1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.ApiregistrationV1beta1Client = apiregistrationv1beta1.New(c)
cs.apiregistrationV1beta1 = apiregistrationv1beta1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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.
type Clientset struct {
*discovery.DiscoveryClient
*apiregistrationinternalversion.ApiregistrationClient
apiregistration *apiregistrationinternalversion.ApiregistrationClient
}
// Apiregistration retrieves the ApiregistrationClient
func (c *Clientset) Apiregistration() apiregistrationinternalversion.ApiregistrationInterface {
return c.ApiregistrationClient
return c.apiregistration
}
// Discovery retrieves the DiscoveryClient
@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.ApiregistrationClient, err = apiregistrationinternalversion.NewForConfig(&configShallowCopy)
cs.apiregistration, err = apiregistrationinternalversion.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.ApiregistrationClient = apiregistrationinternalversion.NewForConfigOrDie(c)
cs.apiregistration = apiregistrationinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.ApiregistrationClient = apiregistrationinternalversion.New(c)
cs.apiregistration = apiregistrationinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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, "$", "$")
allGroups := clientgentypes.ToGroupVersionPackages(g.groups)
m := map[string]interface{}{
"allGroups": allGroups,
"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.
type Clientset struct {
*$.DiscoveryClient|raw$
$range .allGroups$*$.PackageName$.$.GroupVersion$Client
$range .allGroups$$.LowerCaseGroupVersion$ *$.PackageName$.$.GroupVersion$Client
$end$
}
`
@ -124,7 +123,7 @@ type Clientset struct {
var clientsetInterfaceImplTemplate = `
// $.GroupVersion$ retrieves the $.GroupVersion$Client
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.
// Please explicitly pick a version.
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 err error
$range .allGroups$ cs.$.GroupVersion$Client, err =$.PackageName$.NewForConfig(&configShallowCopy)
$range .allGroups$ cs.$.LowerCaseGroupVersion$, err =$.PackageName$.NewForConfig(&configShallowCopy)
if err!=nil {
return nil, err
}
@ -174,7 +173,7 @@ var newClientsetForConfigOrDieTemplate = `
// panics if there is an error in the config.
func NewForConfigOrDie(c *$.Config|raw$) *Clientset {
var cs Clientset
$range .allGroups$ cs.$.GroupVersion$Client =$.PackageName$.NewForConfigOrDie(c)
$range .allGroups$ cs.$.LowerCaseGroupVersion$ =$.PackageName$.NewForConfigOrDie(c)
$end$
cs.DiscoveryClient = $.NewDiscoveryClientForConfigOrDie|raw$(c)
return &cs
@ -185,7 +184,7 @@ var newClientsetForRESTClientTemplate = `
// New creates a new Clientset for the given RESTClient.
func New(c $.RESTClientInterface|raw$) *Clientset {
var cs Clientset
$range .allGroups$ cs.$.GroupVersion$Client =$.PackageName$.New(c)
$range .allGroups$ cs.$.LowerCaseGroupVersion$ =$.PackageName$.New(c)
$end$
cs.DiscoveryClient = $.NewDiscoveryClient|raw$(c)
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)
for _, version := range group.Versions {
groupVersionPackages = append(groupVersionPackages, GroupVersionPackage{
Group: Group(namer.IC(group.Group.NonEmpty())),
Version: Version(namer.IC(version.String())),
GroupVersion: namer.IC(group.Group.NonEmpty()) + namer.IC(version.String()),
PackageName: strings.ToLower(group.Group.NonEmpty() + version.NonEmpty()),
IsDefaultVersion: version == defaultVersion && version != "",
Group: Group(namer.IC(group.Group.NonEmpty())),
Version: Version(namer.IC(version.String())),
GroupVersion: namer.IC(group.Group.NonEmpty()) + namer.IC(version.String()),
LowerCaseGroupVersion: namer.IL(group.Group.NonEmpty()) + namer.IC(version.String()),
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
// 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.
IsDefaultVersion bool
GroupVersion string
PackageName string
IsDefaultVersion bool
GroupVersion string
LowerCaseGroupVersion string
PackageName string
}
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.
type Clientset struct {
*discovery.DiscoveryClient
*testgroupinternalversion.TestgroupClient
testgroup *testgroupinternalversion.TestgroupClient
}
// Testgroup retrieves the TestgroupClient
func (c *Clientset) Testgroup() testgroupinternalversion.TestgroupInterface {
return c.TestgroupClient
return c.testgroup
}
// Discovery retrieves the DiscoveryClient
@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.TestgroupClient, err = testgroupinternalversion.NewForConfig(&configShallowCopy)
cs.testgroup, err = testgroupinternalversion.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.TestgroupClient = testgroupinternalversion.NewForConfigOrDie(c)
cs.testgroup = testgroupinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.TestgroupClient = testgroupinternalversion.New(c)
cs.testgroup = testgroupinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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.
type Clientset struct {
*discovery.DiscoveryClient
*testgroupv1.TestgroupV1Client
testgroupV1 *testgroupv1.TestgroupV1Client
}
// TestgroupV1 retrieves the TestgroupV1Client
func (c *Clientset) TestgroupV1() testgroupv1.TestgroupV1Interface {
return c.TestgroupV1Client
return c.testgroupV1
}
// Deprecated: Testgroup retrieves the default version of TestgroupClient.
// Please explicitly pick a version.
func (c *Clientset) Testgroup() testgroupv1.TestgroupV1Interface {
return c.TestgroupV1Client
return c.testgroupV1
}
// Discovery retrieves the DiscoveryClient
@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.TestgroupV1Client, err = testgroupv1.NewForConfig(&configShallowCopy)
cs.testgroupV1, err = testgroupv1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.TestgroupV1Client = testgroupv1.NewForConfigOrDie(c)
cs.testgroupV1 = testgroupv1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.TestgroupV1Client = testgroupv1.New(c)
cs.testgroupV1 = testgroupv1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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.
type Clientset struct {
*discovery.DiscoveryClient
*metricsv1alpha1.MetricsV1alpha1Client
metricsV1alpha1 *metricsv1alpha1.MetricsV1alpha1Client
}
// MetricsV1alpha1 retrieves the MetricsV1alpha1Client
func (c *Clientset) MetricsV1alpha1() metricsv1alpha1.MetricsV1alpha1Interface {
return c.MetricsV1alpha1Client
return c.metricsV1alpha1
}
// Deprecated: Metrics retrieves the default version of MetricsClient.
// Please explicitly pick a version.
func (c *Clientset) Metrics() metricsv1alpha1.MetricsV1alpha1Interface {
return c.MetricsV1alpha1Client
return c.metricsV1alpha1
}
// Discovery retrieves the DiscoveryClient
@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.MetricsV1alpha1Client, err = metricsv1alpha1.NewForConfig(&configShallowCopy)
cs.metricsV1alpha1, err = metricsv1alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.MetricsV1alpha1Client = metricsv1alpha1.NewForConfigOrDie(c)
cs.metricsV1alpha1 = metricsv1alpha1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.MetricsV1alpha1Client = metricsv1alpha1.New(c)
cs.metricsV1alpha1 = metricsv1alpha1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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.
type Clientset struct {
*discovery.DiscoveryClient
*wardlev1alpha1.WardleV1alpha1Client
wardleV1alpha1 *wardlev1alpha1.WardleV1alpha1Client
}
// WardleV1alpha1 retrieves the WardleV1alpha1Client
func (c *Clientset) WardleV1alpha1() wardlev1alpha1.WardleV1alpha1Interface {
return c.WardleV1alpha1Client
return c.wardleV1alpha1
}
// Deprecated: Wardle retrieves the default version of WardleClient.
// Please explicitly pick a version.
func (c *Clientset) Wardle() wardlev1alpha1.WardleV1alpha1Interface {
return c.WardleV1alpha1Client
return c.wardleV1alpha1
}
// Discovery retrieves the DiscoveryClient
@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.WardleV1alpha1Client, err = wardlev1alpha1.NewForConfig(&configShallowCopy)
cs.wardleV1alpha1, err = wardlev1alpha1.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.WardleV1alpha1Client = wardlev1alpha1.NewForConfigOrDie(c)
cs.wardleV1alpha1 = wardlev1alpha1.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.WardleV1alpha1Client = wardlev1alpha1.New(c)
cs.wardleV1alpha1 = wardlev1alpha1.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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.
type Clientset struct {
*discovery.DiscoveryClient
*wardleinternalversion.WardleClient
wardle *wardleinternalversion.WardleClient
}
// Wardle retrieves the WardleClient
func (c *Clientset) Wardle() wardleinternalversion.WardleInterface {
return c.WardleClient
return c.wardle
}
// Discovery retrieves the DiscoveryClient
@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
}
var cs Clientset
var err error
cs.WardleClient, err = wardleinternalversion.NewForConfig(&configShallowCopy)
cs.wardle, err = wardleinternalversion.NewForConfig(&configShallowCopy)
if err != nil {
return nil, err
}
@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
// panics if there is an error in the config.
func NewForConfigOrDie(c *rest.Config) *Clientset {
var cs Clientset
cs.WardleClient = wardleinternalversion.NewForConfigOrDie(c)
cs.wardle = wardleinternalversion.NewForConfigOrDie(c)
cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
return &cs
@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
// New creates a new Clientset for the given RESTClient.
func New(c rest.Interface) *Clientset {
var cs Clientset
cs.WardleClient = wardleinternalversion.New(c)
cs.wardle = wardleinternalversion.New(c)
cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
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]
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 {
framework.Logf("Could not list ReplicaSets for Deployment %q: %v", d.Name, err)
return
@ -186,7 +186,7 @@ func checkDeploymentRevision(c clientset.Interface, ns, deploymentName, revision
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
Expect(err).NotTo(HaveOccurred())
// 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(newRS).NotTo(Equal(nilRs))
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{})
Expect(err).NotTo(HaveOccurred())
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c)
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred())
Expect(newRS).NotTo(Equal(nilRs))
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)
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
Expect(err).NotTo(HaveOccurred())
_, allOldRSs, err := deploymentutil.GetOldReplicaSets(deployment, c)
_, allOldRSs, err := deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred())
Expect(len(allOldRSs)).Should(Equal(1))
// 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())
// 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(rs).To(Equal(nilRs))
@ -594,11 +594,11 @@ func testPausedDeployment(f *framework.Framework) {
Expect(err).NotTo(HaveOccurred())
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(newRS).To(Equal(nilRs))
_, allOldRs, err := deploymentutil.GetOldReplicaSets(deployment, c)
_, allOldRs, err := deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred())
if len(allOldRs) != 1 {
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)
deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
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(len(oldRSs)).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)
Expect(err).NotTo(HaveOccurred())
rs, err := deploymentutil.GetNewReplicaSet(deployment, c)
rs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred())
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)
Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred())
first, err := deploymentutil.GetNewReplicaSet(deployment, c)
first, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred())
// 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)
second, err := deploymentutil.GetNewReplicaSet(deployment, c)
second, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred())
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))
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())
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{})
Expect(err).NotTo(HaveOccurred())
newRs, err := deploymentutil.GetNewReplicaSet(deployment, c)
newRs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred())
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))
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())
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
// https://github.com/kubernetes/kubernetes/issues/44237
framework.Logf("Mock a hash collision")
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c)
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
Expect(err).NotTo(HaveOccurred())
var nilRs *extensions.ReplicaSet
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.
var pod v1.Pod
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 {
return false, err
}
@ -191,7 +191,7 @@ var _ = SIGDescribe("DisruptionController", func() {
// this gives the controller enough time to have truly set the status.
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."))
} else {
// 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,
// that means the controller is working.
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 {
return false, nil
} 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)
}
}

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

@ -72,7 +72,7 @@ func WaitForDeploymentOldRSsNum(c clientset.Interface, ns, deploymentName string
}
d = deployment
_, oldRSs, err = deploymentutil.GetOldReplicaSets(deployment, c)
_, oldRSs, err = deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
if err != nil {
return false, err
}
@ -108,7 +108,7 @@ func WaitForDeploymentWithCondition(c clientset.Interface, ns, deploymentName, r
})
if pollErr == wait.ErrWaitTimeout {
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 {
logReplicaSetsOfDeployment(deployment, allOldRSs, newRS)
logPodsOfDeployment(c, deployment, append(allOldRSs, newRS))
@ -176,7 +176,7 @@ func WaitForDeploymentStatus(c clientset.Interface, d *extensions.Deployment) er
if err != nil {
return false, err
}
oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c)
oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
if err != nil {
return false, err
}
@ -276,8 +276,8 @@ func WatchRecreateDeployment(c clientset.Interface, d *extensions.Deployment) er
status = d.Status
if d.Status.UpdatedReplicas > 0 && d.Status.Replicas != d.Status.UpdatedReplicas {
_, allOldRSs, err := deploymentutil.GetOldReplicaSets(d, c)
newRS, nerr := deploymentutil.GetNewReplicaSet(d, c)
_, allOldRSs, err := deploymentutil.GetOldReplicaSets(d, c.ExtensionsV1beta1())
newRS, nerr := deploymentutil.GetNewReplicaSet(d, c.ExtensionsV1beta1())
if err == nil && nerr == nil {
Logf("%+v", d)
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 {
return err
}
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c)
newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
if err != nil {
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))
framework.ExpectNoError(framework.WaitForDeploymentStatusValid(c, deployment))
rs, err := deploymentutil.GetNewReplicaSet(deployment, c)
rs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
framework.ExpectNoError(err)
if rs == nil {
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))
framework.ExpectNoError(framework.WaitForDeploymentStatus(c, deployment))
rs, err = deploymentutil.GetNewReplicaSet(deployment, c)
rs, err = deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
framework.ExpectNoError(err)
if rs == nil {
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))
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)
if newRS == nil {
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
err := wait.PollImmediate(framework.Poll, timeout, func() (bool, 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.
By(fmt.Sprintf("Success: shard of federated ingress %q in namespace %q in cluster is absent", ingress.Name, namespace))
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) {
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) {
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 equivalentIngress(*clusterIngress, *ingress) {
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 {
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)
// Wait for the ingress to be deleted.
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 {
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)
}

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 {
framework.Logf("waitForReplicaSet: %s/%s; clusters: %v; expect: %v", namespace, replicaSetName, clusters, expect)
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 {
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))
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)
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))
// 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)
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)
defer func() { // Cleanup
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)
}()
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() {
// Cleanup
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)
}()
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("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)
// Service is deleted, unset the test block-global service variable.
service = nil
@ -359,16 +359,16 @@ func verifyCascadingDeletionForService(clientset *fedclientset.Clientset, cluste
}
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)
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))
return newService
}
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) {
framework.Logf("Failed to delete service %q in namespace %q, in cluster %q", service, namespace, c.Name)
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) {
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) {
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.
By(fmt.Sprintf("Success: shard of federated service %q in namespace %q in cluster is absent", service.Name, namespace))
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))
return clientset.Services(namespace).Create(service)
return clientset.CoreV1().Services(namespace).Create(service)
}
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))
return clientset.Services(namespace).Create(service)
return clientset.CoreV1().Services(namespace).Create(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))
}
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)
// Wait for the service to be deleted.
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) {
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) {
// 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)
@ -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 {
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) {
// Deletion failed with an error, try again.
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.
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.")
if nodes == 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()
// Check new RS annotations
newRS, err := deploymentutil.GetNewReplicaSet(deploy, c)
newRS, err := deploymentutil.GetNewReplicaSet(deploy, c.ExtensionsV1beta1())
if err != nil {
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)
defer closeFn()
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)
}
}

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)
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 {
t.Errorf("Failed to create PersistentVolume: %v", err)
}
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 {
t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
}
@ -146,7 +146,7 @@ func TestPersistentVolumeRecycler(t *testing.T) {
glog.V(2).Infof("TestPersistentVolumeRecycler pvc bound")
// 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)
}
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)
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 {
t.Errorf("Failed to create PersistentVolume: %v", err)
}
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 {
t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
}
@ -198,7 +198,7 @@ func TestPersistentVolumeDeleter(t *testing.T) {
glog.V(2).Infof("TestPersistentVolumeDeleter pvc bound")
// 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)
}
glog.V(2).Infof("TestPersistentVolumeDeleter pvc deleted")
@ -248,7 +248,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
clone, _ := api.Scheme.DeepCopy(pvc)
newPvc, _ := clone.(*v1.PersistentVolumeClaim)
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 {
t.Fatalf("Error creating newPvc: %v", err)
}
@ -266,7 +266,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
pv.Spec.ClaimRef = claimRef
pv.Spec.ClaimRef.UID = ""
pv, err = testClient.PersistentVolumes().Create(pv)
pv, err = testClient.CoreV1().PersistentVolumes().Create(pv)
if err != nil {
t.Fatalf("Unexpected error creating pv: %v", err)
}
@ -277,7 +277,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
waitForAnyPersistentVolumeClaimPhase(watchPVC, v1.ClaimBound)
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 {
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_false.ObjectMeta.SetLabels(map[string]string{"foo": "false"})
_, err = testClient.PersistentVolumes().Create(pv_true)
_, err = testClient.CoreV1().PersistentVolumes().Create(pv_true)
if err != nil {
t.Fatalf("Failed to create PersistentVolume: %v", err)
}
_, err = testClient.PersistentVolumes().Create(pv_false)
_, err = testClient.CoreV1().PersistentVolumes().Create(pv_false)
if err != nil {
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 {
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)
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 {
t.Fatalf("Unexpected error getting pv: %v", err)
}
if pv.Spec.ClaimRef != nil {
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 {
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_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 {
t.Fatalf("Failed to create PersistentVolume: %v", err)
}
_, err = testClient.PersistentVolumes().Create(pv_false)
_, err = testClient.CoreV1().PersistentVolumes().Create(pv_false)
if err != nil {
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 {
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)
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 {
t.Fatalf("Unexpected error getting pv: %v", err)
}
if pv.Spec.ClaimRef != nil {
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 {
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}, "")
for i := 0; i < maxPVs; i++ {
_, err := testClient.PersistentVolumes().Create(pvs[i])
_, err := testClient.CoreV1().PersistentVolumes().Create(pvs[i])
if err != nil {
t.Errorf("Failed to create PersistentVolume %d: %v", i, err)
}
@ -510,7 +510,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
}
t.Log("volumes created")
_, err := testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
_, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil {
t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
}
@ -525,7 +525,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
// only one PV is bound
bound := 0
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 {
t.Fatalf("Unexpected error getting pv: %v", err)
}
@ -550,7 +550,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
}
// 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.Log("claim deleted")
@ -599,7 +599,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// with >3000 volumes.
go func() {
for i := 0; i < objCount; i++ {
_, _ = testClient.PersistentVolumes().Create(pvs[i])
_, _ = testClient.CoreV1().PersistentVolumes().Create(pvs[i])
}
}()
// Wait for them to get Available
@ -620,7 +620,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// Modify PV
i := rand.Intn(objCount)
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 {
// Silently ignore error, the PV may have be already deleted
// or not exists yet.
@ -632,7 +632,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
} else {
pv.Annotations["TestAnnotation"] = fmt.Sprint(rand.Int())
}
_, err = testClient.PersistentVolumes().Update(pv)
_, err = testClient.CoreV1().PersistentVolumes().Update(pv)
if err != nil {
// Silently ignore error, the PV may have been updated by
// the controller.
@ -644,7 +644,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// Modify PVC
i := rand.Intn(objCount)
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 {
// Silently ignore error, the PVC may have be already
// deleted or not exists yet.
@ -656,7 +656,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
} else {
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 {
// Silently ignore error, the PVC may have been updated by
// the controller.
@ -679,7 +679,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
// Create the claims, again in a separate goroutine.
go func() {
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
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 {
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)
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 {
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.Annotations = map[string]string{"annBindCompleted": ""}
pvc.Spec.VolumeName = pvName
newPVC, err := testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
newPVC, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil {
t.Fatalf("Cannot create claim %q: %v", pvc.Name, err)
}
// Save Bound status as a separate transaction
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 {
t.Fatalf("Cannot update claim status %q: %v", pvc.Name, err)
}
@ -772,13 +772,13 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
return
}
pv.Spec.ClaimRef = claimRef
newPV, err := testClient.PersistentVolumes().Create(pv)
newPV, err := testClient.CoreV1().PersistentVolumes().Create(pv)
if err != nil {
t.Fatalf("Cannot create volume %q: %v", pv.Name, err)
}
// Save Bound status as a separate transaction
newPV.Status.Phase = v1.VolumeBound
newPV, err = testClient.PersistentVolumes().UpdateStatus(newPV)
newPV, err = testClient.CoreV1().PersistentVolumes().UpdateStatus(newPV)
if err != nil {
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
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 {
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)
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 {
t.Fatalf("Unexpected error getting pvc: %v", err)
}
@ -895,7 +895,7 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
// early. It gets stuck with >3000 claims.
go func() {
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")
// 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 {
t.Fatalf("Failed to list volumes: %s", err)
}
@ -924,13 +924,13 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
// Delete the claims
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
// (delete events were unreliable)
for {
volumes, err := testClient.PersistentVolumes().List(metav1.ListOptions{})
volumes, err := testClient.CoreV1().PersistentVolumes().List(metav1.ListOptions{})
if err != nil {
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}, "")
_, err := testClient.PersistentVolumes().Create(pv_rwm)
_, err := testClient.CoreV1().PersistentVolumes().Create(pv_rwm)
if err != nil {
t.Errorf("Failed to create PersistentVolume: %v", err)
}
_, err = testClient.PersistentVolumes().Create(pv_rwo)
_, err = testClient.CoreV1().PersistentVolumes().Create(pv_rwo)
if err != nil {
t.Errorf("Failed to create PersistentVolume: %v", err)
}
t.Log("volumes created")
_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
_, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
if err != nil {
t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
}
@ -997,14 +997,14 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
t.Log("claim 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 {
t.Fatalf("Unexpected error getting pv: %v", err)
}
if pv.Spec.ClaimRef != nil {
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 {
t.Fatalf("Unexpected error getting pv: %v", err)
}
@ -1016,7 +1016,7 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
}
// 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.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)
}
watchPV, err := testClient.PersistentVolumes().Watch(metav1.ListOptions{})
watchPV, err := testClient.CoreV1().PersistentVolumes().Watch(metav1.ListOptions{})
if err != nil {
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 {
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
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 {
break
}
@ -114,7 +114,7 @@ func main() {
queries := *queriesAverage * len(nodes.Items) * *podsPerNode
// 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 {
glog.Fatalf("Failed to create namespace: %v", err)
}
@ -125,7 +125,7 @@ func main() {
} else {
// wait until the namespace disappears
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) {
return
}
@ -142,7 +142,7 @@ func main() {
var svc *v1.Service
for start := time.Now(); time.Since(start) < serviceCreateTimeout; time.Sleep(2 * time.Second) {
t := time.Now()
svc, err = client.Services(ns).Create(&v1.Service{
svc, err = client.CoreV1().Services(ns).Create(&v1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: "serve-hostnames",
Labels: map[string]string{
@ -175,7 +175,7 @@ func main() {
glog.Infof("Cleaning up service %s/serve-hostnames", ns)
// Make several attempts to delete the service.
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
}
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) {
glog.Infof("Creating pod %s/%s on node %s", ns, podName, node.Name)
t := time.Now()
_, err = client.Pods(ns).Create(&v1.Pod{
_, err = client.CoreV1().Pods(ns).Create(&v1.Pod{
ObjectMeta: metav1.ObjectMeta{
Name: podName,
Labels: map[string]string{
@ -228,7 +228,7 @@ func main() {
// Make several attempts to delete the pods.
for _, podName := range podNames {
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
}
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 {
var pod *v1.Pod
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 {
glog.Warningf("Get pod %s/%s failed, ignoring for %v: %v", ns, podName, err, podStartTimeout)
continue

4
test/utils/deployment.go
View File

@ -85,7 +85,7 @@ func WaitForDeploymentStatusValid(c clientset.Interface, d *extensions.Deploymen
if err != nil {
return false, err
}
oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c)
oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
if err != nil {
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
newRS, err = deploymentutil.GetNewReplicaSet(deployment, c)
newRS, err = deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
if err != nil {
return false, err