Merge pull request #20591 from caesarxuchao/legacy-to-core

Auto commit by PR queue bot

cmd/kube-controller-manager/app/controllermanager.go

@@ -257,7 +257,7 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
 				metrics.DefaultHeapsterService,
 				metrics.DefaultHeapsterPort,
 			)
-			podautoscaler.NewHorizontalController(hpaClient.Legacy(), hpaClient.Extensions(), hpaClient, metricsClient).
+			podautoscaler.NewHorizontalController(hpaClient.Core(), hpaClient.Extensions(), hpaClient, metricsClient).
 				Run(s.HorizontalPodAutoscalerSyncPeriod)
 		}
 

cmd/kubelet/app/server.go

@@ -40,7 +40,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/chaosclient"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
 	"k8s.io/kubernetes/pkg/client/record"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	clientauth "k8s.io/kubernetes/pkg/client/unversioned/auth"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
@@ -564,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(&unversioned_legacy.EventSinkImpl{kcfg.EventClient.Events("")})
+		eventBroadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{kcfg.EventClient.Events("")})
 	} else {
 		glog.Warning("No api server defined - no events will be sent to API server.")
 	}

cmd/libs/go2idl/client-gen/generators/client-generator.go

@@ -174,9 +174,9 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 				continue
 			}
 			group := filepath.Base(t.Name.Package)
