Merge pull request #32316 from deads2k/client-05-remaining-clients

Automatic merge from submit-queue

remove the rest of the non-generated clients from the kubectl code

Die `Client` Die!

It's always bigger than you think.  Last bit @kargakis after this, it's gone.

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\"")

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.

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"`

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

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}
+}

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 = &copyGroupVersion
+	//}
+
+	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
+}

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

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

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
+}

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
+}

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{}

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
+}

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)
 }

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}
 }

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
+}

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{}

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
+}

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
 		}

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)
 	}

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

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
 		}

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,13 +60,26 @@ func defaultHeader() http.Header {
 
 func defaultClientConfig() *restclient.Config {
 	return &restclient.Config{
+		APIPath: "/api",
 		ContentConfig: restclient.ContentConfig{
+			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,
+		},
+	}
+}
+
 type internalType struct {
 	Kind       string
 	APIVersion string
@@ -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

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 {

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 {

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).

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
+		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{})

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
 		}

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).

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
+		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
+		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")

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
 	}

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

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 {

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)

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 {

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)

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"
 )
 

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) {

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")
+
+	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.CertificatesClient.RESTClient, 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:

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

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
 }

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
 			}

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,9 +106,11 @@ func TestDescribeService(t *testing.T) {
 
 func TestPodDescribeResultsSorted(t *testing.T) {
 	// Arrange
-	fake := testclient.NewSimpleFake(&api.EventList{
+	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)),
@@ -118,6 +119,7 @@ func TestPodDescribeResultsSorted(t *testing.T) {
 					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)),
@@ -126,6 +128,7 @@ func TestPodDescribeResultsSorted(t *testing.T) {
 					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)),
@@ -134,7 +137,9 @@ func TestPodDescribeResultsSorted(t *testing.T) {
 					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",
 				},
 			}, events),
 		},
 		"PersistentVolumeDescriber": &PersistentVolumeDescriber{
-			testclient.NewSimpleFake(&api.PersistentVolume{
+			fake.NewSimpleClientset(&api.PersistentVolume{
 				ObjectMeta: api.ObjectMeta{
 					Name:     "bar",
-					Namespace: "foo",
 					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",
 				},
 			}, events),
 		},

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()
 }

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,9 +128,10 @@ 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,
+		rcClient:  rcClient,
+		podClient: podClient,
 		ns:        namespace,
 	}
 	// Inject real implementations.
@@ -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

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,6 +44,7 @@ import (
 func oldRc(replicas int, original int) *api.ReplicationController {
 	return &api.ReplicationController{
 		ObjectMeta: api.ObjectMeta{
+			Namespace: api.NamespaceDefault,
 			Name:      "foo-v1",
 			UID:       "7764ae47-9092-11e4-8393-42010af018ff",
 			Annotations: map[string]string{
@@ -75,6 +77,7 @@ func newRc(replicas int, desired int) *api.ReplicationController {
 	}
 	rc.Spec.Selector = map[string]string{"version": "v2"}
 	rc.ObjectMeta = api.ObjectMeta{
+		Namespace: api.NamespaceDefault,
 		Name:      "foo-v2",
 		Annotations: map[string]string{
 			desiredReplicasAnnotation: fmt.Sprintf("%d", desired),
@@ -891,20 +894,10 @@ 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,
+		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,6 +948,7 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) {
 		{
 			oldRc: &api.ReplicationController{
 				ObjectMeta: api.ObjectMeta{
+					Namespace: api.NamespaceDefault,
 					Name:      "foo",
 				},
 				Spec: api.ReplicationControllerSpec{
@@ -983,6 +978,7 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) {
 			},
 			newRc: &api.ReplicationController{
 				ObjectMeta: api.ObjectMeta{
+					Namespace: api.NamespaceDefault,
 					Name:      "foo",
 				},
 				Spec: api.ReplicationControllerSpec{
@@ -1017,6 +1013,7 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) {
 		{
 			oldRc: &api.ReplicationController{
 				ObjectMeta: api.ObjectMeta{
+					Namespace: api.NamespaceDefault,
 					Name:      "bar",
 				},
 				Spec: api.ReplicationControllerSpec{
@@ -1042,6 +1039,7 @@ func TestRollingUpdater_multipleContainersInPod(t *testing.T) {
 			},
 			newRc: &api.ReplicationController{
 				ObjectMeta: api.ObjectMeta{
+					Namespace: api.NamespaceDefault,
 					Name:      "bar",
 				},
 				Spec: api.ReplicationControllerSpec{
@@ -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,
+			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,6 +1228,7 @@ func TestRollingUpdater_cleanupWithClients_Rename(t *testing.T) {
 func TestFindSourceController(t *testing.T) {
 	ctrl1 := api.ReplicationController{
 		ObjectMeta: api.ObjectMeta{
+			Namespace: api.NamespaceDefault,
 			Name:      "foo",
 			Annotations: map[string]string{
 				sourceIdAnnotation: "bar:1234",
@@ -1241,6 +1237,7 @@ func TestFindSourceController(t *testing.T) {
 	}
 	ctrl2 := api.ReplicationController{
 		ObjectMeta: api.ObjectMeta{
+			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,7 +1624,8 @@ func TestRollingUpdater_readyPods(t *testing.T) {
 		}
 		return &api.Pod{
 			ObjectMeta: api.ObjectMeta{
-				Name:   "pod",
+				Namespace: api.NamespaceDefault,
+				Name:      fmt.Sprintf("pod-%d", count),
 				Labels:    labels,
 			},
 			Status: api.PodStatus{
@@ -1728,11 +1744,12 @@ 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,
+			rcClient:  client.Core(),
+			podClient: client.Core(),
 			nowFn:     test.nowFn,
 		}
 		oldReady, newReady, err := updater.readyPods(test.oldRc, test.newRc, test.minReadySeconds)

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

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 {

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

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},
+		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},
+		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},
+		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)
 	}
 }

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)
 }

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)
 	}

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())
 }

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))

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())

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))

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)

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))

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)
 			}

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
 	}