replace client with clientset in kubelet and other places

2025-07-22 11:21:47 +00:00 · 2016-02-01 14:30:47 -08:00 · 2016-02-01 14:30:47 -08:00 · cddd7b56a4
commit cddd7b56a4
parent fe7887f1ec
65 changed files with 643 additions and 358 deletions
--- a/cmd/integration/integration.go
+++ b/cmd/integration/integration.go
@ -205,7 +205,7 @@ func startComponents(firstManifestURL, secondManifestURL string) (string, string
 	glog.Infof("Using %s as root dir for kubelet #1", testRootDir)
 	cm := cm.NewStubContainerManager()
 	kcfg := kubeletapp.SimpleKubelet(
-		cl,
+		clientset,
 		fakeDocker1,
 		"localhost",
 		testRootDir,
@ -237,7 +237,7 @@ func startComponents(firstManifestURL, secondManifestURL string) (string, string
 	glog.Infof("Using %s as root dir for kubelet #2", testRootDir)

 	kcfg = kubeletapp.SimpleKubelet(
-		cl,
+		clientset,
 		fakeDocker2,
 		"127.0.0.1",
 		testRootDir,
--- a/cmd/kube-apiserver/app/server.go
+++ b/cmd/kube-apiserver/app/server.go
@ -41,6 +41,7 @@ import (
 	"k8s.io/kubernetes/pkg/apiserver"
 	"k8s.io/kubernetes/pkg/apiserver/authenticator"
 	"k8s.io/kubernetes/pkg/capabilities"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	serviceaccountcontroller "k8s.io/kubernetes/pkg/controller/serviceaccount"
@ -244,9 +245,9 @@ func Run(s *options.APIServer) error {
 		clientConfig.GroupVersion = &gv
 	}

-	client, err := client.New(clientConfig)
+	client, err := clientset.NewForConfig(clientConfig)
 	if err != nil {
-		glog.Fatalf("Invalid server address: %v", err)
+		glog.Errorf("Failed to create clientset: %v", err)
 	}

 	legacyV1Group, err := registered.Group(api.GroupName)
--- a/cmd/kubelet/app/server.go
+++ b/cmd/kubelet/app/server.go
@ -40,6 +40,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/chaosclient"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	"k8s.io/kubernetes/pkg/client/record"
+	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	clientauth "k8s.io/kubernetes/pkg/client/unversioned/auth"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
@ -266,13 +267,13 @@ func Run(s *options.KubeletServer, kcfg *KubeletConfig) error {

 		clientConfig, err := CreateAPIServerClientConfig(s)
 		if err == nil {
-			kcfg.KubeClient, err = client.New(clientConfig)
+			kcfg.KubeClient, err = clientset.NewForConfig(clientConfig)

 			// make a separate client for events
 			eventClientConfig := *clientConfig
 			eventClientConfig.QPS = s.EventRecordQPS
 			eventClientConfig.Burst = s.EventBurst
-			kcfg.EventClient, err = client.New(&eventClientConfig)
+			kcfg.EventClient, err = clientset.NewForConfig(&eventClientConfig)
 		}
 		if err != nil && len(s.APIServerList) > 0 {
 			glog.Warningf("No API client: %v", err)
@ -452,7 +453,7 @@ func addChaosToClientConfig(s *options.KubeletServer, config *client.Config) {

 // SimpleRunKubelet is a simple way to start a Kubelet talking to dockerEndpoint, using an API Client.
 // Under the hood it calls RunKubelet (below)
-func SimpleKubelet(client *client.Client,
+func SimpleKubelet(client *clientset.Clientset,
 	dockerClient dockertools.DockerInterface,
 	hostname, rootDir, manifestURL, address string,
 	port uint,
@ -563,7 +564,7 @@ func RunKubelet(kcfg *KubeletConfig) error {
 	eventBroadcaster.StartLogging(glog.V(3).Infof)
 	if kcfg.EventClient != nil {
 		glog.V(4).Infof("Sending events to api server.")
-		eventBroadcaster.StartRecordingToSink(kcfg.EventClient.Events(""))
+		eventBroadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kcfg.EventClient.Events("")})
 	} else {
 		glog.Warning("No api server defined - no events will be sent to API server.")
 	}
@ -666,7 +667,7 @@ type KubeletConfig struct {
 	DockerExecHandler              dockertools.ExecHandler
 	EnableDebuggingHandlers        bool
 	EnableServer                   bool
-	EventClient                    *client.Client
+	EventClient                    *clientset.Clientset
 	EventBurst                     int
 	EventRecordQPS                 float32
 	FileCheckFrequency             time.Duration
@ -677,7 +678,7 @@ type KubeletConfig struct {
 	HostIPCSources                 []string
 	HTTPCheckFrequency             time.Duration
 	ImageGCPolicy                  kubelet.ImageGCPolicy
-	KubeClient                     *client.Client
+	KubeClient                     *clientset.Clientset
 	ManifestURL                    string
 	ManifestURLHeader              http.Header
 	MasterServiceNamespace         string
@ -733,12 +734,10 @@ func CreateAndInitKubelet(kc *KubeletConfig) (k KubeletBootstrap, pc *config.Pod
 	// TODO: KubeletConfig.KubeClient should be a client interface, but client interface misses certain methods
 	// used by kubelet. Since NewMainKubelet expects a client interface, we need to make sure we are not passing
 	// a nil pointer to it when what we really want is a nil interface.
-	var kubeClient client.Interface
-	var c clientset.Interface
+	var kubeClient clientset.Interface
 	if kc.KubeClient != nil {
 		kubeClient = kc.KubeClient
 		// TODO: remove this when we've refactored kubelet to only use clientset.
-		c = clientset.FromUnversionedClient(kc.KubeClient)
 	}

 	gcPolicy := kubecontainer.ContainerGCPolicy{
@ -760,7 +759,6 @@ func CreateAndInitKubelet(kc *KubeletConfig) (k KubeletBootstrap, pc *config.Pod
 		kc.NodeName,
 		kc.DockerClient,
 		kubeClient,
-		c,
 		kc.RootDirectory,
 		kc.PodInfraContainerImage,
 		kc.SyncFrequency,
--- a/cmd/kubemark/hollow-node.go
+++ b/cmd/kubemark/hollow-node.go
@ -23,6 +23,7 @@ import (
 	docker "github.com/fsouza/go-dockerclient"

 	"k8s.io/kubernetes/pkg/api"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	"k8s.io/kubernetes/pkg/client/record"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
@ -88,6 +89,7 @@ func main() {

 	// create a client to communicate with API server.
 	cl, err := createClientFromFile(config.KubeconfigPath)
+	clientset := clientset.FromUnversionedClient(cl)
 	if err != nil {
 		glog.Fatal("Failed to create a Client. Exiting.")
 	}
@ -102,7 +104,7 @@ func main() {

 		hollowKubelet := kubemark.NewHollowKubelet(
 			config.NodeName,
-			cl,
+			clientset,
 			cadvisorInterface,
 			fakeDockerClient,
 			config.KubeletPort,
--- a/cmd/libs/go2idl/client-gen/generators/generator-for-clientset.go
+++ b/cmd/libs/go2idl/client-gen/generators/generator-for-clientset.go
@ -74,6 +74,7 @@ func (g *genClientset) Imports(c *generator.Context) (imports []string) {
 		typedClientPath := filepath.Join(g.typedClientPath, group, version)
 		imports = append(imports, g.imports.ImportLines()...)
 		imports = append(imports, fmt.Sprintf("%s_%s \"%s\"", group, version, typedClientPath))
+		imports = append(imports, "github.com/golang/glog")
 	}
 	return
 }
@ -158,14 +159,14 @@ func NewForConfig(c *$.Config|raw$) (*Clientset, error) {
 	var err error
 $range .allGroups$    clientset.$.Group$Client, err =$.PackageName$.NewForConfig(c)
 	if err!=nil {
-		return nil, err
+		return &clientset, err
 	}
 $end$
 	clientset.DiscoveryClient, err = $.NewDiscoveryClientForConfig|raw$(c)
 	if err!=nil {
-		return nil, err
+		glog.Errorf("failed to create the DiscoveryClient: %v", err)
 	}
-	return &clientset, nil
+	return &clientset, err
 }
 `

--- a/cmd/libs/go2idl/client-gen/testoutput/clientset_generated/test_release_1_1/clientset.go
+++ b/cmd/libs/go2idl/client-gen/testoutput/clientset_generated/test_release_1_1/clientset.go
@ -17,6 +17,7 @@ limitations under the License.
 package test_release_1_1

 import (
+	"github.com/golang/glog"
 	testgroup_unversioned "k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testoutput/testgroup/unversioned"
 	unversioned "k8s.io/kubernetes/pkg/client/unversioned"
 )
@ -49,14 +50,14 @@ func NewForConfig(c *unversioned.Config) (*Clientset, error) {
 	var err error
 	clientset.TestgroupClient, err = testgroup_unversioned.NewForConfig(c)
 	if err != nil {
-		return nil, err
+		return &clientset, err
 	}

 	clientset.DiscoveryClient, err = unversioned.NewDiscoveryClientForConfig(c)
 	if err != nil {
-		return nil, err
+		glog.Errorf("failed to create the DiscoveryClient: %v", err)
 	}
-	return &clientset, nil
+	return &clientset, err
 }

 // NewForConfigOrDie creates a new Clientset for the given config and
--- a/contrib/mesos/pkg/controllermanager/controllermanager.go
+++ b/contrib/mesos/pkg/controllermanager/controllermanager.go
@ -153,7 +153,7 @@ func (s *CMServer) Run(_ []string) error {
 		s.NodeMonitorGracePeriod, s.NodeStartupGracePeriod, s.NodeMonitorPeriod, (*net.IPNet)(&s.ClusterCIDR), s.AllocateNodeCIDRs)
 	nodeController.Run(s.NodeSyncPeriod)

-	nodeStatusUpdaterController := node.NewStatusUpdater(client.NewOrDie(client.AddUserAgent(kubeconfig, "node-status-controller")), s.NodeMonitorPeriod, time.Now)
+	nodeStatusUpdaterController := node.NewStatusUpdater(clientset.NewForConfigOrDie(client.AddUserAgent(kubeconfig, "node-status-controller")), s.NodeMonitorPeriod, time.Now)
 	if err := nodeStatusUpdaterController.Run(util.NeverStop); err != nil {
 		glog.Fatalf("Failed to start node status update controller: %v", err)
 	}
--- a/contrib/mesos/pkg/executor/apis.go
+++ b/contrib/mesos/pkg/executor/apis.go
@ -19,7 +19,7 @@ package executor
 import (
 	"k8s.io/kubernetes/contrib/mesos/pkg/node"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 )

 type kubeAPI interface {
@ -33,11 +33,11 @@ type nodeAPI interface {
 // clientAPIWrapper implements kubeAPI and node API, which serve to isolate external dependencies
 // such that they're easier to mock in unit test.
 type clientAPIWrapper struct {
-	client *client.Client
+	client *clientset.Clientset
 }

 func (cw *clientAPIWrapper) killPod(ns, name string) error {
-	return cw.client.Pods(ns).Delete(name, api.NewDeleteOptions(0))
+	return cw.client.Legacy().Pods(ns).Delete(name, api.NewDeleteOptions(0))
 }

 func (cw *clientAPIWrapper) createOrUpdate(hostname string, slaveAttrLabels, annotations map[string]string) (*api.Node, error) {
--- a/contrib/mesos/pkg/executor/executor.go
+++ b/contrib/mesos/pkg/executor/executor.go
@ -26,6 +26,8 @@ import (
 	"sync/atomic"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"github.com/fsouza/go-dockerclient"
 	"github.com/gogo/protobuf/proto"
 	log "github.com/golang/glog"
@ -40,7 +42,6 @@ import (
 	"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/meta"
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
 	kruntime "k8s.io/kubernetes/pkg/runtime"
@ -112,7 +113,7 @@ type Executor struct {
 }

 type Config struct {
-	APIClient            *client.Client
+	APIClient            *clientset.Clientset
 	Docker               dockertools.DockerInterface
 	ShutdownAlert        func()
 	SuicideTimeout       time.Duration
--- a/contrib/mesos/pkg/executor/node.go
+++ b/contrib/mesos/pkg/executor/node.go
@ -16,9 +16,7 @@ limitations under the License.

 package executor

-import (
-	mesos "github.com/mesos/mesos-go/mesosproto"
-)
+import mesos "github.com/mesos/mesos-go/mesosproto"

 type NodeInfo struct {
 	Cores int
--- a/contrib/mesos/pkg/executor/registry.go
+++ b/contrib/mesos/pkg/executor/registry.go
@ -21,10 +21,11 @@ import (
 	"errors"
 	"sync"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/contrib/mesos/pkg/executor/messages"
 	"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/meta"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"

 	log "github.com/golang/glog"
 )
@ -69,7 +70,7 @@ type (
 	}

 	registryImpl struct {
-		client     *client.Client
+		client     *clientset.Clientset
 		updates    chan *PodEvent
 		m          sync.RWMutex
 		boundTasks map[string]*api.Pod
@ -108,7 +109,7 @@ func (rp *PodEvent) FormatShort() string {
 	return "task '" + rp.taskID + "' pod '" + rp.pod.Namespace + "/" + rp.pod.Name + "'"
 }

-func NewRegistry(client *client.Client) Registry {
+func NewRegistry(client *clientset.Clientset) Registry {
 	r := &registryImpl{
 		client:     client,
 		updates:    make(chan *PodEvent, updatesBacklogSize),
@ -305,7 +306,7 @@ func (r registryImpl) bind(taskID string, pod *api.Pod) error {
 		log.Infof("Binding task %v pod '%v/%v' to '%v' with annotations %+v...",
 			taskID, pod.Namespace, pod.Name, binding.Target.Name, binding.Annotations)
 		ctx := api.WithNamespace(api.NewContext(), binding.Namespace)
-		err := r.client.Post().Namespace(api.NamespaceValue(ctx)).Resource("bindings").Body(binding).Do().Error()
+		err := r.client.LegacyClient.Post().Namespace(api.NamespaceValue(ctx)).Resource("bindings").Body(binding).Do().Error()
 		if err != nil {
 			log.Warningf("failed to bind task %v pod %v/%v: %v", taskID, pod.Namespace, pod.Name, err)
 			return errCreateBindingFailed
@ -320,7 +321,7 @@ func (r registryImpl) bind(taskID string, pod *api.Pod) error {
 		patch.Metadata.Annotations = pod.Annotations
 		patchJson, _ := json.Marshal(patch)
 		log.V(4).Infof("Patching annotations %v of task %v pod %v/%v: %v", pod.Annotations, taskID, pod.Namespace, pod.Name, string(patchJson))
-		err := r.client.Patch(api.MergePatchType).RequestURI(pod.SelfLink).Body(patchJson).Do().Error()
+		err := r.client.LegacyClient.Patch(api.MergePatchType).RequestURI(pod.SelfLink).Body(patchJson).Do().Error()
 		if err != nil {
 			log.Errorf("Error updating annotations of ready-to-launch task %v pod %v/%v: %v", taskID, pod.Namespace, pod.Name, err)
 			return errAnnotationUpdateFailure
--- a/contrib/mesos/pkg/executor/service/service.go
+++ b/contrib/mesos/pkg/executor/service/service.go
@ -33,6 +33,7 @@ import (
 	"k8s.io/kubernetes/contrib/mesos/pkg/hyperkube"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/cache"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/kubelet"
@ -74,7 +75,7 @@ func (s *KubeletExecutorServer) runExecutor(
 	nodeInfos chan<- executor.NodeInfo,
 	kubeletFinished <-chan struct{},
 	staticPodsConfigPath string,
-	apiclient *client.Client,
+	apiclient *clientset.Clientset,
 	registry executor.Registry,
 ) (<-chan struct{}, error) {
 	exec := executor.New(executor.Config{
@ -116,7 +117,7 @@ func (s *KubeletExecutorServer) runKubelet(
 	nodeInfos <-chan executor.NodeInfo,
 	kubeletDone chan<- struct{},
 	staticPodsConfigPath string,
-	apiclient *client.Client,
+	apiclient *clientset.Clientset,
 	podLW *cache.ListWatch,
 	registry executor.Registry,
 	executorDone <-chan struct{},
@ -163,7 +164,7 @@ func (s *KubeletExecutorServer) runKubelet(
 	// make a separate client for events
 	eventClientConfig.QPS = s.EventRecordQPS
 	eventClientConfig.Burst = s.EventBurst
-	kcfg.EventClient, err = client.New(eventClientConfig)
+	kcfg.EventClient, err = clientset.NewForConfig(eventClientConfig)
 	if err != nil {
 		return err
 	}
@ -229,10 +230,10 @@ func (s *KubeletExecutorServer) Run(hks hyperkube.Interface, _ []string) error {
 	}

 	// create apiserver client
-	var apiclient *client.Client
+	var apiclient *clientset.Clientset
 	clientConfig, err := kubeletapp.CreateAPIServerClientConfig(s.KubeletServer)
 	if err == nil {
-		apiclient, err = client.New(clientConfig)
+		apiclient, err = clientset.NewForConfig(clientConfig)
 	}
 	if err != nil {
 		// required for k8sm since we need to send api.Binding information back to the apiserver
@ -240,7 +241,7 @@ func (s *KubeletExecutorServer) Run(hks hyperkube.Interface, _ []string) error {
 	}

 	var (
-		pw = cache.NewListWatchFromClient(apiclient, "pods", api.NamespaceAll,
+		pw = cache.NewListWatchFromClient(apiclient.LegacyClient, "pods", api.NamespaceAll,
 			fields.OneTermEqualSelector(client.PodHost, s.HostnameOverride),
 		)
 		reg = executor.NewRegistry(apiclient)
--- a/contrib/mesos/pkg/node/node.go
+++ b/contrib/mesos/pkg/node/node.go
@ -23,12 +23,13 @@ import (
 	"strings"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	log "github.com/golang/glog"
 	mesos "github.com/mesos/mesos-go/mesosproto"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/util/validation"
 )

@ -41,7 +42,7 @@ const (
 // Create creates a new node api object with the given hostname,
 // slave attribute labels and annotations
 func Create(
-	client *client.Client,
+	client *clientset.Clientset,
 	hostName string,
 	slaveAttrLabels,
 	annotations map[string]string,
@ -87,7 +88,7 @@ func Create(
 // The updated node merges the given slave attribute labels
 // and annotations with the found api object.
 func Update(
-	client *client.Client,
+	client *clientset.Clientset,
 	hostname string,
 	slaveAttrLabels,
 	annotations map[string]string,
@ -122,7 +123,7 @@ func Update(

 // CreateOrUpdate creates a node api object or updates an existing one
 func CreateOrUpdate(
-	client *client.Client,
+	client *clientset.Clientset,
 	hostname string,
 	slaveAttrLabels,
 	annotations map[string]string,
--- a/contrib/mesos/pkg/node/registrator.go
+++ b/contrib/mesos/pkg/node/registrator.go
@ -20,12 +20,13 @@ import (
 	"fmt"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	log "github.com/golang/glog"
 	"k8s.io/kubernetes/contrib/mesos/pkg/queue"
 	"k8s.io/kubernetes/contrib/mesos/pkg/runtime"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 type Registrator interface {
@ -62,11 +63,11 @@ type LookupFunc func(hostName string) *api.Node

 type clientRegistrator struct {
 	lookupNode LookupFunc
-	client     *client.Client
+	client     *clientset.Clientset
 	queue      *queue.HistoricalFIFO
 }

-func NewRegistrator(client *client.Client, lookupNode LookupFunc) *clientRegistrator {
+func NewRegistrator(client *clientset.Clientset, lookupNode LookupFunc) *clientRegistrator {
 	return &clientRegistrator{
 		lookupNode: lookupNode,
 		client:     client,
--- a/contrib/mesos/pkg/node/statusupdater.go
+++ b/contrib/mesos/pkg/node/statusupdater.go
@ -20,6 +20,8 @@ import (
 	"fmt"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	log "github.com/golang/glog"
 	"k8s.io/kubernetes/cmd/kubelet/app/options"
 	"k8s.io/kubernetes/contrib/mesos/pkg/runtime"
@ -27,7 +29,6 @@ import (
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/client/cache"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/cloudprovider/providers/mesos"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/util/sets"
@ -40,13 +41,13 @@ const (
 )

 type StatusUpdater struct {
-	client          *client.Client
+	client          *clientset.Clientset
 	relistPeriod    time.Duration
 	heartBeatPeriod time.Duration
 	nowFunc         func() time.Time
 }

-func NewStatusUpdater(client *client.Client, relistPeriod time.Duration, nowFunc func() time.Time) *StatusUpdater {
+func NewStatusUpdater(client *clientset.Clientset, relistPeriod time.Duration, nowFunc func() time.Time) *StatusUpdater {
 	kubecfg := options.NewKubeletServer() // only create to get the config, this is without side-effects
 	return &StatusUpdater{
 		client:          client,
@ -58,7 +59,7 @@ func NewStatusUpdater(client *client.Client, relistPeriod time.Duration, nowFunc

 func (u *StatusUpdater) Run(terminate <-chan struct{}) error {
 	nodeStore := cache.NewStore(cache.MetaNamespaceKeyFunc)
-	nodeLW := cache.NewListWatchFromClient(u.client, "nodes", api.NamespaceAll, fields.Everything())
+	nodeLW := cache.NewListWatchFromClient(u.client.LegacyClient, "nodes", api.NamespaceAll, fields.Everything())
 	cache.NewReflector(nodeLW, &api.Node{}, nodeStore, u.relistPeriod).Run()

 	monitor := func() {
--- a/contrib/mesos/pkg/scheduler/components/controller/controller.go
+++ b/contrib/mesos/pkg/scheduler/components/controller/controller.go
@ -19,13 +19,14 @@ package controller
 import (
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	log "github.com/golang/glog"
 	"k8s.io/kubernetes/contrib/mesos/pkg/runtime"
 	"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/components/algorithm"
 	"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/components/binder"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/record"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 const (
@ -45,11 +46,11 @@ type controller struct {
 	nextPod   func() *api.Pod
 	error     func(*api.Pod, error)
 	recorder  record.EventRecorder
-	client    *client.Client
+	client    *clientset.Clientset
 	started   chan<- struct{} // startup latch
 }

-func New(client *client.Client, algorithm algorithm.SchedulerAlgorithm,
+func New(client *clientset.Clientset, algorithm algorithm.SchedulerAlgorithm,
 	recorder record.EventRecorder, nextPod func() *api.Pod, error func(pod *api.Pod, schedulingErr error),
 	binder binder.Binder, started chan<- struct{}) Controller {
 	return &controller{
@ -78,7 +79,7 @@ func (s *controller) scheduleOne() {
 	// the scheduler has to take care of this:
 	if pod.Spec.NodeName != "" && pod.DeletionTimestamp != nil {
 		log.V(3).Infof("deleting pre-scheduled, not yet running pod: %s/%s", pod.Namespace, pod.Name)
-		s.client.Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0))
+		s.client.Legacy().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0))
 		return
 	}

--- a/contrib/mesos/pkg/scheduler/components/framework/framework.go
+++ b/contrib/mesos/pkg/scheduler/components/framework/framework.go
@ -45,7 +45,7 @@ import (
 	"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/podtask"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	"k8s.io/kubernetes/pkg/kubelet/container"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
 	"k8s.io/kubernetes/pkg/util/sets"
@ -69,7 +69,7 @@ type framework struct {
 	// Config related, write-once
 	sched             scheduler.Scheduler
 	schedulerConfig   *schedcfg.Config
-	client            *client.Client
+	client            *clientset.Clientset
 	failoverTimeout   float64 // in seconds
 	reconcileInterval int64
 	nodeRegistrator   node.Registrator
@ -98,7 +98,7 @@ type framework struct {
 type Config struct {
 	SchedulerConfig   schedcfg.Config
 	ExecutorId        *mesos.ExecutorID
-	Client            *client.Client
+	Client            *clientset.Clientset
 	StoreFrameworkId  frameworkid.StoreFunc
 	FailoverTimeout   float64
 	ReconcileInterval int64
@ -526,7 +526,7 @@ func (k *framework) reconcileTerminalTask(driver bindings.SchedulerDriver, taskS
 		// TODO(jdef) for case #2 don't delete the pod, just update it's status to Failed
 		pod := &task.Pod
 		log.Warningf("deleting rogue pod %v/%v for lost task %v", pod.Namespace, pod.Name, task.ID)
-		if err := k.client.Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil && !errors.IsNotFound(err) {
+		if err := k.client.Legacy().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil && !errors.IsNotFound(err) {
 			log.Errorf("failed to delete pod %v/%v for terminal task %v: %v", pod.Namespace, pod.Name, task.ID, err)
 		}
 	} else if taskStatus.GetReason() == mesos.TaskStatus_REASON_EXECUTOR_TERMINATED || taskStatus.GetReason() == mesos.TaskStatus_REASON_EXECUTOR_UNREGISTERED {
@ -578,7 +578,7 @@ func (k *framework) reconcileNonTerminalTask(driver bindings.SchedulerDriver, ta
 		// possible rogue pod exists at this point because we can't identify it; should kill the task
 		log.Errorf("possible rogue pod; illegal api.PodStatusResult, unable to parse full pod name from: '%v' for task %v: %v",
 			podStatus.Name, taskId, err)
-	} else if pod, err := k.client.Pods(namespace).Get(name); err == nil {
+	} else if pod, err := k.client.Legacy().Pods(namespace).Get(name); err == nil {
 		if t, ok, err := podtask.RecoverFrom(*pod); ok {
 			log.Infof("recovered task %v from metadata in pod %v/%v", taskId, namespace, name)
 			_, err := k.sched.Tasks().Register(t)
@ -593,7 +593,7 @@ func (k *framework) reconcileNonTerminalTask(driver bindings.SchedulerDriver, ta
 		} else if err != nil {
 			//should kill the pod and the task
 			log.Errorf("killing pod, failed to recover task from pod %v/%v: %v", namespace, name, err)
-			if err := k.client.Pods(namespace).Delete(name, nil); err != nil {
+			if err := k.client.Legacy().Pods(namespace).Delete(name, nil); err != nil {
 				log.Errorf("failed to delete pod %v/%v: %v", namespace, name, err)
 			}
 		} else {
@ -683,7 +683,7 @@ func (k *framework) makeTaskRegistryReconciler() taskreconciler.Action {
 // tasks identified by annotations in the Kubernetes pod registry.
 func (k *framework) makePodRegistryReconciler() taskreconciler.Action {
 	return taskreconciler.Action(func(drv bindings.SchedulerDriver, cancel <-chan struct{}) <-chan error {
-		podList, err := k.client.Pods(api.NamespaceAll).List(api.ListOptions{})
+		podList, err := k.client.Legacy().Pods(api.NamespaceAll).List(api.ListOptions{})
 		if err != nil {
 			return proc.ErrorChanf("failed to reconcile pod registry: %v", err)
 		}
@ -759,7 +759,7 @@ func (k *framework) explicitlyReconcileTasks(driver bindings.SchedulerDriver, ta
 }

 func (ks *framework) recoverTasks() error {
-	podList, err := ks.client.Pods(api.NamespaceAll).List(api.ListOptions{})
+	podList, err := ks.client.Legacy().Pods(api.NamespaceAll).List(api.ListOptions{})
 	if err != nil {
 		log.V(1).Infof("failed to recover pod registry, madness may ensue: %v", err)
 		return err
@ -778,7 +778,7 @@ func (ks *framework) recoverTasks() error {
 		}
 		if t, ok, err := podtask.RecoverFrom(pod); err != nil {
 			log.Errorf("failed to recover task from pod, will attempt to delete '%v/%v': %v", pod.Namespace, pod.Name, err)
-			err := ks.client.Pods(pod.Namespace).Delete(pod.Name, nil)
+			err := ks.client.Legacy().Pods(pod.Namespace).Delete(pod.Name, nil)
 			//TODO(jdef) check for temporary or not-found errors
 			if err != nil {
 				log.Errorf("failed to delete pod '%v/%v': %v", pod.Namespace, pod.Name, err)
--- a/contrib/mesos/pkg/scheduler/components/podreconciler/podreconciler.go
+++ b/contrib/mesos/pkg/scheduler/components/podreconciler/podreconciler.go
@ -19,6 +19,8 @@ package podreconciler
 import (
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	log "github.com/golang/glog"
 	"k8s.io/kubernetes/contrib/mesos/pkg/scheduler"
 	"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/components/deleter"
@ -27,7 +29,6 @@ import (
 	"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/queuer"
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 // PodReconciler reconciles a pod with the apiserver
@ -37,12 +38,12 @@ type PodReconciler interface {

 type podReconciler struct {
 	sched   scheduler.Scheduler
-	client  *client.Client
+	client  *clientset.Clientset
 	qr      queuer.Queuer
 	deleter deleter.Deleter
 }

-func New(sched scheduler.Scheduler, client *client.Client, qr queuer.Queuer, deleter deleter.Deleter) PodReconciler {
+func New(sched scheduler.Scheduler, client *clientset.Clientset, qr queuer.Queuer, deleter deleter.Deleter) PodReconciler {
 	return &podReconciler{
 		sched:   sched,
 		client:  client,
@ -65,7 +66,7 @@ func New(sched scheduler.Scheduler, client *client.Client, qr queuer.Queuer, del
 func (s *podReconciler) Reconcile(t *podtask.T) {
 	log.V(1).Infof("reconcile pod %v, assigned to slave %q", t.Pod.Name, t.Spec.AssignedSlave)
 	ctx := api.WithNamespace(api.NewDefaultContext(), t.Pod.Namespace)
-	pod, err := s.client.Pods(api.NamespaceValue(ctx)).Get(t.Pod.Name)
+	pod, err := s.client.Legacy().Pods(api.NamespaceValue(ctx)).Get(t.Pod.Name)
 	if err != nil {
 		if apierrors.IsNotFound(err) {
 			// attempt to delete
--- a/contrib/mesos/pkg/scheduler/components/scheduler.go
+++ b/contrib/mesos/pkg/scheduler/components/scheduler.go
@ -20,6 +20,8 @@ import (
 	"net/http"
 	"sync"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	mesos "github.com/mesos/mesos-go/mesosproto"
 	"k8s.io/kubernetes/contrib/mesos/pkg/backoff"
 	"k8s.io/kubernetes/contrib/mesos/pkg/offers"
@ -41,7 +43,6 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/cache"
 	"k8s.io/kubernetes/pkg/client/record"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 // sched implements the Scheduler interface.
@ -59,7 +60,7 @@ func New(
 	c *config.Config,
 	fw framework.Framework,
 	ps podschedulers.PodScheduler,
-	client *client.Client,
+	client *clientset.Clientset,
 	recorder record.EventRecorder,
 	terminate <-chan struct{},
 	mux *http.ServeMux,
--- a/contrib/mesos/pkg/scheduler/integration/integration_test.go
+++ b/contrib/mesos/pkg/scheduler/integration/integration_test.go
@ -48,6 +48,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/client/cache"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util"
@ -488,7 +489,7 @@ func newLifecycleTest(t *testing.T) lifecycleTest {
 	ei.Data = []byte{0, 1, 2}

 	// create framework
-	client := client.NewOrDie(&client.Config{
+	client := clientset.NewForConfigOrDie(&client.Config{
 		Host:          apiServer.server.URL,
 		ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()},
 	})
--- a/contrib/mesos/pkg/scheduler/service/publish.go
+++ b/contrib/mesos/pkg/scheduler/service/publish.go
@ -59,7 +59,7 @@ func (m *SchedulerServer) newServiceWriter(stop <-chan struct{}) func() {
 // doesn't already exist.
 func (m *SchedulerServer) createSchedulerServiceIfNeeded(serviceName string, servicePort int) error {
 	ctx := api.NewDefaultContext()
-	if _, err := m.client.Services(api.NamespaceValue(ctx)).Get(serviceName); err == nil {
+	if _, err := m.client.Legacy().Services(api.NamespaceValue(ctx)).Get(serviceName); err == nil {
 		// The service already exists.
 		return nil
 	}
@ -79,7 +79,7 @@ func (m *SchedulerServer) createSchedulerServiceIfNeeded(serviceName string, ser
 	if m.serviceAddress != nil {
 		svc.Spec.ClusterIP = m.serviceAddress.String()
 	}
-	_, err := m.client.Services(api.NamespaceValue(ctx)).Create(svc)
+	_, err := m.client.Legacy().Services(api.NamespaceValue(ctx)).Create(svc)
 	if err != nil && errors.IsAlreadyExists(err) {
 		err = nil
 	}
--- a/contrib/mesos/pkg/scheduler/service/service.go
+++ b/contrib/mesos/pkg/scheduler/service/service.go
@ -34,6 +34,8 @@ import (
 	"sync"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	etcd "github.com/coreos/etcd/client"
 	"github.com/gogo/protobuf/proto"
 	log "github.com/golang/glog"
@ -173,7 +175,7 @@ type SchedulerServer struct {
 	conntrackTCPTimeoutEstablished int

 	executable  string // path to the binary running this service
-	client      *client.Client
+	client      *clientset.Clientset
 	driver      bindings.SchedulerDriver
 	driverMutex sync.RWMutex
 	mux         *http.ServeMux
@ -521,7 +523,7 @@ func (s *SchedulerServer) prepareStaticPods() (data []byte, staticPodCPUs, stati

 // TODO(jdef): hacked from kubelet/server/server.go
 // TODO(k8s): replace this with clientcmd
-func (s *SchedulerServer) createAPIServerClient() (*client.Client, error) {
+func (s *SchedulerServer) createAPIServerClient() (*clientset.Clientset, error) {
 	authInfo, err := clientauth.LoadFromFile(s.authPath)
 	if err != nil {
 		log.Warningf("Could not load kubernetes auth path: %v. Continuing with defaults.", err)
@ -542,7 +544,7 @@ func (s *SchedulerServer) createAPIServerClient() (*client.Client, error) {
 		log.Infof("Multiple api servers specified.  Picking first one")
 	}
 	clientConfig.Host = s.apiServerList[0]
-	c, err := client.New(&clientConfig)
+	c, err := clientset.NewForConfig(&clientConfig)
 	if err != nil {
 		return nil, err
 	}
@ -722,7 +724,7 @@ func (s *SchedulerServer) bootstrap(hks hyperkube.Interface, sc *schedcfg.Config
 	if err != nil {
 		log.Fatalf("Cannot create client to watch nodes: %v", err)
 	}
-	nodeLW := cache.NewListWatchFromClient(nodesClient, "nodes", api.NamespaceAll, fields.Everything())
+	nodeLW := cache.NewListWatchFromClient(nodesClient.LegacyClient, "nodes", api.NamespaceAll, fields.Everything())
 	nodeStore, nodeCtl := controllerfw.NewInformer(nodeLW, &api.Node{}, s.nodeRelistPeriod, &controllerfw.ResourceEventHandlerFuncs{
 		DeleteFunc: func(obj interface{}) {
 			node := obj.(*api.Node)
@ -796,7 +798,7 @@ func (s *SchedulerServer) bootstrap(hks hyperkube.Interface, sc *schedcfg.Config
 	broadcaster.StartRecordingToSink(client.Events(""))

 	// create scheduler core with all components arranged around it
-	lw := cache.NewListWatchFromClient(client, "pods", api.NamespaceAll, fields.Everything())
+	lw := cache.NewListWatchFromClient(client.LegacyClient, "pods", api.NamespaceAll, fields.Everything())
 	sched := components.New(
 		sc,
 		framework,
--- a/pkg/admission/chain.go
+++ b/pkg/admission/chain.go
@ -16,16 +16,14 @@ limitations under the License.

 package admission

-import (
-	client "k8s.io/kubernetes/pkg/client/unversioned"
-)
+import clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"

 // chainAdmissionHandler is an instance of admission.Interface that performs admission control using a chain of admission handlers
 type chainAdmissionHandler []Interface

 // NewFromPlugins returns an admission.Interface that will enforce admission control decisions of all
 // the given plugins.
-func NewFromPlugins(client client.Interface, pluginNames []string, configFilePath string) Interface {
+func NewFromPlugins(client clientset.Interface, pluginNames []string, configFilePath string) Interface {
 	plugins := []Interface{}
 	for _, pluginName := range pluginNames {
 		plugin := InitPlugin(pluginName, client, configFilePath)
--- a/pkg/admission/plugins.go
+++ b/pkg/admission/plugins.go
@ -23,14 +23,14 @@ import (
 	"sync"

 	"github.com/golang/glog"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 )

 // Factory is a function that returns an Interface for admission decisions.
 // The config parameter provides an io.Reader handler to the factory in
 // order to load specific configurations. If no configuration is provided
 // the parameter is nil.
-type Factory func(client client.Interface, config io.Reader) (Interface, error)
+type Factory func(client clientset.Interface, config io.Reader) (Interface, error)

 // All registered admission options.
 var (
@ -67,7 +67,7 @@ func RegisterPlugin(name string, plugin Factory) {
 // known. The error is returned only when the named provider was known but failed
 // to initialize. The config parameter specifies the io.Reader handler of the
 // configuration file for the cloud provider, or nil for no configuration.
-func GetPlugin(name string, client client.Interface, config io.Reader) (Interface, error) {
+func GetPlugin(name string, client clientset.Interface, config io.Reader) (Interface, error) {
 	pluginsMutex.Lock()
 	defer pluginsMutex.Unlock()
 	f, found := plugins[name]
@ -78,7 +78,7 @@ func GetPlugin(name string, client client.Interface, config io.Reader) (Interfac
 }

 // InitPlugin creates an instance of the named interface.
-func InitPlugin(name string, client client.Interface, configFilePath string) Interface {
+func InitPlugin(name string, client clientset.Interface, configFilePath string) Interface {
 	var (
 		config *os.File
 		err    error
--- a/pkg/api/types.go
+++ b/pkg/api/types.go
@ -2150,6 +2150,8 @@ type SecretList struct {
 	Items []Secret `json:"items"`
 }

+// +genclient=true
+
 // ConfigMap holds configuration data for components or applications to consume.
 type ConfigMap struct {
 	unversioned.TypeMeta `json:",inline"`
--- a/pkg/client/clientset_generated/release_1_1/clientset.go
+++ b/pkg/client/clientset_generated/release_1_1/clientset.go
@ -17,6 +17,7 @@ limitations under the License.
 package release_1_1

 import (
+	"github.com/golang/glog"
 	extensions_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
 	legacy_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
 	unversioned "k8s.io/kubernetes/pkg/client/unversioned"
@ -57,18 +58,18 @@ func NewForConfig(c *unversioned.Config) (*Clientset, error) {
 	var err error
 	clientset.LegacyClient, err = legacy_unversioned.NewForConfig(c)
 	if err != nil {
-		return nil, err
+		return &clientset, err
 	}
 	clientset.ExtensionsClient, err = extensions_unversioned.NewForConfig(c)
 	if err != nil {
-		return nil, err
+		return &clientset, err
 	}

 	clientset.DiscoveryClient, err = unversioned.NewDiscoveryClientForConfig(c)
 	if err != nil {
-		return nil, err
+		glog.Errorf("failed to create the DiscoveryClient: %v", err)
 	}
-	return &clientset, nil
+	return &clientset, err
 }

 // NewForConfigOrDie creates a new Clientset for the given config and
--- a/pkg/client/typed/generated/legacy/unversioned/configmap.go
+++ b/pkg/client/typed/generated/legacy/unversioned/configmap.go
@ -0,0 +1,135 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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"
+	watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// ConfigMapsGetter has a method to return a ConfigMapInterface.
+// A group's client should implement this interface.
+type ConfigMapsGetter interface {
+	ConfigMaps(namespace string) ConfigMapInterface
+}
+
+// ConfigMapInterface has methods to work with ConfigMap resources.
+type ConfigMapInterface interface {
+	Create(*api.ConfigMap) (*api.ConfigMap, error)
+	Update(*api.ConfigMap) (*api.ConfigMap, error)
+	Delete(name string, options *api.DeleteOptions) error
+	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
+	Get(name string) (*api.ConfigMap, error)
+	List(opts api.ListOptions) (*api.ConfigMapList, error)
+	Watch(opts api.ListOptions) (watch.Interface, error)
+	ConfigMapExpansion
+}
+
+// configMaps implements ConfigMapInterface
+type configMaps struct {
+	client *LegacyClient
+	ns     string
+}
+
+// newConfigMaps returns a ConfigMaps
+func newConfigMaps(c *LegacyClient, namespace string) *configMaps {
+	return &configMaps{
+		client: c,
+		ns:     namespace,
+	}
+}
+
+// Create takes the representation of a configMap and creates it.  Returns the server's representation of the configMap, and an error, if there is any.
+func (c *configMaps) Create(configMap *api.ConfigMap) (result *api.ConfigMap, err error) {
+	result = &api.ConfigMap{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("configmaps").
+		Body(configMap).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a configMap and updates it. Returns the server's representation of the configMap, and an error, if there is any.
+func (c *configMaps) Update(configMap *api.ConfigMap) (result *api.ConfigMap, err error) {
+	result = &api.ConfigMap{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("configmaps").
+		Name(configMap.Name).
+		Body(configMap).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the configMap and deletes it. Returns an error if one occurs.
+func (c *configMaps) Delete(name string, options *api.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("configmaps").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *configMaps) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("configmaps").
+		VersionedParams(&listOptions, api.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Get takes name of the configMap, and returns the corresponding configMap object, and an error if there is any.
+func (c *configMaps) Get(name string) (result *api.ConfigMap, err error) {
+	result = &api.ConfigMap{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("configmaps").
+		Name(name).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ConfigMaps that match those selectors.
+func (c *configMaps) List(opts api.ListOptions) (result *api.ConfigMapList, err error) {
+	result = &api.ConfigMapList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("configmaps").
+		VersionedParams(&opts, api.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested configMaps.
+func (c *configMaps) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.client.Get().
+		Prefix("watch").
+		Namespace(c.ns).
+		Resource("configmaps").
+		VersionedParams(&opts, api.ParameterCodec).
+		Watch()
+}
--- a/pkg/client/typed/generated/legacy/unversioned/fake/fake_configmap.go
+++ b/pkg/client/typed/generated/legacy/unversioned/fake/fake_configmap.go
@ -0,0 +1,102 @@
+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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"
+	core "k8s.io/kubernetes/pkg/client/testing/core"
+	labels "k8s.io/kubernetes/pkg/labels"
+	watch "k8s.io/kubernetes/pkg/watch"
+)
+
+// FakeConfigMaps implements ConfigMapInterface
+type FakeConfigMaps struct {
+	Fake *FakeLegacy
+	ns   string
+}
+
+func (c *FakeConfigMaps) Create(configMap *api.ConfigMap) (result *api.ConfigMap, err error) {
+	obj, err := c.Fake.
+		Invokes(core.NewCreateAction("configmaps", c.ns, configMap), &api.ConfigMap{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*api.ConfigMap), err
+}
+
+func (c *FakeConfigMaps) Update(configMap *api.ConfigMap) (result *api.ConfigMap, err error) {
+	obj, err := c.Fake.
+		Invokes(core.NewUpdateAction("configmaps", c.ns, configMap), &api.ConfigMap{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*api.ConfigMap), err
+}
+
+func (c *FakeConfigMaps) Delete(name string, options *api.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(core.NewDeleteAction("configmaps", c.ns, name), &api.ConfigMap{})
+
+	return err
+}
+
+func (c *FakeConfigMaps) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
+	action := core.NewDeleteCollectionAction("events", c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &api.ConfigMapList{})
+	return err
+}
+
+func (c *FakeConfigMaps) Get(name string) (result *api.ConfigMap, err error) {
+	obj, err := c.Fake.
+		Invokes(core.NewGetAction("configmaps", c.ns, name), &api.ConfigMap{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*api.ConfigMap), err
+}
+
+func (c *FakeConfigMaps) List(opts api.ListOptions) (result *api.ConfigMapList, err error) {
+	obj, err := c.Fake.
+		Invokes(core.NewListAction("configmaps", c.ns, opts), &api.ConfigMapList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label := opts.LabelSelector
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &api.ConfigMapList{}
+	for _, item := range obj.(*api.ConfigMapList).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 configMaps.
+func (c *FakeConfigMaps) Watch(opts api.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(core.NewWatchAction("configmaps", c.ns, opts))
+
+}
--- a/pkg/client/typed/generated/legacy/unversioned/fake/fake_legacy_client.go
+++ b/pkg/client/typed/generated/legacy/unversioned/fake/fake_legacy_client.go
@ -29,6 +29,10 @@ func (c *FakeLegacy) ComponentStatuses() unversioned.ComponentStatusInterface {
 	return &FakeComponentStatuses{c}
 }

+func (c *FakeLegacy) ConfigMaps(namespace string) unversioned.ConfigMapInterface {
+	return &FakeConfigMaps{c, namespace}
+}
+
 func (c *FakeLegacy) Endpoints(namespace string) unversioned.EndpointsInterface {
 	return &FakeEndpoints{c, namespace}
 }
--- a/pkg/client/typed/generated/legacy/unversioned/generated_expansion.go
+++ b/pkg/client/typed/generated/legacy/unversioned/generated_expansion.go
@ -37,3 +37,5 @@ type ResourceQuotaExpansion interface{}
 type SecretExpansion interface{}

 type ServiceAccountExpansion interface{}
+
+type ConfigMapExpansion interface{}
--- a/pkg/client/typed/generated/legacy/unversioned/legacy_client.go
+++ b/pkg/client/typed/generated/legacy/unversioned/legacy_client.go
@ -24,6 +24,7 @@ import (

 type LegacyInterface interface {
 	ComponentStatusesGetter
+	ConfigMapsGetter
 	EndpointsGetter
 	EventsGetter
 	LimitRangesGetter
@ -49,6 +50,10 @@ func (c *LegacyClient) ComponentStatuses() ComponentStatusInterface {
 	return newComponentStatuses(c)
 }

+func (c *LegacyClient) ConfigMaps(namespace string) ConfigMapInterface {
+	return newConfigMaps(c, namespace)
+}
+
 func (c *LegacyClient) Endpoints(namespace string) EndpointsInterface {
 	return newEndpoints(c, namespace)
 }
--- a/pkg/kubelet/config/apiserver.go
+++ b/pkg/kubelet/config/apiserver.go
@ -20,14 +20,15 @@ package config
 import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/cache"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/fields"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
 )

 // NewSourceApiserver creates a config source that watches and pulls from the apiserver.
-func NewSourceApiserver(c *client.Client, nodeName string, updates chan<- interface{}) {
-	lw := cache.NewListWatchFromClient(c, "pods", api.NamespaceAll, fields.OneTermEqualSelector(client.PodHost, nodeName))
+func NewSourceApiserver(c *clientset.Clientset, nodeName string, updates chan<- interface{}) {
+	lw := cache.NewListWatchFromClient(c.LegacyClient, "pods", api.NamespaceAll, fields.OneTermEqualSelector(client.PodHost, nodeName))
 	newSourceApiserverFromLW(lw, updates)
 }

--- a/pkg/kubelet/kubelet.go
+++ b/pkg/kubelet/kubelet.go
@ -148,8 +148,7 @@ func NewMainKubelet(
 	hostname string,
 	nodeName string,
 	dockerClient dockertools.DockerInterface,
-	kubeClient client.Interface,
-	clientset clientset.Interface,
+	kubeClient clientset.Interface,
 	rootDirectory string,
 	podInfraContainerImage string,
 	resyncInterval time.Duration,
@ -220,10 +219,10 @@ func NewMainKubelet(
 		// than an interface. There is no way to construct a list+watcher using resource name.
 		listWatch := &cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return kubeClient.Services(api.NamespaceAll).List(options)
+				return kubeClient.Legacy().Services(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return kubeClient.Services(api.NamespaceAll).Watch(options)
+				return kubeClient.Legacy().Services(api.NamespaceAll).Watch(options)
 			},
 		}
 		cache.NewReflector(listWatch, &api.Service{}, serviceStore, 0).Run()
@ -238,11 +237,11 @@ func NewMainKubelet(
 		listWatch := &cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 				options.FieldSelector = fieldSelector
-				return kubeClient.Nodes().List(options)
+				return kubeClient.Legacy().Nodes().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 				options.FieldSelector = fieldSelector
-				return kubeClient.Nodes().Watch(options)
+				return kubeClient.Legacy().Nodes().Watch(options)
 			},
 		}
 		cache.NewReflector(listWatch, &api.Node{}, nodeStore, 0).Run()
@ -275,7 +274,6 @@ func NewMainKubelet(
 		nodeName:                       nodeName,
 		dockerClient:                   dockerClient,
 		kubeClient:                     kubeClient,
-		clientset:                      clientset,
 		rootDirectory:                  rootDirectory,
 		resyncInterval:                 resyncInterval,
 		containerRefManager:            containerRefManager,
@ -469,8 +467,7 @@ type Kubelet struct {
 	nodeName      string
 	dockerClient  dockertools.DockerInterface
 	runtimeCache  kubecontainer.RuntimeCache
-	kubeClient    client.Interface
-	clientset     clientset.Interface
+	kubeClient    clientset.Interface
 	rootDirectory string
 	podWorkers    PodWorkers

@ -1055,12 +1052,12 @@ func (kl *Kubelet) registerWithApiserver() {
 			continue
 		}
 		glog.V(2).Infof("Attempting to register node %s", node.Name)
-		if _, err := kl.kubeClient.Nodes().Create(node); err != nil {
+		if _, err := kl.kubeClient.Legacy().Nodes().Create(node); err != nil {
 			if !apierrors.IsAlreadyExists(err) {
 				glog.V(2).Infof("Unable to register %s with the apiserver: %v", node.Name, err)
 				continue
 			}
-			currentNode, err := kl.kubeClient.Nodes().Get(kl.nodeName)
+			currentNode, err := kl.kubeClient.Legacy().Nodes().Get(kl.nodeName)
 			if err != nil {
 				glog.Errorf("error getting node %q: %v", kl.nodeName, err)
 				continue
@ -1078,7 +1075,7 @@ func (kl *Kubelet) registerWithApiserver() {
 				"Previously %q had externalID %q; now it is %q; will delete and recreate.",
 				kl.nodeName, node.Spec.ExternalID, currentNode.Spec.ExternalID,
 			)
-			if err := kl.kubeClient.Nodes().Delete(node.Name); err != nil {
+			if err := kl.kubeClient.Legacy().Nodes().Delete(node.Name, nil); err != nil {
 				glog.Errorf("Unable to delete old node: %v", err)
 			} else {
 				glog.Errorf("Deleted old node object %q", kl.nodeName)
@ -1410,7 +1407,7 @@ func (kl *Kubelet) makeEnvironmentVariables(pod *api.Pod, container *api.Contain
 				key := envVar.ValueFrom.ConfigMapKeyRef.Key
 				configMap, ok := configMaps[name]
 				if !ok {
-					configMap, err = kl.kubeClient.ConfigMaps(pod.Namespace).Get(name)
+					configMap, err = kl.kubeClient.Legacy().ConfigMaps(pod.Namespace).Get(name)
 					if err != nil {
 						return result, err
 					}
@ -1424,7 +1421,7 @@ func (kl *Kubelet) makeEnvironmentVariables(pod *api.Pod, container *api.Contain
 				key := envVar.ValueFrom.SecretKeyRef.Key
 				secret, ok := secrets[name]
 				if !ok {
-					secret, err = kl.kubeClient.Secrets(pod.Namespace).Get(name)
+					secret, err = kl.kubeClient.Legacy().Secrets(pod.Namespace).Get(name)
 					if err != nil {
 						return result, err
 					}
@ -1718,7 +1715,7 @@ func (kl *Kubelet) getPullSecretsForPod(pod *api.Pod) ([]api.Secret, error) {
 	pullSecrets := []api.Secret{}

 	for _, secretRef := range pod.Spec.ImagePullSecrets {
-		secret, err := kl.kubeClient.Secrets(pod.Namespace).Get(secretRef.Name)
+		secret, err := kl.kubeClient.Legacy().Secrets(pod.Namespace).Get(secretRef.Name)
 		if err != nil {
 			glog.Warningf("Unable to retrieve pull secret %s/%s for %s/%s due to %v.  The image pull may not succeed.", pod.Namespace, secretRef.Name, pod.Namespace, pod.Name, err)
 			continue
@ -2971,7 +2968,7 @@ func (kl *Kubelet) isContainerRuntimeVersionCompatible() error {
 // tryUpdateNodeStatus tries to update node status to master. If ReconcileCBR0
 // is set, this function will also confirm that cbr0 is configured correctly.
 func (kl *Kubelet) tryUpdateNodeStatus() error {
-	node, err := kl.kubeClient.Nodes().Get(kl.nodeName)
+	node, err := kl.kubeClient.Legacy().Nodes().Get(kl.nodeName)
 	if err != nil {
 		return fmt.Errorf("error getting node %q: %v", kl.nodeName, err)
 	}
@ -2986,7 +2983,7 @@ func (kl *Kubelet) tryUpdateNodeStatus() error {
 		if node.Spec.PodCIDR != flannelPodCIDR {
 			node.Spec.PodCIDR = flannelPodCIDR
 			glog.Infof("Updating podcidr to %v", node.Spec.PodCIDR)
-			if updatedNode, err := kl.kubeClient.Nodes().Update(node); err != nil {
+			if updatedNode, err := kl.kubeClient.Legacy().Nodes().Update(node); err != nil {
 				glog.Warningf("Failed to update podCIDR: %v", err)
 			} else {
 				// Update the node resourceVersion so the status update doesn't fail.
@ -3001,7 +2998,7 @@ func (kl *Kubelet) tryUpdateNodeStatus() error {
 		return err
 	}
 	// Update the current status on the API server
-	_, err = kl.kubeClient.Nodes().UpdateStatus(node)
+	_, err = kl.kubeClient.Legacy().Nodes().UpdateStatus(node)
 	return err
 }

--- a/pkg/kubelet/kubelet_test.go
+++ b/pkg/kubelet/kubelet_test.go
@ -40,6 +40,8 @@ import (
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/capabilities"
 	"k8s.io/kubernetes/pkg/client/record"
+	"k8s.io/kubernetes/pkg/client/testing/core"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
 	"k8s.io/kubernetes/pkg/kubelet/cadvisor"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
@ -87,7 +89,7 @@ type TestKubelet struct {
 	kubelet          *Kubelet
 	fakeRuntime      *kubecontainer.FakeRuntime
 	fakeCadvisor     *cadvisor.Mock
-	fakeKubeClient   *testclient.Fake
+	fakeKubeClient   *fake.Clientset
 	fakeMirrorClient *kubepod.FakeMirrorClient
 	fakeClock        *util.FakeClock
 }
@ -108,7 +110,7 @@ func newTestKubelet(t *testing.T) *TestKubelet {
 		},
 	}
 	fakeRecorder := &record.FakeRecorder{}
-	fakeKubeClient := &testclient.Fake{}
+	fakeKubeClient := &fake.Clientset{}
 	kubelet := &Kubelet{}
 	kubelet.kubeClient = fakeKubeClient
 	kubelet.os = kubecontainer.FakeOS{}
@ -2540,7 +2542,7 @@ func TestUpdateNewNodeStatus(t *testing.T) {
 	fakeRuntime.RuntimeType = "docker"
 	fakeRuntime.VersionInfo = "1.5.0"
 	kubeClient := testKubelet.fakeKubeClient
-	kubeClient.ReactionChain = testclient.NewSimpleFake(&api.NodeList{Items: []api.Node{
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.NodeList{Items: []api.Node{
 		{ObjectMeta: api.ObjectMeta{Name: testKubeletHostname}},
 	}}).ReactionChain
 	machineInfo := &cadvisorapi.MachineInfo{
@ -2663,7 +2665,7 @@ func TestUpdateNewNodeOutOfDiskStatusWithTransitionFrequency(t *testing.T) {
 	testKubelet := newTestKubelet(t)
 	kubelet := testKubelet.kubelet
 	kubeClient := testKubelet.fakeKubeClient
-	kubeClient.ReactionChain = testclient.NewSimpleFake(&api.NodeList{Items: []api.Node{
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.NodeList{Items: []api.Node{
 		{ObjectMeta: api.ObjectMeta{Name: testKubeletHostname}},
 	}}).ReactionChain
 	machineInfo := &cadvisorapi.MachineInfo{
@ -2742,7 +2744,7 @@ func TestDockerRuntimeVersion(t *testing.T) {
 	fakeRuntime.VersionInfo = "1.10.0-rc1-fc24"
 	fakeRuntime.APIVersionInfo = "1.22"
 	kubeClient := testKubelet.fakeKubeClient
-	kubeClient.ReactionChain = testclient.NewSimpleFake(&api.NodeList{Items: []api.Node{
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.NodeList{Items: []api.Node{
 		{
 			ObjectMeta: api.ObjectMeta{Name: testKubeletHostname},
 			Spec:       api.NodeSpec{},
@ -2926,7 +2928,7 @@ func TestUpdateExistingNodeStatus(t *testing.T) {
 	fakeRuntime.RuntimeType = "docker"
 	fakeRuntime.VersionInfo = "1.5.0"
 	kubeClient := testKubelet.fakeKubeClient
-	kubeClient.ReactionChain = testclient.NewSimpleFake(&api.NodeList{Items: []api.Node{
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.NodeList{Items: []api.Node{
 		{
 			ObjectMeta: api.ObjectMeta{Name: testKubeletHostname},
 			Spec:       api.NodeSpec{},
@ -3085,7 +3087,7 @@ func TestUpdateExistingNodeOutOfDiskStatusWithTransitionFrequency(t *testing.T)
 	kubelet := testKubelet.kubelet
 	clock := testKubelet.fakeClock
 	kubeClient := testKubelet.fakeKubeClient
-	kubeClient.ReactionChain = testclient.NewSimpleFake(&api.NodeList{Items: []api.Node{
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.NodeList{Items: []api.Node{
 		{
 			ObjectMeta: api.ObjectMeta{Name: testKubeletHostname},
 			Spec:       api.NodeSpec{},
@ -3239,7 +3241,7 @@ func TestUpdateNodeStatusWithoutContainerRuntime(t *testing.T) {
 	fakeRuntime := testKubelet.fakeRuntime
 	fakeRuntime.RuntimeType = "docker"
 	fakeRuntime.VersionInfo = "1.5.0"
-	kubeClient.ReactionChain = testclient.NewSimpleFake(&api.NodeList{Items: []api.Node{
+	kubeClient.ReactionChain = fake.NewSimpleClientset(&api.NodeList{Items: []api.Node{
 		{ObjectMeta: api.ObjectMeta{Name: testKubeletHostname}},
 	}}).ReactionChain
 	mockCadvisor := testKubelet.fakeCadvisor
@ -3363,7 +3365,7 @@ func TestUpdateNodeStatusError(t *testing.T) {
 	testKubelet := newTestKubelet(t)
 	kubelet := testKubelet.kubelet
 	// No matching node for the kubelet
-	testKubelet.fakeKubeClient.ReactionChain = testclient.NewSimpleFake(&api.NodeList{Items: []api.Node{}}).ReactionChain
+	testKubelet.fakeKubeClient.ReactionChain = fake.NewSimpleClientset(&api.NodeList{Items: []api.Node{}}).ReactionChain

 	if err := kubelet.updateNodeStatus(); err == nil {
 		t.Errorf("unexpected non error: %v", err)
@ -3727,20 +3729,20 @@ func TestRegisterExistingNodeWithApiserver(t *testing.T) {
 	testKubelet := newTestKubelet(t)
 	kubelet := testKubelet.kubelet
 	kubeClient := testKubelet.fakeKubeClient
-	kubeClient.AddReactor("create", "nodes", func(action testclient.Action) (bool, runtime.Object, error) {
+	kubeClient.AddReactor("create", "nodes", func(action core.Action) (bool, runtime.Object, error) {
 		// Return an error on create.
 		return true, &api.Node{}, &apierrors.StatusError{
 			ErrStatus: unversioned.Status{Reason: unversioned.StatusReasonAlreadyExists},
 		}
 	})
-	kubeClient.AddReactor("get", "nodes", func(action testclient.Action) (bool, runtime.Object, error) {
+	kubeClient.AddReactor("get", "nodes", func(action core.Action) (bool, runtime.Object, error) {
 		// Return an existing (matching) node on get.
 		return true, &api.Node{
 			ObjectMeta: api.ObjectMeta{Name: testKubeletHostname},
 			Spec:       api.NodeSpec{ExternalID: testKubeletHostname},
 		}, nil
 	})
-	kubeClient.AddReactor("*", "*", func(action testclient.Action) (bool, runtime.Object, error) {
+	kubeClient.AddReactor("*", "*", func(action core.Action) (bool, runtime.Object, error) {
 		return true, nil, fmt.Errorf("no reaction implemented for %s", action)
 	})
 	machineInfo := &cadvisorapi.MachineInfo{
--- a/pkg/kubelet/network/cni/cni_test.go
+++ b/pkg/kubelet/network/cni/cni_test.go
@ -28,12 +28,13 @@ import (
 	"testing"
 	"text/template"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	docker "github.com/fsouza/go-dockerclient"
 	cadvisorapi "github.com/google/cadvisor/info/v1"

 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/record"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
 	"k8s.io/kubernetes/pkg/kubelet/network"
@ -111,10 +112,10 @@ func tearDownPlugin(tmpDir string) {
 }

 type fakeNetworkHost struct {
-	kubeClient client.Interface
+	kubeClient clientset.Interface
 }

-func NewFakeHost(kubeClient client.Interface) *fakeNetworkHost {
+func NewFakeHost(kubeClient clientset.Interface) *fakeNetworkHost {
 	host := &fakeNetworkHost{kubeClient: kubeClient}
 	return host
 }
@ -123,7 +124,7 @@ func (fnh *fakeNetworkHost) GetPodByName(name, namespace string) (*api.Pod, bool
 	return nil, false
 }

-func (fnh *fakeNetworkHost) GetKubeClient() client.Interface {
+func (fnh *fakeNetworkHost) GetKubeClient() clientset.Interface {
 	return nil
 }

--- a/pkg/kubelet/network/plugins.go
+++ b/pkg/kubelet/network/plugins.go
@ -21,10 +21,11 @@ import (
 	"net"
 	"strings"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 	"k8s.io/kubernetes/pkg/util/validation"
@ -72,7 +73,7 @@ type Host interface {
 	GetPodByName(namespace, name string) (*api.Pod, bool)

 	// GetKubeClient returns a client interface
-	GetKubeClient() client.Interface
+	GetKubeClient() clientset.Interface

 	// GetContainerRuntime returns the container runtime that implements the containers (e.g. docker/rkt)
 	GetRuntime() kubecontainer.Runtime
--- a/pkg/kubelet/network/testing.go
+++ b/pkg/kubelet/network/testing.go
@ -21,15 +21,15 @@ package network

 import (
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 )

 type fakeNetworkHost struct {
-	kubeClient client.Interface
+	kubeClient clientset.Interface
 }

-func NewFakeHost(kubeClient client.Interface) *fakeNetworkHost {
+func NewFakeHost(kubeClient clientset.Interface) *fakeNetworkHost {
 	host := &fakeNetworkHost{kubeClient: kubeClient}
 	return host
 }
@ -38,7 +38,7 @@ func (fnh *fakeNetworkHost) GetPodByName(name, namespace string) (*api.Pod, bool
 	return nil, false
 }

-func (fnh *fakeNetworkHost) GetKubeClient() client.Interface {
+func (fnh *fakeNetworkHost) GetKubeClient() clientset.Interface {
 	return nil
 }

--- a/pkg/kubelet/networks.go
+++ b/pkg/kubelet/networks.go
@ -18,7 +18,7 @@ package kubelet

 import (
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 )

@ -32,7 +32,7 @@ func (nh *networkHost) GetPodByName(name, namespace string) (*api.Pod, bool) {
 	return nh.kubelet.GetPodByName(name, namespace)
 }

-func (nh *networkHost) GetKubeClient() client.Interface {
+func (nh *networkHost) GetKubeClient() clientset.Interface {
 	return nh.kubelet.kubeClient
 }

--- a/pkg/kubelet/pod/mirror_client.go
+++ b/pkg/kubelet/pod/mirror_client.go
@ -20,7 +20,7 @@ import (
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
 )
@ -34,10 +34,10 @@ type MirrorClient interface {
 type basicMirrorClient struct {
 	// mirror pods are stored in the kubelet directly because they need to be
 	// in sync with the internal pods.
-	apiserverClient client.Interface
+	apiserverClient clientset.Interface
 }

-func NewBasicMirrorClient(apiserverClient client.Interface) MirrorClient {
+func NewBasicMirrorClient(apiserverClient clientset.Interface) MirrorClient {
 	return &basicMirrorClient{apiserverClient: apiserverClient}
 }

@ -55,7 +55,7 @@ func (mc *basicMirrorClient) CreateMirrorPod(pod *api.Pod) error {
 	}
 	hash := getPodHash(pod)
 	copyPod.Annotations[kubetypes.ConfigMirrorAnnotationKey] = hash
-	apiPod, err := mc.apiserverClient.Pods(copyPod.Namespace).Create(&copyPod)
+	apiPod, err := mc.apiserverClient.Legacy().Pods(copyPod.Namespace).Create(&copyPod)
 	if err != nil && errors.IsAlreadyExists(err) {
 		// Check if the existing pod is the same as the pod we want to create.
 		if h, ok := apiPod.Annotations[kubetypes.ConfigMirrorAnnotationKey]; ok && h == hash {
@ -76,7 +76,7 @@ func (mc *basicMirrorClient) DeleteMirrorPod(podFullName string) error {
 		return err
 	}
 	glog.V(4).Infof("Deleting a mirror pod %q", podFullName)
-	if err := mc.apiserverClient.Pods(namespace).Delete(name, api.NewDeleteOptions(0)); err != nil && !errors.IsNotFound(err) {
+	if err := mc.apiserverClient.Legacy().Pods(namespace).Delete(name, api.NewDeleteOptions(0)); err != nil && !errors.IsNotFound(err) {
 		glog.Errorf("Failed deleting a mirror pod %q: %v", podFullName, err)
 	}
 	return nil
--- a/pkg/kubelet/prober/testing.go
+++ b/pkg/kubelet/prober/testing.go
@ -23,7 +23,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/client/record"
-	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	kubepod "k8s.io/kubernetes/pkg/kubelet/pod"
 	"k8s.io/kubernetes/pkg/kubelet/prober/results"
@ -97,7 +97,7 @@ func newTestManager() *manager {
 	refManager := kubecontainer.NewRefManager()
 	refManager.SetRef(testContainerID, &api.ObjectReference{}) // Suppress prober warnings.
 	m := NewManager(
-		status.NewManager(&testclient.Fake{}, kubepod.NewBasicPodManager(nil)),
+		status.NewManager(&fake.Clientset{}, kubepod.NewBasicPodManager(nil)),
 		results.NewManager(),
 		nil, // runner
 		refManager,
--- a/pkg/kubelet/prober/worker_test.go
+++ b/pkg/kubelet/prober/worker_test.go
@ -24,7 +24,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/client/record"
-	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	kubepod "k8s.io/kubernetes/pkg/kubelet/pod"
 	"k8s.io/kubernetes/pkg/kubelet/prober/results"
@ -118,7 +118,7 @@ func TestDoProbe(t *testing.T) {
 			}

 			// Clean up.
-			m.statusManager = status.NewManager(&testclient.Fake{}, kubepod.NewBasicPodManager(nil))
+			m.statusManager = status.NewManager(&fake.Clientset{}, kubepod.NewBasicPodManager(nil))
 			resultsManager(m, probeType).Remove(testContainerID)
 		}
 	}
--- a/pkg/kubelet/status/manager.go
+++ b/pkg/kubelet/status/manager.go
@ -21,11 +21,12 @@ import (
 	"sync"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	kubepod "k8s.io/kubernetes/pkg/kubelet/pod"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
@ -53,7 +54,7 @@ type podStatusSyncRequest struct {
 // Updates pod statuses in apiserver. Writes only when new status has changed.
 // All methods are thread-safe.
 type manager struct {
-	kubeClient client.Interface
+	kubeClient clientset.Interface
 	podManager kubepod.Manager
 	// Map from pod UID to sync status of the corresponding pod.
 	podStatuses      map[types.UID]versionedPodStatus
@ -93,7 +94,7 @@ type Manager interface {

 const syncPeriod = 10 * time.Second

-func NewManager(kubeClient client.Interface, podManager kubepod.Manager) Manager {
+func NewManager(kubeClient clientset.Interface, podManager kubepod.Manager) Manager {
 	return &manager{
 		kubeClient:        kubeClient,
 		podManager:        podManager,
@ -346,7 +347,7 @@ func (m *manager) syncBatch() {
 // syncPod syncs the given status with the API server. The caller must not hold the lock.
 func (m *manager) syncPod(uid types.UID, status versionedPodStatus) {
 	// TODO: make me easier to express from client code
-	pod, err := m.kubeClient.Pods(status.podNamespace).Get(status.podName)
+	pod, err := m.kubeClient.Legacy().Pods(status.podNamespace).Get(status.podName)
 	if errors.IsNotFound(err) {
 		glog.V(3).Infof("Pod %q (%s) does not exist on the server", status.podName, uid)
 		// If the Pod is deleted the status will be cleared in
@ -366,7 +367,7 @@ func (m *manager) syncPod(uid types.UID, status versionedPodStatus) {
 		}
 		pod.Status = status.status
 		// TODO: handle conflict as a retry, make that easier too.
-		pod, err = m.kubeClient.Pods(pod.Namespace).UpdateStatus(pod)
+		pod, err = m.kubeClient.Legacy().Pods(pod.Namespace).UpdateStatus(pod)
 		if err == nil {
 			glog.V(3).Infof("Status for pod %q updated successfully: %+v", format.Pod(pod), status)
 			m.apiStatusVersions[pod.UID] = status.version
@ -381,7 +382,7 @@ func (m *manager) syncPod(uid types.UID, status versionedPodStatus) {
 				glog.V(3).Infof("Pod %q is terminated, but some containers are still running", format.Pod(pod))
 				return
 			}
-			if err := m.kubeClient.Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err == nil {
+			if err := m.kubeClient.Legacy().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err == nil {
 				glog.V(3).Infof("Pod %q fully terminated and removed from etcd", format.Pod(pod))
 				m.deletePodStatus(uid)
 				return
--- a/pkg/kubelet/status/manager_test.go
+++ b/pkg/kubelet/status/manager_test.go
@ -23,13 +23,15 @@ import (
 	"testing"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+	"k8s.io/kubernetes/pkg/client/testing/core"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
+
 	"github.com/stretchr/testify/assert"

 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
-	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	kubepod "k8s.io/kubernetes/pkg/kubelet/pod"
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
@ -65,7 +67,7 @@ func (m *manager) testSyncBatch() {
 	m.syncBatch()
 }

-func newTestManager(kubeClient client.Interface) *manager {
+func newTestManager(kubeClient clientset.Interface) *manager {
 	podManager := kubepod.NewBasicPodManager(kubepod.NewFakeMirrorClient())
 	podManager.AddPod(getTestPod())
 	return NewManager(kubeClient, podManager).(*manager)
@ -81,8 +83,8 @@ func getRandomPodStatus() api.PodStatus {
 	}
 }

-func verifyActions(t *testing.T, kubeClient client.Interface, expectedActions []testclient.Action) {
-	actions := kubeClient.(*testclient.Fake).Actions()
+func verifyActions(t *testing.T, kubeClient clientset.Interface, expectedActions []core.Action) {
+	actions := kubeClient.(*fake.Clientset).Actions()
 	if len(actions) != len(expectedActions) {
 		t.Fatalf("unexpected actions, got: %+v expected: %+v", actions, expectedActions)
 		return
@ -119,7 +121,7 @@ func verifyUpdates(t *testing.T, manager *manager, expectedUpdates int) {
 }

 func TestNewStatus(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	testPod := getTestPod()
 	syncer.SetPodStatus(testPod, getRandomPodStatus())
 	verifyUpdates(t, syncer, 1)
@ -131,7 +133,7 @@ func TestNewStatus(t *testing.T) {
 }

 func TestNewStatusPreservesPodStartTime(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	pod := &api.Pod{
 		ObjectMeta: api.ObjectMeta{
 			UID:       "12345678",
@ -163,7 +165,7 @@ func getReadyPodStatus() api.PodStatus {
 }

 func TestNewStatusSetsReadyTransitionTime(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	podStatus := getReadyPodStatus()
 	pod := &api.Pod{
 		ObjectMeta: api.ObjectMeta{
@ -183,7 +185,7 @@ func TestNewStatusSetsReadyTransitionTime(t *testing.T) {
 }

 func TestChangedStatus(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	testPod := getTestPod()
 	syncer.SetPodStatus(testPod, getRandomPodStatus())
 	syncer.SetPodStatus(testPod, getRandomPodStatus())
@ -191,7 +193,7 @@ func TestChangedStatus(t *testing.T) {
 }

 func TestChangedStatusKeepsStartTime(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	testPod := getTestPod()
 	now := unversioned.Now()
 	firstStatus := getRandomPodStatus()
@ -209,7 +211,7 @@ func TestChangedStatusKeepsStartTime(t *testing.T) {
 }

 func TestChangedStatusUpdatesLastTransitionTime(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	podStatus := getReadyPodStatus()
 	pod := &api.Pod{
 		ObjectMeta: api.ObjectMeta{
@ -239,7 +241,7 @@ func TestChangedStatusUpdatesLastTransitionTime(t *testing.T) {
 }

 func TestUnchangedStatus(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	testPod := getTestPod()
 	podStatus := getRandomPodStatus()
 	syncer.SetPodStatus(testPod, podStatus)
@ -248,7 +250,7 @@ func TestUnchangedStatus(t *testing.T) {
 }

 func TestUnchangedStatusPreservesLastTransitionTime(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	podStatus := getReadyPodStatus()
 	pod := &api.Pod{
 		ObjectMeta: api.ObjectMeta{
@ -278,61 +280,61 @@ func TestUnchangedStatusPreservesLastTransitionTime(t *testing.T) {
 }

 func TestSyncBatchIgnoresNotFound(t *testing.T) {
-	client := testclient.Fake{}
+	client := fake.Clientset{}
 	syncer := newTestManager(&client)
-	client.AddReactor("get", "pods", func(action testclient.Action) (bool, runtime.Object, error) {
+	client.AddReactor("get", "pods", func(action core.Action) (bool, runtime.Object, error) {
 		return true, nil, errors.NewNotFound(api.Resource("pods"), "test-pod")
 	})
 	syncer.SetPodStatus(getTestPod(), getRandomPodStatus())
 	syncer.testSyncBatch()

-	verifyActions(t, syncer.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
+	verifyActions(t, syncer.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
 	})
 }

 func TestSyncBatch(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	testPod := getTestPod()
-	syncer.kubeClient = testclient.NewSimpleFake(testPod)
+	syncer.kubeClient = fake.NewSimpleClientset(testPod)
 	syncer.SetPodStatus(testPod, getRandomPodStatus())
 	syncer.testSyncBatch()
-	verifyActions(t, syncer.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
-		testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
+	verifyActions(t, syncer.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
+		core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
 	},
 	)
 }

 func TestSyncBatchChecksMismatchedUID(t *testing.T) {
-	syncer := newTestManager(&testclient.Fake{})
+	syncer := newTestManager(&fake.Clientset{})
 	pod := getTestPod()
 	pod.UID = "first"
 	syncer.podManager.AddPod(pod)
 	differentPod := getTestPod()
 	differentPod.UID = "second"
 	syncer.podManager.AddPod(differentPod)
-	syncer.kubeClient = testclient.NewSimpleFake(pod)
+	syncer.kubeClient = fake.NewSimpleClientset(pod)
 	syncer.SetPodStatus(differentPod, getRandomPodStatus())
 	syncer.testSyncBatch()
-	verifyActions(t, syncer.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
+	verifyActions(t, syncer.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
 	})
 }

 func TestSyncBatchNoDeadlock(t *testing.T) {
-	client := &testclient.Fake{}
+	client := &fake.Clientset{}
 	m := newTestManager(client)
 	pod := getTestPod()

 	// Setup fake client.
 	var ret api.Pod
 	var err error
-	client.AddReactor("*", "pods", func(action testclient.Action) (bool, runtime.Object, error) {
+	client.AddReactor("*", "pods", func(action core.Action) (bool, runtime.Object, error) {
 		switch action := action.(type) {
-		case testclient.GetAction:
+		case core.GetAction:
 			assert.Equal(t, pod.Name, action.GetName(), "Unexpeted GetAction: %+v", action)
-		case testclient.UpdateAction:
+		case core.UpdateAction:
 			assert.Equal(t, pod.Name, action.GetObject().(*api.Pod).Name, "Unexpeted UpdateAction: %+v", action)
 		default:
 			assert.Fail(t, "Unexpected Action: %+v", action)
@ -342,15 +344,15 @@ func TestSyncBatchNoDeadlock(t *testing.T) {

 	pod.Status.ContainerStatuses = []api.ContainerStatus{{State: api.ContainerState{Running: &api.ContainerStateRunning{}}}}

-	getAction := testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}}
-	updateAction := testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}}
+	getAction := core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}}
+	updateAction := core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}}

 	// Pod not found.
 	ret = *pod
 	err = errors.NewNotFound(api.Resource("pods"), pod.Name)
 	m.SetPodStatus(pod, getRandomPodStatus())
 	m.testSyncBatch()
-	verifyActions(t, client, []testclient.Action{getAction})
+	verifyActions(t, client, []core.Action{getAction})
 	client.ClearActions()

 	// Pod was recreated.
@ -358,21 +360,21 @@ func TestSyncBatchNoDeadlock(t *testing.T) {
 	err = nil
 	m.SetPodStatus(pod, getRandomPodStatus())
 	m.testSyncBatch()
-	verifyActions(t, client, []testclient.Action{getAction})
+	verifyActions(t, client, []core.Action{getAction})
 	client.ClearActions()

 	// Pod not deleted (success case).
 	ret = *pod
 	m.SetPodStatus(pod, getRandomPodStatus())
 	m.testSyncBatch()
-	verifyActions(t, client, []testclient.Action{getAction, updateAction})
+	verifyActions(t, client, []core.Action{getAction, updateAction})
 	client.ClearActions()

 	// Pod is terminated, but still running.
 	pod.DeletionTimestamp = new(unversioned.Time)
 	m.SetPodStatus(pod, getRandomPodStatus())
 	m.testSyncBatch()
-	verifyActions(t, client, []testclient.Action{getAction, updateAction})
+	verifyActions(t, client, []core.Action{getAction, updateAction})
 	client.ClearActions()

 	// Pod is terminated successfully.
@ -380,20 +382,20 @@ func TestSyncBatchNoDeadlock(t *testing.T) {
 	pod.Status.ContainerStatuses[0].State.Terminated = &api.ContainerStateTerminated{}
 	m.SetPodStatus(pod, getRandomPodStatus())
 	m.testSyncBatch()
-	verifyActions(t, client, []testclient.Action{getAction, updateAction})
+	verifyActions(t, client, []core.Action{getAction, updateAction})
 	client.ClearActions()

 	// Error case.
 	err = fmt.Errorf("intentional test error")
 	m.SetPodStatus(pod, getRandomPodStatus())
 	m.testSyncBatch()
-	verifyActions(t, client, []testclient.Action{getAction})
+	verifyActions(t, client, []core.Action{getAction})
 	client.ClearActions()
 }

 func TestStaleUpdates(t *testing.T) {
 	pod := getTestPod()
-	client := testclient.NewSimpleFake(pod)
+	client := fake.NewSimpleClientset(pod)
 	m := newTestManager(client)

 	status := api.PodStatus{Message: "initial status"}
@ -406,16 +408,16 @@ func TestStaleUpdates(t *testing.T) {

 	t.Logf("First sync pushes latest status.")
 	m.testSyncBatch()
-	verifyActions(t, m.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
-		testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
+	verifyActions(t, m.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
+		core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
 	})
 	client.ClearActions()

 	for i := 0; i < 2; i++ {
 		t.Logf("Next 2 syncs should be ignored (%d).", i)
 		m.testSyncBatch()
-		verifyActions(t, m.kubeClient, []testclient.Action{})
+		verifyActions(t, m.kubeClient, []core.Action{})
 	}

 	t.Log("Unchanged status should not send an update.")
@ -427,9 +429,9 @@ func TestStaleUpdates(t *testing.T) {

 	m.SetPodStatus(pod, status)
 	m.testSyncBatch()
-	verifyActions(t, m.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
-		testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
+	verifyActions(t, m.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
+		core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
 	})

 	// Nothing stuck in the pipe.
@ -477,7 +479,7 @@ func TestStaticPodStatus(t *testing.T) {
 		kubetypes.ConfigSourceAnnotationKey: "api",
 		kubetypes.ConfigMirrorAnnotationKey: "mirror",
 	}
-	client := testclient.NewSimpleFake(mirrorPod)
+	client := fake.NewSimpleClientset(mirrorPod)
 	m := newTestManager(client)
 	m.podManager.AddPod(staticPod)
 	m.podManager.AddPod(mirrorPod)
@ -497,11 +499,11 @@ func TestStaticPodStatus(t *testing.T) {
 	assert.True(t, isStatusEqual(&status, &retrievedStatus), "Expected: %+v, Got: %+v", status, retrievedStatus)
 	// Should translate mirrorPod / staticPod UID.
 	m.testSyncBatch()
-	verifyActions(t, m.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
-		testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
+	verifyActions(t, m.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
+		core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
 	})
-	updateAction := client.Actions()[1].(testclient.UpdateActionImpl)
+	updateAction := client.Actions()[1].(core.UpdateActionImpl)
 	updatedPod := updateAction.Object.(*api.Pod)
 	assert.Equal(t, mirrorPod.UID, updatedPod.UID, "Expected mirrorPod (%q), but got %q", mirrorPod.UID, updatedPod.UID)
 	assert.True(t, isStatusEqual(&status, &updatedPod.Status), "Expected: %+v, Got: %+v", status, updatedPod.Status)
@ -509,7 +511,7 @@ func TestStaticPodStatus(t *testing.T) {

 	// No changes.
 	m.testSyncBatch()
-	verifyActions(t, m.kubeClient, []testclient.Action{})
+	verifyActions(t, m.kubeClient, []core.Action{})

 	// Mirror pod identity changes.
 	m.podManager.DeletePod(mirrorPod)
@ -518,11 +520,11 @@ func TestStaticPodStatus(t *testing.T) {
 	m.podManager.AddPod(mirrorPod)
 	// Expect update to new mirrorPod.
 	m.testSyncBatch()
-	verifyActions(t, m.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
-		testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
+	verifyActions(t, m.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
+		core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
 	})
-	updateAction = client.Actions()[1].(testclient.UpdateActionImpl)
+	updateAction = client.Actions()[1].(core.UpdateActionImpl)
 	updatedPod = updateAction.Object.(*api.Pod)
 	assert.Equal(t, mirrorPod.UID, updatedPod.UID, "Expected mirrorPod (%q), but got %q", mirrorPod.UID, updatedPod.UID)
 	assert.True(t, isStatusEqual(&status, &updatedPod.Status), "Expected: %+v, Got: %+v", status, updatedPod.Status)
@ -575,7 +577,7 @@ func TestSetContainerReadiness(t *testing.T) {
 		}
 	}

-	m := newTestManager(&testclient.Fake{})
+	m := newTestManager(&fake.Clientset{})

 	t.Log("Setting readiness before status should fail.")
 	m.SetContainerReadiness(pod, cID1, true)
@ -616,7 +618,7 @@ func TestSetContainerReadiness(t *testing.T) {
 }

 func TestSyncBatchCleanupVersions(t *testing.T) {
-	m := newTestManager(&testclient.Fake{})
+	m := newTestManager(&fake.Clientset{})
 	testPod := getTestPod()
 	mirrorPod := getTestPod()
 	mirrorPod.UID = "mirror-uid"
@ -657,7 +659,7 @@ func TestSyncBatchCleanupVersions(t *testing.T) {

 func TestReconcilePodStatus(t *testing.T) {
 	testPod := getTestPod()
-	client := testclient.NewSimpleFake(testPod)
+	client := fake.NewSimpleClientset(testPod)
 	syncer := newTestManager(client)
 	syncer.SetPodStatus(testPod, getRandomPodStatus())
 	// Call syncBatch directly to test reconcile
@ -677,7 +679,7 @@ func TestReconcilePodStatus(t *testing.T) {
 	}
 	client.ClearActions()
 	syncer.syncBatch()
-	verifyActions(t, client, []testclient.Action{})
+	verifyActions(t, client, []core.Action{})

 	// If the pod status is the same, only the timestamp is in Rfc3339 format (lower precision without nanosecond),
 	// a reconciliation is not needed, syncBatch should do nothing.
@ -691,7 +693,7 @@ func TestReconcilePodStatus(t *testing.T) {
 	}
 	client.ClearActions()
 	syncer.syncBatch()
-	verifyActions(t, client, []testclient.Action{})
+	verifyActions(t, client, []core.Action{})

 	// If the pod status is different, a reconciliation is needed, syncBatch should trigger an update
 	testPod.Status = getRandomPodStatus()
@ -701,9 +703,9 @@ func TestReconcilePodStatus(t *testing.T) {
 	}
 	client.ClearActions()
 	syncer.syncBatch()
-	verifyActions(t, client, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
-		testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
+	verifyActions(t, client, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
+		core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
 	})
 }

@ -719,7 +721,7 @@ func TestDeletePods(t *testing.T) {
 	pod := getTestPod()
 	// Set the deletion timestamp.
 	pod.DeletionTimestamp = new(unversioned.Time)
-	client := testclient.NewSimpleFake(pod)
+	client := fake.NewSimpleClientset(pod)
 	m := newTestManager(client)
 	m.podManager.AddPod(pod)

@ -730,10 +732,10 @@ func TestDeletePods(t *testing.T) {

 	m.testSyncBatch()
 	// Expect to see an delete action.
-	verifyActions(t, m.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
-		testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
-		testclient.DeleteActionImpl{ActionImpl: testclient.ActionImpl{Verb: "delete", Resource: "pods"}},
+	verifyActions(t, m.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
+		core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
+		core.DeleteActionImpl{ActionImpl: core.ActionImpl{Verb: "delete", Resource: "pods"}},
 	})
 }

@ -748,7 +750,7 @@ func TestDoNotDeleteMirrorPods(t *testing.T) {
 	}
 	// Set the deletion timestamp.
 	mirrorPod.DeletionTimestamp = new(unversioned.Time)
-	client := testclient.NewSimpleFake(mirrorPod)
+	client := fake.NewSimpleClientset(mirrorPod)
 	m := newTestManager(client)
 	m.podManager.AddPod(staticPod)
 	m.podManager.AddPod(mirrorPod)
@ -764,8 +766,8 @@ func TestDoNotDeleteMirrorPods(t *testing.T) {

 	m.testSyncBatch()
 	// Expect not to see an delete action.
-	verifyActions(t, m.kubeClient, []testclient.Action{
-		testclient.GetActionImpl{ActionImpl: testclient.ActionImpl{Verb: "get", Resource: "pods"}},
-		testclient.UpdateActionImpl{ActionImpl: testclient.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
+	verifyActions(t, m.kubeClient, []core.Action{
+		core.GetActionImpl{ActionImpl: core.ActionImpl{Verb: "get", Resource: "pods"}},
+		core.UpdateActionImpl{ActionImpl: core.ActionImpl{Verb: "update", Resource: "pods", Subresource: "status"}},
 	})
 }
--- a/pkg/kubelet/volumes.go
+++ b/pkg/kubelet/volumes.go
@ -55,7 +55,7 @@ func (vh *volumeHost) GetPodPluginDir(podUID types.UID, pluginName string) strin
 }

 func (vh *volumeHost) GetKubeClient() clientset.Interface {
-	return vh.kubelet.clientset
+	return vh.kubelet.kubeClient
 }

 func (vh *volumeHost) NewWrapperBuilder(volName string, spec volume.Spec, pod *api.Pod, opts volume.VolumeOptions) (volume.Builder, error) {
--- a/pkg/kubemark/hollow_kubelet.go
+++ b/pkg/kubemark/hollow_kubelet.go
@ -21,7 +21,7 @@ import (

 	kubeletapp "k8s.io/kubernetes/cmd/kubelet/app"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
 	"k8s.io/kubernetes/pkg/kubelet/cadvisor"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
@ -38,7 +38,7 @@ type HollowKubelet struct {

 func NewHollowKubelet(
 	nodeName string,
-	client *client.Client,
+	client *clientset.Clientset,
 	cadvisorInterface cadvisor.Interface,
 	dockerClient dockertools.DockerInterface,
 	kubeletPort, kubeletReadOnlyPort int,
--- a/plugin/pkg/admission/admit/admission.go
+++ b/plugin/pkg/admission/admit/admission.go
@ -19,12 +19,13 @@ package admit
 import (
 	"io"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 func init() {
-	admission.RegisterPlugin("AlwaysAdmit", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("AlwaysAdmit", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewAlwaysAdmit(), nil
 	})
 }
--- a/plugin/pkg/admission/alwayspullimages/admission.go
+++ b/plugin/pkg/admission/alwayspullimages/admission.go
@ -27,14 +27,15 @@ package alwayspullimages
 import (
 	"io"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 func init() {
-	admission.RegisterPlugin("AlwaysPullImages", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("AlwaysPullImages", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewAlwaysPullImages(), nil
 	})
 }
--- a/plugin/pkg/admission/deny/admission.go
+++ b/plugin/pkg/admission/deny/admission.go
@ -20,12 +20,13 @@ import (
 	"errors"
 	"io"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 func init() {
-	admission.RegisterPlugin("AlwaysDeny", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("AlwaysDeny", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewAlwaysDeny(), nil
 	})
 }
--- a/plugin/pkg/admission/exec/admission.go
+++ b/plugin/pkg/admission/exec/admission.go
@ -20,21 +20,22 @@ import (
 	"fmt"
 	"io"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/rest"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 func init() {
-	admission.RegisterPlugin("DenyEscalatingExec", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("DenyEscalatingExec", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewDenyEscalatingExec(client), nil
 	})

 	// This is for legacy support of the DenyExecOnPrivileged admission controller.  Most
 	// of the time DenyEscalatingExec should be preferred.
-	admission.RegisterPlugin("DenyExecOnPrivileged", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("DenyExecOnPrivileged", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewDenyExecOnPrivileged(client), nil
 	})
 }
@ -43,7 +44,7 @@ func init() {
 // a pod using host based configurations.
 type denyExec struct {
 	*admission.Handler
-	client client.Interface
+	client clientset.Interface

 	// these flags control which items will be checked to deny exec/attach
 	hostIPC    bool
@ -53,7 +54,7 @@ type denyExec struct {

 // NewDenyEscalatingExec creates a new admission controller that denies an exec operation on a pod
 // using host based configurations.
-func NewDenyEscalatingExec(client client.Interface) admission.Interface {
+func NewDenyEscalatingExec(client clientset.Interface) admission.Interface {
 	return &denyExec{
 		Handler:    admission.NewHandler(admission.Connect),
 		client:     client,
@ -66,7 +67,7 @@ func NewDenyEscalatingExec(client client.Interface) admission.Interface {
 // NewDenyExecOnPrivileged creates a new admission controller that is only checking the privileged
 // option.  This is for legacy support of the DenyExecOnPrivileged admission controller.  Most
 // of the time NewDenyEscalatingExec should be preferred.
-func NewDenyExecOnPrivileged(client client.Interface) admission.Interface {
+func NewDenyExecOnPrivileged(client clientset.Interface) admission.Interface {
 	return &denyExec{
 		Handler:    admission.NewHandler(admission.Connect),
 		client:     client,
@ -85,7 +86,7 @@ func (d *denyExec) Admit(a admission.Attributes) (err error) {
 	if connectRequest.ResourcePath != "pods/exec" && connectRequest.ResourcePath != "pods/attach" {
 		return nil
 	}
-	pod, err := d.client.Pods(a.GetNamespace()).Get(connectRequest.Name)
+	pod, err := d.client.Legacy().Pods(a.GetNamespace()).Get(connectRequest.Name)
 	if err != nil {
 		return admission.NewForbidden(a, err)
 	}
--- a/plugin/pkg/admission/exec/admission_test.go
+++ b/plugin/pkg/admission/exec/admission_test.go
@ -22,6 +22,8 @@ import (
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/rest"
+	"k8s.io/kubernetes/pkg/client/testing/core"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
 	"k8s.io/kubernetes/pkg/runtime"
 )
@ -87,8 +89,8 @@ func TestAdmission(t *testing.T) {
 }

 func testAdmission(t *testing.T, pod *api.Pod, handler *denyExec, shouldAccept bool) {
-	mockClient := &testclient.Fake{}
-	mockClient.AddReactor("get", "pods", func(action testclient.Action) (bool, runtime.Object, error) {
+	mockClient := &fake.Clientset{}
+	mockClient.AddReactor("get", "pods", func(action core.Action) (bool, runtime.Object, error) {
 		if action.(testclient.GetAction).GetName() == pod.Name {
 			return true, pod, nil
 		}
--- a/plugin/pkg/admission/initialresources/admission.go
+++ b/plugin/pkg/admission/initialresources/admission.go
@ -23,12 +23,13 @@ import (
 	"strings"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/resource"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 var (
@ -46,7 +47,7 @@ const (

 // WARNING: this feature is experimental and will definitely change.
 func init() {
-	admission.RegisterPlugin("InitialResources", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("InitialResources", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		s, err := newDataSource(*source)
 		if err != nil {
 			return nil, err
--- a/plugin/pkg/admission/limitranger/admission.go
+++ b/plugin/pkg/admission/limitranger/admission.go
@ -22,12 +22,13 @@ import (
 	"sort"
 	"strings"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/meta"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/client/cache"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 	"k8s.io/kubernetes/pkg/watch"
@ -38,7 +39,7 @@ const (
 )

 func init() {
-	admission.RegisterPlugin("LimitRanger", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("LimitRanger", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewLimitRanger(client, Limit), nil
 	})
 }
@ -46,7 +47,7 @@ func init() {
 // limitRanger enforces usage limits on a per resource basis in the namespace
 type limitRanger struct {
 	*admission.Handler
-	client    client.Interface
+	client    clientset.Interface
 	limitFunc LimitFunc
 	indexer   cache.Indexer
 }
@ -94,13 +95,13 @@ func (l *limitRanger) Admit(a admission.Attributes) (err error) {
 }

 // NewLimitRanger returns an object that enforces limits based on the supplied limit function
-func NewLimitRanger(client client.Interface, limitFunc LimitFunc) admission.Interface {
+func NewLimitRanger(client clientset.Interface, limitFunc LimitFunc) admission.Interface {
 	lw := &cache.ListWatch{
 		ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-			return client.LimitRanges(api.NamespaceAll).List(options)
+			return client.Legacy().LimitRanges(api.NamespaceAll).List(options)
 		},
 		WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-			return client.LimitRanges(api.NamespaceAll).Watch(options)
+			return client.Legacy().LimitRanges(api.NamespaceAll).Watch(options)
 		},
 	}
 	indexer, reflector := cache.NewNamespaceKeyedIndexerAndReflector(lw, &api.LimitRange{}, 0)
--- a/plugin/pkg/admission/limitranger/admission_test.go
+++ b/plugin/pkg/admission/limitranger/admission_test.go
@ -24,7 +24,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/client/cache"
-	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 )

 func getResourceList(cpu, memory string) api.ResourceList {
@ -429,7 +429,7 @@ func TestPodLimitFuncApplyDefault(t *testing.T) {
 }

 func TestLimitRangerIgnoresSubresource(t *testing.T) {
-	client := testclient.NewSimpleFake()
+	client := fake.NewSimpleClientset()
 	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{"namespace": cache.MetaNamespaceIndexFunc})
 	handler := &limitRanger{
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
--- a/plugin/pkg/admission/namespace/autoprovision/admission.go
+++ b/plugin/pkg/admission/namespace/autoprovision/admission.go
@ -19,17 +19,18 @@ package autoprovision
 import (
 	"io"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/client/cache"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/watch"
 )

 func init() {
-	admission.RegisterPlugin("NamespaceAutoProvision", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("NamespaceAutoProvision", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewProvision(client), nil
 	})
 }
@ -39,7 +40,7 @@ func init() {
 // It is useful in deployments that do not want to restrict creation of a namespace prior to its usage.
 type provision struct {
 	*admission.Handler
-	client client.Interface
+	client clientset.Interface
 	store  cache.Store
 }

@ -65,7 +66,7 @@ func (p *provision) Admit(a admission.Attributes) (err error) {
 	if exists {
 		return nil
 	}
-	_, err = p.client.Namespaces().Create(namespace)
+	_, err = p.client.Legacy().Namespaces().Create(namespace)
 	if err != nil && !errors.IsAlreadyExists(err) {
 		return admission.NewForbidden(a, err)
 	}
@ -73,15 +74,15 @@ func (p *provision) Admit(a admission.Attributes) (err error) {
 }

 // NewProvision creates a new namespace provision admission control handler
-func NewProvision(c client.Interface) admission.Interface {
+func NewProvision(c clientset.Interface) admission.Interface {
 	store := cache.NewStore(cache.MetaNamespaceKeyFunc)
 	reflector := cache.NewReflector(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return c.Namespaces().List(options)
+				return c.Legacy().Namespaces().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return c.Namespaces().Watch(options)
+				return c.Legacy().Namespaces().Watch(options)
 			},
 		},
 		&api.Namespace{},
@ -92,7 +93,7 @@ func NewProvision(c client.Interface) admission.Interface {
 	return createProvision(c, store)
 }

-func createProvision(c client.Interface, store cache.Store) admission.Interface {
+func createProvision(c clientset.Interface, store cache.Store) admission.Interface {
 	return &provision{
 		Handler: admission.NewHandler(admission.Create),
 		client:  c,
--- a/plugin/pkg/admission/namespace/autoprovision/admission_test.go
+++ b/plugin/pkg/admission/namespace/autoprovision/admission_test.go
@ -23,14 +23,15 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/client/cache"
-	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
+	"k8s.io/kubernetes/pkg/client/testing/core"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 	"k8s.io/kubernetes/pkg/runtime"
 )

 // TestAdmission verifies a namespace is created on create requests for namespace managed resources
 func TestAdmission(t *testing.T) {
 	namespace := "test"
-	mockClient := &testclient.Fake{}
+	mockClient := &fake.Clientset{}
 	handler := &provision{
 		client: mockClient,
 		store:  cache.NewStore(cache.MetaNamespaceKeyFunc),
@ -58,7 +59,7 @@ func TestAdmission(t *testing.T) {
 // TestAdmissionNamespaceExists verifies that no client call is made when a namespace already exists
 func TestAdmissionNamespaceExists(t *testing.T) {
 	namespace := "test"
-	mockClient := &testclient.Fake{}
+	mockClient := &fake.Clientset{}
 	store := cache.NewStore(cache.MetaNamespaceKeyFunc)
 	store.Add(&api.Namespace{
 		ObjectMeta: api.ObjectMeta{Name: namespace},
@ -86,7 +87,7 @@ func TestAdmissionNamespaceExists(t *testing.T) {
 // TestIgnoreAdmission validates that a request is ignored if its not a create
 func TestIgnoreAdmission(t *testing.T) {
 	namespace := "test"
-	mockClient := &testclient.Fake{}
+	mockClient := &fake.Clientset{}
 	handler := admission.NewChainHandler(createProvision(mockClient, nil))
 	pod := api.Pod{
 		ObjectMeta: api.ObjectMeta{Name: "123", Namespace: namespace},
@ -107,8 +108,8 @@ func TestIgnoreAdmission(t *testing.T) {
 // TestAdmissionNamespaceExistsUnknownToHandler
 func TestAdmissionNamespaceExistsUnknownToHandler(t *testing.T) {
 	namespace := "test"
-	mockClient := &testclient.Fake{}
-	mockClient.AddReactor("create", "namespaces", func(action testclient.Action) (bool, runtime.Object, error) {
+	mockClient := &fake.Clientset{}
+	mockClient.AddReactor("create", "namespaces", func(action core.Action) (bool, runtime.Object, error) {
 		return true, nil, errors.NewAlreadyExists(api.Resource("namespaces"), namespace)
 	})

--- a/plugin/pkg/admission/namespace/exists/admission.go
+++ b/plugin/pkg/admission/namespace/exists/admission.go
@ -20,17 +20,18 @@ import (
 	"io"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/client/cache"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/watch"
 )

 func init() {
-	admission.RegisterPlugin("NamespaceExists", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("NamespaceExists", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewExists(client), nil
 	})
 }
@ -40,7 +41,7 @@ func init() {
 // It is useful in deployments that want to enforce pre-declaration of a Namespace resource.
 type exists struct {
 	*admission.Handler
-	client client.Interface
+	client clientset.Interface
 	store  cache.Store
 }

@ -68,7 +69,7 @@ func (e *exists) Admit(a admission.Attributes) (err error) {
 	}

 	// in case of latency in our caches, make a call direct to storage to verify that it truly exists or not
-	_, err = e.client.Namespaces().Get(a.GetNamespace())
+	_, err = e.client.Legacy().Namespaces().Get(a.GetNamespace())
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return err
@ -80,15 +81,15 @@ func (e *exists) Admit(a admission.Attributes) (err error) {
 }

 // NewExists creates a new namespace exists admission control handler
-func NewExists(c client.Interface) admission.Interface {
+func NewExists(c clientset.Interface) admission.Interface {
 	store := cache.NewStore(cache.MetaNamespaceKeyFunc)
 	reflector := cache.NewReflector(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return c.Namespaces().List(options)
+				return c.Legacy().Namespaces().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return c.Namespaces().Watch(options)
+				return c.Legacy().Namespaces().Watch(options)
 			},
 		},
 		&api.Namespace{},
--- a/plugin/pkg/admission/namespace/lifecycle/admission.go
+++ b/plugin/pkg/admission/namespace/lifecycle/admission.go
@ -21,18 +21,19 @@ import (
 	"io"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/client/cache"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/watch"
 )

 func init() {
-	admission.RegisterPlugin("NamespaceLifecycle", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("NamespaceLifecycle", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewLifecycle(client), nil
 	})
 }
@ -41,7 +42,7 @@ func init() {
 // It enforces life-cycle constraints around a Namespace depending on its Phase
 type lifecycle struct {
 	*admission.Handler
-	client             client.Interface
+	client             clientset.Interface
 	store              cache.Store
 	immortalNamespaces sets.String
 }
@ -72,7 +73,7 @@ func (l *lifecycle) Admit(a admission.Attributes) (err error) {
 	// refuse to operate on non-existent namespaces
 	if !exists {
 		// in case of latency in our caches, make a call direct to storage to verify that it truly exists or not
-		namespaceObj, err = l.client.Namespaces().Get(a.GetNamespace())
+		namespaceObj, err = l.client.Legacy().Namespaces().Get(a.GetNamespace())
 		if err != nil {
 			if errors.IsNotFound(err) {
 				return err
@ -96,15 +97,15 @@ func (l *lifecycle) Admit(a admission.Attributes) (err error) {
 }

 // NewLifecycle creates a new namespace lifecycle admission control handler
-func NewLifecycle(c client.Interface) admission.Interface {
+func NewLifecycle(c clientset.Interface) admission.Interface {
 	store := cache.NewStore(cache.MetaNamespaceKeyFunc)
 	reflector := cache.NewReflector(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return c.Namespaces().List(options)
+				return c.Legacy().Namespaces().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return c.Namespaces().Watch(options)
+				return c.Legacy().Namespaces().Watch(options)
 			},
 		},
 		&api.Namespace{},
--- a/plugin/pkg/admission/namespace/lifecycle/admission_test.go
+++ b/plugin/pkg/admission/namespace/lifecycle/admission_test.go
@ -24,6 +24,8 @@ import (
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/cache"
+	"k8s.io/kubernetes/pkg/client/testing/core"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
 	"k8s.io/kubernetes/pkg/runtime"
 )
@ -43,8 +45,8 @@ func TestAdmission(t *testing.T) {

 	store := cache.NewStore(cache.MetaNamespaceKeyFunc)
 	store.Add(namespaceObj)
-	mockClient := testclient.NewSimpleFake()
-	mockClient.PrependReactor("get", "namespaces", func(action testclient.Action) (bool, runtime.Object, error) {
+	mockClient := fake.NewSimpleClientset()
+	mockClient.PrependReactor("get", "namespaces", func(action core.Action) (bool, runtime.Object, error) {
 		namespaceLock.RLock()
 		defer namespaceLock.RUnlock()
 		if getAction, ok := action.(testclient.GetAction); ok && getAction.GetName() == namespaceObj.Name {
@ -52,7 +54,7 @@ func TestAdmission(t *testing.T) {
 		}
 		return true, nil, fmt.Errorf("No result for action %v", action)
 	})
-	mockClient.PrependReactor("list", "namespaces", func(action testclient.Action) (bool, runtime.Object, error) {
+	mockClient.PrependReactor("list", "namespaces", func(action core.Action) (bool, runtime.Object, error) {
 		namespaceLock.RLock()
 		defer namespaceLock.RUnlock()
 		return true, &api.NamespaceList{Items: []api.Namespace{*namespaceObj}}, nil
--- a/plugin/pkg/admission/persistentvolume/label/admission.go
+++ b/plugin/pkg/admission/persistentvolume/label/admission.go
@ -21,16 +21,17 @@ import (
 	"io"
 	"sync"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/cloudprovider/providers/aws"
 	"k8s.io/kubernetes/pkg/cloudprovider/providers/gce"
 )

 func init() {
-	admission.RegisterPlugin("PersistentVolumeLabel", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("PersistentVolumeLabel", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		persistentVolumeLabelAdmission := NewPersistentVolumeLabel()
 		return persistentVolumeLabelAdmission, nil
 	})
--- a/plugin/pkg/admission/resourcequota/admission.go
+++ b/plugin/pkg/admission/resourcequota/admission.go
@ -22,12 +22,13 @@ import (
 	"math/rand"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/client/cache"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	resourcequotacontroller "k8s.io/kubernetes/pkg/controller/resourcequota"
 	"k8s.io/kubernetes/pkg/runtime"
 	utilerrors "k8s.io/kubernetes/pkg/util/errors"
@ -35,25 +36,25 @@ import (
 )

 func init() {
-	admission.RegisterPlugin("ResourceQuota", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("ResourceQuota", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewResourceQuota(client), nil
 	})
 }

 type quota struct {
 	*admission.Handler
-	client  client.Interface
+	client  clientset.Interface
 	indexer cache.Indexer
 }

 // NewResourceQuota creates a new resource quota admission control handler
-func NewResourceQuota(client client.Interface) admission.Interface {
+func NewResourceQuota(client clientset.Interface) admission.Interface {
 	lw := &cache.ListWatch{
 		ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-			return client.ResourceQuotas(api.NamespaceAll).List(options)
+			return client.Legacy().ResourceQuotas(api.NamespaceAll).List(options)
 		},
 		WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-			return client.ResourceQuotas(api.NamespaceAll).Watch(options)
+			return client.Legacy().ResourceQuotas(api.NamespaceAll).Watch(options)
 		},
 	}
 	indexer, reflector := cache.NewNamespaceKeyedIndexerAndReflector(lw, &api.ResourceQuota{}, 0)
@ -61,7 +62,7 @@ func NewResourceQuota(client client.Interface) admission.Interface {
 	return createResourceQuota(client, indexer)
 }

-func createResourceQuota(client client.Interface, indexer cache.Indexer) admission.Interface {
+func createResourceQuota(client clientset.Interface, indexer cache.Indexer) admission.Interface {
 	return &quota{
 		Handler: admission.NewHandler(admission.Create, admission.Update),
 		client:  client,
@ -142,7 +143,7 @@ func (q *quota) Admit(a admission.Attributes) (err error) {
 						Annotations:     quota.Annotations},
 				}
 				usage.Status = *status
-				_, err = q.client.ResourceQuotas(usage.Namespace).UpdateStatus(&usage)
+				_, err = q.client.Legacy().ResourceQuotas(usage.Namespace).UpdateStatus(&usage)
 				if err == nil {
 					break
 				}
@ -153,7 +154,7 @@ func (q *quota) Admit(a admission.Attributes) (err error) {
 				}
 				time.Sleep(interval)
 				// manually get the latest quota
-				quota, err = q.client.ResourceQuotas(usage.Namespace).Get(quota.Name)
+				quota, err = q.client.Legacy().ResourceQuotas(usage.Namespace).Get(quota.Name)
 				if err != nil {
 					return admission.NewForbidden(a, err)
 				}
@ -166,7 +167,7 @@ func (q *quota) Admit(a admission.Attributes) (err error) {
 // IncrementUsage updates the supplied ResourceQuotaStatus object based on the incoming operation
 // Return true if the usage must be recorded prior to admitting the new resource
 // Return an error if the operation should not pass admission control
-func IncrementUsage(a admission.Attributes, status *api.ResourceQuotaStatus, client client.Interface) (bool, error) {
+func IncrementUsage(a admission.Attributes, status *api.ResourceQuotaStatus, client clientset.Interface) (bool, error) {
 	// on update, the only resource that can modify the value of a quota is pods
 	// so if your not a pod, we exit quickly
 	if a.GetOperation() == admission.Update && a.GetResource() != api.Resource("pods") {
@ -227,7 +228,7 @@ func IncrementUsage(a admission.Attributes, status *api.ResourceQuotaStatus, cli

 			// if this operation is an update, we need to find the delta usage from the previous state
 			if a.GetOperation() == admission.Update {
-				oldPod, err := client.Pods(a.GetNamespace()).Get(pod.Name)
+				oldPod, err := client.Legacy().Pods(a.GetNamespace()).Get(pod.Name)
 				if err != nil {
 					return false, err
 				}
--- a/plugin/pkg/admission/resourcequota/admission_test.go
+++ b/plugin/pkg/admission/resourcequota/admission_test.go
@ -25,7 +25,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/client/cache"
-	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 	resourcequotacontroller "k8s.io/kubernetes/pkg/controller/resourcequota"
 	"k8s.io/kubernetes/pkg/runtime"
 )
@ -65,7 +65,7 @@ func validPod(name string, numContainers int, resources api.ResourceRequirements

 func TestAdmissionIgnoresDelete(t *testing.T) {
 	namespace := "default"
-	handler := createResourceQuota(&testclient.Fake{}, nil)
+	handler := createResourceQuota(&fake.Clientset{}, nil)
 	err := handler.Admit(admission.NewAttributesRecord(nil, api.Kind("Pod"), namespace, "name", api.Resource("pods"), "", admission.Delete, nil))
 	if err != nil {
 		t.Errorf("ResourceQuota should admit all deletes: %v", err)
@ -74,7 +74,7 @@ func TestAdmissionIgnoresDelete(t *testing.T) {

 func TestAdmissionIgnoresSubresources(t *testing.T) {
 	indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{"namespace": cache.MetaNamespaceIndexFunc})
-	handler := createResourceQuota(&testclient.Fake{}, indexer)
+	handler := createResourceQuota(&fake.Clientset{}, indexer)

 	quota := &api.ResourceQuota{}
 	quota.Name = "quota"
@ -173,7 +173,7 @@ func TestIncrementUsagePodResources(t *testing.T) {
 	}
 	for _, item := range testCases {
 		podList := &api.PodList{Items: []api.Pod{*item.existing}}
-		client := testclient.NewSimpleFake(podList)
+		client := fake.NewSimpleClientset(podList)
 		status := &api.ResourceQuotaStatus{
 			Hard: api.ResourceList{},
 			Used: api.ResourceList{},
@ -207,7 +207,7 @@ func TestIncrementUsagePodResources(t *testing.T) {
 func TestIncrementUsagePods(t *testing.T) {
 	pod := validPod("123", 1, getResourceRequirements(getResourceList("100m", "1Gi"), getResourceList("", "")))
 	podList := &api.PodList{Items: []api.Pod{*pod}}
-	client := testclient.NewSimpleFake(podList)
+	client := fake.NewSimpleClientset(podList)
 	status := &api.ResourceQuotaStatus{
 		Hard: api.ResourceList{},
 		Used: api.ResourceList{},
@ -231,7 +231,7 @@ func TestIncrementUsagePods(t *testing.T) {
 func TestExceedUsagePods(t *testing.T) {
 	pod := validPod("123", 1, getResourceRequirements(getResourceList("100m", "1Gi"), getResourceList("", "")))
 	podList := &api.PodList{Items: []api.Pod{*pod}}
-	client := testclient.NewSimpleFake(podList)
+	client := fake.NewSimpleClientset(podList)
 	status := &api.ResourceQuotaStatus{
 		Hard: api.ResourceList{},
 		Used: api.ResourceList{},
@ -247,7 +247,7 @@ func TestExceedUsagePods(t *testing.T) {

 func TestIncrementUsageServices(t *testing.T) {
 	namespace := "default"
-	client := testclient.NewSimpleFake(&api.ServiceList{
+	client := fake.NewSimpleClientset(&api.ServiceList{
 		Items: []api.Service{
 			{
 				ObjectMeta: api.ObjectMeta{Name: "123", Namespace: namespace},
@ -276,7 +276,7 @@ func TestIncrementUsageServices(t *testing.T) {

 func TestExceedUsageServices(t *testing.T) {
 	namespace := "default"
-	client := testclient.NewSimpleFake(&api.ServiceList{
+	client := fake.NewSimpleClientset(&api.ServiceList{
 		Items: []api.Service{
 			{
 				ObjectMeta: api.ObjectMeta{Name: "123", Namespace: namespace},
@ -298,7 +298,7 @@ func TestExceedUsageServices(t *testing.T) {

 func TestIncrementUsageReplicationControllers(t *testing.T) {
 	namespace := "default"
-	client := testclient.NewSimpleFake(&api.ReplicationControllerList{
+	client := fake.NewSimpleClientset(&api.ReplicationControllerList{
 		Items: []api.ReplicationController{
 			{
 				ObjectMeta: api.ObjectMeta{Name: "123", Namespace: namespace},
@ -327,7 +327,7 @@ func TestIncrementUsageReplicationControllers(t *testing.T) {

 func TestExceedUsageReplicationControllers(t *testing.T) {
 	namespace := "default"
-	client := testclient.NewSimpleFake(&api.ReplicationControllerList{
+	client := fake.NewSimpleClientset(&api.ReplicationControllerList{
 		Items: []api.ReplicationController{
 			{
 				ObjectMeta: api.ObjectMeta{Name: "123", Namespace: namespace},
@ -349,7 +349,7 @@ func TestExceedUsageReplicationControllers(t *testing.T) {

 func TestExceedUsageSecrets(t *testing.T) {
 	namespace := "default"
-	client := testclient.NewSimpleFake(&api.SecretList{
+	client := fake.NewSimpleClientset(&api.SecretList{
 		Items: []api.Secret{
 			{
 				ObjectMeta: api.ObjectMeta{Name: "123", Namespace: namespace},
@ -371,7 +371,7 @@ func TestExceedUsageSecrets(t *testing.T) {

 func TestExceedUsagePersistentVolumeClaims(t *testing.T) {
 	namespace := "default"
-	client := testclient.NewSimpleFake(&api.PersistentVolumeClaimList{
+	client := fake.NewSimpleClientset(&api.PersistentVolumeClaimList{
 		Items: []api.PersistentVolumeClaim{
 			{
 				ObjectMeta: api.ObjectMeta{Name: "123", Namespace: namespace},
@ -426,7 +426,7 @@ func TestIncrementUsageOnUpdateIgnoresNonPodResources(t *testing.T) {
 	}

 	for _, testCase := range testCase {
-		client := testclient.NewSimpleFake()
+		client := fake.NewSimpleClientset()
 		status := &api.ResourceQuotaStatus{
 			Hard: api.ResourceList{},
 			Used: api.ResourceList{},
--- a/plugin/pkg/admission/securitycontext/scdeny/admission.go
+++ b/plugin/pkg/admission/securitycontext/scdeny/admission.go
@ -20,14 +20,15 @@ import (
 	"fmt"
 	"io"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )

 func init() {
-	admission.RegisterPlugin("SecurityContextDeny", func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin("SecurityContextDeny", func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		return NewSecurityContextDeny(client), nil
 	})
 }
@ -35,11 +36,11 @@ func init() {
 // plugin contains the client used by the SecurityContextDeny admission controller
 type plugin struct {
 	*admission.Handler
-	client client.Interface
+	client clientset.Interface
 }

 // NewSecurityContextDeny creates a new instance of the SecurityContextDeny admission controller
-func NewSecurityContextDeny(client client.Interface) admission.Interface {
+func NewSecurityContextDeny(client clientset.Interface) admission.Interface {
 	return &plugin{
 		Handler: admission.NewHandler(admission.Create, admission.Update),
 		client:  client,
--- a/plugin/pkg/admission/serviceaccount/admission.go
+++ b/plugin/pkg/admission/serviceaccount/admission.go
@ -23,6 +23,8 @@ import (
 	"strconv"
 	"time"

+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_1"
+
 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
@ -51,7 +53,7 @@ const DefaultAPITokenMountPath = "/var/run/secrets/kubernetes.io/serviceaccount"
 const PluginName = "ServiceAccount"

 func init() {
-	admission.RegisterPlugin(PluginName, func(client client.Interface, config io.Reader) (admission.Interface, error) {
+	admission.RegisterPlugin(PluginName, func(client clientset.Interface, config io.Reader) (admission.Interface, error) {
 		serviceAccountAdmission := NewServiceAccount(client)
 		serviceAccountAdmission.Run()
 		return serviceAccountAdmission, nil
@ -70,7 +72,7 @@ type serviceAccount struct {
 	// MountServiceAccountToken creates Volume and VolumeMounts for the first referenced ServiceAccountToken for the pod's service account
 	MountServiceAccountToken bool

-	client client.Interface
+	client clientset.Interface

 	serviceAccounts cache.Indexer
 	secrets         cache.Indexer
@ -86,14 +88,14 @@ type serviceAccount struct {
 // 3. If LimitSecretReferences is true, it rejects the pod if the pod references Secret objects which the pod's ServiceAccount does not reference
 // 4. If the pod does not contain any ImagePullSecrets, the ImagePullSecrets of the service account are added.
 // 5. If MountServiceAccountToken is true, it adds a VolumeMount with the pod's ServiceAccount's api token secret to containers
-func NewServiceAccount(cl client.Interface) *serviceAccount {
+func NewServiceAccount(cl clientset.Interface) *serviceAccount {
 	serviceAccountsIndexer, serviceAccountsReflector := cache.NewNamespaceKeyedIndexerAndReflector(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return cl.ServiceAccounts(api.NamespaceAll).List(options)
+				return cl.Legacy().ServiceAccounts(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return cl.ServiceAccounts(api.NamespaceAll).Watch(options)
+				return cl.Legacy().ServiceAccounts(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.ServiceAccount{},
@ -105,11 +107,11 @@ func NewServiceAccount(cl client.Interface) *serviceAccount {
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 				options.FieldSelector = tokenSelector
-				return cl.Secrets(api.NamespaceAll).List(options)
+				return cl.Legacy().Secrets(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 				options.FieldSelector = tokenSelector
-				return cl.Secrets(api.NamespaceAll).Watch(options)
+				return cl.Legacy().Secrets(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Secret{},
@ -251,7 +253,7 @@ func (s *serviceAccount) getServiceAccount(namespace string, name string) (*api.
 		if i != 0 {
 			time.Sleep(retryInterval)
 		}
-		serviceAccount, err := s.client.ServiceAccounts(namespace).Get(name)
+		serviceAccount, err := s.client.Legacy().ServiceAccounts(namespace).Get(name)
 		if err == nil {
 			return serviceAccount, nil
 		}
--- a/plugin/pkg/admission/serviceaccount/admission_test.go
+++ b/plugin/pkg/admission/serviceaccount/admission_test.go
@ -22,7 +22,7 @@ import (

 	"k8s.io/kubernetes/pkg/admission"
 	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/client/unversioned/testclient"
+	"k8s.io/kubernetes/pkg/client/testing/fake"
 	kubelet "k8s.io/kubernetes/pkg/kubelet/types"
 	"k8s.io/kubernetes/pkg/types"
 )
@ -176,7 +176,7 @@ func TestFetchesUncachedServiceAccount(t *testing.T) {
 	ns := "myns"

 	// Build a test client that the admission plugin can use to look up the service account missing from its cache
-	client := testclient.NewSimpleFake(&api.ServiceAccount{
+	client := fake.NewSimpleClientset(&api.ServiceAccount{
 		ObjectMeta: api.ObjectMeta{
 			Name:      DefaultServiceAccountName,
 			Namespace: ns,
@ -201,7 +201,7 @@ func TestDeniesInvalidServiceAccount(t *testing.T) {
 	ns := "myns"

 	// Build a test client that the admission plugin can use to look up the service account missing from its cache
-	client := testclient.NewSimpleFake()
+	client := fake.NewSimpleClientset()

 	admit := NewServiceAccount(client)

--- a/test/integration/service_account_test.go
+++ b/test/integration/service_account_test.go
@ -69,7 +69,7 @@ func TestServiceAccountAutoCreate(t *testing.T) {
 	ns := "test-service-account-creation"

 	// Create namespace
-	_, err := c.Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: ns}})
+	_, err := c.Legacy().Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: ns}})
 	if err != nil {
 		t.Fatalf("could not create namespace: %v", err)
 	}
@ -81,7 +81,7 @@ func TestServiceAccountAutoCreate(t *testing.T) {
 	}

 	// Delete service account
-	err = c.ServiceAccounts(ns).Delete(defaultUser.Name)
+	err = c.Legacy().ServiceAccounts(ns).Delete(defaultUser.Name, nil)
 	if err != nil {
 		t.Fatalf("Could not delete default serviceaccount: %v", err)
 	}
@ -104,13 +104,13 @@ func TestServiceAccountTokenAutoCreate(t *testing.T) {
 	name := "my-service-account"

 	// Create namespace
-	_, err := c.Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: ns}})
+	_, err := c.Legacy().Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: ns}})
 	if err != nil {
 		t.Fatalf("could not create namespace: %v", err)
 	}

 	// Create service account
-	serviceAccount, err := c.ServiceAccounts(ns).Create(&api.ServiceAccount{ObjectMeta: api.ObjectMeta{Name: name}})
+	serviceAccount, err := c.Legacy().ServiceAccounts(ns).Create(&api.ServiceAccount{ObjectMeta: api.ObjectMeta{Name: name}})
 	if err != nil {
 		t.Fatalf("Service Account not created: %v", err)
 	}
@ -122,7 +122,7 @@ func TestServiceAccountTokenAutoCreate(t *testing.T) {
 	}

 	// Delete token
-	err = c.Secrets(ns).Delete(token1Name)
+	err = c.Legacy().Secrets(ns).Delete(token1Name, nil)
 	if err != nil {
 		t.Fatalf("Could not delete token: %v", err)
 	}
@ -140,12 +140,12 @@ func TestServiceAccountTokenAutoCreate(t *testing.T) {
 	}

 	// Trigger creation of a new referenced token
-	serviceAccount, err = c.ServiceAccounts(ns).Get(name)
+	serviceAccount, err = c.Legacy().ServiceAccounts(ns).Get(name)
 	if err != nil {
 		t.Fatal(err)
 	}
 	serviceAccount.Secrets = []api.ObjectReference{}
-	_, err = c.ServiceAccounts(ns).Update(serviceAccount)
+	_, err = c.Legacy().ServiceAccounts(ns).Update(serviceAccount)
 	if err != nil {
 		t.Fatal(err)
 	}
@ -163,7 +163,7 @@ func TestServiceAccountTokenAutoCreate(t *testing.T) {
 	}

 	// Delete service account
-	err = c.ServiceAccounts(ns).Delete(name)
+	err = c.Legacy().ServiceAccounts(ns).Delete(name, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@ -172,7 +172,7 @@ func TestServiceAccountTokenAutoCreate(t *testing.T) {
 	tokensToCleanup := sets.NewString(token1Name, token2Name, token3Name)
 	err = wait.Poll(time.Second, 10*time.Second, func() (bool, error) {
 		// Get all secrets in the namespace
-		secrets, err := c.Secrets(ns).List(api.ListOptions{})
+		secrets, err := c.Legacy().Secrets(ns).List(api.ListOptions{})
 		// Retrieval errors should fail
 		if err != nil {
 			return false, err
@ -198,7 +198,7 @@ func TestServiceAccountTokenAutoMount(t *testing.T) {
 	ns := "auto-mount-ns"

 	// Create "my" namespace
-	_, err := c.Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: ns}})
+	_, err := c.Legacy().Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: ns}})
 	if err != nil && !errors.IsAlreadyExists(err) {
 		t.Fatalf("could not create namespace: %v", err)
 	}
@ -250,7 +250,7 @@ func TestServiceAccountTokenAutoMount(t *testing.T) {
 	}
 	expectedContainer2VolumeMounts := protoPod.Spec.Containers[1].VolumeMounts

-	createdPod, err := c.Pods(ns).Create(&protoPod)
+	createdPod, err := c.Legacy().Pods(ns).Create(&protoPod)
 	if err != nil {
 		t.Fatal(err)
 	}
@ -276,19 +276,19 @@ func TestServiceAccountTokenAuthentication(t *testing.T) {
 	otherns := "other-ns"

 	// Create "my" namespace
-	_, err := c.Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: myns}})
+	_, err := c.Legacy().Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: myns}})
 	if err != nil && !errors.IsAlreadyExists(err) {
 		t.Fatalf("could not create namespace: %v", err)
 	}

 	// Create "other" namespace
-	_, err = c.Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: otherns}})
+	_, err = c.Legacy().Namespaces().Create(&api.Namespace{ObjectMeta: api.ObjectMeta{Name: otherns}})
 	if err != nil && !errors.IsAlreadyExists(err) {
 		t.Fatalf("could not create namespace: %v", err)
 	}

 	// Create "ro" user in myns
-	_, err = c.ServiceAccounts(myns).Create(&api.ServiceAccount{ObjectMeta: api.ObjectMeta{Name: readOnlyServiceAccountName}})
+	_, err = c.Legacy().ServiceAccounts(myns).Create(&api.ServiceAccount{ObjectMeta: api.ObjectMeta{Name: readOnlyServiceAccountName}})
 	if err != nil {
 		t.Fatalf("Service Account not created: %v", err)
 	}
@ -298,17 +298,17 @@ func TestServiceAccountTokenAuthentication(t *testing.T) {
 	}
 	roClientConfig := config
 	roClientConfig.BearerToken = roToken
-	roClient := client.NewOrDie(&roClientConfig)
+	roClient := clientset.NewForConfigOrDie(&roClientConfig)
 	doServiceAccountAPIRequests(t, roClient, myns, true, true, false)
 	doServiceAccountAPIRequests(t, roClient, otherns, true, false, false)
-	err = c.Secrets(myns).Delete(roTokenName)
+	err = c.Legacy().Secrets(myns).Delete(roTokenName, nil)
 	if err != nil {
 		t.Fatalf("could not delete token: %v", err)
 	}
 	doServiceAccountAPIRequests(t, roClient, myns, false, false, false)

 	// Create "rw" user in myns
-	_, err = c.ServiceAccounts(myns).Create(&api.ServiceAccount{ObjectMeta: api.ObjectMeta{Name: readWriteServiceAccountName}})
+	_, err = c.Legacy().ServiceAccounts(myns).Create(&api.ServiceAccount{ObjectMeta: api.ObjectMeta{Name: readWriteServiceAccountName}})
 	if err != nil {
 		t.Fatalf("Service Account not created: %v", err)
 	}
@ -318,7 +318,7 @@ func TestServiceAccountTokenAuthentication(t *testing.T) {
 	}
 	rwClientConfig := config
 	rwClientConfig.BearerToken = rwToken
-	rwClient := client.NewOrDie(&rwClientConfig)
+	rwClient := clientset.NewForConfigOrDie(&rwClientConfig)
 	doServiceAccountAPIRequests(t, rwClient, myns, true, true, true)
 	doServiceAccountAPIRequests(t, rwClient, otherns, true, false, false)

@ -329,13 +329,13 @@ func TestServiceAccountTokenAuthentication(t *testing.T) {
 	}
 	defaultClientConfig := config
 	defaultClientConfig.BearerToken = defaultToken
-	defaultClient := client.NewOrDie(&defaultClientConfig)
+	defaultClient := clientset.NewForConfigOrDie(&defaultClientConfig)
 	doServiceAccountAPIRequests(t, defaultClient, myns, true, false, false)
 }

 // startServiceAccountTestServer returns a started server
 // It is the responsibility of the caller to ensure the returned stopFunc is called
-func startServiceAccountTestServer(t *testing.T) (*client.Client, client.Config, func()) {
+func startServiceAccountTestServer(t *testing.T) (*clientset.Clientset, client.Config, func()) {

 	deleteAllEtcdKeys()

@ -349,8 +349,7 @@ func startServiceAccountTestServer(t *testing.T) (*client.Client, client.Config,
 	clientConfig := client.Config{Host: apiServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}}
 	// Root client
 	// TODO: remove rootClient after we refactor pkg/admission to use the clientset.
-	rootClient := client.NewOrDie(&client.Config{Host: apiServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}, BearerToken: rootToken})
-	rootClientset := clientset.FromUnversionedClient(rootClient)
+	rootClientset := clientset.NewForConfigOrDie(&client.Config{Host: apiServer.URL, ContentConfig: client.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}, BearerToken: rootToken})
 	// Set up two authenticators:
 	// 1. A token authenticator that maps the rootToken to the "root" user
 	// 2. A ServiceAccountToken authenticator that validates ServiceAccount tokens
@ -401,7 +400,7 @@ func startServiceAccountTestServer(t *testing.T) (*client.Client, client.Config,
 	})

 	// Set up admission plugin to auto-assign serviceaccounts to pods
-	serviceAccountAdmission := serviceaccountadmission.NewServiceAccount(rootClient)
+	serviceAccountAdmission := serviceaccountadmission.NewServiceAccount(rootClientset)

 	masterConfig := framework.NewMasterConfig()
 	masterConfig.EnableIndex = true
@ -428,18 +427,18 @@ func startServiceAccountTestServer(t *testing.T) (*client.Client, client.Config,
 		// apiServer.Close()
 	}

-	return rootClient, clientConfig, stop
+	return rootClientset, clientConfig, stop
 }

-func getServiceAccount(c *client.Client, ns string, name string, shouldWait bool) (*api.ServiceAccount, error) {
+func getServiceAccount(c *clientset.Clientset, ns string, name string, shouldWait bool) (*api.ServiceAccount, error) {
 	if !shouldWait {
-		return c.ServiceAccounts(ns).Get(name)
+		return c.Legacy().ServiceAccounts(ns).Get(name)
 	}

 	var user *api.ServiceAccount
 	var err error
 	err = wait.Poll(time.Second, 10*time.Second, func() (bool, error) {
-		user, err = c.ServiceAccounts(ns).Get(name)
+		user, err = c.Legacy().ServiceAccounts(ns).Get(name)
 		if errors.IsNotFound(err) {
 			return false, nil
 		}
@ -451,12 +450,12 @@ func getServiceAccount(c *client.Client, ns string, name string, shouldWait bool
 	return user, err
 }

-func getReferencedServiceAccountToken(c *client.Client, ns string, name string, shouldWait bool) (string, string, error) {
+func getReferencedServiceAccountToken(c *clientset.Clientset, ns string, name string, shouldWait bool) (string, string, error) {
 	tokenName := ""
 	token := ""

 	findToken := func() (bool, error) {
-		user, err := c.ServiceAccounts(ns).Get(name)
+		user, err := c.Legacy().ServiceAccounts(ns).Get(name)
 		if errors.IsNotFound(err) {
 			return false, nil
 		}
@ -465,7 +464,7 @@ func getReferencedServiceAccountToken(c *client.Client, ns string, name string,
 		}

 		for _, ref := range user.Secrets {
-			secret, err := c.Secrets(ns).Get(ref.Name)
+			secret, err := c.Legacy().Secrets(ns).Get(ref.Name)
 			if errors.IsNotFound(err) {
 				continue
 			}
@ -507,7 +506,7 @@ func getReferencedServiceAccountToken(c *client.Client, ns string, name string,

 type testOperation func() error

-func doServiceAccountAPIRequests(t *testing.T, c *client.Client, ns string, authenticated bool, canRead bool, canWrite bool) {
+func doServiceAccountAPIRequests(t *testing.T, c *clientset.Clientset, ns string, authenticated bool, canRead bool, canWrite bool) {
 	testSecret := &api.Secret{
 		ObjectMeta: api.ObjectMeta{Name: "testSecret"},
 		Data:       map[string][]byte{"test": []byte("data")},
@ -515,17 +514,17 @@ func doServiceAccountAPIRequests(t *testing.T, c *client.Client, ns string, auth

 	readOps := []testOperation{
 		func() error {
-			_, err := c.Secrets(ns).List(api.ListOptions{})
+			_, err := c.Legacy().Secrets(ns).List(api.ListOptions{})
 			return err
 		},
 		func() error {
-			_, err := c.Pods(ns).List(api.ListOptions{})
+			_, err := c.Legacy().Pods(ns).List(api.ListOptions{})
 			return err
 		},
 	}
 	writeOps := []testOperation{
-		func() error { _, err := c.Secrets(ns).Create(testSecret); return err },
-		func() error { return c.Secrets(ns).Delete(testSecret.Name) },
+		func() error { _, err := c.Legacy().Secrets(ns).Create(testSecret); return err },
+		func() error { return c.Legacy().Secrets(ns).Delete(testSecret.Name, nil) },
 	}

 	for _, op := range readOps {