-			// Special case for the legacy API.
+			// Special case for the core API.
 			if group == "api" {
-				group = "legacy"
+				group = "core"
 			}
 			if _, found := groupToTypes[group]; !found {
 				groupToTypes[group] = []*types.Type{}

cmd/libs/go2idl/client-gen/generators/generator-for-group.go

@@ -57,14 +57,14 @@ func (g *genGroup) GenerateType(c *generator.Context, t *types.Type, w io.Writer
 	const pkgRegistered = "k8s.io/kubernetes/pkg/apimachinery/registered"
 	const pkgAPI = "k8s.io/kubernetes/pkg/api"
 	apiPath := func(group string) string {
-		if group == "legacy" {
+		if group == "core" {
 			return `"/api"`
 		}
 		return `"/apis"`
 	}
 
 	canonize := func(group string) string {
-		if group == "legacy" {
+		if group == "core" {
 			return ""
 		}
 		return group

cmd/libs/go2idl/client-gen/generators/normalization/normalization.go

@@ -18,7 +18,7 @@ package normalization
 
 func Group(group string) string {
 	if group == "api" {
-		return "legacy"
+		return "core"
 	}
 	return group
 }

cmd/libs/go2idl/client-gen/main.go

@@ -39,7 +39,7 @@ var (
 
 func versionToPath(group string, version string) (path string) {
 	const base = "k8s.io/kubernetes/pkg"
-	// special case for the legacy group
+	// special case for the core group
 	if group == "api" {
 		path = filepath.Join(base, "api", version)
 	} else {

contrib/mesos/pkg/controllermanager/controllermanager.go

@@ -213,7 +213,7 @@ func (s *CMServer) Run(_ []string) error {
 				metrics.DefaultHeapsterService,
 				metrics.DefaultHeapsterPort,
 			)
-			podautoscaler.NewHorizontalController(hpaClient.Legacy(), hpaClient.Extensions(), hpaClient, metricsClient).
+			podautoscaler.NewHorizontalController(hpaClient.Core(), hpaClient.Extensions(), hpaClient, metricsClient).
 				Run(s.HorizontalPodAutoscalerSyncPeriod)
 		}
 

contrib/mesos/pkg/executor/apis.go

@@ -37,7 +37,7 @@ type clientAPIWrapper struct {
 }
 
 func (cw *clientAPIWrapper) killPod(ns, name string) error {
-	return cw.client.Legacy().Pods(ns).Delete(name, api.NewDeleteOptions(0))
+	return cw.client.Core().Pods(ns).Delete(name, api.NewDeleteOptions(0))
 }
 
 func (cw *clientAPIWrapper) createOrUpdate(hostname string, slaveAttrLabels, annotations map[string]string) (*api.Node, error) {

contrib/mesos/pkg/executor/registry.go

@@ -306,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.LegacyClient.Post().Namespace(api.NamespaceValue(ctx)).Resource("bindings").Body(binding).Do().Error()
+		err := r.client.CoreClient.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
@@ -321,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.LegacyClient.Patch(api.MergePatchType).RequestURI(pod.SelfLink).Body(patchJson).Do().Error()
+		err := r.client.CoreClient.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

contrib/mesos/pkg/executor/service/service.go

@@ -241,7 +241,7 @@ func (s *KubeletExecutorServer) Run(hks hyperkube.Interface, _ []string) error {
 	}
 
 	var (
-		pw = cache.NewListWatchFromClient(apiclient.LegacyClient, "pods", api.NamespaceAll,
+		pw = cache.NewListWatchFromClient(apiclient.CoreClient, "pods", api.NamespaceAll,
 			fields.OneTermEqualSelector(client.PodHost, s.HostnameOverride),
 		)
 		reg = executor.NewRegistry(apiclient)

contrib/mesos/pkg/node/statusupdater.go

@@ -59,7 +59,7 @@ func NewStatusUpdater(client *clientset.Clientset, relistPeriod time.Duration, n
 
 func (u *StatusUpdater) Run(terminate <-chan struct{}) error {
 	nodeStore := cache.NewStore(cache.MetaNamespaceKeyFunc)
-	nodeLW := cache.NewListWatchFromClient(u.client.LegacyClient, "nodes", api.NamespaceAll, fields.Everything())
+	nodeLW := cache.NewListWatchFromClient(u.client.CoreClient, "nodes", api.NamespaceAll, fields.Everything())
 	cache.NewReflector(nodeLW, &api.Node{}, nodeStore, u.relistPeriod).Run()
 
 	monitor := func() {

contrib/mesos/pkg/scheduler/components/controller/controller.go

@@ -79,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.Legacy().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0))
+		s.client.Core().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0))
 		return
 	}
 

contrib/mesos/pkg/scheduler/components/framework/framework.go

@@ -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.Legacy().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil && !errors.IsNotFound(err) {
+		if err := k.client.Core().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.Legacy().Pods(namespace).Get(name); err == nil {
+	} else if pod, err := k.client.Core().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.Legacy().Pods(namespace).Delete(name, nil); err != nil {
+			if err := k.client.Core().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.Legacy().Pods(api.NamespaceAll).List(api.ListOptions{})
+		podList, err := k.client.Core().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.Legacy().Pods(api.NamespaceAll).List(api.ListOptions{})
+	podList, err := ks.client.Core().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.Legacy().Pods(pod.Namespace).Delete(pod.Name, nil)
+			err := ks.client.Core().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)

contrib/mesos/pkg/scheduler/components/podreconciler/podreconciler.go

@@ -66,7 +66,7 @@ func New(sched scheduler.Scheduler, client *clientset.Clientset, qr queuer.Queue
 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.Legacy().Pods(api.NamespaceValue(ctx)).Get(t.Pod.Name)
+	pod, err := s.client.Core().Pods(api.NamespaceValue(ctx)).Get(t.Pod.Name)
 	if err != nil {
 		if apierrors.IsNotFound(err) {
 			// attempt to delete

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.Legacy().Services(api.NamespaceValue(ctx)).Get(serviceName); err == nil {
+	if _, err := m.client.Core().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.Legacy().Services(api.NamespaceValue(ctx)).Create(svc)
+	_, err := m.client.Core().Services(api.NamespaceValue(ctx)).Create(svc)
 	if err != nil && errors.IsAlreadyExists(err) {
 		err = nil
 	}

contrib/mesos/pkg/scheduler/service/service.go

@@ -723,7 +723,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.LegacyClient, "nodes", api.NamespaceAll, fields.Everything())
+	nodeLW := cache.NewListWatchFromClient(nodesClient.CoreClient, "nodes", api.NamespaceAll, fields.Everything())
 	nodeStore, nodeCtl := controllerfw.NewInformer(nodeLW, &api.Node{}, s.nodeRelistPeriod, &controllerfw.ResourceEventHandlerFuncs{
 		DeleteFunc: func(obj interface{}) {
 			node := obj.(*api.Node)
@@ -797,7 +797,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.LegacyClient, "pods", api.NamespaceAll, fields.Everything())
+	lw := cache.NewListWatchFromClient(client.CoreClient, "pods", api.NamespaceAll, fields.Everything())
 	sched := components.New(
 		sc,
 		framework,

contrib/mesos/pkg/service/endpoints_controller.go

@@ -59,10 +59,10 @@ func NewEndpointController(client *clientset.Clientset) *endpointController {
 	e.serviceStore.Store, e.serviceController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return e.client.Legacy().Services(api.NamespaceAll).List(options)
+				return e.client.Core().Services(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return e.client.Legacy().Services(api.NamespaceAll).Watch(options)
+				return e.client.Core().Services(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Service{},
@@ -79,10 +79,10 @@ func NewEndpointController(client *clientset.Clientset) *endpointController {
 	e.podStore.Store, e.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return e.client.Legacy().Pods(api.NamespaceAll).List(options)
+				return e.client.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return e.client.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return e.client.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},

pkg/client/clientset_generated/release_1_2/clientset.go

@@ -18,14 +18,14 @@ package release_1_2
 
 import (
 	"github.com/golang/glog"
+	core_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	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"
 )
 
 type Interface interface {
 	Discovery() unversioned.DiscoveryInterface
-	Legacy() legacy_unversioned.LegacyInterface
+	Core() core_unversioned.CoreInterface
 	Extensions() extensions_unversioned.ExtensionsInterface
 }
 
@@ -33,13 +33,13 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*unversioned.DiscoveryClient
-	*legacy_unversioned.LegacyClient
+	*core_unversioned.CoreClient
 	*extensions_unversioned.ExtensionsClient
 }
 
-// Legacy retrieves the LegacyClient
+// Core retrieves the CoreClient
-func (c *Clientset) Legacy() legacy_unversioned.LegacyInterface {
+func (c *Clientset) Core() core_unversioned.CoreInterface {
-	return c.LegacyClient
+	return c.CoreClient
 }
 
 // Extensions retrieves the ExtensionsClient
@@ -56,7 +56,7 @@ func (c *Clientset) Discovery() unversioned.DiscoveryInterface {
 func NewForConfig(c *unversioned.Config) (*Clientset, error) {
 	var clientset Clientset
 	var err error
-	clientset.LegacyClient, err = legacy_unversioned.NewForConfig(c)
+	clientset.CoreClient, err = core_unversioned.NewForConfig(c)
 	if err != nil {
 		return &clientset, err
 	}
@@ -76,7 +76,7 @@ func NewForConfig(c *unversioned.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *unversioned.Config) *Clientset {
 	var clientset Clientset
-	clientset.LegacyClient = legacy_unversioned.NewForConfigOrDie(c)
+	clientset.CoreClient = core_unversioned.NewForConfigOrDie(c)
 	clientset.ExtensionsClient = extensions_unversioned.NewForConfigOrDie(c)
 
 	clientset.DiscoveryClient = unversioned.NewDiscoveryClientForConfigOrDie(c)
@@ -86,7 +86,7 @@ func NewForConfigOrDie(c *unversioned.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c *unversioned.RESTClient) *Clientset {
 	var clientset Clientset
-	clientset.LegacyClient = legacy_unversioned.New(c)
+	clientset.CoreClient = core_unversioned.New(c)
 	clientset.ExtensionsClient = extensions_unversioned.New(c)
 
 	clientset.DiscoveryClient = unversioned.NewDiscoveryClient(c)

pkg/client/clientset_generated/release_1_2/clientset_adaption.go

@@ -17,8 +17,8 @@ limitations under the License.
 package release_1_2
 
 import (
+	core_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	extensions_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
-	legacy_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned"
 )
 
@@ -28,9 +28,9 @@ import (
 func FromUnversionedClient(c *unversioned.Client) *Clientset {
 	var clientset Clientset
 	if c != nil {
-		clientset.LegacyClient = legacy_unversioned.New(c.RESTClient)
+		clientset.CoreClient = core_unversioned.New(c.RESTClient)
 	} else {
-		clientset.LegacyClient = legacy_unversioned.New(nil)
+		clientset.CoreClient = core_unversioned.New(nil)
 	}
 	if c != nil && c.ExtensionsClient != nil {
 		clientset.ExtensionsClient = extensions_unversioned.New(c.ExtensionsClient.RESTClient)

pkg/client/testing/fake/clientset_generated.go

@@ -17,15 +17,15 @@ limitations under the License.
 package fake
 
 import (
+	core_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
+	core_unversioned_fake "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned/fake"
 	extensions_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
 	extensions_unversioned_fake "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned/fake"
-	legacy_unversioned "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
-	legacy_unversioned_fake "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned/fake"
 )
 
-// Legacy retrieves the LegacyClient
+// Core retrieves the CoreClient
-func (c *Clientset) Legacy() legacy_unversioned.LegacyInterface {
+func (c *Clientset) Core() core_unversioned.CoreInterface {
-	return &legacy_unversioned_fake.FakeLegacy{&c.Fake}
+	return &core_unversioned_fake.FakeCore{&c.Fake}
 }
 
 // Extensions retrieves the ExtensionsClient

pkg/client/typed/generated/core/unversioned/componentstatus.go

@@ -41,11 +41,11 @@ type ComponentStatusInterface interface {
 
 // componentStatuses implements ComponentStatusInterface
 type componentStatuses struct {
-	client *LegacyClient
+	client *CoreClient
 }
 
 // newComponentStatuses returns a ComponentStatuses
-func newComponentStatuses(c *LegacyClient) *componentStatuses {
+func newComponentStatuses(c *CoreClient) *componentStatuses {
 	return &componentStatuses{
 		client: c,
 	}

pkg/client/typed/generated/core/unversioned/configmap.go

@@ -41,12 +41,12 @@ type ConfigMapInterface interface {
 
 // configMaps implements ConfigMapInterface
 type configMaps struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newConfigMaps returns a ConfigMaps
-func newConfigMaps(c *LegacyClient, namespace string) *configMaps {
+func newConfigMaps(c *CoreClient, namespace string) *configMaps {
 	return &configMaps{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/core_client.go

@@ -22,7 +22,7 @@ import (
 	unversioned "k8s.io/kubernetes/pkg/client/unversioned"
 )
 
-type LegacyInterface interface {
+type CoreInterface interface {
 	ComponentStatusesGetter
 	ConfigMapsGetter
 	EndpointsGetter
@@ -41,77 +41,77 @@ type LegacyInterface interface {
 	ServiceAccountsGetter
 }
 
-// LegacyClient is used to interact with features provided by the Legacy group.
+// CoreClient is used to interact with features provided by the Core group.
-type LegacyClient struct {
+type CoreClient struct {
 	*unversioned.RESTClient
 }
 
-func (c *LegacyClient) ComponentStatuses() ComponentStatusInterface {
+func (c *CoreClient) ComponentStatuses() ComponentStatusInterface {
 	return newComponentStatuses(c)
 }
 
-func (c *LegacyClient) ConfigMaps(namespace string) ConfigMapInterface {
+func (c *CoreClient) ConfigMaps(namespace string) ConfigMapInterface {
 	return newConfigMaps(c, namespace)
 }
 
-func (c *LegacyClient) Endpoints(namespace string) EndpointsInterface {
+func (c *CoreClient) Endpoints(namespace string) EndpointsInterface {
 	return newEndpoints(c, namespace)
 }
 
-func (c *LegacyClient) Events(namespace string) EventInterface {
+func (c *CoreClient) Events(namespace string) EventInterface {
 	return newEvents(c, namespace)
 }
 
-func (c *LegacyClient) LimitRanges(namespace string) LimitRangeInterface {
+func (c *CoreClient) LimitRanges(namespace string) LimitRangeInterface {
 	return newLimitRanges(c, namespace)
 }
 
-func (c *LegacyClient) Namespaces() NamespaceInterface {
+func (c *CoreClient) Namespaces() NamespaceInterface {
 	return newNamespaces(c)
 }
 
-func (c *LegacyClient) Nodes() NodeInterface {
+func (c *CoreClient) Nodes() NodeInterface {
 	return newNodes(c)
 }
 
-func (c *LegacyClient) PersistentVolumes() PersistentVolumeInterface {
+func (c *CoreClient) PersistentVolumes() PersistentVolumeInterface {
 	return newPersistentVolumes(c)
 }
 
-func (c *LegacyClient) PersistentVolumeClaims(namespace string) PersistentVolumeClaimInterface {
+func (c *CoreClient) PersistentVolumeClaims(namespace string) PersistentVolumeClaimInterface {
 	return newPersistentVolumeClaims(c, namespace)
 }
 
-func (c *LegacyClient) Pods(namespace string) PodInterface {
+func (c *CoreClient) Pods(namespace string) PodInterface {
 	return newPods(c, namespace)
 }
 
-func (c *LegacyClient) PodTemplates(namespace string) PodTemplateInterface {
+func (c *CoreClient) PodTemplates(namespace string) PodTemplateInterface {
 	return newPodTemplates(c, namespace)
 }
 
-func (c *LegacyClient) ReplicationControllers(namespace string) ReplicationControllerInterface {
+func (c *CoreClient) ReplicationControllers(namespace string) ReplicationControllerInterface {
 	return newReplicationControllers(c, namespace)
 }
 
-func (c *LegacyClient) ResourceQuotas(namespace string) ResourceQuotaInterface {
+func (c *CoreClient) ResourceQuotas(namespace string) ResourceQuotaInterface {
 	return newResourceQuotas(c, namespace)
 }
 
-func (c *LegacyClient) Secrets(namespace string) SecretInterface {
+func (c *CoreClient) Secrets(namespace string) SecretInterface {
 	return newSecrets(c, namespace)
 }
 
-func (c *LegacyClient) Services(namespace string) ServiceInterface {
+func (c *CoreClient) Services(namespace string) ServiceInterface {
 	return newServices(c, namespace)
 }
 
-func (c *LegacyClient) ServiceAccounts(namespace string) ServiceAccountInterface {
+func (c *CoreClient) ServiceAccounts(namespace string) ServiceAccountInterface {
 	return newServiceAccounts(c, namespace)
 }
 
-// NewForConfig creates a new LegacyClient for the given config.
+// NewForConfig creates a new CoreClient for the given config.
-func NewForConfig(c *unversioned.Config) (*LegacyClient, error) {
+func NewForConfig(c *unversioned.Config) (*CoreClient, error) {
 	config := *c
 	if err := setConfigDefaults(&config); err != nil {
 		return nil, err
@@ -120,12 +120,12 @@ func NewForConfig(c *unversioned.Config) (*LegacyClient, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &LegacyClient{client}, nil
+	return &CoreClient{client}, nil
 }
 
-// NewForConfigOrDie creates a new LegacyClient for the given config and
+// NewForConfigOrDie creates a new CoreClient for the given config and
 // panics if there is an error in the config.
-func NewForConfigOrDie(c *unversioned.Config) *LegacyClient {
+func NewForConfigOrDie(c *unversioned.Config) *CoreClient {
 	client, err := NewForConfig(c)
 	if err != nil {
 		panic(err)
@@ -133,13 +133,13 @@ func NewForConfigOrDie(c *unversioned.Config) *LegacyClient {
 	return client
 }
 
-// New creates a new LegacyClient for the given RESTClient.
+// New creates a new CoreClient for the given RESTClient.
-func New(c *unversioned.RESTClient) *LegacyClient {
+func New(c *unversioned.RESTClient) *CoreClient {
-	return &LegacyClient{c}
+	return &CoreClient{c}
 }
 
 func setConfigDefaults(config *unversioned.Config) error {
-	// if legacy group is not registered, return an error
+	// if core group is not registered, return an error
 	g, err := registered.Group("")
 	if err != nil {
 		return err

pkg/client/typed/generated/core/unversioned/endpoints.go

@@ -41,12 +41,12 @@ type EndpointsInterface interface {
 
 // endpoints implements EndpointsInterface
 type endpoints struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newEndpoints returns a Endpoints
-func newEndpoints(c *LegacyClient, namespace string) *endpoints {
+func newEndpoints(c *CoreClient, namespace string) *endpoints {
 	return &endpoints{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/event.go

@@ -41,12 +41,12 @@ type EventInterface interface {
 
 // events implements EventInterface
 type events struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newEvents returns a Events
-func newEvents(c *LegacyClient, namespace string) *events {
+func newEvents(c *CoreClient, namespace string) *events {
 	return &events{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/fake/fake_componentstatus.go

@@ -25,7 +25,7 @@ import (
 
 // FakeComponentStatuses implements ComponentStatusInterface
 type FakeComponentStatuses struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 }
 
 func (c *FakeComponentStatuses) Create(componentStatus *api.ComponentStatus) (result *api.ComponentStatus, err error) {

pkg/client/typed/generated/core/unversioned/fake/fake_configmap.go

@@ -25,7 +25,7 @@ import (
 
 // FakeConfigMaps implements ConfigMapInterface
 type FakeConfigMaps struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_core_client.go

@@ -0,0 +1,90 @@
+/*
+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 (
+	core "k8s.io/kubernetes/pkg/client/testing/core"
+	unversioned "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
+)
+
+type FakeCore struct {
+	*core.Fake
+}
+
+func (c *FakeCore) ComponentStatuses() unversioned.ComponentStatusInterface {
+	return &FakeComponentStatuses{c}
+}
+
+func (c *FakeCore) ConfigMaps(namespace string) unversioned.ConfigMapInterface {
+	return &FakeConfigMaps{c, namespace}
+}
+
+func (c *FakeCore) Endpoints(namespace string) unversioned.EndpointsInterface {
+	return &FakeEndpoints{c, namespace}
+}
+
+func (c *FakeCore) Events(namespace string) unversioned.EventInterface {
+	return &FakeEvents{c, namespace}
+}
+
+func (c *FakeCore) LimitRanges(namespace string) unversioned.LimitRangeInterface {
+	return &FakeLimitRanges{c, namespace}
+}
+
+func (c *FakeCore) Namespaces() unversioned.NamespaceInterface {
+	return &FakeNamespaces{c}
+}
+
+func (c *FakeCore) Nodes() unversioned.NodeInterface {
+	return &FakeNodes{c}
+}
+
+func (c *FakeCore) PersistentVolumes() unversioned.PersistentVolumeInterface {
+	return &FakePersistentVolumes{c}
+}
+
+func (c *FakeCore) PersistentVolumeClaims(namespace string) unversioned.PersistentVolumeClaimInterface {
+	return &FakePersistentVolumeClaims{c, namespace}
+}
+
+func (c *FakeCore) Pods(namespace string) unversioned.PodInterface {
+	return &FakePods{c, namespace}
+}
+
+func (c *FakeCore) PodTemplates(namespace string) unversioned.PodTemplateInterface {
+	return &FakePodTemplates{c, namespace}
+}
+
+func (c *FakeCore) ReplicationControllers(namespace string) unversioned.ReplicationControllerInterface {
+	return &FakeReplicationControllers{c, namespace}
+}
+
+func (c *FakeCore) ResourceQuotas(namespace string) unversioned.ResourceQuotaInterface {
+	return &FakeResourceQuotas{c, namespace}
+}
+
+func (c *FakeCore) Secrets(namespace string) unversioned.SecretInterface {
+	return &FakeSecrets{c, namespace}
+}
+
+func (c *FakeCore) Services(namespace string) unversioned.ServiceInterface {
+	return &FakeServices{c, namespace}
+}
+
+func (c *FakeCore) ServiceAccounts(namespace string) unversioned.ServiceAccountInterface {
+	return &FakeServiceAccounts{c, namespace}
+}

pkg/client/typed/generated/core/unversioned/fake/fake_endpoints.go

@@ -25,7 +25,7 @@ import (
 
 // FakeEndpoints implements EndpointsInterface
 type FakeEndpoints struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_event.go

@@ -25,7 +25,7 @@ import (
 
 // FakeEvents implements EventInterface
 type FakeEvents struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_limitrange.go

@@ -25,7 +25,7 @@ import (
 
 // FakeLimitRanges implements LimitRangeInterface
 type FakeLimitRanges struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_namespace.go

@@ -25,7 +25,7 @@ import (
 
 // FakeNamespaces implements NamespaceInterface
 type FakeNamespaces struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 }
 
 func (c *FakeNamespaces) Create(namespace *api.Namespace) (result *api.Namespace, err error) {

pkg/client/typed/generated/core/unversioned/fake/fake_node.go

@@ -25,7 +25,7 @@ import (
 
 // FakeNodes implements NodeInterface
 type FakeNodes struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 }
 
 func (c *FakeNodes) Create(node *api.Node) (result *api.Node, err error) {

pkg/client/typed/generated/core/unversioned/fake/fake_persistentvolume.go

@@ -25,7 +25,7 @@ import (
 
 // FakePersistentVolumes implements PersistentVolumeInterface
 type FakePersistentVolumes struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 }
 
 func (c *FakePersistentVolumes) Create(persistentVolume *api.PersistentVolume) (result *api.PersistentVolume, err error) {

pkg/client/typed/generated/core/unversioned/fake/fake_persistentvolumeclaim.go

@@ -25,7 +25,7 @@ import (
 
 // FakePersistentVolumeClaims implements PersistentVolumeClaimInterface
 type FakePersistentVolumeClaims struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_pod.go

@@ -25,7 +25,7 @@ import (
 
 // FakePods implements PodInterface
 type FakePods struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_podtemplate.go

@@ -25,7 +25,7 @@ import (
 
 // FakePodTemplates implements PodTemplateInterface
 type FakePodTemplates struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_replicationcontroller.go

@@ -25,7 +25,7 @@ import (
 
 // FakeReplicationControllers implements ReplicationControllerInterface
 type FakeReplicationControllers struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_resourcequota.go

@@ -25,7 +25,7 @@ import (
 
 // FakeResourceQuotas implements ResourceQuotaInterface
 type FakeResourceQuotas struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_secret.go

@@ -25,7 +25,7 @@ import (
 
 // FakeSecrets implements SecretInterface
 type FakeSecrets struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_service.go

@@ -25,7 +25,7 @@ import (
 
 // FakeServices implements ServiceInterface
 type FakeServices struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/fake/fake_serviceaccount.go

@@ -25,7 +25,7 @@ import (
 
 // FakeServiceAccounts implements ServiceAccountInterface
 type FakeServiceAccounts struct {
-	Fake *FakeLegacy
+	Fake *FakeCore
 	ns   string
 }
 

pkg/client/typed/generated/core/unversioned/limitrange.go

@@ -41,12 +41,12 @@ type LimitRangeInterface interface {
 
 // limitRanges implements LimitRangeInterface
 type limitRanges struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newLimitRanges returns a LimitRanges
-func newLimitRanges(c *LegacyClient, namespace string) *limitRanges {
+func newLimitRanges(c *CoreClient, namespace string) *limitRanges {
 	return &limitRanges{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/namespace.go

@@ -42,11 +42,11 @@ type NamespaceInterface interface {
 
 // namespaces implements NamespaceInterface
 type namespaces struct {
-	client *LegacyClient
+	client *CoreClient
 }
 
 // newNamespaces returns a Namespaces
-func newNamespaces(c *LegacyClient) *namespaces {
+func newNamespaces(c *CoreClient) *namespaces {
 	return &namespaces{
 		client: c,
 	}

pkg/client/typed/generated/core/unversioned/node.go

@@ -42,11 +42,11 @@ type NodeInterface interface {
 
 // nodes implements NodeInterface
 type nodes struct {
-	client *LegacyClient
+	client *CoreClient
 }
 
 // newNodes returns a Nodes
-func newNodes(c *LegacyClient) *nodes {
+func newNodes(c *CoreClient) *nodes {
 	return &nodes{
 		client: c,
 	}

pkg/client/typed/generated/core/unversioned/persistentvolume.go

@@ -42,11 +42,11 @@ type PersistentVolumeInterface interface {
 
 // persistentVolumes implements PersistentVolumeInterface
 type persistentVolumes struct {
-	client *LegacyClient
+	client *CoreClient
 }
 
 // newPersistentVolumes returns a PersistentVolumes
-func newPersistentVolumes(c *LegacyClient) *persistentVolumes {
+func newPersistentVolumes(c *CoreClient) *persistentVolumes {
 	return &persistentVolumes{
 		client: c,
 	}

pkg/client/typed/generated/core/unversioned/persistentvolumeclaim.go

@@ -42,12 +42,12 @@ type PersistentVolumeClaimInterface interface {
 
 // persistentVolumeClaims implements PersistentVolumeClaimInterface
 type persistentVolumeClaims struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newPersistentVolumeClaims returns a PersistentVolumeClaims
-func newPersistentVolumeClaims(c *LegacyClient, namespace string) *persistentVolumeClaims {
+func newPersistentVolumeClaims(c *CoreClient, namespace string) *persistentVolumeClaims {
 	return &persistentVolumeClaims{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/pod.go

@@ -42,12 +42,12 @@ type PodInterface interface {
 
 // pods implements PodInterface
 type pods struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newPods returns a Pods
-func newPods(c *LegacyClient, namespace string) *pods {
+func newPods(c *CoreClient, namespace string) *pods {
 	return &pods{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/podtemplate.go

@@ -41,12 +41,12 @@ type PodTemplateInterface interface {
 
 // podTemplates implements PodTemplateInterface
 type podTemplates struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newPodTemplates returns a PodTemplates
-func newPodTemplates(c *LegacyClient, namespace string) *podTemplates {
+func newPodTemplates(c *CoreClient, namespace string) *podTemplates {
 	return &podTemplates{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/replicationcontroller.go

@@ -42,12 +42,12 @@ type ReplicationControllerInterface interface {
 
 // replicationControllers implements ReplicationControllerInterface
 type replicationControllers struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newReplicationControllers returns a ReplicationControllers
-func newReplicationControllers(c *LegacyClient, namespace string) *replicationControllers {
+func newReplicationControllers(c *CoreClient, namespace string) *replicationControllers {
 	return &replicationControllers{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/resourcequota.go

@@ -42,12 +42,12 @@ type ResourceQuotaInterface interface {
 
 // resourceQuotas implements ResourceQuotaInterface
 type resourceQuotas struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newResourceQuotas returns a ResourceQuotas
-func newResourceQuotas(c *LegacyClient, namespace string) *resourceQuotas {
+func newResourceQuotas(c *CoreClient, namespace string) *resourceQuotas {
 	return &resourceQuotas{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/secret.go

@@ -41,12 +41,12 @@ type SecretInterface interface {
 
 // secrets implements SecretInterface
 type secrets struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newSecrets returns a Secrets
-func newSecrets(c *LegacyClient, namespace string) *secrets {
+func newSecrets(c *CoreClient, namespace string) *secrets {
 	return &secrets{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/service.go

@@ -42,12 +42,12 @@ type ServiceInterface interface {
 
 // services implements ServiceInterface
 type services struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newServices returns a Services
-func newServices(c *LegacyClient, namespace string) *services {
+func newServices(c *CoreClient, namespace string) *services {
 	return &services{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/core/unversioned/serviceaccount.go

@@ -41,12 +41,12 @@ type ServiceAccountInterface interface {
 
 // serviceAccounts implements ServiceAccountInterface
 type serviceAccounts struct {
-	client *LegacyClient
+	client *CoreClient
 	ns     string
 }
 
 // newServiceAccounts returns a ServiceAccounts
-func newServiceAccounts(c *LegacyClient, namespace string) *serviceAccounts {
+func newServiceAccounts(c *CoreClient, namespace string) *serviceAccounts {
 	return &serviceAccounts{
 		client: c,
 		ns:     namespace,

pkg/client/typed/generated/legacy/unversioned/fake/fake_legacy_client.go

@@ -1,90 +0,0 @@
-/*
-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 (
-	core "k8s.io/kubernetes/pkg/client/testing/core"
-	unversioned "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
-)
-
-type FakeLegacy struct {
-	*core.Fake
-}
-
-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}
-}
-
-func (c *FakeLegacy) Events(namespace string) unversioned.EventInterface {
-	return &FakeEvents{c, namespace}
-}
-
-func (c *FakeLegacy) LimitRanges(namespace string) unversioned.LimitRangeInterface {
-	return &FakeLimitRanges{c, namespace}
-}
-
-func (c *FakeLegacy) Namespaces() unversioned.NamespaceInterface {
-	return &FakeNamespaces{c}
-}
-
-func (c *FakeLegacy) Nodes() unversioned.NodeInterface {
-	return &FakeNodes{c}
-}
-
-func (c *FakeLegacy) PersistentVolumes() unversioned.PersistentVolumeInterface {
-	return &FakePersistentVolumes{c}
-}
-
-func (c *FakeLegacy) PersistentVolumeClaims(namespace string) unversioned.PersistentVolumeClaimInterface {
-	return &FakePersistentVolumeClaims{c, namespace}
-}
-
-func (c *FakeLegacy) Pods(namespace string) unversioned.PodInterface {
-	return &FakePods{c, namespace}
-}
-
-func (c *FakeLegacy) PodTemplates(namespace string) unversioned.PodTemplateInterface {
-	return &FakePodTemplates{c, namespace}
-}
-
-func (c *FakeLegacy) ReplicationControllers(namespace string) unversioned.ReplicationControllerInterface {
-	return &FakeReplicationControllers{c, namespace}
-}
-
-func (c *FakeLegacy) ResourceQuotas(namespace string) unversioned.ResourceQuotaInterface {
-	return &FakeResourceQuotas{c, namespace}
-}
-
-func (c *FakeLegacy) Secrets(namespace string) unversioned.SecretInterface {
-	return &FakeSecrets{c, namespace}
-}
-
-func (c *FakeLegacy) Services(namespace string) unversioned.ServiceInterface {
-	return &FakeServices{c, namespace}
-}
-
-func (c *FakeLegacy) ServiceAccounts(namespace string) unversioned.ServiceAccountInterface {
-	return &FakeServiceAccounts{c, namespace}
-}

pkg/controller/controller_utils.go

@@ -321,7 +321,7 @@ func (r RealPodControl) createPods(nodeName, namespace string, template *api.Pod
 	if labels.Set(pod.Labels).AsSelector().Empty() {
 		return fmt.Errorf("unable to create pods, no labels")
 	}
-	if newPod, err := r.KubeClient.Legacy().Pods(namespace).Create(pod); err != nil {
+	if newPod, err := r.KubeClient.Core().Pods(namespace).Create(pod); err != nil {
 		r.Recorder.Eventf(object, api.EventTypeWarning, "FailedCreate", "Error creating: %v", err)
 		return fmt.Errorf("unable to create pods: %v", err)
 	} else {
@@ -336,7 +336,7 @@ func (r RealPodControl) DeletePod(namespace string, podID string, object runtime
 	if err != nil {
 		return fmt.Errorf("object does not have ObjectMeta, %v", err)
 	}
-	if err := r.KubeClient.Legacy().Pods(namespace).Delete(podID, nil); err != nil {
+	if err := r.KubeClient.Core().Pods(namespace).Delete(podID, nil); err != nil {
 		r.Recorder.Eventf(object, api.EventTypeWarning, "FailedDelete", "Error deleting: %v", err)
 		return fmt.Errorf("unable to delete pods: %v", err)
 	} else {
@@ -449,7 +449,7 @@ func SyncAllPodsWithStore(kubeClient clientset.Interface, store cache.Store) {
 	var err error
 	listOptions := api.ListOptions{LabelSelector: labels.Everything(), FieldSelector: fields.Everything()}
 	for {
-		if allPods, err = kubeClient.Legacy().Pods(api.NamespaceAll).List(listOptions); err != nil {
+		if allPods, err = kubeClient.Core().Pods(api.NamespaceAll).List(listOptions); err != nil {
 			glog.Warningf("Retrying pod list: %v", err)
 			continue
 		}

pkg/controller/daemon/controller.go

@@ -29,8 +29,8 @@ import (
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
 	"k8s.io/kubernetes/pkg/client/record"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	unversioned_extensions "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/controller/framework"
 	"k8s.io/kubernetes/pkg/labels"
@@ -98,7 +98,7 @@ func NewDaemonSetsController(kubeClient clientset.Interface, resyncPeriod contro
 	eventBroadcaster := record.NewBroadcaster()
 	eventBroadcaster.StartLogging(glog.Infof)
 	// TODO: remove the wrapper when every clients have moved to use the clientset.
-	eventBroadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kubeClient.Legacy().Events("")})
+	eventBroadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{kubeClient.Core().Events("")})
 
 	dsc := &DaemonSetsController{
 		kubeClient: kubeClient,
@@ -146,10 +146,10 @@ func NewDaemonSetsController(kubeClient clientset.Interface, resyncPeriod contro
 	dsc.podStore.Store, dsc.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return dsc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+				return dsc.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return dsc.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return dsc.kubeClient.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},
@@ -164,10 +164,10 @@ func NewDaemonSetsController(kubeClient clientset.Interface, resyncPeriod contro
 	dsc.nodeStore.Store, dsc.nodeController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return dsc.kubeClient.Legacy().Nodes().List(options)
+				return dsc.kubeClient.Core().Nodes().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return dsc.kubeClient.Legacy().Nodes().Watch(options)
+				return dsc.kubeClient.Core().Nodes().Watch(options)
 			},
 		},
 		&api.Node{},

pkg/controller/deployment/deployment_controller.go

@@ -31,7 +31,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
 	"k8s.io/kubernetes/pkg/client/record"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/controller/framework"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -99,7 +99,7 @@ func NewDeploymentController(client clientset.Interface, resyncPeriod controller
 	eventBroadcaster := record.NewBroadcaster()
 	eventBroadcaster.StartLogging(glog.Infof)
 	// TODO: remove the wrapper when every clients have moved to use the clientset.
-	eventBroadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{client.Legacy().Events("")})
+	eventBroadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{client.Core().Events("")})
 
 	dc := &DeploymentController{
 		client:          client,
@@ -144,10 +144,10 @@ func NewDeploymentController(client clientset.Interface, resyncPeriod controller
 	dc.rcStore.Store, dc.rcController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return dc.client.Legacy().ReplicationControllers(api.NamespaceAll).List(options)
+				return dc.client.Core().ReplicationControllers(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return dc.client.Legacy().ReplicationControllers(api.NamespaceAll).Watch(options)
+				return dc.client.Core().ReplicationControllers(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.ReplicationController{},
@@ -162,10 +162,10 @@ func NewDeploymentController(client clientset.Interface, resyncPeriod controller
 	dc.podStore.Store, dc.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return dc.client.Legacy().Pods(api.NamespaceAll).List(options)
+				return dc.client.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return dc.client.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return dc.client.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},
@@ -693,7 +693,7 @@ func (dc *DeploymentController) getNewRC(deployment extensions.Deployment, maxOl
 			glog.V(4).Infof("update existingNewRC %s revision to %s - %+v\n", existingNewRC.Name, newRevision)
 		}
 		if annotationChanged {
-			return dc.client.Legacy().ReplicationControllers(deployment.ObjectMeta.Namespace).Update(existingNewRC)
+			return dc.client.Core().ReplicationControllers(deployment.ObjectMeta.Namespace).Update(existingNewRC)
 		}
 		return existingNewRC, nil
 	}
@@ -740,7 +740,7 @@ func (dc *DeploymentController) getNewRC(deployment extensions.Deployment, maxOl
 			Template: &newRCTemplate,
 		},
 	}
-	createdRC, err := dc.client.Legacy().ReplicationControllers(namespace).Create(&newRC)
+	createdRC, err := dc.client.Core().ReplicationControllers(namespace).Create(&newRC)
 	if err != nil {
 		dc.rcExpectations.DeleteExpectations(dKey)
 		return nil, fmt.Errorf("error creating replication controller: %v", err)
@@ -764,7 +764,7 @@ func (dc *DeploymentController) updateRCRevision(rc api.ReplicationController, r
 		rc.Annotations = make(map[string]string)
 	}
 	rc.Annotations[deploymentutil.RevisionAnnotation] = revision
-	_, err := dc.client.Legacy().ReplicationControllers(rc.ObjectMeta.Namespace).Update(&rc)
+	_, err := dc.client.Core().ReplicationControllers(rc.ObjectMeta.Namespace).Update(&rc)
 	return err
 }
 
@@ -913,7 +913,7 @@ func (dc *DeploymentController) cleanupOldRcs(oldRCs []*api.ReplicationControlle
 		if controller.Spec.Replicas != 0 || controller.Generation > controller.Status.ObservedGeneration {
 			continue
 		}
-		if err := dc.client.Legacy().ReplicationControllers(controller.Namespace).Delete(controller.Name, nil); err != nil && !errors.IsNotFound(err) {
+		if err := dc.client.Core().ReplicationControllers(controller.Namespace).Delete(controller.Name, nil); err != nil && !errors.IsNotFound(err) {
 			glog.V(2).Infof("Failed deleting old rc %v for deployment %v: %v", controller.Name, deployment.Name, err)
 			errList = append(errList, err)
 		}
@@ -967,7 +967,7 @@ func (dc *DeploymentController) scaleRCAndRecordEvent(rc *api.ReplicationControl
 func (dc *DeploymentController) scaleRC(rc *api.ReplicationController, newScale int) (*api.ReplicationController, error) {
 	// TODO: Using client for now, update to use store when it is ready.
 	rc.Spec.Replicas = newScale
-	return dc.client.Legacy().ReplicationControllers(rc.ObjectMeta.Namespace).Update(rc)
+	return dc.client.Core().ReplicationControllers(rc.ObjectMeta.Namespace).Update(rc)
 }
 
 func (dc *DeploymentController) updateDeployment(deployment *extensions.Deployment) (*extensions.Deployment, error) {

pkg/controller/endpoint/endpoints_controller.go

@@ -62,10 +62,10 @@ func NewEndpointController(client *clientset.Clientset, resyncPeriod controller.
 	e.serviceStore.Store, e.serviceController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return e.client.Legacy().Services(api.NamespaceAll).List(options)
+				return e.client.Core().Services(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return e.client.Legacy().Services(api.NamespaceAll).Watch(options)
+				return e.client.Core().Services(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Service{},
@@ -83,10 +83,10 @@ func NewEndpointController(client *clientset.Clientset, resyncPeriod controller.
 	e.podStore.Store, e.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return e.client.Legacy().Pods(api.NamespaceAll).List(options)
+				return e.client.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return e.client.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return e.client.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},

pkg/controller/gc/gc_controller.go

@@ -53,7 +53,7 @@ func New(kubeClient clientset.Interface, resyncPeriod controller.ResyncPeriodFun
 		kubeClient: kubeClient,
 		threshold:  threshold,
 		deletePod: func(namespace, name string) error {
-			return kubeClient.Legacy().Pods(namespace).Delete(name, api.NewDeleteOptions(0))
+			return kubeClient.Core().Pods(namespace).Delete(name, api.NewDeleteOptions(0))
 		},
 	}
 
@@ -63,11 +63,11 @@ func New(kubeClient clientset.Interface, resyncPeriod controller.ResyncPeriodFun
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 				options.FieldSelector = terminatedSelector
-				return gcc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+				return gcc.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 				options.FieldSelector = terminatedSelector
-				return gcc.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return gcc.kubeClient.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},

pkg/controller/job/controller.go

@@ -29,7 +29,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
 	"k8s.io/kubernetes/pkg/client/record"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/controller/framework"
 	replicationcontroller "k8s.io/kubernetes/pkg/controller/replication"
@@ -74,7 +74,7 @@ func NewJobController(kubeClient clientset.Interface, resyncPeriod controller.Re
 	eventBroadcaster := record.NewBroadcaster()
 	eventBroadcaster.StartLogging(glog.Infof)
 	// TODO: remove the wrapper when every clients have moved to use the clientset.
-	eventBroadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kubeClient.Legacy().Events("")})
+	eventBroadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{kubeClient.Core().Events("")})
 
 	jm := &JobController{
 		kubeClient: kubeClient,
@@ -113,10 +113,10 @@ func NewJobController(kubeClient clientset.Interface, resyncPeriod controller.Re
 	jm.podStore.Store, jm.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return jm.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+				return jm.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return jm.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return jm.kubeClient.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},

pkg/controller/namespace/namespace_controller.go

@@ -47,10 +47,10 @@ func NewNamespaceController(kubeClient clientset.Interface, versions *unversione
 	_, controller = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return kubeClient.Legacy().Namespaces().List(options)
+				return kubeClient.Core().Namespaces().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return kubeClient.Legacy().Namespaces().Watch(options)
+				return kubeClient.Core().Namespaces().Watch(options)
 			},
 		},
 		&api.Namespace{},
@@ -140,7 +140,7 @@ func finalizeNamespaceFunc(kubeClient clientset.Interface, namespace *api.Namesp
 	for _, value := range finalizerSet.List() {
 		namespaceFinalize.Spec.Finalizers = append(namespaceFinalize.Spec.Finalizers, api.FinalizerName(value))
 	}
-	namespace, err := kubeClient.Legacy().Namespaces().Finalize(&namespaceFinalize)
+	namespace, err := kubeClient.Core().Namespaces().Finalize(&namespaceFinalize)
 	if err != nil {
 		// it was removed already, so life is good
 		if errors.IsNotFound(err) {
@@ -253,7 +253,7 @@ func retryOnConflictError(kubeClient clientset.Interface, namespace *api.Namespa
 		if !errors.IsConflict(err) {
 			return nil, err
 		}
-		latestNamespace, err = kubeClient.Legacy().Namespaces().Get(latestNamespace.Name)
+		latestNamespace, err = kubeClient.Core().Namespaces().Get(latestNamespace.Name)
 		if err != nil {
 			return nil, err
 		}
@@ -270,7 +270,7 @@ func updateNamespaceStatusFunc(kubeClient clientset.Interface, namespace *api.Na
 	newNamespace.ObjectMeta = namespace.ObjectMeta
 	newNamespace.Status = namespace.Status
 	newNamespace.Status.Phase = api.NamespaceTerminating
-	return kubeClient.Legacy().Namespaces().UpdateStatus(&newNamespace)
+	return kubeClient.Core().Namespaces().UpdateStatus(&newNamespace)
 }
 
 // syncNamespace orchestrates deletion of a Namespace and its associated content.
@@ -282,7 +282,7 @@ func syncNamespace(kubeClient clientset.Interface, versions *unversioned.APIVers
 	// multiple controllers may edit a namespace during termination
 	// first get the latest state of the namespace before proceeding
 	// if the namespace was deleted already, don't do anything
-	namespace, err := kubeClient.Legacy().Namespaces().Get(namespace.Name)
+	namespace, err := kubeClient.Core().Namespaces().Get(namespace.Name)
 	if err != nil {
 		if errors.IsNotFound(err) {
 			return nil
@@ -304,7 +304,7 @@ func syncNamespace(kubeClient clientset.Interface, versions *unversioned.APIVers
 
 	// if the namespace is already finalized, delete it
 	if finalized(namespace) {
-		err = kubeClient.Legacy().Namespaces().Delete(namespace.Name, nil)
+		err = kubeClient.Core().Namespaces().Delete(namespace.Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}
@@ -328,7 +328,7 @@ func syncNamespace(kubeClient clientset.Interface, versions *unversioned.APIVers
 
 	// now check if all finalizers have reported that we delete now
 	if finalized(result) {
-		err = kubeClient.Legacy().Namespaces().Delete(namespace.Name, nil)
+		err = kubeClient.Core().Namespaces().Delete(namespace.Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}
@@ -338,12 +338,12 @@ func syncNamespace(kubeClient clientset.Interface, versions *unversioned.APIVers
 }
 
 func deleteLimitRanges(kubeClient clientset.Interface, ns string) error {
-	items, err := kubeClient.Legacy().LimitRanges(ns).List(api.ListOptions{})
+	items, err := kubeClient.Core().LimitRanges(ns).List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
 	for i := range items.Items {
-		err := kubeClient.Legacy().LimitRanges(ns).Delete(items.Items[i].Name, nil)
+		err := kubeClient.Core().LimitRanges(ns).Delete(items.Items[i].Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}
@@ -352,12 +352,12 @@ func deleteLimitRanges(kubeClient clientset.Interface, ns string) error {
 }
 
 func deleteResourceQuotas(kubeClient clientset.Interface, ns string) error {
-	resourceQuotas, err := kubeClient.Legacy().ResourceQuotas(ns).List(api.ListOptions{})
+	resourceQuotas, err := kubeClient.Core().ResourceQuotas(ns).List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
 	for i := range resourceQuotas.Items {
-		err := kubeClient.Legacy().ResourceQuotas(ns).Delete(resourceQuotas.Items[i].Name, nil)
+		err := kubeClient.Core().ResourceQuotas(ns).Delete(resourceQuotas.Items[i].Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}
@@ -366,12 +366,12 @@ func deleteResourceQuotas(kubeClient clientset.Interface, ns string) error {
 }
 
 func deleteServiceAccounts(kubeClient clientset.Interface, ns string) error {
-	items, err := kubeClient.Legacy().ServiceAccounts(ns).List(api.ListOptions{})
+	items, err := kubeClient.Core().ServiceAccounts(ns).List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
 	for i := range items.Items {
-		err := kubeClient.Legacy().ServiceAccounts(ns).Delete(items.Items[i].Name, nil)
+		err := kubeClient.Core().ServiceAccounts(ns).Delete(items.Items[i].Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}
@@ -380,12 +380,12 @@ func deleteServiceAccounts(kubeClient clientset.Interface, ns string) error {
 }
 
 func deleteServices(kubeClient clientset.Interface, ns string) error {
-	items, err := kubeClient.Legacy().Services(ns).List(api.ListOptions{})
+	items, err := kubeClient.Core().Services(ns).List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
 	for i := range items.Items {
-		err := kubeClient.Legacy().Services(ns).Delete(items.Items[i].Name, nil)
+		err := kubeClient.Core().Services(ns).Delete(items.Items[i].Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}
@@ -394,12 +394,12 @@ func deleteServices(kubeClient clientset.Interface, ns string) error {
 }
 
 func deleteReplicationControllers(kubeClient clientset.Interface, ns string) error {
-	items, err := kubeClient.Legacy().ReplicationControllers(ns).List(api.ListOptions{})
+	items, err := kubeClient.Core().ReplicationControllers(ns).List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
 	for i := range items.Items {
-		err := kubeClient.Legacy().ReplicationControllers(ns).Delete(items.Items[i].Name, nil)
+		err := kubeClient.Core().ReplicationControllers(ns).Delete(items.Items[i].Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}
@@ -408,7 +408,7 @@ func deleteReplicationControllers(kubeClient clientset.Interface, ns string) err
 }
 
 func deletePods(kubeClient clientset.Interface, ns string, before unversioned.Time) (int64, error) {
-	items, err := kubeClient.Legacy().Pods(ns).List(api.ListOptions{})
+	items, err := kubeClient.Core().Pods(ns).List(api.ListOptions{})
 	if err != nil {
 		return 0, err
 	}
@@ -425,7 +425,7 @@ func deletePods(kubeClient clientset.Interface, ns string, before unversioned.Ti
 				estimate = grace
 			}
 		}
-		err := kubeClient.Legacy().Pods(ns).Delete(items.Items[i].Name, deleteOptions)
+		err := kubeClient.Core().Pods(ns).Delete(items.Items[i].Name, deleteOptions)
 		if err != nil && !errors.IsNotFound(err) {
 			return 0, err
 		}
@@ -437,16 +437,16 @@ func deletePods(kubeClient clientset.Interface, ns string, before unversioned.Ti
 }
 
 func deleteEvents(kubeClient clientset.Interface, ns string) error {
-	return kubeClient.Legacy().Events(ns).DeleteCollection(nil, api.ListOptions{})
+	return kubeClient.Core().Events(ns).DeleteCollection(nil, api.ListOptions{})
 }
 
 func deleteSecrets(kubeClient clientset.Interface, ns string) error {
-	items, err := kubeClient.Legacy().Secrets(ns).List(api.ListOptions{})
+	items, err := kubeClient.Core().Secrets(ns).List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
 	for i := range items.Items {
-		err := kubeClient.Legacy().Secrets(ns).Delete(items.Items[i].Name, nil)
+		err := kubeClient.Core().Secrets(ns).Delete(items.Items[i].Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}
@@ -455,12 +455,12 @@ func deleteSecrets(kubeClient clientset.Interface, ns string) error {
 }
 
 func deletePersistentVolumeClaims(kubeClient clientset.Interface, ns string) error {
-	items, err := kubeClient.Legacy().PersistentVolumeClaims(ns).List(api.ListOptions{})
+	items, err := kubeClient.Core().PersistentVolumeClaims(ns).List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
 	for i := range items.Items {
-		err := kubeClient.Legacy().PersistentVolumeClaims(ns).Delete(items.Items[i].Name, nil)
+		err := kubeClient.Core().PersistentVolumeClaims(ns).Delete(items.Items[i].Name, nil)
 		if err != nil && !errors.IsNotFound(err) {
 			return err
 		}

pkg/controller/node/nodecontroller.go

@@ -30,7 +30,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
 	"k8s.io/kubernetes/pkg/client/record"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/controller"
@@ -138,7 +138,7 @@ func NewNodeController(
 	eventBroadcaster.StartLogging(glog.Infof)
 	if kubeClient != nil {
 		glog.Infof("Sending events to api server.")
-		eventBroadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kubeClient.Legacy().Events("")})
+		eventBroadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{kubeClient.Core().Events("")})
 	} else {
 		glog.Infof("No api server defined - no events will be sent to API server.")
 	}
@@ -171,10 +171,10 @@ func NewNodeController(
 	nc.podStore.Store, nc.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+				return nc.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return nc.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return nc.kubeClient.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},
@@ -187,10 +187,10 @@ func NewNodeController(
 	nc.nodeStore.Store, nc.nodeController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return nc.kubeClient.Legacy().Nodes().List(options)
+				return nc.kubeClient.Core().Nodes().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return nc.kubeClient.Legacy().Nodes().Watch(options)
+				return nc.kubeClient.Core().Nodes().Watch(options)
 			},
 		},
 		&api.Node{},
@@ -367,7 +367,7 @@ func (nc *NodeController) maybeDeleteTerminatingPod(obj interface{}) {
 
 func forcefullyDeletePod(c clientset.Interface, pod *api.Pod) {
 	var zero int64
-	err := c.Legacy().Pods(pod.Namespace).Delete(pod.Name, &api.DeleteOptions{GracePeriodSeconds: &zero})
+	err := c.Core().Pods(pod.Namespace).Delete(pod.Name, &api.DeleteOptions{GracePeriodSeconds: &zero})
 	if err != nil {
 		utilruntime.HandleError(err)
 	}
@@ -377,7 +377,7 @@ func forcefullyDeletePod(c clientset.Interface, pod *api.Pod) {
 // post "NodeReady==ConditionUnknown". It also evicts all pods if node is not ready or
 // not reachable for a long period of time.
 func (nc *NodeController) monitorNodeStatus() error {
-	nodes, err := nc.kubeClient.Legacy().Nodes().List(api.ListOptions{})
+	nodes, err := nc.kubeClient.Core().Nodes().List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
@@ -421,7 +421,7 @@ func (nc *NodeController) monitorNodeStatus() error {
 				break
 			}
 			name := node.Name
-			node, err = nc.kubeClient.Legacy().Nodes().Get(name)
+			node, err = nc.kubeClient.Core().Nodes().Get(name)
 			if err != nil {
 				glog.Errorf("Failed while getting a Node to retry updating NodeStatus. Probably Node %s was deleted.", name)
 				break
@@ -487,7 +487,7 @@ func (nc *NodeController) monitorNodeStatus() error {
 						continue
 					}
 
-					if err := nc.kubeClient.Legacy().Nodes().Delete(node.Name, nil); err != nil {
+					if err := nc.kubeClient.Core().Nodes().Delete(node.Name, nil); err != nil {
 						glog.Errorf("Unable to delete node %s: %v", node.Name, err)
 						continue
 					}
@@ -520,7 +520,7 @@ func (nc *NodeController) reconcileNodeCIDRs(nodes *api.NodeList) {
 			}
 			glog.V(4).Infof("Assigning node %s CIDR %s", node.Name, podCIDR)
 			node.Spec.PodCIDR = podCIDR
-			if _, err := nc.kubeClient.Legacy().Nodes().Update(&node); err != nil {
+			if _, err := nc.kubeClient.Core().Nodes().Update(&node); err != nil {
 				nc.recordNodeStatusChange(&node, "CIDRAssignmentFailed")
 			}
 		}
@@ -698,7 +698,7 @@ func (nc *NodeController) tryUpdateNodeStatus(node *api.Node) (time.Duration, ap
 		}
 
 		if !api.Semantic.DeepEqual(nc.getCondition(&node.Status, api.NodeReady), &lastReadyCondition) {
-			if _, err = nc.kubeClient.Legacy().Nodes().UpdateStatus(node); err != nil {
+			if _, err = nc.kubeClient.Core().Nodes().UpdateStatus(node); err != nil {
 				glog.Errorf("Error updating node %s: %v", node.Name, err)
 				return gracePeriod, lastReadyCondition, readyCondition, err
 			} else {
@@ -720,7 +720,7 @@ func (nc *NodeController) tryUpdateNodeStatus(node *api.Node) (time.Duration, ap
 func (nc *NodeController) hasPods(nodeName string) (bool, error) {
 	selector := fields.OneTermEqualSelector(client.PodHost, nodeName)
 	options := api.ListOptions{FieldSelector: selector}
-	pods, err := nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+	pods, err := nc.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 	if err != nil {
 		return false, err
 	}
@@ -755,7 +755,7 @@ func (nc *NodeController) deletePods(nodeName string) (bool, error) {
 	remaining := false
 	selector := fields.OneTermEqualSelector(client.PodHost, nodeName)
 	options := api.ListOptions{FieldSelector: selector}
-	pods, err := nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+	pods, err := nc.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 	if err != nil {
 		return remaining, err
 	}
@@ -781,7 +781,7 @@ func (nc *NodeController) deletePods(nodeName string) (bool, error) {
 
 		glog.V(2).Infof("Starting deletion of pod %v", pod.Name)
 		nc.recorder.Eventf(&pod, api.EventTypeNormal, "NodeControllerEviction", "Marking for deletion Pod %s from Node %s", pod.Name, nodeName)
-		if err := nc.kubeClient.Legacy().Pods(pod.Namespace).Delete(pod.Name, nil); err != nil {
+		if err := nc.kubeClient.Core().Pods(pod.Namespace).Delete(pod.Name, nil); err != nil {
 			return false, err
 		}
 		remaining = true
@@ -794,7 +794,7 @@ func (nc *NodeController) deletePods(nodeName string) (bool, error) {
 func (nc *NodeController) markAllPodsNotReady(nodeName string) error {
 	glog.V(2).Infof("Update ready status of pods on node [%v]", nodeName)
 	opts := api.ListOptions{FieldSelector: fields.OneTermEqualSelector(client.PodHost, nodeName)}
-	pods, err := nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(opts)
+	pods, err := nc.kubeClient.Core().Pods(api.NamespaceAll).List(opts)
 	if err != nil {
 		return err
 	}
@@ -810,7 +810,7 @@ func (nc *NodeController) markAllPodsNotReady(nodeName string) error {
 			if cond.Type == api.PodReady {
 				pod.Status.Conditions[i].Status = api.ConditionFalse
 				glog.V(2).Infof("Updating ready status of pod %v to false", pod.Name)
-				pod, err := nc.kubeClient.Legacy().Pods(pod.Namespace).UpdateStatus(&pod)
+				pod, err := nc.kubeClient.Core().Pods(pod.Namespace).UpdateStatus(&pod)
 				if err != nil {
 					glog.Warningf("Failed to updated status for pod %q: %v", format.Pod(pod), err)
 					errMsg = append(errMsg, fmt.Sprintf("%v", err))
@@ -836,7 +836,7 @@ func (nc *NodeController) terminatePods(nodeName string, since time.Time) (bool,
 
 	selector := fields.OneTermEqualSelector(client.PodHost, nodeName)
 	options := api.ListOptions{FieldSelector: selector}
-	pods, err := nc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+	pods, err := nc.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 	if err != nil {
 		return false, nextAttempt, err
 	}
@@ -865,7 +865,7 @@ func (nc *NodeController) terminatePods(nodeName string, since time.Time) (bool,
 			remaining = 0
 			glog.V(2).Infof("Removing pod %v after %s grace period", pod.Name, grace)
 			nc.recordNodeEvent(nodeName, api.EventTypeNormal, "TerminatingEvictedPod", fmt.Sprintf("Pod %s has exceeded the grace period for deletion after being evicted from Node %q and is being force killed", pod.Name, nodeName))
-			if err := nc.kubeClient.Legacy().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil {
+			if err := nc.kubeClient.Core().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil {
 				glog.Errorf("Error completing deletion of pod %s: %v", pod.Name, err)
 				complete = false
 			}

pkg/controller/node/nodecontroller_test.go

@@ -29,7 +29,7 @@ import (
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/client/cache"
 	"k8s.io/kubernetes/pkg/client/testing/fake"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	"k8s.io/kubernetes/pkg/util"
 	"k8s.io/kubernetes/pkg/watch"
 )
@@ -63,15 +63,15 @@ type FakeNodeHandler struct {
 }
 
 type FakeLegacyHandler struct {
-	unversioned_legacy.LegacyInterface
+	unversioned_core.CoreInterface
 	n *FakeNodeHandler
 }
 
-func (c *FakeNodeHandler) Legacy() unversioned_legacy.LegacyInterface {
+func (c *FakeNodeHandler) Core() unversioned_core.CoreInterface {
-	return &FakeLegacyHandler{c.Clientset.Legacy(), c}
+	return &FakeLegacyHandler{c.Clientset.Core(), c}
 }
 
-func (m *FakeLegacyHandler) Nodes() unversioned_legacy.NodeInterface {
+func (m *FakeLegacyHandler) Nodes() unversioned_core.NodeInterface {
 	return m.n
 }
 

pkg/controller/persistentvolume/persistentvolume_claim_binder_controller.go

@@ -55,10 +55,10 @@ func NewPersistentVolumeClaimBinder(kubeClient clientset.Interface, syncPeriod t
 	_, volumeController := framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return kubeClient.Legacy().PersistentVolumes().List(options)
+				return kubeClient.Core().PersistentVolumes().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return kubeClient.Legacy().PersistentVolumes().Watch(options)
+				return kubeClient.Core().PersistentVolumes().Watch(options)
 			},
 		},
 		&api.PersistentVolume{},
@@ -73,10 +73,10 @@ func NewPersistentVolumeClaimBinder(kubeClient clientset.Interface, syncPeriod t
 	_, claimController := framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return kubeClient.Legacy().PersistentVolumeClaims(api.NamespaceAll).List(options)
+				return kubeClient.Core().PersistentVolumeClaims(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return kubeClient.Legacy().PersistentVolumeClaims(api.NamespaceAll).Watch(options)
+				return kubeClient.Core().PersistentVolumeClaims(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.PersistentVolumeClaim{},
@@ -462,29 +462,29 @@ type realBinderClient struct {
 }
 
 func (c *realBinderClient) GetPersistentVolume(name string) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().Get(name)
+	return c.client.Core().PersistentVolumes().Get(name)
 }
 
 func (c *realBinderClient) UpdatePersistentVolume(volume *api.PersistentVolume) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().Update(volume)
+	return c.client.Core().PersistentVolumes().Update(volume)
 }
 
 func (c *realBinderClient) DeletePersistentVolume(volume *api.PersistentVolume) error {
-	return c.client.Legacy().PersistentVolumes().Delete(volume.Name, nil)
+	return c.client.Core().PersistentVolumes().Delete(volume.Name, nil)
 }
 
 func (c *realBinderClient) UpdatePersistentVolumeStatus(volume *api.PersistentVolume) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().UpdateStatus(volume)
+	return c.client.Core().PersistentVolumes().UpdateStatus(volume)
 }
 
 func (c *realBinderClient) GetPersistentVolumeClaim(namespace, name string) (*api.PersistentVolumeClaim, error) {
-	return c.client.Legacy().PersistentVolumeClaims(namespace).Get(name)
+	return c.client.Core().PersistentVolumeClaims(namespace).Get(name)
 }
 
 func (c *realBinderClient) UpdatePersistentVolumeClaim(claim *api.PersistentVolumeClaim) (*api.PersistentVolumeClaim, error) {
-	return c.client.Legacy().PersistentVolumeClaims(claim.Namespace).Update(claim)
+	return c.client.Core().PersistentVolumeClaims(claim.Namespace).Update(claim)
 }
 
 func (c *realBinderClient) UpdatePersistentVolumeClaimStatus(claim *api.PersistentVolumeClaim) (*api.PersistentVolumeClaim, error) {
-	return c.client.Legacy().PersistentVolumeClaims(claim.Namespace).UpdateStatus(claim)
+	return c.client.Core().PersistentVolumeClaims(claim.Namespace).UpdateStatus(claim)
 }

pkg/controller/persistentvolume/persistentvolume_claim_binder_controller_test.go

@@ -300,7 +300,7 @@ func TestExampleObjects(t *testing.T) {
 		clientset.AddReactor("*", "*", core.ObjectReaction(o, api.RESTMapper))
 
 		if reflect.TypeOf(scenario.expected) == reflect.TypeOf(&api.PersistentVolumeClaim{}) {
-			pvc, err := clientset.Legacy().PersistentVolumeClaims("ns").Get("doesntmatter")
+			pvc, err := clientset.Core().PersistentVolumeClaims("ns").Get("doesntmatter")
 			if err != nil {
 				t.Fatalf("Error retrieving object: %v", err)
 			}
@@ -321,7 +321,7 @@ func TestExampleObjects(t *testing.T) {
 		}
 
 		if reflect.TypeOf(scenario.expected) == reflect.TypeOf(&api.PersistentVolume{}) {
-			pv, err := clientset.Legacy().PersistentVolumes().Get("doesntmatter")
+			pv, err := clientset.Core().PersistentVolumes().Get("doesntmatter")
 			if err != nil {
 				t.Fatalf("Error retrieving object: %v", err)
 			}
@@ -366,7 +366,7 @@ func TestBindingWithExamples(t *testing.T) {
 	clientset := &fake.Clientset{}
 	clientset.AddReactor("*", "*", core.ObjectReaction(o, api.RESTMapper))
 
-	pv, err := clientset.Legacy().PersistentVolumes().Get("any")
+	pv, err := clientset.Core().PersistentVolumes().Get("any")
 	if err != nil {
 		t.Errorf("Unexpected error getting PV from client: %v", err)
 	}
@@ -381,7 +381,7 @@ func TestBindingWithExamples(t *testing.T) {
 	// Test that !Pending gets correctly added
 	pv.Status.Phase = api.VolumeAvailable
 
-	claim, error := clientset.Legacy().PersistentVolumeClaims("ns").Get("any")
+	claim, error := clientset.Core().PersistentVolumeClaims("ns").Get("any")
 	if error != nil {
 		t.Errorf("Unexpected error getting PVC from client: %v", err)
 	}

pkg/controller/persistentvolume/persistentvolume_provisioner_controller.go

@@ -382,51 +382,51 @@ type realControllerClient struct {
 }
 
 func (c *realControllerClient) GetPersistentVolume(name string) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().Get(name)
+	return c.client.Core().PersistentVolumes().Get(name)
 }
 
 func (c *realControllerClient) ListPersistentVolumes(options api.ListOptions) (*api.PersistentVolumeList, error) {
-	return c.client.Legacy().PersistentVolumes().List(options)
+	return c.client.Core().PersistentVolumes().List(options)
 }
 
 func (c *realControllerClient) WatchPersistentVolumes(options api.ListOptions) (watch.Interface, error) {
-	return c.client.Legacy().PersistentVolumes().Watch(options)
+	return c.client.Core().PersistentVolumes().Watch(options)
 }
 
 func (c *realControllerClient) CreatePersistentVolume(pv *api.PersistentVolume) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().Create(pv)
+	return c.client.Core().PersistentVolumes().Create(pv)
 }
 
 func (c *realControllerClient) UpdatePersistentVolume(volume *api.PersistentVolume) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().Update(volume)
+	return c.client.Core().PersistentVolumes().Update(volume)
 }
 
 func (c *realControllerClient) DeletePersistentVolume(volume *api.PersistentVolume) error {
-	return c.client.Legacy().PersistentVolumes().Delete(volume.Name, nil)
+	return c.client.Core().PersistentVolumes().Delete(volume.Name, nil)
 }
 
 func (c *realControllerClient) UpdatePersistentVolumeStatus(volume *api.PersistentVolume) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().UpdateStatus(volume)
+	return c.client.Core().PersistentVolumes().UpdateStatus(volume)
 }
 
 func (c *realControllerClient) GetPersistentVolumeClaim(namespace, name string) (*api.PersistentVolumeClaim, error) {
-	return c.client.Legacy().PersistentVolumeClaims(namespace).Get(name)
+	return c.client.Core().PersistentVolumeClaims(namespace).Get(name)
 }
 
 func (c *realControllerClient) ListPersistentVolumeClaims(namespace string, options api.ListOptions) (*api.PersistentVolumeClaimList, error) {
-	return c.client.Legacy().PersistentVolumeClaims(namespace).List(options)
+	return c.client.Core().PersistentVolumeClaims(namespace).List(options)
 }
 
 func (c *realControllerClient) WatchPersistentVolumeClaims(namespace string, options api.ListOptions) (watch.Interface, error) {
-	return c.client.Legacy().PersistentVolumeClaims(namespace).Watch(options)
+	return c.client.Core().PersistentVolumeClaims(namespace).Watch(options)
 }
 
 func (c *realControllerClient) UpdatePersistentVolumeClaim(claim *api.PersistentVolumeClaim) (*api.PersistentVolumeClaim, error) {
-	return c.client.Legacy().PersistentVolumeClaims(claim.Namespace).Update(claim)
+	return c.client.Core().PersistentVolumeClaims(claim.Namespace).Update(claim)
 }
 
 func (c *realControllerClient) UpdatePersistentVolumeClaimStatus(claim *api.PersistentVolumeClaim) (*api.PersistentVolumeClaim, error) {
-	return c.client.Legacy().PersistentVolumeClaims(claim.Namespace).UpdateStatus(claim)
+	return c.client.Core().PersistentVolumeClaims(claim.Namespace).UpdateStatus(claim)
 }
 
 func (c *realControllerClient) GetKubeClient() clientset.Interface {

pkg/controller/persistentvolume/persistentvolume_recycler_controller.go

@@ -64,10 +64,10 @@ func NewPersistentVolumeRecycler(kubeClient clientset.Interface, syncPeriod time
 	_, volumeController := framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return kubeClient.Legacy().PersistentVolumes().List(options)
+				return kubeClient.Core().PersistentVolumes().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return kubeClient.Legacy().PersistentVolumes().Watch(options)
+				return kubeClient.Core().PersistentVolumes().Watch(options)
 			},
 		},
 		&api.PersistentVolume{},
@@ -258,19 +258,19 @@ type realRecyclerClient struct {
 }
 
 func (c *realRecyclerClient) GetPersistentVolume(name string) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().Get(name)
+	return c.client.Core().PersistentVolumes().Get(name)
 }
 
 func (c *realRecyclerClient) UpdatePersistentVolume(volume *api.PersistentVolume) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().Update(volume)
+	return c.client.Core().PersistentVolumes().Update(volume)
 }
 
 func (c *realRecyclerClient) DeletePersistentVolume(volume *api.PersistentVolume) error {
-	return c.client.Legacy().PersistentVolumes().Delete(volume.Name, nil)
+	return c.client.Core().PersistentVolumes().Delete(volume.Name, nil)
 }
 
 func (c *realRecyclerClient) UpdatePersistentVolumeStatus(volume *api.PersistentVolume) (*api.PersistentVolume, error) {
-	return c.client.Legacy().PersistentVolumes().UpdateStatus(volume)
+	return c.client.Core().PersistentVolumes().UpdateStatus(volume)
 }
 
 // PersistentVolumeRecycler is host to the volume plugins, but does not actually mount any volumes.

pkg/controller/podautoscaler/horizontal.go

@@ -28,8 +28,8 @@ import (
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/client/record"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	unversioned_extensions "k8s.io/kubernetes/pkg/client/typed/generated/extensions/unversioned"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
 	"k8s.io/kubernetes/pkg/controller/podautoscaler/metrics"
 	"k8s.io/kubernetes/pkg/util"
 )
@@ -54,7 +54,7 @@ type HorizontalController struct {
 var downscaleForbiddenWindow = 5 * time.Minute
 var upscaleForbiddenWindow = 3 * time.Minute
 
-func NewHorizontalController(evtNamespacer unversioned_legacy.EventsGetter, scaleNamespacer unversioned_extensions.ScalesGetter, hpaNamespacer unversioned_extensions.HorizontalPodAutoscalersGetter, metricsClient metrics.MetricsClient) *HorizontalController {
+func NewHorizontalController(evtNamespacer unversioned_core.EventsGetter, scaleNamespacer unversioned_extensions.ScalesGetter, hpaNamespacer unversioned_extensions.HorizontalPodAutoscalersGetter, metricsClient metrics.MetricsClient) *HorizontalController {
 	broadcaster := record.NewBroadcaster()
 	broadcaster.StartRecordingToSink(evtNamespacer.Events(""))
 	recorder := broadcaster.NewRecorder(api.EventSource{Component: "horizontal-pod-autoscaler"})

pkg/controller/podautoscaler/horizontal_test.go

@@ -217,7 +217,7 @@ func (tc *testCase) verifyResults(t *testing.T) {
 func (tc *testCase) runTest(t *testing.T) {
 	testClient := tc.prepareTestClient(t)
 	metricsClient := metrics.NewHeapsterMetricsClient(testClient, metrics.DefaultHeapsterNamespace, metrics.DefaultHeapsterScheme, metrics.DefaultHeapsterService, metrics.DefaultHeapsterPort)
-	hpaController := NewHorizontalController(testClient.Legacy(), testClient.Extensions(), testClient.Extensions(), metricsClient)
+	hpaController := NewHorizontalController(testClient.Core(), testClient.Extensions(), testClient.Extensions(), metricsClient)
 	err := hpaController.reconcileAutoscalers()
 	assert.Equal(t, nil, err)
 	if tc.verifyEvents {

pkg/controller/podautoscaler/metrics/metrics_client.go

@@ -113,7 +113,7 @@ func (h *HeapsterMetricsClient) GetCpuConsumptionAndRequestInMillis(namespace st
 	avgRequest int64, timestamp time.Time, err error) {
 
 	labelSelector := labels.SelectorFromSet(labels.Set(selector))
-	podList, err := h.client.Legacy().Pods(namespace).
+	podList, err := h.client.Core().Pods(namespace).
 		List(api.ListOptions{LabelSelector: labelSelector})
 
 	if err != nil {
@@ -152,7 +152,7 @@ func (h *HeapsterMetricsClient) GetCustomMetric(customMetricName string, namespa
 	metricSpec := getHeapsterCustomMetricDefinition(customMetricName)
 
 	labelSelector := labels.SelectorFromSet(labels.Set(selector))
-	podList, err := h.client.Legacy().Pods(namespace).List(api.ListOptions{LabelSelector: labelSelector})
+	podList, err := h.client.Core().Pods(namespace).List(api.ListOptions{LabelSelector: labelSelector})
 
 	if err != nil {
 		return nil, time.Time{}, fmt.Errorf("failed to get pod list: %v", err)
@@ -179,7 +179,7 @@ func (h *HeapsterMetricsClient) getForPods(metricSpec metricDefinition, namespac
 		strings.Join(podNames, ","),
 		metricSpec.name)
 
-	resultRaw, err := h.client.Legacy().Services(h.heapsterNamespace).
+	resultRaw, err := h.client.Core().Services(h.heapsterNamespace).
 		ProxyGet(h.heapsterScheme, h.heapsterService, h.heapsterPort, metricPath, map[string]string{"start": startTime.Format(time.RFC3339)}).
 		DoRaw()
 

pkg/controller/replicaset/replica_set.go

@@ -30,7 +30,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
 	"k8s.io/kubernetes/pkg/client/record"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/controller/framework"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -93,7 +93,7 @@ type ReplicaSetController struct {
 func NewReplicaSetController(kubeClient clientset.Interface, resyncPeriod controller.ResyncPeriodFunc, burstReplicas int) *ReplicaSetController {
 	eventBroadcaster := record.NewBroadcaster()
 	eventBroadcaster.StartLogging(glog.Infof)
-	eventBroadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kubeClient.Legacy().Events("")})
+	eventBroadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{kubeClient.Core().Events("")})
 
 	rsc := &ReplicaSetController{
 		kubeClient: kubeClient,
@@ -150,10 +150,10 @@ func NewReplicaSetController(kubeClient clientset.Interface, resyncPeriod contro
 	rsc.podStore.Store, rsc.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return rsc.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+				return rsc.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return rsc.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return rsc.kubeClient.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},

pkg/controller/replication/replication_controller.go

@@ -29,7 +29,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
 	"k8s.io/kubernetes/pkg/client/record"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/controller/framework"
 	"k8s.io/kubernetes/pkg/labels"
@@ -95,7 +95,7 @@ type ReplicationManager struct {
 func NewReplicationManager(kubeClient clientset.Interface, resyncPeriod controller.ResyncPeriodFunc, burstReplicas int) *ReplicationManager {
 	eventBroadcaster := record.NewBroadcaster()
 	eventBroadcaster.StartLogging(glog.Infof)
-	eventBroadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kubeClient.Legacy().Events("")})
+	eventBroadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{kubeClient.Core().Events("")})
 
 	rm := &ReplicationManager{
 		kubeClient: kubeClient,
@@ -111,10 +111,10 @@ func NewReplicationManager(kubeClient clientset.Interface, resyncPeriod controll
 	rm.rcStore.Store, rm.rcController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return rm.kubeClient.Legacy().ReplicationControllers(api.NamespaceAll).List(options)
+				return rm.kubeClient.Core().ReplicationControllers(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return rm.kubeClient.Legacy().ReplicationControllers(api.NamespaceAll).Watch(options)
+				return rm.kubeClient.Core().ReplicationControllers(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.ReplicationController{},
@@ -152,10 +152,10 @@ func NewReplicationManager(kubeClient clientset.Interface, resyncPeriod controll
 	rm.podStore.Store, rm.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return rm.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+				return rm.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return rm.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return rm.kubeClient.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},
@@ -453,7 +453,7 @@ func (rm *ReplicationManager) syncReplicationController(key string) error {
 	}
 
 	// Always updates status as pods come up or die.
-	if err := updateReplicaCount(rm.kubeClient.Legacy().ReplicationControllers(rc.Namespace), rc, len(filteredPods)); err != nil {
+	if err := updateReplicaCount(rm.kubeClient.Core().ReplicationControllers(rc.Namespace), rc, len(filteredPods)); err != nil {
 		// Multiple things could lead to this update failing. Requeuing the controller ensures
 		// we retry with some fairness.
 		glog.V(2).Infof("Failed to update replica count for controller %v/%v; requeuing; error: %v", rc.Namespace, rc.Name, err)

pkg/controller/replication/replication_controller_test.go

@@ -600,7 +600,7 @@ func TestControllerUpdateStatusWithFailure(t *testing.T) {
 	c.AddReactor("*", "*", func(action core.Action) (bool, runtime.Object, error) {
 		return true, &api.ReplicationController{}, fmt.Errorf("Fake error")
 	})
-	fakeRCClient := c.Legacy().ReplicationControllers("default")
+	fakeRCClient := c.Core().ReplicationControllers("default")
 	numReplicas := 10
 	updateReplicaCount(fakeRCClient, *rc, numReplicas)
 	updates, gets := 0, 0

pkg/controller/replication/replication_controller_utils.go

@@ -21,11 +21,11 @@ package replication
 import (
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 )
 
 // updateReplicaCount attempts to update the Status.Replicas of the given controller, with a single GET/PUT retry.
-func updateReplicaCount(rcClient unversioned_legacy.ReplicationControllerInterface, controller api.ReplicationController, numReplicas int) (updateErr error) {
+func updateReplicaCount(rcClient unversioned_core.ReplicationControllerInterface, controller api.ReplicationController, numReplicas int) (updateErr error) {
 	// This is the steady state. It happens when the rc doesn't have any expectations, since
 	// we do a periodic relist every 30s. If the generations differ but the replicas are
 	// the same, a caller might've resized to the same replica count.

pkg/controller/resourcequota/resource_quota_controller.go

@@ -66,10 +66,10 @@ func NewResourceQuotaController(kubeClient clientset.Interface, resyncPeriod con
 	rq.rqIndexer, rq.rqController = framework.NewIndexerInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return rq.kubeClient.Legacy().ResourceQuotas(api.NamespaceAll).List(options)
+				return rq.kubeClient.Core().ResourceQuotas(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return rq.kubeClient.Legacy().ResourceQuotas(api.NamespaceAll).Watch(options)
+				return rq.kubeClient.Core().ResourceQuotas(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.ResourceQuota{},
@@ -106,10 +106,10 @@ func NewResourceQuotaController(kubeClient clientset.Interface, resyncPeriod con
 	rq.podStore.Store, rq.podController = framework.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return rq.kubeClient.Legacy().Pods(api.NamespaceAll).List(options)
+				return rq.kubeClient.Core().Pods(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return rq.kubeClient.Legacy().Pods(api.NamespaceAll).Watch(options)
+				return rq.kubeClient.Core().Pods(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Pod{},
@@ -265,7 +265,7 @@ func (rq *ResourceQuotaController) syncResourceQuota(quota api.ResourceQuota) (e
 
 	pods := &api.PodList{}
 	if set[api.ResourcePods] || set[api.ResourceMemory] || set[api.ResourceCPU] {
-		pods, err = rq.kubeClient.Legacy().Pods(usage.Namespace).List(api.ListOptions{})
+		pods, err = rq.kubeClient.Core().Pods(usage.Namespace).List(api.ListOptions{})
 		if err != nil {
 			return err
 		}
@@ -288,31 +288,31 @@ func (rq *ResourceQuotaController) syncResourceQuota(quota api.ResourceQuota) (e
 		case api.ResourcePods:
 			value = resource.NewQuantity(int64(len(filteredPods)), resource.DecimalSI)
 		case api.ResourceServices:
-			items, err := rq.kubeClient.Legacy().Services(usage.Namespace).List(api.ListOptions{})
+			items, err := rq.kubeClient.Core().Services(usage.Namespace).List(api.ListOptions{})
 			if err != nil {
 				return err
 			}
 			value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI)
 		case api.ResourceReplicationControllers:
-			items, err := rq.kubeClient.Legacy().ReplicationControllers(usage.Namespace).List(api.ListOptions{})
+			items, err := rq.kubeClient.Core().ReplicationControllers(usage.Namespace).List(api.ListOptions{})
 			if err != nil {
 				return err
 			}
 			value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI)
 		case api.ResourceQuotas:
-			items, err := rq.kubeClient.Legacy().ResourceQuotas(usage.Namespace).List(api.ListOptions{})
+			items, err := rq.kubeClient.Core().ResourceQuotas(usage.Namespace).List(api.ListOptions{})
 			if err != nil {
 				return err
 			}
 			value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI)
 		case api.ResourceSecrets:
-			items, err := rq.kubeClient.Legacy().Secrets(usage.Namespace).List(api.ListOptions{})
+			items, err := rq.kubeClient.Core().Secrets(usage.Namespace).List(api.ListOptions{})
 			if err != nil {
 				return err
 			}
 			value = resource.NewQuantity(int64(len(items.Items)), resource.DecimalSI)
 		case api.ResourcePersistentVolumeClaims:
-			items, err := rq.kubeClient.Legacy().PersistentVolumeClaims(usage.Namespace).List(api.ListOptions{})
+			items, err := rq.kubeClient.Core().PersistentVolumeClaims(usage.Namespace).List(api.ListOptions{})
 			if err != nil {
 				return err
 			}
@@ -334,7 +334,7 @@ func (rq *ResourceQuotaController) syncResourceQuota(quota api.ResourceQuota) (e
 
 	// update the usage only if it changed
 	if dirty {
-		_, err = rq.kubeClient.Legacy().ResourceQuotas(usage.Namespace).UpdateStatus(&usage)
+		_, err = rq.kubeClient.Core().ResourceQuotas(usage.Namespace).UpdateStatus(&usage)
 		return err
 	}
 	return nil

pkg/controller/route/routecontroller.go

@@ -59,7 +59,7 @@ func (rc *RouteController) reconcileNodeRoutes() error {
 	}
 	// TODO (cjcullen): use pkg/controller/framework.NewInformer to watch this
 	// and reduce the number of lists needed.
-	nodeList, err := rc.kubeClient.Legacy().Nodes().List(api.ListOptions{})
+	nodeList, err := rc.kubeClient.Core().Nodes().List(api.ListOptions{})
 	if err != nil {
 		return fmt.Errorf("error listing nodes: %v", err)
 	}

pkg/controller/service/servicecontroller.go

@@ -29,7 +29,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_2"
 	"k8s.io/kubernetes/pkg/client/record"
-	unversioned_legacy "k8s.io/kubernetes/pkg/client/typed/generated/legacy/unversioned"
+	unversioned_core "k8s.io/kubernetes/pkg/client/typed/generated/core/unversioned"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/types"
@@ -82,7 +82,7 @@ type ServiceController struct {
 // (like load balancers) in sync with the registry.
 func New(cloud cloudprovider.Interface, kubeClient clientset.Interface, clusterName string) *ServiceController {
 	broadcaster := record.NewBroadcaster()
-	broadcaster.StartRecordingToSink(&unversioned_legacy.EventSinkImpl{kubeClient.Legacy().Events("")})
+	broadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{kubeClient.Core().Events("")})
 	recorder := broadcaster.NewRecorder(api.EventSource{Component: "service-controller"})
 
 	return &ServiceController{
@@ -134,13 +134,13 @@ func (s *ServiceController) Run(serviceSyncPeriod, nodeSyncPeriod time.Duration)
 		}),
 		s.cache,
 	)
-	lw := cache.NewListWatchFromClient(s.kubeClient.(*clientset.Clientset).LegacyClient, "services", api.NamespaceAll, fields.Everything())
+	lw := cache.NewListWatchFromClient(s.kubeClient.(*clientset.Clientset).CoreClient, "services", api.NamespaceAll, fields.Everything())
 	cache.NewReflector(lw, &api.Service{}, serviceQueue, serviceSyncPeriod).Run()
 	for i := 0; i < workerGoroutines; i++ {
 		go s.watchServices(serviceQueue)
 	}
 
-	nodeLW := cache.NewListWatchFromClient(s.kubeClient.(*clientset.Clientset).LegacyClient, "nodes", api.NamespaceAll, fields.Everything())
+	nodeLW := cache.NewListWatchFromClient(s.kubeClient.(*clientset.Clientset).CoreClient, "nodes", api.NamespaceAll, fields.Everything())
 	cache.NewReflector(nodeLW, &api.Node{}, s.nodeLister.Store, 0).Run()
 	go s.nodeSyncLoop(nodeSyncPeriod)
 	return nil
@@ -344,7 +344,7 @@ func (s *ServiceController) createLoadBalancerIfNeeded(namespacedName types.Name
 func (s *ServiceController) persistUpdate(service *api.Service) error {
 	var err error
 	for i := 0; i < clientRetryCount; i++ {
-		_, err = s.kubeClient.Legacy().Services(service.Namespace).UpdateStatus(service)
+		_, err = s.kubeClient.Core().Services(service.Namespace).UpdateStatus(service)
 		if err == nil {
 			return nil
 		}

pkg/controller/serviceaccount/serviceaccounts_controller.go

@@ -82,11 +82,11 @@ func NewServiceAccountsController(cl clientset.Interface, options ServiceAccount
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 				options.FieldSelector = accountSelector
-				return e.client.Legacy().ServiceAccounts(api.NamespaceAll).List(options)
+				return e.client.Core().ServiceAccounts(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 				options.FieldSelector = accountSelector
-				return e.client.Legacy().ServiceAccounts(api.NamespaceAll).Watch(options)
+				return e.client.Core().ServiceAccounts(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.ServiceAccount{},
@@ -100,10 +100,10 @@ func NewServiceAccountsController(cl clientset.Interface, options ServiceAccount
 	e.namespaces, e.namespaceController = framework.NewIndexerInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return e.client.Legacy().Namespaces().List(options)
+				return e.client.Core().Namespaces().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return e.client.Legacy().Namespaces().Watch(options)
+				return e.client.Core().Namespaces().Watch(options)
 			},
 		},
 		&api.Namespace{},
@@ -217,7 +217,7 @@ func (e *ServiceAccountsController) createServiceAccountIfNeeded(sa api.ServiceA
 // createDefaultServiceAccount creates a default ServiceAccount in the specified namespace
 func (e *ServiceAccountsController) createServiceAccount(sa api.ServiceAccount, namespace string) {
 	sa.Namespace = namespace
-	if _, err := e.client.Legacy().ServiceAccounts(namespace).Create(&sa); err != nil && !apierrs.IsAlreadyExists(err) {
+	if _, err := e.client.Core().ServiceAccounts(namespace).Create(&sa); err != nil && !apierrs.IsAlreadyExists(err) {
 		glog.Error(err)
 	}
 }

pkg/controller/serviceaccount/tokengetter.go

@@ -41,10 +41,10 @@ func NewGetterFromClient(c clientset.Interface) serviceaccount.ServiceAccountTok
 	return clientGetter{c}
 }
 func (c clientGetter) GetServiceAccount(namespace, name string) (*api.ServiceAccount, error) {
-	return c.client.Legacy().ServiceAccounts(namespace).Get(name)
+	return c.client.Core().ServiceAccounts(namespace).Get(name)
 }
 func (c clientGetter) GetSecret(namespace, name string) (*api.Secret, error) {
-	return c.client.Legacy().Secrets(namespace).Get(name)
+	return c.client.Core().Secrets(namespace).Get(name)
 }
 
 // registryGetter implements ServiceAccountTokenGetter using a service account and secret registry

pkg/controller/serviceaccount/tokens_controller.go

@@ -72,10 +72,10 @@ func NewTokensController(cl clientset.Interface, options TokensControllerOptions
 	e.serviceAccounts, e.serviceAccountController = framework.NewIndexerInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return e.client.Legacy().ServiceAccounts(api.NamespaceAll).List(options)
+				return e.client.Core().ServiceAccounts(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return e.client.Legacy().ServiceAccounts(api.NamespaceAll).Watch(options)
+				return e.client.Core().ServiceAccounts(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.ServiceAccount{},
@@ -93,11 +93,11 @@ func NewTokensController(cl clientset.Interface, options TokensControllerOptions
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 				options.FieldSelector = tokenSelector
-				return e.client.Legacy().Secrets(api.NamespaceAll).List(options)
+				return e.client.Core().Secrets(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 				options.FieldSelector = tokenSelector
-				return e.client.Legacy().Secrets(api.NamespaceAll).Watch(options)
+				return e.client.Core().Secrets(api.NamespaceAll).Watch(options)
 			},
 		},
 		&api.Secret{},
@@ -292,7 +292,7 @@ func (e *TokensController) createSecretIfNeeded(serviceAccount *api.ServiceAccou
 func (e *TokensController) createSecret(serviceAccount *api.ServiceAccount) error {
 	// We don't want to update the cache's copy of the service account
 	// so add the secret to a freshly retrieved copy of the service account
-	serviceAccounts := e.client.Legacy().ServiceAccounts(serviceAccount.Namespace)
+	serviceAccounts := e.client.Core().ServiceAccounts(serviceAccount.Namespace)
 	liveServiceAccount, err := serviceAccounts.Get(serviceAccount.Name)
 	if err != nil {
 		return err
@@ -330,7 +330,7 @@ func (e *TokensController) createSecret(serviceAccount *api.ServiceAccount) erro
 	}
 
 	// Save the secret
-	if _, err := e.client.Legacy().Secrets(serviceAccount.Namespace).Create(secret); err != nil {
+	if _, err := e.client.Core().Secrets(serviceAccount.Namespace).Create(secret); err != nil {
 		return err
 	}
 
@@ -340,7 +340,7 @@ func (e *TokensController) createSecret(serviceAccount *api.ServiceAccount) erro
 	if err != nil {
 		// we weren't able to use the token, try to clean it up.
 		glog.V(2).Infof("Deleting secret %s/%s because reference couldn't be added (%v)", secret.Namespace, secret.Name, err)
-		if err := e.client.Legacy().Secrets(secret.Namespace).Delete(secret.Name, nil); err != nil {
+		if err := e.client.Core().Secrets(secret.Namespace).Delete(secret.Name, nil); err != nil {
 			glog.Error(err) // if we fail, just log it
 		}
 	}
@@ -390,7 +390,7 @@ func (e *TokensController) generateTokenIfNeeded(serviceAccount *api.ServiceAcco
 	secret.Annotations[api.ServiceAccountUIDKey] = string(serviceAccount.UID)
 
 	// Save the secret
-	if _, err := e.client.Legacy().Secrets(secret.Namespace).Update(secret); err != nil {
+	if _, err := e.client.Core().Secrets(secret.Namespace).Update(secret); err != nil {
 		return err
 	}
 	return nil
@@ -398,7 +398,7 @@ func (e *TokensController) generateTokenIfNeeded(serviceAccount *api.ServiceAcco
 
 // deleteSecret deletes the given secret
 func (e *TokensController) deleteSecret(secret *api.Secret) error {
-	return e.client.Legacy().Secrets(secret.Namespace).Delete(secret.Name, nil)
+	return e.client.Core().Secrets(secret.Namespace).Delete(secret.Name, nil)
 }
 
 // removeSecretReferenceIfNeeded updates the given ServiceAccount to remove a reference to the given secretName if needed.
@@ -411,7 +411,7 @@ func (e *TokensController) removeSecretReferenceIfNeeded(serviceAccount *api.Ser
 
 	// We don't want to update the cache's copy of the service account
 	// so remove the secret from a freshly retrieved copy of the service account
-	serviceAccounts := e.client.Legacy().ServiceAccounts(serviceAccount.Namespace)
+	serviceAccounts := e.client.Core().ServiceAccounts(serviceAccount.Namespace)
 	serviceAccount, err := serviceAccounts.Get(serviceAccount.Name)
 	if err != nil {
 		return err
@@ -461,7 +461,7 @@ func (e *TokensController) getServiceAccount(secret *api.Secret, fetchOnCacheMis
 	}
 
 	if fetchOnCacheMiss {
-		serviceAccount, err := e.client.Legacy().ServiceAccounts(secret.Namespace).Get(name)
+		serviceAccount, err := e.client.Core().ServiceAccounts(secret.Namespace).Get(name)
 		if apierrors.IsNotFound(err) {
 			return nil, nil
 		}

pkg/kubectl/describe.go

@@ -1621,7 +1621,7 @@ func (dd *DeploymentDescriber) Describe(namespace, name string) (string, error)
 			}
 			fmt.Fprintf(out, "NewReplicationController:\t%s\n", printReplicationControllersByLabels(newRCs))
 		}
-		events, err := dd.Legacy().Events(namespace).Search(d)
+		events, err := dd.Core().Events(namespace).Search(d)
 		if err == nil && events != nil {
 			DescribeEvents(events, out)
 		}

pkg/kubelet/config/apiserver.go

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

pkg/kubelet/kubelet.go

@@ -220,10 +220,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.Legacy().Services(api.NamespaceAll).List(options)
+				return kubeClient.Core().Services(api.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return kubeClient.Legacy().Services(api.NamespaceAll).Watch(options)
+				return kubeClient.Core().Services(api.NamespaceAll).Watch(options)
 			},
 		}
 		cache.NewReflector(listWatch, &api.Service{}, serviceStore, 0).Run()
@@ -238,11 +238,11 @@ func NewMainKubelet(
 		listWatch := &cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 				options.FieldSelector = fieldSelector
-				return kubeClient.Legacy().Nodes().List(options)
+				return kubeClient.Core().Nodes().List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 				options.FieldSelector = fieldSelector
-				return kubeClient.Legacy().Nodes().Watch(options)
+				return kubeClient.Core().Nodes().Watch(options)
 			},
 		}
 		cache.NewReflector(listWatch, &api.Node{}, nodeStore, 0).Run()
@@ -1062,12 +1062,12 @@ func (kl *Kubelet) registerWithApiserver() {
 			continue
 		}
 		glog.V(2).Infof("Attempting to register node %s", node.Name)
-		if _, err := kl.kubeClient.Legacy().Nodes().Create(node); err != nil {
+		if _, err := kl.kubeClient.Core().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.Legacy().Nodes().Get(kl.nodeName)
+			currentNode, err := kl.kubeClient.Core().Nodes().Get(kl.nodeName)
 			if err != nil {
 				glog.Errorf("error getting node %q: %v", kl.nodeName, err)
 				continue
@@ -1085,7 +1085,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.Legacy().Nodes().Delete(node.Name, nil); err != nil {
+			if err := kl.kubeClient.Core().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)
@@ -1417,7 +1417,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.Legacy().ConfigMaps(pod.Namespace).Get(name)
+					configMap, err = kl.kubeClient.Core().ConfigMaps(pod.Namespace).Get(name)
 					if err != nil {
 						return result, err
 					}
@@ -1431,7 +1431,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.Legacy().Secrets(pod.Namespace).Get(name)
+					secret, err = kl.kubeClient.Core().Secrets(pod.Namespace).Get(name)
 					if err != nil {
 						return result, err
 					}
@@ -1723,7 +1723,7 @@ func (kl *Kubelet) getPullSecretsForPod(pod *api.Pod) ([]api.Secret, error) {
 	pullSecrets := []api.Secret{}
 
 	for _, secretRef := range pod.Spec.ImagePullSecrets {
-		secret, err := kl.kubeClient.Legacy().Secrets(pod.Namespace).Get(secretRef.Name)
+		secret, err := kl.kubeClient.Core().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
@@ -1742,7 +1742,7 @@ func (kl *Kubelet) resolveVolumeName(pod *api.Pod, volume *api.Volume) (string,
 	claimSource := volume.VolumeSource.PersistentVolumeClaim
 	if claimSource != nil {
 		// resolve real volume behind the claim
-		claim, err := kl.kubeClient.Legacy().PersistentVolumeClaims(pod.Namespace).Get(claimSource.ClaimName)
+		claim, err := kl.kubeClient.Core().PersistentVolumeClaims(pod.Namespace).Get(claimSource.ClaimName)
 		if err != nil {
 			return "", fmt.Errorf("Cannot find claim %s/%s for volume %s", pod.Namespace, claimSource.ClaimName, volume.Name)
 		}
@@ -3013,7 +3013,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.Legacy().Nodes().Get(kl.nodeName)
+	node, err := kl.kubeClient.Core().Nodes().Get(kl.nodeName)
 	if err != nil {
 		return fmt.Errorf("error getting node %q: %v", kl.nodeName, err)
 	}
@@ -3028,7 +3028,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.Legacy().Nodes().Update(node); err != nil {
+			if updatedNode, err := kl.kubeClient.Core().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.
@@ -3043,7 +3043,7 @@ func (kl *Kubelet) tryUpdateNodeStatus() error {
 		return err
 	}
 	// Update the current status on the API server
-	_, err = kl.kubeClient.Legacy().Nodes().UpdateStatus(node)
+	_, err = kl.kubeClient.Core().Nodes().UpdateStatus(node)
 	return err
 }
 

pkg/kubelet/pod/mirror_client.go

@@ -55,7 +55,7 @@ func (mc *basicMirrorClient) CreateMirrorPod(pod *api.Pod) error {
 	}
 	hash := getPodHash(pod)
 	copyPod.Annotations[kubetypes.ConfigMirrorAnnotationKey] = hash
-	apiPod, err := mc.apiserverClient.Legacy().Pods(copyPod.Namespace).Create(&copyPod)
+	apiPod, err := mc.apiserverClient.Core().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.Legacy().Pods(namespace).Delete(name, api.NewDeleteOptions(0)); err != nil && !errors.IsNotFound(err) {
+	if err := mc.apiserverClient.Core().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

pkg/kubelet/status/manager.go

@@ -347,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.Legacy().Pods(status.podNamespace).Get(status.podName)
+	pod, err := m.kubeClient.Core().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
@@ -367,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.Legacy().Pods(pod.Namespace).UpdateStatus(pod)
+		pod, err = m.kubeClient.Core().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
@@ -382,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.Legacy().Pods(pod.Namespace).Delete(pod.Name, api.NewDeleteOptions(0)); err == nil {
+			if err := m.kubeClient.Core().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

pkg/util/deployment/deployment.go

@@ -44,10 +44,10 @@ const (
 func GetOldRCs(deployment extensions.Deployment, c clientset.Interface) ([]*api.ReplicationController, []*api.ReplicationController, error) {
 	return GetOldRCsFromLists(deployment, c,
 		func(namespace string, options api.ListOptions) (*api.PodList, error) {
-			return c.Legacy().Pods(namespace).List(options)
+			return c.Core().Pods(namespace).List(options)
 		},
 		func(namespace string, options api.ListOptions) ([]api.ReplicationController, error) {
-			rcList, err := c.Legacy().ReplicationControllers(namespace).List(options)
+			rcList, err := c.Core().ReplicationControllers(namespace).List(options)
 			return rcList.Items, err
 		})
 }
@@ -104,7 +104,7 @@ func GetOldRCsFromLists(deployment extensions.Deployment, c clientset.Interface,
 func GetNewRC(deployment extensions.Deployment, c clientset.Interface) (*api.ReplicationController, error) {
 	return GetNewRCFromList(deployment, c,
 		func(namespace string, options api.ListOptions) ([]api.ReplicationController, error) {
-			rcList, err := c.Legacy().ReplicationControllers(namespace).List(options)
+			rcList, err := c.Core().ReplicationControllers(namespace).List(options)
 			return rcList.Items, err
 		})
 }
@@ -200,7 +200,7 @@ func getPodsForRCs(c clientset.Interface, replicationControllers []*api.Replicat
 	for _, rc := range replicationControllers {
 		selector := labels.SelectorFromSet(rc.Spec.Selector)
 		options := api.ListOptions{LabelSelector: selector}
-		podList, err := c.Legacy().Pods(rc.ObjectMeta.Namespace).List(options)
+		podList, err := c.Core().Pods(rc.ObjectMeta.Namespace).List(options)
 		if err != nil {
 			return allPods, fmt.Errorf("error listing pods: %v", err)
 		}

pkg/volume/cephfs/cephfs.go

@@ -74,7 +74,7 @@ func (plugin *cephfsPlugin) NewBuilder(spec *volume.Spec, pod *api.Pod, _ volume
 			return nil, fmt.Errorf("Cannot get kube client")
 		}
 
-		secretName, err := kubeClient.Legacy().Secrets(pod.Namespace).Get(cephvs.SecretRef.Name)
+		secretName, err := kubeClient.Core().Secrets(pod.Namespace).Get(cephvs.SecretRef.Name)
 		if err != nil {
 			err = fmt.Errorf("Couldn't get secret %v/%v err: %v", pod.Namespace, cephvs.SecretRef, err)
 			return nil, err

pkg/volume/flexvolume/flexvolume.go

@@ -110,7 +110,7 @@ func (plugin *flexVolumePlugin) NewBuilder(spec *volume.Spec, pod *api.Pod, _ vo
 			return nil, fmt.Errorf("Cannot get kube client")
 		}
 
-		secretName, err := kubeClient.Legacy().Secrets(pod.Namespace).Get(fv.SecretRef.Name)
+		secretName, err := kubeClient.Core().Secrets(pod.Namespace).Get(fv.SecretRef.Name)
 		if err != nil {
 			err = fmt.Errorf("Couldn't get secret %v/%v err: %v", pod.Namespace, fv.SecretRef, err)
 			return nil, err