Replace client with clientset in code

cluster/addons/fluentd-elasticsearch/es-image/elasticsearch_logging_discovery.go

@@ -25,7 +25,8 @@ import (
 
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	"k8s.io/kubernetes/pkg/client/restclient"
 )
 
 func flattenSubsets(subsets []api.EndpointSubset) []string {
@@ -42,14 +43,19 @@ func main() {
 	flag.Parse()
 	glog.Info("Kubernetes Elasticsearch logging discovery")
 
-	c, err := client.NewInCluster()
+	cc, err := restclient.InClusterConfig()
+	if err != nil {
+		glog.Fatalf("Failed to make client: %v", err)
+	}
+	client, err := clientset.NewForConfig(cc)
+
 	if err != nil {
 		glog.Fatalf("Failed to make client: %v", err)
 	}
 	namespace := api.NamespaceSystem
 	envNamespace := os.Getenv("NAMESPACE")
 	if envNamespace != "" {
-		if _, err := c.Namespaces().Get(envNamespace); err != nil {
+		if _, err := client.Core().Namespaces().Get(envNamespace); err != nil {
 			glog.Fatalf("%s namespace doesn't exist: %v", envNamespace, err)
 		}
 		namespace = envNamespace
@@ -59,7 +65,7 @@ func main() {
 	// Look for endpoints associated with the Elasticsearch loggging service.
 	// First wait for the service to become available.
 	for t := time.Now(); time.Since(t) < 5*time.Minute; time.Sleep(10 * time.Second) {
-		elasticsearch, err = c.Services(namespace).Get("elasticsearch-logging")
+		elasticsearch, err = client.Core().Services(namespace).Get("elasticsearch-logging")
 		if err == nil {
 			break
 		}
@@ -76,7 +82,7 @@ func main() {
 	// Wait for some endpoints.
 	count := 0
 	for t := time.Now(); time.Since(t) < 5*time.Minute; time.Sleep(10 * time.Second) {
-		endpoints, err = c.Endpoints(namespace).Get("elasticsearch-logging")
+		endpoints, err = client.Core().Endpoints(namespace).Get("elasticsearch-logging")
 		if err != nil {
 			continue
 		}

cmd/kube-proxy/app/server.go

@@ -30,8 +30,9 @@ import (
 
 	"k8s.io/kubernetes/cmd/kube-proxy/app/options"
 	"k8s.io/kubernetes/pkg/api"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
 	"k8s.io/kubernetes/pkg/client/record"
-	kubeclient "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
 	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
 	"k8s.io/kubernetes/pkg/proxy"
@@ -56,7 +57,7 @@ import (
 )
 
 type ProxyServer struct {
-	Client       *kubeclient.Client
+	Client       clientset.Interface
 	Config       *options.ProxyServerConfig
 	IptInterface utiliptables.Interface
 	Proxier      proxy.ProxyProvider
@@ -82,7 +83,7 @@ func checkKnownProxyMode(proxyMode string) bool {
 }
 
 func NewProxyServer(
-	client *kubeclient.Client,
+	client clientset.Interface,
 	config *options.ProxyServerConfig,
 	iptInterface utiliptables.Interface,
 	proxier proxy.ProxyProvider,
@@ -185,7 +186,7 @@ func NewProxyServerDefault(config *options.ProxyServerConfig) (*ProxyServer, err
 	kubeconfig.QPS = config.KubeAPIQPS
 	kubeconfig.Burst = int(config.KubeAPIBurst)
 
-	client, err := kubeclient.New(kubeconfig)
+	client, err := clientset.NewForConfig(kubeconfig)
 	if err != nil {
 		glog.Fatalf("Invalid API configuration: %v", err)
 	}
@@ -198,7 +199,7 @@ func NewProxyServerDefault(config *options.ProxyServerConfig) (*ProxyServer, err
 	var proxier proxy.ProxyProvider
 	var endpointsHandler proxyconfig.EndpointsConfigHandler
 
-	proxyMode := getProxyMode(string(config.Mode), client.Nodes(), hostname, iptInterface, iptables.LinuxKernelCompatTester{})
+	proxyMode := getProxyMode(string(config.Mode), client.Core().Nodes(), hostname, iptInterface, iptables.LinuxKernelCompatTester{})
 	if proxyMode == proxyModeIPTables {
 		glog.V(0).Info("Using iptables Proxier.")
 		if config.IPTablesMasqueradeBit == nil {
@@ -251,7 +252,7 @@ func NewProxyServerDefault(config *options.ProxyServerConfig) (*ProxyServer, err
 	endpointsConfig.RegisterHandler(endpointsHandler)
 
 	proxyconfig.NewSourceAPI(
-		client,
+		client.Core().RESTClient(),
 		config.ConfigSyncPeriod,
 		serviceConfig.Channel("api"),
 		endpointsConfig.Channel("api"),
@@ -281,7 +282,7 @@ func (s *ProxyServer) Run() error {
 		return nil
 	}
 
-	s.Broadcaster.StartRecordingToSink(s.Client.Events(""))
+	s.Broadcaster.StartRecordingToSink(&unversionedcore.EventSinkImpl{Interface: s.Client.Core().Events("")})
 
 	// Start up a webserver if requested
 	if s.Config.HealthzPort > 0 {
@@ -418,9 +419,9 @@ func (s *ProxyServer) birthCry() {
 	s.Recorder.Eventf(s.Config.NodeRef, api.EventTypeNormal, "Starting", "Starting kube-proxy.")
 }
 
-func getNodeIP(client *kubeclient.Client, hostname string) net.IP {
+func getNodeIP(client clientset.Interface, hostname string) net.IP {
 	var nodeIP net.IP
-	node, err := client.Nodes().Get(hostname)
+	node, err := client.Core().Nodes().Get(hostname)
 	if err != nil {
 		glog.Warningf("Failed to retrieve node info: %v", err)
 		return nil

cmd/kubemark/hollow-node.go

@@ -24,7 +24,6 @@ import (
 	_ "k8s.io/kubernetes/pkg/client/metrics/prometheus" // for client metric registration
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/client/restclient"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
 	cadvisortest "k8s.io/kubernetes/pkg/kubelet/cadvisor/testing"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
@@ -94,10 +93,7 @@ func main() {
 	if err != nil {
 		glog.Fatalf("Failed to create a ClientConfig: %v. Exiting.", err)
 	}
-	cl, err := client.New(clientConfig)
+
-	if err != nil {
-		glog.Fatalf("Failed to create a Client: %v. Exiting.", err)
-	}
 	clientset, err := internalclientset.NewForConfig(clientConfig)
 	if err != nil {
 		glog.Fatalf("Failed to create a ClientSet: %v. Exiting.", err)
@@ -136,7 +132,7 @@ func main() {
 		endpointsConfig := proxyconfig.NewEndpointsConfig()
 		endpointsConfig.RegisterHandler(&kubemark.FakeProxyHandler{})
 
-		hollowProxy := kubemark.NewHollowProxyOrDie(config.NodeName, cl, endpointsConfig, serviceConfig, iptInterface, eventBroadcaster, recorder)
+		hollowProxy := kubemark.NewHollowProxyOrDie(config.NodeName, clientset, endpointsConfig, serviceConfig, iptInterface, eventBroadcaster, recorder)
 		hollowProxy.Run()
 	}
 }

federation/pkg/federation-controller/util/cluster_util.go

@@ -26,8 +26,8 @@ import (
 	federation_v1beta1 "k8s.io/kubernetes/federation/apis/federation/v1beta1"
 	fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5"
 	"k8s.io/kubernetes/pkg/api"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/client/restclient"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
 	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
 	utilnet "k8s.io/kubernetes/pkg/util/net"
@@ -102,14 +102,18 @@ var KubeconfigGetterForSecret = func(secretName string) clientcmd.KubeconfigGett
 				return nil, fmt.Errorf("unexpected: POD_NAMESPACE env var returned empty string")
 			}
 			// Get a client to talk to the k8s apiserver, to fetch secrets from it.
-			client, err := client.NewInCluster()
+			cc, err := restclient.InClusterConfig()
+			if err != nil {
+				return nil, fmt.Errorf("error in creating in-cluster client: %s", err)
+			}
+			client, err := clientset.NewForConfig(cc)
 			if err != nil {
 				return nil, fmt.Errorf("error in creating in-cluster client: %s", err)
 			}
 			data = []byte{}
 			var secret *api.Secret
 			err = wait.PollImmediate(1*time.Second, getSecretTimeout, func() (bool, error) {
-				secret, err = client.Secrets(namespace).Get(secretName)
+				secret, err = client.Core().Secrets(namespace).Get(secretName)
 				if err == nil {
 					return true, nil
 				}

pkg/client/cache/listwatch_test.go

@@ -25,8 +25,8 @@ import (
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/client/restclient"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/fields"
 	utiltesting "k8s.io/kubernetes/pkg/util/testing"
 )
@@ -98,8 +98,8 @@ func TestListWatchesCanList(t *testing.T) {
 		}
 		server := httptest.NewServer(&handler)
 		defer server.Close()
-		client := client.NewOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}})
+		client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}})
-		lw := NewListWatchFromClient(client, item.resource, item.namespace, item.fieldSelector)
+		lw := NewListWatchFromClient(client.Core().RESTClient(), item.resource, item.namespace, item.fieldSelector)
 		// This test merely tests that the correct request is made.
 		lw.List(api.ListOptions{})
 		handler.ValidateRequest(t, item.location, "GET", nil)
@@ -164,8 +164,8 @@ func TestListWatchesCanWatch(t *testing.T) {
 		}
 		server := httptest.NewServer(&handler)
 		defer server.Close()
-		client := client.NewOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}})
+		client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}})
-		lw := NewListWatchFromClient(client, item.resource, item.namespace, item.fieldSelector)
+		lw := NewListWatchFromClient(client.Core().RESTClient(), item.resource, item.namespace, item.fieldSelector)
 		// This test merely tests that the correct request is made.
 		lw.Watch(api.ListOptions{ResourceVersion: item.rv})
 		handler.ValidateRequest(t, item.location, "GET", nil)

pkg/kubemark/hollow_proxy.go

@@ -22,8 +22,8 @@ import (
 	proxyapp "k8s.io/kubernetes/cmd/kube-proxy/app"
 	"k8s.io/kubernetes/cmd/kube-proxy/app/options"
 	"k8s.io/kubernetes/pkg/api"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/client/record"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	proxyconfig "k8s.io/kubernetes/pkg/proxy/config"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util"
@@ -51,7 +51,7 @@ func (*FakeProxier) SyncLoop() {
 
 func NewHollowProxyOrDie(
 	nodeName string,
-	client *client.Client,
+	client clientset.Interface,
 	endpointsConfig *proxyconfig.EndpointsConfig,
 	serviceConfig *proxyconfig.ServiceConfig,
 	iptInterface utiliptables.Interface,
@@ -69,7 +69,7 @@ func NewHollowProxyOrDie(
 		Namespace: "",
 	}
 	proxyconfig.NewSourceAPI(
-		client,
+		client.Core().RESTClient(),
 		30*time.Second,
 		serviceConfig.Channel("api"),
 		endpointsConfig.Channel("api"),

pkg/metrics/api_server_metrics.go

@@ -36,7 +36,7 @@ func parseApiServerMetrics(data string) (ApiServerMetrics, error) {
 }
 
 func (g *MetricsGrabber) getMetricsFromApiServer() (string, error) {
-	rawOutput, err := g.client.Get().RequestURI("/metrics").Do().Raw()
+	rawOutput, err := g.client.Core().RESTClient().Get().RequestURI("/metrics").Do().Raw()
 	if err != nil {
 		return "", err
 	}

pkg/metrics/generic_metrics.go

@@ -99,7 +99,7 @@ func parseMetrics(data string, output *Metrics) error {
 }
 
 func (g *MetricsGrabber) getMetricsFromPod(podName string, namespace string, port int) (string, error) {
-	rawOutput, err := g.client.Get().
+	rawOutput, err := g.client.Core().RESTClient().Get().
 		Prefix("proxy").
 		Namespace(namespace).
 		Resource("pods").

pkg/metrics/kubelet_metrics.go

@@ -65,7 +65,7 @@ func (g *MetricsGrabber) getMetricsFromNode(nodeName string, kubeletPort int) (s
 	var err error
 	var rawOutput []byte
 	go func() {
-		rawOutput, err = g.client.Get().
+		rawOutput, err = g.client.Core().RESTClient().Get().
 			Prefix("proxy").
 			Resource("nodes").
 			Name(fmt.Sprintf("%v:%v", nodeName, kubeletPort)).

pkg/metrics/metrics_grabber.go

@@ -21,7 +21,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/master/ports"
 	"k8s.io/kubernetes/pkg/util/system"
@@ -41,7 +41,7 @@ type MetricsCollection struct {
 }
 
 type MetricsGrabber struct {
-	client                    *client.Client
+	client                    clientset.Interface
 	grabFromApiServer         bool
 	grabFromControllerManager bool
 	grabFromKubelets          bool
@@ -50,10 +50,10 @@ type MetricsGrabber struct {
 	registeredMaster          bool
 }
 
-func NewMetricsGrabber(c *client.Client, kubelets bool, scheduler bool, controllers bool, apiServer bool) (*MetricsGrabber, error) {
+func NewMetricsGrabber(c clientset.Interface, kubelets bool, scheduler bool, controllers bool, apiServer bool) (*MetricsGrabber, error) {
 	registeredMaster := false
 	masterName := ""
-	nodeList, err := c.Nodes().List(api.ListOptions{})
+	nodeList, err := c.Core().Nodes().List(api.ListOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -85,7 +85,7 @@ func NewMetricsGrabber(c *client.Client, kubelets bool, scheduler bool, controll
 }
 
 func (g *MetricsGrabber) GrabFromKubelet(nodeName string) (KubeletMetrics, error) {
-	nodes, err := g.client.Nodes().List(api.ListOptions{FieldSelector: fields.Set{api.ObjectNameField: nodeName}.AsSelector()})
+	nodes, err := g.client.Core().Nodes().List(api.ListOptions{FieldSelector: fields.Set{api.ObjectNameField: nodeName}.AsSelector()})
 	if err != nil {
 		return KubeletMetrics{}, err
 	}
@@ -166,7 +166,7 @@ func (g *MetricsGrabber) Grab() (MetricsCollection, error) {
 	}
 	if g.grabFromKubelets {
 		result.KubeletMetrics = make(map[string]KubeletMetrics)
-		nodes, err := g.client.Nodes().List(api.ListOptions{})
+		nodes, err := g.client.Core().Nodes().List(api.ListOptions{})
 		if err != nil {
 			errs = append(errs, err)
 		} else {

test/e2e/addon_update.go

@@ -26,7 +26,7 @@ import (
 
 	"golang.org/x/crypto/ssh"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/test/e2e/framework"
 
 	. "github.com/onsi/ginkgo"
@@ -275,8 +275,8 @@ var _ = framework.KubeDescribe("Addon update", func() {
 		sshExecAndVerify(sshClient, fmt.Sprintf("sudo cp %s/%s %s/%s", temporaryRemotePath, rcv1, destinationDir, rcv1))
 		sshExecAndVerify(sshClient, fmt.Sprintf("sudo cp %s/%s %s/%s", temporaryRemotePath, svcv1, destinationDir, svcv1))
 
-		waitForServiceInAddonTest(f.Client, f.Namespace.Name, "addon-test", true)
+		waitForServiceInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test", true)
-		waitForReplicationControllerInAddonTest(f.Client, defaultNsName, "addon-test-v1", true)
+		waitForReplicationControllerInAddonTest(f.ClientSet, defaultNsName, "addon-test-v1", true)
 
 		By("update manifests")
 		sshExecAndVerify(sshClient, fmt.Sprintf("sudo cp %s/%s %s/%s", temporaryRemotePath, rcv2, destinationDir, rcv2))
@@ -289,38 +289,38 @@ var _ = framework.KubeDescribe("Addon update", func() {
 		 * But it is ok - as long as we don't have rolling update, the result will be the same
 		 */
 
-		waitForServiceInAddonTest(f.Client, f.Namespace.Name, "addon-test-updated", true)
+		waitForServiceInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test-updated", true)
-		waitForReplicationControllerInAddonTest(f.Client, f.Namespace.Name, "addon-test-v2", true)
+		waitForReplicationControllerInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test-v2", true)
 
-		waitForServiceInAddonTest(f.Client, f.Namespace.Name, "addon-test", false)
+		waitForServiceInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test", false)
-		waitForReplicationControllerInAddonTest(f.Client, defaultNsName, "addon-test-v1", false)
+		waitForReplicationControllerInAddonTest(f.ClientSet, defaultNsName, "addon-test-v1", false)
 
 		By("remove manifests")
 		sshExecAndVerify(sshClient, fmt.Sprintf("sudo rm %s/%s", destinationDir, rcv2))
 		sshExecAndVerify(sshClient, fmt.Sprintf("sudo rm %s/%s", destinationDir, svcv2))
 
-		waitForServiceInAddonTest(f.Client, f.Namespace.Name, "addon-test-updated", false)
+		waitForServiceInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test-updated", false)
-		waitForReplicationControllerInAddonTest(f.Client, f.Namespace.Name, "addon-test-v2", false)
+		waitForReplicationControllerInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test-v2", false)
 
 		By("verify invalid API addons weren't created")
-		_, err = f.Client.ReplicationControllers(f.Namespace.Name).Get("invalid-addon-test-v1")
+		_, err = f.ClientSet.Core().ReplicationControllers(f.Namespace.Name).Get("invalid-addon-test-v1")
 		Expect(err).To(HaveOccurred())
-		_, err = f.Client.ReplicationControllers(defaultNsName).Get("invalid-addon-test-v1")
+		_, err = f.ClientSet.Core().ReplicationControllers(defaultNsName).Get("invalid-addon-test-v1")
 		Expect(err).To(HaveOccurred())
-		_, err = f.Client.Services(f.Namespace.Name).Get("ivalid-addon-test")
+		_, err = f.ClientSet.Core().Services(f.Namespace.Name).Get("ivalid-addon-test")
 		Expect(err).To(HaveOccurred())
-		_, err = f.Client.Services(defaultNsName).Get("ivalid-addon-test")
+		_, err = f.ClientSet.Core().Services(defaultNsName).Get("ivalid-addon-test")
 		Expect(err).To(HaveOccurred())
 
 		// invalid addons will be deleted by the deferred function
 	})
 })
 
-func waitForServiceInAddonTest(c *client.Client, addonNamespace, name string, exist bool) {
+func waitForServiceInAddonTest(c clientset.Interface, addonNamespace, name string, exist bool) {
 	framework.ExpectNoError(framework.WaitForService(c, addonNamespace, name, exist, addonTestPollInterval, addonTestPollTimeout))
 }
 
-func waitForReplicationControllerInAddonTest(c *client.Client, addonNamespace, name string, exist bool) {
+func waitForReplicationControllerInAddonTest(c clientset.Interface, addonNamespace, name string, exist bool) {
 	framework.ExpectNoError(framework.WaitForReplicationController(c, addonNamespace, name, exist, addonTestPollInterval, addonTestPollTimeout))
 }
 

test/e2e/autoscaling_utils.go

@@ -22,7 +22,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/util/intstr"
 	"k8s.io/kubernetes/test/e2e/framework"
 	testutils "k8s.io/kubernetes/test/utils"
@@ -97,7 +97,7 @@ cpuLimit argument is in millicores, cpuLimit is a maximum amount of cpu that can
 func newResourceConsumer(name, kind string, replicas, initCPUTotal, initMemoryTotal, initCustomMetric, consumptionTimeInSeconds, requestSizeInMillicores,
 	requestSizeInMegabytes int, requestSizeCustomMetric int, cpuLimit, memLimit int64, f *framework.Framework) *ResourceConsumer {
 
-	runServiceAndWorkloadForResourceConsumer(f.Client, f.Namespace.Name, name, kind, replicas, cpuLimit, memLimit)
+	runServiceAndWorkloadForResourceConsumer(f.ClientSet, f.Namespace.Name, name, kind, replicas, cpuLimit, memLimit)
 	rc := &ResourceConsumer{
 		name:                     name,
 		controllerName:           name + "-ctrl",
@@ -199,7 +199,7 @@ func (rc *ResourceConsumer) makeConsumeCustomMetric() {
 }
 
 func (rc *ResourceConsumer) sendConsumeCPURequest(millicores int) {
-	proxyRequest, err := framework.GetServicesProxyRequest(rc.framework.Client, rc.framework.Client.Post())
+	proxyRequest, err := framework.GetServicesProxyRequest(rc.framework.ClientSet, rc.framework.ClientSet.Core().RESTClient().Post())
 	framework.ExpectNoError(err)
 	req := proxyRequest.Namespace(rc.framework.Namespace.Name).
 		Name(rc.controllerName).
@@ -214,7 +214,7 @@ func (rc *ResourceConsumer) sendConsumeCPURequest(millicores int) {
 
 // sendConsumeMemRequest sends POST request for memory consumption
 func (rc *ResourceConsumer) sendConsumeMemRequest(megabytes int) {
-	proxyRequest, err := framework.GetServicesProxyRequest(rc.framework.Client, rc.framework.Client.Post())
+	proxyRequest, err := framework.GetServicesProxyRequest(rc.framework.ClientSet, rc.framework.ClientSet.Core().RESTClient().Post())
 	framework.ExpectNoError(err)
 	req := proxyRequest.Namespace(rc.framework.Namespace.Name).
 		Name(rc.controllerName).
@@ -229,7 +229,7 @@ func (rc *ResourceConsumer) sendConsumeMemRequest(megabytes int) {
 
 // sendConsumeCustomMetric sends POST request for custom metric consumption
 func (rc *ResourceConsumer) sendConsumeCustomMetric(delta int) {
-	proxyRequest, err := framework.GetServicesProxyRequest(rc.framework.Client, rc.framework.Client.Post())
+	proxyRequest, err := framework.GetServicesProxyRequest(rc.framework.ClientSet, rc.framework.ClientSet.Core().RESTClient().Post())
 	framework.ExpectNoError(err)
 	req := proxyRequest.Namespace(rc.framework.Namespace.Name).
 		Name(rc.controllerName).
@@ -246,21 +246,21 @@ func (rc *ResourceConsumer) sendConsumeCustomMetric(delta int) {
 func (rc *ResourceConsumer) GetReplicas() int {
 	switch rc.kind {
 	case kindRC:
-		replicationController, err := rc.framework.Client.ReplicationControllers(rc.framework.Namespace.Name).Get(rc.name)
+		replicationController, err := rc.framework.ClientSet.Core().ReplicationControllers(rc.framework.Namespace.Name).Get(rc.name)
 		framework.ExpectNoError(err)
 		if replicationController == nil {
 			framework.Failf(rcIsNil)
 		}
 		return int(replicationController.Status.Replicas)
 	case kindDeployment:
-		deployment, err := rc.framework.Client.Deployments(rc.framework.Namespace.Name).Get(rc.name)
+		deployment, err := rc.framework.ClientSet.Extensions().Deployments(rc.framework.Namespace.Name).Get(rc.name)
 		framework.ExpectNoError(err)
 		if deployment == nil {
 			framework.Failf(deploymentIsNil)
 		}
 		return int(deployment.Status.Replicas)
 	case kindReplicaSet:
-		rs, err := rc.framework.Client.ReplicaSets(rc.framework.Namespace.Name).Get(rc.name)
+		rs, err := rc.framework.ClientSet.Extensions().ReplicaSets(rc.framework.Namespace.Name).Get(rc.name)
 		framework.ExpectNoError(err)
 		if rs == nil {
 			framework.Failf(rsIsNil)
@@ -303,15 +303,15 @@ func (rc *ResourceConsumer) CleanUp() {
 	rc.stopCustomMetric <- 0
 	// Wait some time to ensure all child goroutines are finished.
 	time.Sleep(10 * time.Second)
-	framework.ExpectNoError(framework.DeleteRCAndPods(rc.framework.Client, rc.framework.ClientSet, rc.framework.Namespace.Name, rc.name))
+	framework.ExpectNoError(framework.DeleteRCAndPods(rc.framework.ClientSet, rc.framework.Namespace.Name, rc.name))
-	framework.ExpectNoError(rc.framework.Client.Services(rc.framework.Namespace.Name).Delete(rc.name))
+	framework.ExpectNoError(rc.framework.ClientSet.Core().Services(rc.framework.Namespace.Name).Delete(rc.name, nil))
-	framework.ExpectNoError(framework.DeleteRCAndPods(rc.framework.Client, rc.framework.ClientSet, rc.framework.Namespace.Name, rc.controllerName))
+	framework.ExpectNoError(framework.DeleteRCAndPods(rc.framework.ClientSet, rc.framework.Namespace.Name, rc.controllerName))
-	framework.ExpectNoError(rc.framework.Client.Services(rc.framework.Namespace.Name).Delete(rc.controllerName))
+	framework.ExpectNoError(rc.framework.ClientSet.Core().Services(rc.framework.Namespace.Name).Delete(rc.controllerName, nil))
 }
 
-func runServiceAndWorkloadForResourceConsumer(c *client.Client, ns, name, kind string, replicas int, cpuLimitMillis, memLimitMb int64) {
+func runServiceAndWorkloadForResourceConsumer(c clientset.Interface, ns, name, kind string, replicas int, cpuLimitMillis, memLimitMb int64) {
 	By(fmt.Sprintf("Running consuming RC %s via %s with %v replicas", name, kind, replicas))
-	_, err := c.Services(ns).Create(&api.Service{
+	_, err := c.Core().Services(ns).Create(&api.Service{
 		ObjectMeta: api.ObjectMeta{
 			Name: name,
 		},
@@ -364,7 +364,7 @@ func runServiceAndWorkloadForResourceConsumer(c *client.Client, ns, name, kind s
 
 	By(fmt.Sprintf("Running controller"))
 	controllerName := name + "-ctrl"
-	_, err = c.Services(ns).Create(&api.Service{
+	_, err = c.Core().Services(ns).Create(&api.Service{
 		ObjectMeta: api.ObjectMeta{
 			Name: controllerName,
 		},

test/e2e/batch_v1_jobs.go

@@ -26,7 +26,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/apis/batch"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/kubectl"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -54,11 +54,11 @@ var _ = framework.KubeDescribe("V1Job", func() {
 	It("should run a job to completion when tasks succeed", func() {
 		By("Creating a job")
 		job := newTestV1Job("succeed", "all-succeed", api.RestartPolicyNever, parallelism, completions)
-		job, err := createV1Job(f.Client, f.Namespace.Name, job)
+		job, err := createV1Job(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job reaches completions")
-		err = waitForV1JobFinish(f.Client, f.Namespace.Name, job.Name, completions)
+		err = waitForV1JobFinish(f.ClientSet, f.Namespace.Name, job.Name, completions)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -73,11 +73,11 @@ var _ = framework.KubeDescribe("V1Job", func() {
 		// due to successive failures too likely with a reasonable
 		// test timeout.
 		job := newTestV1Job("failOnce", "fail-once-local", api.RestartPolicyOnFailure, parallelism, completions)
-		job, err := createV1Job(f.Client, f.Namespace.Name, job)
+		job, err := createV1Job(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job reaches completions")
-		err = waitForV1JobFinish(f.Client, f.Namespace.Name, job.Name, completions)
+		err = waitForV1JobFinish(f.ClientSet, f.Namespace.Name, job.Name, completions)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -91,23 +91,23 @@ var _ = framework.KubeDescribe("V1Job", func() {
 		// run due to some slowness, 1 in 2^15 chance of happening,
 		// causing test flake.  Should be very rare.
 		job := newTestV1Job("randomlySucceedOrFail", "rand-non-local", api.RestartPolicyNever, parallelism, completions)
-		job, err := createV1Job(f.Client, f.Namespace.Name, job)
+		job, err := createV1Job(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job reaches completions")
-		err = waitForV1JobFinish(f.Client, f.Namespace.Name, job.Name, completions)
+		err = waitForV1JobFinish(f.ClientSet, f.Namespace.Name, job.Name, completions)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("should keep restarting failed pods", func() {
 		By("Creating a job")
 		job := newTestV1Job("fail", "all-fail", api.RestartPolicyNever, parallelism, completions)
-		job, err := createV1Job(f.Client, f.Namespace.Name, job)
+		job, err := createV1Job(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job shows many failures")
 		err = wait.Poll(framework.Poll, v1JobTimeout, func() (bool, error) {
-			curr, err := getV1Job(f.Client, f.Namespace.Name, job.Name)
+			curr, err := getV1Job(f.ClientSet, f.Namespace.Name, job.Name)
 			if err != nil {
 				return false, err
 			}
@@ -120,11 +120,11 @@ var _ = framework.KubeDescribe("V1Job", func() {
 		endParallelism := int32(2)
 		By("Creating a job")
 		job := newTestV1Job("notTerminate", "scale-up", api.RestartPolicyNever, startParallelism, completions)
-		job, err := createV1Job(f.Client, f.Namespace.Name, job)
+		job, err := createV1Job(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == startParallelism")
-		err = waitForAllPodsRunningV1(f.Client, f.Namespace.Name, job.Name, startParallelism)
+		err = waitForAllPodsRunningV1(f.ClientSet, f.Namespace.Name, job.Name, startParallelism)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("scale job up")
@@ -136,7 +136,7 @@ var _ = framework.KubeDescribe("V1Job", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == endParallelism")
-		err = waitForAllPodsRunningV1(f.Client, f.Namespace.Name, job.Name, endParallelism)
+		err = waitForAllPodsRunningV1(f.ClientSet, f.Namespace.Name, job.Name, endParallelism)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -145,11 +145,11 @@ var _ = framework.KubeDescribe("V1Job", func() {
 		endParallelism := int32(1)
 		By("Creating a job")
 		job := newTestV1Job("notTerminate", "scale-down", api.RestartPolicyNever, startParallelism, completions)
-		job, err := createV1Job(f.Client, f.Namespace.Name, job)
+		job, err := createV1Job(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == startParallelism")
-		err = waitForAllPodsRunningV1(f.Client, f.Namespace.Name, job.Name, startParallelism)
+		err = waitForAllPodsRunningV1(f.ClientSet, f.Namespace.Name, job.Name, startParallelism)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("scale job down")
@@ -161,18 +161,18 @@ var _ = framework.KubeDescribe("V1Job", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == endParallelism")
-		err = waitForAllPodsRunningV1(f.Client, f.Namespace.Name, job.Name, endParallelism)
+		err = waitForAllPodsRunningV1(f.ClientSet, f.Namespace.Name, job.Name, endParallelism)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("should delete a job", func() {
 		By("Creating a job")
 		job := newTestV1Job("notTerminate", "foo", api.RestartPolicyNever, parallelism, completions)
-		job, err := createV1Job(f.Client, f.Namespace.Name, job)
+		job, err := createV1Job(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == parallelism")
-		err = waitForAllPodsRunningV1(f.Client, f.Namespace.Name, job.Name, parallelism)
+		err = waitForAllPodsRunningV1(f.ClientSet, f.Namespace.Name, job.Name, parallelism)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("delete a job")
@@ -183,7 +183,7 @@ var _ = framework.KubeDescribe("V1Job", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job was deleted")
-		_, err = getV1Job(f.Client, f.Namespace.Name, job.Name)
+		_, err = getV1Job(f.ClientSet, f.Namespace.Name, job.Name)
 		Expect(err).To(HaveOccurred())
 		Expect(errors.IsNotFound(err)).To(BeTrue())
 	})
@@ -193,21 +193,21 @@ var _ = framework.KubeDescribe("V1Job", func() {
 		job := newTestV1Job("notTerminate", "foo", api.RestartPolicyNever, parallelism, completions)
 		activeDeadlineSeconds := int64(10)
 		job.Spec.ActiveDeadlineSeconds = &activeDeadlineSeconds
-		job, err := createV1Job(f.Client, f.Namespace.Name, job)
+		job, err := createV1Job(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job was failed")
-		err = waitForV1JobFail(f.Client, f.Namespace.Name, job.Name, 20*time.Second)
+		err = waitForV1JobFail(f.ClientSet, f.Namespace.Name, job.Name, 20*time.Second)
 		if err == wait.ErrWaitTimeout {
-			job, err = getV1Job(f.Client, f.Namespace.Name, job.Name)
+			job, err = getV1Job(f.ClientSet, f.Namespace.Name, job.Name)
 			Expect(err).NotTo(HaveOccurred())
 			// the job stabilized and won't be synced until modification or full
 			// resync happens, we don't want to wait for the latter so we force
 			// sync modifying it
 			job.Spec.Parallelism = &completions
-			job, err = updateV1Job(f.Client, f.Namespace.Name, job)
+			job, err = updateV1Job(f.ClientSet, f.Namespace.Name, job)
 			Expect(err).NotTo(HaveOccurred())
-			err = waitForV1JobFail(f.Client, f.Namespace.Name, job.Name, v1JobTimeout)
+			err = waitForV1JobFail(f.ClientSet, f.Namespace.Name, job.Name, v1JobTimeout)
 		}
 		Expect(err).NotTo(HaveOccurred())
 	})
@@ -275,28 +275,28 @@ func newTestV1Job(behavior, name string, rPol api.RestartPolicy, parallelism, co
 	return job
 }
 
-func getV1Job(c *client.Client, ns, name string) (*batch.Job, error) {
+func getV1Job(c clientset.Interface, ns, name string) (*batch.Job, error) {
 	return c.Batch().Jobs(ns).Get(name)
 }
 
-func createV1Job(c *client.Client, ns string, job *batch.Job) (*batch.Job, error) {
+func createV1Job(c clientset.Interface, ns string, job *batch.Job) (*batch.Job, error) {
 	return c.Batch().Jobs(ns).Create(job)
 }
 
-func updateV1Job(c *client.Client, ns string, job *batch.Job) (*batch.Job, error) {
+func updateV1Job(c clientset.Interface, ns string, job *batch.Job) (*batch.Job, error) {
 	return c.Batch().Jobs(ns).Update(job)
 }
 
-func deleteV1Job(c *client.Client, ns, name string) error {
+func deleteV1Job(c clientset.Interface, ns, name string) error {
 	return c.Batch().Jobs(ns).Delete(name, api.NewDeleteOptions(0))
 }
 
 // Wait for all pods to become Running.  Only use when pods will run for a long time, or it will be racy.
-func waitForAllPodsRunningV1(c *client.Client, ns, jobName string, parallelism int32) error {
+func waitForAllPodsRunningV1(c clientset.Interface, ns, jobName string, parallelism int32) error {
 	label := labels.SelectorFromSet(labels.Set(map[string]string{v1JobSelectorKey: jobName}))
 	return wait.Poll(framework.Poll, v1JobTimeout, func() (bool, error) {
 		options := api.ListOptions{LabelSelector: label}
-		pods, err := c.Pods(ns).List(options)
+		pods, err := c.Core().Pods(ns).List(options)
 		if err != nil {
 			return false, err
 		}
@@ -311,7 +311,7 @@ func waitForAllPodsRunningV1(c *client.Client, ns, jobName string, parallelism i
 }
 
 // Wait for job to reach completions.
-func waitForV1JobFinish(c *client.Client, ns, jobName string, completions int32) error {
+func waitForV1JobFinish(c clientset.Interface, ns, jobName string, completions int32) error {
 	return wait.Poll(framework.Poll, v1JobTimeout, func() (bool, error) {
 		curr, err := c.Batch().Jobs(ns).Get(jobName)
 		if err != nil {
@@ -322,7 +322,7 @@ func waitForV1JobFinish(c *client.Client, ns, jobName string, completions int32)
 }
 
 // Wait for job fail.
-func waitForV1JobFail(c *client.Client, ns, jobName string, timeout time.Duration) error {
+func waitForV1JobFail(c clientset.Interface, ns, jobName string, timeout time.Duration) error {
 	return wait.Poll(framework.Poll, timeout, func() (bool, error) {
 		curr, err := c.Batch().Jobs(ns).Get(jobName)
 		if err != nil {

test/e2e/cadvisor.go

@@ -21,7 +21,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/test/e2e/framework"
 
 	. "github.com/onsi/ginkgo"
@@ -32,14 +32,14 @@ var _ = framework.KubeDescribe("Cadvisor", func() {
 	f := framework.NewDefaultFramework("cadvisor")
 
 	It("should be healthy on every node.", func() {
-		CheckCadvisorHealthOnAllNodes(f.Client, 5*time.Minute)
+		CheckCadvisorHealthOnAllNodes(f.ClientSet, 5*time.Minute)
 	})
 })
 
-func CheckCadvisorHealthOnAllNodes(c *client.Client, timeout time.Duration) {
+func CheckCadvisorHealthOnAllNodes(c clientset.Interface, timeout time.Duration) {
 	// It should be OK to list unschedulable Nodes here.
 	By("getting list of nodes")
-	nodeList, err := c.Nodes().List(api.ListOptions{})
+	nodeList, err := c.Core().Nodes().List(api.ListOptions{})
 	framework.ExpectNoError(err)
 	var errors []error
 
@@ -69,7 +69,7 @@ func CheckCadvisorHealthOnAllNodes(c *client.Client, timeout time.Duration) {
 			// Here, we access '/stats/' REST endpoint on the kubelet which polls cadvisor internally.
 			statsResource := fmt.Sprintf("api/v1/proxy/nodes/%s/stats/", node.Name)
 			By(fmt.Sprintf("Querying stats from node %s using url %s", node.Name, statsResource))
-			_, err = c.Get().AbsPath(statsResource).Timeout(timeout).Do().Raw()
+			_, err = c.Core().RESTClient().Get().AbsPath(statsResource).Timeout(timeout).Do().Raw()
 			if err != nil {
 				errors = append(errors, err)
 			}

test/e2e/cluster_logging_es.go

@@ -53,7 +53,7 @@ var _ = framework.KubeDescribe("Cluster level logging using Elasticsearch [Featu
 		By("Running synthetic logger")
 		createSynthLogger(f, expectedLinesCount)
 		defer f.PodClient().Delete(synthLoggerPodName, &api.DeleteOptions{})
-		err = framework.WaitForPodSuccessInNamespace(f.Client, synthLoggerPodName, f.Namespace.Name)
+		err = framework.WaitForPodSuccessInNamespace(f.ClientSet, synthLoggerPodName, f.Namespace.Name)
 		framework.ExpectNoError(err, fmt.Sprintf("Should've successfully waited for pod %s to succeed", synthLoggerPodName))
 
 		By("Waiting for logs to ingest")
@@ -86,7 +86,7 @@ var _ = framework.KubeDescribe("Cluster level logging using Elasticsearch [Featu
 func checkElasticsearchReadiness(f *framework.Framework) error {
 	// Check for the existence of the Elasticsearch service.
 	By("Checking the Elasticsearch service exists.")
-	s := f.Client.Services(api.NamespaceSystem)
+	s := f.ClientSet.Core().Services(api.NamespaceSystem)
 	// Make a few attempts to connect. This makes the test robust against
 	// being run as the first e2e test just after the e2e cluster has been created.
 	var err error
@@ -102,10 +102,10 @@ func checkElasticsearchReadiness(f *framework.Framework) error {
 	By("Checking to make sure the Elasticsearch pods are running")
 	label := labels.SelectorFromSet(labels.Set(map[string]string{"k8s-app": "elasticsearch-logging"}))
 	options := api.ListOptions{LabelSelector: label}
-	pods, err := f.Client.Pods(api.NamespaceSystem).List(options)
+	pods, err := f.ClientSet.Core().Pods(api.NamespaceSystem).List(options)
 	Expect(err).NotTo(HaveOccurred())
 	for _, pod := range pods.Items {
-		err = framework.WaitForPodRunningInNamespace(f.Client, &pod)
+		err = framework.WaitForPodRunningInNamespace(f.ClientSet, &pod)
 		Expect(err).NotTo(HaveOccurred())
 	}
 
@@ -115,7 +115,7 @@ func checkElasticsearchReadiness(f *framework.Framework) error {
 	err = nil
 	var body []byte
 	for start := time.Now(); time.Since(start) < graceTime; time.Sleep(10 * time.Second) {
-		proxyRequest, errProxy := framework.GetServicesProxyRequest(f.Client, f.Client.Get())
+		proxyRequest, errProxy := framework.GetServicesProxyRequest(f.ClientSet, f.ClientSet.Core().RESTClient().Get())
 		if errProxy != nil {
 			framework.Logf("After %v failed to get services proxy request: %v", time.Since(start), errProxy)
 			continue
@@ -147,7 +147,7 @@ func checkElasticsearchReadiness(f *framework.Framework) error {
 	By("Checking health of Elasticsearch service.")
 	healthy := false
 	for start := time.Now(); time.Since(start) < graceTime; time.Sleep(5 * time.Second) {
-		proxyRequest, errProxy := framework.GetServicesProxyRequest(f.Client, f.Client.Get())
+		proxyRequest, errProxy := framework.GetServicesProxyRequest(f.ClientSet, f.ClientSet.Core().RESTClient().Get())
 		if errProxy != nil {
 			framework.Logf("After %v failed to get services proxy request: %v", time.Since(start), errProxy)
 			continue
@@ -189,7 +189,7 @@ func checkElasticsearchReadiness(f *framework.Framework) error {
 }
 
 func getMissingLinesCountElasticsearch(f *framework.Framework, expectedCount int) (int, error) {
-	proxyRequest, errProxy := framework.GetServicesProxyRequest(f.Client, f.Client.Get())
+	proxyRequest, errProxy := framework.GetServicesProxyRequest(f.ClientSet, f.ClientSet.Core().RESTClient().Get())
 	if errProxy != nil {
 		return 0, fmt.Errorf("Failed to get services proxy request: %v", errProxy)
 	}

test/e2e/cluster_logging_gcl.go

@@ -43,7 +43,7 @@ var _ = framework.KubeDescribe("Cluster level logging using GCL [Flaky]", func()
 		By("Running synthetic logger")
 		createSynthLogger(f, expectedLinesCount)
 		defer f.PodClient().Delete(synthLoggerPodName, &api.DeleteOptions{})
-		err := framework.WaitForPodSuccessInNamespace(f.Client, synthLoggerPodName, f.Namespace.Name)
+		err := framework.WaitForPodSuccessInNamespace(f.ClientSet, synthLoggerPodName, f.Namespace.Name)
 		framework.ExpectNoError(err, fmt.Sprintf("Should've successfully waited for pod %s to succeed", synthLoggerPodName))
 
 		By("Waiting for logs to ingest")

test/e2e/cluster_logging_utils.go

@@ -73,12 +73,12 @@ func reportLogsFromFluentdPod(f *framework.Framework) error {
 
 	label := labels.SelectorFromSet(labels.Set(map[string]string{"k8s-app": "fluentd-logging"}))
 	options := api.ListOptions{LabelSelector: label}
-	fluentdPods, err := f.Client.Pods(api.NamespaceSystem).List(options)
+	fluentdPods, err := f.ClientSet.Core().Pods(api.NamespaceSystem).List(options)
 
 	for _, fluentdPod := range fluentdPods.Items {
 		if fluentdPod.Spec.NodeName == synthLoggerNodeName {
 			containerName := fluentdPod.Spec.Containers[0].Name
-			logs, err := framework.GetPodLogs(f.Client, api.NamespaceSystem, fluentdPod.Name, containerName)
+			logs, err := framework.GetPodLogs(f.ClientSet, api.NamespaceSystem, fluentdPod.Name, containerName)
 			if err != nil {
 				return fmt.Errorf("Failed to get logs from fluentd pod %s due to %v", fluentdPod.Name, err)
 			}

test/e2e/cluster_size_autoscaling.go

@@ -27,7 +27,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -50,14 +50,14 @@ const (
 
 var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 	f := framework.NewDefaultFramework("autoscaling")
-	var c *client.Client
+	var c clientset.Interface
 	var nodeCount int
 	var coresPerNode int
 	var memCapacityMb int
 	var originalSizes map[string]int
 
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
 		framework.SkipUnlessProviderIs("gce", "gke")
 
 		nodes := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
@@ -98,7 +98,7 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 	It("shouldn't increase cluster size if pending pod is too large [Feature:ClusterSizeAutoscalingScaleUp]", func() {
 		By("Creating unschedulable pod")
 		ReserveMemory(f, "memory-reservation", 1, memCapacityMb, false)
-		defer framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, "memory-reservation")
+		defer framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, "memory-reservation")
 
 		By("Waiting for scale up hoping it won't happen")
 		// Verfiy, that the appropreate event was generated.
@@ -106,7 +106,7 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 	EventsLoop:
 		for start := time.Now(); time.Since(start) < scaleUpTimeout; time.Sleep(20 * time.Second) {
 			By("Waiting for NotTriggerScaleUp event")
-			events, err := f.Client.Events(f.Namespace.Name).List(api.ListOptions{})
+			events, err := f.ClientSet.Core().Events(f.Namespace.Name).List(api.ListOptions{})
 			framework.ExpectNoError(err)
 
 			for _, e := range events.Items {
@@ -119,16 +119,16 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 		}
 		Expect(eventFound).Should(Equal(true))
 		// Verify, that cluster size is not changed.
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size <= nodeCount }, time.Second))
 	})
 
 	It("should increase cluster size if pending pods are small [Feature:ClusterSizeAutoscalingScaleUp]", func() {
 		ReserveMemory(f, "memory-reservation", 100, nodeCount*memCapacityMb, false)
-		defer framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, "memory-reservation")
+		defer framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, "memory-reservation")
 
 		// Verify, that cluster size is increased
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size >= nodeCount+1 }, scaleUpTimeout))
 		framework.ExpectNoError(waitForAllCaPodsReadyInNamespace(f, c))
 	})
@@ -144,10 +144,10 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 		glog.Infof("Not enabling cluster autoscaler for the node pool (on purpose).")
 
 		ReserveMemory(f, "memory-reservation", 100, nodeCount*memCapacityMb, false)
-		defer framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, "memory-reservation")
+		defer framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, "memory-reservation")
 
 		// Verify, that cluster size is increased
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size >= nodeCount+1 }, scaleUpTimeout))
 		framework.ExpectNoError(waitForAllCaPodsReadyInNamespace(f, c))
 	})
@@ -166,9 +166,9 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 
 	It("should increase cluster size if pods are pending due to host port conflict [Feature:ClusterSizeAutoscalingScaleUp]", func() {
 		CreateHostPortPods(f, "host-port", nodeCount+2, false)
-		defer framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, "host-port")
+		defer framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, "host-port")
 
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size >= nodeCount+2 }, scaleUpTimeout))
 		framework.ExpectNoError(waitForAllCaPodsReadyInNamespace(f, c))
 	})
@@ -203,7 +203,7 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 		By("Waiting for new node to appear and annotating it")
 		WaitForGroupSize(minMig, int32(minSize+1))
 		// Verify, that cluster size is increased
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size >= nodeCount+1 }, scaleUpTimeout))
 
 		newNodes, err := GetGroupNodes(minMig)
@@ -214,11 +214,11 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 		By(fmt.Sprintf("Setting labels for new nodes: %v", newNodesSet.List()))
 		updateNodeLabels(c, newNodesSet, labels, nil)
 
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size >= nodeCount+1 }, scaleUpTimeout))
 
 		framework.ExpectNoError(waitForAllCaPodsReadyInNamespace(f, c))
-		framework.ExpectNoError(framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, "node-selector"))
+		framework.ExpectNoError(framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, "node-selector"))
 	})
 
 	It("should scale up correct target pool [Feature:ClusterSizeAutoscalingScaleUp]", func() {
@@ -233,7 +233,7 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 
 		By("Creating rc with 2 pods too big to fit default-pool but fitting extra-pool")
 		ReserveMemory(f, "memory-reservation", 2, 2*memCapacityMb, false)
-		defer framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, "memory-reservation")
+		defer framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, "memory-reservation")
 
 		// Apparently GKE master is restarted couple minutes after the node pool is added
 		// reseting all the timers in scale down code. Adding 5 extra minutes to workaround
@@ -251,11 +251,11 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 			increasedSize += val + 2
 		}
 		setMigSizes(newSizes)
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size >= increasedSize }, scaleUpTimeout))
 
 		By("Some node should be removed")
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size < increasedSize }, scaleDownTimeout))
 	})
 
@@ -270,14 +270,14 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 			increasedSize += val + 2
 		}
 		setMigSizes(newSizes)
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size >= increasedSize }, scaleUpTimeout))
 
 		const extraPoolName = "extra-pool"
 		addNodePool(extraPoolName, "n1-standard-1", 3)
 		defer deleteNodePool(extraPoolName)
 
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size >= increasedSize+3 }, scaleUpTimeout))
 
 		By("Some node should be removed")
@@ -285,7 +285,7 @@ var _ = framework.KubeDescribe("Cluster size autoscaling [Slow]", func() {
 		// reseting all the timers in scale down code. Adding 10 extra minutes to workaround
 		// this issue.
 		// TODO: Remove the extra time when GKE restart is fixed.
-		framework.ExpectNoError(WaitForClusterSizeFunc(f.Client,
+		framework.ExpectNoError(WaitForClusterSizeFunc(f.ClientSet,
 			func(size int) bool { return size < increasedSize+3 }, scaleDownTimeout+10*time.Minute))
 	})
 })
@@ -458,11 +458,11 @@ func CreateNodeSelectorPods(f *framework.Framework, id string, replicas int, nod
 	By(fmt.Sprintf("Running RC which reserves host port and defines node selector"))
 
 	config := &testutils.RCConfig{
-		Client:       f.Client,
+		Client:       f.ClientSet,
 		Name:         "node-selector",
 		Namespace:    f.Namespace.Name,
 		Timeout:      defaultTimeout,
-		Image:        framework.GetPauseImageName(f.Client),
+		Image:        framework.GetPauseImageName(f.ClientSet),
 		Replicas:     replicas,
 		HostPorts:    map[string]int{"port1": 4321},
 		NodeSelector: map[string]string{"cluster-autoscaling-test.special-node": "true"},
@@ -476,11 +476,11 @@ func CreateNodeSelectorPods(f *framework.Framework, id string, replicas int, nod
 func CreateHostPortPods(f *framework.Framework, id string, replicas int, expectRunning bool) {
 	By(fmt.Sprintf("Running RC which reserves host port"))
 	config := &testutils.RCConfig{
-		Client:    f.Client,
+		Client:    f.ClientSet,
 		Name:      id,
 		Namespace: f.Namespace.Name,
 		Timeout:   defaultTimeout,
-		Image:     framework.GetPauseImageName(f.Client),
+		Image:     framework.GetPauseImageName(f.ClientSet),
 		Replicas:  replicas,
 		HostPorts: map[string]int{"port1": 4321},
 	}
@@ -494,11 +494,11 @@ func ReserveCpu(f *framework.Framework, id string, replicas, millicores int) {
 	By(fmt.Sprintf("Running RC which reserves %v millicores", millicores))
 	request := int64(millicores / replicas)
 	config := &testutils.RCConfig{
-		Client:     f.Client,
+		Client:     f.ClientSet,
 		Name:       id,
 		Namespace:  f.Namespace.Name,
 		Timeout:    defaultTimeout,
-		Image:      framework.GetPauseImageName(f.Client),
+		Image:      framework.GetPauseImageName(f.ClientSet),
 		Replicas:   replicas,
 		CpuRequest: request,
 	}
@@ -509,11 +509,11 @@ func ReserveMemory(f *framework.Framework, id string, replicas, megabytes int, e
 	By(fmt.Sprintf("Running RC which reserves %v MB of memory", megabytes))
 	request := int64(1024 * 1024 * megabytes / replicas)
 	config := &testutils.RCConfig{
-		Client:     f.Client,
+		Client:     f.ClientSet,
 		Name:       id,
 		Namespace:  f.Namespace.Name,
 		Timeout:    defaultTimeout,
-		Image:      framework.GetPauseImageName(f.Client),
+		Image:      framework.GetPauseImageName(f.ClientSet),
 		Replicas:   replicas,
 		MemRequest: request,
 	}
@@ -524,9 +524,9 @@ func ReserveMemory(f *framework.Framework, id string, replicas, megabytes int, e
 }
 
 // WaitForClusterSize waits until the cluster size matches the given function.
-func WaitForClusterSizeFunc(c *client.Client, sizeFunc func(int) bool, timeout time.Duration) error {
+func WaitForClusterSizeFunc(c clientset.Interface, sizeFunc func(int) bool, timeout time.Duration) error {
 	for start := time.Now(); time.Since(start) < timeout; time.Sleep(20 * time.Second) {
-		nodes, err := c.Nodes().List(api.ListOptions{FieldSelector: fields.Set{
+		nodes, err := c.Core().Nodes().List(api.ListOptions{FieldSelector: fields.Set{
 			"spec.unschedulable": "false",
 		}.AsSelector()})
 		if err != nil {
@@ -550,10 +550,10 @@ func WaitForClusterSizeFunc(c *client.Client, sizeFunc func(int) bool, timeout t
 	return fmt.Errorf("timeout waiting %v for appropriate cluster size", timeout)
 }
 
-func waitForAllCaPodsReadyInNamespace(f *framework.Framework, c *client.Client) error {
+func waitForAllCaPodsReadyInNamespace(f *framework.Framework, c clientset.Interface) error {
 	var notready []string
 	for start := time.Now(); time.Now().Before(start.Add(scaleUpTimeout)); time.Sleep(20 * time.Second) {
-		pods, err := c.Pods(f.Namespace.Name).List(api.ListOptions{})
+		pods, err := c.Core().Pods(f.Namespace.Name).List(api.ListOptions{})
 		if err != nil {
 			return fmt.Errorf("failed to get pods: %v", err)
 		}

test/e2e/cluster_upgrade.go

@@ -23,7 +23,6 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/test/e2e/chaosmonkey"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -44,7 +43,7 @@ var _ = framework.KubeDescribe("Upgrade [Feature:Upgrade]", func() {
 				v, err := realVersion(framework.TestContext.UpgradeTarget)
 				framework.ExpectNoError(err)
 				framework.ExpectNoError(framework.MasterUpgrade(v))
-				framework.ExpectNoError(checkMasterVersion(f.Client, v))
+				framework.ExpectNoError(checkMasterVersion(f.ClientSet, v))
 			})
 			cm.Register(func(sem *chaosmonkey.Semaphore) {
 				// Close over f.
@@ -90,7 +89,7 @@ var _ = framework.KubeDescribe("Upgrade [Feature:Upgrade]", func() {
 				v, err := realVersion(framework.TestContext.UpgradeTarget)
 				framework.ExpectNoError(err)
 				framework.ExpectNoError(framework.MasterUpgrade(v))
-				framework.ExpectNoError(checkMasterVersion(f.Client, v))
+				framework.ExpectNoError(checkMasterVersion(f.ClientSet, v))
 				framework.ExpectNoError(framework.NodeUpgrade(f, v, framework.TestContext.UpgradeImage))
 				framework.ExpectNoError(checkNodesVersions(f.ClientSet, v))
 			})
@@ -106,7 +105,7 @@ var _ = framework.KubeDescribe("Upgrade [Feature:Upgrade]", func() {
 				v, err := realVersion(framework.TestContext.UpgradeTarget)
 				framework.ExpectNoError(err)
 				framework.ExpectNoError(framework.MasterUpgrade(v))
-				framework.ExpectNoError(checkMasterVersion(f.Client, v))
+				framework.ExpectNoError(checkMasterVersion(f.ClientSet, v))
 				framework.ExpectNoError(framework.NodeUpgrade(f, v, framework.TestContext.UpgradeImage))
 				framework.ExpectNoError(checkNodesVersions(f.ClientSet, v))
 			})
@@ -147,7 +146,7 @@ func testService(f *framework.Framework, sem *chaosmonkey.Semaphore, testDuringD
 	// Setup
 	serviceName := "service-test"
 
-	jig := NewServiceTestJig(f.Client, f.ClientSet, serviceName)
+	jig := NewServiceTestJig(f.ClientSet, serviceName)
 	// nodeIP := pickNodeIP(jig.Client) // for later
 
 	By("creating a TCP service " + serviceName + " with type=LoadBalancer in namespace " + f.Namespace.Name)
@@ -192,7 +191,7 @@ func testService(f *framework.Framework, sem *chaosmonkey.Semaphore, testDuringD
 	jig.SanityCheckService(tcpService, api.ServiceTypeLoadBalancer)
 }
 
-func checkMasterVersion(c *client.Client, want string) error {
+func checkMasterVersion(c clientset.Interface, want string) error {
 	framework.Logf("Checking master version")
 	v, err := c.Discovery().ServerVersion()
 	if err != nil {

test/e2e/common/configmap.go

@@ -91,7 +91,7 @@ var _ = framework.KubeDescribe("ConfigMap", func() {
 
 		By(fmt.Sprintf("Creating configMap with name %s", configMap.Name))
 		var err error
-		if configMap, err = f.Client.ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
+		if configMap, err = f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
 			framework.Failf("unable to create test configMap %s: %v", configMap.Name, err)
 		}
 
@@ -133,7 +133,7 @@ var _ = framework.KubeDescribe("ConfigMap", func() {
 		f.PodClient().CreateSync(pod)
 
 		pollLogs := func() (string, error) {
-			return framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, containerName)
+			return framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, containerName)
 		}
 
 		Eventually(pollLogs, podLogTimeout, framework.Poll).Should(ContainSubstring("value-1"))
@@ -141,7 +141,7 @@ var _ = framework.KubeDescribe("ConfigMap", func() {
 		By(fmt.Sprintf("Updating configmap %v", configMap.Name))
 		configMap.ResourceVersion = "" // to force update
 		configMap.Data["data-1"] = "value-2"
-		_, err = f.Client.ConfigMaps(f.Namespace.Name).Update(configMap)
+		_, err = f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Update(configMap)
 		Expect(err).NotTo(HaveOccurred(), "Failed to update configmap %q in namespace %q", configMap.Name, f.Namespace.Name)
 
 		By("waiting to observe update in volume")
@@ -153,7 +153,7 @@ var _ = framework.KubeDescribe("ConfigMap", func() {
 		configMap := newConfigMap(f, name)
 		By(fmt.Sprintf("Creating configMap %v/%v", f.Namespace.Name, configMap.Name))
 		var err error
-		if configMap, err = f.Client.ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
+		if configMap, err = f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
 			framework.Failf("unable to create test configMap %s: %v", configMap.Name, err)
 		}
 
@@ -203,7 +203,7 @@ var _ = framework.KubeDescribe("ConfigMap", func() {
 
 		By(fmt.Sprintf("Creating configMap with name %s", configMap.Name))
 		var err error
-		if configMap, err = f.Client.ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
+		if configMap, err = f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
 			framework.Failf("unable to create test configMap %s: %v", configMap.Name, err)
 		}
 
@@ -288,7 +288,7 @@ func doConfigMapE2EWithoutMappings(f *framework.Framework, uid, fsGroup int64, d
 
 	By(fmt.Sprintf("Creating configMap with name %s", configMap.Name))
 	var err error
-	if configMap, err = f.Client.ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
+	if configMap, err = f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
 		framework.Failf("unable to create test configMap %s: %v", configMap.Name, err)
 	}
 
@@ -367,7 +367,7 @@ func doConfigMapE2EWithMappings(f *framework.Framework, uid, fsGroup int64, item
 	By(fmt.Sprintf("Creating configMap with name %s", configMap.Name))
 
 	var err error
-	if configMap, err = f.Client.ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
+	if configMap, err = f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Create(configMap); err != nil {
 		framework.Failf("unable to create test configMap %s: %v", configMap.Name, err)
 	}
 

test/e2e/common/container_probe.go

@@ -331,7 +331,7 @@ func runLivenessTest(f *framework.Framework, pod *api.Pod, expectNumRestarts int
 	// Wait until the pod is not pending. (Here we need to check for something other than
 	// 'Pending' other than checking for 'Running', since when failures occur, we go to
 	// 'Terminated' which can cause indefinite blocking.)
-	framework.ExpectNoError(framework.WaitForPodNotPending(f.Client, ns, pod.Name, pod.ResourceVersion),
+	framework.ExpectNoError(framework.WaitForPodNotPending(f.ClientSet, ns, pod.Name, pod.ResourceVersion),
 		fmt.Sprintf("starting pod %s in namespace %s", pod.Name, ns))
 	framework.Logf("Started pod %s in namespace %s", pod.Name, ns)
 

test/e2e/common/downwardapi_volume.go

@@ -93,7 +93,7 @@ var _ = framework.KubeDescribe("Downward API volume", func() {
 		podClient.CreateSync(pod)
 
 		Eventually(func() (string, error) {
-			return framework.GetPodLogs(f.Client, f.Namespace.Name, podName, containerName)
+			return framework.GetPodLogs(f.ClientSet, f.Namespace.Name, podName, containerName)
 		},
 			podLogTimeout, framework.Poll).Should(ContainSubstring("key1=\"value1\"\n"))
 
@@ -103,7 +103,7 @@ var _ = framework.KubeDescribe("Downward API volume", func() {
 		})
 
 		Eventually(func() (string, error) {
-			return framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, containerName)
+			return framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, containerName)
 		},
 			podLogTimeout, framework.Poll).Should(ContainSubstring("key3=\"value3\"\n"))
 	})
@@ -122,7 +122,7 @@ var _ = framework.KubeDescribe("Downward API volume", func() {
 		Expect(err).NotTo(HaveOccurred(), "Failed to get pod %q", pod.Name)
 
 		Eventually(func() (string, error) {
-			return framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, containerName)
+			return framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, containerName)
 		},
 			podLogTimeout, framework.Poll).Should(ContainSubstring("builder=\"bar\"\n"))
 
@@ -132,7 +132,7 @@ var _ = framework.KubeDescribe("Downward API volume", func() {
 		})
 
 		Eventually(func() (string, error) {
-			return framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, containerName)
+			return framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, containerName)
 		},
 			podLogTimeout, framework.Poll).Should(ContainSubstring("builder=\"foo\"\n"))
 	})

test/e2e/common/init_container.go

@@ -128,7 +128,7 @@ var _ = framework.KubeDescribe("InitContainer", func() {
 				Containers: []api.Container{
 					{
 						Name:  "run1",
-						Image: framework.GetPauseImageName(f.Client),
+						Image: framework.GetPauseImageName(f.ClientSet),
 						Resources: api.ResourceRequirements{
 							Limits: api.ResourceList{
 								api.ResourceCPU:    *resource.NewMilliQuantity(100, resource.DecimalSI),
@@ -191,7 +191,7 @@ var _ = framework.KubeDescribe("InitContainer", func() {
 				Containers: []api.Container{
 					{
 						Name:  "run1",
-						Image: framework.GetPauseImageName(f.Client),
+						Image: framework.GetPauseImageName(f.ClientSet),
 						Resources: api.ResourceRequirements{
 							Limits: api.ResourceList{
 								api.ResourceCPU:    *resource.NewMilliQuantity(100, resource.DecimalSI),

test/e2e/common/pods.go

@@ -135,7 +135,7 @@ var _ = framework.KubeDescribe("Pods", func() {
 				Containers: []api.Container{
 					{
 						Name:  "test",
-						Image: framework.GetPauseImageName(f.Client),
+						Image: framework.GetPauseImageName(f.ClientSet),
 					},
 				},
 			},
@@ -211,7 +211,7 @@ var _ = framework.KubeDescribe("Pods", func() {
 
 		By("verifying the kubelet observed the termination notice")
 		Expect(wait.Poll(time.Second*5, time.Second*30, func() (bool, error) {
-			podList, err := framework.GetKubeletPods(f.Client, pod.Spec.NodeName)
+			podList, err := framework.GetKubeletPods(f.ClientSet, pod.Spec.NodeName)
 			if err != nil {
 				framework.Logf("Unable to retrieve kubelet pods for node %v: %v", pod.Spec.NodeName, err)
 				return false, nil
@@ -396,7 +396,7 @@ var _ = framework.KubeDescribe("Pods", func() {
 				},
 			},
 		}
-		_, err := f.Client.Services(f.Namespace.Name).Create(svc)
+		_, err := f.ClientSet.Core().Services(f.Namespace.Name).Create(svc)
 		Expect(err).NotTo(HaveOccurred(), "failed to create service")
 
 		// Make a client pod that verifies that it has the service environment variables.
@@ -460,7 +460,7 @@ var _ = framework.KubeDescribe("Pods", func() {
 		By("submitting the pod to kubernetes")
 		pod = podClient.CreateSync(pod)
 
-		req := f.Client.Get().
+		req := f.ClientSet.Core().RESTClient().Get().
 			Namespace(f.Namespace.Name).
 			Resource("pods").
 			Name(pod.Name).
@@ -530,7 +530,7 @@ var _ = framework.KubeDescribe("Pods", func() {
 		By("submitting the pod to kubernetes")
 		podClient.CreateSync(pod)
 
-		req := f.Client.Get().
+		req := f.ClientSet.Core().RESTClient().Get().
 			Namespace(f.Namespace.Name).
 			Resource("pods").
 			Name(pod.Name).

test/e2e/common/secrets.go

@@ -63,7 +63,7 @@ var _ = framework.KubeDescribe("Secrets", func() {
 
 		By(fmt.Sprintf("Creating secret with name %s", secret.Name))
 		var err error
-		if secret, err = f.Client.Secrets(f.Namespace.Name).Create(secret); err != nil {
+		if secret, err = f.ClientSet.Core().Secrets(f.Namespace.Name).Create(secret); err != nil {
 			framework.Failf("unable to create test secret %s: %v", secret.Name, err)
 		}
 
@@ -127,7 +127,7 @@ var _ = framework.KubeDescribe("Secrets", func() {
 
 		By(fmt.Sprintf("Creating secret with name %s", secret.Name))
 		var err error
-		if secret, err = f.Client.Secrets(f.Namespace.Name).Create(secret); err != nil {
+		if secret, err = f.ClientSet.Core().Secrets(f.Namespace.Name).Create(secret); err != nil {
 			framework.Failf("unable to create test secret %s: %v", secret.Name, err)
 		}
 
@@ -190,7 +190,7 @@ func doSecretE2EWithoutMapping(f *framework.Framework, defaultMode *int32) {
 
 	By(fmt.Sprintf("Creating secret with name %s", secret.Name))
 	var err error
-	if secret, err = f.Client.Secrets(f.Namespace.Name).Create(secret); err != nil {
+	if secret, err = f.ClientSet.Core().Secrets(f.Namespace.Name).Create(secret); err != nil {
 		framework.Failf("unable to create test secret %s: %v", secret.Name, err)
 	}
 
@@ -254,7 +254,7 @@ func doSecretE2EWithMapping(f *framework.Framework, mode *int32) {
 
 	By(fmt.Sprintf("Creating secret with name %s", secret.Name))
 	var err error
-	if secret, err = f.Client.Secrets(f.Namespace.Name).Create(secret); err != nil {
+	if secret, err = f.ClientSet.Core().Secrets(f.Namespace.Name).Create(secret); err != nil {
 		framework.Failf("unable to create test secret %s: %v", secret.Name, err)
 	}
 

test/e2e/common/sysctl.go

@@ -58,7 +58,7 @@ var _ = framework.KubeDescribe("Sysctls", func() {
 	waitForPodErrorEventOrStarted := func(pod *api.Pod) (*api.Event, error) {
 		var ev *api.Event
 		err := wait.Poll(framework.Poll, framework.PodStartTimeout, func() (bool, error) {
-			evnts, err := f.Client.Events(pod.Namespace).Search(pod)
+			evnts, err := f.ClientSet.Core().Events(pod.Namespace).Search(pod)
 			if err != nil {
 				return false, fmt.Errorf("error in listing events: %s", err)
 			}
@@ -114,7 +114,7 @@ var _ = framework.KubeDescribe("Sysctls", func() {
 		Expect(pod.Status.Phase).To(Equal(api.PodSucceeded))
 
 		By("Getting logs from the pod")
-		log, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, pod.Spec.Containers[0].Name)
+		log, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, pod.Spec.Containers[0].Name)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Checking that the sysctl is actually updated")
@@ -155,7 +155,7 @@ var _ = framework.KubeDescribe("Sysctls", func() {
 		Expect(pod.Status.Phase).To(Equal(api.PodSucceeded))
 
 		By("Getting logs from the pod")
-		log, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, pod.Spec.Containers[0].Name)
+		log, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, pod.Spec.Containers[0].Name)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Checking that the sysctl is actually updated")
@@ -194,7 +194,7 @@ var _ = framework.KubeDescribe("Sysctls", func() {
 		})
 
 		By("Creating a pod with one valid and two invalid sysctls")
-		client := f.Client.Pods(f.Namespace.Name)
+		client := f.ClientSet.Core().Pods(f.Namespace.Name)
 		_, err := client.Create(pod)
 
 		Expect(err).NotTo(BeNil())

test/e2e/daemon_restart.go

@@ -23,7 +23,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/cache"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/master/ports"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -169,9 +169,9 @@ func replacePods(pods []*api.Pod, store cache.Store) {
 
 // getContainerRestarts returns the count of container restarts across all pods matching the given labelSelector,
 // and a list of nodenames across which these containers restarted.
-func getContainerRestarts(c *client.Client, ns string, labelSelector labels.Selector) (int, []string) {
+func getContainerRestarts(c clientset.Interface, ns string, labelSelector labels.Selector) (int, []string) {
 	options := api.ListOptions{LabelSelector: labelSelector}
-	pods, err := c.Pods(ns).List(options)
+	pods, err := c.Core().Pods(ns).List(options)
 	framework.ExpectNoError(err)
 	failedContainers := 0
 	containerRestartNodes := sets.NewString()
@@ -205,10 +205,10 @@ var _ = framework.KubeDescribe("DaemonRestart [Disruptive]", func() {
 		// All the restart tests need an rc and a watch on pods of the rc.
 		// Additionally some of them might scale the rc during the test.
 		config = testutils.RCConfig{
-			Client:      f.Client,
+			Client:      f.ClientSet,
 			Name:        rcName,
 			Namespace:   ns,
-			Image:       framework.GetPauseImageName(f.Client),
+			Image:       framework.GetPauseImageName(f.ClientSet),
 			Replicas:    numPods,
 			CreatedPods: &[]*api.Pod{},
 		}
@@ -221,11 +221,12 @@ var _ = framework.KubeDescribe("DaemonRestart [Disruptive]", func() {
 			&cache.ListWatch{
 				ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 					options.LabelSelector = labelSelector
-					return f.Client.Pods(ns).List(options)
+					obj, err := f.ClientSet.Core().Pods(ns).List(options)
+					return runtime.Object(obj), err
 				},
 				WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 					options.LabelSelector = labelSelector
-					return f.Client.Pods(ns).Watch(options)
+					return f.ClientSet.Core().Pods(ns).Watch(options)
 				},
 			},
 			&api.Pod{},
@@ -262,7 +263,7 @@ var _ = framework.KubeDescribe("DaemonRestart [Disruptive]", func() {
 		// that it had the opportunity to create/delete pods, if it were going to do so. Scaling the RC
 		// to the same size achieves this, because the scale operation advances the RC's sequence number
 		// and awaits it to be observed and reported back in the RC's status.
-		framework.ScaleRC(f.Client, f.ClientSet, ns, rcName, numPods, true)
+		framework.ScaleRC(f.ClientSet, ns, rcName, numPods, true)
 
 		// Only check the keys, the pods can be different if the kubelet updated it.
 		// TODO: Can it really?
@@ -293,16 +294,16 @@ var _ = framework.KubeDescribe("DaemonRestart [Disruptive]", func() {
 		restarter.kill()
 		// This is best effort to try and create pods while the scheduler is down,
 		// since we don't know exactly when it is restarted after the kill signal.
-		framework.ExpectNoError(framework.ScaleRC(f.Client, f.ClientSet, ns, rcName, numPods+5, false))
+		framework.ExpectNoError(framework.ScaleRC(f.ClientSet, ns, rcName, numPods+5, false))
 		restarter.waitUp()
-		framework.ExpectNoError(framework.ScaleRC(f.Client, f.ClientSet, ns, rcName, numPods+5, true))
+		framework.ExpectNoError(framework.ScaleRC(f.ClientSet, ns, rcName, numPods+5, true))
 	})
 
 	It("Kubelet should not restart containers across restart", func() {
 
 		nodeIPs, err := getNodePublicIps(f.ClientSet)
 		framework.ExpectNoError(err)
-		preRestarts, badNodes := getContainerRestarts(f.Client, ns, labelSelector)
+		preRestarts, badNodes := getContainerRestarts(f.ClientSet, ns, labelSelector)
 		if preRestarts != 0 {
 			framework.Logf("WARNING: Non-zero container restart count: %d across nodes %v", preRestarts, badNodes)
 		}
@@ -311,9 +312,9 @@ var _ = framework.KubeDescribe("DaemonRestart [Disruptive]", func() {
 				ip, "kubelet", ports.KubeletReadOnlyPort, restartPollInterval, restartTimeout)
 			restarter.restart()
 		}
-		postRestarts, badNodes := getContainerRestarts(f.Client, ns, labelSelector)
+		postRestarts, badNodes := getContainerRestarts(f.ClientSet, ns, labelSelector)
 		if postRestarts != preRestarts {
-			framework.DumpNodeDebugInfo(f.Client, badNodes, framework.Logf)
+			framework.DumpNodeDebugInfo(f.ClientSet, badNodes, framework.Logf)
 			framework.Failf("Net container restart count went from %v -> %v after kubelet restart on nodes %v \n\n %+v", preRestarts, postRestarts, badNodes, tracker)
 		}
 	})

test/e2e/daemon_set.go

@@ -28,7 +28,6 @@ import (
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/kubectl"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -59,17 +58,17 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() {
 	var f *framework.Framework
 
 	AfterEach(func() {
-		if daemonsets, err := f.Client.DaemonSets(f.Namespace.Name).List(api.ListOptions{}); err == nil {
+		if daemonsets, err := f.ClientSet.Extensions().DaemonSets(f.Namespace.Name).List(api.ListOptions{}); err == nil {
 			framework.Logf("daemonset: %s", runtime.EncodeOrDie(api.Codecs.LegacyCodec(registered.EnabledVersions()...), daemonsets))
 		} else {
 			framework.Logf("unable to dump daemonsets: %v", err)
 		}
-		if pods, err := f.Client.Pods(f.Namespace.Name).List(api.ListOptions{}); err == nil {
+		if pods, err := f.ClientSet.Core().Pods(f.Namespace.Name).List(api.ListOptions{}); err == nil {
 			framework.Logf("pods: %s", runtime.EncodeOrDie(api.Codecs.LegacyCodec(registered.EnabledVersions()...), pods))
 		} else {
 			framework.Logf("unable to dump pods: %v", err)
 		}
-		err := clearDaemonSetNodeLabels(f.Client, f.ClientSet)
+		err := clearDaemonSetNodeLabels(f.ClientSet)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -79,12 +78,13 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() {
 	dsName := "daemon-set"
 
 	var ns string
-	var c *client.Client
+	var c clientset.Interface
 
 	BeforeEach(func() {
 		ns = f.Namespace.Name
-		c = f.Client
+
-		err := clearDaemonSetNodeLabels(c, f.ClientSet)
+		c = f.ClientSet
+		err := clearDaemonSetNodeLabels(c)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -92,7 +92,7 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() {
 		label := map[string]string{daemonsetNameLabel: dsName}
 
 		framework.Logf("Creating simple daemon set %s", dsName)
-		_, err := c.DaemonSets(ns).Create(&extensions.DaemonSet{
+		_, err := c.Extensions().DaemonSets(ns).Create(&extensions.DaemonSet{
 			ObjectMeta: api.ObjectMeta{
 				Name: dsName,
 			},
@@ -132,7 +132,7 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Stop a daemon pod, check that the daemon pod is revived.")
-		podClient := c.Pods(ns)
+		podClient := c.Core().Pods(ns)
 
 		selector := labels.Set(label).AsSelector()
 		options := api.ListOptions{LabelSelector: selector}
@@ -151,7 +151,7 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() {
 		complexLabel := map[string]string{daemonsetNameLabel: dsName}
 		nodeSelector := map[string]string{daemonsetColorLabel: "blue"}
 		framework.Logf("Creating daemon with a node selector %s", dsName)
-		_, err := c.DaemonSets(ns).Create(&extensions.DaemonSet{
+		_, err := c.Extensions().DaemonSets(ns).Create(&extensions.DaemonSet{
 			ObjectMeta: api.ObjectMeta{
 				Name: dsName,
 			},
@@ -199,7 +199,7 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() {
 			NotTo(HaveOccurred(), "error waiting for daemon pod to not be running on nodes")
 
 		By("We should now be able to delete the daemon set.")
-		Expect(c.DaemonSets(ns).Delete(dsName)).NotTo(HaveOccurred())
+		Expect(c.Extensions().DaemonSets(ns).Delete(dsName, nil)).NotTo(HaveOccurred())
 
 	})
 
@@ -219,7 +219,7 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() {
 				}]
 			}}}`, daemonsetColorLabel, nodeSelector[daemonsetColorLabel]),
 		}
-		_, err := c.DaemonSets(ns).Create(&extensions.DaemonSet{
+		_, err := c.Extensions().DaemonSets(ns).Create(&extensions.DaemonSet{
 			ObjectMeta: api.ObjectMeta{
 				Name: dsName,
 			},
@@ -267,7 +267,7 @@ var _ = framework.KubeDescribe("Daemon set [Serial]", func() {
 			NotTo(HaveOccurred(), "error waiting for daemon pod to not be running on nodes")
 
 		By("We should now be able to delete the daemon set.")
-		Expect(c.DaemonSets(ns).Delete(dsName)).NotTo(HaveOccurred())
+		Expect(c.Extensions().DaemonSets(ns).Delete(dsName, nil)).NotTo(HaveOccurred())
 
 	})
 })
@@ -285,8 +285,8 @@ func separateDaemonSetNodeLabels(labels map[string]string) (map[string]string, m
 	return daemonSetLabels, otherLabels
 }
 
-func clearDaemonSetNodeLabels(c *client.Client, cs clientset.Interface) error {
+func clearDaemonSetNodeLabels(c clientset.Interface) error {
-	nodeList := framework.GetReadySchedulableNodesOrDie(cs)
+	nodeList := framework.GetReadySchedulableNodesOrDie(c)
 	for _, node := range nodeList.Items {
 		_, err := setDaemonSetNodeLabels(c, node.Name, map[string]string{})
 		if err != nil {
@@ -296,8 +296,8 @@ func clearDaemonSetNodeLabels(c *client.Client, cs clientset.Interface) error {
 	return nil
 }
 
-func setDaemonSetNodeLabels(c *client.Client, nodeName string, labels map[string]string) (*api.Node, error) {
+func setDaemonSetNodeLabels(c clientset.Interface, nodeName string, labels map[string]string) (*api.Node, error) {
-	nodeClient := c.Nodes()
+	nodeClient := c.Core().Nodes()
 	var newNode *api.Node
 	var newLabels map[string]string
 	err := wait.Poll(dsRetryPeriod, dsRetryTimeout, func() (bool, error) {
@@ -340,7 +340,7 @@ func checkDaemonPodOnNodes(f *framework.Framework, selector map[string]string, n
 	return func() (bool, error) {
 		selector := labels.Set(selector).AsSelector()
 		options := api.ListOptions{LabelSelector: selector}
-		podList, err := f.Client.Pods(f.Namespace.Name).List(options)
+		podList, err := f.ClientSet.Core().Pods(f.Namespace.Name).List(options)
 		if err != nil {
 			return false, nil
 		}
@@ -368,7 +368,7 @@ func checkDaemonPodOnNodes(f *framework.Framework, selector map[string]string, n
 
 func checkRunningOnAllNodes(f *framework.Framework, selector map[string]string) func() (bool, error) {
 	return func() (bool, error) {
-		nodeList, err := f.Client.Nodes().List(api.ListOptions{})
+		nodeList, err := f.ClientSet.Core().Nodes().List(api.ListOptions{})
 		framework.ExpectNoError(err)
 		nodeNames := make([]string, 0)
 		for _, node := range nodeList.Items {
@@ -383,7 +383,7 @@ func checkRunningOnNoNodes(f *framework.Framework, selector map[string]string) f
 }
 
 func checkDaemonStatus(f *framework.Framework, dsName string) error {
-	ds, err := f.Client.DaemonSets(f.Namespace.Name).Get(dsName)
+	ds, err := f.ClientSet.Extensions().DaemonSets(f.Namespace.Name).Get(dsName)
 	if err != nil {
 		return fmt.Errorf("Could not get daemon set from api.")
 	}

test/e2e/dashboard.go

@@ -43,18 +43,18 @@ var _ = framework.KubeDescribe("Kubernetes Dashboard", func() {
 
 	It("should check that the kubernetes-dashboard instance is alive", func() {
 		By("Checking whether the kubernetes-dashboard service exists.")
-		err := framework.WaitForService(f.Client, uiNamespace, uiServiceName, true, framework.Poll, framework.ServiceStartTimeout)
+		err := framework.WaitForService(f.ClientSet, uiNamespace, uiServiceName, true, framework.Poll, framework.ServiceStartTimeout)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Checking to make sure the kubernetes-dashboard pods are running")
 		selector := labels.SelectorFromSet(labels.Set(map[string]string{"k8s-app": uiAppName}))
-		err = testutils.WaitForPodsWithLabelRunning(f.Client, uiNamespace, selector)
+		err = testutils.WaitForPodsWithLabelRunning(f.ClientSet, uiNamespace, selector)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Checking to make sure we get a response from the kubernetes-dashboard.")
 		err = wait.Poll(framework.Poll, serverStartTimeout, func() (bool, error) {
 			var status int
-			proxyRequest, errProxy := framework.GetServicesProxyRequest(f.Client, f.Client.Get())
+			proxyRequest, errProxy := framework.GetServicesProxyRequest(f.ClientSet, f.ClientSet.Core().RESTClient().Get())
 			if errProxy != nil {
 				framework.Logf("Get services proxy request failed: %v", errProxy)
 			}
@@ -77,7 +77,7 @@ var _ = framework.KubeDescribe("Kubernetes Dashboard", func() {
 
 		By("Checking that the ApiServer /ui endpoint redirects to a valid server.")
 		var status int
-		err = f.Client.Get().
+		err = f.ClientSet.Core().RESTClient().Get().
 			AbsPath("/ui").
 			Timeout(framework.SingleCallTimeout).
 			Do().

test/e2e/density.go

@@ -30,7 +30,6 @@ import (
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/client/cache"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -55,7 +54,6 @@ var MaxContainerFailures = 0
 
 type DensityTestConfig struct {
 	Configs      []testutils.RCConfig
-	Client       *client.Client
 	ClientSet    internalclientset.Interface
 	Namespace    string
 	PollInterval time.Duration
@@ -162,7 +160,7 @@ func density30AddonResourceVerifier(numNodes int) map[string]framework.ResourceC
 	return constraints
 }
 
-func logPodStartupStatus(c *client.Client, expectedPods int, ns string, observedLabels map[string]string, period time.Duration, stopCh chan struct{}) {
+func logPodStartupStatus(c internalclientset.Interface, expectedPods int, ns string, observedLabels map[string]string, period time.Duration, stopCh chan struct{}) {
 	label := labels.SelectorFromSet(labels.Set(observedLabels))
 	podStore := testutils.NewPodStore(c, ns, label, fields.Everything())
 	defer podStore.Stop()
@@ -194,10 +192,10 @@ func runDensityTest(dtc DensityTestConfig) time.Duration {
 	_, controller := cache.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return dtc.Client.Events(dtc.Namespace).List(options)
+				return dtc.ClientSet.Core().Events(dtc.Namespace).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return dtc.Client.Events(dtc.Namespace).Watch(options)
+				return dtc.ClientSet.Core().Events(dtc.Namespace).Watch(options)
 			},
 		},
 		&api.Event{},
@@ -222,11 +220,11 @@ func runDensityTest(dtc DensityTestConfig) time.Duration {
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 				options.LabelSelector = label
-				return dtc.Client.Pods(dtc.Namespace).List(options)
+				return dtc.ClientSet.Core().Pods(dtc.Namespace).List(options)
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 				options.LabelSelector = label
-				return dtc.Client.Pods(dtc.Namespace).Watch(options)
+				return dtc.ClientSet.Core().Pods(dtc.Namespace).Watch(options)
 			},
 		},
 		&api.Pod{},
@@ -254,7 +252,7 @@ func runDensityTest(dtc DensityTestConfig) time.Duration {
 		}()
 	}
 	logStopCh := make(chan struct{})
-	go logPodStartupStatus(dtc.Client, dtc.PodCount, dtc.Namespace, map[string]string{"type": "densityPod"}, dtc.PollInterval, logStopCh)
+	go logPodStartupStatus(dtc.ClientSet, dtc.PodCount, dtc.Namespace, map[string]string{"type": "densityPod"}, dtc.PollInterval, logStopCh)
 	wg.Wait()
 	startupTime := time.Now().Sub(startTime)
 	close(logStopCh)
@@ -296,7 +294,7 @@ func runDensityTest(dtc DensityTestConfig) time.Duration {
 	Expect(badEvents).NotTo(BeNumerically(">", int(math.Floor(0.01*float64(dtc.PodCount)))))
 	// Print some data about Pod to Node allocation
 	By("Printing Pod to Node allocation data")
-	podList, err := dtc.Client.Pods(api.NamespaceAll).List(api.ListOptions{})
+	podList, err := dtc.ClientSet.Core().Pods(api.NamespaceAll).List(api.ListOptions{})
 	framework.ExpectNoError(err)
 	pausePodAllocation := make(map[string]int)
 	systemPodAllocation := make(map[string][]string)
@@ -324,15 +322,15 @@ func cleanupDensityTest(dtc DensityTestConfig) {
 	// We explicitly delete all pods to have API calls necessary for deletion accounted in metrics.
 	for i := range dtc.Configs {
 		rcName := dtc.Configs[i].Name
-		rc, err := dtc.Client.ReplicationControllers(dtc.Namespace).Get(rcName)
+		rc, err := dtc.ClientSet.Core().ReplicationControllers(dtc.Namespace).Get(rcName)
 		if err == nil && rc.Spec.Replicas != 0 {
 			if framework.TestContext.GarbageCollectorEnabled {
 				By("Cleaning up only the replication controller, garbage collector will clean up the pods")
-				err := framework.DeleteRCAndWaitForGC(dtc.Client, dtc.Namespace, rcName)
+				err := framework.DeleteRCAndWaitForGC(dtc.ClientSet, dtc.Namespace, rcName)
 				framework.ExpectNoError(err)
 			} else {
 				By("Cleaning up the replication controller and pods")
-				err := framework.DeleteRCAndPods(dtc.Client, dtc.ClientSet, dtc.Namespace, rcName)
+				err := framework.DeleteRCAndPods(dtc.ClientSet, dtc.Namespace, rcName)
 				framework.ExpectNoError(err)
 			}
 		}
@@ -347,7 +345,7 @@ func cleanupDensityTest(dtc DensityTestConfig) {
 // results will not be representative for control-plane performance as we'll start hitting
 // limits on Docker's concurrent container startup.
 var _ = framework.KubeDescribe("Density", func() {
-	var c *client.Client
+	var c internalclientset.Interface
 	var nodeCount int
 	var RCName string
 	var additionalPodsPrefix string
@@ -392,7 +390,7 @@ var _ = framework.KubeDescribe("Density", func() {
 	f.NamespaceDeletionTimeout = time.Hour
 
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 
 		// In large clusters we may get to this point but still have a bunch
@@ -477,7 +475,7 @@ var _ = framework.KubeDescribe("Density", func() {
 			for i := 0; i < numberOrRCs; i++ {
 				RCName := "density" + strconv.Itoa(totalPods) + "-" + strconv.Itoa(i) + "-" + uuid
 				RCConfigs[i] = testutils.RCConfig{Client: c,
-					Image:                framework.GetPauseImageName(f.Client),
+					Image:                framework.GetPauseImageName(f.ClientSet),
 					Name:                 RCName,
 					Namespace:            ns,
 					Labels:               map[string]string{"type": "densityPod"},
@@ -492,7 +490,6 @@ var _ = framework.KubeDescribe("Density", func() {
 			}
 
 			dConfig := DensityTestConfig{
-				Client:       c,
 				ClientSet:    f.ClientSet,
 				Configs:      RCConfigs,
 				PodCount:     totalPods,
@@ -543,11 +540,12 @@ var _ = framework.KubeDescribe("Density", func() {
 					&cache.ListWatch{
 						ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 							options.LabelSelector = labels.SelectorFromSet(labels.Set{"type": additionalPodsPrefix})
-							return c.Pods(ns).List(options)
+							obj, err := c.Core().Pods(ns).List(options)
+							return runtime.Object(obj), err
 						},
 						WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 							options.LabelSelector = labels.SelectorFromSet(labels.Set{"type": additionalPodsPrefix})
-							return c.Pods(ns).Watch(options)
+							return c.Core().Pods(ns).Watch(options)
 						},
 					},
 					&api.Pod{},
@@ -586,7 +584,7 @@ var _ = framework.KubeDescribe("Density", func() {
 				}
 				for i := 1; i <= nodeCount; i++ {
 					name := additionalPodsPrefix + "-" + strconv.Itoa(i)
-					go createRunningPodFromRC(&wg, c, name, ns, framework.GetPauseImageName(f.Client), additionalPodsPrefix, cpuRequest, memRequest)
+					go createRunningPodFromRC(&wg, c, name, ns, framework.GetPauseImageName(f.ClientSet), additionalPodsPrefix, cpuRequest, memRequest)
 					time.Sleep(200 * time.Millisecond)
 				}
 				wg.Wait()
@@ -616,7 +614,7 @@ var _ = framework.KubeDescribe("Density", func() {
 					"source":                   api.DefaultSchedulerName,
 				}.AsSelector()
 				options := api.ListOptions{FieldSelector: selector}
-				schedEvents, err := c.Events(ns).List(options)
+				schedEvents, err := c.Core().Events(ns).List(options)
 				framework.ExpectNoError(err)
 				for k := range createTimes {
 					for _, event := range schedEvents.Items {
@@ -700,7 +698,7 @@ var _ = framework.KubeDescribe("Density", func() {
 			}
 			RCName = "density" + strconv.Itoa(totalPods) + "-" + strconv.Itoa(i) + "-" + uuid
 			RCConfigs[i] = testutils.RCConfig{Client: c,
-				Image:                framework.GetPauseImageName(f.Client),
+				Image:                framework.GetPauseImageName(f.ClientSet),
 				Name:                 RCName,
 				Namespace:            ns,
 				Labels:               map[string]string{"type": "densityPod"},
@@ -712,7 +710,6 @@ var _ = framework.KubeDescribe("Density", func() {
 			}
 		}
 		dConfig := DensityTestConfig{
-			Client:       c,
 			ClientSet:    f.ClientSet,
 			Configs:      RCConfigs,
 			PodCount:     totalPods,
@@ -725,7 +722,7 @@ var _ = framework.KubeDescribe("Density", func() {
 	})
 })
 
-func createRunningPodFromRC(wg *sync.WaitGroup, c *client.Client, name, ns, image, podType string, cpuRequest, memRequest resource.Quantity) {
+func createRunningPodFromRC(wg *sync.WaitGroup, c internalclientset.Interface, name, ns, image, podType string, cpuRequest, memRequest resource.Quantity) {
 	defer GinkgoRecover()
 	defer wg.Done()
 	labels := map[string]string{
@@ -762,7 +759,7 @@ func createRunningPodFromRC(wg *sync.WaitGroup, c *client.Client, name, ns, imag
 			},
 		},
 	}
-	_, err := c.ReplicationControllers(ns).Create(rc)
+	_, err := c.Core().ReplicationControllers(ns).Create(rc)
 	framework.ExpectNoError(err)
 	framework.ExpectNoError(framework.WaitForRCPodsRunning(c, ns, name))
 	framework.Logf("Found pod '%s' running", name)

test/e2e/deployment.go

@@ -320,9 +320,6 @@ func testDeleteDeployment(f *framework.Framework) {
 
 func testRollingUpdateDeployment(f *framework.Framework) {
 	ns := f.Namespace.Name
-	// TODO: remove unversionedClient when the refactoring is done. Currently some
-	// functions like verifyPod still expects a unversioned#Client.
-	unversionedClient := f.Client
 	c := f.ClientSet
 	// Create nginx pods.
 	deploymentPodLabels := map[string]string{"name": "sample-pod"}
@@ -336,7 +333,7 @@ func testRollingUpdateDeployment(f *framework.Framework) {
 	_, err := c.Extensions().ReplicaSets(ns).Create(newRS(rsName, replicas, rsPodLabels, nginxImageName, nginxImage))
 	Expect(err).NotTo(HaveOccurred())
 	// Verify that the required pods have come up.
-	err = framework.VerifyPods(unversionedClient, ns, "sample-pod", false, 3)
+	err = framework.VerifyPods(c, ns, "sample-pod", false, 3)
 	if err != nil {
 		framework.Logf("error in waiting for pods to come up: %s", err)
 		Expect(err).NotTo(HaveOccurred())
@@ -369,9 +366,6 @@ func testRollingUpdateDeployment(f *framework.Framework) {
 
 func testRollingUpdateDeploymentEvents(f *framework.Framework) {
 	ns := f.Namespace.Name
-	// TODO: remove unversionedClient when the refactoring is done. Currently some
-	// functions like verifyPod still expects a unversioned#Client.
-	unversionedClient := f.Client
 	c := f.ClientSet
 	// Create nginx pods.
 	deploymentPodLabels := map[string]string{"name": "sample-pod-2"}
@@ -391,7 +385,7 @@ func testRollingUpdateDeploymentEvents(f *framework.Framework) {
 	_, err := c.Extensions().ReplicaSets(ns).Create(rs)
 	Expect(err).NotTo(HaveOccurred())
 	// Verify that the required pods have come up.
-	err = framework.VerifyPods(unversionedClient, ns, "sample-pod-2", false, 1)
+	err = framework.VerifyPods(c, ns, "sample-pod-2", false, 1)
 	if err != nil {
 		framework.Logf("error in waiting for pods to come up: %s", err)
 		Expect(err).NotTo(HaveOccurred())
@@ -412,7 +406,7 @@ func testRollingUpdateDeploymentEvents(f *framework.Framework) {
 	// Verify that the pods were scaled up and down as expected. We use events to verify that.
 	deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
 	Expect(err).NotTo(HaveOccurred())
-	framework.WaitForEvents(unversionedClient, ns, deployment, 2)
+	framework.WaitForEvents(c, ns, deployment, 2)
 	events, err := c.Core().Events(ns).Search(deployment)
 	if err != nil {
 		framework.Logf("error in listing events: %s", err)
@@ -430,9 +424,6 @@ func testRollingUpdateDeploymentEvents(f *framework.Framework) {
 
 func testRecreateDeployment(f *framework.Framework) {
 	ns := f.Namespace.Name
-	// TODO: remove unversionedClient when the refactoring is done. Currently some
-	// functions like verifyPod still expects a unversioned#Client.
-	unversionedClient := f.Client
 	c := f.ClientSet
 	// Create nginx pods.
 	deploymentPodLabels := map[string]string{"name": "sample-pod-3"}
@@ -446,7 +437,7 @@ func testRecreateDeployment(f *framework.Framework) {
 	_, err := c.Extensions().ReplicaSets(ns).Create(newRS(rsName, replicas, rsPodLabels, nginxImageName, nginxImage))
 	Expect(err).NotTo(HaveOccurred())
 	// Verify that the required pods have come up.
-	err = framework.VerifyPods(unversionedClient, ns, "sample-pod-3", false, 3)
+	err = framework.VerifyPods(c, ns, "sample-pod-3", false, 3)
 	if err != nil {
 		framework.Logf("error in waiting for pods to come up: %s", err)
 		Expect(err).NotTo(HaveOccurred())
@@ -468,7 +459,7 @@ func testRecreateDeployment(f *framework.Framework) {
 	// Verify that the pods were scaled up and down as expected. We use events to verify that.
 	deployment, err := c.Extensions().Deployments(ns).Get(deploymentName)
 	Expect(err).NotTo(HaveOccurred())
-	framework.WaitForEvents(unversionedClient, ns, deployment, 2)
+	framework.WaitForEvents(c, ns, deployment, 2)
 	events, err := c.Core().Events(ns).Search(deployment)
 	if err != nil {
 		framework.Logf("error in listing events: %s", err)
@@ -486,7 +477,6 @@ func testRecreateDeployment(f *framework.Framework) {
 // testDeploymentCleanUpPolicy tests that deployment supports cleanup policy
 func testDeploymentCleanUpPolicy(f *framework.Framework) {
 	ns := f.Namespace.Name
-	unversionedClient := f.Client
 	c := f.ClientSet
 	// Create nginx pods.
 	deploymentPodLabels := map[string]string{"name": "cleanup-pod"}
@@ -501,7 +491,7 @@ func testDeploymentCleanUpPolicy(f *framework.Framework) {
 	Expect(err).NotTo(HaveOccurred())
 
 	// Verify that the required pods have come up.
-	err = framework.VerifyPods(unversionedClient, ns, "cleanup-pod", false, 1)
+	err = framework.VerifyPods(c, ns, "cleanup-pod", false, 1)
 	if err != nil {
 		framework.Logf("error in waiting for pods to come up: %s", err)
 		Expect(err).NotTo(HaveOccurred())
@@ -558,9 +548,6 @@ func testDeploymentCleanUpPolicy(f *framework.Framework) {
 // i.e. we can change desired state and kick off rolling update, then change desired state again before it finishes.
 func testRolloverDeployment(f *framework.Framework) {
 	ns := f.Namespace.Name
-	// TODO: remove unversionedClient when the refactoring is done. Currently some
-	// functions like verifyPod still expects a unversioned#Client.
-	unversionedClient := f.Client
 	c := f.ClientSet
 	podName := "rollover-pod"
 	deploymentPodLabels := map[string]string{"name": podName}
@@ -574,7 +561,7 @@ func testRolloverDeployment(f *framework.Framework) {
 	_, err := c.Extensions().ReplicaSets(ns).Create(newRS(rsName, rsReplicas, rsPodLabels, nginxImageName, nginxImage))
 	Expect(err).NotTo(HaveOccurred())
 	// Verify that the required pods have come up.
-	err = framework.VerifyPods(unversionedClient, ns, podName, false, rsReplicas)
+	err = framework.VerifyPods(c, ns, podName, false, rsReplicas)
 	if err != nil {
 		framework.Logf("error in waiting for pods to come up: %s", err)
 		Expect(err).NotTo(HaveOccurred())
@@ -962,9 +949,6 @@ func testRollbackDeploymentRSNoRevision(f *framework.Framework) {
 
 func testDeploymentLabelAdopted(f *framework.Framework) {
 	ns := f.Namespace.Name
-	// TODO: remove unversionedClient when the refactoring is done. Currently some
-	// functions like verifyPod still expects a unversioned#Client.
-	unversionedClient := f.Client
 	c := f.ClientSet
 	// Create nginx pods.
 	podName := "nginx"
@@ -976,7 +960,7 @@ func testDeploymentLabelAdopted(f *framework.Framework) {
 	_, err := c.Extensions().ReplicaSets(ns).Create(newRS(rsName, replicas, podLabels, podName, image))
 	Expect(err).NotTo(HaveOccurred())
 	// Verify that the required pods have come up.
-	err = framework.VerifyPods(unversionedClient, ns, podName, false, 3)
+	err = framework.VerifyPods(c, ns, podName, false, 3)
 	if err != nil {
 		framework.Logf("error in waiting for pods to come up: %s", err)
 		Expect(err).NotTo(HaveOccurred())
@@ -1097,7 +1081,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
 
 	// Verify that the required pods have come up.
 	By("Waiting for all required pods to come up")
-	err = framework.VerifyPods(f.Client, ns, nginxImageName, false, deployment.Spec.Replicas)
+	err = framework.VerifyPods(f.ClientSet, ns, nginxImageName, false, deployment.Spec.Replicas)
 	if err != nil {
 		framework.Logf("error in waiting for pods to come up: %s", err)
 		Expect(err).NotTo(HaveOccurred())

test/e2e/dns.go

@@ -27,7 +27,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/pod"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/uuid"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -171,23 +171,23 @@ func createTargetedProbeCommand(nameToResolve string, lookup string, fileNamePre
 	return probeCmd, fileName
 }
 
-func assertFilesExist(fileNames []string, fileDir string, pod *api.Pod, client *client.Client) {
+func assertFilesExist(fileNames []string, fileDir string, pod *api.Pod, client clientset.Interface) {
 	assertFilesContain(fileNames, fileDir, pod, client, false, "")
 }
 
-func assertFilesContain(fileNames []string, fileDir string, pod *api.Pod, client *client.Client, check bool, expected string) {
+func assertFilesContain(fileNames []string, fileDir string, pod *api.Pod, client clientset.Interface, check bool, expected string) {
 	var failed []string
 
 	framework.ExpectNoError(wait.Poll(time.Second*2, time.Second*60, func() (bool, error) {
 		failed = []string{}
-		subResourceProxyAvailable, err := framework.ServerVersionGTE(framework.SubResourcePodProxyVersion, client)
+		subResourceProxyAvailable, err := framework.ServerVersionGTE(framework.SubResourcePodProxyVersion, client.Discovery())
 		if err != nil {
 			return false, err
 		}
 		var contents []byte
 		for _, fileName := range fileNames {
 			if subResourceProxyAvailable {
-				contents, err = client.Get().
+				contents, err = client.Core().RESTClient().Get().
 					Namespace(pod.Namespace).
 					Resource("pods").
 					SubResource("proxy").
@@ -195,7 +195,7 @@ func assertFilesContain(fileNames []string, fileDir string, pod *api.Pod, client
 					Suffix(fileDir, fileName).
 					Do().Raw()
 			} else {
-				contents, err = client.Get().
+				contents, err = client.Core().RESTClient().Get().
 					Prefix("proxy").
 					Resource("pods").
 					Namespace(pod.Namespace).
@@ -223,7 +223,7 @@ func assertFilesContain(fileNames []string, fileDir string, pod *api.Pod, client
 func validateDNSResults(f *framework.Framework, pod *api.Pod, fileNames []string) {
 
 	By("submitting the pod to kubernetes")
-	podClient := f.Client.Pods(f.Namespace.Name)
+	podClient := f.ClientSet.Core().Pods(f.Namespace.Name)
 	defer func() {
 		By("deleting the pod")
 		defer GinkgoRecover()
@@ -242,7 +242,7 @@ func validateDNSResults(f *framework.Framework, pod *api.Pod, fileNames []string
 	}
 	// Try to find results for each expected name.
 	By("looking for the results for each expected name from probers")
-	assertFilesExist(fileNames, "results", pod, f.Client)
+	assertFilesExist(fileNames, "results", pod, f.ClientSet)
 
 	// TODO: probe from the host, too.
 
@@ -252,7 +252,7 @@ func validateDNSResults(f *framework.Framework, pod *api.Pod, fileNames []string
 func validateTargetedProbeOutput(f *framework.Framework, pod *api.Pod, fileNames []string, value string) {
 
 	By("submitting the pod to kubernetes")
-	podClient := f.Client.Pods(f.Namespace.Name)
+	podClient := f.ClientSet.Core().Pods(f.Namespace.Name)
 	defer func() {
 		By("deleting the pod")
 		defer GinkgoRecover()
@@ -271,13 +271,13 @@ func validateTargetedProbeOutput(f *framework.Framework, pod *api.Pod, fileNames
 	}
 	// Try to find the expected value for each expected name.
 	By("looking for the results for each expected name from probers")
-	assertFilesContain(fileNames, "results", pod, f.Client, true, value)
+	assertFilesContain(fileNames, "results", pod, f.ClientSet, true, value)
 
 	framework.Logf("DNS probes using %s succeeded\n", pod.Name)
 }
 
 func verifyDNSPodIsRunning(f *framework.Framework) {
-	systemClient := f.Client.Pods(api.NamespaceSystem)
+	systemClient := f.ClientSet.Core().Pods(api.NamespaceSystem)
 	By("Waiting for DNS Service to be Running")
 	options := api.ListOptions{LabelSelector: dnsServiceLabelSelector}
 	dnsPods, err := systemClient.List(options)
@@ -288,7 +288,7 @@ func verifyDNSPodIsRunning(f *framework.Framework) {
 		framework.Failf("No pods match the label selector %v", dnsServiceLabelSelector.String())
 	}
 	pod := dnsPods.Items[0]
-	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.Client, &pod))
+	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.ClientSet, &pod))
 }
 
 func createServiceSpec(serviceName, externalName string, isHeadless bool, selector map[string]string) *api.Service {
@@ -358,21 +358,21 @@ var _ = framework.KubeDescribe("DNS", func() {
 			"dns-test": "true",
 		}
 		headlessService := createServiceSpec(dnsTestServiceName, "", true, testServiceSelector)
-		_, err := f.Client.Services(f.Namespace.Name).Create(headlessService)
+		_, err := f.ClientSet.Core().Services(f.Namespace.Name).Create(headlessService)
 		Expect(err).NotTo(HaveOccurred())
 		defer func() {
 			By("deleting the test headless service")
 			defer GinkgoRecover()
-			f.Client.Services(f.Namespace.Name).Delete(headlessService.Name)
+			f.ClientSet.Core().Services(f.Namespace.Name).Delete(headlessService.Name, nil)
 		}()
 
 		regularService := createServiceSpec("test-service-2", "", false, testServiceSelector)
-		regularService, err = f.Client.Services(f.Namespace.Name).Create(regularService)
+		regularService, err = f.ClientSet.Core().Services(f.Namespace.Name).Create(regularService)
 		Expect(err).NotTo(HaveOccurred())
 		defer func() {
 			By("deleting the test service")
 			defer GinkgoRecover()
-			f.Client.Services(f.Namespace.Name).Delete(regularService.Name)
+			f.ClientSet.Core().Services(f.Namespace.Name).Delete(regularService.Name, nil)
 		}()
 
 		// All the names we need to be able to resolve.
@@ -408,12 +408,12 @@ var _ = framework.KubeDescribe("DNS", func() {
 		serviceName := "dns-test-service-2"
 		podHostname := "dns-querier-2"
 		headlessService := createServiceSpec(serviceName, "", true, testServiceSelector)
-		_, err := f.Client.Services(f.Namespace.Name).Create(headlessService)
+		_, err := f.ClientSet.Core().Services(f.Namespace.Name).Create(headlessService)
 		Expect(err).NotTo(HaveOccurred())
 		defer func() {
 			By("deleting the test headless service")
 			defer GinkgoRecover()
-			f.Client.Services(f.Namespace.Name).Delete(headlessService.Name)
+			f.ClientSet.Core().Services(f.Namespace.Name).Delete(headlessService.Name, nil)
 		}()
 
 		hostFQDN := fmt.Sprintf("%s.%s.%s.svc.cluster.local", podHostname, serviceName, f.Namespace.Name)
@@ -441,12 +441,12 @@ var _ = framework.KubeDescribe("DNS", func() {
 		By("Creating a test externalName service")
 		serviceName := "dns-test-service-3"
 		externalNameService := createServiceSpec(serviceName, "foo.example.com", false, nil)
-		_, err := f.Client.Services(f.Namespace.Name).Create(externalNameService)
+		_, err := f.ClientSet.Core().Services(f.Namespace.Name).Create(externalNameService)
 		Expect(err).NotTo(HaveOccurred())
 		defer func() {
 			By("deleting the test externalName service")
 			defer GinkgoRecover()
-			f.Client.Services(f.Namespace.Name).Delete(externalNameService.Name)
+			f.ClientSet.Core().Services(f.Namespace.Name).Delete(externalNameService.Name, nil)
 		}()
 
 		hostFQDN := fmt.Sprintf("%s.%s.svc.cluster.local", serviceName, f.Namespace.Name)
@@ -463,7 +463,7 @@ var _ = framework.KubeDescribe("DNS", func() {
 
 		// Test changing the externalName field
 		By("changing the externalName to bar.example.com")
-		_, err = updateService(f.Client, f.Namespace.Name, serviceName, func(s *api.Service) {
+		_, err = updateService(f.ClientSet, f.Namespace.Name, serviceName, func(s *api.Service) {
 			s.Spec.ExternalName = "bar.example.com"
 		})
 		Expect(err).NotTo(HaveOccurred())
@@ -480,7 +480,7 @@ var _ = framework.KubeDescribe("DNS", func() {
 
 		// Test changing type from ExternalName to ClusterIP
 		By("changing the service to type=ClusterIP")
-		_, err = updateService(f.Client, f.Namespace.Name, serviceName, func(s *api.Service) {
+		_, err = updateService(f.ClientSet, f.Namespace.Name, serviceName, func(s *api.Service) {
 			s.Spec.Type = api.ServiceTypeClusterIP
 			s.Spec.ClusterIP = "127.1.2.3"
 			s.Spec.Ports = []api.ServicePort{

test/e2e/e2e.go

@@ -94,7 +94,7 @@ var _ = ginkgo.SynchronizedBeforeSuite(func() []byte {
 		framework.Failf("Failed to setup provider config: %v", err)
 	}
 
-	c, err := framework.LoadClient()
+	c, err := framework.LoadInternalClientset()
 	if err != nil {
 		glog.Fatal("Error loading client: ", err)
 	}

test/e2e/empty.go

@@ -28,7 +28,7 @@ var _ = framework.KubeDescribe("[Feature:Empty]", func() {
 	f := framework.NewDefaultFramework("empty")
 
 	BeforeEach(func() {
-		c := f.Client
+		c := f.ClientSet
 		ns := f.Namespace.Name
 
 		// TODO: respect --allow-notready-nodes flag in those functions.

test/e2e/empty_dir_wrapper.go

@@ -68,7 +68,7 @@ var _ = framework.KubeDescribe("EmptyDir wrapper volumes", func() {
 		}
 
 		var err error
-		if secret, err = f.Client.Secrets(f.Namespace.Name).Create(secret); err != nil {
+		if secret, err = f.ClientSet.Core().Secrets(f.Namespace.Name).Create(secret); err != nil {
 			framework.Failf("unable to create test secret %s: %v", secret.Name, err)
 		}
 
@@ -124,11 +124,11 @@ var _ = framework.KubeDescribe("EmptyDir wrapper volumes", func() {
 
 		defer func() {
 			By("Cleaning up the secret")
-			if err := f.Client.Secrets(f.Namespace.Name).Delete(secret.Name); err != nil {
+			if err := f.ClientSet.Core().Secrets(f.Namespace.Name).Delete(secret.Name, nil); err != nil {
 				framework.Failf("unable to delete secret %v: %v", secret.Name, err)
 			}
 			By("Cleaning up the git vol pod")
-			if err = f.Client.Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil {
+			if err = f.ClientSet.Core().Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0)); err != nil {
 				framework.Failf("unable to delete git vol pod %v: %v", pod.Name, err)
 			}
 		}()
@@ -216,17 +216,17 @@ func createGitServer(f *framework.Framework) (gitURL string, gitRepo string, cle
 		},
 	}
 
-	if gitServerSvc, err = f.Client.Services(f.Namespace.Name).Create(gitServerSvc); err != nil {
+	if gitServerSvc, err = f.ClientSet.Core().Services(f.Namespace.Name).Create(gitServerSvc); err != nil {
 		framework.Failf("unable to create test git server service %s: %v", gitServerSvc.Name, err)
 	}
 
 	return "http://" + gitServerSvc.Spec.ClusterIP + ":" + strconv.Itoa(httpPort), "test", func() {
 		By("Cleaning up the git server pod")
-		if err := f.Client.Pods(f.Namespace.Name).Delete(gitServerPod.Name, api.NewDeleteOptions(0)); err != nil {
+		if err := f.ClientSet.Core().Pods(f.Namespace.Name).Delete(gitServerPod.Name, api.NewDeleteOptions(0)); err != nil {
 			framework.Failf("unable to delete git server pod %v: %v", gitServerPod.Name, err)
 		}
 		By("Cleaning up the git server svc")
-		if err := f.Client.Services(f.Namespace.Name).Delete(gitServerSvc.Name); err != nil {
+		if err := f.ClientSet.Core().Services(f.Namespace.Name).Delete(gitServerSvc.Name, nil); err != nil {
 			framework.Failf("unable to delete git server svc %v: %v", gitServerSvc.Name, err)
 		}
 	}
@@ -266,7 +266,7 @@ func createConfigmapsForRace(f *framework.Framework) (configMapNames []string) {
 				"data-1": "value-1",
 			},
 		}
-		_, err := f.Client.ConfigMaps(f.Namespace.Name).Create(configMap)
+		_, err := f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Create(configMap)
 		framework.ExpectNoError(err)
 	}
 	return
@@ -275,7 +275,7 @@ func createConfigmapsForRace(f *framework.Framework) (configMapNames []string) {
 func deleteConfigMaps(f *framework.Framework, configMapNames []string) {
 	By("Cleaning up the configMaps")
 	for _, configMapName := range configMapNames {
-		err := f.Client.ConfigMaps(f.Namespace.Name).Delete(configMapName)
+		err := f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Delete(configMapName, nil)
 		Expect(err).NotTo(HaveOccurred(), "unable to delete configMap %v", configMapName)
 	}
 }
@@ -361,15 +361,15 @@ func testNoWrappedVolumeRace(f *framework.Framework, volumes []api.Volume, volum
 			},
 		},
 	}
-	_, err := f.Client.ReplicationControllers(f.Namespace.Name).Create(rc)
+	_, err := f.ClientSet.Core().ReplicationControllers(f.Namespace.Name).Create(rc)
 	Expect(err).NotTo(HaveOccurred(), "error creating replication controller")
 
 	defer func() {
-		err := framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, rcName)
+		err := framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, rcName)
 		framework.ExpectNoError(err)
 	}()
 
-	pods, err := framework.PodsCreated(f.Client, f.Namespace.Name, rcName, podCount)
+	pods, err := framework.PodsCreated(f.ClientSet, f.Namespace.Name, rcName, podCount)
 
 	By("Ensuring each pod is running")
 

test/e2e/etcd_failure.go

@@ -42,10 +42,10 @@ var _ = framework.KubeDescribe("Etcd failure [Disruptive]", func() {
 		framework.SkipUnlessProviderIs("gce")
 
 		Expect(framework.RunRC(testutils.RCConfig{
-			Client:    f.Client,
+			Client:    f.ClientSet,
 			Name:      "baz",
 			Namespace: f.Namespace.Name,
-			Image:     framework.GetPauseImageName(f.Client),
+			Image:     framework.GetPauseImageName(f.ClientSet),
 			Replicas:  1,
 		})).NotTo(HaveOccurred())
 	})
@@ -101,7 +101,7 @@ func masterExec(cmd string) {
 
 func checkExistingRCRecovers(f *framework.Framework) {
 	By("assert that the pre-existing replication controller recovers")
-	podClient := f.Client.Pods(f.Namespace.Name)
+	podClient := f.ClientSet.Core().Pods(f.Namespace.Name)
 	rcSelector := labels.Set{"name": "baz"}.AsSelector()
 
 	By("deleting pods from existing replication controller")

test/e2e/events.go

@@ -37,7 +37,7 @@ var _ = framework.KubeDescribe("Events", func() {
 
 	It("should be sent by kubelets and the scheduler about pods scheduling and running [Conformance]", func() {
 
-		podClient := f.Client.Pods(f.Namespace.Name)
+		podClient := f.ClientSet.Core().Pods(f.Namespace.Name)
 
 		By("creating the pod")
 		name := "send-events-" + string(uuid.NewUUID())
@@ -95,7 +95,7 @@ var _ = framework.KubeDescribe("Events", func() {
 				"source":                   api.DefaultSchedulerName,
 			}.AsSelector()
 			options := api.ListOptions{FieldSelector: selector}
-			events, err := f.Client.Events(f.Namespace.Name).List(options)
+			events, err := f.ClientSet.Core().Events(f.Namespace.Name).List(options)
 			if err != nil {
 				return false, err
 			}
@@ -115,7 +115,7 @@ var _ = framework.KubeDescribe("Events", func() {
 				"source":                   "kubelet",
 			}.AsSelector()
 			options := api.ListOptions{FieldSelector: selector}
-			events, err = f.Client.Events(f.Namespace.Name).List(options)
+			events, err = f.ClientSet.Core().Events(f.Namespace.Name).List(options)
 			if err != nil {
 				return false, err
 			}

test/e2e/example_cluster_dns.go

@@ -22,7 +22,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/test/e2e/framework"
 
@@ -45,9 +45,9 @@ except:
 var _ = framework.KubeDescribe("ClusterDns [Feature:Example]", func() {
 	f := framework.NewDefaultFramework("cluster-dns")
 
-	var c *client.Client
+	var c clientset.Interface
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
 	})
 
 	It("should create pod that uses dns", func() {
@@ -98,7 +98,7 @@ var _ = framework.KubeDescribe("ClusterDns [Feature:Example]", func() {
 		for _, ns := range namespaces {
 			label := labels.SelectorFromSet(labels.Set(map[string]string{"name": backendRcName}))
 			options := api.ListOptions{LabelSelector: label}
-			pods, err := c.Pods(ns.Name).List(options)
+			pods, err := c.Core().Pods(ns.Name).List(options)
 			Expect(err).NotTo(HaveOccurred())
 			err = framework.PodsResponding(c, ns.Name, backendPodName, false, pods)
 			Expect(err).NotTo(HaveOccurred(), "waiting for all pods to respond")
@@ -118,7 +118,7 @@ var _ = framework.KubeDescribe("ClusterDns [Feature:Example]", func() {
 		// This code is probably unnecessary, but let's stay on the safe side.
 		label := labels.SelectorFromSet(labels.Set(map[string]string{"name": backendPodName}))
 		options := api.ListOptions{LabelSelector: label}
-		pods, err := c.Pods(namespaces[0].Name).List(options)
+		pods, err := c.Core().Pods(namespaces[0].Name).List(options)
 
 		if err != nil || pods == nil || len(pods.Items) == 0 {
 			framework.Failf("no running pods found")

test/e2e/example_k8petstore.go

@@ -25,7 +25,7 @@ import (
 	"syscall"
 	"time"
 
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/test/e2e/framework"
 
 	. "github.com/onsi/ginkgo"
@@ -47,8 +47,8 @@ const (
 
 // readTransactions reads # of transactions from the k8petstore web server endpoint.
 // for more details see the source of the k8petstore web server.
-func readTransactions(c *client.Client, ns string) (error, int) {
+func readTransactions(c clientset.Interface, ns string) (error, int) {
-	proxyRequest, errProxy := framework.GetServicesProxyRequest(c, c.Get())
+	proxyRequest, errProxy := framework.GetServicesProxyRequest(c, c.Core().RESTClient().Get())
 	if errProxy != nil {
 		return errProxy, -1
 	}
@@ -66,7 +66,7 @@ func readTransactions(c *client.Client, ns string) (error, int) {
 
 // runK8petstore runs the k8petstore application, bound to external nodeport, and
 // polls until finalTransactionsExpected transactions are acquired, in a maximum of maxSeconds.
-func runK8petstore(restServers int, loadGenerators int, c *client.Client, ns string, finalTransactionsExpected int, maxTime time.Duration) {
+func runK8petstore(restServers int, loadGenerators int, c clientset.Interface, ns string, finalTransactionsExpected int, maxTime time.Duration) {
 
 	var err error = nil
 	k8bpsScriptLocation := filepath.Join(framework.TestContext.RepoRoot, "examples/k8petstore/k8petstore-nodeport.sh")
@@ -171,7 +171,7 @@ var _ = framework.KubeDescribe("Pet Store [Feature:Example]", func() {
 		loadGenerators := nodeCount
 		restServers := nodeCount
 		fmt.Printf("load generators / rest servers [ %v  /  %v ] ", loadGenerators, restServers)
-		runK8petstore(restServers, loadGenerators, f.Client, f.Namespace.Name, k8bpsSmokeTestFinalTransactions, k8bpsSmokeTestTimeout)
+		runK8petstore(restServers, loadGenerators, f.ClientSet, f.Namespace.Name, k8bpsSmokeTestFinalTransactions, k8bpsSmokeTestTimeout)
 	})
 
 })

test/e2e/examples.go

@@ -27,7 +27,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -56,10 +56,10 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() {
 	forEachPod := func(selectorKey string, selectorValue string, fn func(api.Pod)) {
 		clusterState(selectorKey, selectorValue).ForEach(fn)
 	}
-	var c *client.Client
+	var c clientset.Interface
 	var ns string
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 	})
 
@@ -281,7 +281,7 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() {
 			label := labels.SelectorFromSet(labels.Set(map[string]string{"app": "cassandra"}))
 			err = wait.PollImmediate(petsetPoll, petsetTimeout,
 				func() (bool, error) {
-					podList, err := c.Pods(ns).List(api.ListOptions{LabelSelector: label})
+					podList, err := c.Core().Pods(ns).List(api.ListOptions{LabelSelector: label})
 					if err != nil {
 						return false, fmt.Errorf("Unable to get list of pods in petset %s", label)
 					}
@@ -396,7 +396,7 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() {
 				err := framework.WaitForPodNameRunningInNamespace(c, podName, ns)
 				Expect(err).NotTo(HaveOccurred())
 				for t := time.Now(); time.Since(t) < timeout; time.Sleep(framework.Poll) {
-					pod, err := c.Pods(ns).Get(podName)
+					pod, err := c.Core().Pods(ns).Get(podName)
 					framework.ExpectNoError(err, fmt.Sprintf("getting pod %s", podName))
 					stat := api.GetExistingContainerStatus(pod.Status.ContainerStatuses, podName)
 					framework.Logf("Pod: %s, restart count:%d", stat.Name, stat.RestartCount)
@@ -504,7 +504,7 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			By("scaling rethinkdb")
-			framework.ScaleRC(c, f.ClientSet, ns, "rethinkdb-rc", 2, true)
+			framework.ScaleRC(f.ClientSet, ns, "rethinkdb-rc", 2, true)
 			checkDbInstances()
 
 			By("starting admin")
@@ -547,7 +547,7 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			By("scaling hazelcast")
-			framework.ScaleRC(c, f.ClientSet, ns, "hazelcast", 2, true)
+			framework.ScaleRC(f.ClientSet, ns, "hazelcast", 2, true)
 			forEachPod("name", "hazelcast", func(pod api.Pod) {
 				_, err := framework.LookForStringInLog(ns, pod.Name, "hazelcast", "Members [2]", serverStartTimeout)
 				Expect(err).NotTo(HaveOccurred())
@@ -556,11 +556,11 @@ var _ = framework.KubeDescribe("[Feature:Example]", func() {
 	})
 })
 
-func makeHttpRequestToService(c *client.Client, ns, service, path string, timeout time.Duration) (string, error) {
+func makeHttpRequestToService(c clientset.Interface, ns, service, path string, timeout time.Duration) (string, error) {
 	var result []byte
 	var err error
 	for t := time.Now(); time.Since(t) < timeout; time.Sleep(framework.Poll) {
-		proxyRequest, errProxy := framework.GetServicesProxyRequest(c, c.Get())
+		proxyRequest, errProxy := framework.GetServicesProxyRequest(c, c.Core().RESTClient().Get())
 		if errProxy != nil {
 			break
 		}

test/e2e/federated-ingress.go

@@ -63,7 +63,7 @@ var _ = framework.KubeDescribe("Federated ingresses [Feature:Federation]", func(
 		})
 
 		It("should be created and deleted successfully", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 			framework.SkipUnlessProviderIs("gce", "gke") // TODO: Federated ingress is not yet supported on non-GCP platforms.
 			nsName := f.FederationNamespace.Name
 			ingress := createIngressOrFail(f.FederationClientset_1_5, nsName)
@@ -85,7 +85,7 @@ var _ = framework.KubeDescribe("Federated ingresses [Feature:Federation]", func(
 
 		// register clusters in federation apiserver
 		BeforeEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 			framework.SkipUnlessProviderIs("gce", "gke") // TODO: Federated ingress is not yet supported on non-GCP platforms.
 			if federationName = os.Getenv("FEDERATION_NAME"); federationName == "" {
 				federationName = DefaultFederationName
@@ -124,7 +124,7 @@ var _ = framework.KubeDescribe("Federated ingresses [Feature:Federation]", func(
 			)
 
 			BeforeEach(func() {
-				framework.SkipUnlessFederated(f.Client)
+				framework.SkipUnlessFederated(f.ClientSet)
 				// create backend pod
 				createBackendPodsOrFail(clusters, ns, FederatedIngressServicePodName)
 				// create backend service

test/e2e/federated-namespace.go

@@ -44,7 +44,7 @@ var _ = framework.KubeDescribe("Federation namespace [Feature:Federation]", func
 		var clusters map[string]*cluster // All clusters, keyed by cluster name
 
 		BeforeEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			// TODO: Federation API server should be able to answer this.
 			if federationName = os.Getenv("FEDERATION_NAME"); federationName == "" {
@@ -56,7 +56,7 @@ var _ = framework.KubeDescribe("Federation namespace [Feature:Federation]", func
 		})
 
 		AfterEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 			deleteAllTestNamespaces(
 				f.FederationClientset_1_5.Core().Namespaces().List,
 				f.FederationClientset_1_5.Core().Namespaces().Delete)
@@ -69,7 +69,7 @@ var _ = framework.KubeDescribe("Federation namespace [Feature:Federation]", func
 		})
 
 		It("should be created and deleted successfully", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			ns := api_v1.Namespace{
 				ObjectMeta: api_v1.ObjectMeta{

test/e2e/federated-secret.go

@@ -46,18 +46,18 @@ var _ = framework.KubeDescribe("Federation secrets [Feature:Federation12]", func
 	Describe("Secret objects", func() {
 
 		BeforeEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 			clusters = map[string]*cluster{}
 			registerClusters(clusters, UserAgentName, "", f)
 		})
 
 		AfterEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 			unregisterClusters(clusters, f)
 		})
 
 		It("should be created and deleted successfully", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 			nsName := f.FederationNamespace.Name
 			secret := createSecretOrFail(f.FederationClientset_1_5, nsName)
 			defer func() { // Cleanup

test/e2e/federated-service.go

@@ -48,7 +48,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 
 	var _ = Describe("Federated Services", func() {
 		BeforeEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			// TODO: Federation API server should be able to answer this.
 			if federationName = os.Getenv("FEDERATION_NAME"); federationName == "" {
@@ -70,12 +70,12 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 			)
 
 			BeforeEach(func() {
-				framework.SkipUnlessFederated(f.Client)
+				framework.SkipUnlessFederated(f.ClientSet)
 				// Placeholder
 			})
 
 			AfterEach(func() {
-				framework.SkipUnlessFederated(f.Client)
+				framework.SkipUnlessFederated(f.ClientSet)
 
 				if service != nil {
 					By(fmt.Sprintf("Deleting service shards and their provider resources in underlying clusters for service %q in namespace %q", service.Name, nsName))
@@ -86,7 +86,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 			})
 
 			It("should succeed", func() {
-				framework.SkipUnlessFederated(f.Client)
+				framework.SkipUnlessFederated(f.ClientSet)
 
 				nsName = f.FederationNamespace.Name
 				service = createServiceOrFail(f.FederationClientset_1_5, nsName, FederatedServiceName)
@@ -99,7 +99,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 			})
 
 			It("should create matching services in underlying clusters", func() {
-				framework.SkipUnlessFederated(f.Client)
+				framework.SkipUnlessFederated(f.ClientSet)
 
 				nsName = f.FederationNamespace.Name
 				service = createServiceOrFail(f.FederationClientset_1_5, nsName, FederatedServiceName)
@@ -119,7 +119,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 			)
 
 			BeforeEach(func() {
-				framework.SkipUnlessFederated(f.Client)
+				framework.SkipUnlessFederated(f.ClientSet)
 
 				nsName := f.FederationNamespace.Name
 				createBackendPodsOrFail(clusters, nsName, FederatedServicePodName)
@@ -128,7 +128,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 			})
 
 			AfterEach(func() {
-				framework.SkipUnlessFederated(f.Client)
+				framework.SkipUnlessFederated(f.ClientSet)
 
 				nsName := f.FederationNamespace.Name
 				deleteBackendPodsOrFail(clusters, nsName)
@@ -146,7 +146,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 			})
 
 			It("should be able to discover a federated service", func() {
-				framework.SkipUnlessFederated(f.Client)
+				framework.SkipUnlessFederated(f.ClientSet)
 
 				nsName := f.FederationNamespace.Name
 				svcDNSNames := []string{
@@ -166,7 +166,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 
 			Context("non-local federated service", func() {
 				BeforeEach(func() {
-					framework.SkipUnlessFederated(f.Client)
+					framework.SkipUnlessFederated(f.ClientSet)
 
 					// Delete all the backend pods from the shard which is local to the discovery pod.
 					deleteOneBackendPodOrFail(clusters[primaryClusterName])
@@ -174,7 +174,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 				})
 
 				It("should be able to discover a non-local federated service", func() {
-					framework.SkipUnlessFederated(f.Client)
+					framework.SkipUnlessFederated(f.ClientSet)
 
 					nsName := f.FederationNamespace.Name
 					svcDNSNames := []string{
@@ -190,7 +190,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 				// TTL and/or running the pods in parallel.
 				Context("[Slow] missing local service", func() {
 					It("should never find DNS entries for a missing local service", func() {
-						framework.SkipUnlessFederated(f.Client)
+						framework.SkipUnlessFederated(f.ClientSet)
 
 						nsName := f.FederationNamespace.Name
 						localSvcDNSNames := []string{

test/e2e/federation-apiserver.go

@@ -36,7 +36,7 @@ var _ = framework.KubeDescribe("Federation apiserver [Feature:Federation]", func
 
 	Describe("Cluster objects", func() {
 		AfterEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			// Delete registered clusters.
 			// This is if a test failed, it should not affect other tests.
@@ -49,7 +49,7 @@ var _ = framework.KubeDescribe("Federation apiserver [Feature:Federation]", func
 		})
 
 		It("should be created and deleted successfully", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			contexts := f.GetUnderlyingFederatedContexts()
 
@@ -85,11 +85,11 @@ var _ = framework.KubeDescribe("Federation apiserver [Feature:Federation]", func
 	})
 	Describe("Admission control", func() {
 		AfterEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 		})
 
 		It("should not be able to create resources if namespace does not exist", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			// Creating a service in a non-existing namespace should fail.
 			svcNamespace := "federation-admission-test-ns"

test/e2e/federation-authn.go

@@ -34,11 +34,11 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 
 	var _ = Describe("Federation API server authentication", func() {
 		BeforeEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 		})
 
 		It("should accept cluster resources when the client has right authentication credentials", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			nsName := f.FederationNamespace.Name
 			svc := createServiceOrFail(f.FederationClientset_1_5, nsName, FederatedServiceName)
@@ -46,7 +46,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 		})
 
 		It("should not accept cluster resources when the client has invalid authentication credentials", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			contexts := f.GetUnderlyingFederatedContexts()
 
@@ -67,7 +67,7 @@ var _ = framework.KubeDescribe("[Feature:Federation]", func() {
 		})
 
 		It("should not accept cluster resources when the client has no authentication credentials", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			fcs, err := invalidAuthFederationClientSet(nil)
 			ExpectNoError(err)

test/e2e/federation-event.go

@@ -37,7 +37,7 @@ var _ = framework.KubeDescribe("Federation events [Feature:Federation]", func()
 
 	Describe("Event objects", func() {
 		AfterEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			nsName := f.FederationNamespace.Name
 			// Delete registered events.
@@ -50,7 +50,7 @@ var _ = framework.KubeDescribe("Federation events [Feature:Federation]", func()
 		})
 
 		It("should be created and deleted successfully", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			nsName := f.FederationNamespace.Name
 			event := createEventOrFail(f.FederationClientset_1_5, nsName)

test/e2e/federation-replicaset.go

@@ -46,7 +46,7 @@ var _ = framework.KubeDescribe("Federation replicasets [Feature:Federation]", fu
 
 	Describe("ReplicaSet objects", func() {
 		AfterEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			// Delete registered replicasets.
 			nsName := f.FederationNamespace.Name
@@ -59,7 +59,7 @@ var _ = framework.KubeDescribe("Federation replicasets [Feature:Federation]", fu
 		})
 
 		It("should be created and deleted successfully", func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 
 			nsName := f.FederationNamespace.Name
 			replicaset := createReplicaSetOrFail(f.FederationClientset_1_5, nsName)
@@ -79,7 +79,7 @@ var _ = framework.KubeDescribe("Federation replicasets [Feature:Federation]", fu
 			federationName string
 		)
 		BeforeEach(func() {
-			framework.SkipUnlessFederated(f.Client)
+			framework.SkipUnlessFederated(f.ClientSet)
 			if federationName = os.Getenv("FEDERATION_NAME"); federationName == "" {
 				federationName = DefaultFederationName
 			}

test/e2e/federation-util.go

@@ -383,7 +383,7 @@ func podExitCodeDetector(f *framework.Framework, name, namespace string, code in
 	}
 
 	return func() error {
-		pod, err := f.Client.Pods(namespace).Get(name)
+		pod, err := f.ClientSet.Core().Pods(namespace).Get(name)
 		if err != nil {
 			return logerr(err)
 		}
@@ -392,7 +392,7 @@ func podExitCodeDetector(f *framework.Framework, name, namespace string, code in
 		}
 
 		// Best effort attempt to grab pod logs for debugging
-		logs, err = framework.GetPodLogs(f.Client, namespace, name, pod.Spec.Containers[0].Name)
+		logs, err = framework.GetPodLogs(f.ClientSet, namespace, name, pod.Spec.Containers[0].Name)
 		if err != nil {
 			framework.Logf("Cannot fetch pod logs: %v", err)
 		}
@@ -431,12 +431,12 @@ func discoverService(f *framework.Framework, name string, exists bool, podName s
 
 	nsName := f.FederationNamespace.Name
 	By(fmt.Sprintf("Creating pod %q in namespace %q", pod.Name, nsName))
-	_, err := f.Client.Pods(nsName).Create(pod)
+	_, err := f.ClientSet.Core().Pods(nsName).Create(pod)
 	framework.ExpectNoError(err, "Trying to create pod to run %q", command)
 	By(fmt.Sprintf("Successfully created pod %q in namespace %q", pod.Name, nsName))
 	defer func() {
 		By(fmt.Sprintf("Deleting pod %q from namespace %q", podName, nsName))
-		err := f.Client.Pods(nsName).Delete(podName, api.NewDeleteOptions(0))
+		err := f.ClientSet.Core().Pods(nsName).Delete(podName, api.NewDeleteOptions(0))
 		framework.ExpectNoError(err, "Deleting pod %q from namespace %q", podName, nsName)
 		By(fmt.Sprintf("Deleted pod %q from namespace %q", podName, nsName))
 	}()

test/e2e/framework/exec_util.go

@@ -47,7 +47,7 @@ func (f *Framework) ExecCommandInContainerWithFullOutput(podName, containerName
 	var stdout, stderr bytes.Buffer
 	var stdin io.Reader
 	tty := false
-	req := f.Client.RESTClient.Post().
+	req := f.ClientSet.Core().RESTClient().Post().
 		Resource("pods").
 		Name(podName).
 		Namespace(f.Namespace.Name).

test/e2e/framework/framework.go

@@ -39,7 +39,6 @@ import (
 	"k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
 	"k8s.io/kubernetes/pkg/client/restclient"
 	"k8s.io/kubernetes/pkg/client/typed/dynamic"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/metrics"
@@ -61,9 +60,6 @@ const (
 type Framework struct {
 	BaseName string
 
-	// Client is manually created and should not be used unless absolutely necessary. Use ClientSet_1_5
-	// where possible.
-	Client *client.Client
 	// ClientSet uses internal objects, you should use ClientSet_1_5 where possible.
 	ClientSet internalclientset.Interface
 
@@ -134,12 +130,12 @@ func NewDefaultGroupVersionFramework(baseName string, groupVersion unversioned.G
 	return f
 }
 
-func NewFramework(baseName string, options FrameworkOptions, client *client.Client) *Framework {
+func NewFramework(baseName string, options FrameworkOptions, client internalclientset.Interface) *Framework {
 	f := &Framework{
 		BaseName:                 baseName,
 		AddonResourceConstraints: make(map[string]ResourceConstraint),
 		options:                  options,
-		Client:                   client,
+		ClientSet:                client,
 	}
 
 	BeforeEach(f.BeforeEach)
@@ -185,7 +181,7 @@ func (f *Framework) BeforeEach() {
 	// The fact that we need this feels like a bug in ginkgo.
 	// https://github.com/onsi/ginkgo/issues/222
 	f.cleanupHandle = AddCleanupAction(f.AfterEach)
-	if f.Client == nil {
+	if f.ClientSet == nil {
 		By("Creating a kubernetes client")
 		config, err := LoadConfig()
 		Expect(err).NotTo(HaveOccurred())
@@ -197,9 +193,6 @@ func (f *Framework) BeforeEach() {
 		if TestContext.KubeAPIContentType != "" {
 			config.ContentType = TestContext.KubeAPIContentType
 		}
-		c, err := loadClientFromConfig(config)
-		Expect(err).NotTo(HaveOccurred())
-		f.Client = c
 		f.ClientSet, err = internalclientset.NewForConfig(config)
 		Expect(err).NotTo(HaveOccurred())
 		f.ClientSet_1_5, err = release_1_5.NewForConfig(config)
@@ -239,14 +232,14 @@ func (f *Framework) BeforeEach() {
 
 	if TestContext.VerifyServiceAccount {
 		By("Waiting for a default service account to be provisioned in namespace")
-		err = WaitForDefaultServiceAccountInNamespace(f.Client, namespace.Name)
+		err = WaitForDefaultServiceAccountInNamespace(f.ClientSet, namespace.Name)
 		Expect(err).NotTo(HaveOccurred())
 	} else {
 		Logf("Skipping waiting for service account")
 	}
 
 	if TestContext.GatherKubeSystemResourceUsageData != "false" && TestContext.GatherKubeSystemResourceUsageData != "none" {
-		f.gatherer, err = NewResourceUsageGatherer(f.Client, ResourceGathererOptions{
+		f.gatherer, err = NewResourceUsageGatherer(f.ClientSet, ResourceGathererOptions{
 			inKubemark: ProviderIs("kubemark"),
 			masterOnly: TestContext.GatherKubeSystemResourceUsageData == "master",
 		})
@@ -261,7 +254,7 @@ func (f *Framework) BeforeEach() {
 		f.logsSizeWaitGroup = sync.WaitGroup{}
 		f.logsSizeWaitGroup.Add(1)
 		f.logsSizeCloseChannel = make(chan bool)
-		f.logsSizeVerifier = NewLogsVerifier(f.Client, f.ClientSet, f.logsSizeCloseChannel)
+		f.logsSizeVerifier = NewLogsVerifier(f.ClientSet, f.logsSizeCloseChannel)
 		go func() {
 			f.logsSizeVerifier.Run()
 			f.logsSizeWaitGroup.Done()
@@ -326,7 +319,7 @@ func (f *Framework) AfterEach() {
 				if f.NamespaceDeletionTimeout != 0 {
 					timeout = f.NamespaceDeletionTimeout
 				}
-				if err := deleteNS(f.Client, f.ClientPool, ns.Name, timeout); err != nil {
+				if err := deleteNS(f.ClientSet, f.ClientPool, ns.Name, timeout); err != nil {
 					if !apierrs.IsNotFound(err) {
 						nsDeletionErrors[ns.Name] = err
 					} else {
@@ -348,7 +341,7 @@ func (f *Framework) AfterEach() {
 		// Paranoia-- prevent reuse!
 		f.Namespace = nil
 		f.FederationNamespace = nil
-		f.Client = nil
+		f.ClientSet = nil
 		f.namespacesToDelete = nil
 
 		// if we had errors deleting, report them now.
@@ -376,18 +369,18 @@ func (f *Framework) AfterEach() {
 	// Print events if the test failed.
 	if CurrentGinkgoTestDescription().Failed && TestContext.DumpLogsOnFailure {
 		// Pass both unversioned client and and versioned clientset, till we have removed all uses of the unversioned client.
-		DumpAllNamespaceInfo(f.Client, f.ClientSet_1_5, f.Namespace.Name)
+		DumpAllNamespaceInfo(f.ClientSet, f.ClientSet_1_5, f.Namespace.Name)
 		By(fmt.Sprintf("Dumping a list of prepulled images on each node"))
-		LogContainersInPodsWithLabels(f.Client, api.NamespaceSystem, ImagePullerLabels, "image-puller", Logf)
+		LogContainersInPodsWithLabels(f.ClientSet, api.NamespaceSystem, ImagePullerLabels, "image-puller", Logf)
 		if f.federated {
 			// Dump federation events in federation namespace.
 			DumpEventsInNamespace(func(opts v1.ListOptions, ns string) (*v1.EventList, error) {
 				return f.FederationClientset_1_5.Core().Events(ns).List(opts)
 			}, f.FederationNamespace.Name)
 			// Print logs of federation control plane pods (federation-apiserver and federation-controller-manager)
-			LogPodsWithLabels(f.Client, "federation", map[string]string{"app": "federated-cluster"}, Logf)
+			LogPodsWithLabels(f.ClientSet, "federation", map[string]string{"app": "federated-cluster"}, Logf)
 			// Print logs of kube-dns pod
-			LogPodsWithLabels(f.Client, "kube-system", map[string]string{"k8s-app": "kube-dns"}, Logf)
+			LogPodsWithLabels(f.ClientSet, "kube-system", map[string]string{"k8s-app": "kube-dns"}, Logf)
 		}
 	}
 
@@ -407,7 +400,7 @@ func (f *Framework) AfterEach() {
 	if TestContext.GatherMetricsAfterTest {
 		By("Gathering metrics")
 		// TODO: enable Scheduler and ControllerManager metrics grabbing when Master's Kubelet will be registered.
-		grabber, err := metrics.NewMetricsGrabber(f.Client, true, false, false, true)
+		grabber, err := metrics.NewMetricsGrabber(f.ClientSet, true, false, false, true)
 		if err != nil {
 			Logf("Failed to create MetricsGrabber. Skipping metrics gathering.")
 		} else {
@@ -441,7 +434,7 @@ func (f *Framework) AfterEach() {
 	// Check whether all nodes are ready after the test.
 	// This is explicitly done at the very end of the test, to avoid
 	// e.g. not removing namespace in case of this failure.
-	if err := AllNodesReady(f.Client, 3*time.Minute); err != nil {
+	if err := AllNodesReady(f.ClientSet, 3*time.Minute); err != nil {
 		Failf("All nodes should be ready after test, %v", err)
 	}
 }
@@ -451,7 +444,7 @@ func (f *Framework) CreateNamespace(baseName string, labels map[string]string) (
 	if createTestingNS == nil {
 		createTestingNS = CreateTestingNS
 	}
-	ns, err := createTestingNS(baseName, f.Client, labels)
+	ns, err := createTestingNS(baseName, f.ClientSet, labels)
 	if err == nil {
 		f.namespacesToDelete = append(f.namespacesToDelete, ns)
 	}
@@ -483,29 +476,29 @@ func (f *Framework) createFederationNamespace(baseName string) (*v1.Namespace, e
 
 // WaitForPodTerminated waits for the pod to be terminated with the given reason.
 func (f *Framework) WaitForPodTerminated(podName, reason string) error {
-	return waitForPodTerminatedInNamespace(f.Client, podName, reason, f.Namespace.Name)
+	return waitForPodTerminatedInNamespace(f.ClientSet, podName, reason, f.Namespace.Name)
 }
 
 // WaitForPodRunning waits for the pod to run in the namespace.
 func (f *Framework) WaitForPodRunning(podName string) error {
-	return WaitForPodNameRunningInNamespace(f.Client, podName, f.Namespace.Name)
+	return WaitForPodNameRunningInNamespace(f.ClientSet, podName, f.Namespace.Name)
 }
 
 // WaitForPodReady waits for the pod to flip to ready in the namespace.
 func (f *Framework) WaitForPodReady(podName string) error {
-	return waitTimeoutForPodReadyInNamespace(f.Client, podName, f.Namespace.Name, "", PodStartTimeout)
+	return waitTimeoutForPodReadyInNamespace(f.ClientSet, podName, f.Namespace.Name, "", PodStartTimeout)
 }
 
 // WaitForPodRunningSlow waits for the pod to run in the namespace.
 // It has a longer timeout then WaitForPodRunning (util.slowPodStartTimeout).
 func (f *Framework) WaitForPodRunningSlow(podName string) error {
-	return waitForPodRunningInNamespaceSlow(f.Client, podName, f.Namespace.Name, "")
+	return waitForPodRunningInNamespaceSlow(f.ClientSet, podName, f.Namespace.Name, "")
 }
 
 // WaitForPodNoLongerRunning waits for the pod to no longer be running in the namespace, for either
 // success or failure.
 func (f *Framework) WaitForPodNoLongerRunning(podName string) error {
-	return WaitForPodNoLongerRunningInNamespace(f.Client, podName, f.Namespace.Name, "")
+	return WaitForPodNoLongerRunningInNamespace(f.ClientSet, podName, f.Namespace.Name, "")
 }
 
 // TestContainerOutput runs the given pod in the given namespace and waits
@@ -528,7 +521,7 @@ func (f *Framework) WaitForAnEndpoint(serviceName string) error {
 	for {
 		// TODO: Endpoints client should take a field selector so we
 		// don't have to list everything.
-		list, err := f.Client.Endpoints(f.Namespace.Name).List(api.ListOptions{})
+		list, err := f.ClientSet.Core().Endpoints(f.Namespace.Name).List(api.ListOptions{})
 		if err != nil {
 			return err
 		}
@@ -547,7 +540,7 @@ func (f *Framework) WaitForAnEndpoint(serviceName string) error {
 			FieldSelector:   fields.Set{"metadata.name": serviceName}.AsSelector(),
 			ResourceVersion: rv,
 		}
-		w, err := f.Client.Endpoints(f.Namespace.Name).Watch(options)
+		w, err := f.ClientSet.Core().Endpoints(f.Namespace.Name).Watch(options)
 		if err != nil {
 			return err
 		}
@@ -613,7 +606,7 @@ func (f *Framework) CreateServiceForSimpleAppWithPods(contPort int, svcPort int,
 	theService := f.CreateServiceForSimpleApp(contPort, svcPort, appName)
 	f.CreatePodsPerNodeForSimpleApp(appName, podSpec, count)
 	if block {
-		err = testutils.WaitForPodsWithLabelRunning(f.Client, f.Namespace.Name, labels.SelectorFromSet(labels.Set(theService.Spec.Selector)))
+		err = testutils.WaitForPodsWithLabelRunning(f.ClientSet, f.Namespace.Name, labels.SelectorFromSet(labels.Set(theService.Spec.Selector)))
 	}
 	return err, theService
 }
@@ -641,7 +634,7 @@ func (f *Framework) CreateServiceForSimpleApp(contPort, svcPort int, appName str
 		}
 	}
 	Logf("Creating a service-for-%v for selecting app=%v-pod", appName, appName)
-	service, err := f.Client.Services(f.Namespace.Name).Create(&api.Service{
+	service, err := f.ClientSet.Core().Services(f.Namespace.Name).Create(&api.Service{
 		ObjectMeta: api.ObjectMeta{
 			Name: "service-for-" + appName,
 			Labels: map[string]string{
@@ -667,7 +660,7 @@ func (f *Framework) CreatePodsPerNodeForSimpleApp(appName string, podSpec func(n
 		// one per node, but no more than maxCount.
 		if i <= maxCount {
 			Logf("%v/%v : Creating container with label app=%v-pod", i, maxCount, appName)
-			_, err := f.Client.Pods(f.Namespace.Name).Create(&api.Pod{
+			_, err := f.ClientSet.Core().Pods(f.Namespace.Name).Create(&api.Pod{
 				ObjectMeta: api.ObjectMeta{
 					Name:   fmt.Sprintf(appName+"-pod-%v", i),
 					Labels: labels,
@@ -852,14 +845,14 @@ type PodStateVerification struct {
 }
 
 type ClusterVerification struct {
-	client    *client.Client
+	client    internalclientset.Interface
 	namespace *api.Namespace // pointer rather than string, since ns isn't created until before each.
 	podState  PodStateVerification
 }
 
 func (f *Framework) NewClusterVerification(filter PodStateVerification) *ClusterVerification {
 	return &ClusterVerification{
-		f.Client,
+		f.ClientSet,
 		f.Namespace,
 		filter,
 	}
@@ -894,7 +887,7 @@ func passesPhasesFilter(pod api.Pod, validPhases []api.PodPhase) bool {
 }
 
 // filterLabels returns a list of pods which have labels.
-func filterLabels(selectors map[string]string, cli *client.Client, ns string) (*api.PodList, error) {
+func filterLabels(selectors map[string]string, cli internalclientset.Interface, ns string) (*api.PodList, error) {
 	var err error
 	var selector labels.Selector
 	var pl *api.PodList
@@ -903,9 +896,9 @@ func filterLabels(selectors map[string]string, cli *client.Client, ns string) (*
 	if len(selectors) > 0 {
 		selector = labels.SelectorFromSet(labels.Set(selectors))
 		options := api.ListOptions{LabelSelector: selector}
-		pl, err = cli.Pods(ns).List(options)
+		pl, err = cli.Core().Pods(ns).List(options)
 	} else {
-		pl, err = cli.Pods(ns).List(api.ListOptions{})
+		pl, err = cli.Core().Pods(ns).List(api.ListOptions{})
 	}
 	return pl, err
 }
@@ -913,7 +906,7 @@ func filterLabels(selectors map[string]string, cli *client.Client, ns string) (*
 // filter filters pods which pass a filter.  It can be used to compose
 // the more useful abstractions like ForEach, WaitFor, and so on, which
 // can be used directly by tests.
-func (p *PodStateVerification) filter(c *client.Client, namespace *api.Namespace) ([]api.Pod, error) {
+func (p *PodStateVerification) filter(c internalclientset.Interface, namespace *api.Namespace) ([]api.Pod, error) {
 	if len(p.ValidPhases) == 0 || namespace == nil {
 		panic(fmt.Errorf("Need to specify a valid pod phases (%v) and namespace (%v). ", p.ValidPhases, namespace))
 	}

test/e2e/framework/kubelet_stats.go

@@ -30,7 +30,7 @@ import (
 	cadvisorapi "github.com/google/cadvisor/info/v1"
 	"github.com/prometheus/common/model"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/stats"
 	kubeletmetrics "k8s.io/kubernetes/pkg/kubelet/metrics"
 	kubeletstats "k8s.io/kubernetes/pkg/kubelet/server/stats"
@@ -63,7 +63,7 @@ func (a KubeletLatencyMetrics) Less(i, j int) bool { return a[i].Latency > a[j].
 
 // If a apiserver client is passed in, the function will try to get kubelet metrics from metrics grabber;
 // or else, the function will try to get kubelet metrics directly from the node.
-func getKubeletMetricsFromNode(c *client.Client, nodeName string) (metrics.KubeletMetrics, error) {
+func getKubeletMetricsFromNode(c clientset.Interface, nodeName string) (metrics.KubeletMetrics, error) {
 	if c == nil {
 		return metrics.GrabKubeletMetricsWithoutProxy(nodeName)
 	}
@@ -76,7 +76,7 @@ func getKubeletMetricsFromNode(c *client.Client, nodeName string) (metrics.Kubel
 
 // getKubeletMetrics gets all metrics in kubelet subsystem from specified node and trims
 // the subsystem prefix.
-func getKubeletMetrics(c *client.Client, nodeName string) (metrics.KubeletMetrics, error) {
+func getKubeletMetrics(c clientset.Interface, nodeName string) (metrics.KubeletMetrics, error) {
 	ms, err := getKubeletMetricsFromNode(c, nodeName)
 	if err != nil {
 		return metrics.KubeletMetrics{}, err
@@ -138,7 +138,7 @@ func GetKubeletLatencyMetrics(ms metrics.KubeletMetrics) KubeletLatencyMetrics {
 
 // RuntimeOperationMonitor is the tool getting and parsing docker operation metrics.
 type RuntimeOperationMonitor struct {
-	client          *client.Client
+	client          clientset.Interface
 	nodesRuntimeOps map[string]NodeRuntimeOperationErrorRate
 }
 
@@ -152,12 +152,12 @@ type RuntimeOperationErrorRate struct {
 	TimeoutRate float64
 }
 
-func NewRuntimeOperationMonitor(c *client.Client) *RuntimeOperationMonitor {
+func NewRuntimeOperationMonitor(c clientset.Interface) *RuntimeOperationMonitor {
 	m := &RuntimeOperationMonitor{
 		client:          c,
 		nodesRuntimeOps: make(map[string]NodeRuntimeOperationErrorRate),
 	}
-	nodes, err := m.client.Nodes().List(api.ListOptions{})
+	nodes, err := m.client.Core().Nodes().List(api.ListOptions{})
 	if err != nil {
 		Failf("RuntimeOperationMonitor: unable to get list of nodes: %v", err)
 	}
@@ -224,7 +224,7 @@ func FormatRuntimeOperationErrorRate(nodesResult map[string]NodeRuntimeOperation
 }
 
 // getNodeRuntimeOperationErrorRate gets runtime operation error rate from specified node.
-func getNodeRuntimeOperationErrorRate(c *client.Client, node string) (NodeRuntimeOperationErrorRate, error) {
+func getNodeRuntimeOperationErrorRate(c clientset.Interface, node string) (NodeRuntimeOperationErrorRate, error) {
 	result := make(NodeRuntimeOperationErrorRate)
 	ms, err := getKubeletMetrics(c, node)
 	if err != nil {
@@ -256,7 +256,7 @@ func getNodeRuntimeOperationErrorRate(c *client.Client, node string) (NodeRuntim
 }
 
 // HighLatencyKubeletOperations logs and counts the high latency metrics exported by the kubelet server via /metrics.
-func HighLatencyKubeletOperations(c *client.Client, threshold time.Duration, nodeName string, logFunc func(fmt string, args ...interface{})) (KubeletLatencyMetrics, error) {
+func HighLatencyKubeletOperations(c clientset.Interface, threshold time.Duration, nodeName string, logFunc func(fmt string, args ...interface{})) (KubeletLatencyMetrics, error) {
 	ms, err := getKubeletMetrics(c, nodeName)
 	if err != nil {
 		return KubeletLatencyMetrics{}, err
@@ -278,19 +278,19 @@ func HighLatencyKubeletOperations(c *client.Client, threshold time.Duration, nod
 // in the returned ContainerInfo is subject to the requirements in statsRequest.
 // TODO: This function uses the deprecated kubelet stats API; it should be
 // removed.
-func getContainerInfo(c *client.Client, nodeName string, req *kubeletstats.StatsRequest) (map[string]cadvisorapi.ContainerInfo, error) {
+func getContainerInfo(c clientset.Interface, nodeName string, req *kubeletstats.StatsRequest) (map[string]cadvisorapi.ContainerInfo, error) {
 	reqBody, err := json.Marshal(req)
 	if err != nil {
 		return nil, err
 	}
-	subResourceProxyAvailable, err := ServerVersionGTE(subResourceServiceAndNodeProxyVersion, c)
+	subResourceProxyAvailable, err := ServerVersionGTE(subResourceServiceAndNodeProxyVersion, c.Discovery())
 	if err != nil {
 		return nil, err
 	}
 
 	var data []byte
 	if subResourceProxyAvailable {
-		data, err = c.Post().
+		data, err = c.Core().RESTClient().Post().
 			Resource("nodes").
 			SubResource("proxy").
 			Name(fmt.Sprintf("%v:%v", nodeName, ports.KubeletPort)).
@@ -300,7 +300,7 @@ func getContainerInfo(c *client.Client, nodeName string, req *kubeletstats.Stats
 			Do().Raw()
 
 	} else {
-		data, err = c.Post().
+		data, err = c.Core().RESTClient().Post().
 			Prefix("proxy").
 			Resource("nodes").
 			Name(fmt.Sprintf("%v:%v", nodeName, ports.KubeletPort)).
@@ -344,7 +344,7 @@ func getContainerInfo(c *client.Client, nodeName string, req *kubeletstats.Stats
 // TODO: This function relies on the deprecated kubelet stats API and should be
 // removed and/or rewritten.
 func getOneTimeResourceUsageOnNode(
-	c *client.Client,
+	c clientset.Interface,
 	nodeName string,
 	cpuInterval time.Duration,
 	containerNames func() []string,
@@ -400,15 +400,15 @@ func getOneTimeResourceUsageOnNode(
 	return usageMap, nil
 }
 
-func getNodeStatsSummary(c *client.Client, nodeName string) (*stats.Summary, error) {
+func getNodeStatsSummary(c clientset.Interface, nodeName string) (*stats.Summary, error) {
-	subResourceProxyAvailable, err := ServerVersionGTE(subResourceServiceAndNodeProxyVersion, c)
+	subResourceProxyAvailable, err := ServerVersionGTE(subResourceServiceAndNodeProxyVersion, c.Discovery())
 	if err != nil {
 		return nil, err
 	}
 
 	var data []byte
 	if subResourceProxyAvailable {
-		data, err = c.Get().
+		data, err = c.Core().RESTClient().Get().
 			Resource("nodes").
 			SubResource("proxy").
 			Name(fmt.Sprintf("%v:%v", nodeName, ports.KubeletPort)).
@@ -417,7 +417,7 @@ func getNodeStatsSummary(c *client.Client, nodeName string) (*stats.Summary, err
 			Do().Raw()
 
 	} else {
-		data, err = c.Get().
+		data, err = c.Core().RESTClient().Get().
 			Prefix("proxy").
 			Resource("nodes").
 			Name(fmt.Sprintf("%v:%v", nodeName, ports.KubeletPort)).
@@ -515,7 +515,7 @@ type usageDataPerContainer struct {
 	memWorkSetData []uint64
 }
 
-func GetKubeletHeapStats(c *client.Client, nodeName string) (string, error) {
+func GetKubeletHeapStats(c clientset.Interface, nodeName string) (string, error) {
 	client, err := NodeProxyRequest(c, nodeName, "debug/pprof/heap")
 	if err != nil {
 		return "", err
@@ -531,7 +531,7 @@ func GetKubeletHeapStats(c *client.Client, nodeName string) (string, error) {
 	return strings.Join(lines[len(lines)-numLines:], "\n"), nil
 }
 
-func PrintAllKubeletPods(c *client.Client, nodeName string) {
+func PrintAllKubeletPods(c clientset.Interface, nodeName string) {
 	podList, err := GetKubeletPods(c, nodeName)
 	if err != nil {
 		Logf("Unable to retrieve kubelet pods for node %v: %v", nodeName, err)
@@ -565,13 +565,13 @@ type resourceCollector struct {
 	lock            sync.RWMutex
 	node            string
 	containers      []string
-	client          *client.Client
+	client          clientset.Interface
 	buffers         map[string][]*ContainerResourceUsage
 	pollingInterval time.Duration
 	stopCh          chan struct{}
 }
 
-func newResourceCollector(c *client.Client, nodeName string, containerNames []string, pollingInterval time.Duration) *resourceCollector {
+func newResourceCollector(c clientset.Interface, nodeName string, containerNames []string, pollingInterval time.Duration) *resourceCollector {
 	buffers := make(map[string][]*ContainerResourceUsage)
 	return &resourceCollector{
 		node:            nodeName,
@@ -679,13 +679,13 @@ func (r *resourceCollector) GetBasicCPUStats(containerName string) map[float64]f
 
 // ResourceMonitor manages a resourceCollector per node.
 type ResourceMonitor struct {
-	client          *client.Client
+	client          clientset.Interface
 	containers      []string
 	pollingInterval time.Duration
 	collectors      map[string]*resourceCollector
 }
 
-func NewResourceMonitor(c *client.Client, containerNames []string, pollingInterval time.Duration) *ResourceMonitor {
+func NewResourceMonitor(c clientset.Interface, containerNames []string, pollingInterval time.Duration) *ResourceMonitor {
 	return &ResourceMonitor{
 		containers:      containerNames,
 		client:          c,
@@ -695,7 +695,7 @@ func NewResourceMonitor(c *client.Client, containerNames []string, pollingInterv
 
 func (r *ResourceMonitor) Start() {
 	// It should be OK to monitor unschedulable Nodes
-	nodes, err := r.client.Nodes().List(api.ListOptions{})
+	nodes, err := r.client.Core().Nodes().List(api.ListOptions{})
 	if err != nil {
 		Failf("ResourceMonitor: unable to get list of nodes: %v", err)
 	}

test/e2e/framework/log_size_monitoring.go

@@ -26,7 +26,6 @@ import (
 	"time"
 
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 )
 
 const (
@@ -65,8 +64,7 @@ type LogSizeGatherer struct {
 // LogsSizeVerifier gathers data about log files sizes from master and node machines.
 // It oversees a <workersNo> workers which do the gathering.
 type LogsSizeVerifier struct {
-	client      *client.Client
+	client      clientset.Interface
-	clientset   clientset.Interface
 	stopChannel chan bool
 	// data stores LogSizeData groupped per IP and log_path
 	data          *LogsSizeData
@@ -144,8 +142,8 @@ func (d *LogsSizeData) AddNewData(ip, path string, timestamp time.Time, size int
 }
 
 // NewLogsVerifier creates a new LogsSizeVerifier which will stop when stopChannel is closed
-func NewLogsVerifier(c *client.Client, cs clientset.Interface, stopChannel chan bool) *LogsSizeVerifier {
+func NewLogsVerifier(c clientset.Interface, stopChannel chan bool) *LogsSizeVerifier {
-	nodeAddresses, err := NodeSSHHosts(cs)
+	nodeAddresses, err := NodeSSHHosts(c)
 	ExpectNoError(err)
 	masterAddress := GetMasterHost() + ":22"
 
@@ -154,7 +152,6 @@ func NewLogsVerifier(c *client.Client, cs clientset.Interface, stopChannel chan
 
 	verifier := &LogsSizeVerifier{
 		client:        c,
-		clientset:     cs,
 		stopChannel:   stopChannel,
 		data:          prepareData(masterAddress, nodeAddresses),
 		masterAddress: masterAddress,

test/e2e/framework/metrics_util.go

@@ -28,7 +28,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/master/ports"
 	"k8s.io/kubernetes/pkg/metrics"
 	"k8s.io/kubernetes/pkg/util/sets"
@@ -205,7 +205,7 @@ func setQuantile(metric *LatencyMetric, quantile float64, latency time.Duration)
 	}
 }
 
-func readLatencyMetrics(c *client.Client) (APIResponsiveness, error) {
+func readLatencyMetrics(c clientset.Interface) (APIResponsiveness, error) {
 	var a APIResponsiveness
 
 	body, err := getMetrics(c)
@@ -247,7 +247,7 @@ func readLatencyMetrics(c *client.Client) (APIResponsiveness, error) {
 
 // Prints top five summary metrics for request types with latency and returns
 // number of such request types above threshold.
-func HighLatencyRequests(c *client.Client) (int, error) {
+func HighLatencyRequests(c clientset.Interface) (int, error) {
 	metrics, err := readLatencyMetrics(c)
 	if err != nil {
 		return 0, err
@@ -297,9 +297,9 @@ func VerifyPodStartupLatency(latency PodStartupLatency) error {
 }
 
 // Resets latency metrics in apiserver.
-func ResetMetrics(c *client.Client) error {
+func ResetMetrics(c clientset.Interface) error {
 	Logf("Resetting latency metrics in apiserver...")
-	body, err := c.Delete().AbsPath("/metrics").DoRaw()
+	body, err := c.Core().RESTClient().Delete().AbsPath("/metrics").DoRaw()
 	if err != nil {
 		return err
 	}
@@ -310,8 +310,8 @@ func ResetMetrics(c *client.Client) error {
 }
 
 // Retrieves metrics information.
-func getMetrics(c *client.Client) (string, error) {
+func getMetrics(c clientset.Interface) (string, error) {
-	body, err := c.Get().AbsPath("/metrics").DoRaw()
+	body, err := c.Core().RESTClient().Get().AbsPath("/metrics").DoRaw()
 	if err != nil {
 		return "", err
 	}
@@ -319,11 +319,11 @@ func getMetrics(c *client.Client) (string, error) {
 }
 
 // Retrieves scheduler metrics information.
-func getSchedulingLatency(c *client.Client) (SchedulingLatency, error) {
+func getSchedulingLatency(c clientset.Interface) (SchedulingLatency, error) {
 	result := SchedulingLatency{}
 
 	// Check if master Node is registered
-	nodes, err := c.Nodes().List(api.ListOptions{})
+	nodes, err := c.Core().Nodes().List(api.ListOptions{})
 	ExpectNoError(err)
 
 	var data string
@@ -334,7 +334,7 @@ func getSchedulingLatency(c *client.Client) (SchedulingLatency, error) {
 		}
 	}
 	if masterRegistered {
-		rawData, err := c.Get().
+		rawData, err := c.Core().RESTClient().Get().
 			Prefix("proxy").
 			Namespace(api.NamespaceSystem).
 			Resource("pods").
@@ -383,7 +383,7 @@ func getSchedulingLatency(c *client.Client) (SchedulingLatency, error) {
 }
 
 // Verifies (currently just by logging them) the scheduling latencies.
-func VerifySchedulerLatency(c *client.Client) error {
+func VerifySchedulerLatency(c clientset.Interface) error {
 	latency, err := getSchedulingLatency(c)
 	if err != nil {
 		return err
@@ -457,7 +457,7 @@ func ExtractLatencyMetrics(latencies []PodLatencyData) LatencyMetric {
 
 // LogSuspiciousLatency logs metrics/docker errors from all nodes that had slow startup times
 // If latencyDataLag is nil then it will be populated from latencyData
-func LogSuspiciousLatency(latencyData []PodLatencyData, latencyDataLag []PodLatencyData, nodeCount int, c *client.Client) {
+func LogSuspiciousLatency(latencyData []PodLatencyData, latencyDataLag []PodLatencyData, nodeCount int, c clientset.Interface) {
 	if latencyDataLag == nil {
 		latencyDataLag = latencyData
 	}

test/e2e/framework/networking_utils.go

@@ -27,7 +27,7 @@ import (
 	api "k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	coreclientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/intstr"
 	"k8s.io/kubernetes/pkg/util/rand"
@@ -372,7 +372,7 @@ func (config *NetworkingTestConfig) createNodePortService(selector map[string]st
 }
 
 func (config *NetworkingTestConfig) DeleteNodePortService() {
-	err := config.getServiceClient().Delete(config.NodePortService.Name)
+	err := config.getServiceClient().Delete(config.NodePortService.Name, nil)
 	Expect(err).NotTo(HaveOccurred(), "error while deleting NodePortService. err:%v)", err)
 	time.Sleep(15 * time.Second) // wait for kube-proxy to catch up with the service being deleted.
 }
@@ -403,7 +403,7 @@ func (config *NetworkingTestConfig) createService(serviceSpec *api.Service) *api
 	_, err := config.getServiceClient().Create(serviceSpec)
 	Expect(err).NotTo(HaveOccurred(), fmt.Sprintf("Failed to create %s service: %v", serviceSpec.Name, err))
 
-	err = WaitForService(config.f.Client, config.Namespace, serviceSpec.Name, true, 5*time.Second, 45*time.Second)
+	err = WaitForService(config.f.ClientSet, config.Namespace, serviceSpec.Name, true, 5*time.Second, 45*time.Second)
 	Expect(err).NotTo(HaveOccurred(), fmt.Sprintf("error while waiting for service:%s err: %v", serviceSpec.Name, err))
 
 	createdService, err := config.getServiceClient().Get(serviceSpec.Name)
@@ -431,7 +431,7 @@ func (config *NetworkingTestConfig) setup(selector map[string]string) {
 	config.setupCore(selector)
 
 	By("Getting node addresses")
-	ExpectNoError(WaitForAllNodesSchedulable(config.f.Client))
+	ExpectNoError(WaitForAllNodesSchedulable(config.f.ClientSet))
 	nodeList := GetReadySchedulableNodesOrDie(config.f.ClientSet)
 	config.ExternalAddrs = NodeAddresses(nodeList, api.NodeExternalIP)
 	if len(config.ExternalAddrs) < 2 {
@@ -464,7 +464,7 @@ func (config *NetworkingTestConfig) cleanup() {
 	if err == nil {
 		for _, ns := range nsList.Items {
 			if strings.Contains(ns.Name, config.f.BaseName) && ns.Name != config.Namespace {
-				nsClient.Delete(ns.Name)
+				nsClient.Delete(ns.Name, nil)
 			}
 		}
 	}
@@ -482,7 +482,7 @@ func shuffleNodes(nodes []api.Node) []api.Node {
 }
 
 func (config *NetworkingTestConfig) createNetProxyPods(podName string, selector map[string]string) []*api.Pod {
-	ExpectNoError(WaitForAllNodesSchedulable(config.f.Client))
+	ExpectNoError(WaitForAllNodesSchedulable(config.f.ClientSet))
 	nodeList := GetReadySchedulableNodesOrDie(config.f.ClientSet)
 
 	// To make this test work reasonably fast in large clusters,
@@ -520,12 +520,12 @@ func (config *NetworkingTestConfig) DeleteNetProxyPod() {
 	config.getPodClient().Delete(pod.Name, api.NewDeleteOptions(0))
 	config.EndpointPods = config.EndpointPods[1:]
 	// wait for pod being deleted.
-	err := WaitForPodToDisappear(config.f.Client, config.Namespace, pod.Name, labels.Everything(), time.Second, wait.ForeverTestTimeout)
+	err := WaitForPodToDisappear(config.f.ClientSet, config.Namespace, pod.Name, labels.Everything(), time.Second, wait.ForeverTestTimeout)
 	if err != nil {
 		Failf("Failed to delete %s pod: %v", pod.Name, err)
 	}
 	// wait for endpoint being removed.
-	err = WaitForServiceEndpointsNum(config.f.Client, config.Namespace, nodePortServiceName, len(config.EndpointPods), time.Second, wait.ForeverTestTimeout)
+	err = WaitForServiceEndpointsNum(config.f.ClientSet, config.Namespace, nodePortServiceName, len(config.EndpointPods), time.Second, wait.ForeverTestTimeout)
 	if err != nil {
 		Failf("Failed to remove endpoint from service: %s", nodePortServiceName)
 	}
@@ -544,10 +544,10 @@ func (config *NetworkingTestConfig) getPodClient() *PodClient {
 	return config.podClient
 }
 
-func (config *NetworkingTestConfig) getServiceClient() client.ServiceInterface {
+func (config *NetworkingTestConfig) getServiceClient() coreclientset.ServiceInterface {
-	return config.f.Client.Services(config.Namespace)
+	return config.f.ClientSet.Core().Services(config.Namespace)
 }
 
-func (config *NetworkingTestConfig) getNamespacesClient() client.NamespaceInterface {
+func (config *NetworkingTestConfig) getNamespacesClient() coreclientset.NamespaceInterface {
-	return config.f.Client.Namespaces()
+	return config.f.ClientSet.Core().Namespaces()
 }

test/e2e/framework/nodes_util.go

@@ -23,7 +23,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/util/wait"
 )
@@ -82,7 +82,7 @@ var NodeUpgrade = func(f *Framework, v string, img string) error {
 	// TODO(ihmccreery) We shouldn't have to wait for nodes to be ready in
 	// GKE; the operation shouldn't return until they all are.
 	Logf("Waiting up to %v for all nodes to be ready after the upgrade", RestartNodeReadyAgainTimeout)
-	if _, err := CheckNodesReady(f.Client, RestartNodeReadyAgainTimeout, TestContext.CloudConfig.NumNodes); err != nil {
+	if _, err := CheckNodesReady(f.ClientSet, RestartNodeReadyAgainTimeout, TestContext.CloudConfig.NumNodes); err != nil {
 		return err
 	}
 	return nil
@@ -139,7 +139,7 @@ func nodeUpgradeGKE(v string, img string) error {
 // CheckNodesReady waits up to nt for expect nodes accessed by c to be ready,
 // returning an error if this doesn't happen in time. It returns the names of
 // nodes it finds.
-func CheckNodesReady(c *client.Client, nt time.Duration, expect int) ([]string, error) {
+func CheckNodesReady(c clientset.Interface, nt time.Duration, expect int) ([]string, error) {
 	// First, keep getting all of the nodes until we get the number we expect.
 	var nodeList *api.NodeList
 	var errLast error
@@ -148,7 +148,7 @@ func CheckNodesReady(c *client.Client, nt time.Duration, expect int) ([]string,
 		// A rolling-update (GCE/GKE implementation of restart) can complete before the apiserver
 		// knows about all of the nodes. Thus, we retry the list nodes call
 		// until we get the expected number of nodes.
-		nodeList, errLast = c.Nodes().List(api.ListOptions{
+		nodeList, errLast = c.Core().Nodes().List(api.ListOptions{
 			FieldSelector: fields.Set{"spec.unschedulable": "false"}.AsSelector()})
 		if errLast != nil {
 			return false, nil

test/e2e/framework/pods.go

@@ -23,7 +23,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
-	"k8s.io/kubernetes/pkg/client/unversioned"
+	unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -43,13 +43,13 @@ var ImageWhiteList sets.String
 func (f *Framework) PodClient() *PodClient {
 	return &PodClient{
 		f:            f,
-		PodInterface: f.Client.Pods(f.Namespace.Name),
+		PodInterface: f.ClientSet.Core().Pods(f.Namespace.Name),
 	}
 }
 
 type PodClient struct {
 	f *Framework
-	unversioned.PodInterface
+	unversionedcore.PodInterface
 }
 
 // Create creates a new pod according to the framework specifications (don't wait for it to start).
@@ -116,7 +116,7 @@ func (c *PodClient) DeleteSync(name string, options *api.DeleteOptions, timeout
 	if err != nil && !errors.IsNotFound(err) {
 		Failf("Failed to delete pod %q: %v", name, err)
 	}
-	Expect(WaitForPodToDisappear(c.f.Client, c.f.Namespace.Name, name, labels.Everything(),
+	Expect(WaitForPodToDisappear(c.f.ClientSet, c.f.Namespace.Name, name, labels.Everything(),
 		2*time.Second, timeout)).To(Succeed(), "wait for pod %q to disappear", name)
 }
 
@@ -156,7 +156,7 @@ func (c *PodClient) mungeSpec(pod *api.Pod) {
 // WaitForSuccess waits for pod to success.
 func (c *PodClient) WaitForSuccess(name string, timeout time.Duration) {
 	f := c.f
-	Expect(waitForPodCondition(f.Client, f.Namespace.Name, name, "success or failure", timeout,
+	Expect(waitForPodCondition(f.ClientSet, f.Namespace.Name, name, "success or failure", timeout,
 		func(pod *api.Pod) (bool, error) {
 			switch pod.Status.Phase {
 			case api.PodFailed:

test/e2e/framework/resource_usage_gatherer.go

@@ -30,7 +30,7 @@ import (
 
 	. "github.com/onsi/gomega"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	utilruntime "k8s.io/kubernetes/pkg/util/runtime"
 	"k8s.io/kubernetes/pkg/util/system"
 )
@@ -129,7 +129,7 @@ func leftMergeData(left, right map[int]ResourceUsagePerContainer) map[int]Resour
 }
 
 type resourceGatherWorker struct {
-	c                    *client.Client
+	c                    clientset.Interface
 	nodeName             string
 	wg                   *sync.WaitGroup
 	containerIDToNameMap map[string]string
@@ -204,7 +204,7 @@ func getKubemarkMasterComponentsResourceUsage() ResourceUsagePerContainer {
 	return result
 }
 
-func (g *containerResourceGatherer) getKubeSystemContainersResourceUsage(c *client.Client) {
+func (g *containerResourceGatherer) getKubeSystemContainersResourceUsage(c clientset.Interface) {
 	if len(g.workers) == 0 {
 		return
 	}
@@ -218,7 +218,7 @@ func (g *containerResourceGatherer) getKubeSystemContainersResourceUsage(c *clie
 }
 
 type containerResourceGatherer struct {
-	client               *client.Client
+	client               clientset.Interface
 	stopCh               chan struct{}
 	workers              []resourceGatherWorker
 	workerWg             sync.WaitGroup
@@ -232,7 +232,7 @@ type ResourceGathererOptions struct {
 	masterOnly bool
 }
 
-func NewResourceUsageGatherer(c *client.Client, options ResourceGathererOptions) (*containerResourceGatherer, error) {
+func NewResourceUsageGatherer(c clientset.Interface, options ResourceGathererOptions) (*containerResourceGatherer, error) {
 	g := containerResourceGatherer{
 		client:               c,
 		stopCh:               make(chan struct{}),
@@ -250,7 +250,7 @@ func NewResourceUsageGatherer(c *client.Client, options ResourceGathererOptions)
 			finished:   false,
 		})
 	} else {
-		pods, err := c.Pods("kube-system").List(api.ListOptions{})
+		pods, err := c.Core().Pods("kube-system").List(api.ListOptions{})
 		if err != nil {
 			Logf("Error while listing Pods: %v", err)
 			return nil, err
@@ -262,7 +262,7 @@ func NewResourceUsageGatherer(c *client.Client, options ResourceGathererOptions)
 				g.containerIDs = append(g.containerIDs, containerID)
 			}
 		}
-		nodeList, err := c.Nodes().List(api.ListOptions{})
+		nodeList, err := c.Core().Nodes().List(api.ListOptions{})
 		if err != nil {
 			Logf("Error while listing Nodes: %v", err)
 			return nil, err

test/e2e/garbage_collector.go

@@ -100,7 +100,7 @@ func verifyRemainingObjects(f *framework.Framework, clientSet clientset.Interfac
 func gatherMetrics(f *framework.Framework) {
 	By("Gathering metrics")
 	var summary framework.TestDataSummary
-	grabber, err := metrics.NewMetricsGrabber(f.Client, false, false, true, false)
+	grabber, err := metrics.NewMetricsGrabber(f.ClientSet, false, false, true, false)
 	if err != nil {
 		framework.Logf("Failed to create MetricsGrabber. Skipping metrics gathering.")
 	} else {

test/e2e/ha_master.go

@@ -19,12 +19,13 @@ package e2e
 import (
 	"bytes"
 	"fmt"
-	. "github.com/onsi/ginkgo"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
-	"k8s.io/kubernetes/test/e2e/framework"
 	"os/exec"
 	"path"
 	"strconv"
+
+	. "github.com/onsi/ginkgo"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	"k8s.io/kubernetes/test/e2e/framework"
 )
 
 func addMasterReplica() error {
@@ -47,13 +48,13 @@ func removeMasterReplica() error {
 	return nil
 }
 
-func verifyRCs(c *client.Client, ns string, names []string) {
+func verifyRCs(c clientset.Interface, ns string, names []string) {
 	for _, name := range names {
 		framework.ExpectNoError(framework.VerifyPods(c, ns, name, true, 1))
 	}
 }
 
-func createNewRC(c *client.Client, ns string, name string) {
+func createNewRC(c clientset.Interface, ns string, name string) {
 	_, err := newRCByName(c, ns, name, 1)
 	framework.ExpectNoError(err)
 }
@@ -77,14 +78,14 @@ func verifyNumberOfMasterReplicas(expected int) {
 
 var _ = framework.KubeDescribe("HA-master [Feature:HAMaster]", func() {
 	f := framework.NewDefaultFramework("ha-master")
-	var c *client.Client
+	var c clientset.Interface
 	var ns string
 	var additionalReplicas int
 	var existingRCs []string
 
 	BeforeEach(func() {
 		framework.SkipUnlessProviderIs("gce")
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 		verifyNumberOfMasterReplicas(1)
 		additionalReplicas = 0

test/e2e/horizontal_pod_autoscaling.go

@@ -191,6 +191,6 @@ func createCPUHorizontalPodAutoscaler(rc *ResourceConsumer, cpu, minReplicas, ma
 			TargetCPUUtilizationPercentage: &cpu,
 		},
 	}
-	_, errHPA := rc.framework.Client.Autoscaling().HorizontalPodAutoscalers(rc.framework.Namespace.Name).Create(hpa)
+	_, errHPA := rc.framework.ClientSet.Autoscaling().HorizontalPodAutoscalers(rc.framework.Namespace.Name).Create(hpa)
 	framework.ExpectNoError(errHPA)
 }

test/e2e/ingress.go

@@ -66,7 +66,7 @@ var _ = framework.KubeDescribe("Loadbalancing: L7 [Feature:Ingress]", func() {
 
 	BeforeEach(func() {
 		f.BeforeEach()
-		jig = newTestJig(f.Client)
+		jig = newTestJig(f.ClientSet)
 		ns = f.Namespace.Name
 	})
 

test/e2e/ingress_utils.go

@@ -43,7 +43,7 @@ import (
 	"google.golang.org/api/googleapi"
 	apierrs "k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/apis/extensions"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	gcecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/gce"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -68,7 +68,7 @@ const (
 )
 
 type testJig struct {
-	client  *client.Client
+	client  clientset.Interface
 	rootCAs map[string][]byte
 	address string
 	ing     *extensions.Ingress
@@ -269,7 +269,7 @@ func buildInsecureClient(timeout time.Duration) *http.Client {
 // createSecret creates a secret containing TLS certificates for the given Ingress.
 // If a secret with the same name already exists in the namespace of the
 // Ingress, it's updated.
-func createSecret(kubeClient *client.Client, ing *extensions.Ingress) (host string, rootCA, privKey []byte, err error) {
+func createSecret(kubeClient clientset.Interface, ing *extensions.Ingress) (host string, rootCA, privKey []byte, err error) {
 	var k, c bytes.Buffer
 	tls := ing.Spec.TLS[0]
 	host = strings.Join(tls.Hosts, ",")
@@ -290,14 +290,14 @@ func createSecret(kubeClient *client.Client, ing *extensions.Ingress) (host stri
 		},
 	}
 	var s *api.Secret
-	if s, err = kubeClient.Secrets(ing.Namespace).Get(tls.SecretName); err == nil {
+	if s, err = kubeClient.Core().Secrets(ing.Namespace).Get(tls.SecretName); err == nil {
 		// TODO: Retry the update. We don't really expect anything to conflict though.
 		framework.Logf("Updating secret %v in ns %v with hosts %v for ingress %v", secret.Name, secret.Namespace, host, ing.Name)
 		s.Data = secret.Data
-		_, err = kubeClient.Secrets(ing.Namespace).Update(s)
+		_, err = kubeClient.Core().Secrets(ing.Namespace).Update(s)
 	} else {
 		framework.Logf("Creating secret %v in ns %v with hosts %v for ingress %v", secret.Name, secret.Namespace, host, ing.Name)
-		_, err = kubeClient.Secrets(ing.Namespace).Create(secret)
+		_, err = kubeClient.Core().Secrets(ing.Namespace).Create(secret)
 	}
 	return host, cert, key, err
 }
@@ -684,7 +684,7 @@ func (j *testJig) createIngress(manifestPath, ns string, ingAnnotations map[stri
 	}
 	framework.Logf(fmt.Sprintf("creating" + j.ing.Name + " ingress"))
 	var err error
-	j.ing, err = j.client.Extensions().Ingress(ns).Create(j.ing)
+	j.ing, err = j.client.Extensions().Ingresses(ns).Create(j.ing)
 	ExpectNoError(err)
 }
 
@@ -692,12 +692,12 @@ func (j *testJig) update(update func(ing *extensions.Ingress)) {
 	var err error
 	ns, name := j.ing.Namespace, j.ing.Name
 	for i := 0; i < 3; i++ {
-		j.ing, err = j.client.Extensions().Ingress(ns).Get(name)
+		j.ing, err = j.client.Extensions().Ingresses(ns).Get(name)
 		if err != nil {
 			framework.Failf("failed to get ingress %q: %v", name, err)
 		}
 		update(j.ing)
-		j.ing, err = j.client.Extensions().Ingress(ns).Update(j.ing)
+		j.ing, err = j.client.Extensions().Ingresses(ns).Update(j.ing)
 		if err == nil {
 			describeIng(j.ing.Namespace)
 			return
@@ -732,7 +732,7 @@ func (j *testJig) getRootCA(secretName string) (rootCA []byte) {
 }
 
 func (j *testJig) deleteIngress() {
-	ExpectNoError(j.client.Extensions().Ingress(j.ing.Namespace).Delete(j.ing.Name, nil))
+	ExpectNoError(j.client.Extensions().Ingresses(j.ing.Namespace).Delete(j.ing.Name, nil))
 }
 
 func (j *testJig) waitForIngress() {
@@ -803,7 +803,7 @@ func ingFromManifest(fileName string) *extensions.Ingress {
 
 func (cont *GCEIngressController) getL7AddonUID() (string, error) {
 	framework.Logf("Retrieving UID from config map: %v/%v", api.NamespaceSystem, uidConfigMap)
-	cm, err := cont.c.ConfigMaps(api.NamespaceSystem).Get(uidConfigMap)
+	cm, err := cont.c.Core().ConfigMaps(api.NamespaceSystem).Get(uidConfigMap)
 	if err != nil {
 		return "", err
 	}
@@ -833,11 +833,11 @@ type GCEIngressController struct {
 	staticIPName string
 	rc           *api.ReplicationController
 	svc          *api.Service
-	c            *client.Client
+	c            clientset.Interface
 	cloud        framework.CloudConfig
 }
 
-func newTestJig(c *client.Client) *testJig {
+func newTestJig(c clientset.Interface) *testJig {
 	return &testJig{client: c, rootCAs: map[string][]byte{}}
 }
 
@@ -846,7 +846,7 @@ type NginxIngressController struct {
 	ns         string
 	rc         *api.ReplicationController
 	pod        *api.Pod
-	c          *client.Client
+	c          clientset.Interface
 	externalIP string
 }
 
@@ -857,14 +857,14 @@ func (cont *NginxIngressController) init() {
 	framework.Logf("initializing nginx ingress controller")
 	framework.RunKubectlOrDie("create", "-f", mkpath("rc.yaml"), fmt.Sprintf("--namespace=%v", cont.ns))
 
-	rc, err := cont.c.ReplicationControllers(cont.ns).Get("nginx-ingress-controller")
+	rc, err := cont.c.Core().ReplicationControllers(cont.ns).Get("nginx-ingress-controller")
 	ExpectNoError(err)
 	cont.rc = rc
 
 	framework.Logf("waiting for pods with label %v", rc.Spec.Selector)
 	sel := labels.SelectorFromSet(labels.Set(rc.Spec.Selector))
 	ExpectNoError(testutils.WaitForPodsWithLabelRunning(cont.c, cont.ns, sel))
-	pods, err := cont.c.Pods(cont.ns).List(api.ListOptions{LabelSelector: sel})
+	pods, err := cont.c.Core().Pods(cont.ns).List(api.ListOptions{LabelSelector: sel})
 	ExpectNoError(err)
 	if len(pods.Items) == 0 {
 		framework.Failf("Failed to find nginx ingress controller pods with selector %v", sel)

test/e2e/initial_resources.go

@@ -65,8 +65,8 @@ func runPod(f *framework.Framework, name, image string) *api.Pod {
 			},
 		},
 	}
-	createdPod, err := f.Client.Pods(f.Namespace.Name).Create(pod)
+	createdPod, err := f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 	framework.ExpectNoError(err)
-	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.Client, createdPod))
+	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.ClientSet, createdPod))
 	return createdPod
 }

test/e2e/job.go

@@ -22,7 +22,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/apis/batch"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/kubectl"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -50,11 +50,11 @@ var _ = framework.KubeDescribe("Job", func() {
 	It("should run a job to completion when tasks succeed", func() {
 		By("Creating a job")
 		job := newTestJob("succeed", "all-succeed", api.RestartPolicyNever, parallelism, completions)
-		job, err := createJob(f.Client, f.Namespace.Name, job)
+		job, err := createJob(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job reaches completions")
-		err = waitForJobFinish(f.Client, f.Namespace.Name, job.Name, completions)
+		err = waitForJobFinish(f.ClientSet, f.Namespace.Name, job.Name, completions)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -69,11 +69,11 @@ var _ = framework.KubeDescribe("Job", func() {
 		// due to successive failures too likely with a reasonable
 		// test timeout.
 		job := newTestJob("failOnce", "fail-once-local", api.RestartPolicyOnFailure, parallelism, completions)
-		job, err := createJob(f.Client, f.Namespace.Name, job)
+		job, err := createJob(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job reaches completions")
-		err = waitForJobFinish(f.Client, f.Namespace.Name, job.Name, completions)
+		err = waitForJobFinish(f.ClientSet, f.Namespace.Name, job.Name, completions)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -87,23 +87,23 @@ var _ = framework.KubeDescribe("Job", func() {
 		// run due to some slowness, 1 in 2^15 chance of happening,
 		// causing test flake.  Should be very rare.
 		job := newTestJob("randomlySucceedOrFail", "rand-non-local", api.RestartPolicyNever, parallelism, completions)
-		job, err := createJob(f.Client, f.Namespace.Name, job)
+		job, err := createJob(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job reaches completions")
-		err = waitForJobFinish(f.Client, f.Namespace.Name, job.Name, completions)
+		err = waitForJobFinish(f.ClientSet, f.Namespace.Name, job.Name, completions)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("should keep restarting failed pods", func() {
 		By("Creating a job")
 		job := newTestJob("fail", "all-fail", api.RestartPolicyNever, parallelism, completions)
-		job, err := createJob(f.Client, f.Namespace.Name, job)
+		job, err := createJob(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job shows many failures")
 		err = wait.Poll(framework.Poll, jobTimeout, func() (bool, error) {
-			curr, err := getJob(f.Client, f.Namespace.Name, job.Name)
+			curr, err := getJob(f.ClientSet, f.Namespace.Name, job.Name)
 			if err != nil {
 				return false, err
 			}
@@ -116,11 +116,11 @@ var _ = framework.KubeDescribe("Job", func() {
 		endParallelism := int32(2)
 		By("Creating a job")
 		job := newTestJob("notTerminate", "scale-up", api.RestartPolicyNever, startParallelism, completions)
-		job, err := createJob(f.Client, f.Namespace.Name, job)
+		job, err := createJob(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == startParallelism")
-		err = waitForAllPodsRunning(f.Client, f.Namespace.Name, job.Name, startParallelism)
+		err = waitForAllPodsRunning(f.ClientSet, f.Namespace.Name, job.Name, startParallelism)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("scale job up")
@@ -132,7 +132,7 @@ var _ = framework.KubeDescribe("Job", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == endParallelism")
-		err = waitForAllPodsRunning(f.Client, f.Namespace.Name, job.Name, endParallelism)
+		err = waitForAllPodsRunning(f.ClientSet, f.Namespace.Name, job.Name, endParallelism)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -141,11 +141,11 @@ var _ = framework.KubeDescribe("Job", func() {
 		endParallelism := int32(1)
 		By("Creating a job")
 		job := newTestJob("notTerminate", "scale-down", api.RestartPolicyNever, startParallelism, completions)
-		job, err := createJob(f.Client, f.Namespace.Name, job)
+		job, err := createJob(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == startParallelism")
-		err = waitForAllPodsRunning(f.Client, f.Namespace.Name, job.Name, startParallelism)
+		err = waitForAllPodsRunning(f.ClientSet, f.Namespace.Name, job.Name, startParallelism)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("scale job down")
@@ -157,18 +157,18 @@ var _ = framework.KubeDescribe("Job", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == endParallelism")
-		err = waitForAllPodsRunning(f.Client, f.Namespace.Name, job.Name, endParallelism)
+		err = waitForAllPodsRunning(f.ClientSet, f.Namespace.Name, job.Name, endParallelism)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("should delete a job", func() {
 		By("Creating a job")
 		job := newTestJob("notTerminate", "foo", api.RestartPolicyNever, parallelism, completions)
-		job, err := createJob(f.Client, f.Namespace.Name, job)
+		job, err := createJob(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring active pods == parallelism")
-		err = waitForAllPodsRunning(f.Client, f.Namespace.Name, job.Name, parallelism)
+		err = waitForAllPodsRunning(f.ClientSet, f.Namespace.Name, job.Name, parallelism)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("delete a job")
@@ -179,7 +179,7 @@ var _ = framework.KubeDescribe("Job", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job was deleted")
-		_, err = getJob(f.Client, f.Namespace.Name, job.Name)
+		_, err = getJob(f.ClientSet, f.Namespace.Name, job.Name)
 		Expect(err).To(HaveOccurred())
 		Expect(errors.IsNotFound(err)).To(BeTrue())
 	})
@@ -189,21 +189,21 @@ var _ = framework.KubeDescribe("Job", func() {
 		job := newTestJob("notTerminate", "foo", api.RestartPolicyNever, parallelism, completions)
 		activeDeadlineSeconds := int64(10)
 		job.Spec.ActiveDeadlineSeconds = &activeDeadlineSeconds
-		job, err := createJob(f.Client, f.Namespace.Name, job)
+		job, err := createJob(f.ClientSet, f.Namespace.Name, job)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring job was failed")
-		err = waitForJobFail(f.Client, f.Namespace.Name, job.Name, 20*time.Second)
+		err = waitForJobFail(f.ClientSet, f.Namespace.Name, job.Name, 20*time.Second)
 		if err == wait.ErrWaitTimeout {
-			job, err = getJob(f.Client, f.Namespace.Name, job.Name)
+			job, err = getJob(f.ClientSet, f.Namespace.Name, job.Name)
 			Expect(err).NotTo(HaveOccurred())
 			// the job stabilized and won't be synced until modification or full
 			// resync happens, we don't want to wait for the latter so we force
 			// sync modifying it
 			job.Spec.Parallelism = &completions
-			job, err = updateJob(f.Client, f.Namespace.Name, job)
+			job, err = updateJob(f.ClientSet, f.Namespace.Name, job)
 			Expect(err).NotTo(HaveOccurred())
-			err = waitForJobFail(f.Client, f.Namespace.Name, job.Name, jobTimeout)
+			err = waitForJobFail(f.ClientSet, f.Namespace.Name, job.Name, jobTimeout)
 		}
 		Expect(err).NotTo(HaveOccurred())
 	})
@@ -218,7 +218,7 @@ func newTestJob(behavior, name string, rPol api.RestartPolicy, parallelism, comp
 		Spec: batch.JobSpec{
 			Parallelism:    &parallelism,
 			Completions:    &completions,
-			ManualSelector: newBool(true),
+			ManualSelector: newBool(false),
 			Template: api.PodTemplateSpec{
 				ObjectMeta: api.ObjectMeta{
 					Labels: map[string]string{jobSelectorKey: name},
@@ -272,28 +272,28 @@ func newTestJob(behavior, name string, rPol api.RestartPolicy, parallelism, comp
 	return job
 }
 
-func getJob(c *client.Client, ns, name string) (*batch.Job, error) {
+func getJob(c clientset.Interface, ns, name string) (*batch.Job, error) {
-	return c.Extensions().Jobs(ns).Get(name)
+	return c.Batch().Jobs(ns).Get(name)
 }
 
-func createJob(c *client.Client, ns string, job *batch.Job) (*batch.Job, error) {
+func createJob(c clientset.Interface, ns string, job *batch.Job) (*batch.Job, error) {
-	return c.Extensions().Jobs(ns).Create(job)
+	return c.Batch().Jobs(ns).Create(job)
 }
 
-func updateJob(c *client.Client, ns string, job *batch.Job) (*batch.Job, error) {
+func updateJob(c clientset.Interface, ns string, job *batch.Job) (*batch.Job, error) {
-	return c.Extensions().Jobs(ns).Update(job)
+	return c.Batch().Jobs(ns).Update(job)
 }
 
-func deleteJob(c *client.Client, ns, name string) error {
+func deleteJob(c clientset.Interface, ns, name string) error {
-	return c.Extensions().Jobs(ns).Delete(name, nil)
+	return c.Batch().Jobs(ns).Delete(name, nil)
 }
 
 // Wait for all pods to become Running.  Only use when pods will run for a long time, or it will be racy.
-func waitForAllPodsRunning(c *client.Client, ns, jobName string, parallelism int32) error {
+func waitForAllPodsRunning(c clientset.Interface, ns, jobName string, parallelism int32) error {
 	label := labels.SelectorFromSet(labels.Set(map[string]string{jobSelectorKey: jobName}))
 	return wait.Poll(framework.Poll, jobTimeout, func() (bool, error) {
 		options := api.ListOptions{LabelSelector: label}
-		pods, err := c.Pods(ns).List(options)
+		pods, err := c.Core().Pods(ns).List(options)
 		if err != nil {
 			return false, err
 		}
@@ -308,9 +308,9 @@ func waitForAllPodsRunning(c *client.Client, ns, jobName string, parallelism int
 }
 
 // Wait for job to reach completions.
-func waitForJobFinish(c *client.Client, ns, jobName string, completions int32) error {
+func waitForJobFinish(c clientset.Interface, ns, jobName string, completions int32) error {
 	return wait.Poll(framework.Poll, jobTimeout, func() (bool, error) {
-		curr, err := c.Extensions().Jobs(ns).Get(jobName)
+		curr, err := c.Batch().Jobs(ns).Get(jobName)
 		if err != nil {
 			return false, err
 		}
@@ -319,9 +319,9 @@ func waitForJobFinish(c *client.Client, ns, jobName string, completions int32) e
 }
 
 // Wait for job fail.
-func waitForJobFail(c *client.Client, ns, jobName string, timeout time.Duration) error {
+func waitForJobFail(c clientset.Interface, ns, jobName string, timeout time.Duration) error {
 	return wait.Poll(framework.Poll, timeout, func() (bool, error) {
-		curr, err := c.Extensions().Jobs(ns).Get(jobName)
+		curr, err := c.Batch().Jobs(ns).Get(jobName)
 		if err != nil {
 			return false, err
 		}

test/e2e/kibana_logging.go

@@ -54,7 +54,7 @@ func ClusterLevelLoggingWithKibana(f *framework.Framework) {
 
 	// Check for the existence of the Kibana service.
 	By("Checking the Kibana service exists.")
-	s := f.Client.Services(api.NamespaceSystem)
+	s := f.ClientSet.Core().Services(api.NamespaceSystem)
 	// Make a few attempts to connect. This makes the test robust against
 	// being run as the first e2e test just after the e2e cluster has been created.
 	var err error
@@ -70,17 +70,17 @@ func ClusterLevelLoggingWithKibana(f *framework.Framework) {
 	By("Checking to make sure the Kibana pods are running")
 	label := labels.SelectorFromSet(labels.Set(map[string]string{kibanaKey: kibanaValue}))
 	options := api.ListOptions{LabelSelector: label}
-	pods, err := f.Client.Pods(api.NamespaceSystem).List(options)
+	pods, err := f.ClientSet.Core().Pods(api.NamespaceSystem).List(options)
 	Expect(err).NotTo(HaveOccurred())
 	for _, pod := range pods.Items {
-		err = framework.WaitForPodRunningInNamespace(f.Client, &pod)
+		err = framework.WaitForPodRunningInNamespace(f.ClientSet, &pod)
 		Expect(err).NotTo(HaveOccurred())
 	}
 
 	By("Checking to make sure we get a response from the Kibana UI.")
 	err = nil
 	for start := time.Now(); time.Since(start) < graceTime; time.Sleep(5 * time.Second) {
-		proxyRequest, errProxy := framework.GetServicesProxyRequest(f.Client, f.Client.Get())
+		proxyRequest, errProxy := framework.GetServicesProxyRequest(f.ClientSet, f.ClientSet.Core().RESTClient().Get())
 		if errProxy != nil {
 			framework.Logf("After %v failed to get services proxy request: %v", time.Since(start), errProxy)
 			continue

test/e2e/kubectl.go

@@ -46,7 +46,7 @@ import (
 	apierrs "k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/kubectl/cmd/util"
 	"k8s.io/kubernetes/pkg/labels"
@@ -184,10 +184,10 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 	forEachPod := func(podFunc func(p api.Pod)) {
 		clusterState().ForEach(podFunc)
 	}
-	var c *client.Client
+	var c clientset.Interface
 	var ns string
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 	})
 
@@ -260,7 +260,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 		}
 
 		It("should create and stop a working application [Conformance]", func() {
-			framework.SkipUnlessServerVersionGTE(deploymentsVersion, c)
+			framework.SkipUnlessServerVersionGTE(deploymentsVersion, c.Discovery())
 
 			defer forEachGBFile(func(contents string) {
 				cleanupKubectlInputs(contents, ns)
@@ -393,7 +393,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 				WithStdinData("abcd1234").
 				Exec()
 			ExpectNoError(err)
-			framework.WaitForPodToDisappear(f.Client, ns, "failure-3", labels.Everything(), 2*time.Second, wait.ForeverTestTimeout)
+			framework.WaitForPodToDisappear(f.ClientSet, ns, "failure-3", labels.Everything(), 2*time.Second, wait.ForeverTestTimeout)
 
 			By("running a failing command with --leave-stdin-open")
 			_, err = framework.NewKubectlCommand(nsFlag, "run", "-i", "--image="+busyboxImage, "--restart=Never", "failure-4", "--leave-stdin-open", "--", "/bin/sh", "-c", "exit 42").
@@ -404,7 +404,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 
 		It("should support inline execution and attach", func() {
 			framework.SkipIfContainerRuntimeIs("rkt") // #23335
-			framework.SkipUnlessServerVersionGTE(jobsVersion, c)
+			framework.SkipUnlessServerVersionGTE(jobsVersion, c.Discovery())
 
 			nsFlag := fmt.Sprintf("--namespace=%v", ns)
 
@@ -414,7 +414,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 				ExecOrDie()
 			Expect(runOutput).To(ContainSubstring("abcd1234"))
 			Expect(runOutput).To(ContainSubstring("stdin closed"))
-			Expect(c.Extensions().Jobs(ns).Delete("run-test", nil)).To(BeNil())
+			Expect(c.Batch().Jobs(ns).Delete("run-test", nil)).To(BeNil())
 
 			By("executing a command with run and attach without stdin")
 			runOutput = framework.NewKubectlCommand(fmt.Sprintf("--namespace=%v", ns), "run", "run-test-2", "--image="+busyboxImage, "--restart=OnFailure", "--attach=true", "--leave-stdin-open=true", "--", "sh", "-c", "cat && echo 'stdin closed'").
@@ -422,7 +422,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 				ExecOrDie()
 			Expect(runOutput).ToNot(ContainSubstring("abcd1234"))
 			Expect(runOutput).To(ContainSubstring("stdin closed"))
-			Expect(c.Extensions().Jobs(ns).Delete("run-test-2", nil)).To(BeNil())
+			Expect(c.Batch().Jobs(ns).Delete("run-test-2", nil)).To(BeNil())
 
 			By("executing a command with run and attach with stdin with open stdin should remain running")
 			runOutput = framework.NewKubectlCommand(nsFlag, "run", "run-test-3", "--image="+busyboxImage, "--restart=OnFailure", "--attach=true", "--leave-stdin-open=true", "--stdin", "--", "sh", "-c", "cat && echo 'stdin closed'").
@@ -453,7 +453,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 			}
 			Expect(err).To(BeNil())
 
-			Expect(c.Extensions().Jobs(ns).Delete("run-test-3", nil)).To(BeNil())
+			Expect(c.Batch().Jobs(ns).Delete("run-test-3", nil)).To(BeNil())
 		})
 
 		It("should support port-forward", func() {
@@ -541,10 +541,10 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 
 	framework.KubeDescribe("Kubectl describe", func() {
 		It("should check if kubectl describe prints relevant information for rc and pods [Conformance]", func() {
-			framework.SkipUnlessServerVersionGTE(nodePortsOptionalVersion, c)
+			framework.SkipUnlessServerVersionGTE(nodePortsOptionalVersion, c.Discovery())
 			kv, err := framework.KubectlVersion()
 			Expect(err).NotTo(HaveOccurred())
-			framework.SkipUnlessServerVersionGTE(kv, c)
+			framework.SkipUnlessServerVersionGTE(kv, c.Discovery())
 			controllerJson := readTestFileOrDie(redisControllerFilename)
 			serviceJson := readTestFileOrDie(redisServiceFilename)
 
@@ -610,7 +610,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 
 			// Node
 			// It should be OK to list unschedulable Nodes here.
-			nodes, err := c.Nodes().List(api.ListOptions{})
+			nodes, err := c.Core().Nodes().List(api.ListOptions{})
 			Expect(err).NotTo(HaveOccurred())
 			node := nodes.Items[0]
 			output = framework.RunKubectlOrDie("describe", "node", node.Name)
@@ -664,7 +664,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 			})
 			validateService := func(name string, servicePort int, timeout time.Duration) {
 				err := wait.Poll(framework.Poll, timeout, func() (bool, error) {
-					endpoints, err := c.Endpoints(ns).Get(name)
+					endpoints, err := c.Core().Endpoints(ns).Get(name)
 					if err != nil {
 						// log the real error
 						framework.Logf("Get endpoints failed (interval %v): %v", framework.Poll, err)
@@ -695,7 +695,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 				})
 				Expect(err).NotTo(HaveOccurred())
 
-				service, err := c.Services(ns).Get(name)
+				service, err := c.Core().Services(ns).Get(name)
 				Expect(err).NotTo(HaveOccurred())
 
 				if len(service.Spec.Ports) != 1 {
@@ -773,7 +773,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 		})
 
 		It("should be able to retrieve and filter logs [Conformance]", func() {
-			framework.SkipUnlessServerVersionGTE(extendedPodLogFilterVersion, c)
+			framework.SkipUnlessServerVersionGTE(extendedPodLogFilterVersion, c.Discovery())
 
 			// Split("something\n", "\n") returns ["something", ""], so
 			// strip trailing newline first
@@ -873,7 +873,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 
 		BeforeEach(func() {
 			nsFlag = fmt.Sprintf("--namespace=%v", ns)
-			gte, err := framework.ServerVersionGTE(deploymentsVersion, c)
+			gte, err := framework.ServerVersionGTE(deploymentsVersion, c.Discovery())
 			if err != nil {
 				framework.Failf("Failed to get server version: %v", err)
 			}
@@ -924,7 +924,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 			By("running the image " + nginxImage)
 			framework.RunKubectlOrDie("run", rcName, "--image="+nginxImage, "--generator=run/v1", nsFlag)
 			By("verifying the rc " + rcName + " was created")
-			rc, err := c.ReplicationControllers(ns).Get(rcName)
+			rc, err := c.Core().ReplicationControllers(ns).Get(rcName)
 			if err != nil {
 				framework.Failf("Failed getting rc %s: %v", rcName, err)
 			}
@@ -964,10 +964,10 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 	framework.KubeDescribe("Kubectl rolling-update", func() {
 		var nsFlag string
 		var rcName string
-		var c *client.Client
+		var c clientset.Interface
 
 		BeforeEach(func() {
-			c = f.Client
+			c = f.ClientSet
 			nsFlag = fmt.Sprintf("--namespace=%v", ns)
 			rcName = "e2e-test-nginx-rc"
 		})
@@ -980,7 +980,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 			By("running the image " + nginxImage)
 			framework.RunKubectlOrDie("run", rcName, "--image="+nginxImage, "--generator=run/v1", nsFlag)
 			By("verifying the rc " + rcName + " was created")
-			rc, err := c.ReplicationControllers(ns).Get(rcName)
+			rc, err := c.Core().ReplicationControllers(ns).Get(rcName)
 			if err != nil {
 				framework.Failf("Failed getting rc %s: %v", rcName, err)
 			}
@@ -1021,7 +1021,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 		})
 
 		It("should create a deployment from an image [Conformance]", func() {
-			framework.SkipUnlessServerVersionGTE(deploymentsVersion, c)
+			framework.SkipUnlessServerVersionGTE(deploymentsVersion, c.Discovery())
 
 			By("running the image " + nginxImage)
 			framework.RunKubectlOrDie("run", dName, "--image="+nginxImage, "--generator=deployment/v1beta1", nsFlag)
@@ -1063,12 +1063,12 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 		})
 
 		It("should create a job from an image when restart is OnFailure [Conformance]", func() {
-			framework.SkipUnlessServerVersionGTE(jobsVersion, c)
+			framework.SkipUnlessServerVersionGTE(jobsVersion, c.Discovery())
 
 			By("running the image " + nginxImage)
 			framework.RunKubectlOrDie("run", jobName, "--restart=OnFailure", "--generator=job/v1", "--image="+nginxImage, nsFlag)
 			By("verifying the job " + jobName + " was created")
-			job, err := c.Extensions().Jobs(ns).Get(jobName)
+			job, err := c.Batch().Jobs(ns).Get(jobName)
 			if err != nil {
 				framework.Failf("Failed getting job %s: %v", jobName, err)
 			}
@@ -1133,12 +1133,12 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 		})
 
 		It("should create a pod from an image when restart is Never [Conformance]", func() {
-			framework.SkipUnlessServerVersionGTE(jobsVersion, c)
+			framework.SkipUnlessServerVersionGTE(jobsVersion, c.Discovery())
 
 			By("running the image " + nginxImage)
 			framework.RunKubectlOrDie("run", podName, "--restart=Never", "--generator=run-pod/v1", "--image="+nginxImage, nsFlag)
 			By("verifying the pod " + podName + " was created")
-			pod, err := c.Pods(ns).Get(podName)
+			pod, err := c.Core().Pods(ns).Get(podName)
 			if err != nil {
 				framework.Failf("Failed getting pod %s: %v", podName, err)
 			}
@@ -1166,7 +1166,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 		})
 
 		It("should update a single-container pod's image [Conformance]", func() {
-			framework.SkipUnlessServerVersionGTE(jobsVersion, c)
+			framework.SkipUnlessServerVersionGTE(jobsVersion, c.Discovery())
 
 			By("running the image " + nginxImage)
 			framework.RunKubectlOrDie("run", podName, "--generator=run-pod/v1", "--image="+nginxImage, "--labels=run="+podName, nsFlag)
@@ -1189,7 +1189,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 			framework.RunKubectlOrDieInput(podJson, "replace", "-f", "-", nsFlag)
 
 			By("verifying the pod " + podName + " has the right image " + busyboxImage)
-			pod, err := c.Pods(ns).Get(podName)
+			pod, err := c.Core().Pods(ns).Get(podName)
 			if err != nil {
 				framework.Failf("Failed getting deployment %s: %v", podName, err)
 			}
@@ -1208,7 +1208,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 
 			// The rkt runtime doesn't support attach, see #23335
 			framework.SkipIfContainerRuntimeIs("rkt")
-			framework.SkipUnlessServerVersionGTE(jobsVersion, c)
+			framework.SkipUnlessServerVersionGTE(jobsVersion, c.Discovery())
 
 			By("executing a command with run --rm and attach with stdin")
 			t := time.NewTimer(runJobTimeout)
@@ -1221,7 +1221,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 			Expect(runOutput).To(ContainSubstring("stdin closed"))
 
 			By("verifying the job " + jobName + " was deleted")
-			_, err := c.Extensions().Jobs(ns).Get(jobName)
+			_, err := c.Batch().Jobs(ns).Get(jobName)
 			Expect(err).To(HaveOccurred())
 			Expect(apierrs.IsNotFound(err)).To(BeTrue())
 		})
@@ -1286,7 +1286,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 				Effect: api.TaintEffectNoSchedule,
 			}
 
-			nodes, err := c.Nodes().List(api.ListOptions{})
+			nodes, err := c.Core().Nodes().List(api.ListOptions{})
 			Expect(err).NotTo(HaveOccurred())
 			node := nodes.Items[0]
 			nodeName := node.Name
@@ -1318,7 +1318,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 				Effect: api.TaintEffectNoSchedule,
 			}
 
-			nodes, err := c.Nodes().List(api.ListOptions{})
+			nodes, err := c.Core().Nodes().List(api.ListOptions{})
 			Expect(err).NotTo(HaveOccurred())
 			node := nodes.Items[0]
 			nodeName := node.Name
@@ -1370,7 +1370,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 			framework.RunKubectlOrDie("create", "quota", quotaName, "--hard=pods=1000000,services=1000000", nsFlag)
 
 			By("verifying that the quota was created")
-			quota, err := c.ResourceQuotas(ns).Get(quotaName)
+			quota, err := c.Core().ResourceQuotas(ns).Get(quotaName)
 			if err != nil {
 				framework.Failf("Failed getting quota %s: %v", quotaName, err)
 			}
@@ -1400,7 +1400,7 @@ var _ = framework.KubeDescribe("Kubectl client", func() {
 			framework.RunKubectlOrDie("create", "quota", quotaName, "--hard=pods=1000000", "--scopes=BestEffort,NotTerminating", nsFlag)
 
 			By("verifying that the quota was created")
-			quota, err := c.ResourceQuotas(ns).Get(quotaName)
+			quota, err := c.Core().ResourceQuotas(ns).Get(quotaName)
 			if err != nil {
 				framework.Failf("Failed getting quota %s: %v", quotaName, err)
 			}
@@ -1517,7 +1517,7 @@ func curl(url string) (string, error) {
 	return curlTransport(url, utilnet.SetTransportDefaults(&http.Transport{}))
 }
 
-func validateGuestbookApp(c *client.Client, ns string) {
+func validateGuestbookApp(c clientset.Interface, ns string) {
 	framework.Logf("Waiting for all frontend pods to be Running.")
 	label := labels.SelectorFromSet(labels.Set(map[string]string{"tier": "frontend", "app": "guestbook"}))
 	err := testutils.WaitForPodsWithLabelRunning(c, ns, label)
@@ -1539,7 +1539,7 @@ func validateGuestbookApp(c *client.Client, ns string) {
 }
 
 // Returns whether received expected response from guestbook on time.
-func waitForGuestbookResponse(c *client.Client, cmd, arg, expectedResponse string, timeout time.Duration, ns string) bool {
+func waitForGuestbookResponse(c clientset.Interface, cmd, arg, expectedResponse string, timeout time.Duration, ns string) bool {
 	for start := time.Now(); time.Since(start) < timeout; time.Sleep(5 * time.Second) {
 		res, err := makeRequestToGuestbook(c, cmd, arg, ns)
 		if err == nil && res == expectedResponse {
@@ -1550,8 +1550,8 @@ func waitForGuestbookResponse(c *client.Client, cmd, arg, expectedResponse strin
 	return false
 }
 
-func makeRequestToGuestbook(c *client.Client, cmd, value string, ns string) (string, error) {
+func makeRequestToGuestbook(c clientset.Interface, cmd, value string, ns string) (string, error) {
-	proxyRequest, errProxy := framework.GetServicesProxyRequest(c, c.Get())
+	proxyRequest, errProxy := framework.GetServicesProxyRequest(c, c.Core().RESTClient().Get())
 	if errProxy != nil {
 		return "", errProxy
 	}
@@ -1609,13 +1609,13 @@ func modifyReplicationControllerConfiguration(contents string) io.Reader {
 	return bytes.NewReader(data)
 }
 
-func forEachReplicationController(c *client.Client, ns, selectorKey, selectorValue string, fn func(api.ReplicationController)) {
+func forEachReplicationController(c clientset.Interface, ns, selectorKey, selectorValue string, fn func(api.ReplicationController)) {
 	var rcs *api.ReplicationControllerList
 	var err error
 	for t := time.Now(); time.Since(t) < framework.PodListTimeout; time.Sleep(framework.Poll) {
 		label := labels.SelectorFromSet(labels.Set(map[string]string{selectorKey: selectorValue}))
 		options := api.ListOptions{LabelSelector: label}
-		rcs, err = c.ReplicationControllers(ns).List(options)
+		rcs, err = c.Core().ReplicationControllers(ns).List(options)
 		Expect(err).NotTo(HaveOccurred())
 		if len(rcs.Items) > 0 {
 			break
@@ -1646,18 +1646,18 @@ func validateReplicationControllerConfiguration(rc api.ReplicationController) {
 // getUDData creates a validator function based on the input string (i.e. kitten.jpg).
 // For example, if you send "kitten.jpg", this function verifies that the image jpg = kitten.jpg
 // in the container's json field.
-func getUDData(jpgExpected string, ns string) func(*client.Client, string) error {
+func getUDData(jpgExpected string, ns string) func(clientset.Interface, string) error {
 
 	// getUDData validates data.json in the update-demo (returns nil if data is ok).
-	return func(c *client.Client, podID string) error {
+	return func(c clientset.Interface, podID string) error {
 		framework.Logf("validating pod %s", podID)
-		subResourceProxyAvailable, err := framework.ServerVersionGTE(framework.SubResourcePodProxyVersion, c)
+		subResourceProxyAvailable, err := framework.ServerVersionGTE(framework.SubResourcePodProxyVersion, c.Discovery())
 		if err != nil {
 			return err
 		}
 		var body []byte
 		if subResourceProxyAvailable {
-			body, err = c.Get().
+			body, err = c.Core().RESTClient().Get().
 				Namespace(ns).
 				Resource("pods").
 				SubResource("proxy").
@@ -1666,7 +1666,7 @@ func getUDData(jpgExpected string, ns string) func(*client.Client, string) error
 				Do().
 				Raw()
 		} else {
-			body, err = c.Get().
+			body, err = c.Core().RESTClient().Get().
 				Prefix("proxy").
 				Namespace(ns).
 				Resource("pods").
@@ -1692,7 +1692,7 @@ func getUDData(jpgExpected string, ns string) func(*client.Client, string) error
 	}
 }
 
-func noOpValidatorFn(c *client.Client, podID string) error { return nil }
+func noOpValidatorFn(c clientset.Interface, podID string) error { return nil }
 
 // newBlockingReader returns a reader that allows reading the given string,
 // then blocks until Close() is called on the returned closer.

test/e2e/kubelet.go

@@ -22,7 +22,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/uuid"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -44,7 +44,7 @@ const (
 
 // getPodMatches returns a set of pod names on the given node that matches the
 // podNamePrefix and namespace.
-func getPodMatches(c *client.Client, nodeName string, podNamePrefix string, namespace string) sets.String {
+func getPodMatches(c clientset.Interface, nodeName string, podNamePrefix string, namespace string) sets.String {
 	matches := sets.NewString()
 	framework.Logf("Checking pods on node %v via /runningpods endpoint", nodeName)
 	runningPods, err := framework.GetKubeletPods(c, nodeName)
@@ -68,7 +68,7 @@ func getPodMatches(c *client.Client, nodeName string, podNamePrefix string, name
 // information; they are reconstructed by examining the container runtime. In
 // the scope of this test, we do not expect pod naming conflicts so
 // podNamePrefix should be sufficient to identify the pods.
-func waitTillNPodsRunningOnNodes(c *client.Client, nodeNames sets.String, podNamePrefix string, namespace string, targetNumPods int, timeout time.Duration) error {
+func waitTillNPodsRunningOnNodes(c clientset.Interface, nodeNames sets.String, podNamePrefix string, namespace string, targetNumPods int, timeout time.Duration) error {
 	return wait.Poll(pollInterval, timeout, func() (bool, error) {
 		matchCh := make(chan sets.String, len(nodeNames))
 		for _, item := range nodeNames.List() {
@@ -95,13 +95,13 @@ func waitTillNPodsRunningOnNodes(c *client.Client, nodeNames sets.String, podNam
 // In case a given label already exists, it overwrites it. If label to remove doesn't exist
 // it silently ignores it.
 // TODO: migrate to use framework.AddOrUpdateLabelOnNode/framework.RemoveLabelOffNode
-func updateNodeLabels(c *client.Client, nodeNames sets.String, toAdd, toRemove map[string]string) {
+func updateNodeLabels(c clientset.Interface, nodeNames sets.String, toAdd, toRemove map[string]string) {
 	const maxRetries = 5
 	for nodeName := range nodeNames {
 		var node *api.Node
 		var err error
 		for i := 0; i < maxRetries; i++ {
-			node, err = c.Nodes().Get(nodeName)
+			node, err = c.Core().Nodes().Get(nodeName)
 			if err != nil {
 				framework.Logf("Error getting node %s: %v", nodeName, err)
 				continue
@@ -116,7 +116,7 @@ func updateNodeLabels(c *client.Client, nodeNames sets.String, toAdd, toRemove m
 					delete(node.ObjectMeta.Labels, k)
 				}
 			}
-			_, err = c.Nodes().Update(node)
+			_, err = c.Core().Nodes().Update(node)
 			if err != nil {
 				framework.Logf("Error updating node %s: %v", nodeName, err)
 			} else {
@@ -128,7 +128,7 @@ func updateNodeLabels(c *client.Client, nodeNames sets.String, toAdd, toRemove m
 }
 
 var _ = framework.KubeDescribe("kubelet", func() {
-	var c *client.Client
+	var c clientset.Interface
 	var numNodes int
 	var nodeNames sets.String
 	var nodeLabels map[string]string
@@ -136,8 +136,8 @@ var _ = framework.KubeDescribe("kubelet", func() {
 	var resourceMonitor *framework.ResourceMonitor
 
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
-		nodes := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
+		nodes := framework.GetReadySchedulableNodesOrDie(c)
 		numNodes = len(nodes.Items)
 		nodeNames = sets.NewString()
 		// If there are a lot of nodes, we don't want to use all of them
@@ -158,7 +158,7 @@ var _ = framework.KubeDescribe("kubelet", func() {
 
 		// Start resourceMonitor only in small clusters.
 		if len(nodes.Items) <= maxNodesToCheck {
-			resourceMonitor = framework.NewResourceMonitor(f.Client, framework.TargetContainers(), containerStatsPollingInterval)
+			resourceMonitor = framework.NewResourceMonitor(f.ClientSet, framework.TargetContainers(), containerStatsPollingInterval)
 			resourceMonitor.Start()
 		}
 	})
@@ -188,10 +188,10 @@ var _ = framework.KubeDescribe("kubelet", func() {
 				rcName := fmt.Sprintf("cleanup%d-%s", totalPods, string(uuid.NewUUID()))
 
 				Expect(framework.RunRC(testutils.RCConfig{
-					Client:       f.Client,
+					Client:       f.ClientSet,
 					Name:         rcName,
 					Namespace:    f.Namespace.Name,
-					Image:        framework.GetPauseImageName(f.Client),
+					Image:        framework.GetPauseImageName(f.ClientSet),
 					Replicas:     totalPods,
 					NodeSelector: nodeLabels,
 				})).NotTo(HaveOccurred())
@@ -199,14 +199,14 @@ var _ = framework.KubeDescribe("kubelet", func() {
 				// running on the nodes according to kubelet. The timeout is set to
 				// only 30 seconds here because framework.RunRC already waited for all pods to
 				// transition to the running status.
-				Expect(waitTillNPodsRunningOnNodes(f.Client, nodeNames, rcName, f.Namespace.Name, totalPods,
+				Expect(waitTillNPodsRunningOnNodes(f.ClientSet, nodeNames, rcName, f.Namespace.Name, totalPods,
 					time.Second*30)).NotTo(HaveOccurred())
 				if resourceMonitor != nil {
 					resourceMonitor.LogLatest()
 				}
 
 				By("Deleting the RC")
-				framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, rcName)
+				framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, rcName)
 				// Check that the pods really are gone by querying /runningpods on the
 				// node. The /runningpods handler checks the container runtime (or its
 				// cache) and  returns a list of running pods. Some possible causes of
@@ -215,7 +215,7 @@ var _ = framework.KubeDescribe("kubelet", func() {
 				//   - a bug in graceful termination (if it is enabled)
 				//   - docker slow to delete pods (or resource problems causing slowness)
 				start := time.Now()
-				Expect(waitTillNPodsRunningOnNodes(f.Client, nodeNames, rcName, f.Namespace.Name, 0,
+				Expect(waitTillNPodsRunningOnNodes(f.ClientSet, nodeNames, rcName, f.Namespace.Name, 0,
 					itArg.timeout)).NotTo(HaveOccurred())
 				framework.Logf("Deleting %d pods on %d nodes completed in %v after the RC was deleted", totalPods, len(nodeNames),
 					time.Since(start))

test/e2e/kubelet_perf.go

@@ -22,7 +22,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/stats"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/uuid"
@@ -50,7 +50,7 @@ type resourceTest struct {
 	memLimits   framework.ResourceUsagePerContainer
 }
 
-func logPodsOnNodes(c *client.Client, nodeNames []string) {
+func logPodsOnNodes(c clientset.Interface, nodeNames []string) {
 	for _, n := range nodeNames {
 		podList, err := framework.GetKubeletRunningPods(c, n)
 		if err != nil {
@@ -70,10 +70,10 @@ func runResourceTrackingTest(f *framework.Framework, podsPerNode int, nodeNames
 
 	// TODO: Use a more realistic workload
 	Expect(framework.RunRC(testutils.RCConfig{
-		Client:    f.Client,
+		Client:    f.ClientSet,
 		Name:      rcName,
 		Namespace: f.Namespace.Name,
-		Image:     framework.GetPauseImageName(f.Client),
+		Image:     framework.GetPauseImageName(f.ClientSet),
 		Replicas:  totalPods,
 	})).NotTo(HaveOccurred())
 
@@ -96,18 +96,18 @@ func runResourceTrackingTest(f *framework.Framework, podsPerNode int, nodeNames
 		} else {
 			time.Sleep(reportingPeriod)
 		}
-		logPodsOnNodes(f.Client, nodeNames.List())
+		logPodsOnNodes(f.ClientSet, nodeNames.List())
 	}
 
 	By("Reporting overall resource usage")
-	logPodsOnNodes(f.Client, nodeNames.List())
+	logPodsOnNodes(f.ClientSet, nodeNames.List())
 	usageSummary, err := rm.GetLatest()
 	Expect(err).NotTo(HaveOccurred())
 	// TODO(random-liu): Remove the original log when we migrate to new perfdash
 	framework.Logf("%s", rm.FormatResourceUsage(usageSummary))
 	// Log perf result
 	framework.PrintPerfData(framework.ResourceUsageToPerfData(rm.GetMasterNodeLatest(usageSummary)))
-	verifyMemoryLimits(f.Client, expectedMemory, usageSummary)
+	verifyMemoryLimits(f.ClientSet, expectedMemory, usageSummary)
 
 	cpuSummary := rm.GetCPUSummary()
 	framework.Logf("%s", rm.FormatCPUSummary(cpuSummary))
@@ -116,10 +116,10 @@ func runResourceTrackingTest(f *framework.Framework, podsPerNode int, nodeNames
 	verifyCPULimits(expectedCPU, cpuSummary)
 
 	By("Deleting the RC")
-	framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, rcName)
+	framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, rcName)
 }
 
-func verifyMemoryLimits(c *client.Client, expected framework.ResourceUsagePerContainer, actual framework.ResourceUsagePerNode) {
+func verifyMemoryLimits(c clientset.Interface, expected framework.ResourceUsagePerContainer, actual framework.ResourceUsagePerNode) {
 	if expected == nil {
 		return
 	}
@@ -200,16 +200,16 @@ var _ = framework.KubeDescribe("Kubelet [Serial] [Slow]", func() {
 		// Wait until image prepull pod has completed so that they wouldn't
 		// affect the runtime cpu usage. Fail the test if prepulling cannot
 		// finish in time.
-		if err := framework.WaitForPodsSuccess(f.Client, api.NamespaceSystem, framework.ImagePullerLabels, imagePrePullingLongTimeout); err != nil {
+		if err := framework.WaitForPodsSuccess(f.ClientSet, api.NamespaceSystem, framework.ImagePullerLabels, imagePrePullingLongTimeout); err != nil {
-			framework.Failf("Image puller didn't complete in %v, not running resource usage test since the metrics might be adulterated", imagePrePullingLongTimeout)
+			framework.Failf("Image puller didn't complete in %v, not running resource usage test since the metrics might be adultrated", imagePrePullingLongTimeout)
 		}
 		nodes := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
 		nodeNames = sets.NewString()
 		for _, node := range nodes.Items {
 			nodeNames.Insert(node.Name)
 		}
-		om = framework.NewRuntimeOperationMonitor(f.Client)
+		om = framework.NewRuntimeOperationMonitor(f.ClientSet)
-		rm = framework.NewResourceMonitor(f.Client, framework.TargetContainers(), containerStatsPollingPeriod)
+		rm = framework.NewResourceMonitor(f.ClientSet, framework.TargetContainers(), containerStatsPollingPeriod)
 		rm.Start()
 	})
 

test/e2e/limit_range.go

@@ -42,11 +42,11 @@ var _ = framework.KubeDescribe("LimitRange", func() {
 			min, max,
 			defaultLimit, defaultRequest,
 			maxLimitRequestRatio)
-		limitRange, err := f.Client.LimitRanges(f.Namespace.Name).Create(limitRange)
+		limitRange, err := f.ClientSet.Core().LimitRanges(f.Namespace.Name).Create(limitRange)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Fetching the LimitRange to ensure it has proper values")
-		limitRange, err = f.Client.LimitRanges(f.Namespace.Name).Get(limitRange.Name)
+		limitRange, err = f.ClientSet.Core().LimitRanges(f.Namespace.Name).Get(limitRange.Name)
 		expected := api.ResourceRequirements{Requests: defaultRequest, Limits: defaultLimit}
 		actual := api.ResourceRequirements{Requests: limitRange.Spec.Limits[0].DefaultRequest, Limits: limitRange.Spec.Limits[0].Default}
 		err = equalResourceRequirement(expected, actual)
@@ -54,11 +54,11 @@ var _ = framework.KubeDescribe("LimitRange", func() {
 
 		By("Creating a Pod with no resource requirements")
 		pod := newTestPod(f, "pod-no-resources", api.ResourceList{}, api.ResourceList{})
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring Pod has resource requirements applied from LimitRange")
-		pod, err = f.Client.Pods(f.Namespace.Name).Get(pod.Name)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Get(pod.Name)
 		Expect(err).NotTo(HaveOccurred())
 		for i := range pod.Spec.Containers {
 			err = equalResourceRequirement(expected, pod.Spec.Containers[i].Resources)
@@ -71,11 +71,11 @@ var _ = framework.KubeDescribe("LimitRange", func() {
 
 		By("Creating a Pod with partial resource requirements")
 		pod = newTestPod(f, "pod-partial-resources", getResourceList("", "150Mi"), getResourceList("300m", ""))
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring Pod has merged resource requirements applied from LimitRange")
-		pod, err = f.Client.Pods(f.Namespace.Name).Get(pod.Name)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Get(pod.Name)
 		Expect(err).NotTo(HaveOccurred())
 		// This is an interesting case, so it's worth a comment
 		// If you specify a Limit, and no Request, the Limit will default to the Request
@@ -92,12 +92,12 @@ var _ = framework.KubeDescribe("LimitRange", func() {
 
 		By("Failing to create a Pod with less than min resources")
 		pod = newTestPod(f, podName, getResourceList("10m", "50Mi"), api.ResourceList{})
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).To(HaveOccurred())
 
 		By("Failing to create a Pod with more than max resources")
 		pod = newTestPod(f, podName, getResourceList("600m", "600Mi"), api.ResourceList{})
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).To(HaveOccurred())
 	})
 
@@ -176,7 +176,7 @@ func newTestPod(f *framework.Framework, name string, requests api.ResourceList,
 			Containers: []api.Container{
 				{
 					Name:  "pause",
-					Image: framework.GetPauseImageName(f.Client),
+					Image: framework.GetPauseImageName(f.ClientSet),
 					Resources: api.ResourceRequirements{
 						Requests: requests,
 						Limits:   limits,

test/e2e/load.go

@@ -29,10 +29,8 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
 	"k8s.io/kubernetes/pkg/client/restclient"
 	"k8s.io/kubernetes/pkg/client/transport"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/intstr"
 	utilnet "k8s.io/kubernetes/pkg/util/net"
@@ -64,7 +62,7 @@ const (
 // To run this suite you must explicitly ask for it by setting the
 // -t/--test flag or ginkgo.focus flag.
 var _ = framework.KubeDescribe("Load capacity", func() {
-	var c *client.Client
+	var clientset internalclientset.Interface
 	var nodeCount int
 	var ns string
 	var configs []*testutils.RCConfig
@@ -74,7 +72,7 @@ var _ = framework.KubeDescribe("Load capacity", func() {
 	// TODO add flag that allows to skip cleanup on failure
 	AfterEach(func() {
 		// Verify latency metrics
-		highLatencyRequests, err := framework.HighLatencyRequests(c)
+		highLatencyRequests, err := framework.HighLatencyRequests(clientset)
 		framework.ExpectNoError(err, "Too many instances metrics above the threshold")
 		Expect(highLatencyRequests).NotTo(BeNumerically(">", 0))
 	})
@@ -99,25 +97,25 @@ var _ = framework.KubeDescribe("Load capacity", func() {
 	f.NamespaceDeletionTimeout = time.Hour
 
 	BeforeEach(func() {
-		c = f.Client
+		clientset = f.ClientSet
 
 		// In large clusters we may get to this point but still have a bunch
 		// of nodes without Routes created. Since this would make a node
 		// unschedulable, we need to wait until all of them are schedulable.
-		framework.ExpectNoError(framework.WaitForAllNodesSchedulable(c))
+		framework.ExpectNoError(framework.WaitForAllNodesSchedulable(clientset))
 
 		ns = f.Namespace.Name
-		nodes := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
+		nodes := framework.GetReadySchedulableNodesOrDie(clientset)
 		nodeCount = len(nodes.Items)
 		Expect(nodeCount).NotTo(BeZero())
 
 		// Terminating a namespace (deleting the remaining objects from it - which
 		// generally means events) can affect the current run. Thus we wait for all
 		// terminating namespace to be finally deleted before starting this test.
-		err := framework.CheckTestingNSDeletedExcept(c, ns)
+		err := framework.CheckTestingNSDeletedExcept(clientset, ns)
 		framework.ExpectNoError(err)
 
-		framework.ExpectNoError(framework.ResetMetrics(c))
+		framework.ExpectNoError(framework.ResetMetrics(clientset))
 	})
 
 	type Load struct {
@@ -153,7 +151,7 @@ var _ = framework.KubeDescribe("Load capacity", func() {
 				framework.Logf("Creating services")
 				services := generateServicesForConfigs(configs)
 				for _, service := range services {
-					_, err := c.Services(service.Namespace).Create(service)
+					_, err := clientset.Core().Services(service.Namespace).Create(service)
 					framework.ExpectNoError(err)
 				}
 				framework.Logf("%v Services created.", len(services))
@@ -203,7 +201,7 @@ var _ = framework.KubeDescribe("Load capacity", func() {
 			if createServices == "true" {
 				framework.Logf("Starting to delete services...")
 				for _, service := range services {
-					err := c.Services(ns).Delete(service.Name)
+					err := clientset.Core().Services(ns).Delete(service.Name, nil)
 					framework.ExpectNoError(err)
 				}
 				framework.Logf("Services deleted")
@@ -223,8 +221,8 @@ func createNamespaces(f *framework.Framework, nodeCount, podsPerNode int) []*api
 	return namespaces
 }
 
-func createClients(numberOfClients int) ([]*client.Client, error) {
+func createClients(numberOfClients int) ([]*internalclientset.Clientset, error) {
-	clients := make([]*client.Client, numberOfClients)
+	clients := make([]*internalclientset.Clientset, numberOfClients)
 	for i := 0; i < numberOfClients; i++ {
 		config, err := framework.LoadConfig()
 		Expect(err).NotTo(HaveOccurred())
@@ -260,7 +258,7 @@ func createClients(numberOfClients int) ([]*client.Client, error) {
 		// Transport field.
 		config.TLSClientConfig = restclient.TLSClientConfig{}
 
-		c, err := client.New(config)
+		c, err := internalclientset.NewForConfig(config)
 		if err != nil {
 			return nil, err
 		}
@@ -385,14 +383,14 @@ func scaleRC(wg *sync.WaitGroup, config *testutils.RCConfig, scalingTime time.Du
 
 	sleepUpTo(scalingTime)
 	newSize := uint(rand.Intn(config.Replicas) + config.Replicas/2)
-	framework.ExpectNoError(framework.ScaleRC(config.Client, coreClientSetFromUnversioned(config.Client), config.Namespace, config.Name, newSize, true),
+	framework.ExpectNoError(framework.ScaleRC(config.Client, config.Namespace, config.Name, newSize, true),
 		fmt.Sprintf("scaling rc %s for the first time", config.Name))
 	selector := labels.SelectorFromSet(labels.Set(map[string]string{"name": config.Name}))
 	options := api.ListOptions{
 		LabelSelector:   selector,
 		ResourceVersion: "0",
 	}
-	_, err := config.Client.Pods(config.Namespace).List(options)
+	_, err := config.Client.Core().Pods(config.Namespace).List(options)
 	framework.ExpectNoError(err, fmt.Sprintf("listing pods from rc %v", config.Name))
 }
 
@@ -413,17 +411,6 @@ func deleteRC(wg *sync.WaitGroup, config *testutils.RCConfig, deletingTime time.
 	if framework.TestContext.GarbageCollectorEnabled {
 		framework.ExpectNoError(framework.DeleteRCAndWaitForGC(config.Client, config.Namespace, config.Name), fmt.Sprintf("deleting rc %s", config.Name))
 	} else {
-		framework.ExpectNoError(framework.DeleteRCAndPods(config.Client, coreClientSetFromUnversioned(config.Client), config.Namespace, config.Name), fmt.Sprintf("deleting rc %s", config.Name))
+		framework.ExpectNoError(framework.DeleteRCAndPods(config.Client, config.Namespace, config.Name), fmt.Sprintf("deleting rc %s", config.Name))
 	}
 }
-
-// coreClientSetFromUnversioned adapts just enough of a a unversioned.Client to work with the scale RC function
-func coreClientSetFromUnversioned(c *client.Client) internalclientset.Interface {
-	var clientset internalclientset.Clientset
-	if c != nil {
-		clientset.CoreClient = unversionedcore.New(c.RESTClient)
-	} else {
-		clientset.CoreClient = unversionedcore.New(nil)
-	}
-	return &clientset
-}

test/e2e/logging_soak.go

@@ -18,14 +18,15 @@ package e2e
 
 import (
 	"fmt"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/test/e2e/framework"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/test/e2e/framework"
 )
 
 var _ = framework.KubeDescribe("Logging soak [Performance] [Slow] [Disruptive]", func() {

test/e2e/mesos.go

@@ -21,7 +21,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -32,17 +32,17 @@ import (
 
 var _ = framework.KubeDescribe("Mesos", func() {
 	f := framework.NewDefaultFramework("pods")
-	var c *client.Client
+	var c clientset.Interface
 	var ns string
 
 	BeforeEach(func() {
 		framework.SkipUnlessProviderIs("mesos/docker")
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 	})
 
 	It("applies slave attributes as labels", func() {
-		nodeClient := f.Client.Nodes()
+		nodeClient := f.ClientSet.Core().Nodes()
 
 		rackA := labels.SelectorFromSet(map[string]string{"k8s.mesosphere.io/attribute-rack": "1"})
 		options := api.ListOptions{LabelSelector: rackA}
@@ -62,11 +62,10 @@ var _ = framework.KubeDescribe("Mesos", func() {
 	})
 
 	It("starts static pods on every node in the mesos cluster", func() {
-		client := f.Client
+		client := f.ClientSet
 		framework.ExpectNoError(framework.AllNodesReady(client, wait.ForeverTestTimeout), "all nodes ready")
 
-		nodelist := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
+		nodelist := framework.GetReadySchedulableNodesOrDie(client)
-
 		const ns = "static-pods"
 		numpods := int32(len(nodelist.Items))
 		framework.ExpectNoError(framework.WaitForPodsRunningReady(client, ns, numpods, wait.ForeverTestTimeout, map[string]string{}),
@@ -80,7 +79,7 @@ var _ = framework.KubeDescribe("Mesos", func() {
 		// scheduled onto it.
 		By("Trying to launch a pod with a label to get a node which can launch it.")
 		podName := "with-label"
-		_, err := c.Pods(ns).Create(&api.Pod{
+		_, err := c.Core().Pods(ns).Create(&api.Pod{
 			TypeMeta: unversioned.TypeMeta{
 				Kind: "Pod",
 			},
@@ -94,7 +93,7 @@ var _ = framework.KubeDescribe("Mesos", func() {
 				Containers: []api.Container{
 					{
 						Name:  podName,
-						Image: framework.GetPauseImageName(f.Client),
+						Image: framework.GetPauseImageName(f.ClientSet),
 					},
 				},
 			},
@@ -102,10 +101,10 @@ var _ = framework.KubeDescribe("Mesos", func() {
 		framework.ExpectNoError(err)
 
 		framework.ExpectNoError(framework.WaitForPodNameRunningInNamespace(c, podName, ns))
-		pod, err := c.Pods(ns).Get(podName)
+		pod, err := c.Core().Pods(ns).Get(podName)
 		framework.ExpectNoError(err)
 
-		nodeClient := f.Client.Nodes()
+		nodeClient := f.ClientSet.Core().Nodes()
 
 		// schedule onto node with rack=2 being assigned to the "public" role
 		rack2 := labels.SelectorFromSet(map[string]string{

test/e2e/metrics_grabber_test.go

@@ -20,7 +20,7 @@ import (
 	"strings"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/metrics"
 	"k8s.io/kubernetes/test/e2e/framework"
 
@@ -30,11 +30,11 @@ import (
 
 var _ = framework.KubeDescribe("MetricsGrabber", func() {
 	f := framework.NewDefaultFramework("metrics-grabber")
-	var c *client.Client
+	var c clientset.Interface
 	var grabber *metrics.MetricsGrabber
 	BeforeEach(func() {
 		var err error
-		c = f.Client
+		c = f.ClientSet
 		framework.ExpectNoError(err)
 		grabber, err = metrics.NewMetricsGrabber(c, true, true, true, true)
 		framework.ExpectNoError(err)
@@ -59,7 +59,7 @@ var _ = framework.KubeDescribe("MetricsGrabber", func() {
 	It("should grab all metrics from a Scheduler.", func() {
 		By("Proxying to Pod through the API server")
 		// Check if master Node is registered
-		nodes, err := c.Nodes().List(api.ListOptions{})
+		nodes, err := c.Core().Nodes().List(api.ListOptions{})
 		framework.ExpectNoError(err)
 
 		var masterRegistered = false
@@ -80,7 +80,7 @@ var _ = framework.KubeDescribe("MetricsGrabber", func() {
 	It("should grab all metrics from a ControllerManager.", func() {
 		By("Proxying to Pod through the API server")
 		// Check if master Node is registered
-		nodes, err := c.Nodes().List(api.ListOptions{})
+		nodes, err := c.Core().Nodes().List(api.ListOptions{})
 		framework.ExpectNoError(err)
 
 		var masterRegistered = false

test/e2e/monitoring.go

@@ -24,7 +24,7 @@ import (
 
 	influxdb "github.com/influxdata/influxdb/client"
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/test/e2e/framework"
 
@@ -39,7 +39,7 @@ var _ = framework.KubeDescribe("Monitoring", func() {
 	})
 
 	It("should verify monitoring pods and all cluster nodes are available on influxdb using heapster.", func() {
-		testMonitoringUsingHeapsterInfluxdb(f.Client)
+		testMonitoringUsingHeapsterInfluxdb(f.ClientSet)
 	})
 })
 
@@ -61,8 +61,8 @@ var (
 )
 
 // Query sends a command to the server and returns the Response
-func Query(c *client.Client, query string) (*influxdb.Response, error) {
+func Query(c clientset.Interface, query string) (*influxdb.Response, error) {
-	result, err := c.Get().
+	result, err := c.Core().RESTClient().Get().
 		Prefix("proxy").
 		Namespace("kube-system").
 		Resource("services").
@@ -89,7 +89,7 @@ func Query(c *client.Client, query string) (*influxdb.Response, error) {
 	return &response, nil
 }
 
-func verifyExpectedRcsExistAndGetExpectedPods(c *client.Client) ([]string, error) {
+func verifyExpectedRcsExistAndGetExpectedPods(c clientset.Interface) ([]string, error) {
 	expectedPods := []string{}
 	// Iterate over the labels that identify the replication controllers that we
 	// want to check. The rcLabels contains the value values for the k8s-app key
@@ -102,11 +102,11 @@ func verifyExpectedRcsExistAndGetExpectedPods(c *client.Client) ([]string, error
 	for _, rcLabel := range rcLabels {
 		selector := labels.Set{"k8s-app": rcLabel}.AsSelector()
 		options := api.ListOptions{LabelSelector: selector}
-		deploymentList, err := c.Deployments(api.NamespaceSystem).List(options)
+		deploymentList, err := c.Extensions().Deployments(api.NamespaceSystem).List(options)
 		if err != nil {
 			return nil, err
 		}
-		rcList, err := c.ReplicationControllers(api.NamespaceSystem).List(options)
+		rcList, err := c.Core().ReplicationControllers(api.NamespaceSystem).List(options)
 		if err != nil {
 			return nil, err
 		}
@@ -122,7 +122,7 @@ func verifyExpectedRcsExistAndGetExpectedPods(c *client.Client) ([]string, error
 		for _, rc := range rcList.Items {
 			selector := labels.Set(rc.Spec.Selector).AsSelector()
 			options := api.ListOptions{LabelSelector: selector}
-			podList, err := c.Pods(api.NamespaceSystem).List(options)
+			podList, err := c.Core().Pods(api.NamespaceSystem).List(options)
 			if err != nil {
 				return nil, err
 			}
@@ -137,7 +137,7 @@ func verifyExpectedRcsExistAndGetExpectedPods(c *client.Client) ([]string, error
 		for _, rc := range deploymentList.Items {
 			selector := labels.Set(rc.Spec.Selector.MatchLabels).AsSelector()
 			options := api.ListOptions{LabelSelector: selector}
-			podList, err := c.Pods(api.NamespaceSystem).List(options)
+			podList, err := c.Core().Pods(api.NamespaceSystem).List(options)
 			if err != nil {
 				return nil, err
 			}
@@ -152,7 +152,7 @@ func verifyExpectedRcsExistAndGetExpectedPods(c *client.Client) ([]string, error
 		for _, ps := range psList.Items {
 			selector := labels.Set(ps.Spec.Selector.MatchLabels).AsSelector()
 			options := api.ListOptions{LabelSelector: selector}
-			podList, err := c.Pods(api.NamespaceSystem).List(options)
+			podList, err := c.Core().Pods(api.NamespaceSystem).List(options)
 			if err != nil {
 				return nil, err
 			}
@@ -167,8 +167,8 @@ func verifyExpectedRcsExistAndGetExpectedPods(c *client.Client) ([]string, error
 	return expectedPods, nil
 }
 
-func expectedServicesExist(c *client.Client) error {
+func expectedServicesExist(c clientset.Interface) error {
-	serviceList, err := c.Services(api.NamespaceSystem).List(api.ListOptions{})
+	serviceList, err := c.Core().Services(api.NamespaceSystem).List(api.ListOptions{})
 	if err != nil {
 		return err
 	}
@@ -185,9 +185,9 @@ func expectedServicesExist(c *client.Client) error {
 	return nil
 }
 
-func getAllNodesInCluster(c *client.Client) ([]string, error) {
+func getAllNodesInCluster(c clientset.Interface) ([]string, error) {
 	// It should be OK to list unschedulable Nodes here.
-	nodeList, err := c.Nodes().List(api.ListOptions{})
+	nodeList, err := c.Core().Nodes().List(api.ListOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -198,7 +198,7 @@ func getAllNodesInCluster(c *client.Client) ([]string, error) {
 	return result, nil
 }
 
-func getInfluxdbData(c *client.Client, query string, tag string) (map[string]bool, error) {
+func getInfluxdbData(c clientset.Interface, query string, tag string) (map[string]bool, error) {
 	response, err := Query(c, query)
 	if err != nil {
 		return nil, err
@@ -232,7 +232,7 @@ func expectedItemsExist(expectedItems []string, actualItems map[string]bool) boo
 	return true
 }
 
-func validatePodsAndNodes(c *client.Client, expectedPods, expectedNodes []string) bool {
+func validatePodsAndNodes(c clientset.Interface, expectedPods, expectedNodes []string) bool {
 	pods, err := getInfluxdbData(c, podlistQuery, "pod_id")
 	if err != nil {
 		// We don't fail the test here because the influxdb service might still not be running.
@@ -255,7 +255,7 @@ func validatePodsAndNodes(c *client.Client, expectedPods, expectedNodes []string
 	return true
 }
 
-func testMonitoringUsingHeapsterInfluxdb(c *client.Client) {
+func testMonitoringUsingHeapsterInfluxdb(c clientset.Interface) {
 	// Check if heapster pods and services are up.
 	expectedPods, err := verifyExpectedRcsExistAndGetExpectedPods(c)
 	framework.ExpectNoError(err)
@@ -279,10 +279,10 @@ func testMonitoringUsingHeapsterInfluxdb(c *client.Client) {
 	framework.Failf("monitoring using heapster and influxdb test failed")
 }
 
-func printDebugInfo(c *client.Client) {
+func printDebugInfo(c clientset.Interface) {
 	set := labels.Set{"k8s-app": "heapster"}
 	options := api.ListOptions{LabelSelector: set.AsSelector()}
-	podList, err := c.Pods(api.NamespaceSystem).List(options)
+	podList, err := c.Core().Pods(api.NamespaceSystem).List(options)
 	if err != nil {
 		framework.Logf("Error while listing pods %v", err)
 		return

test/e2e/namespace.go

@@ -51,7 +51,7 @@ func extinguish(f *framework.Framework, totalNS int, maxAllowedAfterDel int, max
 	//Wait 10 seconds, then SEND delete requests for all the namespaces.
 	By("Waiting 10 seconds")
 	time.Sleep(time.Duration(10 * time.Second))
-	deleted, err := framework.DeleteNamespaces(f.Client, []string{"nslifetest"}, nil /* skipFilter */)
+	deleted, err := framework.DeleteNamespaces(f.ClientSet, []string{"nslifetest"}, nil /* skipFilter */)
 	Expect(err).NotTo(HaveOccurred())
 	Expect(len(deleted)).To(Equal(totalNS))
 
@@ -60,7 +60,7 @@ func extinguish(f *framework.Framework, totalNS int, maxAllowedAfterDel int, max
 	framework.ExpectNoError(wait.Poll(2*time.Second, time.Duration(maxSeconds)*time.Second,
 		func() (bool, error) {
 			var cnt = 0
-			nsList, err := f.Client.Namespaces().List(api.ListOptions{})
+			nsList, err := f.ClientSet.Core().Namespaces().List(api.ListOptions{})
 			if err != nil {
 				return false, err
 			}
@@ -85,7 +85,7 @@ func ensurePodsAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Waiting for a default service account to be provisioned in namespace")
-	err = framework.WaitForDefaultServiceAccountInNamespace(f.Client, namespace.Name)
+	err = framework.WaitForDefaultServiceAccountInNamespace(f.ClientSet, namespace.Name)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Creating a pod in the namespace")
@@ -97,26 +97,26 @@ func ensurePodsAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 			Containers: []api.Container{
 				{
 					Name:  "nginx",
-					Image: framework.GetPauseImageName(f.Client),
+					Image: framework.GetPauseImageName(f.ClientSet),
 				},
 			},
 		},
 	}
-	pod, err = f.Client.Pods(namespace.Name).Create(pod)
+	pod, err = f.ClientSet.Core().Pods(namespace.Name).Create(pod)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Waiting for the pod to have running status")
-	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.Client, pod))
+	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.ClientSet, pod))
 
 	By("Deleting the namespace")
-	err = f.Client.Namespaces().Delete(namespace.Name)
+	err = f.ClientSet.Core().Namespaces().Delete(namespace.Name, nil)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Waiting for the namespace to be removed.")
 	maxWaitSeconds := int64(60) + *pod.Spec.TerminationGracePeriodSeconds
 	framework.ExpectNoError(wait.Poll(1*time.Second, time.Duration(maxWaitSeconds)*time.Second,
 		func() (bool, error) {
-			_, err = f.Client.Namespaces().Get(namespace.Name)
+			_, err = f.ClientSet.Core().Namespaces().Get(namespace.Name)
 			if err != nil && errors.IsNotFound(err) {
 				return true, nil
 			}
@@ -124,7 +124,7 @@ func ensurePodsAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 		}))
 
 	By("Verifying there is no pod in the namespace")
-	_, err = f.Client.Pods(namespace.Name).Get(pod.Name)
+	_, err = f.ClientSet.Core().Pods(namespace.Name).Get(pod.Name)
 	Expect(err).To(HaveOccurred())
 }
 
@@ -136,7 +136,7 @@ func ensureServicesAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Waiting for a default service account to be provisioned in namespace")
-	err = framework.WaitForDefaultServiceAccountInNamespace(f.Client, namespace.Name)
+	err = framework.WaitForDefaultServiceAccountInNamespace(f.ClientSet, namespace.Name)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Creating a service in the namespace")
@@ -157,18 +157,18 @@ func ensureServicesAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 			}},
 		},
 	}
-	service, err = f.Client.Services(namespace.Name).Create(service)
+	service, err = f.ClientSet.Core().Services(namespace.Name).Create(service)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Deleting the namespace")
-	err = f.Client.Namespaces().Delete(namespace.Name)
+	err = f.ClientSet.Core().Namespaces().Delete(namespace.Name, nil)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Waiting for the namespace to be removed.")
 	maxWaitSeconds := int64(60)
 	framework.ExpectNoError(wait.Poll(1*time.Second, time.Duration(maxWaitSeconds)*time.Second,
 		func() (bool, error) {
-			_, err = f.Client.Namespaces().Get(namespace.Name)
+			_, err = f.ClientSet.Core().Namespaces().Get(namespace.Name)
 			if err != nil && errors.IsNotFound(err) {
 				return true, nil
 			}
@@ -176,7 +176,7 @@ func ensureServicesAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 		}))
 
 	By("Verifying there is no service in the namespace")
-	_, err = f.Client.Services(namespace.Name).Get(service.Name)
+	_, err = f.ClientSet.Core().Services(namespace.Name).Get(service.Name)
 	Expect(err).To(HaveOccurred())
 }
 

test/e2e/networking.go

@@ -64,7 +64,7 @@ var _ = framework.KubeDescribe("Networking", func() {
 		}
 		for _, test := range tests {
 			By(fmt.Sprintf("testing: %s", test.path))
-			data, err := f.Client.RESTClient.Get().
+			data, err := f.ClientSet.Core().RESTClient().Get().
 				AbsPath(test.path).
 				DoRaw()
 			if err != nil {

test/e2e/node_problem_detector.go

@@ -22,7 +22,8 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
+	coreclientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/system"
@@ -41,11 +42,11 @@ var _ = framework.KubeDescribe("NodeProblemDetector", func() {
 		image          = "gcr.io/google_containers/node-problem-detector:v0.1"
 	)
 	f := framework.NewDefaultFramework("node-problem-detector")
-	var c *client.Client
+	var c clientset.Interface
 	var uid string
 	var ns, name, configName, eventNamespace string
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 		uid = string(uuid.NewUUID())
 		name = "node-problem-detector-" + uid
@@ -116,7 +117,7 @@ var _ = framework.KubeDescribe("NodeProblemDetector", func() {
 				]
 			}`
 			By("Get a non master node to run the pod")
-			nodes, err := c.Nodes().List(api.ListOptions{})
+			nodes, err := c.Core().Nodes().List(api.ListOptions{})
 			Expect(err).NotTo(HaveOccurred())
 			node = nil
 			for _, n := range nodes.Items {
@@ -139,7 +140,7 @@ var _ = framework.KubeDescribe("NodeProblemDetector", func() {
 			cmd := fmt.Sprintf("mkdir %s; > %s/%s", tmpDir, tmpDir, logFile)
 			Expect(framework.IssueSSHCommand(cmd, framework.TestContext.Provider, node)).To(Succeed())
 			By("Create config map for the node problem detector")
-			_, err = c.ConfigMaps(ns).Create(&api.ConfigMap{
+			_, err = c.Core().ConfigMaps(ns).Create(&api.ConfigMap{
 				ObjectMeta: api.ObjectMeta{
 					Name: configName,
 				},
@@ -147,7 +148,7 @@ var _ = framework.KubeDescribe("NodeProblemDetector", func() {
 			})
 			Expect(err).NotTo(HaveOccurred())
 			By("Create the node problem detector")
-			_, err = c.Pods(ns).Create(&api.Pod{
+			_, err = c.Core().Pods(ns).Create(&api.Pod{
 				ObjectMeta: api.ObjectMeta{
 					Name: name,
 				},
@@ -197,11 +198,11 @@ var _ = framework.KubeDescribe("NodeProblemDetector", func() {
 		It("should generate node condition and events for corresponding errors", func() {
 			By("Make sure no events are generated")
 			Consistently(func() error {
-				return verifyNoEvents(c.Events(eventNamespace), eventListOptions)
+				return verifyNoEvents(c.Core().Events(eventNamespace), eventListOptions)
 			}, pollConsistent, pollInterval).Should(Succeed())
 			By("Make sure the default node condition is generated")
 			Eventually(func() error {
-				return verifyCondition(c.Nodes(), node.Name, condition, api.ConditionFalse, defaultReason, defaultMessage)
+				return verifyCondition(c.Core().Nodes(), node.Name, condition, api.ConditionFalse, defaultReason, defaultMessage)
 			}, pollTimeout, pollInterval).Should(Succeed())
 
 			num := 3
@@ -209,39 +210,39 @@ var _ = framework.KubeDescribe("NodeProblemDetector", func() {
 			Expect(framework.IssueSSHCommand(injectCommand(tempMessage, num), framework.TestContext.Provider, node)).To(Succeed())
 			By(fmt.Sprintf("Wait for %d events generated", num))
 			Eventually(func() error {
-				return verifyEvents(c.Events(eventNamespace), eventListOptions, num, tempReason, tempMessage)
+				return verifyEvents(c.Core().Events(eventNamespace), eventListOptions, num, tempReason, tempMessage)
 			}, pollTimeout, pollInterval).Should(Succeed())
 			By(fmt.Sprintf("Make sure only %d events generated", num))
 			Consistently(func() error {
-				return verifyEvents(c.Events(eventNamespace), eventListOptions, num, tempReason, tempMessage)
+				return verifyEvents(c.Core().Events(eventNamespace), eventListOptions, num, tempReason, tempMessage)
 			}, pollConsistent, pollInterval).Should(Succeed())
 			By("Make sure the node condition is still false")
-			Expect(verifyCondition(c.Nodes(), node.Name, condition, api.ConditionFalse, defaultReason, defaultMessage)).To(Succeed())
+			Expect(verifyCondition(c.Core().Nodes(), node.Name, condition, api.ConditionFalse, defaultReason, defaultMessage)).To(Succeed())
 
 			By("Inject 1 permanent error")
 			Expect(framework.IssueSSHCommand(injectCommand(permMessage, 1), framework.TestContext.Provider, node)).To(Succeed())
 			By("Make sure the corresponding node condition is generated")
 			Eventually(func() error {
-				return verifyCondition(c.Nodes(), node.Name, condition, api.ConditionTrue, permReason, permMessage)
+				return verifyCondition(c.Core().Nodes(), node.Name, condition, api.ConditionTrue, permReason, permMessage)
 			}, pollTimeout, pollInterval).Should(Succeed())
 			By("Make sure no new events are generated")
 			Consistently(func() error {
-				return verifyEvents(c.Events(eventNamespace), eventListOptions, num, tempReason, tempMessage)
+				return verifyEvents(c.Core().Events(eventNamespace), eventListOptions, num, tempReason, tempMessage)
 			}, pollConsistent, pollInterval).Should(Succeed())
 		})
 
 		AfterEach(func() {
 			By("Delete the node problem detector")
-			c.Pods(ns).Delete(name, api.NewDeleteOptions(0))
+			c.Core().Pods(ns).Delete(name, api.NewDeleteOptions(0))
 			By("Wait for the node problem detector to disappear")
 			Expect(framework.WaitForPodToDisappear(c, ns, name, labels.Everything(), pollInterval, pollTimeout)).To(Succeed())
 			By("Delete the config map")
-			c.ConfigMaps(ns).Delete(configName)
+			c.Core().ConfigMaps(ns).Delete(configName, nil)
 			By("Clean up the events")
-			Expect(c.Events(eventNamespace).DeleteCollection(api.NewDeleteOptions(0), eventListOptions)).To(Succeed())
+			Expect(c.Core().Events(eventNamespace).DeleteCollection(api.NewDeleteOptions(0), eventListOptions)).To(Succeed())
 			By("Clean up the node condition")
 			patch := []byte(fmt.Sprintf(`{"status":{"conditions":[{"$patch":"delete","type":"%s"}]}}`, condition))
-			c.Patch(api.StrategicMergePatchType).Resource("nodes").Name(node.Name).SubResource("status").Body(patch).Do()
+			c.Core().RESTClient().Patch(api.StrategicMergePatchType).Resource("nodes").Name(node.Name).SubResource("status").Body(patch).Do()
 			By("Clean up the temporary directory")
 			framework.IssueSSHCommand(fmt.Sprintf("rm -r %s", tmpDir), framework.TestContext.Provider, node)
 		})
@@ -249,7 +250,7 @@ var _ = framework.KubeDescribe("NodeProblemDetector", func() {
 })
 
 // verifyEvents verifies there are num specific events generated
-func verifyEvents(e client.EventInterface, options api.ListOptions, num int, reason, message string) error {
+func verifyEvents(e coreclientset.EventInterface, options api.ListOptions, num int, reason, message string) error {
 	events, err := e.List(options)
 	if err != nil {
 		return err
@@ -268,7 +269,7 @@ func verifyEvents(e client.EventInterface, options api.ListOptions, num int, rea
 }
 
 // verifyNoEvents verifies there is no event generated
-func verifyNoEvents(e client.EventInterface, options api.ListOptions) error {
+func verifyNoEvents(e coreclientset.EventInterface, options api.ListOptions) error {
 	events, err := e.List(options)
 	if err != nil {
 		return err
@@ -280,7 +281,7 @@ func verifyNoEvents(e client.EventInterface, options api.ListOptions) error {
 }
 
 // verifyCondition verifies specific node condition is generated, if reason and message are empty, they will not be checked
-func verifyCondition(n client.NodeInterface, nodeName string, condition api.NodeConditionType, status api.ConditionStatus, reason, message string) error {
+func verifyCondition(n coreclientset.NodeInterface, nodeName string, condition api.NodeConditionType, status api.ConditionStatus, reason, message string) error {
 	node, err := n.Get(nodeName)
 	if err != nil {
 		return err

test/e2e/nodeoutofdisk.go

@@ -25,7 +25,6 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -67,16 +66,14 @@ const (
 //
 // Flaky issue #20015.  We have no clear path for how to test this functionality in a non-flaky way.
 var _ = framework.KubeDescribe("NodeOutOfDisk [Serial] [Flaky] [Disruptive]", func() {
-	var c *client.Client
+	var c clientset.Interface
-	var cs clientset.Interface
 	var unfilledNodeName, recoveredNodeName string
 	f := framework.NewDefaultFramework("node-outofdisk")
 
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
-		cs = f.ClientSet
 
-		nodelist := framework.GetReadySchedulableNodesOrDie(cs)
+		nodelist := framework.GetReadySchedulableNodesOrDie(c)
 
 		// Skip this test on small clusters.  No need to fail since it is not a use
 		// case that any cluster of small size needs to support.
@@ -90,7 +87,7 @@ var _ = framework.KubeDescribe("NodeOutOfDisk [Serial] [Flaky] [Disruptive]", fu
 
 	AfterEach(func() {
 
-		nodelist := framework.GetReadySchedulableNodesOrDie(cs)
+		nodelist := framework.GetReadySchedulableNodesOrDie(c)
 		Expect(len(nodelist.Items)).ToNot(BeZero())
 		for _, node := range nodelist.Items {
 			if unfilledNodeName == node.Name || recoveredNodeName == node.Name {
@@ -101,7 +98,7 @@ var _ = framework.KubeDescribe("NodeOutOfDisk [Serial] [Flaky] [Disruptive]", fu
 	})
 
 	It("runs out of disk space", func() {
-		unfilledNode, err := c.Nodes().Get(unfilledNodeName)
+		unfilledNode, err := c.Core().Nodes().Get(unfilledNodeName)
 		framework.ExpectNoError(err)
 
 		By(fmt.Sprintf("Calculating CPU availability on node %s", unfilledNode.Name))
@@ -116,7 +113,7 @@ var _ = framework.KubeDescribe("NodeOutOfDisk [Serial] [Flaky] [Disruptive]", fu
 		podCPU := int64(float64(milliCpu/(numNodeOODPods-1)) * 0.99)
 
 		ns := f.Namespace.Name
-		podClient := c.Pods(ns)
+		podClient := c.Core().Pods(ns)
 
 		By("Creating pods and waiting for all but one pods to be scheduled")
 
@@ -143,7 +140,7 @@ var _ = framework.KubeDescribe("NodeOutOfDisk [Serial] [Flaky] [Disruptive]", fu
 				"reason":                   "FailedScheduling",
 			}.AsSelector()
 			options := api.ListOptions{FieldSelector: selector}
-			schedEvents, err := c.Events(ns).List(options)
+			schedEvents, err := c.Core().Events(ns).List(options)
 			framework.ExpectNoError(err)
 
 			if len(schedEvents.Items) > 0 {
@@ -153,7 +150,7 @@ var _ = framework.KubeDescribe("NodeOutOfDisk [Serial] [Flaky] [Disruptive]", fu
 			}
 		})
 
-		nodelist := framework.GetReadySchedulableNodesOrDie(cs)
+		nodelist := framework.GetReadySchedulableNodesOrDie(c)
 		Expect(len(nodelist.Items)).To(BeNumerically(">", 1))
 
 		nodeToRecover := nodelist.Items[1]
@@ -171,8 +168,8 @@ var _ = framework.KubeDescribe("NodeOutOfDisk [Serial] [Flaky] [Disruptive]", fu
 })
 
 // createOutOfDiskPod creates a pod in the given namespace with the requested amount of CPU.
-func createOutOfDiskPod(c *client.Client, ns, name string, milliCPU int64) {
+func createOutOfDiskPod(c clientset.Interface, ns, name string, milliCPU int64) {
-	podClient := c.Pods(ns)
+	podClient := c.Core().Pods(ns)
 
 	pod := &api.Pod{
 		ObjectMeta: api.ObjectMeta{
@@ -200,8 +197,8 @@ func createOutOfDiskPod(c *client.Client, ns, name string, milliCPU int64) {
 
 // availCpu calculates the available CPU on a given node by subtracting the CPU requested by
 // all the pods from the total available CPU capacity on the node.
-func availCpu(c *client.Client, node *api.Node) (int64, error) {
+func availCpu(c clientset.Interface, node *api.Node) (int64, error) {
-	podClient := c.Pods(api.NamespaceAll)
+	podClient := c.Core().Pods(api.NamespaceAll)
 
 	selector := fields.Set{"spec.nodeName": node.Name}.AsSelector()
 	options := api.ListOptions{FieldSelector: selector}
@@ -220,10 +217,10 @@ func availCpu(c *client.Client, node *api.Node) (int64, error) {
 
 // availSize returns the available disk space on a given node by querying node stats which
 // is in turn obtained internally from cadvisor.
-func availSize(c *client.Client, node *api.Node) (uint64, error) {
+func availSize(c clientset.Interface, node *api.Node) (uint64, error) {
 	statsResource := fmt.Sprintf("api/v1/proxy/nodes/%s/stats/", node.Name)
 	framework.Logf("Querying stats for node %s using url %s", node.Name, statsResource)
-	res, err := c.Get().AbsPath(statsResource).Timeout(time.Minute).Do().Raw()
+	res, err := c.Core().RESTClient().Get().AbsPath(statsResource).Timeout(time.Minute).Do().Raw()
 	if err != nil {
 		return 0, fmt.Errorf("error querying cAdvisor API: %v", err)
 	}
@@ -238,7 +235,7 @@ func availSize(c *client.Client, node *api.Node) (uint64, error) {
 // fillDiskSpace fills the available disk space on a given node by creating a large file. The disk
 // space on the node is filled in such a way that the available space after filling the disk is just
 // below the lowDiskSpaceThreshold mark.
-func fillDiskSpace(c *client.Client, node *api.Node) {
+func fillDiskSpace(c clientset.Interface, node *api.Node) {
 	avail, err := availSize(c, node)
 	framework.ExpectNoError(err, "Node %s: couldn't obtain available disk size %v", node.Name, err)
 
@@ -259,7 +256,7 @@ func fillDiskSpace(c *client.Client, node *api.Node) {
 }
 
 // recoverDiskSpace recovers disk space, filled by creating a large file, on a given node.
-func recoverDiskSpace(c *client.Client, node *api.Node) {
+func recoverDiskSpace(c clientset.Interface, node *api.Node) {
 	By(fmt.Sprintf("Recovering disk space on node %s", node.Name))
 	cmd := "rm -f test.img"
 	framework.ExpectNoError(framework.IssueSSHCommand(cmd, framework.TestContext.Provider, node))

test/e2e/pd.go

@@ -34,7 +34,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/unversioned"
 	awscloud "k8s.io/kubernetes/pkg/cloudprovider/providers/aws"
 	gcecloud "k8s.io/kubernetes/pkg/cloudprovider/providers/gce"
 	"k8s.io/kubernetes/pkg/types"
@@ -53,8 +53,8 @@ const (
 
 var _ = framework.KubeDescribe("Pod Disks", func() {
 	var (
-		podClient  client.PodInterface
+		podClient  unversionedcore.PodInterface
-		nodeClient client.NodeInterface
+		nodeClient unversionedcore.NodeInterface
 		host0Name  types.NodeName
 		host1Name  types.NodeName
 	)
@@ -63,8 +63,8 @@ var _ = framework.KubeDescribe("Pod Disks", func() {
 	BeforeEach(func() {
 		framework.SkipUnlessNodeCountIsAtLeast(2)
 
-		podClient = f.Client.Pods(f.Namespace.Name)
+		podClient = f.ClientSet.Core().Pods(f.Namespace.Name)
-		nodeClient = f.Client.Nodes()
+		nodeClient = f.ClientSet.Core().Nodes()
 		nodes := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
 
 		Expect(len(nodes.Items)).To(BeNumerically(">=", 2), "Requires at least 2 nodes")
@@ -702,7 +702,7 @@ func detachAndDeletePDs(diskName string, hosts []types.NodeName) {
 }
 
 func waitForPDInVolumesInUse(
-	nodeClient client.NodeInterface,
+	nodeClient unversionedcore.NodeInterface,
 	diskName string,
 	nodeName types.NodeName,
 	timeout time.Duration,

test/e2e/persistent_volumes.go

@@ -27,16 +27,16 @@ import (
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
 	"k8s.io/kubernetes/test/e2e/framework"
 )
 
 // Delete the nfs-server pod.
-func nfsServerPodCleanup(c *client.Client, config VolumeTestConfig) {
+func nfsServerPodCleanup(c clientset.Interface, config VolumeTestConfig) {
 	defer GinkgoRecover()
 
-	podClient := c.Pods(config.namespace)
+	podClient := c.Core().Pods(config.namespace)
 
 	if config.serverImage != "" {
 		podName := config.prefix + "-server"
@@ -49,14 +49,14 @@ func nfsServerPodCleanup(c *client.Client, config VolumeTestConfig) {
 
 // Delete the PV. Fail test if delete fails. If success the returned PV should
 // be nil, which prevents the AfterEach from attempting to delete it.
-func deletePersistentVolume(c *client.Client, pv *api.PersistentVolume) (*api.PersistentVolume, error) {
+func deletePersistentVolume(c clientset.Interface, pv *api.PersistentVolume) (*api.PersistentVolume, error) {
 
 	if pv == nil {
 		return nil, fmt.Errorf("PV to be deleted is nil")
 	}
 
 	framework.Logf("Deleting PersistentVolume %v", pv.Name)
-	err := c.PersistentVolumes().Delete(pv.Name)
+	err := c.Core().PersistentVolumes().Delete(pv.Name, nil)
 	if err != nil {
 		return pv, fmt.Errorf("Delete() PersistentVolume %v failed: %v", pv.Name, err)
 	}
@@ -77,16 +77,16 @@ func deletePersistentVolume(c *client.Client, pv *api.PersistentVolume) (*api.Pe
 // delete is successful the returned pvc should be nil and the pv non-nil.
 // Note: the pv and pvc are returned back to the It() caller so that the
 //   AfterEach func can delete these objects if they are not nil.
-func deletePVCandValidatePV(c *client.Client, ns string, pvc *api.PersistentVolumeClaim, pv *api.PersistentVolume) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
+func deletePVCandValidatePV(c clientset.Interface, ns string, pvc *api.PersistentVolumeClaim, pv *api.PersistentVolume) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
 
 	framework.Logf("Deleting PersistentVolumeClaim %v to trigger PV Recycling", pvc.Name)
-	err := c.PersistentVolumeClaims(ns).Delete(pvc.Name)
+	err := c.Core().PersistentVolumeClaims(ns).Delete(pvc.Name, nil)
 	if err != nil {
 		return pv, pvc, fmt.Errorf("Delete of PVC %v failed: %v", pvc.Name, err)
 	}
 
 	// Check that the PVC is really deleted.
-	pvc, err = c.PersistentVolumeClaims(ns).Get(pvc.Name)
+	pvc, err = c.Core().PersistentVolumeClaims(ns).Get(pvc.Name)
 	if err == nil {
 		return pv, pvc, fmt.Errorf("PVC %v deleted yet still exists", pvc.Name)
 	}
@@ -102,7 +102,7 @@ func deletePVCandValidatePV(c *client.Client, ns string, pvc *api.PersistentVolu
 	}
 
 	// Examine the pv.ClaimRef and UID. Expect nil values.
-	pv, err = c.PersistentVolumes().Get(pv.Name)
+	pv, err = c.Core().PersistentVolumes().Get(pv.Name)
 	if err != nil {
 		return pv, pvc, fmt.Errorf("Cannot re-get PersistentVolume %v:", pv.Name)
 	}
@@ -115,9 +115,9 @@ func deletePVCandValidatePV(c *client.Client, ns string, pvc *api.PersistentVolu
 }
 
 // create the PV resource. Fails test on error.
-func createPV(c *client.Client, pv *api.PersistentVolume) (*api.PersistentVolume, error) {
+func createPV(c clientset.Interface, pv *api.PersistentVolume) (*api.PersistentVolume, error) {
 
-	pv, err := c.PersistentVolumes().Create(pv)
+	pv, err := c.Core().PersistentVolumes().Create(pv)
 	if err != nil {
 		return pv, fmt.Errorf("Create PersistentVolume %v failed: %v", pv.Name, err)
 	}
@@ -126,9 +126,9 @@ func createPV(c *client.Client, pv *api.PersistentVolume) (*api.PersistentVolume
 }
 
 // create the PVC resource. Fails test on error.
-func createPVC(c *client.Client, ns string, pvc *api.PersistentVolumeClaim) (*api.PersistentVolumeClaim, error) {
+func createPVC(c clientset.Interface, ns string, pvc *api.PersistentVolumeClaim) (*api.PersistentVolumeClaim, error) {
 
-	pvc, err := c.PersistentVolumeClaims(ns).Create(pvc)
+	pvc, err := c.Core().PersistentVolumeClaims(ns).Create(pvc)
 	if err != nil {
 		return pvc, fmt.Errorf("Create PersistentVolumeClaim %v failed: %v", pvc.Name, err)
 	}
@@ -144,7 +144,7 @@ func createPVC(c *client.Client, ns string, pvc *api.PersistentVolumeClaim) (*ap
 // Note: in the pre-bind case the real PVC name, which is generated, is not
 //   known until after the PVC is instantiated. This is why the pvc is created
 //   before the pv.
-func createPVCPV(c *client.Client, serverIP, ns string, preBind bool) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
+func createPVCPV(c clientset.Interface, serverIP, ns string, preBind bool) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
 
 	var bindTo *api.PersistentVolumeClaim
 	var preBindMsg string
@@ -187,7 +187,7 @@ func createPVCPV(c *client.Client, serverIP, ns string, preBind bool) (*api.Pers
 // Note: in the pre-bind case the real PV name, which is generated, is not
 //   known until after the PV is instantiated. This is why the pv is created
 //   before the pvc.
-func createPVPVC(c *client.Client, serverIP, ns string, preBind bool) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
+func createPVPVC(c clientset.Interface, serverIP, ns string, preBind bool) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
 
 	preBindMsg := ""
 	if preBind {
@@ -219,7 +219,7 @@ func createPVPVC(c *client.Client, serverIP, ns string, preBind bool) (*api.Pers
 }
 
 // Wait for the pv and pvc to bind to each other. Fail test on errors.
-func waitOnPVandPVC(c *client.Client, ns string, pv *api.PersistentVolume, pvc *api.PersistentVolumeClaim) error {
+func waitOnPVandPVC(c clientset.Interface, ns string, pv *api.PersistentVolume, pvc *api.PersistentVolumeClaim) error {
 
 	// Wait for newly created PVC to bind to the PV
 	framework.Logf("Waiting for PV %v to bind to PVC %v", pv.Name, pvc.Name)
@@ -243,7 +243,7 @@ func waitOnPVandPVC(c *client.Client, ns string, pv *api.PersistentVolume, pvc *
 // reflect that these resources have been retrieved again (Get).
 // Note: the pv and pvc are returned back to the It() caller so that the
 //   AfterEach func can delete these objects if they are not nil.
-func waitAndValidatePVandPVC(c *client.Client, ns string, pv *api.PersistentVolume, pvc *api.PersistentVolumeClaim) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
+func waitAndValidatePVandPVC(c clientset.Interface, ns string, pv *api.PersistentVolume, pvc *api.PersistentVolumeClaim) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
 
 	var err error
 
@@ -254,12 +254,12 @@ func waitAndValidatePVandPVC(c *client.Client, ns string, pv *api.PersistentVolu
 
 	// Check that the PersistentVolume.ClaimRef is valid and matches the PVC
 	framework.Logf("Checking PersistentVolume ClaimRef is non-nil")
-	pv, err = c.PersistentVolumes().Get(pv.Name)
+	pv, err = c.Core().PersistentVolumes().Get(pv.Name)
 	if err != nil {
 		return pv, pvc, fmt.Errorf("Cannot re-get PersistentVolume %v:", pv.Name)
 	}
 
-	pvc, err = c.PersistentVolumeClaims(ns).Get(pvc.Name)
+	pvc, err = c.Core().PersistentVolumeClaims(ns).Get(pvc.Name)
 	if err != nil {
 		return pv, pvc, fmt.Errorf("Cannot re-get PersistentVolumeClaim %v:", pvc.Name)
 	}
@@ -273,7 +273,7 @@ func waitAndValidatePVandPVC(c *client.Client, ns string, pv *api.PersistentVolu
 }
 
 // Test the pod's exitcode to be zero.
-func testPodSuccessOrFail(f *framework.Framework, c *client.Client, ns string, pod *api.Pod) error {
+func testPodSuccessOrFail(f *framework.Framework, c clientset.Interface, ns string, pod *api.Pod) error {
 
 	By("Pod should terminate with exitcode 0 (success)")
 
@@ -287,10 +287,10 @@ func testPodSuccessOrFail(f *framework.Framework, c *client.Client, ns string, p
 }
 
 // Delete the passed in pod.
-func deletePod(f *framework.Framework, c *client.Client, ns string, pod *api.Pod) error {
+func deletePod(f *framework.Framework, c clientset.Interface, ns string, pod *api.Pod) error {
 
 	framework.Logf("Deleting pod %v", pod.Name)
-	err := c.Pods(ns).Delete(pod.Name, nil)
+	err := c.Core().Pods(ns).Delete(pod.Name, nil)
 	if err != nil {
 		return fmt.Errorf("Pod %v encountered a delete error: %v", pod.Name, err)
 	}
@@ -303,7 +303,7 @@ func deletePod(f *framework.Framework, c *client.Client, ns string, pod *api.Pod
 
 	// Re-get the pod to double check that it has been deleted; expect err
 	// Note: Get() writes a log error if the pod is not found
-	_, err = c.Pods(ns).Get(pod.Name)
+	_, err = c.Core().Pods(ns).Get(pod.Name)
 	if err == nil {
 		return fmt.Errorf("Pod %v has been deleted but able to re-Get the deleted pod", pod.Name)
 	}
@@ -316,7 +316,7 @@ func deletePod(f *framework.Framework, c *client.Client, ns string, pod *api.Pod
 }
 
 // Create the test pod, wait for (hopefully) success, and then delete the pod.
-func createWaitAndDeletePod(f *framework.Framework, c *client.Client, ns string, claimName string) error {
+func createWaitAndDeletePod(f *framework.Framework, c clientset.Interface, ns string, claimName string) error {
 
 	var errmsg string
 
@@ -326,7 +326,7 @@ func createWaitAndDeletePod(f *framework.Framework, c *client.Client, ns string,
 	pod := makeWritePod(ns, claimName)
 
 	// Instantiate pod (Create)
-	runPod, err := c.Pods(ns).Create(pod)
+	runPod, err := c.Core().Pods(ns).Create(pod)
 	if err != nil || runPod == nil {
 		name := ""
 		if runPod != nil {
@@ -366,7 +366,7 @@ func createWaitAndDeletePod(f *framework.Framework, c *client.Client, ns string,
 // these resources have been retrieved again (Get).
 // Note: the pv and pvc are returned back to the It() caller so that the
 //   AfterEach func can delete these objects if they are not nil.
-func completeTest(f *framework.Framework, c *client.Client, ns string, pv *api.PersistentVolume, pvc *api.PersistentVolumeClaim) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
+func completeTest(f *framework.Framework, c clientset.Interface, ns string, pv *api.PersistentVolume, pvc *api.PersistentVolumeClaim) (*api.PersistentVolume, *api.PersistentVolumeClaim, error) {
 
 	// 1. verify that the PV and PVC have binded correctly
 	By("Validating the PV-PVC binding")
@@ -402,7 +402,7 @@ var _ = framework.KubeDescribe("PersistentVolumes", func() {
 
 	// global vars for the It() tests below
 	f := framework.NewDefaultFramework("pv")
-	var c *client.Client
+	var c clientset.Interface
 	var ns string
 	var NFSconfig VolumeTestConfig
 	var serverIP string
@@ -421,7 +421,7 @@ var _ = framework.KubeDescribe("PersistentVolumes", func() {
 	}
 
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 
 		// If it doesn't exist, create the nfs server pod in "default" ns
@@ -439,7 +439,7 @@ var _ = framework.KubeDescribe("PersistentVolumes", func() {
 			if pvc != nil && len(pvc.Name) > 0 {
 				// Delete the PersistentVolumeClaim
 				framework.Logf("AfterEach: PVC %v is non-nil, deleting claim", pvc.Name)
-				err := c.PersistentVolumeClaims(ns).Delete(pvc.Name)
+				err := c.Core().PersistentVolumeClaims(ns).Delete(pvc.Name, nil)
 				if err != nil && !apierrs.IsNotFound(err) {
 					framework.Logf("AfterEach: delete of PersistentVolumeClaim %v error: %v", pvc.Name, err)
 				}
@@ -447,7 +447,7 @@ var _ = framework.KubeDescribe("PersistentVolumes", func() {
 			}
 			if pv != nil && len(pv.Name) > 0 {
 				framework.Logf("AfterEach: PV %v is non-nil, deleting pv", pv.Name)
-				err := c.PersistentVolumes().Delete(pv.Name)
+				err := c.Core().PersistentVolumes().Delete(pv.Name, nil)
 				if err != nil && !apierrs.IsNotFound(err) {
 					framework.Logf("AfterEach: delete of PersistentVolume %v error: %v", pv.Name, err)
 				}

test/e2e/petset.go

@@ -33,7 +33,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apis/apps"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/controller/petset"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -71,7 +71,7 @@ var _ = framework.KubeDescribe("PetSet [Slow] [Feature:PetSet]", func() {
 	}
 	f := framework.NewFramework("petset", options, nil)
 	var ns string
-	var c *client.Client
+	var c clientset.Interface
 
 	BeforeEach(func() {
 		// PetSet is in alpha, so it's disabled on some platforms. We skip this
@@ -82,7 +82,7 @@ var _ = framework.KubeDescribe("PetSet [Slow] [Feature:PetSet]", func() {
 			framework.SkipIfMissingResource(f.ClientPool, unversioned.GroupVersionResource{Group: apps.GroupName, Version: "v1alpha1", Resource: "petsets"}, f.Namespace.Name)
 		}
 
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 	})
 
@@ -97,7 +97,7 @@ var _ = framework.KubeDescribe("PetSet [Slow] [Feature:PetSet]", func() {
 		BeforeEach(func() {
 			By("creating service " + headlessSvcName + " in namespace " + ns)
 			headlessService := createServiceSpec(headlessSvcName, "", true, labels)
-			_, err := c.Services(ns).Create(headlessService)
+			_, err := c.Core().Services(ns).Create(headlessService)
 			Expect(err).NotTo(HaveOccurred())
 		})
 
@@ -254,7 +254,7 @@ var _ = framework.KubeDescribe("PetSet [Slow] [Feature:PetSet]", func() {
 
 var _ = framework.KubeDescribe("Pet set recreate [Slow] [Feature:PetSet]", func() {
 	f := framework.NewDefaultFramework("pet-set-recreate")
-	var c *client.Client
+	var c clientset.Interface
 	var ns string
 
 	labels := map[string]string{
@@ -270,9 +270,9 @@ var _ = framework.KubeDescribe("Pet set recreate [Slow] [Feature:PetSet]", func(
 		framework.SkipUnlessProviderIs("gce", "vagrant")
 		By("creating service " + headlessSvcName + " in namespace " + f.Namespace.Name)
 		headlessService := createServiceSpec(headlessSvcName, "", true, labels)
-		_, err := f.Client.Services(f.Namespace.Name).Create(headlessService)
+		_, err := f.ClientSet.Core().Services(f.Namespace.Name).Create(headlessService)
 		framework.ExpectNoError(err)
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 	})
 
@@ -306,7 +306,7 @@ var _ = framework.KubeDescribe("Pet set recreate [Slow] [Feature:PetSet]", func(
 				NodeName: node.Name,
 			},
 		}
-		pod, err := f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err := f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		framework.ExpectNoError(err)
 
 		By("creating petset with conflicting port in namespace " + f.Namespace.Name)
@@ -314,7 +314,7 @@ var _ = framework.KubeDescribe("Pet set recreate [Slow] [Feature:PetSet]", func(
 		petContainer := &ps.Spec.Template.Spec.Containers[0]
 		petContainer.Ports = append(petContainer.Ports, conflictingPort)
 		ps.Spec.Template.Spec.NodeName = node.Name
-		_, err = f.Client.Apps().PetSets(f.Namespace.Name).Create(ps)
+		_, err = f.ClientSet.Apps().PetSets(f.Namespace.Name).Create(ps)
 		framework.ExpectNoError(err)
 
 		By("waiting until pod " + podName + " will start running in namespace " + f.Namespace.Name)
@@ -324,7 +324,7 @@ var _ = framework.KubeDescribe("Pet set recreate [Slow] [Feature:PetSet]", func(
 
 		var initialPetPodUID types.UID
 		By("waiting until pet pod " + petPodName + " will be recreated and deleted at least once in namespace " + f.Namespace.Name)
-		w, err := f.Client.Pods(f.Namespace.Name).Watch(api.SingleObject(api.ObjectMeta{Name: petPodName}))
+		w, err := f.ClientSet.Core().Pods(f.Namespace.Name).Watch(api.SingleObject(api.ObjectMeta{Name: petPodName}))
 		framework.ExpectNoError(err)
 		// we need to get UID from pod in any state and wait until pet set controller will remove pod atleast once
 		_, err = watch.Until(petPodTimeout, w, func(event watch.Event) (bool, error) {
@@ -347,13 +347,13 @@ var _ = framework.KubeDescribe("Pet set recreate [Slow] [Feature:PetSet]", func(
 		}
 
 		By("removing pod with conflicting port in namespace " + f.Namespace.Name)
-		err = f.Client.Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0))
+		err = f.ClientSet.Core().Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0))
 		framework.ExpectNoError(err)
 
 		By("waiting when pet pod " + petPodName + " will be recreated in namespace " + f.Namespace.Name + " and will be in running state")
 		// we may catch delete event, thats why we are waiting for running phase like this, and not with watch.Until
 		Eventually(func() error {
-			petPod, err := f.Client.Pods(f.Namespace.Name).Get(petPodName)
+			petPod, err := f.ClientSet.Core().Pods(f.Namespace.Name).Get(petPodName)
 			if err != nil {
 				return err
 			}
@@ -367,8 +367,8 @@ var _ = framework.KubeDescribe("Pet set recreate [Slow] [Feature:PetSet]", func(
 	})
 })
 
-func dumpDebugInfo(c *client.Client, ns string) {
+func dumpDebugInfo(c clientset.Interface, ns string) {
-	pl, _ := c.Pods(ns).List(api.ListOptions{LabelSelector: labels.Everything()})
+	pl, _ := c.Core().Pods(ns).List(api.ListOptions{LabelSelector: labels.Everything()})
 	for _, p := range pl.Items {
 		desc, _ := framework.RunKubectl("describe", "po", p.Name, fmt.Sprintf("--namespace=%v", ns))
 		framework.Logf("\nOutput of kubectl describe %v:\n%v", p.Name, desc)
@@ -526,7 +526,7 @@ func petSetFromManifest(fileName, ns string) *apps.PetSet {
 
 // petSetTester has all methods required to test a single petset.
 type petSetTester struct {
-	c *client.Client
+	c clientset.Interface
 }
 
 func (p *petSetTester) createPetSet(manifestPath, ns string) *apps.PetSet {
@@ -588,7 +588,7 @@ func (p *petSetTester) deletePetAtIndex(index int, ps *apps.PetSet) {
 	// pull the name out from an identity mapper.
 	name := fmt.Sprintf("%v-%v", ps.Name, index)
 	noGrace := int64(0)
-	if err := p.c.Pods(ps.Namespace).Delete(name, &api.DeleteOptions{GracePeriodSeconds: &noGrace}); err != nil {
+	if err := p.c.Core().Pods(ps.Namespace).Delete(name, &api.DeleteOptions{GracePeriodSeconds: &noGrace}); err != nil {
 		framework.Failf("Failed to delete pet %v for PetSet %v: %v", name, ps.Name, ps.Namespace, err)
 	}
 }
@@ -646,7 +646,7 @@ func (p *petSetTester) update(ns, name string, update func(ps *apps.PetSet)) {
 func (p *petSetTester) getPodList(ps *apps.PetSet) *api.PodList {
 	selector, err := unversioned.LabelSelectorAsSelector(ps.Spec.Selector)
 	ExpectNoError(err)
-	podList, err := p.c.Pods(ps.Namespace).List(api.ListOptions{LabelSelector: selector})
+	podList, err := p.c.Core().Pods(ps.Namespace).List(api.ListOptions{LabelSelector: selector})
 	ExpectNoError(err)
 	return podList
 }
@@ -735,7 +735,7 @@ func (p *petSetTester) waitForStatus(ps *apps.PetSet, expectedReplicas int32) {
 	}
 }
 
-func deleteAllPetSets(c *client.Client, ns string) {
+func deleteAllPetSets(c clientset.Interface, ns string) {
 	pst := &petSetTester{c: c}
 	psList, err := c.Apps().PetSets(ns).List(api.ListOptions{LabelSelector: labels.Everything()})
 	ExpectNoError(err)
@@ -759,7 +759,7 @@ func deleteAllPetSets(c *client.Client, ns string) {
 	pvNames := sets.NewString()
 	// TODO: Don't assume all pvcs in the ns belong to a petset
 	pvcPollErr := wait.PollImmediate(petsetPoll, petsetTimeout, func() (bool, error) {
-		pvcList, err := c.PersistentVolumeClaims(ns).List(api.ListOptions{LabelSelector: labels.Everything()})
+		pvcList, err := c.Core().PersistentVolumeClaims(ns).List(api.ListOptions{LabelSelector: labels.Everything()})
 		if err != nil {
 			framework.Logf("WARNING: Failed to list pvcs, retrying %v", err)
 			return false, nil
@@ -768,7 +768,7 @@ func deleteAllPetSets(c *client.Client, ns string) {
 			pvNames.Insert(pvc.Spec.VolumeName)
 			// TODO: Double check that there are no pods referencing the pvc
 			framework.Logf("Deleting pvc: %v with volume %v", pvc.Name, pvc.Spec.VolumeName)
-			if err := c.PersistentVolumeClaims(ns).Delete(pvc.Name); err != nil {
+			if err := c.Core().PersistentVolumeClaims(ns).Delete(pvc.Name, nil); err != nil {
 				return false, nil
 			}
 		}
@@ -779,7 +779,7 @@ func deleteAllPetSets(c *client.Client, ns string) {
 	}
 
 	pollErr := wait.PollImmediate(petsetPoll, petsetTimeout, func() (bool, error) {
-		pvList, err := c.PersistentVolumes().List(api.ListOptions{LabelSelector: labels.Everything()})
+		pvList, err := c.Core().PersistentVolumes().List(api.ListOptions{LabelSelector: labels.Everything()})
 		if err != nil {
 			framework.Logf("WARNING: Failed to list pvs, retrying %v", err)
 			return false, nil

test/e2e/pod_gc.go

@@ -39,7 +39,7 @@ var _ = framework.KubeDescribe("Pod garbage collector [Feature:PodGarbageCollect
 			pod, err := createTerminatingPod(f)
 			pod.ResourceVersion = ""
 			pod.Status.Phase = api.PodFailed
-			pod, err = f.Client.Pods(f.Namespace.Name).UpdateStatus(pod)
+			pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).UpdateStatus(pod)
 			if err != nil {
 				framework.Failf("err failing pod: %v", err)
 			}
@@ -61,7 +61,7 @@ var _ = framework.KubeDescribe("Pod garbage collector [Feature:PodGarbageCollect
 
 		By(fmt.Sprintf("Waiting for gc controller to gc all but %d pods", gcThreshold))
 		pollErr := wait.Poll(1*time.Minute, timeout, func() (bool, error) {
-			pods, err = f.Client.Pods(f.Namespace.Name).List(api.ListOptions{})
+			pods, err = f.ClientSet.Core().Pods(f.Namespace.Name).List(api.ListOptions{})
 			if err != nil {
 				framework.Logf("Failed to list pod %v", err)
 				return false, nil
@@ -96,5 +96,5 @@ func createTerminatingPod(f *framework.Framework) (*api.Pod, error) {
 			},
 		},
 	}
-	return f.Client.Pods(f.Namespace.Name).Create(pod)
+	return f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 }

test/e2e/portforward.go

@@ -177,14 +177,14 @@ var _ = framework.KubeDescribe("Port forwarding", func() {
 		It("should support a client that connects, sends no data, and disconnects [Conformance]", func() {
 			By("creating the target pod")
 			pod := pfPod("abc", "1", "1", "1")
-			if _, err := f.Client.Pods(f.Namespace.Name).Create(pod); err != nil {
+			if _, err := f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod); err != nil {
 				framework.Failf("Couldn't create pod: %v", err)
 			}
 			if err := f.WaitForPodRunning(pod.Name); err != nil {
 				framework.Failf("Pod did not start running: %v", err)
 			}
 			defer func() {
-				logs, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, "portforwardtester")
+				logs, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, "portforwardtester")
 				if err != nil {
 					framework.Logf("Error getting pod log: %v", err)
 				} else {
@@ -211,7 +211,7 @@ var _ = framework.KubeDescribe("Port forwarding", func() {
 			}
 
 			By("Verifying logs")
-			logOutput, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, "portforwardtester")
+			logOutput, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, "portforwardtester")
 			if err != nil {
 				framework.Failf("Error retrieving pod logs: %v", err)
 			}
@@ -222,14 +222,14 @@ var _ = framework.KubeDescribe("Port forwarding", func() {
 		It("should support a client that connects, sends data, and disconnects [Conformance]", func() {
 			By("creating the target pod")
 			pod := pfPod("abc", "10", "10", "100")
-			if _, err := f.Client.Pods(f.Namespace.Name).Create(pod); err != nil {
+			if _, err := f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod); err != nil {
 				framework.Failf("Couldn't create pod: %v", err)
 			}
 			if err := f.WaitForPodRunning(pod.Name); err != nil {
 				framework.Failf("Pod did not start running: %v", err)
 			}
 			defer func() {
-				logs, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, "portforwardtester")
+				logs, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, "portforwardtester")
 				if err != nil {
 					framework.Logf("Error getting pod log: %v", err)
 				} else {
@@ -277,7 +277,7 @@ var _ = framework.KubeDescribe("Port forwarding", func() {
 			}
 
 			By("Verifying logs")
-			logOutput, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, "portforwardtester")
+			logOutput, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, "portforwardtester")
 			if err != nil {
 				framework.Failf("Error retrieving pod logs: %v", err)
 			}
@@ -290,14 +290,14 @@ var _ = framework.KubeDescribe("Port forwarding", func() {
 		It("should support a client that connects, sends no data, and disconnects [Conformance]", func() {
 			By("creating the target pod")
 			pod := pfPod("", "10", "10", "100")
-			if _, err := f.Client.Pods(f.Namespace.Name).Create(pod); err != nil {
+			if _, err := f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod); err != nil {
 				framework.Failf("Couldn't create pod: %v", err)
 			}
 			if err := f.WaitForPodRunning(pod.Name); err != nil {
 				framework.Failf("Pod did not start running: %v", err)
 			}
 			defer func() {
-				logs, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, "portforwardtester")
+				logs, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, "portforwardtester")
 				if err != nil {
 					framework.Logf("Error getting pod log: %v", err)
 				} else {
@@ -335,7 +335,7 @@ var _ = framework.KubeDescribe("Port forwarding", func() {
 			}
 
 			By("Verifying logs")
-			logOutput, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, "portforwardtester")
+			logOutput, err := framework.GetPodLogs(f.ClientSet, f.Namespace.Name, pod.Name, "portforwardtester")
 			if err != nil {
 				framework.Failf("Error retrieving pod logs: %v", err)
 			}

test/e2e/pre_stop.go

@@ -22,7 +22,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/pkg/api"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/test/e2e/framework"
 
@@ -34,7 +34,7 @@ type State struct {
 	Received map[string]int
 }
 
-func testPreStop(c *client.Client, ns string) {
+func testPreStop(c clientset.Interface, ns string) {
 	// This is the server that will receive the preStop notification
 	podDescr := &api.Pod{
 		ObjectMeta: api.ObjectMeta{
@@ -51,13 +51,13 @@ func testPreStop(c *client.Client, ns string) {
 		},
 	}
 	By(fmt.Sprintf("Creating server pod %s in namespace %s", podDescr.Name, ns))
-	podDescr, err := c.Pods(ns).Create(podDescr)
+	podDescr, err := c.Core().Pods(ns).Create(podDescr)
 	framework.ExpectNoError(err, fmt.Sprintf("creating pod %s", podDescr.Name))
 
 	// At the end of the test, clean up by removing the pod.
 	defer func() {
 		By("Deleting the server pod")
-		c.Pods(ns).Delete(podDescr.Name, nil)
+		c.Core().Pods(ns).Delete(podDescr.Name, nil)
 	}()
 
 	By("Waiting for pods to come up.")
@@ -66,7 +66,7 @@ func testPreStop(c *client.Client, ns string) {
 
 	val := "{\"Source\": \"prestop\"}"
 
-	podOut, err := c.Pods(ns).Get(podDescr.Name)
+	podOut, err := c.Core().Pods(ns).Get(podDescr.Name)
 	framework.ExpectNoError(err, "getting pod info")
 
 	preStopDescr := &api.Pod{
@@ -94,7 +94,7 @@ func testPreStop(c *client.Client, ns string) {
 	}
 
 	By(fmt.Sprintf("Creating tester pod %s in namespace %s", preStopDescr.Name, ns))
-	preStopDescr, err = c.Pods(ns).Create(preStopDescr)
+	preStopDescr, err = c.Core().Pods(ns).Create(preStopDescr)
 	framework.ExpectNoError(err, fmt.Sprintf("creating pod %s", preStopDescr.Name))
 	deletePreStop := true
 
@@ -102,7 +102,7 @@ func testPreStop(c *client.Client, ns string) {
 	defer func() {
 		if deletePreStop {
 			By("Deleting the tester pod")
-			c.Pods(ns).Delete(preStopDescr.Name, nil)
+			c.Core().Pods(ns).Delete(preStopDescr.Name, nil)
 		}
 	}()
 
@@ -111,20 +111,20 @@ func testPreStop(c *client.Client, ns string) {
 
 	// Delete the pod with the preStop handler.
 	By("Deleting pre-stop pod")
-	if err := c.Pods(ns).Delete(preStopDescr.Name, nil); err == nil {
+	if err := c.Core().Pods(ns).Delete(preStopDescr.Name, nil); err == nil {
 		deletePreStop = false
 	}
 	framework.ExpectNoError(err, fmt.Sprintf("deleting pod: %s", preStopDescr.Name))
 
 	// Validate that the server received the web poke.
 	err = wait.Poll(time.Second*5, time.Second*60, func() (bool, error) {
-		subResourceProxyAvailable, err := framework.ServerVersionGTE(framework.SubResourcePodProxyVersion, c)
+		subResourceProxyAvailable, err := framework.ServerVersionGTE(framework.SubResourcePodProxyVersion, c.Discovery())
 		if err != nil {
 			return false, err
 		}
 		var body []byte
 		if subResourceProxyAvailable {
-			body, err = c.Get().
+			body, err = c.Core().RESTClient().Get().
 				Namespace(ns).
 				Resource("pods").
 				SubResource("proxy").
@@ -132,7 +132,7 @@ func testPreStop(c *client.Client, ns string) {
 				Suffix("read").
 				DoRaw()
 		} else {
-			body, err = c.Get().
+			body, err = c.Core().RESTClient().Get().
 				Prefix("proxy").
 				Namespace(ns).
 				Resource("pods").
@@ -163,6 +163,6 @@ var _ = framework.KubeDescribe("PreStop", func() {
 	f := framework.NewDefaultFramework("prestop")
 
 	It("should call prestop when killing a pod [Conformance]", func() {
-		testPreStop(f.Client, f.Namespace.Name)
+		testPreStop(f.ClientSet, f.Namespace.Name)
 	})
 })

test/e2e/proxy.go

@@ -71,7 +71,7 @@ var _ = framework.KubeDescribe("Proxy", func() {
 		It("should proxy through a service and a pod [Conformance]", func() {
 			start := time.Now()
 			labels := map[string]string{"proxy-service-target": "true"}
-			service, err := f.Client.Services(f.Namespace.Name).Create(&api.Service{
+			service, err := f.ClientSet.Core().Services(f.Namespace.Name).Create(&api.Service{
 				ObjectMeta: api.ObjectMeta{
 					GenerateName: "proxy-service-",
 				},
@@ -109,7 +109,7 @@ var _ = framework.KubeDescribe("Proxy", func() {
 			By("starting an echo server on multiple ports")
 			pods := []*api.Pod{}
 			cfg := testutils.RCConfig{
-				Client:       f.Client,
+				Client:       f.ClientSet,
 				Image:        "gcr.io/google_containers/porter:cd5cb5791ebaa8641955f0e8c2a9bed669b1eaab",
 				Name:         service.Name,
 				Namespace:    f.Namespace.Name,
@@ -146,7 +146,7 @@ var _ = framework.KubeDescribe("Proxy", func() {
 				CreatedPods: &pods,
 			}
 			Expect(framework.RunRC(cfg)).NotTo(HaveOccurred())
-			defer framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, cfg.Name)
+			defer framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, cfg.Name)
 
 			Expect(f.WaitForAnEndpoint(service.Name)).NotTo(HaveOccurred())
 
@@ -260,7 +260,7 @@ var _ = framework.KubeDescribe("Proxy", func() {
 			}
 
 			if len(errs) != 0 {
-				body, err := f.Client.Pods(f.Namespace.Name).GetLogs(pods[0].Name, &api.PodLogOptions{}).Do().Raw()
+				body, err := f.ClientSet.Core().Pods(f.Namespace.Name).GetLogs(pods[0].Name, &api.PodLogOptions{}).Do().Raw()
 				if err != nil {
 					framework.Logf("Error getting logs for pod %s: %v", pods[0].Name, err)
 				} else {
@@ -281,7 +281,7 @@ func doProxy(f *framework.Framework, path string, i int) (body []byte, statusCod
 	//   chance of the things we are talking to being confused for an error
 	//   that apiserver would have emitted.
 	start := time.Now()
-	body, err = f.Client.Get().AbsPath(path).Do().StatusCode(&statusCode).Raw()
+	body, err = f.ClientSet.Core().RESTClient().Get().AbsPath(path).Do().StatusCode(&statusCode).Raw()
 	d = time.Since(start)
 	if len(body) > 0 {
 		framework.Logf("(%v) %v: %s (%v; %v)", i, path, truncate(body, maxDisplayBodyLen), statusCode, d)

test/e2e/rc.go

@@ -57,7 +57,7 @@ func ServeImageOrFail(f *framework.Framework, test string, image string) {
 	// The source for the Docker containter kubernetes/serve_hostname is
 	// in contrib/for-demos/serve_hostname
 	By(fmt.Sprintf("Creating replication controller %s", name))
-	controller, err := f.Client.ReplicationControllers(f.Namespace.Name).Create(&api.ReplicationController{
+	controller, err := f.ClientSet.Core().ReplicationControllers(f.Namespace.Name).Create(&api.ReplicationController{
 		ObjectMeta: api.ObjectMeta{
 			Name: name,
 		},
@@ -86,7 +86,7 @@ func ServeImageOrFail(f *framework.Framework, test string, image string) {
 	// Cleanup the replication controller when we are done.
 	defer func() {
 		// Resize the replication controller to zero to get rid of pods.
-		if err := framework.DeleteRCAndPods(f.Client, f.ClientSet, f.Namespace.Name, controller.Name); err != nil {
+		if err := framework.DeleteRCAndPods(f.ClientSet, f.Namespace.Name, controller.Name); err != nil {
 			framework.Logf("Failed to cleanup replication controller %v: %v.", controller.Name, err)
 		}
 	}()
@@ -94,7 +94,7 @@ func ServeImageOrFail(f *framework.Framework, test string, image string) {
 	// List the pods, making sure we observe all the replicas.
 	label := labels.SelectorFromSet(labels.Set(map[string]string{"name": name}))
 
-	pods, err := framework.PodsCreated(f.Client, f.Namespace.Name, name, replicas)
+	pods, err := framework.PodsCreated(f.ClientSet, f.Namespace.Name, name, replicas)
 
 	By("Ensuring each pod is running")
 
@@ -112,7 +112,7 @@ func ServeImageOrFail(f *framework.Framework, test string, image string) {
 	By("Trying to dial each unique pod")
 	retryTimeout := 2 * time.Minute
 	retryInterval := 5 * time.Second
-	err = wait.Poll(retryInterval, retryTimeout, framework.PodProxyResponseChecker(f.Client, f.Namespace.Name, label, name, true, pods).CheckAllResponses)
+	err = wait.Poll(retryInterval, retryTimeout, framework.PodProxyResponseChecker(f.ClientSet, f.Namespace.Name, label, name, true, pods).CheckAllResponses)
 	if err != nil {
 		framework.Failf("Did not get expected responses within the timeout period of %.2f seconds.", retryTimeout.Seconds())
 	}

test/e2e/reboot.go

@@ -23,7 +23,6 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/sets"
@@ -65,7 +64,7 @@ var _ = framework.KubeDescribe("Reboot [Disruptive] [Feature:Reboot]", func() {
 			// events for the kube-system namespace on failures
 			namespaceName := api.NamespaceSystem
 			By(fmt.Sprintf("Collecting events from namespace %q.", namespaceName))
-			events, err := f.Client.Events(namespaceName).List(api.ListOptions{})
+			events, err := f.ClientSet.Core().Events(namespaceName).List(api.ListOptions{})
 			Expect(err).NotTo(HaveOccurred())
 
 			for _, e := range events.Items {
@@ -90,32 +89,32 @@ var _ = framework.KubeDescribe("Reboot [Disruptive] [Feature:Reboot]", func() {
 	It("each node by ordering clean reboot and ensure they function upon restart", func() {
 		// clean shutdown and restart
 		// We sleep 10 seconds to give some time for ssh command to cleanly finish before the node is rebooted.
-		testReboot(f.Client, f.ClientSet, "nohup sh -c 'sleep 10 && sudo reboot' >/dev/null 2>&1 &")
+		testReboot(f.ClientSet, "nohup sh -c 'sleep 10 && sudo reboot' >/dev/null 2>&1 &")
 	})
 
 	It("each node by ordering unclean reboot and ensure they function upon restart", func() {
 		// unclean shutdown and restart
 		// We sleep 10 seconds to give some time for ssh command to cleanly finish before the node is shutdown.
-		testReboot(f.Client, f.ClientSet, "nohup sh -c 'sleep 10 && echo b | sudo tee /proc/sysrq-trigger' >/dev/null 2>&1 &")
+		testReboot(f.ClientSet, "nohup sh -c 'sleep 10 && echo b | sudo tee /proc/sysrq-trigger' >/dev/null 2>&1 &")
 	})
 
 	It("each node by triggering kernel panic and ensure they function upon restart", func() {
 		// kernel panic
 		// We sleep 10 seconds to give some time for ssh command to cleanly finish before kernel panic is triggered.
-		testReboot(f.Client, f.ClientSet, "nohup sh -c 'sleep 10 && echo c | sudo tee /proc/sysrq-trigger' >/dev/null 2>&1 &")
+		testReboot(f.ClientSet, "nohup sh -c 'sleep 10 && echo c | sudo tee /proc/sysrq-trigger' >/dev/null 2>&1 &")
 	})
 
 	It("each node by switching off the network interface and ensure they function upon switch on", func() {
 		// switch the network interface off for a while to simulate a network outage
 		// We sleep 10 seconds to give some time for ssh command to cleanly finish before network is down.
-		testReboot(f.Client, f.ClientSet, "nohup sh -c 'sleep 10 && (sudo ifdown eth0 || sudo ip link set eth0 down) && sleep 120 && (sudo ifup eth0 || sudo ip link set eth0 up)' >/dev/null 2>&1 &")
+		testReboot(f.ClientSet, "nohup sh -c 'sleep 10 && (sudo ifdown eth0 || sudo ip link set eth0 down) && sleep 120 && (sudo ifup eth0 || sudo ip link set eth0 up)' >/dev/null 2>&1 &")
 	})
 
 	It("each node by dropping all inbound packets for a while and ensure they function afterwards", func() {
 		// tell the firewall to drop all inbound packets for a while
 		// We sleep 10 seconds to give some time for ssh command to cleanly finish before starting dropping inbound packets.
 		// We still accept packages send from localhost to prevent monit from restarting kubelet.
-		testReboot(f.Client, f.ClientSet, "nohup sh -c 'sleep 10 && sudo iptables -I INPUT 1 -s 127.0.0.1 -j ACCEPT && sudo iptables -I INPUT 2 -j DROP && "+
+		testReboot(f.ClientSet, "nohup sh -c 'sleep 10 && sudo iptables -I INPUT 1 -s 127.0.0.1 -j ACCEPT && sudo iptables -I INPUT 2 -j DROP && "+
 			" sleep 120 && sudo iptables -D INPUT -j DROP && sudo iptables -D INPUT -s 127.0.0.1 -j ACCEPT' >/dev/null 2>&1 &")
 	})
 
@@ -123,14 +122,14 @@ var _ = framework.KubeDescribe("Reboot [Disruptive] [Feature:Reboot]", func() {
 		// tell the firewall to drop all outbound packets for a while
 		// We sleep 10 seconds to give some time for ssh command to cleanly finish before starting dropping outbound packets.
 		// We still accept packages send to localhost to prevent monit from restarting kubelet.
-		testReboot(f.Client, f.ClientSet, "nohup sh -c 'sleep 10 &&  sudo iptables -I OUTPUT 1 -s 127.0.0.1 -j ACCEPT && sudo iptables -I OUTPUT 2 -j DROP && "+
+		testReboot(f.ClientSet, "nohup sh -c 'sleep 10 &&  sudo iptables -I OUTPUT 1 -s 127.0.0.1 -j ACCEPT && sudo iptables -I OUTPUT 2 -j DROP && "+
 			" sleep 120 && sudo iptables -D OUTPUT -j DROP && sudo iptables -D OUTPUT -s 127.0.0.1 -j ACCEPT' >/dev/null 2>&1 &")
 	})
 })
 
-func testReboot(c *client.Client, cs clientset.Interface, rebootCmd string) {
+func testReboot(c clientset.Interface, rebootCmd string) {
 	// Get all nodes, and kick off the test on each.
-	nodelist := framework.GetReadySchedulableNodesOrDie(cs)
+	nodelist := framework.GetReadySchedulableNodesOrDie(c)
 	result := make([]bool, len(nodelist.Items))
 	wg := sync.WaitGroup{}
 	wg.Add(len(nodelist.Items))
@@ -161,7 +160,7 @@ func testReboot(c *client.Client, cs clientset.Interface, rebootCmd string) {
 	}
 }
 
-func printStatusAndLogsForNotReadyPods(c *client.Client, ns string, podNames []string, pods []*api.Pod) {
+func printStatusAndLogsForNotReadyPods(c clientset.Interface, ns string, podNames []string, pods []*api.Pod) {
 	printFn := func(id, log string, err error, previous bool) {
 		prefix := "Retrieving log for container"
 		if previous {
@@ -208,7 +207,7 @@ func printStatusAndLogsForNotReadyPods(c *client.Client, ns string, podNames []s
 //
 // It returns true through result only if all of the steps pass; at the first
 // failed step, it will return false through result and not run the rest.
-func rebootNode(c *client.Client, provider, name, rebootCmd string) bool {
+func rebootNode(c clientset.Interface, provider, name, rebootCmd string) bool {
 	// Setup
 	ns := api.NamespaceSystem
 	ps := testutils.NewPodStore(c, ns, labels.Everything(), fields.OneTermEqualSelector(api.PodHostField, name))
@@ -216,7 +215,7 @@ func rebootNode(c *client.Client, provider, name, rebootCmd string) bool {
 
 	// Get the node initially.
 	framework.Logf("Getting %s", name)
-	node, err := c.Nodes().Get(name)
+	node, err := c.Core().Nodes().Get(name)
 	if err != nil {
 		framework.Logf("Couldn't get node %s", name)
 		return false

test/e2e/replica_set.go

@@ -57,7 +57,7 @@ func ReplicaSetServeImageOrFail(f *framework.Framework, test string, image strin
 	// The source for the Docker containter kubernetes/serve_hostname is
 	// in contrib/for-demos/serve_hostname
 	By(fmt.Sprintf("Creating ReplicaSet %s", name))
-	rs, err := f.Client.Extensions().ReplicaSets(f.Namespace.Name).Create(&extensions.ReplicaSet{
+	rs, err := f.ClientSet.Extensions().ReplicaSets(f.Namespace.Name).Create(&extensions.ReplicaSet{
 		ObjectMeta: api.ObjectMeta{
 			Name: name,
 		},
@@ -86,7 +86,7 @@ func ReplicaSetServeImageOrFail(f *framework.Framework, test string, image strin
 	// Cleanup the ReplicaSet when we are done.
 	defer func() {
 		// Resize the ReplicaSet to zero to get rid of pods.
-		if err := framework.DeleteReplicaSet(f.Client, f.ClientSet, f.Namespace.Name, rs.Name); err != nil {
+		if err := framework.DeleteReplicaSet(f.ClientSet, f.Namespace.Name, rs.Name); err != nil {
 			framework.Logf("Failed to cleanup ReplicaSet %v: %v.", rs.Name, err)
 		}
 	}()
@@ -94,7 +94,7 @@ func ReplicaSetServeImageOrFail(f *framework.Framework, test string, image strin
 	// List the pods, making sure we observe all the replicas.
 	label := labels.SelectorFromSet(labels.Set(map[string]string{"name": name}))
 
-	pods, err := framework.PodsCreated(f.Client, f.Namespace.Name, name, replicas)
+	pods, err := framework.PodsCreated(f.ClientSet, f.Namespace.Name, name, replicas)
 	Expect(err).NotTo(HaveOccurred())
 
 	By("Ensuring each pod is running")
@@ -113,7 +113,7 @@ func ReplicaSetServeImageOrFail(f *framework.Framework, test string, image strin
 	By("Trying to dial each unique pod")
 	retryTimeout := 2 * time.Minute
 	retryInterval := 5 * time.Second
-	err = wait.Poll(retryInterval, retryTimeout, framework.PodProxyResponseChecker(f.Client, f.Namespace.Name, label, name, true, pods).CheckAllResponses)
+	err = wait.Poll(retryInterval, retryTimeout, framework.PodProxyResponseChecker(f.ClientSet, f.Namespace.Name, label, name, true, pods).CheckAllResponses)
 	if err != nil {
 		framework.Failf("Did not get expected responses within the timeout period of %.2f seconds.", retryTimeout.Seconds())
 	}

test/e2e/rescheduler.go

@@ -49,21 +49,21 @@ var _ = framework.KubeDescribe("Rescheduler [Serial]", func() {
 	It("should ensure that critical pod is scheduled in case there is no resources available", func() {
 		By("reserving all available cpu")
 		err := reserveAllCpu(f, "reserve-all-cpu", totalMillicores)
-		defer framework.DeleteRCAndPods(f.Client, f.ClientSet, ns, "reserve-all-cpu")
+		defer framework.DeleteRCAndPods(f.ClientSet, ns, "reserve-all-cpu")
 		framework.ExpectNoError(err)
 
 		By("creating a new instance of DNS and waiting for DNS to be scheduled")
 		label := labels.SelectorFromSet(labels.Set(map[string]string{"k8s-app": "kube-dns"}))
 		listOpts := api.ListOptions{LabelSelector: label}
-		rcs, err := f.Client.ReplicationControllers(api.NamespaceSystem).List(listOpts)
+		rcs, err := f.ClientSet.Core().ReplicationControllers(api.NamespaceSystem).List(listOpts)
 		framework.ExpectNoError(err)
 		Expect(len(rcs.Items)).Should(Equal(1))
 
 		rc := rcs.Items[0]
 		replicas := uint(rc.Spec.Replicas)
 
-		err = framework.ScaleRC(f.Client, f.ClientSet, api.NamespaceSystem, rc.Name, replicas+1, true)
+		err = framework.ScaleRC(f.ClientSet, api.NamespaceSystem, rc.Name, replicas+1, true)
-		defer framework.ExpectNoError(framework.ScaleRC(f.Client, f.ClientSet, api.NamespaceSystem, rc.Name, replicas, true))
+		defer framework.ExpectNoError(framework.ScaleRC(f.ClientSet, api.NamespaceSystem, rc.Name, replicas, true))
 		framework.ExpectNoError(err)
 	})
 })
@@ -73,10 +73,10 @@ func reserveAllCpu(f *framework.Framework, id string, millicores int) error {
 	replicas := millicores / 100
 
 	ReserveCpu(f, id, 1, 100)
-	framework.ExpectNoError(framework.ScaleRC(f.Client, f.ClientSet, f.Namespace.Name, id, uint(replicas), false))
+	framework.ExpectNoError(framework.ScaleRC(f.ClientSet, f.Namespace.Name, id, uint(replicas), false))
 
 	for start := time.Now(); time.Since(start) < timeout; time.Sleep(10 * time.Second) {
-		pods, err := framework.GetPodsInNamespace(f.Client, f.Namespace.Name, framework.ImagePullerLabels)
+		pods, err := framework.GetPodsInNamespace(f.ClientSet, f.Namespace.Name, framework.ImagePullerLabels)
 		if err != nil {
 			return err
 		}

test/e2e/resize_nodes.go

@@ -26,7 +26,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/util/intstr"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -160,8 +160,8 @@ func svcByName(name string, port int) *api.Service {
 	}
 }
 
-func newSVCByName(c *client.Client, ns, name string) error {
+func newSVCByName(c clientset.Interface, ns, name string) error {
-	_, err := c.Services(ns).Create(svcByName(name, testPort))
+	_, err := c.Core().Services(ns).Create(svcByName(name, testPort))
 	return err
 }
 
@@ -187,8 +187,8 @@ func podOnNode(podName, nodeName string, image string) *api.Pod {
 	}
 }
 
-func newPodOnNode(c *client.Client, namespace, podName, nodeName string) error {
+func newPodOnNode(c clientset.Interface, namespace, podName, nodeName string) error {
-	pod, err := c.Pods(namespace).Create(podOnNode(podName, nodeName, serveHostnameImage))
+	pod, err := c.Core().Pods(namespace).Create(podOnNode(podName, nodeName, serveHostnameImage))
 	if err == nil {
 		framework.Logf("Created pod %s on node %s", pod.ObjectMeta.Name, nodeName)
 	} else {
@@ -243,27 +243,27 @@ func rcByNameContainer(name string, replicas int32, image string, labels map[str
 }
 
 // newRCByName creates a replication controller with a selector by name of name.
-func newRCByName(c *client.Client, ns, name string, replicas int32) (*api.ReplicationController, error) {
+func newRCByName(c clientset.Interface, ns, name string, replicas int32) (*api.ReplicationController, error) {
 	By(fmt.Sprintf("creating replication controller %s", name))
-	return c.ReplicationControllers(ns).Create(rcByNamePort(
+	return c.Core().ReplicationControllers(ns).Create(rcByNamePort(
 		name, replicas, serveHostnameImage, 9376, api.ProtocolTCP, map[string]string{}))
 }
 
-func resizeRC(c *client.Client, ns, name string, replicas int32) error {
+func resizeRC(c clientset.Interface, ns, name string, replicas int32) error {
-	rc, err := c.ReplicationControllers(ns).Get(name)
+	rc, err := c.Core().ReplicationControllers(ns).Get(name)
 	if err != nil {
 		return err
 	}
 	rc.Spec.Replicas = replicas
-	_, err = c.ReplicationControllers(rc.Namespace).Update(rc)
+	_, err = c.Core().ReplicationControllers(rc.Namespace).Update(rc)
 	return err
 }
 
-func getMaster(c *client.Client) string {
+func getMaster(c clientset.Interface) string {
 	master := ""
 	switch framework.TestContext.Provider {
 	case "gce":
-		eps, err := c.Endpoints(api.NamespaceDefault).Get("kubernetes")
+		eps, err := c.Core().Endpoints(api.NamespaceDefault).Get("kubernetes")
 		if err != nil {
 			framework.Failf("Fail to get kubernetes endpoinds: %v", err)
 		}
@@ -306,7 +306,7 @@ func getNodeExternalIP(node *api.Node) string {
 // At the end (even in case of errors), the network traffic is brought back to normal.
 // This function executes commands on a node so it will work only for some
 // environments.
-func performTemporaryNetworkFailure(c *client.Client, ns, rcName string, replicas int32, podNameToDisappear string, node *api.Node) {
+func performTemporaryNetworkFailure(c clientset.Interface, ns, rcName string, replicas int32, podNameToDisappear string, node *api.Node) {
 	host := getNodeExternalIP(node)
 	master := getMaster(c)
 	By(fmt.Sprintf("block network traffic from node %s to the master", node.Name))
@@ -365,13 +365,13 @@ func expectNodeReadiness(isReady bool, newNode chan *api.Node) {
 var _ = framework.KubeDescribe("Nodes [Disruptive]", func() {
 	f := framework.NewDefaultFramework("resize-nodes")
 	var systemPodsNo int32
-	var c *client.Client
+	var c clientset.Interface
 	var ns string
 	ignoreLabels := framework.ImagePullerLabels
 	var group string
 
 	BeforeEach(func() {
-		c = f.Client
+		c = f.ClientSet
 		ns = f.Namespace.Name
 		systemPods, err := framework.GetPodsInNamespace(c, ns, ignoreLabels)
 		Expect(err).NotTo(HaveOccurred())
@@ -507,11 +507,11 @@ var _ = framework.KubeDescribe("Nodes [Disruptive]", func() {
 				By("choose a node with at least one pod - we will block some network traffic on this node")
 				label := labels.SelectorFromSet(labels.Set(map[string]string{"name": name}))
 				options := api.ListOptions{LabelSelector: label}
-				pods, err := c.Pods(ns).List(options) // list pods after all have been scheduled
+				pods, err := c.Core().Pods(ns).List(options) // list pods after all have been scheduled
 				Expect(err).NotTo(HaveOccurred())
 				nodeName := pods.Items[0].Spec.NodeName
 
-				node, err := c.Nodes().Get(nodeName)
+				node, err := c.Core().Nodes().Get(nodeName)
 				Expect(err).NotTo(HaveOccurred())
 
 				By(fmt.Sprintf("block network traffic from node %s", node.Name))
@@ -535,7 +535,7 @@ var _ = framework.KubeDescribe("Nodes [Disruptive]", func() {
 
 				// verify that it is really on the requested node
 				{
-					pod, err := c.Pods(ns).Get(additionalPod)
+					pod, err := c.Core().Pods(ns).Get(additionalPod)
 					Expect(err).NotTo(HaveOccurred())
 					if pod.Spec.NodeName != node.Name {
 						framework.Logf("Pod %s found on invalid node: %s instead of %s", pod.Name, pod.Spec.NodeName, node.Name)
@@ -554,14 +554,14 @@ var _ = framework.KubeDescribe("Nodes [Disruptive]", func() {
 				By("choose a node - we will block all network traffic on this node")
 				var podOpts api.ListOptions
 				nodeOpts := api.ListOptions{}
-				nodes, err := c.Nodes().List(nodeOpts)
+				nodes, err := c.Core().Nodes().List(nodeOpts)
 				Expect(err).NotTo(HaveOccurred())
 				framework.FilterNodes(nodes, func(node api.Node) bool {
 					if !framework.IsNodeConditionSetAsExpected(&node, api.NodeReady, true) {
 						return false
 					}
 					podOpts = api.ListOptions{FieldSelector: fields.OneTermEqualSelector(api.PodHostField, node.Name)}
-					pods, err := c.Pods(api.NamespaceAll).List(podOpts)
+					pods, err := c.Core().Pods(api.NamespaceAll).List(podOpts)
 					if err != nil || len(pods.Items) <= 0 {
 						return false
 					}
@@ -585,11 +585,12 @@ var _ = framework.KubeDescribe("Nodes [Disruptive]", func() {
 					&cache.ListWatch{
 						ListFunc: func(options api.ListOptions) (runtime.Object, error) {
 							options.FieldSelector = nodeSelector
-							return f.Client.Nodes().List(options)
+							obj, err := f.ClientSet.Core().Nodes().List(options)
+							return runtime.Object(obj), err
 						},
 						WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
 							options.FieldSelector = nodeSelector
-							return f.Client.Nodes().Watch(options)
+							return f.ClientSet.Core().Nodes().Watch(options)
 						},
 					},
 					&api.Node{},

test/e2e/resource_quota.go

@@ -22,7 +22,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/util/intstr"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -43,13 +43,13 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		By("Creating a ResourceQuota")
 		quotaName := "test-quota"
 		resourceQuota := newTestResourceQuota(quotaName)
-		resourceQuota, err := createResourceQuota(f.Client, f.Namespace.Name, resourceQuota)
+		resourceQuota, err := createResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuota)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status is calculated")
 		usedResources := api.ResourceList{}
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -57,40 +57,40 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		By("Creating a ResourceQuota")
 		quotaName := "test-quota"
 		resourceQuota := newTestResourceQuota(quotaName)
-		resourceQuota, err := createResourceQuota(f.Client, f.Namespace.Name, resourceQuota)
+		resourceQuota, err := createResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuota)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status is calculated")
 		usedResources := api.ResourceList{}
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a Service")
 		service := newTestServiceForQuota("test-service", api.ServiceTypeClusterIP)
-		service, err = f.Client.Services(f.Namespace.Name).Create(service)
+		service, err = f.ClientSet.Core().Services(f.Namespace.Name).Create(service)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status captures service creation")
 		usedResources = api.ResourceList{}
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
 		usedResources[api.ResourceServices] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting a Service")
-		err = f.Client.Services(f.Namespace.Name).Delete(service.Name)
+		err = f.ClientSet.Core().Services(f.Namespace.Name).Delete(service.Name, nil)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released usage")
 		usedResources[api.ResourceServices] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("should create a ResourceQuota and capture the life of a secret.", func() {
 		By("Discovering how many secrets are in namespace by default")
-		secrets, err := f.Client.Secrets(f.Namespace.Name).List(api.ListOptions{})
+		secrets, err := f.ClientSet.Core().Secrets(f.Namespace.Name).List(api.ListOptions{})
 		Expect(err).NotTo(HaveOccurred())
 		defaultSecrets := fmt.Sprintf("%d", len(secrets.Items))
 		hardSecrets := fmt.Sprintf("%d", len(secrets.Items)+1)
@@ -99,19 +99,19 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		quotaName := "test-quota"
 		resourceQuota := newTestResourceQuota(quotaName)
 		resourceQuota.Spec.Hard[api.ResourceSecrets] = resource.MustParse(hardSecrets)
-		resourceQuota, err = createResourceQuota(f.Client, f.Namespace.Name, resourceQuota)
+		resourceQuota, err = createResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuota)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status is calculated")
 		usedResources := api.ResourceList{}
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
 		usedResources[api.ResourceSecrets] = resource.MustParse(defaultSecrets)
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a Secret")
 		secret := newTestSecretForQuota("test-secret")
-		secret, err = f.Client.Secrets(f.Namespace.Name).Create(secret)
+		secret, err = f.ClientSet.Core().Secrets(f.Namespace.Name).Create(secret)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status captures secret creation")
@@ -119,16 +119,16 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourceSecrets] = resource.MustParse(hardSecrets)
 		// we expect there to be two secrets because each namespace will receive
 		// a service account token secret by default
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting a secret")
-		err = f.Client.Secrets(f.Namespace.Name).Delete(secret.Name)
+		err = f.ClientSet.Core().Secrets(f.Namespace.Name).Delete(secret.Name, nil)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released usage")
 		usedResources[api.ResourceSecrets] = resource.MustParse(defaultSecrets)
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -136,13 +136,13 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		By("Creating a ResourceQuota")
 		quotaName := "test-quota"
 		resourceQuota := newTestResourceQuota(quotaName)
-		resourceQuota, err := createResourceQuota(f.Client, f.Namespace.Name, resourceQuota)
+		resourceQuota, err := createResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuota)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status is calculated")
 		usedResources := api.ResourceList{}
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a Pod that fits quota")
@@ -151,7 +151,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		requests[api.ResourceCPU] = resource.MustParse("500m")
 		requests[api.ResourceMemory] = resource.MustParse("252Mi")
 		pod := newTestPodForQuota(f, podName, requests, api.ResourceList{})
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).NotTo(HaveOccurred())
 		podToUpdate := pod
 
@@ -160,7 +160,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourcePods] = resource.MustParse("1")
 		usedResources[api.ResourceCPU] = requests[api.ResourceCPU]
 		usedResources[api.ResourceMemory] = requests[api.ResourceMemory]
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Not allowing a pod to be created that exceeds remaining quota")
@@ -168,7 +168,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		requests[api.ResourceCPU] = resource.MustParse("600m")
 		requests[api.ResourceMemory] = resource.MustParse("100Mi")
 		pod = newTestPodForQuota(f, "fail-pod", requests, api.ResourceList{})
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).To(HaveOccurred())
 
 		By("Ensuring a pod cannot update its resource requirements")
@@ -177,15 +177,15 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		requests[api.ResourceCPU] = resource.MustParse("100m")
 		requests[api.ResourceMemory] = resource.MustParse("100Mi")
 		podToUpdate.Spec.Containers[0].Resources.Requests = requests
-		_, err = f.Client.Pods(f.Namespace.Name).Update(podToUpdate)
+		_, err = f.ClientSet.Core().Pods(f.Namespace.Name).Update(podToUpdate)
 		Expect(err).To(HaveOccurred())
 
 		By("Ensuring attempts to update pod resource requirements did not change quota usage")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting the pod")
-		err = f.Client.Pods(f.Namespace.Name).Delete(podName, api.NewDeleteOptions(0))
+		err = f.ClientSet.Core().Pods(f.Namespace.Name).Delete(podName, api.NewDeleteOptions(0))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released the pod usage")
@@ -193,7 +193,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourcePods] = resource.MustParse("0")
 		usedResources[api.ResourceCPU] = resource.MustParse("0")
 		usedResources[api.ResourceMemory] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -201,34 +201,34 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		By("Creating a ResourceQuota")
 		quotaName := "test-quota"
 		resourceQuota := newTestResourceQuota(quotaName)
-		resourceQuota, err := createResourceQuota(f.Client, f.Namespace.Name, resourceQuota)
+		resourceQuota, err := createResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuota)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status is calculated")
 		usedResources := api.ResourceList{}
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a ConfigMap")
 		configMap := newTestConfigMapForQuota("test-configmap")
-		configMap, err = f.Client.ConfigMaps(f.Namespace.Name).Create(configMap)
+		configMap, err = f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Create(configMap)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status captures configMap creation")
 		usedResources = api.ResourceList{}
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
 		usedResources[api.ResourceConfigMaps] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting a ConfigMap")
-		err = f.Client.ConfigMaps(f.Namespace.Name).Delete(configMap.Name)
+		err = f.ClientSet.Core().ConfigMaps(f.Namespace.Name).Delete(configMap.Name, nil)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released usage")
 		usedResources[api.ResourceConfigMaps] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -236,34 +236,34 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		By("Creating a ResourceQuota")
 		quotaName := "test-quota"
 		resourceQuota := newTestResourceQuota(quotaName)
-		resourceQuota, err := createResourceQuota(f.Client, f.Namespace.Name, resourceQuota)
+		resourceQuota, err := createResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuota)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status is calculated")
 		usedResources := api.ResourceList{}
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
 		usedResources[api.ResourceReplicationControllers] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a ReplicationController")
 		replicationController := newTestReplicationControllerForQuota("test-rc", "nginx", 0)
-		replicationController, err = f.Client.ReplicationControllers(f.Namespace.Name).Create(replicationController)
+		replicationController, err = f.ClientSet.Core().ReplicationControllers(f.Namespace.Name).Create(replicationController)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status captures replication controller creation")
 		usedResources = api.ResourceList{}
 		usedResources[api.ResourceReplicationControllers] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting a ReplicationController")
-		err = f.Client.ReplicationControllers(f.Namespace.Name).Delete(replicationController.Name, nil)
+		err = f.ClientSet.Core().ReplicationControllers(f.Namespace.Name).Delete(replicationController.Name, nil)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released usage")
 		usedResources[api.ResourceReplicationControllers] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -271,7 +271,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		By("Creating a ResourceQuota")
 		quotaName := "test-quota"
 		resourceQuota := newTestResourceQuota(quotaName)
-		resourceQuota, err := createResourceQuota(f.Client, f.Namespace.Name, resourceQuota)
+		resourceQuota, err := createResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuota)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status is calculated")
@@ -279,51 +279,51 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourceQuotas] = resource.MustParse("1")
 		usedResources[api.ResourcePersistentVolumeClaims] = resource.MustParse("0")
 		usedResources[api.ResourceRequestsStorage] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a PersistentVolumeClaim")
 		pvc := newTestPersistentVolumeClaimForQuota("test-claim")
-		pvc, err = f.Client.PersistentVolumeClaims(f.Namespace.Name).Create(pvc)
+		pvc, err = f.ClientSet.Core().PersistentVolumeClaims(f.Namespace.Name).Create(pvc)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status captures persistent volume claimcreation")
 		usedResources = api.ResourceList{}
 		usedResources[api.ResourcePersistentVolumeClaims] = resource.MustParse("1")
 		usedResources[api.ResourceRequestsStorage] = resource.MustParse("1Gi")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting a PersistentVolumeClaim")
-		err = f.Client.PersistentVolumeClaims(f.Namespace.Name).Delete(pvc.Name)
+		err = f.ClientSet.Core().PersistentVolumeClaims(f.Namespace.Name).Delete(pvc.Name, nil)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released usage")
 		usedResources[api.ResourcePersistentVolumeClaims] = resource.MustParse("0")
 		usedResources[api.ResourceRequestsStorage] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, quotaName, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, quotaName, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("should verify ResourceQuota with terminating scopes.", func() {
 		By("Creating a ResourceQuota with terminating scope")
 		quotaTerminatingName := "quota-terminating"
-		resourceQuotaTerminating, err := createResourceQuota(f.Client, f.Namespace.Name, newTestResourceQuotaWithScope(quotaTerminatingName, api.ResourceQuotaScopeTerminating))
+		resourceQuotaTerminating, err := createResourceQuota(f.ClientSet, f.Namespace.Name, newTestResourceQuotaWithScope(quotaTerminatingName, api.ResourceQuotaScopeTerminating))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring ResourceQuota status is calculated")
 		usedResources := api.ResourceList{}
 		usedResources[api.ResourcePods] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaTerminating.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaTerminating.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a ResourceQuota with not terminating scope")
 		quotaNotTerminatingName := "quota-not-terminating"
-		resourceQuotaNotTerminating, err := createResourceQuota(f.Client, f.Namespace.Name, newTestResourceQuotaWithScope(quotaNotTerminatingName, api.ResourceQuotaScopeNotTerminating))
+		resourceQuotaNotTerminating, err := createResourceQuota(f.ClientSet, f.Namespace.Name, newTestResourceQuotaWithScope(quotaNotTerminatingName, api.ResourceQuotaScopeNotTerminating))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring ResourceQuota status is calculated")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaNotTerminating.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaNotTerminating.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a long running pod")
@@ -335,7 +335,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		limits[api.ResourceCPU] = resource.MustParse("1")
 		limits[api.ResourceMemory] = resource.MustParse("400Mi")
 		pod := newTestPodForQuota(f, podName, requests, limits)
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota with not terminating scope captures the pod usage")
@@ -344,7 +344,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourceRequestsMemory] = requests[api.ResourceMemory]
 		usedResources[api.ResourceLimitsCPU] = limits[api.ResourceCPU]
 		usedResources[api.ResourceLimitsMemory] = limits[api.ResourceMemory]
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaNotTerminating.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaNotTerminating.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota with terminating scope ignored the pod usage")
@@ -353,11 +353,11 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourceRequestsMemory] = resource.MustParse("0")
 		usedResources[api.ResourceLimitsCPU] = resource.MustParse("0")
 		usedResources[api.ResourceLimitsMemory] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaTerminating.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaTerminating.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting the pod")
-		err = f.Client.Pods(f.Namespace.Name).Delete(podName, api.NewDeleteOptions(0))
+		err = f.ClientSet.Core().Pods(f.Namespace.Name).Delete(podName, api.NewDeleteOptions(0))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released the pod usage")
@@ -366,7 +366,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourceRequestsMemory] = resource.MustParse("0")
 		usedResources[api.ResourceLimitsCPU] = resource.MustParse("0")
 		usedResources[api.ResourceLimitsMemory] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaNotTerminating.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaNotTerminating.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a terminating pod")
@@ -374,7 +374,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		pod = newTestPodForQuota(f, podName, requests, limits)
 		activeDeadlineSeconds := int64(3600)
 		pod.Spec.ActiveDeadlineSeconds = &activeDeadlineSeconds
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota with terminating scope captures the pod usage")
@@ -383,7 +383,7 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourceRequestsMemory] = requests[api.ResourceMemory]
 		usedResources[api.ResourceLimitsCPU] = limits[api.ResourceCPU]
 		usedResources[api.ResourceLimitsMemory] = limits[api.ResourceMemory]
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaTerminating.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaTerminating.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota with not terminating scope ignored the pod usage")
@@ -392,11 +392,11 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourceRequestsMemory] = resource.MustParse("0")
 		usedResources[api.ResourceLimitsCPU] = resource.MustParse("0")
 		usedResources[api.ResourceLimitsMemory] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaNotTerminating.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaNotTerminating.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting the pod")
-		err = f.Client.Pods(f.Namespace.Name).Delete(podName, api.NewDeleteOptions(0))
+		err = f.ClientSet.Core().Pods(f.Namespace.Name).Delete(podName, api.NewDeleteOptions(0))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released the pod usage")
@@ -405,51 +405,51 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		usedResources[api.ResourceRequestsMemory] = resource.MustParse("0")
 		usedResources[api.ResourceLimitsCPU] = resource.MustParse("0")
 		usedResources[api.ResourceLimitsMemory] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaTerminating.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaTerminating.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("should verify ResourceQuota with best effort scope.", func() {
 		By("Creating a ResourceQuota with best effort scope")
-		resourceQuotaBestEffort, err := createResourceQuota(f.Client, f.Namespace.Name, newTestResourceQuotaWithScope("quota-besteffort", api.ResourceQuotaScopeBestEffort))
+		resourceQuotaBestEffort, err := createResourceQuota(f.ClientSet, f.Namespace.Name, newTestResourceQuotaWithScope("quota-besteffort", api.ResourceQuotaScopeBestEffort))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring ResourceQuota status is calculated")
 		usedResources := api.ResourceList{}
 		usedResources[api.ResourcePods] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaBestEffort.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaBestEffort.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a ResourceQuota with not best effort scope")
-		resourceQuotaNotBestEffort, err := createResourceQuota(f.Client, f.Namespace.Name, newTestResourceQuotaWithScope("quota-not-besteffort", api.ResourceQuotaScopeNotBestEffort))
+		resourceQuotaNotBestEffort, err := createResourceQuota(f.ClientSet, f.Namespace.Name, newTestResourceQuotaWithScope("quota-not-besteffort", api.ResourceQuotaScopeNotBestEffort))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring ResourceQuota status is calculated")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaNotBestEffort.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaNotBestEffort.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a best-effort pod")
 		pod := newTestPodForQuota(f, podName, api.ResourceList{}, api.ResourceList{})
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota with best effort scope captures the pod usage")
 		usedResources[api.ResourcePods] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaBestEffort.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaBestEffort.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota with not best effort ignored the pod usage")
 		usedResources[api.ResourcePods] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaNotBestEffort.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaNotBestEffort.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting the pod")
-		err = f.Client.Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0))
+		err = f.ClientSet.Core().Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released the pod usage")
 		usedResources[api.ResourcePods] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaBestEffort.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaBestEffort.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Creating a not best-effort pod")
@@ -460,26 +460,26 @@ var _ = framework.KubeDescribe("ResourceQuota", func() {
 		limits[api.ResourceCPU] = resource.MustParse("1")
 		limits[api.ResourceMemory] = resource.MustParse("400Mi")
 		pod = newTestPodForQuota(f, "burstable-pod", requests, limits)
-		pod, err = f.Client.Pods(f.Namespace.Name).Create(pod)
+		pod, err = f.ClientSet.Core().Pods(f.Namespace.Name).Create(pod)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota with not best effort scope captures the pod usage")
 		usedResources[api.ResourcePods] = resource.MustParse("1")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaNotBestEffort.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaNotBestEffort.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota with best effort scope ignored the pod usage")
 		usedResources[api.ResourcePods] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaBestEffort.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaBestEffort.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Deleting the pod")
-		err = f.Client.Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0))
+		err = f.ClientSet.Core().Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0))
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring resource quota status released the pod usage")
 		usedResources[api.ResourcePods] = resource.MustParse("0")
-		err = waitForResourceQuota(f.Client, f.Namespace.Name, resourceQuotaNotBestEffort.Name, usedResources)
+		err = waitForResourceQuota(f.ClientSet, f.Namespace.Name, resourceQuotaNotBestEffort.Name, usedResources)
 		Expect(err).NotTo(HaveOccurred())
 	})
 })
@@ -532,7 +532,7 @@ func newTestPodForQuota(f *framework.Framework, name string, requests api.Resour
 			Containers: []api.Container{
 				{
 					Name:  "pause",
-					Image: framework.GetPauseImageName(f.Client),
+					Image: framework.GetPauseImageName(f.ClientSet),
 					Resources: api.ResourceRequirements{
 						Requests: requests,
 						Limits:   limits,
@@ -633,19 +633,19 @@ func newTestSecretForQuota(name string) *api.Secret {
 }
 
 // createResourceQuota in the specified namespace
-func createResourceQuota(c *client.Client, namespace string, resourceQuota *api.ResourceQuota) (*api.ResourceQuota, error) {
+func createResourceQuota(c clientset.Interface, namespace string, resourceQuota *api.ResourceQuota) (*api.ResourceQuota, error) {
-	return c.ResourceQuotas(namespace).Create(resourceQuota)
+	return c.Core().ResourceQuotas(namespace).Create(resourceQuota)
 }
 
 // deleteResourceQuota with the specified name
-func deleteResourceQuota(c *client.Client, namespace, name string) error {
+func deleteResourceQuota(c clientset.Interface, namespace, name string) error {
-	return c.ResourceQuotas(namespace).Delete(name)
+	return c.Core().ResourceQuotas(namespace).Delete(name, nil)
 }
 
 // wait for resource quota status to show the expected used resources value
-func waitForResourceQuota(c *client.Client, ns, quotaName string, used api.ResourceList) error {
+func waitForResourceQuota(c clientset.Interface, ns, quotaName string, used api.ResourceList) error {
 	return wait.Poll(framework.Poll, resourceQuotaTimeout, func() (bool, error) {
-		resourceQuota, err := c.ResourceQuotas(ns).Get(quotaName)
+		resourceQuota, err := c.Core().ResourceQuotas(ns).Get(quotaName)
 		if err != nil {
 			return false, err
 		}

test/e2e/restart.go

@@ -63,7 +63,7 @@ var _ = framework.KubeDescribe("Restart [Disruptive]", func() {
 		// check must be identical to that call.
 		framework.SkipUnlessProviderIs("gce", "gke")
 
-		ps = testutils.NewPodStore(f.Client, api.NamespaceSystem, labels.Everything(), fields.Everything())
+		ps = testutils.NewPodStore(f.ClientSet, api.NamespaceSystem, labels.Everything(), fields.Everything())
 	})
 
 	AfterEach(func() {
@@ -76,7 +76,7 @@ var _ = framework.KubeDescribe("Restart [Disruptive]", func() {
 		nn := framework.TestContext.CloudConfig.NumNodes
 
 		By("ensuring all nodes are ready")
-		nodeNamesBefore, err := framework.CheckNodesReady(f.Client, framework.NodeReadyInitialTimeout, nn)
+		nodeNamesBefore, err := framework.CheckNodesReady(f.ClientSet, framework.NodeReadyInitialTimeout, nn)
 		Expect(err).NotTo(HaveOccurred())
 		framework.Logf("Got the following nodes before restart: %v", nodeNamesBefore)
 
@@ -89,7 +89,7 @@ var _ = framework.KubeDescribe("Restart [Disruptive]", func() {
 			podNamesBefore[i] = p.ObjectMeta.Name
 		}
 		ns := api.NamespaceSystem
-		if !framework.CheckPodsRunningReadyOrSucceeded(f.Client, ns, podNamesBefore, framework.PodReadyBeforeTimeout) {
+		if !framework.CheckPodsRunningReadyOrSucceeded(f.ClientSet, ns, podNamesBefore, framework.PodReadyBeforeTimeout) {
 			framework.Failf("At least one pod wasn't running and ready or succeeded at test start.")
 		}
 
@@ -98,7 +98,7 @@ var _ = framework.KubeDescribe("Restart [Disruptive]", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		By("ensuring all nodes are ready after the restart")
-		nodeNamesAfter, err := framework.CheckNodesReady(f.Client, framework.RestartNodeReadyAgainTimeout, nn)
+		nodeNamesAfter, err := framework.CheckNodesReady(f.ClientSet, framework.RestartNodeReadyAgainTimeout, nn)
 		Expect(err).NotTo(HaveOccurred())
 		framework.Logf("Got the following nodes after restart: %v", nodeNamesAfter)
 
@@ -118,7 +118,7 @@ var _ = framework.KubeDescribe("Restart [Disruptive]", func() {
 		podNamesAfter, err := waitForNPods(ps, len(podNamesBefore), framework.RestartPodReadyAgainTimeout)
 		Expect(err).NotTo(HaveOccurred())
 		remaining := framework.RestartPodReadyAgainTimeout - time.Since(podCheckStart)
-		if !framework.CheckPodsRunningReadyOrSucceeded(f.Client, ns, podNamesAfter, remaining) {
+		if !framework.CheckPodsRunningReadyOrSucceeded(f.ClientSet, ns, podNamesAfter, remaining) {
 			framework.Failf("At least one pod wasn't running and ready after the restart.")
 		}
 	})
@@ -156,7 +156,7 @@ func restartNodes(f *framework.Framework, nodeNames []string) error {
 	// List old boot IDs.
 	oldBootIDs := make(map[string]string)
 	for _, name := range nodeNames {
-		node, err := f.Client.Nodes().Get(name)
+		node, err := f.ClientSet.Core().Nodes().Get(name)
 		if err != nil {
 			return fmt.Errorf("error getting node info before reboot: %s", err)
 		}
@@ -178,7 +178,7 @@ func restartNodes(f *framework.Framework, nodeNames []string) error {
 	// Wait for their boot IDs to change.
 	for _, name := range nodeNames {
 		if err := wait.Poll(30*time.Second, 5*time.Minute, func() (bool, error) {
-			node, err := f.Client.Nodes().Get(name)
+			node, err := f.ClientSet.Core().Nodes().Get(name)
 			if err != nil {
 				return false, fmt.Errorf("error getting node info after reboot: %s", err)
 			}

test/e2e/scheduledjob.go

@@ -26,7 +26,7 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/apis/batch"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
+	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/controller/job"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -53,21 +53,21 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 	It("should schedule multiple jobs concurrently", func() {
 		By("Creating a scheduledjob")
 		scheduledJob := newTestScheduledJob("concurrent", "*/1 * * * ?", batch.AllowConcurrent, true)
-		scheduledJob, err := createScheduledJob(f.Client, f.Namespace.Name, scheduledJob)
+		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring more than one job is running at a time")
-		err = waitForActiveJobs(f.Client, f.Namespace.Name, scheduledJob.Name, 2)
+		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name, 2)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring at least two running jobs exists by listing jobs explicitly")
-		jobs, err := f.Client.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
+		jobs, err := f.ClientSet.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
 		Expect(err).NotTo(HaveOccurred())
 		activeJobs := filterActiveJobs(jobs)
 		Expect(len(activeJobs) >= 2).To(BeTrue())
 
 		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.Client, f.Namespace.Name, scheduledJob.Name)
+		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -76,20 +76,20 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 		By("Creating a suspended scheduledjob")
 		scheduledJob := newTestScheduledJob("suspended", "*/1 * * * ?", batch.AllowConcurrent, true)
 		scheduledJob.Spec.Suspend = newBool(true)
-		scheduledJob, err := createScheduledJob(f.Client, f.Namespace.Name, scheduledJob)
+		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring no jobs are scheduled")
-		err = waitForNoJobs(f.Client, f.Namespace.Name, scheduledJob.Name)
+		err = waitForNoJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).To(HaveOccurred())
 
 		By("Ensuring no job exists by listing jobs explicitly")
-		jobs, err := f.Client.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
+		jobs, err := f.ClientSet.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
 		Expect(err).NotTo(HaveOccurred())
 		Expect(jobs.Items).To(HaveLen(0))
 
 		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.Client, f.Namespace.Name, scheduledJob.Name)
+		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -97,30 +97,30 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 	It("should not schedule new jobs when ForbidConcurrent [Slow]", func() {
 		By("Creating a ForbidConcurrent scheduledjob")
 		scheduledJob := newTestScheduledJob("forbid", "*/1 * * * ?", batch.ForbidConcurrent, true)
-		scheduledJob, err := createScheduledJob(f.Client, f.Namespace.Name, scheduledJob)
+		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring a job is scheduled")
-		err = waitForActiveJobs(f.Client, f.Namespace.Name, scheduledJob.Name, 1)
+		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name, 1)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring exactly one is scheduled")
-		scheduledJob, err = getScheduledJob(f.Client, f.Namespace.Name, scheduledJob.Name)
+		scheduledJob, err = getScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(scheduledJob.Status.Active).Should(HaveLen(1))
 
 		By("Ensuring exaclty one running job exists by listing jobs explicitly")
-		jobs, err := f.Client.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
+		jobs, err := f.ClientSet.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
 		Expect(err).NotTo(HaveOccurred())
 		activeJobs := filterActiveJobs(jobs)
 		Expect(activeJobs).To(HaveLen(1))
 
 		By("Ensuring no more jobs are scheduled")
-		err = waitForActiveJobs(f.Client, f.Namespace.Name, scheduledJob.Name, 2)
+		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name, 2)
 		Expect(err).To(HaveOccurred())
 
 		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.Client, f.Namespace.Name, scheduledJob.Name)
+		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -128,30 +128,30 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 	It("should replace jobs when ReplaceConcurrent", func() {
 		By("Creating a ReplaceConcurrent scheduledjob")
 		scheduledJob := newTestScheduledJob("replace", "*/1 * * * ?", batch.ReplaceConcurrent, true)
-		scheduledJob, err := createScheduledJob(f.Client, f.Namespace.Name, scheduledJob)
+		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring a job is scheduled")
-		err = waitForActiveJobs(f.Client, f.Namespace.Name, scheduledJob.Name, 1)
+		err = waitForActiveJobs(f.ClientSet, f.Namespace.Name, scheduledJob.Name, 1)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring exactly one is scheduled")
-		scheduledJob, err = getScheduledJob(f.Client, f.Namespace.Name, scheduledJob.Name)
+		scheduledJob, err = getScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(scheduledJob.Status.Active).Should(HaveLen(1))
 
 		By("Ensuring exaclty one running job exists by listing jobs explicitly")
-		jobs, err := f.Client.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
+		jobs, err := f.ClientSet.Batch().Jobs(f.Namespace.Name).List(api.ListOptions{})
 		Expect(err).NotTo(HaveOccurred())
 		activeJobs := filterActiveJobs(jobs)
 		Expect(activeJobs).To(HaveLen(1))
 
 		By("Ensuring the job is replaced with a new one")
-		err = waitForJobReplaced(f.Client, f.Namespace.Name, jobs.Items[0].Name)
+		err = waitForJobReplaced(f.ClientSet, f.Namespace.Name, jobs.Items[0].Name)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.Client, f.Namespace.Name, scheduledJob.Name)
+		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -159,21 +159,21 @@ var _ = framework.KubeDescribe("ScheduledJob", func() {
 	It("should not emit unexpected warnings", func() {
 		By("Creating a scheduledjob")
 		scheduledJob := newTestScheduledJob("concurrent", "*/1 * * * ?", batch.AllowConcurrent, false)
-		scheduledJob, err := createScheduledJob(f.Client, f.Namespace.Name, scheduledJob)
+		scheduledJob, err := createScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring at least two jobs and at least one finished job exists by listing jobs explicitly")
-		err = waitForJobsAtLeast(f.Client, f.Namespace.Name, 2)
+		err = waitForJobsAtLeast(f.ClientSet, f.Namespace.Name, 2)
 		Expect(err).NotTo(HaveOccurred())
-		err = waitForAnyFinishedJob(f.Client, f.Namespace.Name)
+		err = waitForAnyFinishedJob(f.ClientSet, f.Namespace.Name)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Ensuring no unexpected event has happened")
-		err = checkNoUnexpectedEvents(f.Client, f.Namespace.Name, scheduledJob.Name)
+		err = checkNoUnexpectedEvents(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 
 		By("Removing scheduledjob")
-		err = deleteScheduledJob(f.Client, f.Namespace.Name, scheduledJob.Name)
+		err = deleteScheduledJob(f.ClientSet, f.Namespace.Name, scheduledJob.Name)
 		Expect(err).NotTo(HaveOccurred())
 	})
 })
@@ -228,20 +228,20 @@ func newTestScheduledJob(name, schedule string, concurrencyPolicy batch.Concurre
 	return sj
 }
 
-func createScheduledJob(c *client.Client, ns string, scheduledJob *batch.ScheduledJob) (*batch.ScheduledJob, error) {
+func createScheduledJob(c clientset.Interface, ns string, scheduledJob *batch.ScheduledJob) (*batch.ScheduledJob, error) {
 	return c.Batch().ScheduledJobs(ns).Create(scheduledJob)
 }
 
-func getScheduledJob(c *client.Client, ns, name string) (*batch.ScheduledJob, error) {
+func getScheduledJob(c clientset.Interface, ns, name string) (*batch.ScheduledJob, error) {
 	return c.Batch().ScheduledJobs(ns).Get(name)
 }
 
-func deleteScheduledJob(c *client.Client, ns, name string) error {
+func deleteScheduledJob(c clientset.Interface, ns, name string) error {
 	return c.Batch().ScheduledJobs(ns).Delete(name, nil)
 }
 
 // Wait for at least given amount of active jobs.
-func waitForActiveJobs(c *client.Client, ns, scheduledJobName string, active int) error {
+func waitForActiveJobs(c clientset.Interface, ns, scheduledJobName string, active int) error {
 	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
 		curr, err := c.Batch().ScheduledJobs(ns).Get(scheduledJobName)
 		if err != nil {
@@ -252,7 +252,7 @@ func waitForActiveJobs(c *client.Client, ns, scheduledJobName string, active int
 }
 
 // Wait for no jobs to appear.
-func waitForNoJobs(c *client.Client, ns, jobName string) error {
+func waitForNoJobs(c clientset.Interface, ns, jobName string) error {
 	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
 		curr, err := c.Batch().ScheduledJobs(ns).Get(jobName)
 		if err != nil {
@@ -264,7 +264,7 @@ func waitForNoJobs(c *client.Client, ns, jobName string) error {
 }
 
 // Wait for a job to be replaced with a new one.
-func waitForJobReplaced(c *client.Client, ns, previousJobName string) error {
+func waitForJobReplaced(c clientset.Interface, ns, previousJobName string) error {
 	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
 		jobs, err := c.Batch().Jobs(ns).List(api.ListOptions{})
 		if err != nil {
@@ -281,7 +281,7 @@ func waitForJobReplaced(c *client.Client, ns, previousJobName string) error {
 }
 
 // waitForJobsAtLeast waits for at least a number of jobs to appear.
-func waitForJobsAtLeast(c *client.Client, ns string, atLeast int) error {
+func waitForJobsAtLeast(c clientset.Interface, ns string, atLeast int) error {
 	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
 		jobs, err := c.Batch().Jobs(ns).List(api.ListOptions{})
 		if err != nil {
@@ -292,7 +292,7 @@ func waitForJobsAtLeast(c *client.Client, ns string, atLeast int) error {
 }
 
 // waitForAnyFinishedJob waits for any completed job to appear.
-func waitForAnyFinishedJob(c *client.Client, ns string) error {
+func waitForAnyFinishedJob(c clientset.Interface, ns string) error {
 	return wait.Poll(framework.Poll, scheduledJobTimeout, func() (bool, error) {
 		jobs, err := c.Batch().Jobs(ns).List(api.ListOptions{})
 		if err != nil {
@@ -309,12 +309,12 @@ func waitForAnyFinishedJob(c *client.Client, ns string) error {
 
 // checkNoUnexpectedEvents checks unexpected events didn't happen.
 // Currently only "UnexpectedJob" is checked.
-func checkNoUnexpectedEvents(c *client.Client, ns, scheduledJobName string) error {
+func checkNoUnexpectedEvents(c clientset.Interface, ns, scheduledJobName string) error {
 	sj, err := c.Batch().ScheduledJobs(ns).Get(scheduledJobName)
 	if err != nil {
 		return fmt.Errorf("error in getting scheduledjob %s/%s: %v", ns, scheduledJobName, err)
 	}
-	events, err := c.Events(ns).Search(sj)
+	events, err := c.Core().Events(ns).Search(sj)
 	if err != nil {
 		return fmt.Errorf("error in listing events: %s", err)
 	}

test/e2e/scheduler_predicates.go

@@ -24,7 +24,6 @@ import (
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/resource"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/uuid"
 	"k8s.io/kubernetes/test/e2e/framework"
@@ -49,7 +48,6 @@ type pausePodConfig struct {
 }
 
 var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
-	var c *client.Client
 	var cs clientset.Interface
 	var nodeList *api.NodeList
 	var systemPodsNo int
@@ -60,30 +58,29 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 	ignoreLabels := framework.ImagePullerLabels
 
 	AfterEach(func() {
-		rc, err := c.ReplicationControllers(ns).Get(RCName)
+		rc, err := cs.Core().ReplicationControllers(ns).Get(RCName)
 		if err == nil && rc.Spec.Replicas != 0 {
 			By("Cleaning up the replication controller")
-			err := framework.DeleteRCAndPods(c, f.ClientSet, ns, RCName)
+			err := framework.DeleteRCAndPods(f.ClientSet, ns, RCName)
 			framework.ExpectNoError(err)
 		}
 	})
 
 	BeforeEach(func() {
-		c = f.Client
 		cs = f.ClientSet
 		ns = f.Namespace.Name
 		nodeList = &api.NodeList{}
 
-		framework.WaitForAllNodesHealthy(c, time.Minute)
+		framework.WaitForAllNodesHealthy(cs, time.Minute)
-		masterNodes, nodeList = framework.GetMasterAndWorkerNodesOrDie(c)
+		masterNodes, nodeList = framework.GetMasterAndWorkerNodesOrDie(cs)
 
-		err := framework.CheckTestingNSDeletedExcept(c, ns)
+		err := framework.CheckTestingNSDeletedExcept(cs, ns)
 		framework.ExpectNoError(err)
 
 		// Every test case in this suite assumes that cluster add-on pods stay stable and
 		// cannot be run in parallel with any other test that touches Nodes or Pods.
 		// It is so because we need to have precise control on what's running in the cluster.
-		systemPods, err := framework.GetPodsInNamespace(c, ns, ignoreLabels)
+		systemPods, err := framework.GetPodsInNamespace(cs, ns, ignoreLabels)
 		Expect(err).NotTo(HaveOccurred())
 		systemPodsNo = 0
 		for _, pod := range systemPods {
@@ -92,12 +89,12 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 			}
 		}
 
-		err = framework.WaitForPodsRunningReady(c, api.NamespaceSystem, int32(systemPodsNo), framework.PodReadyBeforeTimeout, ignoreLabels)
+		err = framework.WaitForPodsRunningReady(cs, api.NamespaceSystem, int32(systemPodsNo), framework.PodReadyBeforeTimeout, ignoreLabels)
 		Expect(err).NotTo(HaveOccurred())
 
 		for _, node := range nodeList.Items {
 			framework.Logf("\nLogging pods the kubelet thinks is on node %v before test", node.Name)
-			framework.PrintAllKubeletPods(c, node.Name)
+			framework.PrintAllKubeletPods(cs, node.Name)
 		}
 
 	})
@@ -117,7 +114,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 			totalPodCapacity += podCapacity.Value()
 		}
 
-		currentlyScheduledPods := framework.WaitForStableCluster(c, masterNodes)
+		currentlyScheduledPods := framework.WaitForStableCluster(cs, masterNodes)
 		podsNeededForSaturation := int(totalPodCapacity) - currentlyScheduledPods
 
 		By(fmt.Sprintf("Starting additional %v Pods to fully saturate the cluster max pods and trying to start another one", podsNeededForSaturation))
@@ -127,7 +124,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// and there is no need to create additional pods.
 		// StartPods requires at least one pod to replicate.
 		if podsNeededForSaturation > 0 {
-			framework.ExpectNoError(testutils.StartPods(c, podsNeededForSaturation, ns, "maxp",
+			framework.ExpectNoError(testutils.StartPods(cs, podsNeededForSaturation, ns, "maxp",
 				*initPausePod(f, pausePodConfig{
 					Name:   "",
 					Labels: map[string]string{"name": ""},
@@ -139,7 +136,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 			Labels: map[string]string{"name": "additional"},
 		})
 		waitForScheduler()
-		verifyResult(c, podsNeededForSaturation, 1, ns)
+		verifyResult(cs, podsNeededForSaturation, 1, ns)
 	})
 
 	// This test verifies we don't allow scheduling of pods in a way that sum of limits of pods is greater than machines capacity.
@@ -157,9 +154,9 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 				nodeMaxCapacity = capacity.MilliValue()
 			}
 		}
-		framework.WaitForStableCluster(c, masterNodes)
+		framework.WaitForStableCluster(cs, masterNodes)
 
-		pods, err := c.Pods(api.NamespaceAll).List(api.ListOptions{})
+		pods, err := cs.Core().Pods(api.NamespaceAll).List(api.ListOptions{})
 		framework.ExpectNoError(err)
 		for _, pod := range pods.Items {
 			_, found := nodeToCapacityMap[pod.Spec.NodeName]
@@ -188,7 +185,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// and there is no need to create additional pods.
 		// StartPods requires at least one pod to replicate.
 		if podsNeededForSaturation > 0 {
-			framework.ExpectNoError(testutils.StartPods(c, podsNeededForSaturation, ns, "overcommit",
+			framework.ExpectNoError(testutils.StartPods(cs, podsNeededForSaturation, ns, "overcommit",
 				*initPausePod(f, pausePodConfig{
 					Name:   "",
 					Labels: map[string]string{"name": ""},
@@ -213,7 +210,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 			},
 		})
 		waitForScheduler()
-		verifyResult(c, podsNeededForSaturation, 1, ns)
+		verifyResult(cs, podsNeededForSaturation, 1, ns)
 	})
 
 	// Test Nodes does not have any label, hence it should be impossible to schedule Pod with
@@ -222,7 +219,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		By("Trying to schedule Pod with nonempty NodeSelector.")
 		podName := "restricted-pod"
 
-		framework.WaitForStableCluster(c, masterNodes)
+		framework.WaitForStableCluster(cs, masterNodes)
 
 		createPausePod(f, pausePodConfig{
 			Name:   podName,
@@ -233,13 +230,13 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		})
 
 		waitForScheduler()
-		verifyResult(c, 0, 1, ns)
+		verifyResult(cs, 0, 1, ns)
 	})
 
 	It("validates that a pod with an invalid NodeAffinity is rejected", func() {
 		By("Trying to launch a pod with an invalid Affinity data.")
 		podName := "without-label"
-		_, err := c.Pods(ns).Create(initPausePod(f, pausePodConfig{
+		_, err := cs.Core().Pods(ns).Create(initPausePod(f, pausePodConfig{
 			Name: podName,
 			Affinity: `{
 				"nodeAffinity": {
@@ -285,8 +282,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// kubelet and the scheduler: the scheduler might have scheduled a pod
 		// already when the kubelet does not know about its new label yet. The
 		// kubelet will then refuse to launch the pod.
-		framework.ExpectNoError(framework.WaitForPodNotPending(c, ns, labelPodName, pod.ResourceVersion))
+		framework.ExpectNoError(framework.WaitForPodNotPending(cs, ns, labelPodName, pod.ResourceVersion))
-		labelPod, err := c.Pods(ns).Get(labelPodName)
+		labelPod, err := cs.Core().Pods(ns).Get(labelPodName)
 		framework.ExpectNoError(err)
 		Expect(labelPod.Spec.NodeName).To(Equal(nodeName))
 	})
@@ -297,7 +294,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		By("Trying to schedule Pod with nonempty NodeSelector.")
 		podName := "restricted-pod"
 
-		framework.WaitForStableCluster(c, masterNodes)
+		framework.WaitForStableCluster(cs, masterNodes)
 
 		createPausePod(f, pausePodConfig{
 			Name: podName,
@@ -326,7 +323,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 			Labels: map[string]string{"name": "restricted"},
 		})
 		waitForScheduler()
-		verifyResult(c, 0, 1, ns)
+		verifyResult(cs, 0, 1, ns)
 	})
 
 	// Keep the same steps with the test on NodeSelector,
@@ -369,8 +366,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// kubelet and the scheduler: the scheduler might have scheduled a pod
 		// already when the kubelet does not know about its new label yet. The
 		// kubelet will then refuse to launch the pod.
-		framework.ExpectNoError(framework.WaitForPodNotPending(c, ns, labelPodName, pod.ResourceVersion))
+		framework.ExpectNoError(framework.WaitForPodNotPending(cs, ns, labelPodName, pod.ResourceVersion))
-		labelPod, err := c.Pods(ns).Get(labelPodName)
+		labelPod, err := cs.Core().Pods(ns).Get(labelPodName)
 		framework.ExpectNoError(err)
 		Expect(labelPod.Spec.NodeName).To(Equal(nodeName))
 	})
@@ -394,8 +391,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// kubelet and the scheduler: the scheduler might have scheduled a pod
 		// already when the kubelet does not know about its new label yet. The
 		// kubelet will then refuse to launch the pod.
-		framework.ExpectNoError(framework.WaitForPodNotPending(c, ns, pod.Name, ""))
+		framework.ExpectNoError(framework.WaitForPodNotPending(cs, ns, pod.Name, ""))
-		labelPod, err := c.Pods(ns).Get(pod.Name)
+		labelPod, err := cs.Core().Pods(ns).Get(pod.Name)
 		framework.ExpectNoError(err)
 		Expect(labelPod.Spec.NodeName).To(Equal(nodeName))
 	})
@@ -405,7 +402,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 	It("validates that a pod with an invalid podAffinity is rejected because of the LabelSelectorRequirement is invalid", func() {
 		By("Trying to launch a pod with an invalid pod Affinity data.")
 		podName := "without-label-" + string(uuid.NewUUID())
-		_, err := c.Pods(ns).Create(initPausePod(f, pausePodConfig{
+		_, err := cs.Core().Pods(ns).Create(initPausePod(f, pausePodConfig{
 			Name:   podName,
 			Labels: map[string]string{"name": "without-label"},
 			Affinity: `{
@@ -439,7 +436,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 	// Test Nodes does not have any pod, hence it should be impossible to schedule a Pod with pod affinity.
 	It("validates that Inter-pod-Affinity is respected if not matching", func() {
 		By("Trying to schedule Pod with nonempty Pod Affinity.")
-		framework.WaitForStableCluster(c, masterNodes)
+		framework.WaitForStableCluster(cs, masterNodes)
 		podName := "without-label-" + string(uuid.NewUUID())
 		createPausePod(f, pausePodConfig{
 			Name: podName,
@@ -460,7 +457,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		})
 
 		waitForScheduler()
-		verifyResult(c, 0, 1, ns)
+		verifyResult(cs, 0, 1, ns)
 	})
 
 	// test the pod affinity successful matching scenario.
@@ -500,8 +497,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// kubelet and the scheduler: the scheduler might have scheduled a pod
 		// already when the kubelet does not know about its new label yet. The
 		// kubelet will then refuse to launch the pod.
-		framework.ExpectNoError(framework.WaitForPodNotPending(c, ns, labelPodName, pod.ResourceVersion))
+		framework.ExpectNoError(framework.WaitForPodNotPending(cs, ns, labelPodName, pod.ResourceVersion))
-		labelPod, err := c.Pods(ns).Get(labelPodName)
+		labelPod, err := cs.Core().Pods(ns).Get(labelPodName)
 		framework.ExpectNoError(err)
 		Expect(labelPod.Spec.NodeName).To(Equal(nodeName))
 	})
@@ -514,8 +511,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// cannot be scheduled onto it.
 		By("Launching two pods on two distinct nodes to get two node names")
 		CreateHostPortPods(f, "host-port", 2, true)
-		defer framework.DeleteRCAndPods(c, f.ClientSet, ns, "host-port")
+		defer framework.DeleteRCAndPods(f.ClientSet, ns, "host-port")
-		podList, err := c.Pods(ns).List(api.ListOptions{})
+		podList, err := cs.Core().Pods(ns).List(api.ListOptions{})
 		ExpectNoError(err)
 		Expect(len(podList.Items)).To(Equal(2))
 		nodeNames := []string{podList.Items[0].Spec.NodeName, podList.Items[1].Spec.NodeName}
@@ -563,7 +560,7 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		})
 
 		waitForScheduler()
-		verifyResult(c, 3, 1, ns)
+		verifyResult(cs, 3, 1, ns)
 	})
 
 	// test the pod affinity successful matching scenario with multiple Label Operators.
@@ -611,8 +608,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// kubelet and the scheduler: the scheduler might have scheduled a pod
 		// already when the kubelet does not know about its new label yet. The
 		// kubelet will then refuse to launch the pod.
-		framework.ExpectNoError(framework.WaitForPodNotPending(c, ns, labelPodName, pod.ResourceVersion))
+		framework.ExpectNoError(framework.WaitForPodNotPending(cs, ns, labelPodName, pod.ResourceVersion))
-		labelPod, err := c.Pods(ns).Get(labelPodName)
+		labelPod, err := cs.Core().Pods(ns).Get(labelPodName)
 		framework.ExpectNoError(err)
 		Expect(labelPod.Spec.NodeName).To(Equal(nodeName))
 	})
@@ -636,8 +633,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// kubelet and the scheduler: the scheduler might have scheduled a pod
 		// already when the kubelet does not know about its new label yet. The
 		// kubelet will then refuse to launch the pod.
-		framework.ExpectNoError(framework.WaitForPodNotPending(c, ns, pod.Name, pod.ResourceVersion))
+		framework.ExpectNoError(framework.WaitForPodNotPending(cs, ns, pod.Name, pod.ResourceVersion))
-		labelPod, err := c.Pods(ns).Get(pod.Name)
+		labelPod, err := cs.Core().Pods(ns).Get(pod.Name)
 		framework.ExpectNoError(err)
 		Expect(labelPod.Spec.NodeName).To(Equal(nodeName))
 	})
@@ -660,8 +657,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// kubelet and the scheduler: the scheduler might have scheduled a pod
 		// already when the kubelet does not know about its new label yet. The
 		// kubelet will then refuse to launch the pod.
-		framework.ExpectNoError(framework.WaitForPodNotPending(c, ns, pod.Name, pod.ResourceVersion))
+		framework.ExpectNoError(framework.WaitForPodNotPending(cs, ns, pod.Name, pod.ResourceVersion))
-		labelPod, err := c.Pods(ns).Get(pod.Name)
+		labelPod, err := cs.Core().Pods(ns).Get(pod.Name)
 		framework.ExpectNoError(err)
 		Expect(labelPod.Spec.NodeName).To(Equal(nodeName))
 	})
@@ -679,9 +676,9 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 			Value:  "testing-taint-value",
 			Effect: api.TaintEffectNoSchedule,
 		}
-		framework.AddOrUpdateTaintOnNode(c, nodeName, testTaint)
+		framework.AddOrUpdateTaintOnNode(cs, nodeName, testTaint)
-		framework.ExpectNodeHasTaint(c, nodeName, testTaint)
+		framework.ExpectNodeHasTaint(cs, nodeName, testTaint)
-		defer framework.RemoveTaintOffNode(c, nodeName, testTaint)
+		defer framework.RemoveTaintOffNode(cs, nodeName, testTaint)
 
 		By("Trying to apply a random label on the found node.")
 		labelKey := fmt.Sprintf("kubernetes.io/e2e-label-key-%s", string(uuid.NewUUID()))
@@ -712,8 +709,8 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		// kubelet and the scheduler: the scheduler might have scheduled a pod
 		// already when the kubelet does not know about its new taint yet. The
 		// kubelet will then refuse to launch the pod.
-		framework.ExpectNoError(framework.WaitForPodNotPending(c, ns, tolerationPodName, pod.ResourceVersion))
+		framework.ExpectNoError(framework.WaitForPodNotPending(cs, ns, tolerationPodName, pod.ResourceVersion))
-		deployedPod, err := c.Pods(ns).Get(tolerationPodName)
+		deployedPod, err := cs.Core().Pods(ns).Get(tolerationPodName)
 		framework.ExpectNoError(err)
 		Expect(deployedPod.Spec.NodeName).To(Equal(nodeName))
 	})
@@ -731,9 +728,9 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 			Value:  "testing-taint-value",
 			Effect: api.TaintEffectNoSchedule,
 		}
-		framework.AddOrUpdateTaintOnNode(c, nodeName, testTaint)
+		framework.AddOrUpdateTaintOnNode(cs, nodeName, testTaint)
-		framework.ExpectNodeHasTaint(c, nodeName, testTaint)
+		framework.ExpectNodeHasTaint(cs, nodeName, testTaint)
-		defer framework.RemoveTaintOffNode(c, nodeName, testTaint)
+		defer framework.RemoveTaintOffNode(cs, nodeName, testTaint)
 
 		By("Trying to apply a random label on the found node.")
 		labelKey := fmt.Sprintf("kubernetes.io/e2e-label-key-%s", string(uuid.NewUUID()))
@@ -750,13 +747,13 @@ var _ = framework.KubeDescribe("SchedulerPredicates [Serial]", func() {
 		})
 
 		waitForScheduler()
-		verifyResult(c, 0, 1, ns)
+		verifyResult(cs, 0, 1, ns)
 
 		By("Removing taint off the node")
-		framework.RemoveTaintOffNode(c, nodeName, testTaint)
+		framework.RemoveTaintOffNode(cs, nodeName, testTaint)
 
 		waitForScheduler()
-		verifyResult(c, 1, 0, ns)
+		verifyResult(cs, 1, 0, ns)
 	})
 })
 
@@ -781,7 +778,7 @@ func initPausePod(f *framework.Framework, conf pausePodConfig) *api.Pod {
 			Containers: []api.Container{
 				{
 					Name:  podName,
-					Image: framework.GetPauseImageName(f.Client),
+					Image: framework.GetPauseImageName(f.ClientSet),
 				},
 			},
 		},
@@ -793,15 +790,15 @@ func initPausePod(f *framework.Framework, conf pausePodConfig) *api.Pod {
 }
 
 func createPausePod(f *framework.Framework, conf pausePodConfig) *api.Pod {
-	pod, err := f.Client.Pods(f.Namespace.Name).Create(initPausePod(f, conf))
+	pod, err := f.ClientSet.Core().Pods(f.Namespace.Name).Create(initPausePod(f, conf))
 	framework.ExpectNoError(err)
 	return pod
 }
 
 func runPausePod(f *framework.Framework, conf pausePodConfig) *api.Pod {
 	pod := createPausePod(f, conf)
-	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.Client, pod))
+	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.ClientSet, pod))
-	pod, err := f.Client.Pods(f.Namespace.Name).Get(conf.Name)
+	pod, err := f.ClientSet.Core().Pods(f.Namespace.Name).Get(conf.Name)
 	framework.ExpectNoError(err)
 	return pod
 }
@@ -814,7 +811,7 @@ func runPodAndGetNodeName(f *framework.Framework, conf pausePodConfig) string {
 	pod := runPausePod(f, conf)
 
 	By("Explicitly delete pod here to free the resource it takes.")
-	err := f.Client.Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0))
+	err := f.ClientSet.Core().Pods(f.Namespace.Name).Delete(pod.Name, api.NewDeleteOptions(0))
 	framework.ExpectNoError(err)
 
 	return pod.Spec.NodeName
@@ -915,8 +912,8 @@ func waitForScheduler() {
 }
 
 // TODO: upgrade calls in PodAffinity tests when we're able to run them
-func verifyResult(c *client.Client, expectedScheduled int, expectedNotScheduled int, ns string) {
+func verifyResult(c clientset.Interface, expectedScheduled int, expectedNotScheduled int, ns string) {
-	allPods, err := c.Pods(ns).List(api.ListOptions{})
+	allPods, err := c.Core().Pods(ns).List(api.ListOptions{})
 	framework.ExpectNoError(err)
 	scheduledPods, notScheduledPods := framework.GetPodsScheduled(masterNodes, allPods)
 

test/e2e/security_context.go

@@ -167,11 +167,11 @@ func testPodSELinuxLabeling(f *framework.Framework, hostIPC bool, hostPID bool)
 	}
 	pod.Spec.Containers[0].Command = []string{"sleep", "6000"}
 
-	client := f.Client.Pods(f.Namespace.Name)
+	client := f.ClientSet.Core().Pods(f.Namespace.Name)
 	pod, err := client.Create(pod)
 
 	framework.ExpectNoError(err, "Error creating pod %v", pod)
-	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.Client, pod))
+	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.ClientSet, pod))
 
 	testContent := "hello"
 	testFilePath := mountPath + "/TEST"
@@ -181,7 +181,7 @@ func testPodSELinuxLabeling(f *framework.Framework, hostIPC bool, hostPID bool)
 	Expect(err).To(BeNil())
 	Expect(content).To(ContainSubstring(testContent))
 
-	foundPod, err := f.Client.Pods(f.Namespace.Name).Get(pod.Name)
+	foundPod, err := f.ClientSet.Core().Pods(f.Namespace.Name).Get(pod.Name)
 	Expect(err).NotTo(HaveOccurred())
 
 	// Confirm that the file can be accessed from a second

test/e2e/service.go

@@ -34,7 +34,6 @@ import (
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/service"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	client "k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/controller/endpoint"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/types"
@@ -80,18 +79,16 @@ var ServiceNodePortRange = utilnet.PortRange{Base: 30000, Size: 2768}
 var _ = framework.KubeDescribe("Services", func() {
 	f := framework.NewDefaultFramework("services")
 
-	var c *client.Client
 	var cs clientset.Interface
 
 	BeforeEach(func() {
-		c = f.Client
 		cs = f.ClientSet
 	})
 
 	// TODO: We get coverage of TCP/UDP and multi-port services through the DNS test. We should have a simpler test for multi-port TCP here.
 
 	It("should provide secure master service [Conformance]", func() {
-		_, err := c.Services(api.NamespaceDefault).Get("kubernetes")
+		_, err := cs.Core().Services(api.NamespaceDefault).Get("kubernetes")
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -106,7 +103,7 @@ var _ = framework.KubeDescribe("Services", func() {
 
 		By("creating service " + serviceName + " in namespace " + ns)
 		defer func() {
-			err := c.Services(ns).Delete(serviceName)
+			err := cs.Core().Services(ns).Delete(serviceName, nil)
 			Expect(err).NotTo(HaveOccurred())
 		}()
 
@@ -122,15 +119,15 @@ var _ = framework.KubeDescribe("Services", func() {
 				}},
 			},
 		}
-		_, err := c.Services(ns).Create(service)
+		_, err := cs.Core().Services(ns).Create(service)
 		Expect(err).NotTo(HaveOccurred())
 
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{})
 
 		names := map[string]bool{}
 		defer func() {
 			for name := range names {
-				err := c.Pods(ns).Delete(name, nil)
+				err := cs.Core().Pods(ns).Delete(name, nil)
 				Expect(err).NotTo(HaveOccurred())
 			}
 		}()
@@ -138,21 +135,21 @@ var _ = framework.KubeDescribe("Services", func() {
 		name1 := "pod1"
 		name2 := "pod2"
 
-		createPodOrFail(c, ns, name1, labels, []api.ContainerPort{{ContainerPort: 80}})
+		createPodOrFail(cs, ns, name1, labels, []api.ContainerPort{{ContainerPort: 80}})
 		names[name1] = true
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{name1: {80}})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{name1: {80}})
 
-		createPodOrFail(c, ns, name2, labels, []api.ContainerPort{{ContainerPort: 80}})
+		createPodOrFail(cs, ns, name2, labels, []api.ContainerPort{{ContainerPort: 80}})
 		names[name2] = true
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{name1: {80}, name2: {80}})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{name1: {80}, name2: {80}})
 
-		deletePodOrFail(c, ns, name1)
+		deletePodOrFail(cs, ns, name1)
 		delete(names, name1)
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{name2: {80}})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{name2: {80}})
 
-		deletePodOrFail(c, ns, name2)
+		deletePodOrFail(cs, ns, name2)
 		delete(names, name2)
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{})
 	})
 
 	It("should serve multiport endpoints from pods [Conformance]", func() {
@@ -162,7 +159,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		ns := f.Namespace.Name
 
 		defer func() {
-			err := c.Services(ns).Delete(serviceName)
+			err := cs.Core().Services(ns).Delete(serviceName, nil)
 			Expect(err).NotTo(HaveOccurred())
 		}()
 
@@ -192,16 +189,16 @@ var _ = framework.KubeDescribe("Services", func() {
 				},
 			},
 		}
-		_, err := c.Services(ns).Create(service)
+		_, err := cs.Core().Services(ns).Create(service)
 		Expect(err).NotTo(HaveOccurred())
 		port1 := 100
 		port2 := 101
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{})
 
 		names := map[string]bool{}
 		defer func() {
 			for name := range names {
-				err := c.Pods(ns).Delete(name, nil)
+				err := cs.Core().Pods(ns).Delete(name, nil)
 				Expect(err).NotTo(HaveOccurred())
 			}
 		}()
@@ -222,21 +219,21 @@ var _ = framework.KubeDescribe("Services", func() {
 		podname1 := "pod1"
 		podname2 := "pod2"
 
-		createPodOrFail(c, ns, podname1, labels, containerPorts1)
+		createPodOrFail(cs, ns, podname1, labels, containerPorts1)
 		names[podname1] = true
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{podname1: {port1}})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{podname1: {port1}})
 
-		createPodOrFail(c, ns, podname2, labels, containerPorts2)
+		createPodOrFail(cs, ns, podname2, labels, containerPorts2)
 		names[podname2] = true
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{podname1: {port1}, podname2: {port2}})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{podname1: {port1}, podname2: {port2}})
 
-		deletePodOrFail(c, ns, podname1)
+		deletePodOrFail(cs, ns, podname1)
 		delete(names, podname1)
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{podname2: {port2}})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{podname2: {port2}})
 
-		deletePodOrFail(c, ns, podname2)
+		deletePodOrFail(cs, ns, podname2)
 		delete(names, podname2)
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{})
 	})
 
 	It("should preserve source pod IP for traffic thru service cluster IP", func() {
@@ -245,13 +242,13 @@ var _ = framework.KubeDescribe("Services", func() {
 		ns := f.Namespace.Name
 
 		By("creating a TCP service " + serviceName + " with type=ClusterIP in namespace " + ns)
-		jig := NewServiceTestJig(c, cs, serviceName)
+		jig := NewServiceTestJig(cs, serviceName)
 		servicePort := 8080
 		tcpService := jig.CreateTCPServiceWithPort(ns, nil, int32(servicePort))
 		jig.SanityCheckService(tcpService, api.ServiceTypeClusterIP)
 		defer func() {
 			framework.Logf("Cleaning up the sourceip test service")
-			err := c.Services(ns).Delete(serviceName)
+			err := cs.Core().Services(ns).Delete(serviceName, nil)
 			Expect(err).NotTo(HaveOccurred())
 		}()
 		serviceIp := tcpService.Spec.ClusterIP
@@ -272,20 +269,20 @@ var _ = framework.KubeDescribe("Services", func() {
 		jig.launchEchoserverPodOnNode(f, node1.Name, serverPodName)
 		defer func() {
 			framework.Logf("Cleaning up the echo server pod")
-			err := c.Pods(ns).Delete(serverPodName, nil)
+			err := cs.Core().Pods(ns).Delete(serverPodName, nil)
 			Expect(err).NotTo(HaveOccurred())
 		}()
 
 		// Waiting for service to expose endpoint.
-		validateEndpointsOrFail(c, ns, serviceName, PortsByPodName{serverPodName: {servicePort}})
+		validateEndpointsOrFail(cs, ns, serviceName, PortsByPodName{serverPodName: {servicePort}})
 
 		By("Retrieve sourceip from a pod on the same node")
-		sourceIp1, execPodIp1 := execSourceipTest(f, c, ns, node1.Name, serviceIp, servicePort)
+		sourceIp1, execPodIp1 := execSourceipTest(f, cs, ns, node1.Name, serviceIp, servicePort)
 		By("Verifying the preserved source ip")
 		Expect(sourceIp1).To(Equal(execPodIp1))
 
 		By("Retrieve sourceip from a pod on a different node")
-		sourceIp2, execPodIp2 := execSourceipTest(f, c, ns, node2.Name, serviceIp, servicePort)
+		sourceIp2, execPodIp2 := execSourceipTest(f, cs, ns, node2.Name, serviceIp, servicePort)
 		By("Verifying the preserved source ip")
 		Expect(sourceIp2).To(Equal(execPodIp2))
 	})
@@ -298,13 +295,13 @@ var _ = framework.KubeDescribe("Services", func() {
 		numPods, servicePort := 3, 80
 
 		By("creating service1 in namespace " + ns)
-		podNames1, svc1IP, err := startServeHostnameService(c, ns, "service1", servicePort, numPods)
+		podNames1, svc1IP, err := startServeHostnameService(cs, ns, "service1", servicePort, numPods)
 		Expect(err).NotTo(HaveOccurred())
 		By("creating service2 in namespace " + ns)
-		podNames2, svc2IP, err := startServeHostnameService(c, ns, "service2", servicePort, numPods)
+		podNames2, svc2IP, err := startServeHostnameService(cs, ns, "service2", servicePort, numPods)
 		Expect(err).NotTo(HaveOccurred())
 
-		hosts, err := framework.NodeSSHHosts(f.ClientSet)
+		hosts, err := framework.NodeSSHHosts(cs)
 		Expect(err).NotTo(HaveOccurred())
 		if len(hosts) == 0 {
 			framework.Failf("No ssh-able nodes")
@@ -312,23 +309,23 @@ var _ = framework.KubeDescribe("Services", func() {
 		host := hosts[0]
 
 		By("verifying service1 is up")
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames1, svc1IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames1, svc1IP, servicePort))
 
 		By("verifying service2 is up")
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames2, svc2IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames2, svc2IP, servicePort))
 
 		// Stop service 1 and make sure it is gone.
 		By("stopping service1")
-		framework.ExpectNoError(stopServeHostnameService(c, f.ClientSet, ns, "service1"))
+		framework.ExpectNoError(stopServeHostnameService(f.ClientSet, ns, "service1"))
 
 		By("verifying service1 is not up")
-		framework.ExpectNoError(verifyServeHostnameServiceDown(c, host, svc1IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceDown(cs, host, svc1IP, servicePort))
 		By("verifying service2 is still up")
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames2, svc2IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames2, svc2IP, servicePort))
 
 		// Start another service and verify both are up.
 		By("creating service3 in namespace " + ns)
-		podNames3, svc3IP, err := startServeHostnameService(c, ns, "service3", servicePort, numPods)
+		podNames3, svc3IP, err := startServeHostnameService(cs, ns, "service3", servicePort, numPods)
 		Expect(err).NotTo(HaveOccurred())
 
 		if svc2IP == svc3IP {
@@ -336,10 +333,10 @@ var _ = framework.KubeDescribe("Services", func() {
 		}
 
 		By("verifying service2 is still up")
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames2, svc2IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames2, svc2IP, servicePort))
 
 		By("verifying service3 is up")
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames3, svc3IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames3, svc3IP, servicePort))
 	})
 
 	It("should work after restarting kube-proxy [Disruptive]", func() {
@@ -352,34 +349,34 @@ var _ = framework.KubeDescribe("Services", func() {
 		svc1 := "service1"
 		svc2 := "service2"
 
-		defer func() { framework.ExpectNoError(stopServeHostnameService(c, f.ClientSet, ns, svc1)) }()
+		defer func() { framework.ExpectNoError(stopServeHostnameService(f.ClientSet, ns, svc1)) }()
-		podNames1, svc1IP, err := startServeHostnameService(c, ns, svc1, servicePort, numPods)
+		podNames1, svc1IP, err := startServeHostnameService(cs, ns, svc1, servicePort, numPods)
 		Expect(err).NotTo(HaveOccurred())
 
-		defer func() { framework.ExpectNoError(stopServeHostnameService(c, f.ClientSet, ns, svc2)) }()
+		defer func() { framework.ExpectNoError(stopServeHostnameService(f.ClientSet, ns, svc2)) }()
-		podNames2, svc2IP, err := startServeHostnameService(c, ns, svc2, servicePort, numPods)
+		podNames2, svc2IP, err := startServeHostnameService(cs, ns, svc2, servicePort, numPods)
 		Expect(err).NotTo(HaveOccurred())
 
 		if svc1IP == svc2IP {
 			framework.Failf("VIPs conflict: %v", svc1IP)
 		}
 
-		hosts, err := framework.NodeSSHHosts(f.ClientSet)
+		hosts, err := framework.NodeSSHHosts(cs)
 		Expect(err).NotTo(HaveOccurred())
 		if len(hosts) == 0 {
 			framework.Failf("No ssh-able nodes")
 		}
 		host := hosts[0]
 
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames1, svc1IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames1, svc1IP, servicePort))
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames2, svc2IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames2, svc2IP, servicePort))
 
 		By(fmt.Sprintf("Restarting kube-proxy on %v", host))
 		if err := framework.RestartKubeProxy(host); err != nil {
 			framework.Failf("error restarting kube-proxy: %v", err)
 		}
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames1, svc1IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames1, svc1IP, servicePort))
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames2, svc2IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames2, svc2IP, servicePort))
 
 		By("Removing iptable rules")
 		result, err := framework.SSH(`
@@ -390,8 +387,8 @@ var _ = framework.KubeDescribe("Services", func() {
 			framework.LogSSHResult(result)
 			framework.Failf("couldn't remove iptable rules: %v", err)
 		}
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames1, svc1IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames1, svc1IP, servicePort))
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames2, svc2IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames2, svc2IP, servicePort))
 	})
 
 	It("should work after restarting apiserver [Disruptive]", func() {
@@ -401,40 +398,40 @@ var _ = framework.KubeDescribe("Services", func() {
 		ns := f.Namespace.Name
 		numPods, servicePort := 3, 80
 
-		defer func() { framework.ExpectNoError(stopServeHostnameService(c, f.ClientSet, ns, "service1")) }()
+		defer func() { framework.ExpectNoError(stopServeHostnameService(f.ClientSet, ns, "service1")) }()
-		podNames1, svc1IP, err := startServeHostnameService(c, ns, "service1", servicePort, numPods)
+		podNames1, svc1IP, err := startServeHostnameService(cs, ns, "service1", servicePort, numPods)
 		Expect(err).NotTo(HaveOccurred())
 
-		hosts, err := framework.NodeSSHHosts(f.ClientSet)
+		hosts, err := framework.NodeSSHHosts(cs)
 		Expect(err).NotTo(HaveOccurred())
 		if len(hosts) == 0 {
 			framework.Failf("No ssh-able nodes")
 		}
 		host := hosts[0]
 
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames1, svc1IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames1, svc1IP, servicePort))
 
 		// Restart apiserver
 		By("Restarting apiserver")
-		if err := framework.RestartApiserver(c); err != nil {
+		if err := framework.RestartApiserver(cs.Discovery()); err != nil {
 			framework.Failf("error restarting apiserver: %v", err)
 		}
 		By("Waiting for apiserver to come up by polling /healthz")
-		if err := framework.WaitForApiserverUp(c); err != nil {
+		if err := framework.WaitForApiserverUp(cs); err != nil {
 			framework.Failf("error while waiting for apiserver up: %v", err)
 		}
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames1, svc1IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames1, svc1IP, servicePort))
 
 		// Create a new service and check if it's not reusing IP.
-		defer func() { framework.ExpectNoError(stopServeHostnameService(c, f.ClientSet, ns, "service2")) }()
+		defer func() { framework.ExpectNoError(stopServeHostnameService(f.ClientSet, ns, "service2")) }()
-		podNames2, svc2IP, err := startServeHostnameService(c, ns, "service2", servicePort, numPods)
+		podNames2, svc2IP, err := startServeHostnameService(cs, ns, "service2", servicePort, numPods)
 		Expect(err).NotTo(HaveOccurred())
 
 		if svc1IP == svc2IP {
 			framework.Failf("VIPs conflict: %v", svc1IP)
 		}
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames1, svc1IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames1, svc1IP, servicePort))
-		framework.ExpectNoError(verifyServeHostnameServiceUp(c, ns, host, podNames2, svc2IP, servicePort))
+		framework.ExpectNoError(verifyServeHostnameServiceUp(cs, ns, host, podNames2, svc2IP, servicePort))
 	})
 
 	// TODO: Run this test against the userspace proxy and nodes
@@ -444,8 +441,8 @@ var _ = framework.KubeDescribe("Services", func() {
 		serviceName := "nodeport-test"
 		ns := f.Namespace.Name
 
-		jig := NewServiceTestJig(c, cs, serviceName)
+		jig := NewServiceTestJig(cs, serviceName)
-		nodeIP := pickNodeIP(jig.ClientSet) // for later
+		nodeIP := pickNodeIP(jig.Client) // for later
 
 		By("creating service " + serviceName + " with type=NodePort in namespace " + ns)
 		service := jig.CreateTCPServiceOrFail(ns, func(svc *api.Service) {
@@ -461,7 +458,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		jig.TestReachableHTTP(nodeIP, nodePort, kubeProxyLagTimeout)
 
 		By("verifying the node port is locked")
-		hostExec := framework.LaunchHostExecPod(f.Client, f.Namespace.Name, "hostexec")
+		hostExec := framework.LaunchHostExecPod(f.ClientSet, f.Namespace.Name, "hostexec")
 		// Even if the node-ip:node-port check above passed, this hostexec pod
 		// might fall on a node with a laggy kube-proxy.
 		cmd := fmt.Sprintf(`for i in $(seq 1 300); do if ss -ant46 'sport = :%d' | grep ^LISTEN; then exit 0; fi; sleep 1; done; exit 1`, nodePort)
@@ -500,8 +497,8 @@ var _ = framework.KubeDescribe("Services", func() {
 		ns2 := namespacePtr.Name // LB2 in ns2 on UDP
 		framework.Logf("namespace for UDP test: %s", ns2)
 
-		jig := NewServiceTestJig(c, cs, serviceName)
+		jig := NewServiceTestJig(cs, serviceName)
-		nodeIP := pickNodeIP(jig.ClientSet) // for later
+		nodeIP := pickNodeIP(jig.Client) // for later
 
 		// Test TCP and UDP Services.  Services with the same name in different
 		// namespaces should get different node ports and load balancers.
@@ -794,7 +791,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		serviceName := "nodeports"
 		ns := f.Namespace.Name
 
-		t := NewServerTest(c, ns, serviceName)
+		t := NewServerTest(cs, ns, serviceName)
 		defer func() {
 			defer GinkgoRecover()
 			errs := t.Cleanup()
@@ -844,7 +841,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		serviceName2 := baseName + "2"
 		ns := f.Namespace.Name
 
-		t := NewServerTest(c, ns, serviceName1)
+		t := NewServerTest(cs, ns, serviceName1)
 		defer func() {
 			defer GinkgoRecover()
 			errs := t.Cleanup()
@@ -896,7 +893,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		serviceName := "nodeport-range-test"
 		ns := f.Namespace.Name
 
-		t := NewServerTest(c, ns, serviceName)
+		t := NewServerTest(cs, ns, serviceName)
 		defer func() {
 			defer GinkgoRecover()
 			errs := t.Cleanup()
@@ -935,7 +932,7 @@ var _ = framework.KubeDescribe("Services", func() {
 			}
 		}
 		By(fmt.Sprintf("changing service "+serviceName+" to out-of-range NodePort %d", outOfRangeNodePort))
-		result, err := updateService(c, ns, serviceName, func(s *api.Service) {
+		result, err := updateService(cs, ns, serviceName, func(s *api.Service) {
 			s.Spec.Ports[0].NodePort = int32(outOfRangeNodePort)
 		})
 		if err == nil {
@@ -964,7 +961,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		serviceName := "nodeport-reuse"
 		ns := f.Namespace.Name
 
-		t := NewServerTest(c, ns, serviceName)
+		t := NewServerTest(cs, ns, serviceName)
 		defer func() {
 			defer GinkgoRecover()
 			errs := t.Cleanup()
@@ -999,7 +996,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		err = t.DeleteService(serviceName)
 		Expect(err).NotTo(HaveOccurred())
 
-		hostExec := framework.LaunchHostExecPod(f.Client, f.Namespace.Name, "hostexec")
+		hostExec := framework.LaunchHostExecPod(f.ClientSet, f.Namespace.Name, "hostexec")
 		cmd := fmt.Sprintf(`! ss -ant46 'sport = :%d' | tail -n +2 | grep LISTEN`, nodePort)
 		var stdout string
 		if pollErr := wait.PollImmediate(framework.Poll, kubeProxyLagTimeout, func() (bool, error) {
@@ -1026,7 +1023,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		serviceName := "never-ready"
 		ns := f.Namespace.Name
 
-		t := NewServerTest(c, ns, serviceName)
+		t := NewServerTest(cs, ns, serviceName)
 		defer func() {
 			defer GinkgoRecover()
 			errs := t.Cleanup()
@@ -1064,7 +1061,7 @@ var _ = framework.KubeDescribe("Services", func() {
 		svcName := fmt.Sprintf("%v.%v", serviceName, f.Namespace.Name)
 		By("waiting for endpoints of Service with DNS name " + svcName)
 
-		execPodName := createExecPodOrFail(f.Client, f.Namespace.Name, "execpod-")
+		execPodName := createExecPodOrFail(f.ClientSet, f.Namespace.Name, "execpod-")
 		cmd := fmt.Sprintf("wget -qO- %v", svcName)
 		var stdout string
 		if pollErr := wait.PollImmediate(framework.Poll, kubeProxyLagTimeout, func() (bool, error) {
@@ -1085,14 +1082,12 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 	f := framework.NewDefaultFramework("esipp")
 	loadBalancerCreateTimeout := loadBalancerCreateTimeoutDefault
 
-	var c *client.Client
 	var cs clientset.Interface
 
 	BeforeEach(func() {
 		// requires cloud load-balancer support - this feature currently supported only on GCE/GKE
 		framework.SkipUnlessProviderIs("gce", "gke")
 
-		c = f.Client
 		cs = f.ClientSet
 		if nodes := framework.GetReadySchedulableNodesOrDie(cs); len(nodes.Items) > largeClusterMinNodesNumber {
 			loadBalancerCreateTimeout = loadBalancerCreateTimeoutLarge
@@ -1102,7 +1097,7 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 	It("should work for type=LoadBalancer [Slow][Feature:ExternalTrafficLocalOnly]", func() {
 		namespace := f.Namespace.Name
 		serviceName := "external-local"
-		jig := NewServiceTestJig(c, cs, serviceName)
+		jig := NewServiceTestJig(cs, serviceName)
 
 		svc := jig.createOnlyLocalLoadBalancerService(namespace, serviceName, loadBalancerCreateTimeout, true)
 		healthCheckNodePort := int(service.GetServiceHealthCheckNodePort(svc))
@@ -1120,7 +1115,7 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 				}
 				break
 			}
-			Expect(c.Services(svc.Namespace).Delete(svc.Name)).NotTo(HaveOccurred())
+			Expect(cs.Core().Services(svc.Namespace).Delete(svc.Name, nil)).NotTo(HaveOccurred())
 		}()
 
 		svcTCPPort := int(svc.Spec.Ports[0].Port)
@@ -1140,11 +1135,11 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 	It("should work for type=NodePort [Slow][Feature:ExternalTrafficLocalOnly]", func() {
 		namespace := f.Namespace.Name
 		serviceName := "external-local"
-		jig := NewServiceTestJig(c, cs, serviceName)
+		jig := NewServiceTestJig(cs, serviceName)
 
 		svc := jig.createOnlyLocalNodePortService(namespace, serviceName, true)
 		defer func() {
-			Expect(c.Services(svc.Namespace).Delete(svc.Name)).NotTo(HaveOccurred())
+			Expect(cs.Core().Services(svc.Namespace).Delete(svc.Name, nil)).NotTo(HaveOccurred())
 		}()
 
 		tcpNodePort := int(svc.Spec.Ports[0].NodePort)
@@ -1166,13 +1161,13 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 	It("should only target nodes with endpoints [Slow][Feature:ExternalTrafficLocalOnly]", func() {
 		namespace := f.Namespace.Name
 		serviceName := "external-local"
-		jig := NewServiceTestJig(c, cs, serviceName)
+		jig := NewServiceTestJig(cs, serviceName)
 		nodes := jig.getNodes(maxNodesForEndpointsTests)
 
 		svc := jig.createOnlyLocalLoadBalancerService(namespace, serviceName, loadBalancerCreateTimeout, false)
 		defer func() {
 			jig.ChangeServiceType(svc.Namespace, svc.Name, api.ServiceTypeClusterIP, loadBalancerCreateTimeout)
-			Expect(c.Services(svc.Namespace).Delete(svc.Name)).NotTo(HaveOccurred())
+			Expect(cs.Core().Services(svc.Namespace).Delete(svc.Name, nil)).NotTo(HaveOccurred())
 		}()
 
 		healthCheckNodePort := int(service.GetServiceHealthCheckNodePort(svc))
@@ -1218,20 +1213,20 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 				// Make sure the loadbalancer picked up the helth check change
 				jig.TestReachableHTTP(ingressIP, svcTCPPort, kubeProxyLagTimeout)
 			}
-			framework.ExpectNoError(framework.DeleteRCAndPods(c, f.ClientSet, namespace, serviceName))
+			framework.ExpectNoError(framework.DeleteRCAndPods(f.ClientSet, namespace, serviceName))
 		}
 	})
 
 	It("should work from pods [Slow][Feature:ExternalTrafficLocalOnly]", func() {
 		namespace := f.Namespace.Name
 		serviceName := "external-local"
-		jig := NewServiceTestJig(c, cs, serviceName)
+		jig := NewServiceTestJig(cs, serviceName)
 		nodes := jig.getNodes(maxNodesForEndpointsTests)
 
 		svc := jig.createOnlyLocalLoadBalancerService(namespace, serviceName, loadBalancerCreateTimeout, true)
 		defer func() {
 			jig.ChangeServiceType(svc.Namespace, svc.Name, api.ServiceTypeClusterIP, loadBalancerCreateTimeout)
-			Expect(c.Services(svc.Namespace).Delete(svc.Name)).NotTo(HaveOccurred())
+			Expect(cs.Core().Services(svc.Namespace).Delete(svc.Name, nil)).NotTo(HaveOccurred())
 		}()
 
 		ingressIP := getIngressPoint(&svc.Status.LoadBalancer.Ingress[0])
@@ -1240,12 +1235,12 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 		podName := "execpod-sourceip"
 
 		By(fmt.Sprintf("Creating %v on node %v", podName, nodeName))
-		execPodName := createExecPodOnNode(f.Client, namespace, nodeName, podName)
+		execPodName := createExecPodOnNode(f.ClientSet, namespace, nodeName, podName)
 		defer func() {
-			err := c.Pods(namespace).Delete(execPodName, nil)
+			err := cs.Core().Pods(namespace).Delete(execPodName, nil)
 			Expect(err).NotTo(HaveOccurred())
 		}()
-		execPod, err := f.Client.Pods(namespace).Get(execPodName)
+		execPod, err := f.ClientSet.Core().Pods(namespace).Get(execPodName)
 		ExpectNoError(err)
 
 		framework.Logf("Waiting up to %v wget %v", kubeProxyLagTimeout, path)
@@ -1269,7 +1264,7 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 	It("should handle updates to source ip annotation [Slow][Feature:ExternalTrafficLocalOnly]", func() {
 		namespace := f.Namespace.Name
 		serviceName := "external-local"
-		jig := NewServiceTestJig(c, cs, serviceName)
+		jig := NewServiceTestJig(cs, serviceName)
 
 		nodes := jig.getNodes(maxNodesForEndpointsTests)
 		if len(nodes.Items) < 2 {
@@ -1279,7 +1274,7 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 		svc := jig.createOnlyLocalLoadBalancerService(namespace, serviceName, loadBalancerCreateTimeout, true)
 		defer func() {
 			jig.ChangeServiceType(svc.Namespace, svc.Name, api.ServiceTypeClusterIP, loadBalancerCreateTimeout)
-			Expect(c.Services(svc.Namespace).Delete(svc.Name)).NotTo(HaveOccurred())
+			Expect(cs.Core().Services(svc.Namespace).Delete(svc.Name, nil)).NotTo(HaveOccurred())
 		}()
 
 		// save the health check node port because it disappears when lift the annotation.
@@ -1375,18 +1370,18 @@ var _ = framework.KubeDescribe("ESIPP [Slow][Feature:ExternalTrafficLocalOnly]",
 // updateService fetches a service, calls the update function on it,
 // and then attempts to send the updated service. It retries up to 2
 // times in the face of timeouts and conflicts.
-func updateService(c *client.Client, namespace, serviceName string, update func(*api.Service)) (*api.Service, error) {
+func updateService(c clientset.Interface, namespace, serviceName string, update func(*api.Service)) (*api.Service, error) {
 	var service *api.Service
 	var err error
 	for i := 0; i < 3; i++ {
-		service, err = c.Services(namespace).Get(serviceName)
+		service, err = c.Core().Services(namespace).Get(serviceName)
 		if err != nil {
 			return service, err
 		}
 
 		update(service)
 
-		service, err = c.Services(namespace).Update(service)
+		service, err = c.Core().Services(namespace).Update(service)
 
 		if !errors.IsConflict(err) && !errors.IsServerTimeout(err) {
 			return service, err
@@ -1430,11 +1425,11 @@ func getContainerPortsByPodUID(endpoints *api.Endpoints) PortsByPodUID {
 type PortsByPodName map[string][]int
 type PortsByPodUID map[types.UID][]int
 
-func translatePodNameToUIDOrFail(c *client.Client, ns string, expectedEndpoints PortsByPodName) PortsByPodUID {
+func translatePodNameToUIDOrFail(c clientset.Interface, ns string, expectedEndpoints PortsByPodName) PortsByPodUID {
 	portsByUID := make(PortsByPodUID)
 
 	for name, portList := range expectedEndpoints {
-		pod, err := c.Pods(ns).Get(name)
+		pod, err := c.Core().Pods(ns).Get(name)
 		if err != nil {
 			framework.Failf("failed to get pod %s, that's pretty weird. validation failed: %s", name, err)
 		}
@@ -1466,11 +1461,11 @@ func validatePortsOrFail(endpoints PortsByPodUID, expectedEndpoints PortsByPodUI
 	}
 }
 
-func validateEndpointsOrFail(c *client.Client, namespace, serviceName string, expectedEndpoints PortsByPodName) {
+func validateEndpointsOrFail(c clientset.Interface, namespace, serviceName string, expectedEndpoints PortsByPodName) {
 	By(fmt.Sprintf("waiting up to %v for service %s in namespace %s to expose endpoints %v", framework.ServiceStartTimeout, serviceName, namespace, expectedEndpoints))
 	i := 1
 	for start := time.Now(); time.Since(start) < framework.ServiceStartTimeout; time.Sleep(1 * time.Second) {
-		endpoints, err := c.Endpoints(namespace).Get(serviceName)
+		endpoints, err := c.Core().Endpoints(namespace).Get(serviceName)
 		if err != nil {
 			framework.Logf("Get endpoints failed (%v elapsed, ignoring for 5s): %v", time.Since(start), err)
 			continue
@@ -1494,7 +1489,7 @@ func validateEndpointsOrFail(c *client.Client, namespace, serviceName string, ex
 		i++
 	}
 
-	if pods, err := c.Pods(api.NamespaceAll).List(api.ListOptions{}); err == nil {
+	if pods, err := c.Core().Pods(api.NamespaceAll).List(api.ListOptions{}); err == nil {
 		for _, pod := range pods.Items {
 			framework.Logf("Pod %s\t%s\t%s\t%s", pod.Namespace, pod.Name, pod.Spec.NodeName, pod.DeletionTimestamp)
 		}
@@ -1529,13 +1524,13 @@ func newExecPodSpec(ns, generateName string) *api.Pod {
 // createExecPodOrFail creates a simple busybox pod in a sleep loop used as a
 // vessel for kubectl exec commands.
 // Returns the name of the created pod.
-func createExecPodOrFail(client *client.Client, ns, generateName string) string {
+func createExecPodOrFail(client clientset.Interface, ns, generateName string) string {
 	framework.Logf("Creating new exec pod")
 	execPod := newExecPodSpec(ns, generateName)
-	created, err := client.Pods(ns).Create(execPod)
+	created, err := client.Core().Pods(ns).Create(execPod)
 	Expect(err).NotTo(HaveOccurred())
 	err = wait.PollImmediate(framework.Poll, 5*time.Minute, func() (bool, error) {
-		retrievedPod, err := client.Pods(execPod.Namespace).Get(created.Name)
+		retrievedPod, err := client.Core().Pods(execPod.Namespace).Get(created.Name)
 		if err != nil {
 			return false, nil
 		}
@@ -1547,14 +1542,14 @@ func createExecPodOrFail(client *client.Client, ns, generateName string) string
 
 // createExecPodOnNode launches a exec pod in the given namespace and node
 // waits until it's Running, created pod name would be returned
-func createExecPodOnNode(client *client.Client, ns, nodeName, generateName string) string {
+func createExecPodOnNode(client clientset.Interface, ns, nodeName, generateName string) string {
 	framework.Logf("Creating exec pod %q in namespace %q", generateName, ns)
 	execPod := newExecPodSpec(ns, generateName)
 	execPod.Spec.NodeName = nodeName
-	created, err := client.Pods(ns).Create(execPod)
+	created, err := client.Core().Pods(ns).Create(execPod)
 	Expect(err).NotTo(HaveOccurred())
 	err = wait.PollImmediate(framework.Poll, 5*time.Minute, func() (bool, error) {
-		retrievedPod, err := client.Pods(execPod.Namespace).Get(created.Name)
+		retrievedPod, err := client.Core().Pods(execPod.Namespace).Get(created.Name)
 		if err != nil {
 			return false, nil
 		}
@@ -1564,7 +1559,7 @@ func createExecPodOnNode(client *client.Client, ns, nodeName, generateName strin
 	return created.Name
 }
 
-func createPodOrFail(c *client.Client, ns, name string, labels map[string]string, containerPorts []api.ContainerPort) {
+func createPodOrFail(c clientset.Interface, ns, name string, labels map[string]string, containerPorts []api.ContainerPort) {
 	By(fmt.Sprintf("creating pod %s in namespace %s", name, ns))
 	pod := &api.Pod{
 		ObjectMeta: api.ObjectMeta{
@@ -1584,13 +1579,13 @@ func createPodOrFail(c *client.Client, ns, name string, labels map[string]string
 			},
 		},
 	}
-	_, err := c.Pods(ns).Create(pod)
+	_, err := c.Core().Pods(ns).Create(pod)
 	Expect(err).NotTo(HaveOccurred())
 }
 
-func deletePodOrFail(c *client.Client, ns, name string) {
+func deletePodOrFail(c clientset.Interface, ns, name string) {
 	By(fmt.Sprintf("deleting pod %s in namespace %s", name, ns))
-	err := c.Pods(ns).Delete(name, nil)
+	err := c.Core().Pods(ns).Delete(name, nil)
 	Expect(err).NotTo(HaveOccurred())
 }
 
@@ -1612,8 +1607,8 @@ func collectAddresses(nodes *api.NodeList, addressType api.NodeAddressType) []st
 	return ips
 }
 
-func getNodePublicIps(cs clientset.Interface) ([]string, error) {
+func getNodePublicIps(c clientset.Interface) ([]string, error) {
-	nodes := framework.GetReadySchedulableNodesOrDie(cs)
+	nodes := framework.GetReadySchedulableNodesOrDie(c)
 
 	ips := collectAddresses(nodes, api.NodeExternalIP)
 	if len(ips) == 0 {
@@ -1622,8 +1617,8 @@ func getNodePublicIps(cs clientset.Interface) ([]string, error) {
 	return ips, nil
 }
 
-func pickNodeIP(cs clientset.Interface) string {
+func pickNodeIP(c clientset.Interface) string {
-	publicIps, err := getNodePublicIps(cs)
+	publicIps, err := getNodePublicIps(c)
 	Expect(err).NotTo(HaveOccurred())
 	if len(publicIps) == 0 {
 		framework.Failf("got unexpected number (%d) of public IPs", len(publicIps))
@@ -1808,11 +1803,11 @@ func testNotReachableUDP(ip string, port int, request string) (bool, error) {
 }
 
 // Creates a replication controller that serves its hostname and a service on top of it.
-func startServeHostnameService(c *client.Client, ns, name string, port, replicas int) ([]string, string, error) {
+func startServeHostnameService(c clientset.Interface, ns, name string, port, replicas int) ([]string, string, error) {
 	podNames := make([]string, replicas)
 
 	By("creating service " + name + " in namespace " + ns)
-	_, err := c.Services(ns).Create(&api.Service{
+	_, err := c.Core().Services(ns).Create(&api.Service{
 		ObjectMeta: api.ObjectMeta{
 			Name: name,
 		},
@@ -1858,7 +1853,7 @@ func startServeHostnameService(c *client.Client, ns, name string, port, replicas
 	}
 	sort.StringSlice(podNames).Sort()
 
-	service, err := c.Services(ns).Get(name)
+	service, err := c.Core().Services(ns).Get(name)
 	if err != nil {
 		return podNames, "", err
 	}
@@ -1869,11 +1864,11 @@ func startServeHostnameService(c *client.Client, ns, name string, port, replicas
 	return podNames, serviceIP, nil
 }
 
-func stopServeHostnameService(c *client.Client, clientset clientset.Interface, ns, name string) error {
+func stopServeHostnameService(clientset clientset.Interface, ns, name string) error {
-	if err := framework.DeleteRCAndPods(c, clientset, ns, name); err != nil {
+	if err := framework.DeleteRCAndPods(clientset, ns, name); err != nil {
 		return err
 	}
-	if err := c.Services(ns).Delete(name); err != nil {
+	if err := clientset.Core().Services(ns).Delete(name, nil); err != nil {
 		return err
 	}
 	return nil
@@ -1883,7 +1878,7 @@ func stopServeHostnameService(c *client.Client, clientset clientset.Interface, n
 // given host and from within a pod. The host is expected to be an SSH-able node
 // in the cluster. Each pod in the service is expected to echo its name. These
 // names are compared with the given expectedPods list after a sort | uniq.
-func verifyServeHostnameServiceUp(c *client.Client, ns, host string, expectedPods []string, serviceIP string, servicePort int) error {
+func verifyServeHostnameServiceUp(c clientset.Interface, ns, host string, expectedPods []string, serviceIP string, servicePort int) error {
 	execPodName := createExecPodOrFail(c, ns, "execpod-")
 	defer func() {
 		deletePodOrFail(c, ns, execPodName)
@@ -1959,7 +1954,7 @@ func verifyServeHostnameServiceUp(c *client.Client, ns, host string, expectedPod
 	return nil
 }
 
-func verifyServeHostnameServiceDown(c *client.Client, host string, serviceIP string, servicePort int) error {
+func verifyServeHostnameServiceDown(c clientset.Interface, host string, serviceIP string, servicePort int) error {
 	command := fmt.Sprintf(
 		"curl -s --connect-timeout 2 http://%s:%d && exit 99", serviceIP, servicePort)
 
@@ -1994,18 +1989,16 @@ func httpGetNoConnectionPool(url string) (*http.Response, error) {
 
 // A test jig to help testing.
 type ServiceTestJig struct {
-	ID        string
+	ID     string
-	Name      string
+	Name   string
-	Client    *client.Client
+	Client clientset.Interface
-	ClientSet clientset.Interface
+	Labels map[string]string
-	Labels    map[string]string
 }
 
 // NewServiceTestJig allocates and inits a new ServiceTestJig.
-func NewServiceTestJig(client *client.Client, cs clientset.Interface, name string) *ServiceTestJig {
+func NewServiceTestJig(client clientset.Interface, name string) *ServiceTestJig {
 	j := &ServiceTestJig{}
 	j.Client = client
-	j.ClientSet = cs
 	j.Name = name
 	j.ID = j.Name + "-" + string(uuid.NewUUID())
 	j.Labels = map[string]string{"testid": j.ID}
@@ -2044,7 +2037,7 @@ func (j *ServiceTestJig) CreateTCPServiceWithPort(namespace string, tweak func(s
 	if tweak != nil {
 		tweak(svc)
 	}
-	result, err := j.Client.Services(namespace).Create(svc)
+	result, err := j.Client.Core().Services(namespace).Create(svc)
 	if err != nil {
 		framework.Failf("Failed to create TCP Service %q: %v", svc.Name, err)
 	}
@@ -2059,7 +2052,7 @@ func (j *ServiceTestJig) CreateTCPServiceOrFail(namespace string, tweak func(svc
 	if tweak != nil {
 		tweak(svc)
 	}
-	result, err := j.Client.Services(namespace).Create(svc)
+	result, err := j.Client.Core().Services(namespace).Create(svc)
 	if err != nil {
 		framework.Failf("Failed to create TCP Service %q: %v", svc.Name, err)
 	}
@@ -2074,7 +2067,7 @@ func (j *ServiceTestJig) CreateUDPServiceOrFail(namespace string, tweak func(svc
 	if tweak != nil {
 		tweak(svc)
 	}
-	result, err := j.Client.Services(namespace).Create(svc)
+	result, err := j.Client.Core().Services(namespace).Create(svc)
 	if err != nil {
 		framework.Failf("Failed to create UDP Service %q: %v", svc.Name, err)
 	}
@@ -2145,7 +2138,7 @@ func (j *ServiceTestJig) createOnlyLocalLoadBalancerService(namespace, serviceNa
 // endpoints of the given Service are running.
 func (j *ServiceTestJig) getEndpointNodes(svc *api.Service) map[string][]string {
 	nodes := j.getNodes(maxNodesForEndpointsTests)
-	endpoints, err := j.Client.Endpoints(svc.Namespace).Get(svc.Name)
+	endpoints, err := j.Client.Core().Endpoints(svc.Namespace).Get(svc.Name)
 	if err != nil {
 		framework.Failf("Get endpoints for service %s/%s failed (%s)", svc.Namespace, svc.Name, err)
 	}
@@ -2172,7 +2165,7 @@ func (j *ServiceTestJig) getEndpointNodes(svc *api.Service) map[string][]string
 // getNodes returns the first maxNodesForTest nodes. Useful in large clusters
 // where we don't eg: want to create an endpoint per node.
 func (j *ServiceTestJig) getNodes(maxNodesForTest int) (nodes *api.NodeList) {
-	nodes = framework.GetReadySchedulableNodesOrDie(j.ClientSet)
+	nodes = framework.GetReadySchedulableNodesOrDie(j.Client)
 	if len(nodes.Items) <= maxNodesForTest {
 		maxNodesForTest = len(nodes.Items)
 	}
@@ -2182,7 +2175,7 @@ func (j *ServiceTestJig) getNodes(maxNodesForTest int) (nodes *api.NodeList) {
 
 func (j *ServiceTestJig) waitForEndpointOnNode(namespace, serviceName, nodeName string) {
 	err := wait.PollImmediate(framework.Poll, loadBalancerCreateTimeoutDefault, func() (bool, error) {
-		endpoints, err := j.Client.Endpoints(namespace).Get(serviceName)
+		endpoints, err := j.Client.Core().Endpoints(namespace).Get(serviceName)
 		if err != nil {
 			framework.Logf("Get endpoints for service %s/%s failed (%s)", namespace, serviceName, err)
 			return false, nil
@@ -2244,12 +2237,12 @@ func (j *ServiceTestJig) SanityCheckService(svc *api.Service, svcType api.Servic
 // face of timeouts and conflicts.
 func (j *ServiceTestJig) UpdateService(namespace, name string, update func(*api.Service)) (*api.Service, error) {
 	for i := 0; i < 3; i++ {
-		service, err := j.Client.Services(namespace).Get(name)
+		service, err := j.Client.Core().Services(namespace).Get(name)
 		if err != nil {
 			return nil, fmt.Errorf("Failed to get Service %q: %v", name, err)
 		}
 		update(service)
-		service, err = j.Client.Services(namespace).Update(service)
+		service, err = j.Client.Core().Services(namespace).Update(service)
 		if err == nil {
 			return service, nil
 		}
@@ -2298,7 +2291,7 @@ func (j *ServiceTestJig) WaitForLoadBalancerOrFail(namespace, name string, timeo
 	var service *api.Service
 	framework.Logf("Waiting up to %v for service %q to have a LoadBalancer", timeout, name)
 	pollFunc := func() (bool, error) {
-		svc, err := j.Client.Services(namespace).Get(name)
+		svc, err := j.Client.Core().Services(namespace).Get(name)
 		if err != nil {
 			return false, err
 		}
@@ -2325,7 +2318,7 @@ func (j *ServiceTestJig) WaitForLoadBalancerDestroyOrFail(namespace, name string
 	var service *api.Service
 	framework.Logf("Waiting up to %v for service %q to have no LoadBalancer", timeout, name)
 	pollFunc := func() (bool, error) {
-		svc, err := j.Client.Services(namespace).Get(name)
+		svc, err := j.Client.Core().Services(namespace).Get(name)
 		if err != nil {
 			return false, err
 		}
@@ -2453,7 +2446,7 @@ func (j *ServiceTestJig) RunOrFail(namespace string, tweak func(rc *api.Replicat
 	if tweak != nil {
 		tweak(rc)
 	}
-	result, err := j.Client.ReplicationControllers(namespace).Create(rc)
+	result, err := j.Client.Core().ReplicationControllers(namespace).Create(rc)
 	if err != nil {
 		framework.Failf("Failed to created RC %q: %v", rc.Name, err)
 	}
@@ -2474,7 +2467,7 @@ func (j *ServiceTestJig) waitForPodsCreated(namespace string, replicas int) ([]s
 	framework.Logf("Waiting up to %v for %d pods to be created", timeout, replicas)
 	for start := time.Now(); time.Since(start) < timeout; time.Sleep(2 * time.Second) {
 		options := api.ListOptions{LabelSelector: label}
-		pods, err := j.Client.Pods(namespace).List(options)
+		pods, err := j.Client.Core().Pods(namespace).List(options)
 		if err != nil {
 			return nil, err
 		}
@@ -2507,7 +2500,7 @@ func (j *ServiceTestJig) waitForPodsReady(namespace string, pods []string) error
 type ServiceTestFixture struct {
 	ServiceName string
 	Namespace   string
-	Client      *client.Client
+	Client      clientset.Interface
 
 	TestId string
 	Labels map[string]string
@@ -2518,7 +2511,7 @@ type ServiceTestFixture struct {
 	image    string
 }
 
-func NewServerTest(client *client.Client, namespace string, serviceName string) *ServiceTestFixture {
+func NewServerTest(client clientset.Interface, namespace string, serviceName string) *ServiceTestFixture {
 	t := &ServiceTestFixture{}
 	t.Client = client
 	t.Namespace = namespace
@@ -2571,7 +2564,7 @@ func (t *ServiceTestFixture) CreateWebserverRC(replicas int32) *api.ReplicationC
 
 // createRC creates a replication controller and records it for cleanup.
 func (t *ServiceTestFixture) createRC(rc *api.ReplicationController) (*api.ReplicationController, error) {
-	rc, err := t.Client.ReplicationControllers(t.Namespace).Create(rc)
+	rc, err := t.Client.Core().ReplicationControllers(t.Namespace).Create(rc)
 	if err == nil {
 		t.rcs[rc.Name] = true
 	}
@@ -2580,7 +2573,7 @@ func (t *ServiceTestFixture) createRC(rc *api.ReplicationController) (*api.Repli
 
 // Create a service, and record it for cleanup
 func (t *ServiceTestFixture) CreateService(service *api.Service) (*api.Service, error) {
-	result, err := t.Client.Services(t.Namespace).Create(service)
+	result, err := t.Client.Core().Services(t.Namespace).Create(service)
 	if err == nil {
 		t.services[service.Name] = true
 	}
@@ -2589,7 +2582,7 @@ func (t *ServiceTestFixture) CreateService(service *api.Service) (*api.Service,
 
 // Delete a service, and remove it from the cleanup list
 func (t *ServiceTestFixture) DeleteService(serviceName string) error {
-	err := t.Client.Services(t.Namespace).Delete(serviceName)
+	err := t.Client.Core().Services(t.Namespace).Delete(serviceName, nil)
 	if err == nil {
 		delete(t.services, serviceName)
 	}
@@ -2601,25 +2594,25 @@ func (t *ServiceTestFixture) Cleanup() []error {
 	for rcName := range t.rcs {
 		By("stopping RC " + rcName + " in namespace " + t.Namespace)
 		// First, resize the RC to 0.
-		old, err := t.Client.ReplicationControllers(t.Namespace).Get(rcName)
+		old, err := t.Client.Core().ReplicationControllers(t.Namespace).Get(rcName)
 		if err != nil {
 			errs = append(errs, err)
 		}
 		old.Spec.Replicas = 0
-		if _, err := t.Client.ReplicationControllers(t.Namespace).Update(old); err != nil {
+		if _, err := t.Client.Core().ReplicationControllers(t.Namespace).Update(old); err != nil {
 			errs = append(errs, err)
 		}
 		// TODO(mikedanese): Wait.
 
 		// Then, delete the RC altogether.
-		if err := t.Client.ReplicationControllers(t.Namespace).Delete(rcName, nil); err != nil {
+		if err := t.Client.Core().ReplicationControllers(t.Namespace).Delete(rcName, nil); err != nil {
 			errs = append(errs, err)
 		}
 	}
 
 	for serviceName := range t.services {
 		By("deleting service " + serviceName + " in namespace " + t.Namespace)
-		err := t.Client.Services(t.Namespace).Delete(serviceName)
+		err := t.Client.Core().Services(t.Namespace).Delete(serviceName, nil)
 		if err != nil {
 			errs = append(errs, err)
 		}
@@ -2657,22 +2650,22 @@ func (j *ServiceTestJig) launchEchoserverPodOnNode(f *framework.Framework, nodeN
 	pod := newEchoServerPodSpec(podName)
 	pod.Spec.NodeName = nodeName
 	pod.ObjectMeta.Labels = j.Labels
-	podClient := f.Client.Pods(f.Namespace.Name)
+	podClient := f.ClientSet.Core().Pods(f.Namespace.Name)
 	_, err := podClient.Create(pod)
 	framework.ExpectNoError(err)
 	framework.ExpectNoError(f.WaitForPodRunning(podName))
 	framework.Logf("Echo server pod %q in namespace %q running", pod.Name, f.Namespace.Name)
 }
 
-func execSourceipTest(f *framework.Framework, c *client.Client, ns, nodeName, serviceIP string, servicePort int) (string, string) {
+func execSourceipTest(f *framework.Framework, c clientset.Interface, ns, nodeName, serviceIP string, servicePort int) (string, string) {
 	framework.Logf("Creating an exec pod on node %v", nodeName)
-	execPodName := createExecPodOnNode(f.Client, ns, nodeName, fmt.Sprintf("execpod-sourceip-%s", nodeName))
+	execPodName := createExecPodOnNode(f.ClientSet, ns, nodeName, fmt.Sprintf("execpod-sourceip-%s", nodeName))
 	defer func() {
 		framework.Logf("Cleaning up the exec pod")
-		err := c.Pods(ns).Delete(execPodName, nil)
+		err := c.Core().Pods(ns).Delete(execPodName, nil)
 		Expect(err).NotTo(HaveOccurred())
 	}()
-	execPod, err := f.Client.Pods(ns).Get(execPodName)
+	execPod, err := f.ClientSet.Core().Pods(ns).Get(execPodName)
 	ExpectNoError(err)
 
 	var stdout string

test/e2e/service_accounts.go

@@ -42,7 +42,7 @@ var _ = framework.KubeDescribe("ServiceAccounts", func() {
 		var secrets []api.ObjectReference
 		framework.ExpectNoError(wait.Poll(time.Millisecond*500, time.Second*10, func() (bool, error) {
 			By("waiting for a single token reference")
-			sa, err := f.Client.ServiceAccounts(f.Namespace.Name).Get("default")
+			sa, err := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Get("default")
 			if apierrors.IsNotFound(err) {
 				framework.Logf("default service account was not found")
 				return false, nil
@@ -68,19 +68,19 @@ var _ = framework.KubeDescribe("ServiceAccounts", func() {
 		{
 			By("ensuring the single token reference persists")
 			time.Sleep(2 * time.Second)
-			sa, err := f.Client.ServiceAccounts(f.Namespace.Name).Get("default")
+			sa, err := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Get("default")
 			framework.ExpectNoError(err)
 			Expect(sa.Secrets).To(Equal(secrets))
 		}
 
 		// delete the referenced secret
 		By("deleting the service account token")
-		framework.ExpectNoError(f.Client.Secrets(f.Namespace.Name).Delete(secrets[0].Name))
+		framework.ExpectNoError(f.ClientSet.Core().Secrets(f.Namespace.Name).Delete(secrets[0].Name, nil))
 
 		// wait for the referenced secret to be removed, and another one autocreated
 		framework.ExpectNoError(wait.Poll(time.Millisecond*500, framework.ServiceAccountProvisionTimeout, func() (bool, error) {
 			By("waiting for a new token reference")
-			sa, err := f.Client.ServiceAccounts(f.Namespace.Name).Get("default")
+			sa, err := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Get("default")
 			if err != nil {
 				framework.Logf("error getting default service account: %v", err)
 				return false, err
@@ -106,7 +106,7 @@ var _ = framework.KubeDescribe("ServiceAccounts", func() {
 		{
 			By("ensuring the single token reference persists")
 			time.Sleep(2 * time.Second)
-			sa, err := f.Client.ServiceAccounts(f.Namespace.Name).Get("default")
+			sa, err := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Get("default")
 			framework.ExpectNoError(err)
 			Expect(sa.Secrets).To(Equal(secrets))
 		}
@@ -114,17 +114,17 @@ var _ = framework.KubeDescribe("ServiceAccounts", func() {
 		// delete the reference from the service account
 		By("deleting the reference to the service account token")
 		{
-			sa, err := f.Client.ServiceAccounts(f.Namespace.Name).Get("default")
+			sa, err := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Get("default")
 			framework.ExpectNoError(err)
 			sa.Secrets = nil
-			_, updateErr := f.Client.ServiceAccounts(f.Namespace.Name).Update(sa)
+			_, updateErr := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Update(sa)
 			framework.ExpectNoError(updateErr)
 		}
 
 		// wait for another one to be autocreated
 		framework.ExpectNoError(wait.Poll(time.Millisecond*500, framework.ServiceAccountProvisionTimeout, func() (bool, error) {
 			By("waiting for a new token to be created and added")
-			sa, err := f.Client.ServiceAccounts(f.Namespace.Name).Get("default")
+			sa, err := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Get("default")
 			if err != nil {
 				framework.Logf("error getting default service account: %v", err)
 				return false, err
@@ -146,7 +146,7 @@ var _ = framework.KubeDescribe("ServiceAccounts", func() {
 		{
 			By("ensuring the single token reference persists")
 			time.Sleep(2 * time.Second)
-			sa, err := f.Client.ServiceAccounts(f.Namespace.Name).Get("default")
+			sa, err := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Get("default")
 			framework.ExpectNoError(err)
 			Expect(sa.Secrets).To(Equal(secrets))
 		}
@@ -159,7 +159,7 @@ var _ = framework.KubeDescribe("ServiceAccounts", func() {
 		// Standard get, update retry loop
 		framework.ExpectNoError(wait.Poll(time.Millisecond*500, framework.ServiceAccountProvisionTimeout, func() (bool, error) {
 			By("getting the auto-created API token")
-			sa, err := f.Client.ServiceAccounts(f.Namespace.Name).Get("default")
+			sa, err := f.ClientSet.Core().ServiceAccounts(f.Namespace.Name).Get("default")
 			if apierrors.IsNotFound(err) {
 				framework.Logf("default service account was not found")
 				return false, nil
@@ -173,7 +173,7 @@ var _ = framework.KubeDescribe("ServiceAccounts", func() {
 				return false, nil
 			}
 			for _, secretRef := range sa.Secrets {
-				secret, err := f.Client.Secrets(f.Namespace.Name).Get(secretRef.Name)
+				secret, err := f.ClientSet.Core().Secrets(f.Namespace.Name).Get(secretRef.Name)
 				if err != nil {
 					framework.Logf("Error getting secret %s: %v", secretRef.Name, err)
 					continue
@@ -214,7 +214,7 @@ var _ = framework.KubeDescribe("ServiceAccounts", func() {
 			},
 		}
 
-		supportsTokenNamespace, _ := framework.ServerVersionGTE(serviceAccountTokenNamespaceVersion, f.Client)
+		supportsTokenNamespace, _ := framework.ServerVersionGTE(serviceAccountTokenNamespaceVersion, f.ClientSet.Discovery())
 		if supportsTokenNamespace {
 			pod.Spec.Containers = append(pod.Spec.Containers, api.Container{
 				Name:  "namespace-test",

test/e2e/service_latency.go

@@ -24,6 +24,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/cache"
+	"k8s.io/kubernetes/pkg/client/restclient"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/flowcontrol"
 	"k8s.io/kubernetes/pkg/util/sets"
@@ -66,9 +67,9 @@ var _ = framework.KubeDescribe("Service endpoints latency", func() {
 		)
 
 		// Turn off rate limiting--it interferes with our measurements.
-		oldThrottle := f.Client.RESTClient.Throttle
+		oldThrottle := f.ClientSet.Core().RESTClient().GetRateLimiter()
-		f.Client.RESTClient.Throttle = flowcontrol.NewFakeAlwaysRateLimiter()
+		f.ClientSet.Core().RESTClient().(*restclient.RESTClient).Throttle = flowcontrol.NewFakeAlwaysRateLimiter()
-		defer func() { f.Client.RESTClient.Throttle = oldThrottle }()
+		defer func() { f.ClientSet.Core().RESTClient().(*restclient.RESTClient).Throttle = oldThrottle }()
 
 		failing := sets.NewString()
 		d, err := runServiceLatencies(f, parallelTrials, totalTrials)
@@ -117,8 +118,8 @@ var _ = framework.KubeDescribe("Service endpoints latency", func() {
 
 func runServiceLatencies(f *framework.Framework, inParallel, total int) (output []time.Duration, err error) {
 	cfg := testutils.RCConfig{
-		Client:       f.Client,
+		Client:       f.ClientSet,
-		Image:        framework.GetPauseImageName(f.Client),
+		Image:        framework.GetPauseImageName(f.ClientSet),
 		Name:         "svc-latency-rc",
 		Namespace:    f.Namespace.Name,
 		Replicas:     1,
@@ -277,10 +278,11 @@ func startEndpointWatcher(f *framework.Framework, q *endpointQueries) {
 	_, controller := cache.NewInformer(
 		&cache.ListWatch{
 			ListFunc: func(options api.ListOptions) (runtime.Object, error) {
-				return f.Client.Endpoints(f.Namespace.Name).List(options)
+				obj, err := f.ClientSet.Core().Endpoints(f.Namespace.Name).List(options)
+				return runtime.Object(obj), err
 			},
 			WatchFunc: func(options api.ListOptions) (watch.Interface, error) {
-				return f.Client.Endpoints(f.Namespace.Name).Watch(options)
+				return f.ClientSet.Core().Endpoints(f.Namespace.Name).Watch(options)
 			},
 		},
 		&api.Endpoints{},
@@ -325,7 +327,7 @@ func singleServiceLatency(f *framework.Framework, name string, q *endpointQuerie
 		},
 	}
 	startTime := time.Now()
-	gotSvc, err := f.Client.Services(f.Namespace.Name).Create(svc)
+	gotSvc, err := f.ClientSet.Core().Services(f.Namespace.Name).Create(svc)
 	if err != nil {
 		return 0, err
 	}