diff --git a/cmd/libs/go2idl/client-gen/main.go b/cmd/libs/go2idl/client-gen/main.go index 51f2a9ae5d8..45ca829cbb0 100644 --- a/cmd/libs/go2idl/client-gen/main.go +++ b/cmd/libs/go2idl/client-gen/main.go @@ -43,6 +43,7 @@ var ( "extensions/", "rbac/", "storage/", + "apps/", }, "group/versions that client-gen will generate clients for. At most one version per group is allowed. Specified in the format \"group1/version1,group2/version2...\". Default to \"api/,extensions/,autoscaling/,batch/,rbac/\"") includedTypesOverrides = flag.StringSlice("included-types-overrides", []string{}, "list of group/version/type for which client should be generated. By default, client is generated for all types which have genclient=true in types.go. This overrides that. For each groupVersion in this list, only the types mentioned here will be included. The default check of genclient=true will be used for other group versions.") basePath = flag.String("input-base", "k8s.io/kubernetes/pkg/apis", "base path to look for the api group. Default to \"k8s.io/kubernetes/pkg/apis\"") diff --git a/pkg/apis/apps/types.go b/pkg/apis/apps/types.go index c3e28972fe4..5568e2ef3f5 100644 --- a/pkg/apis/apps/types.go +++ b/pkg/apis/apps/types.go @@ -21,6 +21,8 @@ import ( "k8s.io/kubernetes/pkg/api/unversioned" ) +// +genclient=true + // PetSet represents a set of pods with consistent identities. // Identities are defined as: // - Network: A single stable DNS and hostname. diff --git a/pkg/apis/extensions/types.go b/pkg/apis/extensions/types.go index 59e87164dbd..988485fcc08 100644 --- a/pkg/apis/extensions/types.go +++ b/pkg/apis/extensions/types.go @@ -826,6 +826,8 @@ type PodSecurityPolicyList struct { Items []PodSecurityPolicy `json:"items"` } +// +genclient=true + type NetworkPolicy struct { unversioned.TypeMeta `json:",inline"` api.ObjectMeta `json:"metadata,omitempty"` diff --git a/pkg/client/clientset_generated/internalclientset/clientset.go b/pkg/client/clientset_generated/internalclientset/clientset.go index b2d96d3a2b4..ae8c7dbf85b 100644 --- a/pkg/client/clientset_generated/internalclientset/clientset.go +++ b/pkg/client/clientset_generated/internalclientset/clientset.go @@ -18,6 +18,7 @@ package internalclientset import ( "github.com/golang/glog" + unversionedapps "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned" unversionedauthentication "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authentication/unversioned" unversionedauthorization "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authorization/unversioned" unversionedautoscaling "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/autoscaling/unversioned" @@ -43,6 +44,7 @@ type Interface interface { Extensions() unversionedextensions.ExtensionsInterface Rbac() unversionedrbac.RbacInterface Storage() unversionedstorage.StorageInterface + Apps() unversionedapps.AppsInterface } // Clientset contains the clients for groups. Each group has exactly one @@ -58,6 +60,7 @@ type Clientset struct { *unversionedextensions.ExtensionsClient *unversionedrbac.RbacClient *unversionedstorage.StorageClient + *unversionedapps.AppsClient } // Core retrieves the CoreClient @@ -132,6 +135,14 @@ func (c *Clientset) Storage() unversionedstorage.StorageInterface { return c.StorageClient } +// Apps retrieves the AppsClient +func (c *Clientset) Apps() unversionedapps.AppsInterface { + if c == nil { + return nil + } + return c.AppsClient +} + // Discovery retrieves the DiscoveryClient func (c *Clientset) Discovery() discovery.DiscoveryInterface { return c.DiscoveryClient @@ -181,6 +192,10 @@ func NewForConfig(c *restclient.Config) (*Clientset, error) { if err != nil { return nil, err } + clientset.AppsClient, err = unversionedapps.NewForConfig(&configShallowCopy) + if err != nil { + return nil, err + } clientset.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy) if err != nil { @@ -203,6 +218,7 @@ func NewForConfigOrDie(c *restclient.Config) *Clientset { clientset.ExtensionsClient = unversionedextensions.NewForConfigOrDie(c) clientset.RbacClient = unversionedrbac.NewForConfigOrDie(c) clientset.StorageClient = unversionedstorage.NewForConfigOrDie(c) + clientset.AppsClient = unversionedapps.NewForConfigOrDie(c) clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) return &clientset @@ -220,6 +236,7 @@ func New(c *restclient.RESTClient) *Clientset { clientset.ExtensionsClient = unversionedextensions.New(c) clientset.RbacClient = unversionedrbac.New(c) clientset.StorageClient = unversionedstorage.New(c) + clientset.AppsClient = unversionedapps.New(c) clientset.DiscoveryClient = discovery.NewDiscoveryClient(c) return &clientset diff --git a/pkg/client/clientset_generated/internalclientset/fake/clientset_generated.go b/pkg/client/clientset_generated/internalclientset/fake/clientset_generated.go index c64972c04f0..fcdc95f3670 100644 --- a/pkg/client/clientset_generated/internalclientset/fake/clientset_generated.go +++ b/pkg/client/clientset_generated/internalclientset/fake/clientset_generated.go @@ -20,6 +20,8 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/apimachinery/registered" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" + unversionedapps "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned" + fakeunversionedapps "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake" unversionedauthentication "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authentication/unversioned" fakeunversionedauthentication "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authentication/unversioned/fake" unversionedauthorization "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/authorization/unversioned" @@ -122,3 +124,8 @@ func (c *Clientset) Rbac() unversionedrbac.RbacInterface { func (c *Clientset) Storage() unversionedstorage.StorageInterface { return &fakeunversionedstorage.FakeStorage{Fake: &c.Fake} } + +// Apps retrieves the AppsClient +func (c *Clientset) Apps() unversionedapps.AppsInterface { + return &fakeunversionedapps.FakeApps{Fake: &c.Fake} +} diff --git a/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/apps_client.go b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/apps_client.go new file mode 100644 index 00000000000..f0ea95c1c2e --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/apps_client.go @@ -0,0 +1,101 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package unversioned + +import ( + api "k8s.io/kubernetes/pkg/api" + registered "k8s.io/kubernetes/pkg/apimachinery/registered" + restclient "k8s.io/kubernetes/pkg/client/restclient" +) + +type AppsInterface interface { + GetRESTClient() *restclient.RESTClient + PetSetsGetter +} + +// AppsClient is used to interact with features provided by the Apps group. +type AppsClient struct { + *restclient.RESTClient +} + +func (c *AppsClient) PetSets(namespace string) PetSetInterface { + return newPetSets(c, namespace) +} + +// NewForConfig creates a new AppsClient for the given config. +func NewForConfig(c *restclient.Config) (*AppsClient, error) { + config := *c + if err := setConfigDefaults(&config); err != nil { + return nil, err + } + client, err := restclient.RESTClientFor(&config) + if err != nil { + return nil, err + } + return &AppsClient{client}, nil +} + +// NewForConfigOrDie creates a new AppsClient for the given config and +// panics if there is an error in the config. +func NewForConfigOrDie(c *restclient.Config) *AppsClient { + client, err := NewForConfig(c) + if err != nil { + panic(err) + } + return client +} + +// New creates a new AppsClient for the given RESTClient. +func New(c *restclient.RESTClient) *AppsClient { + return &AppsClient{c} +} + +func setConfigDefaults(config *restclient.Config) error { + // if apps group is not registered, return an error + g, err := registered.Group("apps") + if err != nil { + return err + } + config.APIPath = "/apis" + if config.UserAgent == "" { + config.UserAgent = restclient.DefaultKubernetesUserAgent() + } + // TODO: Unconditionally set the config.Version, until we fix the config. + //if config.Version == "" { + copyGroupVersion := g.GroupVersion + config.GroupVersion = ©GroupVersion + //} + + config.NegotiatedSerializer = api.Codecs + + if config.QPS == 0 { + config.QPS = 5 + } + if config.Burst == 0 { + config.Burst = 10 + } + return nil +} + +// GetRESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *AppsClient) GetRESTClient() *restclient.RESTClient { + if c == nil { + return nil + } + return c.RESTClient +} diff --git a/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/doc.go b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/doc.go new file mode 100644 index 00000000000..1e6a8ff827b --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/doc.go @@ -0,0 +1,20 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// This package is generated by client-gen with the default arguments. + +// This package has the automatically generated typed clients. +package unversioned diff --git a/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/doc.go b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/doc.go new file mode 100644 index 00000000000..083f78f3a40 --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/doc.go @@ -0,0 +1,20 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// This package is generated by client-gen with the default arguments. + +// Package fake has the automatically generated clients. +package fake diff --git a/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/fake_apps_client.go b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/fake_apps_client.go new file mode 100644 index 00000000000..5b0e6973ecc --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/fake_apps_client.go @@ -0,0 +1,37 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package fake + +import ( + unversioned "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned" + restclient "k8s.io/kubernetes/pkg/client/restclient" + core "k8s.io/kubernetes/pkg/client/testing/core" +) + +type FakeApps struct { + *core.Fake +} + +func (c *FakeApps) PetSets(namespace string) unversioned.PetSetInterface { + return &FakePetSets{c, namespace} +} + +// GetRESTClient returns a RESTClient that is used to communicate +// with API server by this client implementation. +func (c *FakeApps) GetRESTClient() *restclient.RESTClient { + return nil +} diff --git a/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/fake_petset.go b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/fake_petset.go new file mode 100644 index 00000000000..5331cc18428 --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/fake/fake_petset.go @@ -0,0 +1,127 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package fake + +import ( + api "k8s.io/kubernetes/pkg/api" + unversioned "k8s.io/kubernetes/pkg/api/unversioned" + apps "k8s.io/kubernetes/pkg/apis/apps" + core "k8s.io/kubernetes/pkg/client/testing/core" + labels "k8s.io/kubernetes/pkg/labels" + watch "k8s.io/kubernetes/pkg/watch" +) + +// FakePetSets implements PetSetInterface +type FakePetSets struct { + Fake *FakeApps + ns string +} + +var petsetsResource = unversioned.GroupVersionResource{Group: "apps", Version: "", Resource: "petsets"} + +func (c *FakePetSets) Create(petSet *apps.PetSet) (result *apps.PetSet, err error) { + obj, err := c.Fake. + Invokes(core.NewCreateAction(petsetsResource, c.ns, petSet), &apps.PetSet{}) + + if obj == nil { + return nil, err + } + return obj.(*apps.PetSet), err +} + +func (c *FakePetSets) Update(petSet *apps.PetSet) (result *apps.PetSet, err error) { + obj, err := c.Fake. + Invokes(core.NewUpdateAction(petsetsResource, c.ns, petSet), &apps.PetSet{}) + + if obj == nil { + return nil, err + } + return obj.(*apps.PetSet), err +} + +func (c *FakePetSets) UpdateStatus(petSet *apps.PetSet) (*apps.PetSet, error) { + obj, err := c.Fake. + Invokes(core.NewUpdateSubresourceAction(petsetsResource, "status", c.ns, petSet), &apps.PetSet{}) + + if obj == nil { + return nil, err + } + return obj.(*apps.PetSet), err +} + +func (c *FakePetSets) Delete(name string, options *api.DeleteOptions) error { + _, err := c.Fake. + Invokes(core.NewDeleteAction(petsetsResource, c.ns, name), &apps.PetSet{}) + + return err +} + +func (c *FakePetSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error { + action := core.NewDeleteCollectionAction(petsetsResource, c.ns, listOptions) + + _, err := c.Fake.Invokes(action, &apps.PetSetList{}) + return err +} + +func (c *FakePetSets) Get(name string) (result *apps.PetSet, err error) { + obj, err := c.Fake. + Invokes(core.NewGetAction(petsetsResource, c.ns, name), &apps.PetSet{}) + + if obj == nil { + return nil, err + } + return obj.(*apps.PetSet), err +} + +func (c *FakePetSets) List(opts api.ListOptions) (result *apps.PetSetList, err error) { + obj, err := c.Fake. + Invokes(core.NewListAction(petsetsResource, c.ns, opts), &apps.PetSetList{}) + + if obj == nil { + return nil, err + } + + label := opts.LabelSelector + if label == nil { + label = labels.Everything() + } + list := &apps.PetSetList{} + for _, item := range obj.(*apps.PetSetList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested petSets. +func (c *FakePetSets) Watch(opts api.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(core.NewWatchAction(petsetsResource, c.ns, opts)) + +} + +// Patch applies the patch and returns the patched petSet. +func (c *FakePetSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *apps.PetSet, err error) { + obj, err := c.Fake. + Invokes(core.NewPatchSubresourceAction(petsetsResource, c.ns, name, data, subresources...), &apps.PetSet{}) + + if obj == nil { + return nil, err + } + return obj.(*apps.PetSet), err +} diff --git a/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/generated_expansion.go b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/generated_expansion.go new file mode 100644 index 00000000000..552b3cff2de --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/generated_expansion.go @@ -0,0 +1,19 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package unversioned + +type PetSetExpansion interface{} diff --git a/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/petset.go b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/petset.go new file mode 100644 index 00000000000..d88f0755960 --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned/petset.go @@ -0,0 +1,165 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package unversioned + +import ( + api "k8s.io/kubernetes/pkg/api" + apps "k8s.io/kubernetes/pkg/apis/apps" + watch "k8s.io/kubernetes/pkg/watch" +) + +// PetSetsGetter has a method to return a PetSetInterface. +// A group's client should implement this interface. +type PetSetsGetter interface { + PetSets(namespace string) PetSetInterface +} + +// PetSetInterface has methods to work with PetSet resources. +type PetSetInterface interface { + Create(*apps.PetSet) (*apps.PetSet, error) + Update(*apps.PetSet) (*apps.PetSet, error) + UpdateStatus(*apps.PetSet) (*apps.PetSet, error) + Delete(name string, options *api.DeleteOptions) error + DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error + Get(name string) (*apps.PetSet, error) + List(opts api.ListOptions) (*apps.PetSetList, error) + Watch(opts api.ListOptions) (watch.Interface, error) + Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *apps.PetSet, err error) + PetSetExpansion +} + +// petSets implements PetSetInterface +type petSets struct { + client *AppsClient + ns string +} + +// newPetSets returns a PetSets +func newPetSets(c *AppsClient, namespace string) *petSets { + return &petSets{ + client: c, + ns: namespace, + } +} + +// Create takes the representation of a petSet and creates it. Returns the server's representation of the petSet, and an error, if there is any. +func (c *petSets) Create(petSet *apps.PetSet) (result *apps.PetSet, err error) { + result = &apps.PetSet{} + err = c.client.Post(). + Namespace(c.ns). + Resource("petsets"). + Body(petSet). + Do(). + Into(result) + return +} + +// Update takes the representation of a petSet and updates it. Returns the server's representation of the petSet, and an error, if there is any. +func (c *petSets) Update(petSet *apps.PetSet) (result *apps.PetSet, err error) { + result = &apps.PetSet{} + err = c.client.Put(). + Namespace(c.ns). + Resource("petsets"). + Name(petSet.Name). + Body(petSet). + Do(). + Into(result) + return +} + +func (c *petSets) UpdateStatus(petSet *apps.PetSet) (result *apps.PetSet, err error) { + result = &apps.PetSet{} + err = c.client.Put(). + Namespace(c.ns). + Resource("petsets"). + Name(petSet.Name). + SubResource("status"). + Body(petSet). + Do(). + Into(result) + return +} + +// Delete takes name of the petSet and deletes it. Returns an error if one occurs. +func (c *petSets) Delete(name string, options *api.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("petsets"). + Name(name). + Body(options). + Do(). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *petSets) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("petsets"). + VersionedParams(&listOptions, api.ParameterCodec). + Body(options). + Do(). + Error() +} + +// Get takes name of the petSet, and returns the corresponding petSet object, and an error if there is any. +func (c *petSets) Get(name string) (result *apps.PetSet, err error) { + result = &apps.PetSet{} + err = c.client.Get(). + Namespace(c.ns). + Resource("petsets"). + Name(name). + Do(). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of PetSets that match those selectors. +func (c *petSets) List(opts api.ListOptions) (result *apps.PetSetList, err error) { + result = &apps.PetSetList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("petsets"). + VersionedParams(&opts, api.ParameterCodec). + Do(). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested petSets. +func (c *petSets) Watch(opts api.ListOptions) (watch.Interface, error) { + return c.client.Get(). + Prefix("watch"). + Namespace(c.ns). + Resource("petsets"). + VersionedParams(&opts, api.ParameterCodec). + Watch() +} + +// Patch applies the patch and returns the patched petSet. +func (c *petSets) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *apps.PetSet, err error) { + result = &apps.PetSet{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("petsets"). + SubResource(subresources...). + Name(name). + Body(data). + Do(). + Into(result) + return +} diff --git a/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/extensions_client.go b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/extensions_client.go index 5454ea783ed..7a6f8248f44 100644 --- a/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/extensions_client.go +++ b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/extensions_client.go @@ -27,6 +27,7 @@ type ExtensionsInterface interface { DaemonSetsGetter DeploymentsGetter IngressesGetter + NetworkPoliciesGetter PodSecurityPoliciesGetter ReplicaSetsGetter ScalesGetter @@ -50,6 +51,10 @@ func (c *ExtensionsClient) Ingresses(namespace string) IngressInterface { return newIngresses(c, namespace) } +func (c *ExtensionsClient) NetworkPolicies(namespace string) NetworkPolicyInterface { + return newNetworkPolicies(c, namespace) +} + func (c *ExtensionsClient) PodSecurityPolicies() PodSecurityPolicyInterface { return newPodSecurityPolicies(c) } diff --git a/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/fake/fake_extensions_client.go b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/fake/fake_extensions_client.go index 809e80ed8af..19278bed80a 100644 --- a/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/fake/fake_extensions_client.go +++ b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/fake/fake_extensions_client.go @@ -38,6 +38,10 @@ func (c *FakeExtensions) Ingresses(namespace string) unversioned.IngressInterfac return &FakeIngresses{c, namespace} } +func (c *FakeExtensions) NetworkPolicies(namespace string) unversioned.NetworkPolicyInterface { + return &FakeNetworkPolicies{c, namespace} +} + func (c *FakeExtensions) PodSecurityPolicies() unversioned.PodSecurityPolicyInterface { return &FakePodSecurityPolicies{c} } diff --git a/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/fake/fake_networkpolicy.go b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/fake/fake_networkpolicy.go new file mode 100644 index 00000000000..4795f308741 --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/fake/fake_networkpolicy.go @@ -0,0 +1,117 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package fake + +import ( + api "k8s.io/kubernetes/pkg/api" + unversioned "k8s.io/kubernetes/pkg/api/unversioned" + extensions "k8s.io/kubernetes/pkg/apis/extensions" + core "k8s.io/kubernetes/pkg/client/testing/core" + labels "k8s.io/kubernetes/pkg/labels" + watch "k8s.io/kubernetes/pkg/watch" +) + +// FakeNetworkPolicies implements NetworkPolicyInterface +type FakeNetworkPolicies struct { + Fake *FakeExtensions + ns string +} + +var networkpoliciesResource = unversioned.GroupVersionResource{Group: "extensions", Version: "", Resource: "networkpolicies"} + +func (c *FakeNetworkPolicies) Create(networkPolicy *extensions.NetworkPolicy) (result *extensions.NetworkPolicy, err error) { + obj, err := c.Fake. + Invokes(core.NewCreateAction(networkpoliciesResource, c.ns, networkPolicy), &extensions.NetworkPolicy{}) + + if obj == nil { + return nil, err + } + return obj.(*extensions.NetworkPolicy), err +} + +func (c *FakeNetworkPolicies) Update(networkPolicy *extensions.NetworkPolicy) (result *extensions.NetworkPolicy, err error) { + obj, err := c.Fake. + Invokes(core.NewUpdateAction(networkpoliciesResource, c.ns, networkPolicy), &extensions.NetworkPolicy{}) + + if obj == nil { + return nil, err + } + return obj.(*extensions.NetworkPolicy), err +} + +func (c *FakeNetworkPolicies) Delete(name string, options *api.DeleteOptions) error { + _, err := c.Fake. + Invokes(core.NewDeleteAction(networkpoliciesResource, c.ns, name), &extensions.NetworkPolicy{}) + + return err +} + +func (c *FakeNetworkPolicies) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error { + action := core.NewDeleteCollectionAction(networkpoliciesResource, c.ns, listOptions) + + _, err := c.Fake.Invokes(action, &extensions.NetworkPolicyList{}) + return err +} + +func (c *FakeNetworkPolicies) Get(name string) (result *extensions.NetworkPolicy, err error) { + obj, err := c.Fake. + Invokes(core.NewGetAction(networkpoliciesResource, c.ns, name), &extensions.NetworkPolicy{}) + + if obj == nil { + return nil, err + } + return obj.(*extensions.NetworkPolicy), err +} + +func (c *FakeNetworkPolicies) List(opts api.ListOptions) (result *extensions.NetworkPolicyList, err error) { + obj, err := c.Fake. + Invokes(core.NewListAction(networkpoliciesResource, c.ns, opts), &extensions.NetworkPolicyList{}) + + if obj == nil { + return nil, err + } + + label := opts.LabelSelector + if label == nil { + label = labels.Everything() + } + list := &extensions.NetworkPolicyList{} + for _, item := range obj.(*extensions.NetworkPolicyList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested networkPolicies. +func (c *FakeNetworkPolicies) Watch(opts api.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(core.NewWatchAction(networkpoliciesResource, c.ns, opts)) + +} + +// Patch applies the patch and returns the patched networkPolicy. +func (c *FakeNetworkPolicies) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *extensions.NetworkPolicy, err error) { + obj, err := c.Fake. + Invokes(core.NewPatchSubresourceAction(networkpoliciesResource, c.ns, name, data, subresources...), &extensions.NetworkPolicy{}) + + if obj == nil { + return nil, err + } + return obj.(*extensions.NetworkPolicy), err +} diff --git a/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/generated_expansion.go b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/generated_expansion.go index d818910a59a..6a140557512 100644 --- a/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/generated_expansion.go +++ b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/generated_expansion.go @@ -20,6 +20,8 @@ type DaemonSetExpansion interface{} type IngressExpansion interface{} +type NetworkPolicyExpansion interface{} + type PodSecurityPolicyExpansion interface{} type ReplicaSetExpansion interface{} diff --git a/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/networkpolicy.go b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/networkpolicy.go new file mode 100644 index 00000000000..a46d3980e2a --- /dev/null +++ b/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned/networkpolicy.go @@ -0,0 +1,151 @@ +/* +Copyright 2016 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package unversioned + +import ( + api "k8s.io/kubernetes/pkg/api" + extensions "k8s.io/kubernetes/pkg/apis/extensions" + watch "k8s.io/kubernetes/pkg/watch" +) + +// NetworkPoliciesGetter has a method to return a NetworkPolicyInterface. +// A group's client should implement this interface. +type NetworkPoliciesGetter interface { + NetworkPolicies(namespace string) NetworkPolicyInterface +} + +// NetworkPolicyInterface has methods to work with NetworkPolicy resources. +type NetworkPolicyInterface interface { + Create(*extensions.NetworkPolicy) (*extensions.NetworkPolicy, error) + Update(*extensions.NetworkPolicy) (*extensions.NetworkPolicy, error) + Delete(name string, options *api.DeleteOptions) error + DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error + Get(name string) (*extensions.NetworkPolicy, error) + List(opts api.ListOptions) (*extensions.NetworkPolicyList, error) + Watch(opts api.ListOptions) (watch.Interface, error) + Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *extensions.NetworkPolicy, err error) + NetworkPolicyExpansion +} + +// networkPolicies implements NetworkPolicyInterface +type networkPolicies struct { + client *ExtensionsClient + ns string +} + +// newNetworkPolicies returns a NetworkPolicies +func newNetworkPolicies(c *ExtensionsClient, namespace string) *networkPolicies { + return &networkPolicies{ + client: c, + ns: namespace, + } +} + +// Create takes the representation of a networkPolicy and creates it. Returns the server's representation of the networkPolicy, and an error, if there is any. +func (c *networkPolicies) Create(networkPolicy *extensions.NetworkPolicy) (result *extensions.NetworkPolicy, err error) { + result = &extensions.NetworkPolicy{} + err = c.client.Post(). + Namespace(c.ns). + Resource("networkpolicies"). + Body(networkPolicy). + Do(). + Into(result) + return +} + +// Update takes the representation of a networkPolicy and updates it. Returns the server's representation of the networkPolicy, and an error, if there is any. +func (c *networkPolicies) Update(networkPolicy *extensions.NetworkPolicy) (result *extensions.NetworkPolicy, err error) { + result = &extensions.NetworkPolicy{} + err = c.client.Put(). + Namespace(c.ns). + Resource("networkpolicies"). + Name(networkPolicy.Name). + Body(networkPolicy). + Do(). + Into(result) + return +} + +// Delete takes name of the networkPolicy and deletes it. Returns an error if one occurs. +func (c *networkPolicies) Delete(name string, options *api.DeleteOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("networkpolicies"). + Name(name). + Body(options). + Do(). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *networkPolicies) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error { + return c.client.Delete(). + Namespace(c.ns). + Resource("networkpolicies"). + VersionedParams(&listOptions, api.ParameterCodec). + Body(options). + Do(). + Error() +} + +// Get takes name of the networkPolicy, and returns the corresponding networkPolicy object, and an error if there is any. +func (c *networkPolicies) Get(name string) (result *extensions.NetworkPolicy, err error) { + result = &extensions.NetworkPolicy{} + err = c.client.Get(). + Namespace(c.ns). + Resource("networkpolicies"). + Name(name). + Do(). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of NetworkPolicies that match those selectors. +func (c *networkPolicies) List(opts api.ListOptions) (result *extensions.NetworkPolicyList, err error) { + result = &extensions.NetworkPolicyList{} + err = c.client.Get(). + Namespace(c.ns). + Resource("networkpolicies"). + VersionedParams(&opts, api.ParameterCodec). + Do(). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested networkPolicies. +func (c *networkPolicies) Watch(opts api.ListOptions) (watch.Interface, error) { + return c.client.Get(). + Prefix("watch"). + Namespace(c.ns). + Resource("networkpolicies"). + VersionedParams(&opts, api.ParameterCodec). + Watch() +} + +// Patch applies the patch and returns the patched networkPolicy. +func (c *networkPolicies) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *extensions.NetworkPolicy, err error) { + result = &extensions.NetworkPolicy{} + err = c.client.Patch(pt). + Namespace(c.ns). + Resource("networkpolicies"). + SubResource(subresources...). + Name(name). + Body(data). + Do(). + Into(result) + return +} diff --git a/pkg/client/unversioned/conditions.go b/pkg/client/unversioned/conditions.go index cd913de61ac..973fb92a8e4 100644 --- a/pkg/client/unversioned/conditions.go +++ b/pkg/client/unversioned/conditions.go @@ -25,20 +25,24 @@ import ( "k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/batch" "k8s.io/kubernetes/pkg/apis/extensions" + appsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned" + batchclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" + extensionsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned" "k8s.io/kubernetes/pkg/util/wait" "k8s.io/kubernetes/pkg/watch" ) // ControllerHasDesiredReplicas returns a condition that will be true if and only if // the desired replica count for a controller's ReplicaSelector equals the Replicas count. -func ControllerHasDesiredReplicas(c Interface, controller *api.ReplicationController) wait.ConditionFunc { +func ControllerHasDesiredReplicas(rcClient coreclient.ReplicationControllersGetter, controller *api.ReplicationController) wait.ConditionFunc { // If we're given a controller where the status lags the spec, it either means that the controller is stale, // or that the rc manager hasn't noticed the update yet. Polling status.Replicas is not safe in the latter case. desiredGeneration := controller.Generation return func() (bool, error) { - ctrl, err := c.ReplicationControllers(controller.Namespace).Get(controller.Name) + ctrl, err := rcClient.ReplicationControllers(controller.Namespace).Get(controller.Name) if err != nil { return false, err } @@ -52,7 +56,7 @@ func ControllerHasDesiredReplicas(c Interface, controller *api.ReplicationContro // ReplicaSetHasDesiredReplicas returns a condition that will be true if and only if // the desired replica count for a ReplicaSet's ReplicaSelector equals the Replicas count. -func ReplicaSetHasDesiredReplicas(c ExtensionsInterface, replicaSet *extensions.ReplicaSet) wait.ConditionFunc { +func ReplicaSetHasDesiredReplicas(rsClient extensionsclient.ReplicaSetsGetter, replicaSet *extensions.ReplicaSet) wait.ConditionFunc { // If we're given a ReplicaSet where the status lags the spec, it either means that the // ReplicaSet is stale, or that the ReplicaSet manager hasn't noticed the update yet. @@ -60,7 +64,7 @@ func ReplicaSetHasDesiredReplicas(c ExtensionsInterface, replicaSet *extensions. desiredGeneration := replicaSet.Generation return func() (bool, error) { - rs, err := c.ReplicaSets(replicaSet.Namespace).Get(replicaSet.Name) + rs, err := rsClient.ReplicaSets(replicaSet.Namespace).Get(replicaSet.Name) if err != nil { return false, err } @@ -73,10 +77,10 @@ func ReplicaSetHasDesiredReplicas(c ExtensionsInterface, replicaSet *extensions. } } -func PetSetHasDesiredPets(c AppsInterface, petset *apps.PetSet) wait.ConditionFunc { +func PetSetHasDesiredPets(psClient appsclient.PetSetsGetter, petset *apps.PetSet) wait.ConditionFunc { // TODO: Differentiate between 0 pets and a really quick scale down using generation. return func() (bool, error) { - ps, err := c.PetSets(petset.Namespace).Get(petset.Name) + ps, err := psClient.PetSets(petset.Namespace).Get(petset.Name) if err != nil { return false, err } @@ -86,10 +90,9 @@ func PetSetHasDesiredPets(c AppsInterface, petset *apps.PetSet) wait.ConditionFu // JobHasDesiredParallelism returns a condition that will be true if the desired parallelism count // for a job equals the current active counts or is less by an appropriate successful/unsuccessful count. -func JobHasDesiredParallelism(c BatchInterface, job *batch.Job) wait.ConditionFunc { - +func JobHasDesiredParallelism(jobClient batchclient.JobsGetter, job *batch.Job) wait.ConditionFunc { return func() (bool, error) { - job, err := c.Jobs(job.Namespace).Get(job.Name) + job, err := jobClient.Jobs(job.Namespace).Get(job.Name) if err != nil { return false, err } @@ -112,7 +115,7 @@ func JobHasDesiredParallelism(c BatchInterface, job *batch.Job) wait.ConditionFu // DeploymentHasDesiredReplicas returns a condition that will be true if and only if // the desired replica count for a deployment equals its updated replicas count. // (non-terminated pods that have the desired template spec). -func DeploymentHasDesiredReplicas(c ExtensionsInterface, deployment *extensions.Deployment) wait.ConditionFunc { +func DeploymentHasDesiredReplicas(dClient extensionsclient.DeploymentsGetter, deployment *extensions.Deployment) wait.ConditionFunc { // If we're given a deployment where the status lags the spec, it either // means that the deployment is stale, or that the deployment manager hasn't // noticed the update yet. Polling status.Replicas is not safe in the latter @@ -120,7 +123,7 @@ func DeploymentHasDesiredReplicas(c ExtensionsInterface, deployment *extensions. desiredGeneration := deployment.Generation return func() (bool, error) { - deployment, err := c.Deployments(deployment.Namespace).Get(deployment.Name) + deployment, err := dClient.Deployments(deployment.Namespace).Get(deployment.Name) if err != nil { return false, err } diff --git a/pkg/kubectl/cmd/apiversions.go b/pkg/kubectl/cmd/apiversions.go index d39665aad5b..db57693df11 100644 --- a/pkg/kubectl/cmd/apiversions.go +++ b/pkg/kubectl/cmd/apiversions.go @@ -47,12 +47,12 @@ func RunApiVersions(f *cmdutil.Factory, w io.Writer) error { printDeprecationWarning("api-versions", "apiversions") } - client, err := f.Client() + clientset, err := f.ClientSet() if err != nil { return err } - groupList, err := client.Discovery().ServerGroups() + groupList, err := clientset.Discovery().ServerGroups() if err != nil { return fmt.Errorf("Couldn't get available api versions from server: %v\n", err) } diff --git a/pkg/kubectl/cmd/attach_test.go b/pkg/kubectl/cmd/attach_test.go index 7676aa23167..458cdba133a 100644 --- a/pkg/kubectl/cmd/attach_test.go +++ b/pkg/kubectl/cmd/attach_test.go @@ -102,7 +102,7 @@ func TestPodAndContainerAttach(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return nil, nil }), } tf.Namespace = "test" - tf.ClientConfig = &restclient.Config{} + tf.ClientConfig = defaultClientConfig() cmd := &cobra.Command{} options := test.p diff --git a/pkg/kubectl/cmd/clusterinfo_dump.go b/pkg/kubectl/cmd/clusterinfo_dump.go index 895f178c835..2d04da52333 100644 --- a/pkg/kubectl/cmd/clusterinfo_dump.go +++ b/pkg/kubectl/cmd/clusterinfo_dump.go @@ -25,7 +25,6 @@ import ( "github.com/spf13/cobra" "k8s.io/kubernetes/pkg/api" - "k8s.io/kubernetes/pkg/client/unversioned" "k8s.io/kubernetes/pkg/kubectl" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" ) @@ -86,17 +85,17 @@ func setupOutputWriter(cmd *cobra.Command, defaultWriter io.Writer, filename str } func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out io.Writer) error { - var c *unversioned.Client - var err error - if c, err = f.Client(); err != nil { + clientset, err := f.ClientSet() + if err != nil { return err } + printer, _, err := kubectl.GetPrinter("json", "", false) if err != nil { return err } - nodes, err := c.Nodes().List(api.ListOptions{}) + nodes, err := clientset.Core().Nodes().List(api.ListOptions{}) if err != nil { return err } @@ -107,7 +106,7 @@ func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out var namespaces []string if cmdutil.GetFlagBool(cmd, "all-namespaces") { - namespaceList, err := c.Namespaces().List(api.ListOptions{}) + namespaceList, err := clientset.Core().Namespaces().List(api.ListOptions{}) if err != nil { return err } @@ -130,7 +129,7 @@ func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out for _, namespace := range namespaces { // TODO: this is repetitive in the extreme. Use reflection or // something to make this a for loop. - events, err := c.Events(namespace).List(api.ListOptions{}) + events, err := clientset.Core().Events(namespace).List(api.ListOptions{}) if err != nil { return err } @@ -138,7 +137,7 @@ func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out return err } - rcs, err := c.ReplicationControllers(namespace).List(api.ListOptions{}) + rcs, err := clientset.Core().ReplicationControllers(namespace).List(api.ListOptions{}) if err != nil { return err } @@ -146,7 +145,7 @@ func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out return err } - svcs, err := c.Services(namespace).List(api.ListOptions{}) + svcs, err := clientset.Core().Services(namespace).List(api.ListOptions{}) if err != nil { return err } @@ -154,7 +153,7 @@ func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out return err } - sets, err := c.DaemonSets(namespace).List(api.ListOptions{}) + sets, err := clientset.Extensions().DaemonSets(namespace).List(api.ListOptions{}) if err != nil { return err } @@ -162,7 +161,7 @@ func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out return err } - deps, err := c.Deployments(namespace).List(api.ListOptions{}) + deps, err := clientset.Extensions().Deployments(namespace).List(api.ListOptions{}) if err != nil { return err } @@ -170,7 +169,7 @@ func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out return err } - rps, err := c.ReplicaSets(namespace).List(api.ListOptions{}) + rps, err := clientset.Extensions().ReplicaSets(namespace).List(api.ListOptions{}) if err != nil { return err } @@ -178,7 +177,7 @@ func dumpClusterInfo(f *cmdutil.Factory, cmd *cobra.Command, args []string, out return err } - pods, err := c.Pods(namespace).List(api.ListOptions{}) + pods, err := clientset.Core().Pods(namespace).List(api.ListOptions{}) if err != nil { return err } diff --git a/pkg/kubectl/cmd/cmd_test.go b/pkg/kubectl/cmd/cmd_test.go index aa890bc21c6..8063f481b56 100644 --- a/pkg/kubectl/cmd/cmd_test.go +++ b/pkg/kubectl/cmd/cmd_test.go @@ -37,7 +37,6 @@ import ( "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/typed/discovery" client "k8s.io/kubernetes/pkg/client/unversioned" - clientset "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" "k8s.io/kubernetes/pkg/client/unversioned/fake" "k8s.io/kubernetes/pkg/kubectl" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" @@ -61,9 +60,22 @@ func defaultHeader() http.Header { func defaultClientConfig() *restclient.Config { return &restclient.Config{ + APIPath: "/api", ContentConfig: restclient.ContentConfig{ - ContentType: runtime.ContentTypeJSON, - GroupVersion: testapi.Default.GroupVersion(), + NegotiatedSerializer: api.Codecs, + ContentType: runtime.ContentTypeJSON, + GroupVersion: testapi.Default.GroupVersion(), + }, + } +} + +func defaultClientConfigForVersion(version *unversioned.GroupVersion) *restclient.Config { + return &restclient.Config{ + APIPath: "/api", + ContentConfig: restclient.ContentConfig{ + NegotiatedSerializer: api.Codecs, + ContentType: runtime.ContentTypeJSON, + GroupVersion: version, }, } } @@ -289,20 +301,25 @@ func NewAPIFactory() (*cmdutil.Factory, *testFactory, runtime.Codec, runtime.Neg return kubectl.ShortcutExpander{RESTMapper: mapper}, typer, nil }, - Client: func() (*client.Client, error) { + ClientSet: func() (*internalclientset.Clientset, error) { // Swap out the HTTP client out of the client with the fake's version. fakeClient := t.Client.(*fake.RESTClient) - c := client.NewOrDie(t.ClientConfig) - c.Client = fakeClient.Client - c.ExtensionsClient.Client = fakeClient.Client - return c, t.Err + restClient, err := restclient.RESTClientFor(t.ClientConfig) + if err != nil { + panic(err) + } + restClient.Client = fakeClient.Client + return internalclientset.New(restClient), t.Err }, - ClientSet: func() (*internalclientset.Clientset, error) { + RESTClient: func() (*restclient.RESTClient, error) { + // Swap out the HTTP client out of the client with the fake's version. fakeClient := t.Client.(*fake.RESTClient) - c := client.NewOrDie(t.ClientConfig) - c.Client = fakeClient.Client - c.ExtensionsClient.Client = fakeClient.Client - return clientset.FromUnversionedClient(c), nil + restClient, err := restclient.RESTClientFor(t.ClientConfig) + if err != nil { + panic(err) + } + restClient.Client = fakeClient.Client + return restClient, t.Err }, ClientForMapping: func(*meta.RESTMapping) (resource.RESTClient, error) { return t.Client, t.Err diff --git a/pkg/kubectl/cmd/drain.go b/pkg/kubectl/cmd/drain.go index 19d5e7bca2f..f21ac9c649b 100644 --- a/pkg/kubectl/cmd/drain.go +++ b/pkg/kubectl/cmd/drain.go @@ -28,7 +28,8 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/meta" - client "k8s.io/kubernetes/pkg/client/unversioned" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" + "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/fields" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" "k8s.io/kubernetes/pkg/kubectl/resource" @@ -37,7 +38,8 @@ import ( ) type DrainOptions struct { - client *client.Client + client *internalclientset.Clientset + restClient *restclient.RESTClient factory *cmdutil.Factory Force bool GracePeriodSeconds int @@ -177,7 +179,12 @@ func (o *DrainOptions) SetupDrain(cmd *cobra.Command, args []string) error { return cmdutil.UsageError(cmd, fmt.Sprintf("USAGE: %s [flags]", cmd.Use)) } - if o.client, err = o.factory.Client(); err != nil { + if o.client, err = o.factory.ClientSet(); err != nil { + return err + } + + o.restClient, err = o.factory.RESTClient() + if err != nil { return err } @@ -227,13 +234,13 @@ func (o *DrainOptions) RunDrain() error { func (o *DrainOptions) getController(sr *api.SerializedReference) (interface{}, error) { switch sr.Reference.Kind { case "ReplicationController": - return o.client.ReplicationControllers(sr.Reference.Namespace).Get(sr.Reference.Name) + return o.client.Core().ReplicationControllers(sr.Reference.Namespace).Get(sr.Reference.Name) case "DaemonSet": - return o.client.DaemonSets(sr.Reference.Namespace).Get(sr.Reference.Name) + return o.client.Extensions().DaemonSets(sr.Reference.Namespace).Get(sr.Reference.Name) case "Job": - return o.client.ExtensionsClient.Jobs(sr.Reference.Namespace).Get(sr.Reference.Name) + return o.client.Batch().Jobs(sr.Reference.Namespace).Get(sr.Reference.Name) case "ReplicaSet": - return o.client.ExtensionsClient.ReplicaSets(sr.Reference.Namespace).Get(sr.Reference.Name) + return o.client.Extensions().ReplicaSets(sr.Reference.Namespace).Get(sr.Reference.Name) } return nil, fmt.Errorf("Unknown controller kind %q", sr.Reference.Kind) } @@ -284,7 +291,7 @@ func (o *DrainOptions) daemonsetFilter(pod api.Pod) (bool, *warning, *fatal) { if sr == nil || sr.Reference.Kind != "DaemonSet" { return true, nil, nil } - if _, err := o.client.DaemonSets(sr.Reference.Namespace).Get(sr.Reference.Name); err != nil { + if _, err := o.client.Extensions().DaemonSets(sr.Reference.Namespace).Get(sr.Reference.Name); err != nil { return false, nil, &fatal{err.Error()} } if !o.IgnoreDaemonsets { @@ -335,7 +342,7 @@ func (ps podStatuses) Message() string { // getPodsForDeletion returns all the pods we're going to delete. If there are // any pods preventing us from deleting, we return that list in an error. func (o *DrainOptions) getPodsForDeletion() (pods []api.Pod, err error) { - podList, err := o.client.Pods(api.NamespaceAll).List(api.ListOptions{ + podList, err := o.client.Core().Pods(api.NamespaceAll).List(api.ListOptions{ FieldSelector: fields.SelectorFromSet(fields.Set{"spec.nodeName": o.nodeInfo.Name})}) if err != nil { return pods, err @@ -380,7 +387,7 @@ func (o *DrainOptions) deletePods(pods []api.Pod) error { } for _, pod := range pods { - err := o.client.Pods(pod.Namespace).Delete(pod.Name, &deleteOptions) + err := o.client.Core().Pods(pod.Namespace).Delete(pod.Name, &deleteOptions) if err != nil { return err } @@ -403,7 +410,7 @@ func (o *DrainOptions) RunCordonOrUncordon(desired bool) error { if unsched.Bool() == desired { cmdutil.PrintSuccess(o.mapper, false, o.out, o.nodeInfo.Mapping.Resource, o.nodeInfo.Name, already(desired)) } else { - helper := resource.NewHelper(o.client, o.nodeInfo.Mapping) + helper := resource.NewHelper(o.restClient, o.nodeInfo.Mapping) unsched.SetBool(desired) _, err := helper.Replace(cmdNamespace, o.nodeInfo.Name, true, o.nodeInfo.Object) if err != nil { diff --git a/pkg/kubectl/cmd/drain_test.go b/pkg/kubectl/cmd/drain_test.go index a1261b689a1..fd285c8cdf4 100644 --- a/pkg/kubectl/cmd/drain_test.go +++ b/pkg/kubectl/cmd/drain_test.go @@ -552,7 +552,10 @@ type MyReq struct { func (m *MyReq) isFor(method string, path string) bool { req := m.Request - return method == req.Method && (req.URL.Path == path || req.URL.Path == strings.Join([]string{"/api/v1", path}, "") || req.URL.Path == strings.Join([]string{"/apis/extensions/v1beta1", path}, "")) + return method == req.Method && (req.URL.Path == path || + req.URL.Path == strings.Join([]string{"/api/v1", path}, "") || + req.URL.Path == strings.Join([]string{"/apis/extensions/v1beta1", path}, "") || + req.URL.Path == strings.Join([]string{"/apis/batch/v1", path}, "")) } func refJson(t *testing.T, o runtime.Object) string { diff --git a/pkg/kubectl/cmd/exec.go b/pkg/kubectl/cmd/exec.go index baf8377e286..62c1f92f814 100644 --- a/pkg/kubectl/cmd/exec.go +++ b/pkg/kubectl/cmd/exec.go @@ -24,9 +24,10 @@ import ( dockerterm "github.com/docker/docker/pkg/term" "github.com/renstrom/dedent" "github.com/spf13/cobra" + "k8s.io/kubernetes/pkg/api" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" "k8s.io/kubernetes/pkg/client/restclient" - client "k8s.io/kubernetes/pkg/client/unversioned" "k8s.io/kubernetes/pkg/client/unversioned/remotecommand" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" remotecommandserver "k8s.io/kubernetes/pkg/kubelet/server/remotecommand" @@ -132,7 +133,7 @@ type ExecOptions struct { FullCmdName string Executor RemoteExecutor - Client *client.Client + PodClient coreclient.PodsGetter Config *restclient.Config } @@ -172,11 +173,11 @@ func (p *ExecOptions) Complete(f *cmdutil.Factory, cmd *cobra.Command, argsIn [] } p.Config = config - client, err := f.Client() + clientset, err := f.ClientSet() if err != nil { return err } - p.Client = client + p.PodClient = clientset.Core() return nil } @@ -192,7 +193,7 @@ func (p *ExecOptions) Validate() error { if p.Out == nil || p.Err == nil { return fmt.Errorf("both output and error output must be provided") } - if p.Executor == nil || p.Client == nil || p.Config == nil { + if p.Executor == nil || p.PodClient == nil || p.Config == nil { return fmt.Errorf("client, client config, and executor must be provided") } return nil @@ -252,7 +253,7 @@ func (o *StreamOptions) setupTTY() term.TTY { // Run executes a validated remote execution against a pod. func (p *ExecOptions) Run() error { - pod, err := p.Client.Pods(p.Namespace).Get(p.PodName) + pod, err := p.PodClient.Pods(p.Namespace).Get(p.PodName) if err != nil { return err } @@ -283,8 +284,13 @@ func (p *ExecOptions) Run() error { } fn := func() error { + restClient, err := restclient.RESTClientFor(p.Config) + if err != nil { + return err + } + // TODO: consider abstracting into a client invocation or client helper - req := p.Client.RESTClient.Post(). + req := restClient.Post(). Resource("pods"). Name(pod.Name). Namespace(pod.Namespace). diff --git a/pkg/kubectl/cmd/exec_test.go b/pkg/kubectl/cmd/exec_test.go index 3340aef0294..3cf3c695b40 100644 --- a/pkg/kubectl/cmd/exec_test.go +++ b/pkg/kubectl/cmd/exec_test.go @@ -31,7 +31,6 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/testapi" - "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/unversioned/fake" "k8s.io/kubernetes/pkg/util/term" @@ -133,7 +132,7 @@ func TestPodAndContainer(t *testing.T) { Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return nil, nil }), } tf.Namespace = "test" - tf.ClientConfig = &restclient.Config{} + tf.ClientConfig = defaultClientConfig() cmd := &cobra.Command{} options := test.p @@ -162,20 +161,18 @@ func TestPodAndContainer(t *testing.T) { func TestExec(t *testing.T) { version := testapi.Default.GroupVersion().Version tests := []struct { - name, version, podPath, execPath, container string - pod *api.Pod - execErr bool + name, podPath, execPath, container string + pod *api.Pod + execErr bool }{ { name: "pod exec", - version: version, podPath: "/api/" + version + "/namespaces/test/pods/foo", execPath: "/api/" + version + "/namespaces/test/pods/foo/exec", pod: execPod(), }, { name: "pod exec error", - version: version, podPath: "/api/" + version + "/namespaces/test/pods/foo", execPath: "/api/" + version + "/namespaces/test/pods/foo/exec", pod: execPod(), @@ -199,7 +196,7 @@ func TestExec(t *testing.T) { }), } tf.Namespace = "test" - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: test.version}}} + tf.ClientConfig = defaultClientConfig() bufOut := bytes.NewBuffer([]byte{}) bufErr := bytes.NewBuffer([]byte{}) bufIn := bytes.NewBuffer([]byte{}) diff --git a/pkg/kubectl/cmd/get.go b/pkg/kubectl/cmd/get.go index 620750b85fb..18434ea0fd6 100644 --- a/pkg/kubectl/cmd/get.go +++ b/pkg/kubectl/cmd/get.go @@ -22,6 +22,7 @@ import ( "github.com/renstrom/dedent" "github.com/spf13/cobra" + "k8s.io/kubernetes/pkg/api/meta" "k8s.io/kubernetes/pkg/kubectl" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" @@ -126,12 +127,12 @@ func NewCmdGet(f *cmdutil.Factory, out io.Writer, errOut io.Writer) *cobra.Comma // TODO: convert all direct flag accessors to a struct and pass that instead of cmd func RunGet(f *cmdutil.Factory, out io.Writer, errOut io.Writer, cmd *cobra.Command, args []string, options *GetOptions) error { if len(options.Raw) > 0 { - client, err := f.Client() + restClient, err := f.RESTClient() if err != nil { return err } - stream, err := client.RESTClient.Get().RequestURI(options.Raw).Stream() + stream, err := restClient.Get().RequestURI(options.Raw).Stream() if err != nil { return err } diff --git a/pkg/kubectl/cmd/portforward.go b/pkg/kubectl/cmd/portforward.go index fae37584740..c78411464bd 100644 --- a/pkg/kubectl/cmd/portforward.go +++ b/pkg/kubectl/cmd/portforward.go @@ -25,9 +25,10 @@ import ( "github.com/renstrom/dedent" "github.com/spf13/cobra" + "k8s.io/kubernetes/pkg/api" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" "k8s.io/kubernetes/pkg/client/restclient" - client "k8s.io/kubernetes/pkg/client/unversioned" "k8s.io/kubernetes/pkg/client/unversioned/portforward" "k8s.io/kubernetes/pkg/client/unversioned/remotecommand" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" @@ -37,8 +38,9 @@ import ( type PortForwardOptions struct { Namespace string PodName string + RESTClient *restclient.RESTClient Config *restclient.Config - Client *client.Client + PodClient coreclient.PodsGetter Ports []string PortForwarder portForwarder StopChannel chan struct{} @@ -130,15 +132,20 @@ func (o *PortForwardOptions) Complete(f *cmdutil.Factory, cmd *cobra.Command, ar return err } - o.Client, err = f.Client() + clientset, err := f.ClientSet() if err != nil { return err } + o.PodClient = clientset.Core() o.Config, err = f.ClientConfig() if err != nil { return err } + o.RESTClient, err = f.RESTClient() + if err != nil { + return err + } o.StopChannel = make(chan struct{}, 1) o.ReadyChannel = make(chan struct{}) @@ -155,15 +162,15 @@ func (o PortForwardOptions) Validate() error { return fmt.Errorf("at least 1 PORT is required for port-forward") } - if o.PortForwarder == nil || o.Client == nil || o.Config == nil { - return fmt.Errorf("client, client config, and portforwarder must be provided") + if o.PortForwarder == nil || o.PodClient == nil || o.RESTClient == nil || o.Config == nil { + return fmt.Errorf("client, client config, restClient, and portforwarder must be provided") } return nil } // RunPortForward implements all the necessary functionality for port-forward cmd. func (o PortForwardOptions) RunPortForward() error { - pod, err := o.Client.Pods(o.Namespace).Get(o.PodName) + pod, err := o.PodClient.Pods(o.Namespace).Get(o.PodName) if err != nil { return err } @@ -183,7 +190,7 @@ func (o PortForwardOptions) RunPortForward() error { } }() - req := o.Client.RESTClient.Post(). + req := o.RESTClient.Post(). Resource("pods"). Namespace(o.Namespace). Name(pod.Name). diff --git a/pkg/kubectl/cmd/portforward_test.go b/pkg/kubectl/cmd/portforward_test.go index 45c4597367b..37ce5a4be26 100644 --- a/pkg/kubectl/cmd/portforward_test.go +++ b/pkg/kubectl/cmd/portforward_test.go @@ -27,8 +27,6 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/testapi" - "k8s.io/kubernetes/pkg/api/unversioned" - "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/unversioned/fake" ) @@ -48,20 +46,19 @@ func TestPortForward(t *testing.T) { version := testapi.Default.GroupVersion().Version tests := []struct { - name, version, podPath, pfPath, container string - pod *api.Pod - pfErr bool + name string + podPath, pfPath, container string + pod *api.Pod + pfErr bool }{ { name: "pod portforward", - version: version, podPath: "/api/" + version + "/namespaces/test/pods/foo", pfPath: "/api/" + version + "/namespaces/test/pods/foo/portforward", pod: execPod(), }, { name: "pod portforward error", - version: version, podPath: "/api/" + version + "/namespaces/test/pods/foo", pfPath: "/api/" + version + "/namespaces/test/pods/foo/portforward", pod: execPod(), @@ -86,7 +83,7 @@ func TestPortForward(t *testing.T) { }), } tf.Namespace = "test" - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: test.version}}} + tf.ClientConfig = defaultClientConfig() ff := &fakePortForwarder{} if test.pfErr { ff.pfErr = fmt.Errorf("pf error") @@ -130,20 +127,18 @@ func TestPortForwardWithPFlag(t *testing.T) { version := testapi.Default.GroupVersion().Version tests := []struct { - name, version, podPath, pfPath, container string - pod *api.Pod - pfErr bool + name, podPath, pfPath, container string + pod *api.Pod + pfErr bool }{ { name: "pod portforward", - version: version, podPath: "/api/" + version + "/namespaces/test/pods/foo", pfPath: "/api/" + version + "/namespaces/test/pods/foo/portforward", pod: execPod(), }, { name: "pod portforward error", - version: version, podPath: "/api/" + version + "/namespaces/test/pods/foo", pfPath: "/api/" + version + "/namespaces/test/pods/foo/portforward", pod: execPod(), @@ -168,7 +163,7 @@ func TestPortForwardWithPFlag(t *testing.T) { }), } tf.Namespace = "test" - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: test.version}}} + tf.ClientConfig = defaultClientConfig() ff := &fakePortForwarder{} if test.pfErr { ff.pfErr = fmt.Errorf("pf error") diff --git a/pkg/kubectl/cmd/rollingupdate.go b/pkg/kubectl/cmd/rollingupdate.go index 2f336b7b417..bd4d618d65d 100644 --- a/pkg/kubectl/cmd/rollingupdate.go +++ b/pkg/kubectl/cmd/rollingupdate.go @@ -27,6 +27,7 @@ import ( "github.com/renstrom/dedent" "github.com/spf13/cobra" + "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/meta" @@ -177,24 +178,25 @@ func RunRollingUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, arg return err } - client, err := f.Client() + clientset, err := f.ClientSet() if err != nil { return err } + coreClient := clientset.Core() var newRc *api.ReplicationController // fetch rc - oldRc, err := client.ReplicationControllers(cmdNamespace).Get(oldName) + oldRc, err := coreClient.ReplicationControllers(cmdNamespace).Get(oldName) if err != nil { if !errors.IsNotFound(err) || len(image) == 0 || len(args) > 1 { return err } // We're in the middle of a rename, look for an RC with a source annotation of oldName - newRc, err := kubectl.FindSourceController(client, cmdNamespace, oldName) + newRc, err := kubectl.FindSourceController(coreClient, cmdNamespace, oldName) if err != nil { return err } - return kubectl.Rename(client, newRc, oldName) + return kubectl.Rename(coreClient, newRc, oldName) } var keepOldName bool @@ -248,10 +250,10 @@ func RunRollingUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, arg // than the old rc. This selector is the hash of the rc, with a suffix to provide uniqueness for // same-image updates. if len(image) != 0 { - codec := api.Codecs.LegacyCodec(client.APIVersion()) + codec := api.Codecs.LegacyCodec(clientset.CoreClient.APIVersion()) keepOldName = len(args) == 1 newName := findNewName(args, oldRc) - if newRc, err = kubectl.LoadExistingNextReplicationController(client, cmdNamespace, newName); err != nil { + if newRc, err = kubectl.LoadExistingNextReplicationController(coreClient, cmdNamespace, newName); err != nil { return err } if newRc != nil { @@ -274,7 +276,7 @@ func RunRollingUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, arg } config.PullPolicy = api.PullPolicy(pullPolicy) } - newRc, err = kubectl.CreateNewControllerFromCurrentController(client, codec, config) + newRc, err = kubectl.CreateNewControllerFromCurrentController(coreClient, codec, config) if err != nil { return err } @@ -287,7 +289,7 @@ func RunRollingUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, arg } // If new image is same as old, the hash may not be distinct, so add a suffix. oldHash += "-orig" - oldRc, err = kubectl.UpdateExistingReplicationController(client, oldRc, cmdNamespace, newRc.Name, deploymentKey, oldHash, out) + oldRc, err = kubectl.UpdateExistingReplicationController(coreClient, coreClient, oldRc, cmdNamespace, newRc.Name, deploymentKey, oldHash, out) if err != nil { return err } @@ -296,7 +298,7 @@ func RunRollingUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, arg if rollback { keepOldName = len(args) == 1 newName := findNewName(args, oldRc) - if newRc, err = kubectl.LoadExistingNextReplicationController(client, cmdNamespace, newName); err != nil { + if newRc, err = kubectl.LoadExistingNextReplicationController(coreClient, cmdNamespace, newName); err != nil { return err } @@ -310,7 +312,7 @@ func RunRollingUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, arg filename, oldName) } - updater := kubectl.NewRollingUpdater(newRc.Namespace, client) + updater := kubectl.NewRollingUpdater(newRc.Namespace, coreClient, coreClient) // To successfully pull off a rolling update the new and old rc have to differ // by at least one selector. Every new pod should have the selector and every @@ -367,7 +369,7 @@ func RunRollingUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, arg if err != nil { return err } - client.ReplicationControllers(config.NewRc.Namespace).Update(config.NewRc) + coreClient.ReplicationControllers(config.NewRc.Namespace).Update(config.NewRc) } err = updater.Update(config) if err != nil { @@ -380,7 +382,7 @@ func RunRollingUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, arg } else { message = fmt.Sprintf("rolling updated to %q", newRc.Name) } - newRc, err = client.ReplicationControllers(cmdNamespace).Get(newRc.Name) + newRc, err = coreClient.ReplicationControllers(cmdNamespace).Get(newRc.Name) if err != nil { return err } diff --git a/pkg/kubectl/cmd/run.go b/pkg/kubectl/cmd/run.go index b379313285b..87751e3fc8e 100644 --- a/pkg/kubectl/cmd/run.go +++ b/pkg/kubectl/cmd/run.go @@ -32,7 +32,7 @@ import ( "k8s.io/kubernetes/pkg/api/unversioned" batchv1 "k8s.io/kubernetes/pkg/apis/batch/v1" "k8s.io/kubernetes/pkg/apis/extensions/v1beta1" - client "k8s.io/kubernetes/pkg/client/unversioned" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" "k8s.io/kubernetes/pkg/kubectl" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" "k8s.io/kubernetes/pkg/kubectl/resource" @@ -179,11 +179,11 @@ func Run(f *cmdutil.Factory, cmdIn io.Reader, cmdOut, cmdErr io.Writer, cmd *cob generatorName = "scheduledjob/v2alpha1" } if len(generatorName) == 0 { - client, err := f.Client() + clientset, err := f.ClientSet() if err != nil { return err } - resourcesList, err := client.Discovery().ServerResources() + resourcesList, err := clientset.Discovery().ServerResources() // ServerResources ignores errors for old servers do not expose discovery if err != nil { return fmt.Errorf("failed to discover supported resources: %v", err) @@ -270,11 +270,6 @@ func Run(f *cmdutil.Factory, cmdIn io.Reader, cmdOut, cmdErr io.Writer, cmd *cob } opts.Config = config - client, err := f.Client() - if err != nil { - return err - } - clientset, err := f.ClientSet() if err != nil { return err @@ -285,7 +280,7 @@ func Run(f *cmdutil.Factory, cmdIn io.Reader, cmdOut, cmdErr io.Writer, cmd *cob if err != nil { return err } - err = handleAttachPod(f, client, attachablePod.Namespace, attachablePod.Name, opts, quiet) + err = handleAttachPod(f, clientset.Core(), attachablePod.Namespace, attachablePod.Name, opts, quiet) if err != nil { return err } @@ -294,7 +289,7 @@ func Run(f *cmdutil.Factory, cmdIn io.Reader, cmdOut, cmdErr io.Writer, cmd *cob leaveStdinOpen := cmdutil.GetFlagBool(cmd, "leave-stdin-open") waitForExitCode := !leaveStdinOpen && restartPolicy == api.RestartPolicyNever if waitForExitCode { - pod, err = waitForPodTerminated(client, attachablePod.Namespace, attachablePod.Name, opts.Out, quiet) + pod, err = waitForPodTerminated(clientset.Core(), attachablePod.Namespace, attachablePod.Name, opts.Out, quiet) if err != nil { return err } @@ -377,8 +372,8 @@ func contains(resourcesList map[string]*unversioned.APIResourceList, resource un // waitForPod watches the given pod until the exitCondition is true. Each two seconds // the tick function is called e.g. for progress output. -func waitForPod(c *client.Client, ns, name string, exitCondition func(*api.Pod) bool, tick func(*api.Pod)) (*api.Pod, error) { - pod, err := c.Pods(ns).Get(name) +func waitForPod(podClient coreclient.PodsGetter, ns, name string, exitCondition func(*api.Pod) bool, tick func(*api.Pod)) (*api.Pod, error) { + pod, err := podClient.Pods(ns).Get(name) if err != nil { return nil, err } @@ -388,7 +383,7 @@ func waitForPod(c *client.Client, ns, name string, exitCondition func(*api.Pod) tick(pod) - w, err := c.Pods(ns).Watch(api.SingleObject(api.ObjectMeta{Name: pod.Name, ResourceVersion: pod.ResourceVersion})) + w, err := podClient.Pods(ns).Watch(api.SingleObject(api.ObjectMeta{Name: pod.Name, ResourceVersion: pod.ResourceVersion})) if err != nil { return nil, err } @@ -424,7 +419,7 @@ func waitForPod(c *client.Client, ns, name string, exitCondition func(*api.Pod) return result, err } -func waitForPodRunning(c *client.Client, ns, name string, out io.Writer, quiet bool) (*api.Pod, error) { +func waitForPodRunning(podClient coreclient.PodsGetter, ns, name string, out io.Writer, quiet bool) (*api.Pod, error) { exitCondition := func(pod *api.Pod) bool { switch pod.Status.Phase { case api.PodRunning: @@ -440,26 +435,26 @@ func waitForPodRunning(c *client.Client, ns, name string, out io.Writer, quiet b return false } } - return waitForPod(c, ns, name, exitCondition, func(pod *api.Pod) { + return waitForPod(podClient, ns, name, exitCondition, func(pod *api.Pod) { if !quiet { fmt.Fprintf(out, "Waiting for pod %s/%s to be running, status is %s, pod ready: false\n", pod.Namespace, pod.Name, pod.Status.Phase) } }) } -func waitForPodTerminated(c *client.Client, ns, name string, out io.Writer, quiet bool) (*api.Pod, error) { +func waitForPodTerminated(podClient coreclient.PodsGetter, ns, name string, out io.Writer, quiet bool) (*api.Pod, error) { exitCondition := func(pod *api.Pod) bool { return pod.Status.Phase == api.PodSucceeded || pod.Status.Phase == api.PodFailed } - return waitForPod(c, ns, name, exitCondition, func(pod *api.Pod) { + return waitForPod(podClient, ns, name, exitCondition, func(pod *api.Pod) { if !quiet { fmt.Fprintf(out, "Waiting for pod %s/%s to terminate, status is %s\n", pod.Namespace, pod.Name, pod.Status.Phase) } }) } -func handleAttachPod(f *cmdutil.Factory, c *client.Client, ns, name string, opts *AttachOptions, quiet bool) error { - pod, err := waitForPodRunning(c, ns, name, opts.Out, quiet) +func handleAttachPod(f *cmdutil.Factory, podClient coreclient.PodsGetter, ns, name string, opts *AttachOptions, quiet bool) error { + pod, err := waitForPodRunning(podClient, ns, name, opts.Out, quiet) if err != nil { return err } @@ -481,11 +476,7 @@ func handleAttachPod(f *cmdutil.Factory, c *client.Client, ns, name string, opts return err } - clientset, err := f.ClientSet() - if err != nil { - return nil - } - opts.PodClient = clientset.Core() + opts.PodClient = podClient opts.PodName = name opts.Namespace = ns diff --git a/pkg/kubectl/cmd/top_node.go b/pkg/kubectl/cmd/top_node.go index b685b5649e9..6c9dae8abc5 100644 --- a/pkg/kubectl/cmd/top_node.go +++ b/pkg/kubectl/cmd/top_node.go @@ -20,12 +20,13 @@ import ( "errors" "io" - cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" - "k8s.io/kubernetes/pkg/kubectl/metricsutil" - "github.com/renstrom/dedent" "github.com/spf13/cobra" + "k8s.io/kubernetes/pkg/api" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" + cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" + "k8s.io/kubernetes/pkg/kubectl/metricsutil" "k8s.io/kubernetes/pkg/labels" ) @@ -33,6 +34,7 @@ import ( type TopNodeOptions struct { ResourceName string Selector string + NodeClient coreclient.NodesGetter Client *metricsutil.HeapsterMetricsClient Printer *metricsutil.TopCmdPrinter } @@ -84,11 +86,12 @@ func (o *TopNodeOptions) Complete(f *cmdutil.Factory, cmd *cobra.Command, args [ return cmdutil.UsageError(cmd, cmd.Use) } - cli, err := f.Client() + clientset, err := f.ClientSet() if err != nil { return err } - o.Client = metricsutil.DefaultHeapsterMetricsClient(cli) + o.NodeClient = clientset.Core() + o.Client = metricsutil.DefaultHeapsterMetricsClient(clientset.Core()) o.Printer = metricsutil.NewTopCmdPrinter(out) return nil } @@ -122,13 +125,13 @@ func (o TopNodeOptions) RunTopNode() error { var nodes []api.Node if len(o.ResourceName) > 0 { - node, err := o.Client.Nodes().Get(o.ResourceName) + node, err := o.NodeClient.Nodes().Get(o.ResourceName) if err != nil { return err } nodes = append(nodes, *node) } else { - nodeList, err := o.Client.Nodes().List(api.ListOptions{ + nodeList, err := o.NodeClient.Nodes().List(api.ListOptions{ LabelSelector: selector, }) if err != nil { diff --git a/pkg/kubectl/cmd/top_node_test.go b/pkg/kubectl/cmd/top_node_test.go index 20f8a44730f..3e9a15731ec 100644 --- a/pkg/kubectl/cmd/top_node_test.go +++ b/pkg/kubectl/cmd/top_node_test.go @@ -25,8 +25,6 @@ import ( "k8s.io/heapster/metrics/apis/metrics/v1alpha1" "k8s.io/kubernetes/pkg/api" - "k8s.io/kubernetes/pkg/api/unversioned" - "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/unversioned/fake" "net/url" ) @@ -63,7 +61,7 @@ func TestTopNodeAllMetrics(t *testing.T) { }), } tf.Namespace = "test" - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdTopNode(f, buf) @@ -111,7 +109,7 @@ func TestTopNodeWithNameMetrics(t *testing.T) { }), } tf.Namespace = "test" - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdTopNode(f, buf) @@ -170,7 +168,7 @@ func TestTopNodeWithLabelSelectorMetrics(t *testing.T) { }), } tf.Namespace = "test" - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdTopNode(f, buf) diff --git a/pkg/kubectl/cmd/top_pod.go b/pkg/kubectl/cmd/top_pod.go index c2549791582..a9384643906 100644 --- a/pkg/kubectl/cmd/top_pod.go +++ b/pkg/kubectl/cmd/top_pod.go @@ -23,6 +23,7 @@ import ( "time" "k8s.io/kubernetes/pkg/api" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util" "k8s.io/kubernetes/pkg/kubectl/metricsutil" "k8s.io/kubernetes/pkg/labels" @@ -38,6 +39,7 @@ type TopPodOptions struct { Selector string AllNamespaces bool PrintContainers bool + PodClient coreclient.PodsGetter Client *metricsutil.HeapsterMetricsClient Printer *metricsutil.TopCmdPrinter } @@ -103,11 +105,12 @@ func (o *TopPodOptions) Complete(f *cmdutil.Factory, cmd *cobra.Command, args [] if err != nil { return err } - cli, err := f.Client() + clientset, err := f.ClientSet() if err != nil { return err } - o.Client = metricsutil.DefaultHeapsterMetricsClient(cli) + o.PodClient = clientset.Core() + o.Client = metricsutil.DefaultHeapsterMetricsClient(clientset.Core()) o.Printer = metricsutil.NewTopCmdPrinter(out) return nil } @@ -147,7 +150,7 @@ func (o TopPodOptions) RunTopPod() error { func verifyEmptyMetrics(o TopPodOptions, selector labels.Selector) error { if len(o.ResourceName) > 0 { - pod, err := o.Client.Pods(o.Namespace).Get(o.ResourceName) + pod, err := o.PodClient.Pods(o.Namespace).Get(o.ResourceName) if err != nil { return err } @@ -155,7 +158,7 @@ func verifyEmptyMetrics(o TopPodOptions, selector labels.Selector) error { return err } } else { - pods, err := o.Client.Pods(o.Namespace).List(api.ListOptions{ + pods, err := o.PodClient.Pods(o.Namespace).List(api.ListOptions{ LabelSelector: selector, }) if err != nil { diff --git a/pkg/kubectl/cmd/top_pod_test.go b/pkg/kubectl/cmd/top_pod_test.go index 587677b3179..9ef1e408b1a 100644 --- a/pkg/kubectl/cmd/top_pod_test.go +++ b/pkg/kubectl/cmd/top_pod_test.go @@ -24,8 +24,6 @@ import ( "testing" metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1" - "k8s.io/kubernetes/pkg/api/unversioned" - "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/unversioned/fake" "net/url" ) @@ -61,7 +59,7 @@ func TestTopPodAllNamespacesMetrics(t *testing.T) { }), } tf.Namespace = firstTestNamespace - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdTopPod(f, buf) @@ -120,7 +118,7 @@ func TestTopPodAllInNamespaceMetrics(t *testing.T) { }), } tf.Namespace = testNamespace - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdTopPod(f, buf) @@ -171,7 +169,7 @@ func TestTopPodWithNameMetrics(t *testing.T) { }), } tf.Namespace = testNamespace - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdTopPod(f, buf) @@ -224,7 +222,7 @@ func TestTopPodWithLabelSelectorMetrics(t *testing.T) { }), } tf.Namespace = testNamespace - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdTopPod(f, buf) @@ -276,7 +274,7 @@ func TestTopPodWithContainersMetrics(t *testing.T) { }), } tf.Namespace = testNamespace - tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &unversioned.GroupVersion{Version: "v1"}}} + tf.ClientConfig = defaultClientConfig() buf := bytes.NewBuffer([]byte{}) cmd := NewCmdTopPod(f, buf) diff --git a/pkg/kubectl/cmd/top_test.go b/pkg/kubectl/cmd/top_test.go index 8250c9f2ca2..2b47176c501 100644 --- a/pkg/kubectl/cmd/top_test.go +++ b/pkg/kubectl/cmd/top_test.go @@ -32,8 +32,8 @@ import ( ) const ( - baseHeapsterServiceAddress = "/api/v1/namespaces/kube-system/services/http:heapster:" - baseMetricsAddress = baseHeapsterServiceAddress + "/proxy/apis/metrics" + baseHeapsterServiceAddress = "/api/v1/proxy/namespaces/kube-system/services/http:heapster:" + baseMetricsAddress = baseHeapsterServiceAddress + "/apis/metrics" metricsApiVersion = "v1alpha1" ) diff --git a/pkg/kubectl/cmd/util/clientcache.go b/pkg/kubectl/cmd/util/clientcache.go index 81476cabaf0..8ae66177811 100644 --- a/pkg/kubectl/cmd/util/clientcache.go +++ b/pkg/kubectl/cmd/util/clientcache.go @@ -20,6 +20,7 @@ import ( fed_clientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset" "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/apimachinery/registered" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" "k8s.io/kubernetes/pkg/client/restclient" client "k8s.io/kubernetes/pkg/client/unversioned" "k8s.io/kubernetes/pkg/client/unversioned/clientcmd" @@ -27,7 +28,7 @@ import ( func NewClientCache(loader clientcmd.ClientConfig) *ClientCache { return &ClientCache{ - clients: make(map[unversioned.GroupVersion]*client.Client), + clientsets: make(map[unversioned.GroupVersion]*internalclientset.Clientset), configs: make(map[unversioned.GroupVersion]*restclient.Config), fedClientSets: make(map[unversioned.GroupVersion]fed_clientset.Interface), loader: loader, @@ -38,7 +39,7 @@ func NewClientCache(loader clientcmd.ClientConfig) *ClientCache { // is invoked only once type ClientCache struct { loader clientcmd.ClientConfig - clients map[unversioned.GroupVersion]*client.Client + clientsets map[unversioned.GroupVersion]*internalclientset.Clientset fedClientSets map[unversioned.GroupVersion]fed_clientset.Interface configs map[unversioned.GroupVersion]*restclient.Config defaultConfig *restclient.Config @@ -95,12 +96,12 @@ func (c *ClientCache) ClientConfigForVersion(version *unversioned.GroupVersion) return &config, nil } -// ClientForVersion initializes or reuses a client for the specified version, or returns an +// ClientSetForVersion initializes or reuses a clientset for the specified version, or returns an // error if that is not possible -func (c *ClientCache) ClientForVersion(version *unversioned.GroupVersion) (*client.Client, error) { +func (c *ClientCache) ClientSetForVersion(version *unversioned.GroupVersion) (*internalclientset.Clientset, error) { if version != nil { - if client, ok := c.clients[*version]; ok { - return client, nil + if clientset, ok := c.clientsets[*version]; ok { + return clientset, nil } } config, err := c.ClientConfigForVersion(version) @@ -108,25 +109,25 @@ func (c *ClientCache) ClientForVersion(version *unversioned.GroupVersion) (*clie return nil, err } - kubeclient, err := client.New(config) + clientset, err := internalclientset.NewForConfig(config) if err != nil { return nil, err } - c.clients[*config.GroupVersion] = kubeclient + c.clientsets[*config.GroupVersion] = clientset // `version` does not necessarily equal `config.Version`. However, we know that if we call this method again with // `version`, we should get a client based on the same config we just found. There's no guarantee that a client // is copiable, so create a new client and save it in the cache. if version != nil { configCopy := *config - kubeclient, err := client.New(&configCopy) + clientset, err := internalclientset.NewForConfig(&configCopy) if err != nil { return nil, err } - c.clients[*version] = kubeclient + c.clientsets[*version] = clientset } - return kubeclient, nil + return clientset, nil } func (c *ClientCache) FederationClientSetForVersion(version *unversioned.GroupVersion) (fed_clientset.Interface, error) { diff --git a/pkg/kubectl/cmd/util/factory.go b/pkg/kubectl/cmd/util/factory.go index b5b76d931b7..ec84e0ac123 100644 --- a/pkg/kubectl/cmd/util/factory.go +++ b/pkg/kubectl/cmd/util/factory.go @@ -49,17 +49,13 @@ import ( "k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/autoscaling" "k8s.io/kubernetes/pkg/apis/batch" - "k8s.io/kubernetes/pkg/apis/certificates" "k8s.io/kubernetes/pkg/apis/extensions" - "k8s.io/kubernetes/pkg/apis/policy" - "k8s.io/kubernetes/pkg/apis/rbac" - "k8s.io/kubernetes/pkg/apis/storage" "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" "k8s.io/kubernetes/pkg/client/restclient" "k8s.io/kubernetes/pkg/client/typed/discovery" "k8s.io/kubernetes/pkg/client/typed/dynamic" client "k8s.io/kubernetes/pkg/client/unversioned" - clientset "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" "k8s.io/kubernetes/pkg/client/unversioned/clientcmd" "k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/kubectl" @@ -97,10 +93,10 @@ type Factory struct { Decoder func(toInternal bool) runtime.Decoder // Returns an encoder capable of encoding a provided object into JSON in the default desired version. JSONEncoder func() runtime.Encoder - // Returns a client for accessing Kubernetes resources or an error. - Client func() (*client.Client, error) // ClientSet gives you back an internal, generated clientset ClientSet func() (*internalclientset.Clientset, error) + // Returns a RESTClient for accessing Kubernetes resources or an error. + RESTClient func() (*restclient.RESTClient, error) // Returns a client.Config for accessing the Kubernetes server. ClientConfig func() (*restclient.Config, error) // Returns a RESTClient for working with the specified RESTMapping or an error. This is intended @@ -308,14 +304,14 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { cmdApiVersion = *cfg.GroupVersion } if discoverDynamicAPIs { - client, err := clients.ClientForVersion(&unversioned.GroupVersion{Version: "v1"}) + clientset, err := clients.ClientSetForVersion(&unversioned.GroupVersion{Version: "v1"}) checkErrWithPrefix("failed to find client for version v1: ", err) var versions []unversioned.GroupVersion var gvks []unversioned.GroupVersionKind retries := 3 for i := 0; i < retries; i++ { - versions, gvks, err = GetThirdPartyGroupVersions(client.Discovery()) + versions, gvks, err = GetThirdPartyGroupVersions(clientset.Discovery()) // Retry if we got a NotFound error, because user may delete // a thirdparty group when the GetThirdPartyGroupVersions is // running. @@ -418,17 +414,15 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return kubectl.ShortcutExpander{RESTMapper: mapper}, typer, nil }, - Client: func() (*client.Client, error) { - return clients.ClientForVersion(nil) - }, - - ClientSet: func() (*internalclientset.Clientset, error) { - cfg, err := clients.ClientConfigForVersion(nil) + RESTClient: func() (*restclient.RESTClient, error) { + clientConfig, err := clients.ClientConfigForVersion(nil) if err != nil { return nil, err } - - return internalclientset.NewForConfig(cfg) + return restclient.RESTClientFor(clientConfig) + }, + ClientSet: func() (*internalclientset.Clientset, error) { + return clients.ClientSetForVersion(nil) }, ClientConfig: func() (*restclient.Config, error) { return clients.ClientConfigForVersion(nil) @@ -486,11 +480,11 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return &kubectl.ClusterDescriber{Interface: fedClientSet}, nil } } - client, err := clients.ClientForVersion(&mappingVersion) + clientset, err := clients.ClientSetForVersion(&mappingVersion) if err != nil { return nil, err } - if describer, ok := kubectl.DescriberFor(mapping.GroupVersionKind.GroupKind(), client); ok { + if describer, ok := kubectl.DescriberFor(mapping.GroupVersionKind.GroupKind(), clientset); ok { return describer, nil } return nil, fmt.Errorf("no description has been implemented for %q", mapping.GroupVersionKind.Kind) @@ -594,7 +588,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return meta.NewAccessor().Labels(object) }, LogsForObject: func(object, options runtime.Object) (*restclient.Request, error) { - c, err := clients.ClientForVersion(nil) + clientset, err := clients.ClientSetForVersion(nil) if err != nil { return nil, err } @@ -605,7 +599,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { if !ok { return nil, errors.New("provided options object is not a PodLogOptions") } - return c.Pods(t.Namespace).GetLogs(t.Name, opts), nil + return clientset.Core().Pods(t.Namespace).GetLogs(t.Name, opts), nil case *api.ReplicationController: opts, ok := options.(*api.PodLogOptions) @@ -614,7 +608,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { } selector := labels.SelectorFromSet(t.Spec.Selector) sortBy := func(pods []*api.Pod) sort.Interface { return controller.ByLogging(pods) } - pod, numPods, err := GetFirstPod(c, t.Namespace, selector, 20*time.Second, sortBy) + pod, numPods, err := GetFirstPod(clientset.Core(), t.Namespace, selector, 20*time.Second, sortBy) if err != nil { return nil, err } @@ -622,7 +616,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { fmt.Fprintf(os.Stderr, "Found %v pods, using pod/%v\n", numPods, pod.Name) } - return c.Pods(pod.Namespace).GetLogs(pod.Name, opts), nil + return clientset.Core().Pods(pod.Namespace).GetLogs(pod.Name, opts), nil case *extensions.ReplicaSet: opts, ok := options.(*api.PodLogOptions) @@ -634,7 +628,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return nil, fmt.Errorf("invalid label selector: %v", err) } sortBy := func(pods []*api.Pod) sort.Interface { return controller.ByLogging(pods) } - pod, numPods, err := GetFirstPod(c, t.Namespace, selector, 20*time.Second, sortBy) + pod, numPods, err := GetFirstPod(clientset.Core(), t.Namespace, selector, 20*time.Second, sortBy) if err != nil { return nil, err } @@ -642,7 +636,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { fmt.Fprintf(os.Stderr, "Found %v pods, using pod/%v\n", numPods, pod.Name) } - return c.Pods(pod.Namespace).GetLogs(pod.Name, opts), nil + return clientset.Core().Pods(pod.Namespace).GetLogs(pod.Name, opts), nil default: gvks, _, err := api.Scheme.ObjectKinds(object) @@ -653,7 +647,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { } }, PauseObject: func(object runtime.Object) (bool, error) { - c, err := clients.ClientForVersion(nil) + clientset, err := clients.ClientSetForVersion(nil) if err != nil { return false, err } @@ -664,7 +658,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return true, nil } t.Spec.Paused = true - _, err := c.Extensions().Deployments(t.Namespace).Update(t) + _, err := clientset.Extensions().Deployments(t.Namespace).Update(t) return false, err default: gvks, _, err := api.Scheme.ObjectKinds(object) @@ -675,7 +669,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { } }, ResumeObject: func(object runtime.Object) (bool, error) { - c, err := clients.ClientForVersion(nil) + clientset, err := clients.ClientSetForVersion(nil) if err != nil { return false, err } @@ -686,7 +680,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return true, nil } t.Spec.Paused = false - _, err := c.Extensions().Deployments(t.Namespace).Update(t) + _, err := clientset.Extensions().Deployments(t.Namespace).Update(t) return false, err default: gvks, _, err := api.Scheme.ObjectKinds(object) @@ -698,55 +692,61 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { }, Scaler: func(mapping *meta.RESTMapping) (kubectl.Scaler, error) { mappingVersion := mapping.GroupVersionKind.GroupVersion() - client, err := clients.ClientForVersion(&mappingVersion) + clientset, err := clients.ClientSetForVersion(&mappingVersion) if err != nil { return nil, err } - return kubectl.ScalerFor(mapping.GroupVersionKind.GroupKind(), client) + return kubectl.ScalerFor(mapping.GroupVersionKind.GroupKind(), clientset) }, Reaper: func(mapping *meta.RESTMapping) (kubectl.Reaper, error) { mappingVersion := mapping.GroupVersionKind.GroupVersion() - client, err := clients.ClientForVersion(&mappingVersion) + clientset, err := clients.ClientSetForVersion(&mappingVersion) if err != nil { return nil, err } - return kubectl.ReaperFor(mapping.GroupVersionKind.GroupKind(), client) + return kubectl.ReaperFor(mapping.GroupVersionKind.GroupKind(), clientset) }, HistoryViewer: func(mapping *meta.RESTMapping) (kubectl.HistoryViewer, error) { mappingVersion := mapping.GroupVersionKind.GroupVersion() - client, err := clients.ClientForVersion(&mappingVersion) + clientset, err := clients.ClientSetForVersion(&mappingVersion) if err != nil { return nil, err } - clientset := clientset.FromUnversionedClient(client) return kubectl.HistoryViewerFor(mapping.GroupVersionKind.GroupKind(), clientset) }, Rollbacker: func(mapping *meta.RESTMapping) (kubectl.Rollbacker, error) { mappingVersion := mapping.GroupVersionKind.GroupVersion() - client, err := clients.ClientForVersion(&mappingVersion) + clientset, err := clients.ClientSetForVersion(&mappingVersion) if err != nil { return nil, err } - clientset := clientset.FromUnversionedClient(client) return kubectl.RollbackerFor(mapping.GroupVersionKind.GroupKind(), clientset) }, StatusViewer: func(mapping *meta.RESTMapping) (kubectl.StatusViewer, error) { mappingVersion := mapping.GroupVersionKind.GroupVersion() - client, err := clients.ClientForVersion(&mappingVersion) + clientset, err := clients.ClientSetForVersion(&mappingVersion) if err != nil { return nil, err } - return kubectl.StatusViewerFor(mapping.GroupVersionKind.GroupKind(), client) + return kubectl.StatusViewerFor(mapping.GroupVersionKind.GroupKind(), clientset) }, Validator: func(validate bool, cacheDir string) (validation.Schema, error) { if validate { - client, err := clients.ClientForVersion(nil) + clientConfig, err := clients.ClientConfigForVersion(nil) + if err != nil { + return nil, err + } + restclient, err := restclient.RESTClientFor(clientConfig) + if err != nil { + return nil, err + } + clientset, err := clients.ClientSetForVersion(nil) if err != nil { return nil, err } dir := cacheDir if len(dir) > 0 { - version, err := client.ServerVersion() + version, err := clientset.Discovery().ServerVersion() if err != nil { return nil, err } @@ -757,7 +757,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return nil, err } return &clientSwaggerSchema{ - c: client, + c: restclient, fedc: fedClient, cacheDir: dir, mapper: api.RESTMapper, @@ -766,18 +766,12 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return validation.NullSchema{}, nil }, SwaggerSchema: func(gvk unversioned.GroupVersionKind) (*swagger.ApiDeclaration, error) { - // discovery doesn't care about which groupversion you get a client for, - // so get whichever one you happen to have available and use that. - cfg, err := clients.ClientConfigForVersion(nil) + version := gvk.GroupVersion() + clientset, err := clients.ClientSetForVersion(&version) if err != nil { return nil, err } - dc, err := discovery.NewDiscoveryClientForConfig(cfg) - if err != nil { - return nil, err - } - - return dc.SwaggerSchema(gvk.GroupVersion()) + return clientset.Discovery().SwaggerSchema(version) }, DefaultNamespace: func() (string, bool, error) { return clientConfig.Namespace() @@ -804,7 +798,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return nil }, AttachablePodForObject: func(object runtime.Object) (*api.Pod, error) { - client, err := clients.ClientForVersion(nil) + clientset, err := clients.ClientSetForVersion(nil) if err != nil { return nil, err } @@ -812,7 +806,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { case *api.ReplicationController: selector := labels.SelectorFromSet(t.Spec.Selector) sortBy := func(pods []*api.Pod) sort.Interface { return sort.Reverse(controller.ActivePods(pods)) } - pod, _, err := GetFirstPod(client, t.Namespace, selector, 1*time.Minute, sortBy) + pod, _, err := GetFirstPod(clientset.Core(), t.Namespace, selector, 1*time.Minute, sortBy) return pod, err case *extensions.Deployment: selector, err := unversioned.LabelSelectorAsSelector(t.Spec.Selector) @@ -820,7 +814,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return nil, fmt.Errorf("invalid label selector: %v", err) } sortBy := func(pods []*api.Pod) sort.Interface { return sort.Reverse(controller.ActivePods(pods)) } - pod, _, err := GetFirstPod(client, t.Namespace, selector, 1*time.Minute, sortBy) + pod, _, err := GetFirstPod(clientset.Core(), t.Namespace, selector, 1*time.Minute, sortBy) return pod, err case *batch.Job: selector, err := unversioned.LabelSelectorAsSelector(t.Spec.Selector) @@ -828,7 +822,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory { return nil, fmt.Errorf("invalid label selector: %v", err) } sortBy := func(pods []*api.Pod) sort.Interface { return sort.Reverse(controller.ActivePods(pods)) } - pod, _, err := GetFirstPod(client, t.Namespace, selector, 1*time.Minute, sortBy) + pod, _, err := GetFirstPod(clientset.Core(), t.Namespace, selector, 1*time.Minute, sortBy) return pod, err case *api.Pod: return t, nil @@ -900,7 +894,7 @@ See http://releases.k8s.io/HEAD/docs/user-guide/services-firewalls.md for more d // GetFirstPod returns a pod matching the namespace and label selector // and the number of all pods that match the label selector. -func GetFirstPod(client client.PodsNamespacer, namespace string, selector labels.Selector, timeout time.Duration, sortBy func([]*api.Pod) sort.Interface) (*api.Pod, int, error) { +func GetFirstPod(client coreclient.PodsGetter, namespace string, selector labels.Selector, timeout time.Duration, sortBy func([]*api.Pod) sort.Interface) (*api.Pod, int, error) { options := api.ListOptions{LabelSelector: selector} podList, err := client.Pods(namespace).List(options) @@ -1026,7 +1020,7 @@ func getServiceProtocols(spec api.ServiceSpec) map[string]string { } type clientSwaggerSchema struct { - c *client.Client + c *restclient.RESTClient fedc *restclient.RESTClient cacheDir string mapper meta.RESTMapper @@ -1157,60 +1151,24 @@ func (c *clientSwaggerSchema) ValidateBytes(data []byte) error { if ok := registered.IsEnabledVersion(gvk.GroupVersion()); !ok { return fmt.Errorf("API version %q isn't supported, only supports API versions %q", gvk.GroupVersion().String(), registered.EnabledVersions()) } - switch gvk.Group { - case autoscaling.GroupName: - if c.c.AutoscalingClient == nil { - return errors.New("unable to validate: no autoscaling client") - } - return getSchemaAndValidate(c.c.AutoscalingClient.RESTClient, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) - case policy.GroupName: - if c.c.PolicyClient == nil { - return errors.New("unable to validate: no policy client") - } - return getSchemaAndValidate(c.c.PolicyClient.RESTClient, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) - case apps.GroupName: - if c.c.AppsClient == nil { - return errors.New("unable to validate: no apps client") - } - return getSchemaAndValidate(c.c.AppsClient.RESTClient, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) - case batch.GroupName: - if c.c.BatchClient == nil { - return errors.New("unable to validate: no batch client") - } - return getSchemaAndValidate(c.c.BatchClient.RESTClient, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) - case rbac.GroupName: - if c.c.RbacClient == nil { - return errors.New("unable to validate: no rbac client") - } - return getSchemaAndValidate(c.c.RbacClient.RESTClient, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) - case storage.GroupName: - if c.c.StorageClient == nil { - return errors.New("unable to validate: no storage client") - } - return getSchemaAndValidate(c.c.StorageClient.RESTClient, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) - } if registered.IsThirdPartyAPIGroupVersion(gvk.GroupVersion()) { // Don't attempt to validate third party objects return nil } + switch gvk.Group { - case extensions.GroupName: - if c.c.ExtensionsClient == nil { - return errors.New("unable to validate: no experimental client") - } - return getSchemaAndValidate(c.c.ExtensionsClient.RESTClient, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) case federation.GroupName: if c.fedc == nil { return errors.New("unable to validate: no federation client") } return getSchemaAndValidate(c.fedc, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) - case certificates.GroupName: - if c.c.CertificatesClient == nil { - return errors.New("unable to validate: no certificates client") - } - return getSchemaAndValidate(c.c.CertificatesClient.RESTClient, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) + + case api.GroupName: + return getSchemaAndValidate(c.c, data, "api", gvk.GroupVersion().String(), c.cacheDir, c) + + default: + return getSchemaAndValidate(c.c, data, "apis/", gvk.GroupVersion().String(), c.cacheDir, c) } - return getSchemaAndValidate(c.c.RESTClient, data, "api", gvk.GroupVersion().String(), c.cacheDir, c) } // DefaultClientConfig creates a clientcmd.ClientConfig with the following hierarchy: diff --git a/pkg/kubectl/cmd/util/factory_test.go b/pkg/kubectl/cmd/util/factory_test.go index cee417937ce..1a5b2b319eb 100644 --- a/pkg/kubectl/cmd/util/factory_test.go +++ b/pkg/kubectl/cmd/util/factory_test.go @@ -36,10 +36,11 @@ import ( "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/validation" "k8s.io/kubernetes/pkg/apis/extensions" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" + testcore "k8s.io/kubernetes/pkg/client/testing/core" "k8s.io/kubernetes/pkg/client/unversioned/clientcmd" clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api" - "k8s.io/kubernetes/pkg/client/unversioned/fake" - "k8s.io/kubernetes/pkg/client/unversioned/testclient" + manualfake "k8s.io/kubernetes/pkg/client/unversioned/fake" "k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/kubectl" "k8s.io/kubernetes/pkg/labels" @@ -262,9 +263,9 @@ func TestRefetchSchemaWhenValidationFails(t *testing.T) { } requests := map[string]int{} - c := &fake.RESTClient{ + c := &manualfake.RESTClient{ NegotiatedSerializer: testapi.Default.NegotiatedSerializer(), - Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { + Client: manualfake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case strings.HasPrefix(p, "/swaggerapi") && m == "GET": requests[p] = requests[p] + 1 @@ -319,9 +320,9 @@ func TestValidateCachesSchema(t *testing.T) { } requests := map[string]int{} - c := &fake.RESTClient{ + c := &manualfake.RESTClient{ NegotiatedSerializer: testapi.Default.NegotiatedSerializer(), - Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { + Client: manualfake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case strings.HasPrefix(p, "/swaggerapi") && m == "GET": requests[p] = requests[p] + 1 @@ -587,10 +588,7 @@ func TestGetFirstPod(t *testing.T) { for i := range tests { test := tests[i] - client := &testclient.Fake{} - client.PrependReactor("list", "pods", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { - return true, test.podList, nil - }) + fake := fake.NewSimpleClientset(test.podList) if len(test.watching) > 0 { watcher := watch.NewFake() for _, event := range test.watching { @@ -601,11 +599,11 @@ func TestGetFirstPod(t *testing.T) { go watcher.Modify(event.Object) } } - client.PrependWatchReactor("pods", testclient.DefaultWatchReactor(watcher, nil)) + fake.PrependWatchReactor("pods", testcore.DefaultWatchReactor(watcher, nil)) } selector := labels.Set(labelSet).AsSelector() - pod, numPods, err := GetFirstPod(client, api.NamespaceDefault, selector, 1*time.Minute, test.sortBy) + pod, numPods, err := GetFirstPod(fake.Core(), api.NamespaceDefault, selector, 1*time.Minute, test.sortBy) if !test.expectedErr && err != nil { t.Errorf("%s: unexpected error: %v", test.name, err) continue diff --git a/pkg/kubectl/cmd/version.go b/pkg/kubectl/cmd/version.go index c4ec598fea7..eb785330dab 100644 --- a/pkg/kubectl/cmd/version.go +++ b/pkg/kubectl/cmd/version.go @@ -17,6 +17,7 @@ limitations under the License. package cmd import ( + "fmt" "io" "github.com/spf13/cobra" @@ -45,11 +46,16 @@ func RunVersion(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command) error { return nil } - client, err := f.Client() + clientset, err := f.ClientSet() if err != nil { return err } - kubectl.GetServerVersion(out, client) + serverVersion, err := clientset.Discovery().ServerVersion() + if err != nil { + return err + } + + fmt.Fprintf(out, "Server Version: %#v\n", *serverVersion) return nil } diff --git a/pkg/kubectl/describe.go b/pkg/kubectl/describe.go index 68d94df8407..bc6ff170ecd 100644 --- a/pkg/kubectl/describe.go +++ b/pkg/kubectl/describe.go @@ -42,7 +42,6 @@ import ( "k8s.io/kubernetes/pkg/apis/storage" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" client "k8s.io/kubernetes/pkg/client/unversioned" - adapter "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util" "k8s.io/kubernetes/pkg/fieldpath" "k8s.io/kubernetes/pkg/fields" @@ -89,7 +88,7 @@ func (e ErrNoDescriber) Error() string { return fmt.Sprintf("no describer has been defined for %v", e.Types) } -func describerMap(c *client.Client) map[unversioned.GroupKind]Describer { +func describerMap(c clientset.Interface) map[unversioned.GroupKind]Describer { m := map[unversioned.GroupKind]Describer{ api.Kind("Pod"): &PodDescriber{c}, api.Kind("ReplicationController"): &ReplicationControllerDescriber{c}, @@ -110,11 +109,11 @@ func describerMap(c *client.Client) map[unversioned.GroupKind]Describer { extensions.Kind("NetworkPolicy"): &NetworkPolicyDescriber{c}, autoscaling.Kind("HorizontalPodAutoscaler"): &HorizontalPodAutoscalerDescriber{c}, extensions.Kind("DaemonSet"): &DaemonSetDescriber{c}, - extensions.Kind("Deployment"): &DeploymentDescriber{adapter.FromUnversionedClient(c)}, + extensions.Kind("Deployment"): &DeploymentDescriber{c}, extensions.Kind("Job"): &JobDescriber{c}, extensions.Kind("Ingress"): &IngressDescriber{c}, batch.Kind("Job"): &JobDescriber{c}, - batch.Kind("ScheduledJob"): &ScheduledJobDescriber{adapter.FromUnversionedClient(c)}, + batch.Kind("ScheduledJob"): &ScheduledJobDescriber{c}, apps.Kind("PetSet"): &PetSetDescriber{c}, certificates.Kind("CertificateSigningRequest"): &CertificateSigningRequestDescriber{c}, storage.Kind("StorageClass"): &StorageClassDescriber{c}, @@ -136,7 +135,7 @@ func DescribableResources() []string { // Describer returns the default describe functions for each of the standard // Kubernetes types. -func DescriberFor(kind unversioned.GroupKind, c *client.Client) (Describer, bool) { +func DescriberFor(kind unversioned.GroupKind, c clientset.Interface) (Describer, bool) { f, ok := describerMap(c)[kind] return f, ok } @@ -164,19 +163,19 @@ func init() { // NamespaceDescriber generates information about a namespace type NamespaceDescriber struct { - client.Interface + clientset.Interface } func (d *NamespaceDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - ns, err := d.Namespaces().Get(name) + ns, err := d.Core().Namespaces().Get(name) if err != nil { return "", err } - resourceQuotaList, err := d.ResourceQuotas(name).List(api.ListOptions{}) + resourceQuotaList, err := d.Core().ResourceQuotas(name).List(api.ListOptions{}) if err != nil { return "", err } - limitRangeList, err := d.LimitRanges(name).List(api.ListOptions{}) + limitRangeList, err := d.Core().LimitRanges(name).List(api.ListOptions{}) if err != nil { return "", err } @@ -320,11 +319,11 @@ func DescribeResourceQuotas(quotas *api.ResourceQuotaList, w io.Writer) { // LimitRangeDescriber generates information about a limit range type LimitRangeDescriber struct { - client.Interface + clientset.Interface } func (d *LimitRangeDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - lr := d.LimitRanges(namespace) + lr := d.Core().LimitRanges(namespace) limitRange, err := lr.Get(name) if err != nil { @@ -407,11 +406,11 @@ func describeLimitRange(limitRange *api.LimitRange) (string, error) { // ResourceQuotaDescriber generates information about a resource quota type ResourceQuotaDescriber struct { - client.Interface + clientset.Interface } func (d *ResourceQuotaDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - rq := d.ResourceQuotas(namespace) + rq := d.Core().ResourceQuotas(namespace) resourceQuota, err := rq.Get(name) if err != nil { @@ -476,14 +475,14 @@ func describeQuota(resourceQuota *api.ResourceQuota) (string, error) { // PodDescriber generates information about a pod and the replication controllers that // create it. type PodDescriber struct { - client.Interface + clientset.Interface } func (d *PodDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - pod, err := d.Pods(namespace).Get(name) + pod, err := d.Core().Pods(namespace).Get(name) if err != nil { if describerSettings.ShowEvents { - eventsInterface := d.Events(namespace) + eventsInterface := d.Core().Events(namespace) selector := eventsInterface.GetFieldSelector(&name, &namespace, nil, nil) options := api.ListOptions{FieldSelector: selector} events, err2 := eventsInterface.List(options) @@ -504,7 +503,7 @@ func (d *PodDescriber) Describe(namespace, name string, describerSettings Descri glog.Errorf("Unable to construct reference to '%#v': %v", pod, err) } else { ref.Kind = "" - events, _ = d.Events(namespace).Search(ref) + events, _ = d.Core().Events(namespace).Search(ref) } } @@ -759,11 +758,11 @@ func printCinderVolumeSource(cinder *api.CinderVolumeSource, out io.Writer) { } type PersistentVolumeDescriber struct { - client.Interface + clientset.Interface } func (d *PersistentVolumeDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - c := d.PersistentVolumes() + c := d.Core().PersistentVolumes() pv, err := c.Get(name) if err != nil { @@ -774,7 +773,7 @@ func (d *PersistentVolumeDescriber) Describe(namespace, name string, describerSe var events *api.EventList if describerSettings.ShowEvents { - events, _ = d.Events(namespace).Search(pv) + events, _ = d.Core().Events(namespace).Search(pv) } return tabbedString(func(out io.Writer) error { @@ -824,11 +823,11 @@ func (d *PersistentVolumeDescriber) Describe(namespace, name string, describerSe } type PersistentVolumeClaimDescriber struct { - client.Interface + clientset.Interface } func (d *PersistentVolumeClaimDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - c := d.PersistentVolumeClaims(namespace) + c := d.Core().PersistentVolumeClaims(namespace) pvc, err := c.Get(name) if err != nil { @@ -844,7 +843,7 @@ func (d *PersistentVolumeClaimDescriber) Describe(namespace, name string, descri capacity = storage.String() } - events, _ := d.Events(namespace).Search(pvc) + events, _ := d.Core().Events(namespace).Search(pvc) return tabbedString(func(out io.Writer) error { fmt.Fprintf(out, "Name:\t%s\n", pvc.Name) @@ -1096,12 +1095,12 @@ func printBool(value bool) string { // ReplicationControllerDescriber generates information about a replication controller // and the pods it has created. type ReplicationControllerDescriber struct { - client.Interface + clientset.Interface } func (d *ReplicationControllerDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - rc := d.ReplicationControllers(namespace) - pc := d.Pods(namespace) + rc := d.Core().ReplicationControllers(namespace) + pc := d.Core().Pods(namespace) controller, err := rc.Get(name) if err != nil { @@ -1115,7 +1114,7 @@ func (d *ReplicationControllerDescriber) Describe(namespace, name string, descri var events *api.EventList if describerSettings.ShowEvents { - events, _ = d.Events(namespace).Search(controller) + events, _ = d.Core().Events(namespace).Search(controller) } return describeReplicationController(controller, events, running, waiting, succeeded, failed) @@ -1165,12 +1164,12 @@ func DescribePodTemplate(template *api.PodTemplateSpec, out io.Writer) { // ReplicaSetDescriber generates information about a ReplicaSet and the pods it has created. type ReplicaSetDescriber struct { - client.Interface + clientset.Interface } func (d *ReplicaSetDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { rsc := d.Extensions().ReplicaSets(namespace) - pc := d.Pods(namespace) + pc := d.Core().Pods(namespace) rs, err := rsc.Get(name) if err != nil { @@ -1189,7 +1188,7 @@ func (d *ReplicaSetDescriber) Describe(namespace, name string, describerSettings var events *api.EventList if describerSettings.ShowEvents { - events, _ = d.Events(namespace).Search(rs) + events, _ = d.Core().Events(namespace).Search(rs) } return describeReplicaSet(rs, events, running, waiting, succeeded, failed) @@ -1214,7 +1213,7 @@ func describeReplicaSet(rs *extensions.ReplicaSet, events *api.EventList, runnin // JobDescriber generates information about a job and the pods it has created. type JobDescriber struct { - client.Interface + clientset.Interface } func (d *JobDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { @@ -1225,7 +1224,7 @@ func (d *JobDescriber) Describe(namespace, name string, describerSettings Descri var events *api.EventList if describerSettings.ShowEvents { - events, _ = d.Events(namespace).Search(job) + events, _ = d.Core().Events(namespace).Search(job) } return describeJob(job, events) @@ -1348,12 +1347,12 @@ func printActiveJobs(out io.Writer, title string, jobs []api.ObjectReference) { // DaemonSetDescriber generates information about a daemon set and the pods it has created. type DaemonSetDescriber struct { - client.Interface + clientset.Interface } func (d *DaemonSetDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { dc := d.Extensions().DaemonSets(namespace) - pc := d.Pods(namespace) + pc := d.Core().Pods(namespace) daemon, err := dc.Get(name) if err != nil { @@ -1371,7 +1370,7 @@ func (d *DaemonSetDescriber) Describe(namespace, name string, describerSettings var events *api.EventList if describerSettings.ShowEvents { - events, _ = d.Events(namespace).Search(daemon) + events, _ = d.Core().Events(namespace).Search(daemon) } return describeDaemonSet(daemon, events, running, waiting, succeeded, failed) @@ -1402,11 +1401,11 @@ func describeDaemonSet(daemon *extensions.DaemonSet, events *api.EventList, runn // SecretDescriber generates information about a secret type SecretDescriber struct { - client.Interface + clientset.Interface } func (d *SecretDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - c := d.Secrets(namespace) + c := d.Core().Secrets(namespace) secret, err := c.Get(name) if err != nil { @@ -1440,11 +1439,11 @@ func describeSecret(secret *api.Secret) (string, error) { } type IngressDescriber struct { - client.Interface + clientset.Interface } func (i *IngressDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - c := i.Extensions().Ingress(namespace) + c := i.Extensions().Ingresses(namespace) ing, err := c.Get(name) if err != nil { return "", err @@ -1453,8 +1452,8 @@ func (i *IngressDescriber) Describe(namespace, name string, describerSettings De } func (i *IngressDescriber) describeBackend(ns string, backend *extensions.IngressBackend) string { - endpoints, _ := i.Endpoints(ns).Get(backend.ServiceName) - service, _ := i.Services(ns).Get(backend.ServiceName) + endpoints, _ := i.Core().Endpoints(ns).Get(backend.ServiceName) + service, _ := i.Core().Services(ns).Get(backend.ServiceName) spName := "" for i := range service.Spec.Ports { sp := &service.Spec.Ports[i] @@ -1515,7 +1514,7 @@ func (i *IngressDescriber) describeIngress(ing *extensions.Ingress, describerSet describeIngressAnnotations(out, ing.Annotations) if describerSettings.ShowEvents { - events, _ := i.Events(ing.Namespace).Search(ing) + events, _ := i.Core().Events(ing.Namespace).Search(ing) if events != nil { DescribeEvents(events, out) } @@ -1552,21 +1551,21 @@ func describeIngressAnnotations(out io.Writer, annotations map[string]string) { // ServiceDescriber generates information about a service. type ServiceDescriber struct { - client.Interface + clientset.Interface } func (d *ServiceDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - c := d.Services(namespace) + c := d.Core().Services(namespace) service, err := c.Get(name) if err != nil { return "", err } - endpoints, _ := d.Endpoints(namespace).Get(name) + endpoints, _ := d.Core().Endpoints(namespace).Get(name) var events *api.EventList if describerSettings.ShowEvents { - events, _ = d.Events(namespace).Search(service) + events, _ = d.Core().Events(namespace).Search(service) } return describeService(service, endpoints, events) } @@ -1631,11 +1630,11 @@ func describeService(service *api.Service, endpoints *api.Endpoints, events *api // EndpointsDescriber generates information about an Endpoint. type EndpointsDescriber struct { - client.Interface + clientset.Interface } func (d *EndpointsDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - c := d.Endpoints(namespace) + c := d.Core().Endpoints(namespace) ep, err := c.Get(name) if err != nil { @@ -1644,7 +1643,7 @@ func (d *EndpointsDescriber) Describe(namespace, name string, describerSettings var events *api.EventList if describerSettings.ShowEvents { - events, _ = d.Events(namespace).Search(ep) + events, _ = d.Core().Events(namespace).Search(ep) } return describeEndpoints(ep, events) @@ -1704,11 +1703,11 @@ func describeEndpoints(ep *api.Endpoints, events *api.EventList) (string, error) // ServiceAccountDescriber generates information about a service. type ServiceAccountDescriber struct { - client.Interface + clientset.Interface } func (d *ServiceAccountDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - c := d.ServiceAccounts(namespace) + c := d.Core().ServiceAccounts(namespace) serviceAccount, err := c.Get(name) if err != nil { @@ -1719,7 +1718,7 @@ func (d *ServiceAccountDescriber) Describe(namespace, name string, describerSett tokenSelector := fields.SelectorFromSet(map[string]string{api.SecretTypeField: string(api.SecretTypeServiceAccountToken)}) options := api.ListOptions{FieldSelector: tokenSelector} - secrets, err := d.Secrets(namespace).List(options) + secrets, err := d.Core().Secrets(namespace).List(options) if err == nil { for _, s := range secrets.Items { name, _ := s.Annotations[api.ServiceAccountNameKey] @@ -1785,11 +1784,11 @@ func describeServiceAccount(serviceAccount *api.ServiceAccount, tokens []api.Sec // NodeDescriber generates information about a node. type NodeDescriber struct { - client.Interface + clientset.Interface } func (d *NodeDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - mc := d.Nodes() + mc := d.Core().Nodes() node, err := mc.Get(name) if err != nil { return "", err @@ -1802,7 +1801,7 @@ func (d *NodeDescriber) Describe(namespace, name string, describerSettings Descr // in a policy aware setting, users may have access to a node, but not all pods // in that case, we note that the user does not have access to the pods canViewPods := true - nodeNonTerminatedPodsList, err := d.Pods(namespace).List(api.ListOptions{FieldSelector: fieldSelector}) + nodeNonTerminatedPodsList, err := d.Core().Pods(namespace).List(api.ListOptions{FieldSelector: fieldSelector}) if err != nil { if !errors.IsForbidden(err) { return "", err @@ -1817,7 +1816,7 @@ func (d *NodeDescriber) Describe(namespace, name string, describerSettings Descr } else { // TODO: We haven't decided the namespace for Node object yet. ref.UID = types.UID(ref.Name) - events, _ = d.Events("").Search(ref) + events, _ = d.Core().Events("").Search(ref) } } @@ -1904,7 +1903,7 @@ func describeNode(node *api.Node, nodeNonTerminatedPodsList *api.PodList, events } type PetSetDescriber struct { - client *client.Client + client clientset.Interface } func (p *PetSetDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { @@ -1912,7 +1911,7 @@ func (p *PetSetDescriber) Describe(namespace, name string, describerSettings Des if err != nil { return "", err } - pc := p.client.Pods(namespace) + pc := p.client.Core().Pods(namespace) selector, err := unversioned.LabelSelectorAsSelector(ps.Spec.Selector) if err != nil { @@ -1936,7 +1935,7 @@ func (p *PetSetDescriber) Describe(namespace, name string, describerSettings Des fmt.Fprintf(out, "Pods Status:\t%d Running / %d Waiting / %d Succeeded / %d Failed\n", running, waiting, succeeded, failed) describeVolumes(ps.Spec.Template.Spec.Volumes, out, "") if describerSettings.ShowEvents { - events, _ := p.client.Events(namespace).Search(ps) + events, _ := p.client.Core().Events(namespace).Search(ps) if events != nil { DescribeEvents(events, out) } @@ -1946,7 +1945,7 @@ func (p *PetSetDescriber) Describe(namespace, name string, describerSettings Des } type CertificateSigningRequestDescriber struct { - client *client.Client + client clientset.Interface } func (p *CertificateSigningRequestDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { @@ -2004,7 +2003,7 @@ func (p *CertificateSigningRequestDescriber) Describe(namespace, name string, de } if describerSettings.ShowEvents { - events, _ := p.client.Events(namespace).Search(csr) + events, _ := p.client.Core().Events(namespace).Search(csr) if events != nil { DescribeEvents(events, out) } @@ -2015,7 +2014,7 @@ func (p *CertificateSigningRequestDescriber) Describe(namespace, name string, de // HorizontalPodAutoscalerDescriber generates information about a horizontal pod autoscaler. type HorizontalPodAutoscalerDescriber struct { - client *client.Client + client clientset.Interface } func (d *HorizontalPodAutoscalerDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { @@ -2051,7 +2050,7 @@ func (d *HorizontalPodAutoscalerDescriber) Describe(namespace, name string, desc // TODO: switch to scale subresource once the required code is submitted. if strings.ToLower(hpa.Spec.ScaleTargetRef.Kind) == "replicationcontroller" { fmt.Fprintf(out, "ReplicationController pods:\t") - rc, err := d.client.ReplicationControllers(hpa.Namespace).Get(hpa.Spec.ScaleTargetRef.Name) + rc, err := d.client.Core().ReplicationControllers(hpa.Namespace).Get(hpa.Spec.ScaleTargetRef.Name) if err == nil { fmt.Fprintf(out, "%d current / %d desired\n", rc.Status.Replicas, rc.Spec.Replicas) } else { @@ -2060,7 +2059,7 @@ func (d *HorizontalPodAutoscalerDescriber) Describe(namespace, name string, desc } if describerSettings.ShowEvents { - events, _ := d.client.Events(namespace).Search(hpa) + events, _ := d.client.Core().Events(namespace).Search(hpa) if events != nil { DescribeEvents(events, out) } @@ -2301,11 +2300,11 @@ func getPodStatusForController(c client.PodInterface, selector labels.Selector) // ConfigMapDescriber generates information about a ConfigMap type ConfigMapDescriber struct { - client.Interface + clientset.Interface } func (d *ConfigMapDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { - c := d.ConfigMaps(namespace) + c := d.Core().ConfigMaps(namespace) configMap, err := c.Get(name) if err != nil { @@ -2373,7 +2372,7 @@ func describeCluster(cluster *federation.Cluster) (string, error) { // NetworkPolicyDescriber generates information about a NetworkPolicy type NetworkPolicyDescriber struct { - client.Interface + clientset.Interface } func (d *NetworkPolicyDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { @@ -2399,7 +2398,7 @@ func describeNetworkPolicy(networkPolicy *extensions.NetworkPolicy) (string, err } type StorageClassDescriber struct { - client.Interface + clientset.Interface } func (s *StorageClassDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) { @@ -2413,7 +2412,7 @@ func (s *StorageClassDescriber) Describe(namespace, name string, describerSettin fmt.Fprintf(out, "Provisioner:\t%s\n", sc.Provisioner) fmt.Fprintf(out, "Parameters:\t%s\n", labels.FormatLabels(sc.Parameters)) if describerSettings.ShowEvents { - events, err := s.Events(namespace).Search(sc) + events, err := s.Core().Events(namespace).Search(sc) if err != nil { return err } diff --git a/pkg/kubectl/describe_test.go b/pkg/kubectl/describe_test.go index 8fe73be2b84..451be43562f 100644 --- a/pkg/kubectl/describe_test.go +++ b/pkg/kubectl/describe_test.go @@ -32,20 +32,19 @@ import ( "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/apis/storage" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" - client "k8s.io/kubernetes/pkg/client/unversioned" - "k8s.io/kubernetes/pkg/client/unversioned/testclient" ) type describeClient struct { T *testing.T Namespace string Err error - client.Interface + internalclientset.Interface } func TestDescribePod(t *testing.T) { - fake := testclient.NewSimpleFake(&api.Pod{ + fake := fake.NewSimpleClientset(&api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -67,7 +66,7 @@ func TestDescribePodTolerations(t *testing.T) { podTolerations := []api.Toleration{{Key: "key1", Value: "value1"}, {Key: "key2", Value: "value2"}} pt, _ := json.Marshal(podTolerations) - fake := testclient.NewSimpleFake(&api.Pod{ + fake := fake.NewSimpleClientset(&api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -88,7 +87,7 @@ func TestDescribePodTolerations(t *testing.T) { } func TestDescribeService(t *testing.T) { - fake := testclient.NewSimpleFake(&api.Service{ + fake := fake.NewSimpleClientset(&api.Service{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -107,34 +106,40 @@ func TestDescribeService(t *testing.T) { func TestPodDescribeResultsSorted(t *testing.T) { // Arrange - fake := testclient.NewSimpleFake(&api.EventList{ - Items: []api.Event{ - { - Source: api.EventSource{Component: "kubelet"}, - Message: "Item 1", - FirstTimestamp: unversioned.NewTime(time.Date(2014, time.January, 15, 0, 0, 0, 0, time.UTC)), - LastTimestamp: unversioned.NewTime(time.Date(2014, time.January, 15, 0, 0, 0, 0, time.UTC)), - Count: 1, - Type: api.EventTypeNormal, - }, - { - Source: api.EventSource{Component: "scheduler"}, - Message: "Item 2", - FirstTimestamp: unversioned.NewTime(time.Date(1987, time.June, 17, 0, 0, 0, 0, time.UTC)), - LastTimestamp: unversioned.NewTime(time.Date(1987, time.June, 17, 0, 0, 0, 0, time.UTC)), - Count: 1, - Type: api.EventTypeNormal, - }, - { - Source: api.EventSource{Component: "kubelet"}, - Message: "Item 3", - FirstTimestamp: unversioned.NewTime(time.Date(2002, time.December, 25, 0, 0, 0, 0, time.UTC)), - LastTimestamp: unversioned.NewTime(time.Date(2002, time.December, 25, 0, 0, 0, 0, time.UTC)), - Count: 1, - Type: api.EventTypeNormal, + fake := fake.NewSimpleClientset( + &api.EventList{ + Items: []api.Event{ + { + ObjectMeta: api.ObjectMeta{Name: "one"}, + Source: api.EventSource{Component: "kubelet"}, + Message: "Item 1", + FirstTimestamp: unversioned.NewTime(time.Date(2014, time.January, 15, 0, 0, 0, 0, time.UTC)), + LastTimestamp: unversioned.NewTime(time.Date(2014, time.January, 15, 0, 0, 0, 0, time.UTC)), + Count: 1, + Type: api.EventTypeNormal, + }, + { + ObjectMeta: api.ObjectMeta{Name: "two"}, + Source: api.EventSource{Component: "scheduler"}, + Message: "Item 2", + FirstTimestamp: unversioned.NewTime(time.Date(1987, time.June, 17, 0, 0, 0, 0, time.UTC)), + LastTimestamp: unversioned.NewTime(time.Date(1987, time.June, 17, 0, 0, 0, 0, time.UTC)), + Count: 1, + Type: api.EventTypeNormal, + }, + { + ObjectMeta: api.ObjectMeta{Name: "three"}, + Source: api.EventSource{Component: "kubelet"}, + Message: "Item 3", + FirstTimestamp: unversioned.NewTime(time.Date(2002, time.December, 25, 0, 0, 0, 0, time.UTC)), + LastTimestamp: unversioned.NewTime(time.Date(2002, time.December, 25, 0, 0, 0, 0, time.UTC)), + Count: 1, + Type: api.EventTypeNormal, + }, }, }, - }) + &api.Pod{ObjectMeta: api.ObjectMeta{Namespace: "foo", Name: "bar"}}, + ) c := &describeClient{T: t, Namespace: "foo", Interface: fake} d := PodDescriber{c} @@ -483,6 +488,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { tests := map[string]*api.PersistentVolume{ "hostpath": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ HostPath: &api.HostPathVolumeSource{}, @@ -490,6 +496,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { }, }, "gce": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ GCEPersistentDisk: &api.GCEPersistentDiskVolumeSource{}, @@ -497,6 +504,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { }, }, "ebs": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ AWSElasticBlockStore: &api.AWSElasticBlockStoreVolumeSource{}, @@ -504,6 +512,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { }, }, "nfs": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ NFS: &api.NFSVolumeSource{}, @@ -511,6 +520,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { }, }, "iscsi": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ ISCSI: &api.ISCSIVolumeSource{}, @@ -518,6 +528,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { }, }, "gluster": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ Glusterfs: &api.GlusterfsVolumeSource{}, @@ -525,6 +536,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { }, }, "rbd": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ RBD: &api.RBDVolumeSource{}, @@ -532,6 +544,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { }, }, "quobyte": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ Quobyte: &api.QuobyteVolumeSource{}, @@ -539,6 +552,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { }, }, "cinder": { + ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.PersistentVolumeSpec{ PersistentVolumeSource: api.PersistentVolumeSource{ Cinder: &api.CinderVolumeSource{}, @@ -548,7 +562,7 @@ func TestPersistentVolumeDescriber(t *testing.T) { } for name, pv := range tests { - fake := testclient.NewSimpleFake(pv) + fake := fake.NewSimpleClientset(pv) c := PersistentVolumeDescriber{fake} str, err := c.Describe("foo", "bar", DescriberSettings{ShowEvents: true}) if err != nil { @@ -615,7 +629,7 @@ func TestDescribeCluster(t *testing.T) { } func TestDescribeStorageClass(t *testing.T) { - f := testclient.NewSimpleFake(&storage.StorageClass{ + f := fake.NewSimpleClientset(&storage.StorageClass{ ObjectMeta: api.ObjectMeta{ Name: "foo", ResourceVersion: "4", @@ -659,7 +673,7 @@ func TestDescribeEvents(t *testing.T) { m := map[string]Describer{ "DaemonSetDescriber": &DaemonSetDescriber{ - testclient.NewSimpleFake(&extensions.DaemonSet{ + fake.NewSimpleClientset(&extensions.DaemonSet{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -675,7 +689,7 @@ func TestDescribeEvents(t *testing.T) { }, events), }, "EndpointsDescriber": &EndpointsDescriber{ - testclient.NewSimpleFake(&api.Endpoints{ + fake.NewSimpleClientset(&api.Endpoints{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -687,25 +701,23 @@ func TestDescribeEvents(t *testing.T) { // - IngressDescriber // - JobDescriber "NodeDescriber": &NodeDescriber{ - testclient.NewSimpleFake(&api.Node{ + fake.NewSimpleClientset(&api.Node{ ObjectMeta: api.ObjectMeta{ - Name: "bar", - Namespace: "foo", - SelfLink: "url/url/url", + Name: "bar", + SelfLink: "url/url/url", }, }, events), }, "PersistentVolumeDescriber": &PersistentVolumeDescriber{ - testclient.NewSimpleFake(&api.PersistentVolume{ + fake.NewSimpleClientset(&api.PersistentVolume{ ObjectMeta: api.ObjectMeta{ - Name: "bar", - Namespace: "foo", - SelfLink: "url/url/url", + Name: "bar", + SelfLink: "url/url/url", }, }, events), }, "PodDescriber": &PodDescriber{ - testclient.NewSimpleFake(&api.Pod{ + fake.NewSimpleClientset(&api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -714,7 +726,7 @@ func TestDescribeEvents(t *testing.T) { }, events), }, "ReplicaSetDescriber": &ReplicaSetDescriber{ - testclient.NewSimpleFake(&extensions.ReplicaSet{ + fake.NewSimpleClientset(&extensions.ReplicaSet{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -722,7 +734,7 @@ func TestDescribeEvents(t *testing.T) { }, events), }, "ReplicationControllerDescriber": &ReplicationControllerDescriber{ - testclient.NewSimpleFake(&api.ReplicationController{ + fake.NewSimpleClientset(&api.ReplicationController{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -730,7 +742,7 @@ func TestDescribeEvents(t *testing.T) { }, events), }, "Service": &ServiceDescriber{ - testclient.NewSimpleFake(&api.Service{ + fake.NewSimpleClientset(&api.Service{ ObjectMeta: api.ObjectMeta{ Name: "bar", Namespace: "foo", @@ -738,10 +750,9 @@ func TestDescribeEvents(t *testing.T) { }, events), }, "StorageClass": &StorageClassDescriber{ - testclient.NewSimpleFake(&storage.StorageClass{ + fake.NewSimpleClientset(&storage.StorageClass{ ObjectMeta: api.ObjectMeta{ - Name: "bar", - Namespace: "foo", + Name: "bar", }, }, events), }, diff --git a/pkg/kubectl/metricsutil/metrics_client.go b/pkg/kubectl/metricsutil/metrics_client.go index 1dce9e00b62..6f2a59cb7ee 100644 --- a/pkg/kubectl/metricsutil/metrics_client.go +++ b/pkg/kubectl/metricsutil/metrics_client.go @@ -25,7 +25,7 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/validation" - client "k8s.io/kubernetes/pkg/client/unversioned" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" "k8s.io/kubernetes/pkg/labels" ) @@ -46,16 +46,16 @@ var ( ) type HeapsterMetricsClient struct { - *client.Client + SVCClient coreclient.ServicesGetter HeapsterNamespace string HeapsterScheme string HeapsterService string HeapsterPort string } -func NewHeapsterMetricsClient(client *client.Client, namespace, scheme, service, port string) *HeapsterMetricsClient { +func NewHeapsterMetricsClient(svcClient coreclient.ServicesGetter, namespace, scheme, service, port string) *HeapsterMetricsClient { return &HeapsterMetricsClient{ - Client: client, + SVCClient: svcClient, HeapsterNamespace: namespace, HeapsterScheme: scheme, HeapsterService: service, @@ -63,8 +63,8 @@ func NewHeapsterMetricsClient(client *client.Client, namespace, scheme, service, } } -func DefaultHeapsterMetricsClient(client *client.Client) *HeapsterMetricsClient { - return NewHeapsterMetricsClient(client, DefaultHeapsterNamespace, DefaultHeapsterScheme, DefaultHeapsterService, DefaultHeapsterPort) +func DefaultHeapsterMetricsClient(svcClient coreclient.ServicesGetter) *HeapsterMetricsClient { + return NewHeapsterMetricsClient(svcClient, DefaultHeapsterNamespace, DefaultHeapsterScheme, DefaultHeapsterService, DefaultHeapsterPort) } func podMetricsUrl(namespace string, name string) (string, error) { @@ -161,7 +161,7 @@ func (cli *HeapsterMetricsClient) GetPodMetrics(namespace string, podName string } func GetHeapsterMetrics(cli *HeapsterMetricsClient, path string, params map[string]string) ([]byte, error) { - return cli.Services(cli.HeapsterNamespace). + return cli.SVCClient.Services(cli.HeapsterNamespace). ProxyGet(cli.HeapsterScheme, cli.HeapsterService, cli.HeapsterPort, path, params). DoRaw() } diff --git a/pkg/kubectl/rolling_updater.go b/pkg/kubectl/rolling_updater.go index 4468530891d..0ab90461976 100644 --- a/pkg/kubectl/rolling_updater.go +++ b/pkg/kubectl/rolling_updater.go @@ -27,6 +27,7 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/unversioned" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned" deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util" "k8s.io/kubernetes/pkg/labels" @@ -109,8 +110,8 @@ const ( // RollingUpdater provides methods for updating replicated pods in a predictable, // fault-tolerant way. type RollingUpdater struct { - // Client interface for creating and updating controllers - c client.Interface + rcClient coreclient.ReplicationControllersGetter + podClient coreclient.PodsGetter // Namespace for resources ns string // scaleAndWait scales a controller and returns its updated state. @@ -127,10 +128,11 @@ type RollingUpdater struct { } // NewRollingUpdater creates a RollingUpdater from a client. -func NewRollingUpdater(namespace string, client client.Interface) *RollingUpdater { +func NewRollingUpdater(namespace string, rcClient coreclient.ReplicationControllersGetter, podClient coreclient.PodsGetter) *RollingUpdater { updater := &RollingUpdater{ - c: client, - ns: namespace, + rcClient: rcClient, + podClient: podClient, + ns: namespace, } // Inject real implementations. updater.scaleAndWait = updater.scaleAndWaitWithScaler @@ -189,7 +191,7 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error { // annotation if it doesn't yet exist. _, hasOriginalAnnotation := oldRc.Annotations[originalReplicasAnnotation] if !hasOriginalAnnotation { - existing, err := r.c.ReplicationControllers(oldRc.Namespace).Get(oldRc.Name) + existing, err := r.rcClient.ReplicationControllers(oldRc.Namespace).Get(oldRc.Name) if err != nil { return err } @@ -200,7 +202,7 @@ func (r *RollingUpdater) Update(config *RollingUpdaterConfig) error { } rc.Annotations[originalReplicasAnnotation] = originReplicas } - if oldRc, err = updateRcWithRetries(r.c, existing.Namespace, existing, applyUpdate); err != nil { + if oldRc, err = updateRcWithRetries(r.rcClient, existing.Namespace, existing, applyUpdate); err != nil { return err } } @@ -390,14 +392,11 @@ func (r *RollingUpdater) scaleDown(newRc, oldRc *api.ReplicationController, desi // scalerScaleAndWait scales a controller using a Scaler and a real client. func (r *RollingUpdater) scaleAndWaitWithScaler(rc *api.ReplicationController, retry *RetryParams, wait *RetryParams) (*api.ReplicationController, error) { - scaler, err := ScalerFor(api.Kind("ReplicationController"), r.c) - if err != nil { - return nil, fmt.Errorf("Couldn't make scaler: %s", err) - } + scaler := &ReplicationControllerScaler{r.rcClient} if err := scaler.Scale(rc.Namespace, rc.Name, uint(rc.Spec.Replicas), &ScalePrecondition{-1, ""}, retry, wait); err != nil { return nil, err } - return r.c.ReplicationControllers(rc.Namespace).Get(rc.Name) + return r.rcClient.ReplicationControllers(rc.Namespace).Get(rc.Name) } // readyPods returns the old and new ready counts for their pods. @@ -415,7 +414,7 @@ func (r *RollingUpdater) readyPods(oldRc, newRc *api.ReplicationController, minR controller := controllers[i] selector := labels.Set(controller.Spec.Selector).AsSelector() options := api.ListOptions{LabelSelector: selector} - pods, err := r.c.Pods(controller.Namespace).List(options) + pods, err := r.podClient.Pods(controller.Namespace).List(options) if err != nil { return 0, 0, err } @@ -460,7 +459,7 @@ func (r *RollingUpdater) getOrCreateTargetControllerWithClient(controller *api.R controller.Annotations[desiredReplicasAnnotation] = fmt.Sprintf("%d", controller.Spec.Replicas) controller.Annotations[sourceIdAnnotation] = sourceId controller.Spec.Replicas = 0 - newRc, err := r.c.ReplicationControllers(r.ns).Create(controller) + newRc, err := r.rcClient.ReplicationControllers(r.ns).Create(controller) return newRc, false, err } // Validate and use the existing controller. @@ -480,7 +479,7 @@ func (r *RollingUpdater) existingController(controller *api.ReplicationControlle return nil, errors.NewNotFound(api.Resource("replicationcontrollers"), controller.Name) } // controller name is required to get rc back - return r.c.ReplicationControllers(controller.Namespace).Get(controller.Name) + return r.rcClient.ReplicationControllers(controller.Namespace).Get(controller.Name) } // cleanupWithClients performs cleanup tasks after the rolling update. Update @@ -489,7 +488,7 @@ func (r *RollingUpdater) existingController(controller *api.ReplicationControlle func (r *RollingUpdater) cleanupWithClients(oldRc, newRc *api.ReplicationController, config *RollingUpdaterConfig) error { // Clean up annotations var err error - newRc, err = r.c.ReplicationControllers(r.ns).Get(newRc.Name) + newRc, err = r.rcClient.ReplicationControllers(r.ns).Get(newRc.Name) if err != nil { return err } @@ -497,14 +496,14 @@ func (r *RollingUpdater) cleanupWithClients(oldRc, newRc *api.ReplicationControl delete(rc.Annotations, sourceIdAnnotation) delete(rc.Annotations, desiredReplicasAnnotation) } - if newRc, err = updateRcWithRetries(r.c, r.ns, newRc, applyUpdate); err != nil { + if newRc, err = updateRcWithRetries(r.rcClient, r.ns, newRc, applyUpdate); err != nil { return err } - if err = wait.Poll(config.Interval, config.Timeout, client.ControllerHasDesiredReplicas(r.c, newRc)); err != nil { + if err = wait.Poll(config.Interval, config.Timeout, client.ControllerHasDesiredReplicas(r.rcClient, newRc)); err != nil { return err } - newRc, err = r.c.ReplicationControllers(r.ns).Get(newRc.Name) + newRc, err = r.rcClient.ReplicationControllers(r.ns).Get(newRc.Name) if err != nil { return err } @@ -513,15 +512,15 @@ func (r *RollingUpdater) cleanupWithClients(oldRc, newRc *api.ReplicationControl case DeleteRollingUpdateCleanupPolicy: // delete old rc fmt.Fprintf(config.Out, "Update succeeded. Deleting %s\n", oldRc.Name) - return r.c.ReplicationControllers(r.ns).Delete(oldRc.Name, nil) + return r.rcClient.ReplicationControllers(r.ns).Delete(oldRc.Name, nil) case RenameRollingUpdateCleanupPolicy: // delete old rc fmt.Fprintf(config.Out, "Update succeeded. Deleting old controller: %s\n", oldRc.Name) - if err := r.c.ReplicationControllers(r.ns).Delete(oldRc.Name, nil); err != nil { + if err := r.rcClient.ReplicationControllers(r.ns).Delete(oldRc.Name, nil); err != nil { return err } fmt.Fprintf(config.Out, "Renaming %s to %s\n", oldRc.Name, newRc.Name) - return Rename(r.c, newRc, oldRc.Name) + return Rename(r.rcClient, newRc, oldRc.Name) case PreserveRollingUpdateCleanupPolicy: return nil default: @@ -529,7 +528,7 @@ func (r *RollingUpdater) cleanupWithClients(oldRc, newRc *api.ReplicationControl } } -func Rename(c client.ReplicationControllersNamespacer, rc *api.ReplicationController, newName string) error { +func Rename(c coreclient.ReplicationControllersGetter, rc *api.ReplicationController, newName string) error { oldName := rc.Name rc.Name = newName rc.ResourceVersion = "" @@ -560,7 +559,7 @@ func Rename(c client.ReplicationControllersNamespacer, rc *api.ReplicationContro return nil } -func LoadExistingNextReplicationController(c client.ReplicationControllersNamespacer, namespace, newName string) (*api.ReplicationController, error) { +func LoadExistingNextReplicationController(c coreclient.ReplicationControllersGetter, namespace, newName string) (*api.ReplicationController, error) { if len(newName) == 0 { return nil, nil } @@ -580,10 +579,10 @@ type NewControllerConfig struct { PullPolicy api.PullPolicy } -func CreateNewControllerFromCurrentController(c client.Interface, codec runtime.Codec, cfg *NewControllerConfig) (*api.ReplicationController, error) { +func CreateNewControllerFromCurrentController(rcClient coreclient.ReplicationControllersGetter, codec runtime.Codec, cfg *NewControllerConfig) (*api.ReplicationController, error) { containerIndex := 0 // load the old RC into the "new" RC - newRc, err := c.ReplicationControllers(cfg.Namespace).Get(cfg.OldName) + newRc, err := rcClient.ReplicationControllers(cfg.Namespace).Get(cfg.OldName) if err != nil { return nil, err } @@ -669,21 +668,21 @@ func SetNextControllerAnnotation(rc *api.ReplicationController, name string) { rc.Annotations[nextControllerAnnotation] = name } -func UpdateExistingReplicationController(c client.Interface, oldRc *api.ReplicationController, namespace, newName, deploymentKey, deploymentValue string, out io.Writer) (*api.ReplicationController, error) { +func UpdateExistingReplicationController(rcClient coreclient.ReplicationControllersGetter, podClient coreclient.PodsGetter, oldRc *api.ReplicationController, namespace, newName, deploymentKey, deploymentValue string, out io.Writer) (*api.ReplicationController, error) { if _, found := oldRc.Spec.Selector[deploymentKey]; !found { SetNextControllerAnnotation(oldRc, newName) - return AddDeploymentKeyToReplicationController(oldRc, c, deploymentKey, deploymentValue, namespace, out) + return AddDeploymentKeyToReplicationController(oldRc, rcClient, podClient, deploymentKey, deploymentValue, namespace, out) } else { // If we didn't need to update the controller for the deployment key, we still need to write // the "next" controller. applyUpdate := func(rc *api.ReplicationController) { SetNextControllerAnnotation(rc, newName) } - return updateRcWithRetries(c, namespace, oldRc, applyUpdate) + return updateRcWithRetries(rcClient, namespace, oldRc, applyUpdate) } } -func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, client client.Interface, deploymentKey, deploymentValue, namespace string, out io.Writer) (*api.ReplicationController, error) { +func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, rcClient coreclient.ReplicationControllersGetter, podClient coreclient.PodsGetter, deploymentKey, deploymentValue, namespace string, out io.Writer) (*api.ReplicationController, error) { var err error // First, update the template label. This ensures that any newly created pods will have the new label applyUpdate := func(rc *api.ReplicationController) { @@ -692,7 +691,7 @@ func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, c } rc.Spec.Template.Labels[deploymentKey] = deploymentValue } - if oldRc, err = updateRcWithRetries(client, namespace, oldRc, applyUpdate); err != nil { + if oldRc, err = updateRcWithRetries(rcClient, namespace, oldRc, applyUpdate); err != nil { return nil, err } @@ -700,7 +699,7 @@ func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, c // TODO: extract the code from the label command and re-use it here. selector := labels.SelectorFromSet(oldRc.Spec.Selector) options := api.ListOptions{LabelSelector: selector} - podList, err := client.Pods(namespace).List(options) + podList, err := podClient.Pods(namespace).List(options) if err != nil { return nil, err } @@ -715,7 +714,7 @@ func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, c p.Labels[deploymentKey] = deploymentValue } } - if pod, err = updatePodWithRetries(client, namespace, pod, applyUpdate); err != nil { + if pod, err = updatePodWithRetries(podClient, namespace, pod, applyUpdate); err != nil { return nil, err } } @@ -732,7 +731,7 @@ func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, c rc.Spec.Selector[deploymentKey] = deploymentValue } // Update the selector of the rc so it manages all the pods we updated above - if oldRc, err = updateRcWithRetries(client, namespace, oldRc, applyUpdate); err != nil { + if oldRc, err = updateRcWithRetries(rcClient, namespace, oldRc, applyUpdate); err != nil { return nil, err } @@ -741,11 +740,11 @@ func AddDeploymentKeyToReplicationController(oldRc *api.ReplicationController, c // we've finished re-adopting existing pods to the rc. selector = labels.SelectorFromSet(selectorCopy) options = api.ListOptions{LabelSelector: selector} - podList, err = client.Pods(namespace).List(options) + podList, err = podClient.Pods(namespace).List(options) for ix := range podList.Items { pod := &podList.Items[ix] if value, found := pod.Labels[deploymentKey]; !found || value != deploymentValue { - if err := client.Pods(namespace).Delete(pod.Name, nil); err != nil { + if err := podClient.Pods(namespace).Delete(pod.Name, nil); err != nil { return nil, err } } @@ -760,7 +759,7 @@ type updateRcFunc func(controller *api.ReplicationController) // 1. Get latest resource // 2. applyUpdate // 3. Update the resource -func updateRcWithRetries(c client.Interface, namespace string, rc *api.ReplicationController, applyUpdate updateRcFunc) (*api.ReplicationController, error) { +func updateRcWithRetries(rcClient coreclient.ReplicationControllersGetter, namespace string, rc *api.ReplicationController, applyUpdate updateRcFunc) (*api.ReplicationController, error) { // Deep copy the rc in case we failed on Get during retry loop obj, err := api.Scheme.Copy(rc) if err != nil { @@ -770,14 +769,14 @@ func updateRcWithRetries(c client.Interface, namespace string, rc *api.Replicati err = client.RetryOnConflict(client.DefaultBackoff, func() (e error) { // Apply the update, then attempt to push it to the apiserver. applyUpdate(rc) - if rc, e = c.ReplicationControllers(namespace).Update(rc); e == nil { + if rc, e = rcClient.ReplicationControllers(namespace).Update(rc); e == nil { // rc contains the latest controller post update return } updateErr := e // Update the controller with the latest resource version, if the update failed we // can't trust rc so use oldRc.Name. - if rc, e = c.ReplicationControllers(namespace).Get(oldRc.Name); e != nil { + if rc, e = rcClient.ReplicationControllers(namespace).Get(oldRc.Name); e != nil { // The Get failed: Value in rc cannot be trusted. rc = oldRc } @@ -795,7 +794,7 @@ type updatePodFunc func(controller *api.Pod) // 1. Get latest resource // 2. applyUpdate // 3. Update the resource -func updatePodWithRetries(c client.Interface, namespace string, pod *api.Pod, applyUpdate updatePodFunc) (*api.Pod, error) { +func updatePodWithRetries(podClient coreclient.PodsGetter, namespace string, pod *api.Pod, applyUpdate updatePodFunc) (*api.Pod, error) { // Deep copy the pod in case we failed on Get during retry loop obj, err := api.Scheme.Copy(pod) if err != nil { @@ -805,11 +804,11 @@ func updatePodWithRetries(c client.Interface, namespace string, pod *api.Pod, ap err = client.RetryOnConflict(client.DefaultBackoff, func() (e error) { // Apply the update, then attempt to push it to the apiserver. applyUpdate(pod) - if pod, e = c.Pods(namespace).Update(pod); e == nil { + if pod, e = podClient.Pods(namespace).Update(pod); e == nil { return } updateErr := e - if pod, e = c.Pods(namespace).Get(oldPod.Name); e != nil { + if pod, e = podClient.Pods(namespace).Get(oldPod.Name); e != nil { pod = oldPod } // Only return the error from update @@ -820,7 +819,7 @@ func updatePodWithRetries(c client.Interface, namespace string, pod *api.Pod, ap return pod, err } -func FindSourceController(r client.ReplicationControllersNamespacer, namespace, name string) (*api.ReplicationController, error) { +func FindSourceController(r coreclient.ReplicationControllersGetter, namespace, name string) (*api.ReplicationController, error) { list, err := r.ReplicationControllers(namespace).List(api.ListOptions{}) if err != nil { return nil, err diff --git a/pkg/kubectl/rolling_updater_test.go b/pkg/kubectl/rolling_updater_test.go index aa8a8ff2352..836e253c59a 100644 --- a/pkg/kubectl/rolling_updater_test.go +++ b/pkg/kubectl/rolling_updater_test.go @@ -31,10 +31,11 @@ import ( "k8s.io/kubernetes/pkg/api/testapi" apitesting "k8s.io/kubernetes/pkg/api/testing" "k8s.io/kubernetes/pkg/api/unversioned" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" "k8s.io/kubernetes/pkg/client/restclient" - client "k8s.io/kubernetes/pkg/client/unversioned" - "k8s.io/kubernetes/pkg/client/unversioned/fake" - "k8s.io/kubernetes/pkg/client/unversioned/testclient" + testcore "k8s.io/kubernetes/pkg/client/testing/core" + manualfake "k8s.io/kubernetes/pkg/client/unversioned/fake" "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/util/intstr" "k8s.io/kubernetes/pkg/util/sets" @@ -43,8 +44,9 @@ import ( func oldRc(replicas int, original int) *api.ReplicationController { return &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ - Name: "foo-v1", - UID: "7764ae47-9092-11e4-8393-42010af018ff", + Namespace: api.NamespaceDefault, + Name: "foo-v1", + UID: "7764ae47-9092-11e4-8393-42010af018ff", Annotations: map[string]string{ originalReplicasAnnotation: fmt.Sprintf("%d", original), }, @@ -75,7 +77,8 @@ func newRc(replicas int, desired int) *api.ReplicationController { } rc.Spec.Selector = map[string]string{"version": "v2"} rc.ObjectMeta = api.ObjectMeta{ - Name: "foo-v2", + Namespace: api.NamespaceDefault, + Name: "foo-v2", Annotations: map[string]string{ desiredReplicasAnnotation: fmt.Sprintf("%d", desired), sourceIdAnnotation: "foo-v1:7764ae47-9092-11e4-8393-42010af018ff", @@ -891,21 +894,11 @@ func TestUpdate_assignOriginalAnnotation(t *testing.T) { oldRc := oldRc(1, 1) delete(oldRc.Annotations, originalReplicasAnnotation) newRc := newRc(1, 1) - var updatedOldRc *api.ReplicationController - fake := &testclient.Fake{} - fake.AddReactor("*", "*", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { - switch a := action.(type) { - case testclient.GetAction: - return true, oldRc, nil - case testclient.UpdateAction: - updatedOldRc = a.GetObject().(*api.ReplicationController) - return true, updatedOldRc, nil - } - return false, nil, nil - }) + fake := fake.NewSimpleClientset(oldRc) updater := &RollingUpdater{ - c: fake, - ns: "default", + rcClient: fake.Core(), + podClient: fake.Core(), + ns: "default", scaleAndWait: func(rc *api.ReplicationController, retry *RetryParams, wait *RetryParams) (*api.ReplicationController, error) { return rc, nil }, @@ -934,10 +927,11 @@ func TestUpdate_assignOriginalAnnotation(t *testing.T) { if err != nil { t.Fatalf("unexpected error: %v", err) } - if updatedOldRc == nil { - t.Fatalf("expected rc to be updated") + updateAction := fake.Actions()[1].(testcore.UpdateAction) + if updateAction.GetResource().GroupResource() != api.Resource("replicationcontrollers") { + t.Fatalf("expected rc to be updated: %#v", updateAction) } - if e, a := "1", updatedOldRc.Annotations[originalReplicasAnnotation]; e != a { + if e, a := "1", updateAction.GetObject().(*api.ReplicationController).Annotations[originalReplicasAnnotation]; e != a { t.Fatalf("expected annotation value %s, got %s", e, a) } } @@ -954,7 +948,8 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) { { oldRc: &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ - Name: "foo", + Namespace: api.NamespaceDefault, + Name: "foo", }, Spec: api.ReplicationControllerSpec{ Selector: map[string]string{ @@ -983,7 +978,8 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) { }, newRc: &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ - Name: "foo", + Namespace: api.NamespaceDefault, + Name: "foo", }, Spec: api.ReplicationControllerSpec{ Selector: map[string]string{ @@ -1017,7 +1013,8 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) { { oldRc: &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ - Name: "bar", + Namespace: api.NamespaceDefault, + Name: "bar", }, Spec: api.ReplicationControllerSpec{ Selector: map[string]string{ @@ -1042,7 +1039,8 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) { }, newRc: &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ - Name: "bar", + Namespace: api.NamespaceDefault, + Name: "bar", }, Spec: api.ReplicationControllerSpec{ Selector: map[string]string{ @@ -1072,14 +1070,7 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) { } for _, test := range tests { - fake := &testclient.Fake{} - fake.AddReactor("*", "*", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { - switch action.(type) { - case testclient.GetAction: - return true, test.oldRc, nil - } - return false, nil, nil - }) + fake := fake.NewSimpleClientset(test.oldRc) codec := testapi.Default.Codec() @@ -1093,13 +1084,14 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) { test.newRc.Name = fmt.Sprintf("%s-%s", test.newRc.Name, deploymentHash) config := &NewControllerConfig{ + Namespace: api.NamespaceDefault, OldName: test.oldRc.ObjectMeta.Name, NewName: test.newRc.ObjectMeta.Name, Image: test.image, Container: test.container, DeploymentKey: test.deploymentKey, } - updatedRc, err := CreateNewControllerFromCurrentController(fake, codec, config) + updatedRc, err := CreateNewControllerFromCurrentController(fake.Core(), codec, config) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -1168,10 +1160,13 @@ func TestRollingUpdater_cleanupWithClients(t *testing.T) { } for _, test := range tests { - fake := testclient.NewSimpleFake(test.responses...) + objs := []runtime.Object{rc} + objs = append(objs, test.responses...) + fake := fake.NewSimpleClientset(objs...) updater := &RollingUpdater{ - ns: "default", - c: fake, + ns: "default", + rcClient: fake.Core(), + podClient: fake.Core(), } config := &RollingUpdaterConfig{ Out: ioutil.Discard, @@ -1206,20 +1201,20 @@ func TestRollingUpdater_cleanupWithClients_Rename(t *testing.T) { rc := oldRc(2, 2) rcExisting := newRc(1, 3) expectedActions := []string{"delete", "get", "create"} - fake := &testclient.Fake{} - fake.AddReactor("*", "*", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { + fake := fake.NewSimpleClientset() + fake.AddReactor("*", "*", func(action testcore.Action) (handled bool, ret runtime.Object, err error) { switch action.(type) { - case testclient.CreateAction: + case testcore.CreateAction: return true, nil, nil - case testclient.GetAction: + case testcore.GetAction: return true, nil, errors.NewNotFound(unversioned.GroupResource{}, "") - case testclient.DeleteAction: + case testcore.DeleteAction: return true, nil, nil } return false, nil, nil }) - err := Rename(fake, rcExisting, rc.Name) + err := Rename(fake.Core(), rcExisting, rc.Name) if err != nil { t.Fatal(err) } @@ -1233,7 +1228,8 @@ func TestRollingUpdater_cleanupWithClients_Rename(t *testing.T) { func TestFindSourceController(t *testing.T) { ctrl1 := api.ReplicationController{ ObjectMeta: api.ObjectMeta{ - Name: "foo", + Namespace: api.NamespaceDefault, + Name: "foo", Annotations: map[string]string{ sourceIdAnnotation: "bar:1234", }, @@ -1241,7 +1237,8 @@ func TestFindSourceController(t *testing.T) { } ctrl2 := api.ReplicationController{ ObjectMeta: api.ObjectMeta{ - Name: "bar", + Namespace: api.NamespaceDefault, + Name: "bar", Annotations: map[string]string{ sourceIdAnnotation: "foo:12345", }, @@ -1249,6 +1246,8 @@ func TestFindSourceController(t *testing.T) { } ctrl3 := api.ReplicationController{ ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "baz", Annotations: map[string]string{ sourceIdAnnotation: "baz:45667", }, @@ -1302,8 +1301,8 @@ func TestFindSourceController(t *testing.T) { }, } for _, test := range tests { - fakeClient := testclient.NewSimpleFake(test.list) - ctrl, err := FindSourceController(fakeClient, "default", test.name) + fakeClient := fake.NewSimpleClientset(test.list) + ctrl, err := FindSourceController(fakeClient.Core(), "default", test.name) if test.expectError && err == nil { t.Errorf("unexpected non-error") } @@ -1328,6 +1327,10 @@ func TestUpdateExistingReplicationController(t *testing.T) { }{ { rc: &api.ReplicationController{ + ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "foo", + }, Spec: api.ReplicationControllerSpec{ Template: &api.PodTemplateSpec{}, }, @@ -1338,6 +1341,8 @@ func TestUpdateExistingReplicationController(t *testing.T) { expectedRc: &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "foo", Annotations: map[string]string{ "kubectl.kubernetes.io/next-controller-id": "foo", }, @@ -1358,6 +1363,10 @@ func TestUpdateExistingReplicationController(t *testing.T) { }, { rc: &api.ReplicationController{ + ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "foo", + }, Spec: api.ReplicationControllerSpec{ Template: &api.PodTemplateSpec{ ObjectMeta: api.ObjectMeta{ @@ -1377,6 +1386,8 @@ func TestUpdateExistingReplicationController(t *testing.T) { expectedRc: &api.ReplicationController{ ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "foo", Annotations: map[string]string{ "kubectl.kubernetes.io/next-controller-id": "foo", }, @@ -1398,8 +1409,8 @@ func TestUpdateExistingReplicationController(t *testing.T) { } for _, test := range tests { buffer := &bytes.Buffer{} - fakeClient := testclient.NewSimpleFake(test.expectedRc) - rc, err := UpdateExistingReplicationController(fakeClient, test.rc, "default", test.name, test.deploymentKey, test.deploymentValue, buffer) + fakeClient := fake.NewSimpleClientset(test.expectedRc) + rc, err := UpdateExistingReplicationController(fakeClient.Core(), fakeClient.Core(), test.rc, "default", test.name, test.deploymentKey, test.deploymentValue, buffer) if !reflect.DeepEqual(rc, test.expectedRc) { t.Errorf("expected:\n%#v\ngot:\n%#v\n", test.expectedRc, rc) } @@ -1453,9 +1464,9 @@ func TestUpdateRcWithRetries(t *testing.T) { {StatusCode: 500, Header: header, Body: objBody(codec, &api.ReplicationController{})}, {StatusCode: 200, Header: header, Body: objBody(codec, rc)}, } - fakeClient := &fake.RESTClient{ + fakeClient := &manualfake.RESTClient{ NegotiatedSerializer: testapi.Default.NegotiatedSerializer(), - Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { + Client: manualfake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == testapi.Default.ResourcePath("replicationcontrollers", "default", "rc") && m == "PUT": update := updates[0] @@ -1480,12 +1491,13 @@ func TestUpdateRcWithRetries(t *testing.T) { } }), } - clientConfig := &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}} - client := client.NewOrDie(clientConfig) - client.Client = fakeClient.Client + clientConfig := &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: api.Codecs, GroupVersion: testapi.Default.GroupVersion()}} + restClient, _ := restclient.RESTClientFor(clientConfig) + restClient.Client = fakeClient.Client + clientset := internalclientset.New(restClient) if rc, err := updateRcWithRetries( - client, "default", rc, func(c *api.ReplicationController) { + clientset, "default", rc, func(c *api.ReplicationController) { c.Spec.Selector["baz"] = "foobar" }); err != nil { t.Errorf("unexpected error: %v", err) @@ -1544,9 +1556,9 @@ func TestAddDeploymentHash(t *testing.T) { seen := sets.String{} updatedRc := false - fakeClient := &fake.RESTClient{ + fakeClient := &manualfake.RESTClient{ NegotiatedSerializer: testapi.Default.NegotiatedSerializer(), - Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { + Client: manualfake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { header := http.Header{} header.Set("Content-Type", runtime.ContentTypeJSON) switch p, m := req.URL.Path, req.Method; { @@ -1579,11 +1591,12 @@ func TestAddDeploymentHash(t *testing.T) { } }), } - clientConfig := &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}} - client := client.NewOrDie(clientConfig) - client.Client = fakeClient.Client + clientConfig := &restclient.Config{APIPath: "/api", ContentConfig: restclient.ContentConfig{NegotiatedSerializer: api.Codecs, GroupVersion: testapi.Default.GroupVersion()}} + restClient, _ := restclient.RESTClientFor(clientConfig) + restClient.Client = fakeClient.Client + clientset := internalclientset.New(restClient) - if _, err := AddDeploymentKeyToReplicationController(rc, client, "dk", "hash", api.NamespaceDefault, buf); err != nil { + if _, err := AddDeploymentKeyToReplicationController(rc, clientset.Core(), clientset.Core(), "dk", "hash", api.NamespaceDefault, buf); err != nil { t.Errorf("unexpected error: %v", err) } for _, pod := range podList.Items { @@ -1597,8 +1610,10 @@ func TestAddDeploymentHash(t *testing.T) { } func TestRollingUpdater_readyPods(t *testing.T) { + count := 0 now := unversioned.Date(2016, time.April, 1, 1, 0, 0, 0, time.UTC) mkpod := func(owner *api.ReplicationController, ready bool, readyTime unversioned.Time) *api.Pod { + count = count + 1 labels := map[string]string{} for k, v := range owner.Spec.Selector { labels[k] = v @@ -1609,8 +1624,9 @@ func TestRollingUpdater_readyPods(t *testing.T) { } return &api.Pod{ ObjectMeta: api.ObjectMeta{ - Name: "pod", - Labels: labels, + Namespace: api.NamespaceDefault, + Name: fmt.Sprintf("pod-%d", count), + Labels: labels, }, Status: api.PodStatus{ Conditions: []api.PodCondition{ @@ -1728,12 +1744,13 @@ func TestRollingUpdater_readyPods(t *testing.T) { for _, ready := range test.newPods { pods = append(pods, mkpod(test.newRc, ready, test.podReadyTimeFn())) } - client := testclient.NewSimpleFake(pods...) + client := fake.NewSimpleClientset(pods...) updater := &RollingUpdater{ - ns: "default", - c: client, - nowFn: test.nowFn, + ns: "default", + rcClient: client.Core(), + podClient: client.Core(), + nowFn: test.nowFn, } oldReady, newReady, err := updater.readyPods(test.oldRc, test.newRc, test.minReadySeconds) if err != nil { diff --git a/pkg/kubectl/rollout_status.go b/pkg/kubectl/rollout_status.go index ce7fabc364f..b65e5ada68d 100644 --- a/pkg/kubectl/rollout_status.go +++ b/pkg/kubectl/rollout_status.go @@ -21,7 +21,8 @@ import ( "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/apis/extensions" - client "k8s.io/kubernetes/pkg/client/unversioned" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" + extensionsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned" ) // StatusViewer provides an interface for resources that provides rollout status. @@ -29,7 +30,7 @@ type StatusViewer interface { Status(namespace, name string) (string, bool, error) } -func StatusViewerFor(kind unversioned.GroupKind, c client.Interface) (StatusViewer, error) { +func StatusViewerFor(kind unversioned.GroupKind, c internalclientset.Interface) (StatusViewer, error) { switch kind { case extensions.Kind("Deployment"): return &DeploymentStatusViewer{c.Extensions()}, nil @@ -38,7 +39,7 @@ func StatusViewerFor(kind unversioned.GroupKind, c client.Interface) (StatusView } type DeploymentStatusViewer struct { - c client.ExtensionsInterface + c extensionsclient.DeploymentsGetter } // Status returns a message describing deployment status, and a bool value indicating if the status is considered done diff --git a/pkg/kubectl/rollout_status_test.go b/pkg/kubectl/rollout_status_test.go index 52beecf7d11..46daa42f0a4 100644 --- a/pkg/kubectl/rollout_status_test.go +++ b/pkg/kubectl/rollout_status_test.go @@ -21,7 +21,7 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/apis/extensions" - "k8s.io/kubernetes/pkg/client/unversioned/testclient" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" ) func TestDeploymentStatusViewerStatus(t *testing.T) { @@ -107,6 +107,7 @@ func TestDeploymentStatusViewerStatus(t *testing.T) { for _, test := range tests { d := &extensions.Deployment{ ObjectMeta: api.ObjectMeta{ + Namespace: "bar", Name: "foo", UID: "8764ae47-9092-11e4-8393-42010af018ff", Generation: test.generation, @@ -116,7 +117,7 @@ func TestDeploymentStatusViewerStatus(t *testing.T) { }, Status: test.status, } - client := testclient.NewSimpleFake(d).Extensions() + client := fake.NewSimpleClientset(d).Extensions() dsv := &DeploymentStatusViewer{c: client} msg, done, err := dsv.Status("bar", "foo") if err != nil { diff --git a/pkg/kubectl/scale.go b/pkg/kubectl/scale.go index 044be5706f0..291276b32fc 100644 --- a/pkg/kubectl/scale.go +++ b/pkg/kubectl/scale.go @@ -27,6 +27,11 @@ import ( "k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/batch" "k8s.io/kubernetes/pkg/apis/extensions" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" + appsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned" + batchclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" + extensionsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned" "k8s.io/kubernetes/pkg/fields" "k8s.io/kubernetes/pkg/util/wait" @@ -44,10 +49,10 @@ type Scaler interface { ScaleSimple(namespace, name string, preconditions *ScalePrecondition, newSize uint) (updatedResourceVersion string, err error) } -func ScalerFor(kind unversioned.GroupKind, c client.Interface) (Scaler, error) { +func ScalerFor(kind unversioned.GroupKind, c internalclientset.Interface) (Scaler, error) { switch kind { case api.Kind("ReplicationController"): - return &ReplicationControllerScaler{c}, nil + return &ReplicationControllerScaler{c.Core()}, nil case extensions.Kind("ReplicaSet"): return &ReplicaSetScaler{c.Extensions()}, nil case extensions.Kind("Job"), batch.Kind("Job"): @@ -155,7 +160,7 @@ func (precondition *ScalePrecondition) ValidateReplicationController(controller } type ReplicationControllerScaler struct { - c client.Interface + c coreclient.ReplicationControllersGetter } // ScaleSimple does a simple one-shot attempt at scaling. It returns the @@ -253,7 +258,7 @@ func (precondition *ScalePrecondition) ValidateReplicaSet(replicaSet *extensions } type ReplicaSetScaler struct { - c client.ExtensionsInterface + c extensionsclient.ReplicaSetsGetter } // ScaleSimple does a simple one-shot attempt at scaling. It returns the @@ -324,7 +329,7 @@ func (precondition *ScalePrecondition) ValidateJob(job *batch.Job) error { } type PetSetScaler struct { - c client.AppsInterface + c appsclient.PetSetsGetter } // ScaleSimple does a simple one-shot attempt at scaling. It returns the @@ -377,7 +382,7 @@ func (scaler *PetSetScaler) Scale(namespace, name string, newSize uint, precondi } type JobScaler struct { - c client.BatchInterface + c batchclient.JobsGetter } // ScaleSimple is responsible for updating job's parallelism. It returns the @@ -445,7 +450,7 @@ func (precondition *ScalePrecondition) ValidateDeployment(deployment *extensions } type DeploymentScaler struct { - c client.ExtensionsInterface + c extensionsclient.DeploymentsGetter } // ScaleSimple is responsible for updating a deployment's desired replicas diff --git a/pkg/kubectl/scale_test.go b/pkg/kubectl/scale_test.go index 9306a1828e8..e7295e294d1 100644 --- a/pkg/kubectl/scale_test.go +++ b/pkg/kubectl/scale_test.go @@ -24,12 +24,15 @@ import ( kerrors "k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/apis/batch" "k8s.io/kubernetes/pkg/apis/extensions" - client "k8s.io/kubernetes/pkg/client/unversioned" - "k8s.io/kubernetes/pkg/client/unversioned/testclient" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" + batchclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" + extensionsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned" + testcore "k8s.io/kubernetes/pkg/client/testing/core" ) type ErrorReplicationControllers struct { - testclient.FakeReplicationControllers + coreclient.ReplicationControllerInterface conflict bool invalid bool } @@ -45,26 +48,26 @@ func (c *ErrorReplicationControllers) Update(controller *api.ReplicationControll } type ErrorReplicationControllerClient struct { - testclient.Fake + *fake.Clientset conflict bool invalid bool } -func (c *ErrorReplicationControllerClient) ReplicationControllers(namespace string) client.ReplicationControllerInterface { +func (c *ErrorReplicationControllerClient) ReplicationControllers(namespace string) coreclient.ReplicationControllerInterface { return &ErrorReplicationControllers{ - FakeReplicationControllers: testclient.FakeReplicationControllers{Fake: &c.Fake, Namespace: namespace}, - conflict: c.conflict, - invalid: c.invalid, + ReplicationControllerInterface: c.Clientset.Core().ReplicationControllers(namespace), + conflict: c.conflict, + invalid: c.invalid, } } func TestReplicationControllerScaleRetry(t *testing.T) { - fake := &ErrorReplicationControllerClient{Fake: testclient.Fake{}, conflict: true} + fake := &ErrorReplicationControllerClient{Clientset: fake.NewSimpleClientset(oldRc(0, 0)), conflict: true} scaler := ReplicationControllerScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) - name := "foo" - namespace := "default" + name := "foo-v1" + namespace := api.NamespaceDefault scaleFunc := ScaleCondition(&scaler, &preconditions, namespace, name, count, nil) pass, err := scaleFunc() @@ -83,11 +86,11 @@ func TestReplicationControllerScaleRetry(t *testing.T) { } func TestReplicationControllerScaleInvalid(t *testing.T) { - fake := &ErrorReplicationControllerClient{Fake: testclient.Fake{}, invalid: true} + fake := &ErrorReplicationControllerClient{Clientset: fake.NewSimpleClientset(oldRc(0, 0)), invalid: true} scaler := ReplicationControllerScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) - name := "foo" + name := "foo-v1" namespace := "default" scaleFunc := ScaleCondition(&scaler, &preconditions, namespace, name, count, nil) @@ -102,32 +105,33 @@ func TestReplicationControllerScaleInvalid(t *testing.T) { } func TestReplicationControllerScale(t *testing.T) { - fake := &testclient.Fake{} - scaler := ReplicationControllerScaler{fake} + fake := fake.NewSimpleClientset(oldRc(0, 0)) + scaler := ReplicationControllerScaler{fake.Core()} preconditions := ScalePrecondition{-1, ""} count := uint(3) - name := "foo" + name := "foo-v1" scaler.Scale("default", name, count, &preconditions, nil, nil) actions := fake.Actions() if len(actions) != 2 { t.Errorf("unexpected actions: %v, expected 2 actions (get, update)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "replicationcontrollers" || action.GetName() != name { + if action, ok := actions[0].(testcore.GetAction); !ok || action.GetResource().GroupResource() != api.Resource("replicationcontrollers") || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-replicationController %s", actions[0], name) } - if action, ok := actions[1].(testclient.UpdateAction); !ok || action.GetResource() != "replicationcontrollers" || action.GetObject().(*api.ReplicationController).Spec.Replicas != int32(count) { + if action, ok := actions[1].(testcore.UpdateAction); !ok || action.GetResource().GroupResource() != api.Resource("replicationcontrollers") || action.GetObject().(*api.ReplicationController).Spec.Replicas != int32(count) { t.Errorf("unexpected action %v, expected update-replicationController with replicas = %d", actions[1], count) } } func TestReplicationControllerScaleFailsPreconditions(t *testing.T) { - fake := testclient.NewSimpleFake(&api.ReplicationController{ + fake := fake.NewSimpleClientset(&api.ReplicationController{ + ObjectMeta: api.ObjectMeta{Namespace: api.NamespaceDefault, Name: "foo"}, Spec: api.ReplicationControllerSpec{ Replicas: 10, }, }) - scaler := ReplicationControllerScaler{fake} + scaler := ReplicationControllerScaler{fake.Core()} preconditions := ScalePrecondition{2, ""} count := uint(3) name := "foo" @@ -137,7 +141,7 @@ func TestReplicationControllerScaleFailsPreconditions(t *testing.T) { if len(actions) != 1 { t.Errorf("unexpected actions: %v, expected 1 action (get)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "replicationcontrollers" || action.GetName() != name { + if action, ok := actions[0].(testcore.GetAction); !ok || action.GetResource().GroupResource() != api.Resource("replicationcontrollers") || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-replicationController %s", actions[0], name) } } @@ -258,7 +262,7 @@ func TestValidateReplicationController(t *testing.T) { } type ErrorJobs struct { - testclient.FakeJobsV1 + batchclient.JobInterface conflict bool invalid bool } @@ -283,21 +287,21 @@ func (c *ErrorJobs) Get(name string) (*batch.Job, error) { } type ErrorJobClient struct { - testclient.FakeBatch + batchclient.JobsGetter conflict bool invalid bool } -func (c *ErrorJobClient) Jobs(namespace string) client.JobInterface { +func (c *ErrorJobClient) Jobs(namespace string) batchclient.JobInterface { return &ErrorJobs{ - FakeJobsV1: testclient.FakeJobsV1{Fake: &c.FakeBatch, Namespace: namespace}, - conflict: c.conflict, - invalid: c.invalid, + JobInterface: c.JobsGetter.Jobs(namespace), + conflict: c.conflict, + invalid: c.invalid, } } func TestJobScaleRetry(t *testing.T) { - fake := &ErrorJobClient{FakeBatch: testclient.FakeBatch{}, conflict: true} + fake := &ErrorJobClient{JobsGetter: fake.NewSimpleClientset().Batch(), conflict: true} scaler := JobScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) @@ -320,28 +324,37 @@ func TestJobScaleRetry(t *testing.T) { } } +func job() *batch.Job { + return &batch.Job{ + ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "foo", + }, + } +} + func TestJobScale(t *testing.T) { - fake := &testclient.FakeBatch{Fake: &testclient.Fake{}} - scaler := JobScaler{fake} + fakeClientset := fake.NewSimpleClientset(job()) + scaler := JobScaler{fakeClientset.Batch()} preconditions := ScalePrecondition{-1, ""} count := uint(3) name := "foo" scaler.Scale("default", name, count, &preconditions, nil, nil) - actions := fake.Actions() + actions := fakeClientset.Actions() if len(actions) != 2 { t.Errorf("unexpected actions: %v, expected 2 actions (get, update)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "jobs" || action.GetName() != name { + if action, ok := actions[0].(testcore.GetAction); !ok || action.GetResource().GroupResource() != batch.Resource("jobs") || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-replicationController %s", actions[0], name) } - if action, ok := actions[1].(testclient.UpdateAction); !ok || action.GetResource() != "jobs" || *action.GetObject().(*batch.Job).Spec.Parallelism != int32(count) { + if action, ok := actions[1].(testcore.UpdateAction); !ok || action.GetResource().GroupResource() != batch.Resource("jobs") || *action.GetObject().(*batch.Job).Spec.Parallelism != int32(count) { t.Errorf("unexpected action %v, expected update-job with parallelism = %d", actions[1], count) } } func TestJobScaleInvalid(t *testing.T) { - fake := &ErrorJobClient{FakeBatch: testclient.FakeBatch{}, invalid: true} + fake := &ErrorJobClient{JobsGetter: fake.NewSimpleClientset().Batch(), invalid: true} scaler := JobScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) @@ -361,12 +374,16 @@ func TestJobScaleInvalid(t *testing.T) { func TestJobScaleFailsPreconditions(t *testing.T) { ten := int32(10) - fake := testclient.NewSimpleFake(&batch.Job{ + fake := fake.NewSimpleClientset(&batch.Job{ + ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "foo", + }, Spec: batch.JobSpec{ Parallelism: &ten, }, }) - scaler := JobScaler{&testclient.FakeBatch{Fake: fake}} + scaler := JobScaler{fake.Batch()} preconditions := ScalePrecondition{2, ""} count := uint(3) name := "foo" @@ -376,7 +393,7 @@ func TestJobScaleFailsPreconditions(t *testing.T) { if len(actions) != 1 { t.Errorf("unexpected actions: %v, expected 1 actions (get)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "jobs" || action.GetName() != name { + if action, ok := actions[0].(testcore.GetAction); !ok || action.GetResource().GroupResource() != batch.Resource("jobs") || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-job %s", actions[0], name) } } @@ -508,7 +525,7 @@ func TestValidateJob(t *testing.T) { } type ErrorDeployments struct { - testclient.FakeDeployments + extensionsclient.DeploymentInterface conflict bool invalid bool } @@ -532,21 +549,21 @@ func (c *ErrorDeployments) Get(name string) (*extensions.Deployment, error) { } type ErrorDeploymentClient struct { - testclient.FakeExperimental + extensionsclient.DeploymentsGetter conflict bool invalid bool } -func (c *ErrorDeploymentClient) Deployments(namespace string) client.DeploymentInterface { +func (c *ErrorDeploymentClient) Deployments(namespace string) extensionsclient.DeploymentInterface { return &ErrorDeployments{ - FakeDeployments: testclient.FakeDeployments{Fake: &c.FakeExperimental, Namespace: namespace}, - invalid: c.invalid, - conflict: c.conflict, + DeploymentInterface: c.DeploymentsGetter.Deployments(namespace), + invalid: c.invalid, + conflict: c.conflict, } } func TestDeploymentScaleRetry(t *testing.T) { - fake := &ErrorDeploymentClient{FakeExperimental: testclient.FakeExperimental{}, conflict: true} + fake := &ErrorDeploymentClient{DeploymentsGetter: fake.NewSimpleClientset().Extensions(), conflict: true} scaler := &DeploymentScaler{fake} preconditions := &ScalePrecondition{-1, ""} count := uint(3) @@ -569,9 +586,18 @@ func TestDeploymentScaleRetry(t *testing.T) { } } +func deployment() *extensions.Deployment { + return &extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "foo", + }, + } +} + func TestDeploymentScale(t *testing.T) { - fake := &testclient.FakeExperimental{Fake: &testclient.Fake{}} - scaler := DeploymentScaler{fake} + fake := fake.NewSimpleClientset(deployment()) + scaler := DeploymentScaler{fake.Extensions()} preconditions := ScalePrecondition{-1, ""} count := uint(3) name := "foo" @@ -581,16 +607,16 @@ func TestDeploymentScale(t *testing.T) { if len(actions) != 2 { t.Errorf("unexpected actions: %v, expected 2 actions (get, update)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "deployments" || action.GetName() != name { + if action, ok := actions[0].(testcore.GetAction); !ok || action.GetResource().GroupResource() != extensions.Resource("deployments") || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-replicationController %s", actions[0], name) } - if action, ok := actions[1].(testclient.UpdateAction); !ok || action.GetResource() != "deployments" || action.GetObject().(*extensions.Deployment).Spec.Replicas != int32(count) { + if action, ok := actions[1].(testcore.UpdateAction); !ok || action.GetResource().GroupResource() != extensions.Resource("deployments") || action.GetObject().(*extensions.Deployment).Spec.Replicas != int32(count) { t.Errorf("unexpected action %v, expected update-deployment with replicas = %d", actions[1], count) } } func TestDeploymentScaleInvalid(t *testing.T) { - fake := &ErrorDeploymentClient{FakeExperimental: testclient.FakeExperimental{}, invalid: true} + fake := &ErrorDeploymentClient{DeploymentsGetter: fake.NewSimpleClientset().Extensions(), invalid: true} scaler := DeploymentScaler{fake} preconditions := ScalePrecondition{-1, ""} count := uint(3) @@ -609,12 +635,16 @@ func TestDeploymentScaleInvalid(t *testing.T) { } func TestDeploymentScaleFailsPreconditions(t *testing.T) { - fake := testclient.NewSimpleFake(&extensions.Deployment{ + fake := fake.NewSimpleClientset(&extensions.Deployment{ + ObjectMeta: api.ObjectMeta{ + Namespace: api.NamespaceDefault, + Name: "foo", + }, Spec: extensions.DeploymentSpec{ Replicas: 10, }, }) - scaler := DeploymentScaler{&testclient.FakeExperimental{Fake: fake}} + scaler := DeploymentScaler{fake.Extensions()} preconditions := ScalePrecondition{2, ""} count := uint(3) name := "foo" @@ -624,7 +654,7 @@ func TestDeploymentScaleFailsPreconditions(t *testing.T) { if len(actions) != 1 { t.Errorf("unexpected actions: %v, expected 1 actions (get)", actions) } - if action, ok := actions[0].(testclient.GetAction); !ok || action.GetResource() != "deployments" || action.GetName() != name { + if action, ok := actions[0].(testcore.GetAction); !ok || action.GetResource().GroupResource() != extensions.Resource("deployments") || action.GetName() != name { t.Errorf("unexpected action: %v, expected get-deployment %s", actions[0], name) } } diff --git a/pkg/kubectl/stop.go b/pkg/kubectl/stop.go index 99538f58a5f..4dad40e8055 100644 --- a/pkg/kubectl/stop.go +++ b/pkg/kubectl/stop.go @@ -28,6 +28,11 @@ import ( "k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/batch" "k8s.io/kubernetes/pkg/apis/extensions" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" + appsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/apps/unversioned" + batchclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/batch/unversioned" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" + extensionsclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/extensions/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned" deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util" "k8s.io/kubernetes/pkg/labels" @@ -63,68 +68,71 @@ func IsNoSuchReaperError(err error) bool { return ok } -func ReaperFor(kind unversioned.GroupKind, c client.Interface) (Reaper, error) { +func ReaperFor(kind unversioned.GroupKind, c internalclientset.Interface) (Reaper, error) { switch kind { case api.Kind("ReplicationController"): - return &ReplicationControllerReaper{c, Interval, Timeout}, nil + return &ReplicationControllerReaper{c.Core(), Interval, Timeout}, nil case extensions.Kind("ReplicaSet"): - return &ReplicaSetReaper{c, Interval, Timeout}, nil + return &ReplicaSetReaper{c.Extensions(), Interval, Timeout}, nil case extensions.Kind("DaemonSet"): - return &DaemonSetReaper{c, Interval, Timeout}, nil + return &DaemonSetReaper{c.Extensions(), Interval, Timeout}, nil case api.Kind("Pod"): - return &PodReaper{c}, nil + return &PodReaper{c.Core()}, nil case api.Kind("Service"): - return &ServiceReaper{c}, nil + return &ServiceReaper{c.Core()}, nil case extensions.Kind("Job"), batch.Kind("Job"): - return &JobReaper{c, Interval, Timeout}, nil + return &JobReaper{c.Batch(), c.Core(), Interval, Timeout}, nil case apps.Kind("PetSet"): - return &PetSetReaper{c, Interval, Timeout}, nil + return &PetSetReaper{c.Apps(), c.Core(), Interval, Timeout}, nil case extensions.Kind("Deployment"): - return &DeploymentReaper{c, Interval, Timeout}, nil + return &DeploymentReaper{c.Extensions(), c.Extensions(), Interval, Timeout}, nil } return nil, &NoSuchReaperError{kind} } -func ReaperForReplicationController(c client.Interface, timeout time.Duration) (Reaper, error) { - return &ReplicationControllerReaper{c, Interval, timeout}, nil +func ReaperForReplicationController(rcClient coreclient.ReplicationControllersGetter, timeout time.Duration) (Reaper, error) { + return &ReplicationControllerReaper{rcClient, Interval, timeout}, nil } type ReplicationControllerReaper struct { - client.Interface + client coreclient.ReplicationControllersGetter pollInterval, timeout time.Duration } type ReplicaSetReaper struct { - client.Interface + client extensionsclient.ReplicaSetsGetter pollInterval, timeout time.Duration } type DaemonSetReaper struct { - client.Interface + client extensionsclient.DaemonSetsGetter pollInterval, timeout time.Duration } type JobReaper struct { - client.Interface + client batchclient.JobsGetter + podClient coreclient.PodsGetter pollInterval, timeout time.Duration } type DeploymentReaper struct { - client.Interface + dClient extensionsclient.DeploymentsGetter + rsClient extensionsclient.ReplicaSetsGetter pollInterval, timeout time.Duration } type PodReaper struct { - client.Interface + client coreclient.PodsGetter } type ServiceReaper struct { - client.Interface + client coreclient.ServicesGetter } type PetSetReaper struct { - client.Interface + client appsclient.PetSetsGetter + podClient coreclient.PodsGetter pollInterval, timeout time.Duration } @@ -134,8 +142,8 @@ type objInterface interface { } // getOverlappingControllers finds rcs that this controller overlaps, as well as rcs overlapping this controller. -func getOverlappingControllers(c client.ReplicationControllerInterface, rc *api.ReplicationController) ([]api.ReplicationController, error) { - rcs, err := c.List(api.ListOptions{}) +func getOverlappingControllers(rcClient coreclient.ReplicationControllerInterface, rc *api.ReplicationController) ([]api.ReplicationController, error) { + rcs, err := rcClient.List(api.ListOptions{}) if err != nil { return nil, fmt.Errorf("error getting replication controllers: %v", err) } @@ -151,11 +159,8 @@ func getOverlappingControllers(c client.ReplicationControllerInterface, rc *api. } func (reaper *ReplicationControllerReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error { - rc := reaper.ReplicationControllers(namespace) - scaler, err := ScalerFor(api.Kind("ReplicationController"), *reaper) - if err != nil { - return err - } + rc := reaper.client.ReplicationControllers(namespace) + scaler := &ReplicationControllerScaler{reaper.client} ctrl, err := rc.Get(name) if err != nil { return err @@ -223,11 +228,8 @@ func getOverlappingReplicaSets(c client.ReplicaSetInterface, rs *extensions.Repl } func (reaper *ReplicaSetReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error { - rsc := reaper.Extensions().ReplicaSets(namespace) - scaler, err := ScalerFor(extensions.Kind("ReplicaSet"), *reaper) - if err != nil { - return err - } + rsc := reaper.client.ReplicaSets(namespace) + scaler := &ReplicaSetScaler{reaper.client} rs, err := rsc.Get(name) if err != nil { return err @@ -290,7 +292,7 @@ func (reaper *ReplicaSetReaper) Stop(namespace, name string, timeout time.Durati } func (reaper *DaemonSetReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error { - ds, err := reaper.Extensions().DaemonSets(namespace).Get(name) + ds, err := reaper.client.DaemonSets(namespace).Get(name) if err != nil { return err } @@ -305,13 +307,13 @@ func (reaper *DaemonSetReaper) Stop(namespace, name string, timeout time.Duratio // force update to avoid version conflict ds.ResourceVersion = "" - if ds, err = reaper.Extensions().DaemonSets(namespace).Update(ds); err != nil { + if ds, err = reaper.client.DaemonSets(namespace).Update(ds); err != nil { return err } // Wait for the daemon set controller to kill all the daemon pods. if err := wait.Poll(reaper.pollInterval, reaper.timeout, func() (bool, error) { - updatedDS, err := reaper.Extensions().DaemonSets(namespace).Get(name) + updatedDS, err := reaper.client.DaemonSets(namespace).Get(name) if err != nil { return false, nil } @@ -321,15 +323,12 @@ func (reaper *DaemonSetReaper) Stop(namespace, name string, timeout time.Duratio return err } - return reaper.Extensions().DaemonSets(namespace).Delete(name) + return reaper.client.DaemonSets(namespace).Delete(name, nil) } func (reaper *PetSetReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error { - petsets := reaper.Apps().PetSets(namespace) - scaler, err := ScalerFor(apps.Kind("PetSet"), *reaper) - if err != nil { - return err - } + petsets := reaper.client.PetSets(namespace) + scaler := &PetSetScaler{reaper.client} ps, err := petsets.Get(name) if err != nil { return err @@ -346,7 +345,7 @@ func (reaper *PetSetReaper) Stop(namespace, name string, timeout time.Duration, // TODO: This shouldn't be needed, see corresponding TODO in PetSetHasDesiredPets. // PetSet should track generation number. - pods := reaper.Pods(namespace) + pods := reaper.podClient.Pods(namespace) selector, _ := unversioned.LabelSelectorAsSelector(ps.Spec.Selector) options := api.ListOptions{LabelSelector: selector} podList, err := pods.List(options) @@ -372,12 +371,9 @@ func (reaper *PetSetReaper) Stop(namespace, name string, timeout time.Duration, } func (reaper *JobReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error { - jobs := reaper.Batch().Jobs(namespace) - pods := reaper.Pods(namespace) - scaler, err := ScalerFor(batch.Kind("Job"), *reaper) - if err != nil { - return err - } + jobs := reaper.client.Jobs(namespace) + pods := reaper.podClient.Pods(namespace) + scaler := &JobScaler{reaper.client} job, err := jobs.Get(name) if err != nil { return err @@ -418,9 +414,9 @@ func (reaper *JobReaper) Stop(namespace, name string, timeout time.Duration, gra } func (reaper *DeploymentReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error { - deployments := reaper.Extensions().Deployments(namespace) - replicaSets := reaper.Extensions().ReplicaSets(namespace) - rsReaper, _ := ReaperFor(extensions.Kind("ReplicaSet"), reaper) + deployments := reaper.dClient.Deployments(namespace) + replicaSets := reaper.rsClient.ReplicaSets(namespace) + rsReaper := &ReplicaSetReaper{reaper.rsClient, reaper.pollInterval, reaper.timeout} deployment, err := reaper.updateDeploymentWithRetries(namespace, name, func(d *extensions.Deployment) { // set deployment's history and scale to 0 @@ -473,7 +469,7 @@ func (reaper *DeploymentReaper) Stop(namespace, name string, timeout time.Durati type updateDeploymentFunc func(d *extensions.Deployment) func (reaper *DeploymentReaper) updateDeploymentWithRetries(namespace, name string, applyUpdate updateDeploymentFunc) (deployment *extensions.Deployment, err error) { - deployments := reaper.Extensions().Deployments(namespace) + deployments := reaper.dClient.Deployments(namespace) err = wait.Poll(10*time.Millisecond, 1*time.Minute, func() (bool, error) { if deployment, err = deployments.Get(name); err != nil { return false, err @@ -493,7 +489,7 @@ func (reaper *DeploymentReaper) updateDeploymentWithRetries(namespace, name stri } func (reaper *PodReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error { - pods := reaper.Pods(namespace) + pods := reaper.client.Pods(namespace) _, err := pods.Get(name) if err != nil { return err @@ -502,10 +498,10 @@ func (reaper *PodReaper) Stop(namespace, name string, timeout time.Duration, gra } func (reaper *ServiceReaper) Stop(namespace, name string, timeout time.Duration, gracePeriod *api.DeleteOptions) error { - services := reaper.Services(namespace) + services := reaper.client.Services(namespace) _, err := services.Get(name) if err != nil { return err } - return services.Delete(name) + return services.Delete(name, nil) } diff --git a/pkg/kubectl/stop_test.go b/pkg/kubectl/stop_test.go index 9c388099e9c..430158b8727 100644 --- a/pkg/kubectl/stop_test.go +++ b/pkg/kubectl/stop_test.go @@ -28,8 +28,9 @@ import ( "k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/apis/batch" "k8s.io/kubernetes/pkg/apis/extensions" - client "k8s.io/kubernetes/pkg/client/unversioned" - "k8s.io/kubernetes/pkg/client/unversioned/testclient" + "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" + coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned" + testcore "k8s.io/kubernetes/pkg/client/testing/core" deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util" "k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/watch" @@ -47,15 +48,6 @@ func TestReplicationControllerStop(t *testing.T) { { Name: "OnlyOneRC", Objs: []runtime.Object{ - &api.ReplicationController{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: api.ReplicationControllerSpec{ - Replicas: 0, - Selector: map[string]string{"k1": "v1"}}, - }, &api.ReplicationControllerList{ // LIST Items: []api.ReplicationController{ { @@ -76,15 +68,6 @@ func TestReplicationControllerStop(t *testing.T) { { Name: "NoOverlapping", Objs: []runtime.Object{ - &api.ReplicationController{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: api.ReplicationControllerSpec{ - Replicas: 0, - Selector: map[string]string{"k1": "v1"}}, - }, &api.ReplicationControllerList{ // LIST Items: []api.ReplicationController{ { @@ -115,15 +98,6 @@ func TestReplicationControllerStop(t *testing.T) { Name: "OverlappingError", Objs: []runtime.Object{ - &api.ReplicationController{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: api.ReplicationControllerSpec{ - Replicas: 0, - Selector: map[string]string{"k1": "v1"}}, - }, &api.ReplicationControllerList{ // LIST Items: []api.ReplicationController{ { @@ -155,15 +129,6 @@ func TestReplicationControllerStop(t *testing.T) { Name: "OverlappingButSafeDelete", Objs: []runtime.Object{ - &api.ReplicationController{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: api.ReplicationControllerSpec{ - Replicas: 0, - Selector: map[string]string{"k1": "v1", "k2": "v2"}}, - }, &api.ReplicationControllerList{ // LIST Items: []api.ReplicationController{ { @@ -205,15 +170,6 @@ func TestReplicationControllerStop(t *testing.T) { Name: "TwoExactMatchRCs", Objs: []runtime.Object{ - &api.ReplicationController{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: api.ReplicationControllerSpec{ - Replicas: 0, - Selector: map[string]string{"k1": "v1"}}, - }, &api.ReplicationControllerList{ // LIST Items: []api.ReplicationController{ { @@ -248,15 +204,15 @@ func TestReplicationControllerStop(t *testing.T) { if err != nil { t.Fatalf("%s unexpected error: %v", test.Name, err) } - fake := testclient.NewSimpleFake(test.Objs...) + fake := fake.NewSimpleClientset(test.Objs...) fakeWatch := watch.NewFake() - fake.PrependWatchReactor("replicationcontrollers", testclient.DefaultWatchReactor(fakeWatch, nil)) + fake.PrependWatchReactor("replicationcontrollers", testcore.DefaultWatchReactor(fakeWatch, nil)) go func() { fakeWatch.Add(copiedForWatch) }() - reaper := ReplicationControllerReaper{fake, time.Millisecond, time.Millisecond} + reaper := ReplicationControllerReaper{fake.Core(), time.Millisecond, time.Millisecond} err = reaper.Stop(ns, name, 0, nil) if !reflect.DeepEqual(err, test.StopError) { t.Errorf("%s unexpected error: %v", test.Name, err) @@ -269,7 +225,7 @@ func TestReplicationControllerStop(t *testing.T) { continue } for i, verb := range test.ExpectedActions { - if actions[i].GetResource() != "replicationcontrollers" { + if actions[i].GetResource().GroupResource() != api.Resource("replicationcontrollers") { t.Errorf("%s unexpected action: %+v, expected %s-replicationController", test.Name, actions[i], verb) } if actions[i].GetVerb() != verb { @@ -291,16 +247,6 @@ func TestReplicaSetStop(t *testing.T) { { Name: "OnlyOneRS", Objs: []runtime.Object{ - &extensions.ReplicaSet{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: extensions.ReplicaSetSpec{ - Replicas: 0, - Selector: &unversioned.LabelSelector{MatchLabels: map[string]string{"k1": "v1"}}, - }, - }, &extensions.ReplicaSetList{ // LIST Items: []extensions.ReplicaSet{ { @@ -322,16 +268,6 @@ func TestReplicaSetStop(t *testing.T) { { Name: "NoOverlapping", Objs: []runtime.Object{ - &extensions.ReplicaSet{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: extensions.ReplicaSetSpec{ - Replicas: 0, - Selector: &unversioned.LabelSelector{MatchLabels: map[string]string{"k1": "v1"}}, - }, - }, &extensions.ReplicaSetList{ // LIST Items: []extensions.ReplicaSet{ { @@ -365,8 +301,8 @@ func TestReplicaSetStop(t *testing.T) { } for _, test := range tests { - fake := testclient.NewSimpleFake(test.Objs...) - reaper := ReplicaSetReaper{fake, time.Millisecond, time.Millisecond} + fake := fake.NewSimpleClientset(test.Objs...) + reaper := ReplicaSetReaper{fake.Extensions(), time.Millisecond, time.Millisecond} err := reaper.Stop(ns, name, 0, nil) if !reflect.DeepEqual(err, test.StopError) { t.Errorf("%s unexpected error: %v", test.Name, err) @@ -379,7 +315,7 @@ func TestReplicaSetStop(t *testing.T) { continue } for i, verb := range test.ExpectedActions { - if actions[i].GetResource() != "replicasets" { + if actions[i].GetResource().GroupResource() != extensions.Resource("replicasets") { t.Errorf("%s unexpected action: %+v, expected %s-replicaSet", test.Name, actions[i], verb) } if actions[i].GetVerb() != verb { @@ -402,18 +338,6 @@ func TestJobStop(t *testing.T) { { Name: "OnlyOneJob", Objs: []runtime.Object{ - &batch.Job{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: batch.JobSpec{ - Parallelism: &zero, - Selector: &unversioned.LabelSelector{ - MatchLabels: map[string]string{"k1": "v1"}, - }, - }, - }, &batch.JobList{ // LIST Items: []batch.Job{ { @@ -438,18 +362,6 @@ func TestJobStop(t *testing.T) { { Name: "JobWithDeadPods", Objs: []runtime.Object{ - &batch.Job{ // GET - ObjectMeta: api.ObjectMeta{ - Name: name, - Namespace: ns, - }, - Spec: batch.JobSpec{ - Parallelism: &zero, - Selector: &unversioned.LabelSelector{ - MatchLabels: map[string]string{"k1": "v1"}, - }, - }, - }, &batch.JobList{ // LIST Items: []batch.Job{ { @@ -485,8 +397,8 @@ func TestJobStop(t *testing.T) { } for _, test := range tests { - fake := testclient.NewSimpleFake(test.Objs...) - reaper := JobReaper{fake, time.Millisecond, time.Millisecond} + fake := fake.NewSimpleClientset(test.Objs...) + reaper := JobReaper{fake.Batch(), fake.Core(), time.Millisecond, time.Millisecond} err := reaper.Stop(ns, name, 0, nil) if !reflect.DeepEqual(err, test.StopError) { t.Errorf("%s unexpected error: %v", test.Name, err) @@ -503,7 +415,7 @@ func TestJobStop(t *testing.T) { if actions[i].GetVerb() != action[0] { t.Errorf("%s unexpected verb: %+v, expected %s", test.Name, actions[i], expAction) } - if actions[i].GetResource() != action[1] { + if actions[i].GetResource().Resource != action[1] { t.Errorf("%s unexpected resource: %+v, expected %s", test.Name, actions[i], expAction) } } @@ -564,6 +476,7 @@ func TestDeploymentStop(t *testing.T) { ObjectMeta: api.ObjectMeta{ Name: name, Namespace: ns, + Labels: map[string]string{"k1": "v1"}, }, Spec: extensions.ReplicaSetSpec{ Template: template, @@ -581,8 +494,8 @@ func TestDeploymentStop(t *testing.T) { } for _, test := range tests { - fake := testclient.NewSimpleFake(test.Objs...) - reaper := DeploymentReaper{fake, time.Millisecond, time.Millisecond} + fake := fake.NewSimpleClientset(test.Objs...) + reaper := DeploymentReaper{fake.Extensions(), fake.Extensions(), time.Millisecond, time.Millisecond} err := reaper.Stop(ns, name, 0, nil) if !reflect.DeepEqual(err, test.StopError) { t.Errorf("%s unexpected error: %v", test.Name, err) @@ -599,7 +512,7 @@ func TestDeploymentStop(t *testing.T) { if actions[i].GetVerb() != action[0] { t.Errorf("%s unexpected verb: %+v, expected %s", test.Name, actions[i], expAction) } - if actions[i].GetResource() != action[1] { + if actions[i].GetResource().Resource != action[1] { t.Errorf("%s unexpected resource: %+v, expected %s", test.Name, actions[i], expAction) } if len(action) == 3 && actions[i].GetSubresource() != action[2] { @@ -610,7 +523,7 @@ func TestDeploymentStop(t *testing.T) { } type noSuchPod struct { - *testclient.FakePods + coreclient.PodInterface } func (c *noSuchPod) Get(name string) (*api.Pod, error) { @@ -618,84 +531,101 @@ func (c *noSuchPod) Get(name string) (*api.Pod, error) { } type noDeleteService struct { - *testclient.FakeServices + coreclient.ServiceInterface } -func (c *noDeleteService) Delete(service string) error { +func (c *noDeleteService) Delete(service string, o *api.DeleteOptions) error { return fmt.Errorf("I'm afraid I can't do that, Dave") } type reaperFake struct { - *testclient.Fake + *fake.Clientset noSuchPod, noDeleteService bool } -func (c *reaperFake) Pods(namespace string) client.PodInterface { - pods := &testclient.FakePods{Fake: c.Fake, Namespace: namespace} +func (c *reaperFake) Core() coreclient.CoreInterface { + return &reaperCoreFake{c.Clientset.Core(), c.noSuchPod, c.noDeleteService} +} + +type reaperCoreFake struct { + coreclient.CoreInterface + noSuchPod, noDeleteService bool +} + +func (c *reaperCoreFake) Pods(namespace string) coreclient.PodInterface { + pods := c.CoreInterface.Pods(namespace) if c.noSuchPod { return &noSuchPod{pods} } return pods } -func (c *reaperFake) Services(namespace string) client.ServiceInterface { - services := &testclient.FakeServices{Fake: c.Fake, Namespace: namespace} +func (c *reaperCoreFake) Services(namespace string) coreclient.ServiceInterface { + services := c.CoreInterface.Services(namespace) if c.noDeleteService { return &noDeleteService{services} } return services } +func pod() *api.Pod { + return &api.Pod{ObjectMeta: api.ObjectMeta{Namespace: api.NamespaceDefault, Name: "foo"}} +} + +func service() *api.Service { + return &api.Service{ObjectMeta: api.ObjectMeta{Namespace: api.NamespaceDefault, Name: "foo"}} +} + func TestSimpleStop(t *testing.T) { tests := []struct { fake *reaperFake kind unversioned.GroupKind - actions []testclient.Action + actions []testcore.Action expectError bool test string }{ { fake: &reaperFake{ - Fake: &testclient.Fake{}, + Clientset: fake.NewSimpleClientset(pod()), }, kind: api.Kind("Pod"), - actions: []testclient.Action{ - testclient.NewGetAction("pods", api.NamespaceDefault, "foo"), - testclient.NewDeleteAction("pods", api.NamespaceDefault, "foo"), + actions: []testcore.Action{ + testcore.NewGetAction(api.Resource("pods").WithVersion(""), api.NamespaceDefault, "foo"), + testcore.NewDeleteAction(api.Resource("pods").WithVersion(""), api.NamespaceDefault, "foo"), }, expectError: false, test: "stop pod succeeds", }, { fake: &reaperFake{ - Fake: &testclient.Fake{}, + Clientset: fake.NewSimpleClientset(service()), }, kind: api.Kind("Service"), - actions: []testclient.Action{ - testclient.NewGetAction("services", api.NamespaceDefault, "foo"), - testclient.NewDeleteAction("services", api.NamespaceDefault, "foo"), + actions: []testcore.Action{ + testcore.NewGetAction(api.Resource("services").WithVersion(""), api.NamespaceDefault, "foo"), + testcore.NewDeleteAction(api.Resource("services").WithVersion(""), api.NamespaceDefault, "foo"), }, expectError: false, test: "stop service succeeds", }, { fake: &reaperFake{ - Fake: &testclient.Fake{}, + Clientset: fake.NewSimpleClientset(), noSuchPod: true, }, kind: api.Kind("Pod"), - actions: []testclient.Action{}, + actions: []testcore.Action{}, expectError: true, test: "stop pod fails, no pod", }, { fake: &reaperFake{ - Fake: &testclient.Fake{}, + Clientset: fake.NewSimpleClientset(service()), noDeleteService: true, }, kind: api.Kind("Service"), - actions: []testclient.Action{ - testclient.NewGetAction("services", api.NamespaceDefault, "foo"), + actions: []testcore.Action{ + testcore.NewGetAction(api.Resource("services").WithVersion(""), api.NamespaceDefault, "foo"), }, expectError: true, test: "stop service fails, can't delete", @@ -747,12 +677,9 @@ func TestDeploymentNotFoundError(t *testing.T) { } template := deploymentutil.GetNewReplicaSetTemplate(deployment) - fake := &testclient.Fake{} - fake.AddReactor("get", "deployments", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { - return true, deployment, nil - }) - fake.AddReactor("list", "replicasets", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { - list := &extensions.ReplicaSetList{Items: []extensions.ReplicaSet{ + fake := fake.NewSimpleClientset( + deployment, + &extensions.ReplicaSetList{Items: []extensions.ReplicaSet{ { ObjectMeta: api.ObjectMeta{ Name: name, @@ -762,14 +689,14 @@ func TestDeploymentNotFoundError(t *testing.T) { Template: template, }, }, - }} - return true, list, nil - }) - fake.AddReactor("get", "replicasets", func(action testclient.Action) (handled bool, ret runtime.Object, err error) { + }, + }, + ) + fake.AddReactor("get", "replicasets", func(action testcore.Action) (handled bool, ret runtime.Object, err error) { return true, nil, ScaleError{ActualError: errors.NewNotFound(api.Resource("replicaset"), "doesn't-matter")} }) - reaper := DeploymentReaper{fake, time.Millisecond, time.Millisecond} + reaper := DeploymentReaper{fake.Extensions(), fake.Extensions(), time.Millisecond, time.Millisecond} if err := reaper.Stop(ns, name, 0, nil); err != nil { t.Fatalf("unexpected error: %#v", err) } diff --git a/pkg/kubectl/version.go b/pkg/kubectl/version.go index 8e32c2dcc54..d015df727fc 100644 --- a/pkg/kubectl/version.go +++ b/pkg/kubectl/version.go @@ -19,22 +19,10 @@ package kubectl import ( "fmt" "io" - "os" - client "k8s.io/kubernetes/pkg/client/unversioned" "k8s.io/kubernetes/pkg/version" ) -func GetServerVersion(w io.Writer, kubeClient client.Interface) { - serverVersion, err := kubeClient.Discovery().ServerVersion() - if err != nil { - fmt.Printf("Couldn't read server version from server: %v\n", err) - os.Exit(1) - } - - fmt.Fprintf(w, "Server Version: %#v\n", *serverVersion) -} - func GetClientVersion(w io.Writer) { fmt.Fprintf(w, "Client Version: %#v\n", version.Get()) } diff --git a/test/e2e/batch_v1_jobs.go b/test/e2e/batch_v1_jobs.go index 4f795bce3f3..5e8bf34ce8f 100644 --- a/test/e2e/batch_v1_jobs.go +++ b/test/e2e/batch_v1_jobs.go @@ -27,6 +27,7 @@ import ( "k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/apis/batch" client "k8s.io/kubernetes/pkg/client/unversioned" + clientsetadapter "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" "k8s.io/kubernetes/pkg/kubectl" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/util/wait" @@ -128,7 +129,7 @@ var _ = framework.KubeDescribe("V1Job", func() { Expect(err).NotTo(HaveOccurred()) By("scale job up") - scaler, err := kubectl.ScalerFor(batch.Kind("Job"), f.Client) + scaler, err := kubectl.ScalerFor(batch.Kind("Job"), clientsetadapter.FromUnversionedClient(f.Client)) Expect(err).NotTo(HaveOccurred()) waitForScale := kubectl.NewRetryParams(5*time.Second, 1*time.Minute) waitForReplicas := kubectl.NewRetryParams(5*time.Second, 5*time.Minute) @@ -153,7 +154,7 @@ var _ = framework.KubeDescribe("V1Job", func() { Expect(err).NotTo(HaveOccurred()) By("scale job down") - scaler, err := kubectl.ScalerFor(batch.Kind("Job"), f.Client) + scaler, err := kubectl.ScalerFor(batch.Kind("Job"), clientsetadapter.FromUnversionedClient(f.Client)) Expect(err).NotTo(HaveOccurred()) waitForScale := kubectl.NewRetryParams(5*time.Second, 1*time.Minute) waitForReplicas := kubectl.NewRetryParams(5*time.Second, 5*time.Minute) @@ -176,7 +177,7 @@ var _ = framework.KubeDescribe("V1Job", func() { Expect(err).NotTo(HaveOccurred()) By("delete a job") - reaper, err := kubectl.ReaperFor(batch.Kind("Job"), f.Client) + reaper, err := kubectl.ReaperFor(batch.Kind("Job"), clientsetadapter.FromUnversionedClient(f.Client)) Expect(err).NotTo(HaveOccurred()) timeout := 1 * time.Minute err = reaper.Stop(f.Namespace.Name, job.Name, timeout, api.NewDeleteOptions(0)) diff --git a/test/e2e/daemon_set.go b/test/e2e/daemon_set.go index de4a4545ba2..e2d5d928a08 100644 --- a/test/e2e/daemon_set.go +++ b/test/e2e/daemon_set.go @@ -28,6 +28,7 @@ import ( "k8s.io/kubernetes/pkg/apimachinery/registered" "k8s.io/kubernetes/pkg/apis/extensions" client "k8s.io/kubernetes/pkg/client/unversioned" + clientsetadapter "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" "k8s.io/kubernetes/pkg/kubectl" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/runtime" @@ -115,7 +116,7 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() { Expect(err).NotTo(HaveOccurred()) defer func() { framework.Logf("Check that reaper kills all daemon pods for %s", dsName) - dsReaper, err := kubectl.ReaperFor(extensions.Kind("DaemonSet"), c) + dsReaper, err := kubectl.ReaperFor(extensions.Kind("DaemonSet"), clientsetadapter.FromUnversionedClient(c)) Expect(err).NotTo(HaveOccurred()) err = dsReaper.Stop(ns, dsName, 0, nil) Expect(err).NotTo(HaveOccurred()) diff --git a/test/e2e/deployment.go b/test/e2e/deployment.go index 6948ac514e4..28f5a6b8afb 100644 --- a/test/e2e/deployment.go +++ b/test/e2e/deployment.go @@ -195,7 +195,7 @@ func stopDeploymentMaybeOverlap(c *clientset.Clientset, oldC client.Interface, n Expect(err).NotTo(HaveOccurred()) framework.Logf("Deleting deployment %s", deploymentName) - reaper, err := kubectl.ReaperFor(extensions.Kind("Deployment"), oldC) + reaper, err := kubectl.ReaperFor(extensions.Kind("Deployment"), c) Expect(err).NotTo(HaveOccurred()) timeout := 1 * time.Minute err = reaper.Stop(ns, deployment.Name, timeout, api.NewDeleteOptions(0)) @@ -1114,10 +1114,10 @@ func testScaledRolloutDeployment(f *framework.Framework) { first, err = c.Extensions().ReplicaSets(first.Namespace).Get(first.Name) Expect(err).NotTo(HaveOccurred()) - firstCond := client.ReplicaSetHasDesiredReplicas(f.Client.Extensions(), first) + firstCond := client.ReplicaSetHasDesiredReplicas(c.Extensions(), first) wait.PollImmediate(10*time.Millisecond, 1*time.Minute, firstCond) - secondCond := client.ReplicaSetHasDesiredReplicas(f.Client.Extensions(), second) + secondCond := client.ReplicaSetHasDesiredReplicas(c.Extensions(), second) wait.PollImmediate(10*time.Millisecond, 1*time.Minute, secondCond) By(fmt.Sprintf("Updating the size (up) and template at the same time for deployment %q", deploymentName)) @@ -1175,10 +1175,10 @@ func testScaledRolloutDeployment(f *framework.Framework) { newRs, err := deploymentutil.GetNewReplicaSet(deployment, c) Expect(err).NotTo(HaveOccurred()) - oldCond := client.ReplicaSetHasDesiredReplicas(f.Client.Extensions(), oldRs) + oldCond := client.ReplicaSetHasDesiredReplicas(c.Extensions(), oldRs) wait.PollImmediate(10*time.Millisecond, 1*time.Minute, oldCond) - newCond := client.ReplicaSetHasDesiredReplicas(f.Client.Extensions(), newRs) + newCond := client.ReplicaSetHasDesiredReplicas(c.Extensions(), newRs) wait.PollImmediate(10*time.Millisecond, 1*time.Minute, newCond) By(fmt.Sprintf("Updating the size (down) and template at the same time for deployment %q", deploymentName)) diff --git a/test/e2e/framework/util.go b/test/e2e/framework/util.go index 4ac5f40fd59..7b9fbc3f82e 100644 --- a/test/e2e/framework/util.go +++ b/test/e2e/framework/util.go @@ -56,6 +56,7 @@ import ( "k8s.io/kubernetes/pkg/client/typed/discovery" "k8s.io/kubernetes/pkg/client/typed/dynamic" client "k8s.io/kubernetes/pkg/client/unversioned" + clientsetadapter "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" "k8s.io/kubernetes/pkg/client/unversioned/clientcmd" clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api" gcecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/gce" @@ -3197,7 +3198,7 @@ func RemoveTaintOffNode(c *client.Client, nodeName string, taint api.Taint) { func ScaleRC(c *client.Client, ns, name string, size uint, wait bool) error { By(fmt.Sprintf("Scaling replication controller %s in namespace %s to %d", name, ns, size)) - scaler, err := kubectl.ScalerFor(api.Kind("ReplicationController"), c) + scaler, err := kubectl.ScalerFor(api.Kind("ReplicationController"), clientsetadapter.FromUnversionedClient(c)) if err != nil { return err } @@ -3314,7 +3315,7 @@ func DeleteRCAndPods(c *client.Client, ns, name string) error { } return err } - reaper, err := kubectl.ReaperForReplicationController(c, 10*time.Minute) + reaper, err := kubectl.ReaperForReplicationController(clientsetadapter.FromUnversionedClient(c).Core(), 10*time.Minute) if err != nil { if apierrs.IsNotFound(err) { Logf("RC %s was already deleted: %v", name, err) @@ -3462,7 +3463,7 @@ func DeleteReplicaSet(c *client.Client, ns, name string) error { } return err } - reaper, err := kubectl.ReaperFor(extensions.Kind("ReplicaSet"), c) + reaper, err := kubectl.ReaperFor(extensions.Kind("ReplicaSet"), clientsetadapter.FromUnversionedClient(c)) if err != nil { if apierrs.IsNotFound(err) { Logf("ReplicaSet %s was already deleted: %v", name, err) diff --git a/test/e2e/job.go b/test/e2e/job.go index 65224d846e7..59d239f2541 100644 --- a/test/e2e/job.go +++ b/test/e2e/job.go @@ -23,6 +23,7 @@ import ( "k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/apis/batch" client "k8s.io/kubernetes/pkg/client/unversioned" + clientsetadapter "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" "k8s.io/kubernetes/pkg/kubectl" "k8s.io/kubernetes/pkg/labels" "k8s.io/kubernetes/pkg/util/wait" @@ -124,7 +125,7 @@ var _ = framework.KubeDescribe("Job", func() { Expect(err).NotTo(HaveOccurred()) By("scale job up") - scaler, err := kubectl.ScalerFor(batch.Kind("Job"), f.Client) + scaler, err := kubectl.ScalerFor(batch.Kind("Job"), clientsetadapter.FromUnversionedClient(f.Client)) Expect(err).NotTo(HaveOccurred()) waitForScale := kubectl.NewRetryParams(5*time.Second, 1*time.Minute) waitForReplicas := kubectl.NewRetryParams(5*time.Second, 5*time.Minute) @@ -149,7 +150,7 @@ var _ = framework.KubeDescribe("Job", func() { Expect(err).NotTo(HaveOccurred()) By("scale job down") - scaler, err := kubectl.ScalerFor(batch.Kind("Job"), f.Client) + scaler, err := kubectl.ScalerFor(batch.Kind("Job"), clientsetadapter.FromUnversionedClient(f.Client)) Expect(err).NotTo(HaveOccurred()) waitForScale := kubectl.NewRetryParams(5*time.Second, 1*time.Minute) waitForReplicas := kubectl.NewRetryParams(5*time.Second, 5*time.Minute) @@ -172,7 +173,7 @@ var _ = framework.KubeDescribe("Job", func() { Expect(err).NotTo(HaveOccurred()) By("delete a job") - reaper, err := kubectl.ReaperFor(batch.Kind("Job"), f.Client) + reaper, err := kubectl.ReaperFor(batch.Kind("Job"), clientsetadapter.FromUnversionedClient(f.Client)) Expect(err).NotTo(HaveOccurred()) timeout := 1 * time.Minute err = reaper.Stop(f.Namespace.Name, job.Name, timeout, api.NewDeleteOptions(0)) diff --git a/test/e2e/kubectl.go b/test/e2e/kubectl.go index 8a807b6fdd4..66e653582e3 100644 --- a/test/e2e/kubectl.go +++ b/test/e2e/kubectl.go @@ -47,6 +47,7 @@ import ( "k8s.io/kubernetes/pkg/api/resource" "k8s.io/kubernetes/pkg/api/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned" + clientsetadapter "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" "k8s.io/kubernetes/pkg/controller" "k8s.io/kubernetes/pkg/kubectl/cmd/util" "k8s.io/kubernetes/pkg/labels" @@ -420,7 +421,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() { ExecOrDie() Expect(runOutput).ToNot(ContainSubstring("stdin closed")) f := func(pods []*api.Pod) sort.Interface { return sort.Reverse(controller.ActivePods(pods)) } - runTestPod, _, err := util.GetFirstPod(c, ns, labels.SelectorFromSet(map[string]string{"run": "run-test-3"}), 1*time.Minute, f) + runTestPod, _, err := util.GetFirstPod(clientsetadapter.FromUnversionedClient(c), ns, labels.SelectorFromSet(map[string]string{"run": "run-test-3"}), 1*time.Minute, f) if err != nil { os.Exit(1) } diff --git a/test/integration/framework/master_utils.go b/test/integration/framework/master_utils.go index 295a4972de2..995ecd01593 100644 --- a/test/integration/framework/master_utils.go +++ b/test/integration/framework/master_utils.go @@ -42,6 +42,7 @@ import ( "k8s.io/kubernetes/pkg/client/record" "k8s.io/kubernetes/pkg/client/restclient" client "k8s.io/kubernetes/pkg/client/unversioned" + clientsetadapter "k8s.io/kubernetes/pkg/client/unversioned/adapters/internalclientset" "k8s.io/kubernetes/pkg/controller" replicationcontroller "k8s.io/kubernetes/pkg/controller/replication" "k8s.io/kubernetes/pkg/fields" @@ -290,7 +291,7 @@ func RCFromManifest(fileName string) *api.ReplicationController { // StopRC stops the rc via kubectl's stop library func StopRC(rc *api.ReplicationController, restClient *client.Client) error { - reaper, err := kubectl.ReaperFor(api.Kind("ReplicationController"), restClient) + reaper, err := kubectl.ReaperFor(api.Kind("ReplicationController"), clientsetadapter.FromUnversionedClient(restClient)) if err != nil || reaper == nil { return err } @@ -303,7 +304,7 @@ func StopRC(rc *api.ReplicationController, restClient *client.Client) error { // ScaleRC scales the given rc to the given replicas. func ScaleRC(name, ns string, replicas int32, restClient *client.Client) (*api.ReplicationController, error) { - scaler, err := kubectl.ScalerFor(api.Kind("ReplicationController"), restClient) + scaler, err := kubectl.ScalerFor(api.Kind("ReplicationController"), clientsetadapter.FromUnversionedClient(restClient)) if err != nil { return nil, err }