Merge pull request #34905 from ingvagabund/client-to-clientset

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}})
-		lw := NewListWatchFromClient(client, item.resource, item.namespace, item.fieldSelector)
+		client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}})
+		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}})
-		lw := NewListWatchFromClient(client, item.resource, item.namespace, item.fieldSelector)
+		client := clientset.NewForConfigOrDie(&restclient.Config{Host: server.URL, ContentConfig: restclient.ContentConfig{GroupVersion: &registered.GroupOrDie(api.GroupName).GroupVersion}})
+		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)
-		waitForReplicationControllerInAddonTest(f.Client, defaultNsName, "addon-test-v1", true)
+		waitForServiceInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test", 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)
-		waitForReplicationControllerInAddonTest(f.Client, f.Namespace.Name, "addon-test-v2", true)
+		waitForServiceInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test-updated", true)
+		waitForReplicationControllerInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test-v2", true)
 
-		waitForServiceInAddonTest(f.Client, f.Namespace.Name, "addon-test", false)
-		waitForReplicationControllerInAddonTest(f.Client, defaultNsName, "addon-test-v1", false)
+		waitForServiceInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test", 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)
-		waitForReplicationControllerInAddonTest(f.Client, f.Namespace.Name, "addon-test-v2", false)
+		waitForServiceInAddonTest(f.ClientSet, f.Namespace.Name, "addon-test-updated", 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(rc.framework.Client.Services(rc.framework.Namespace.Name).Delete(rc.name))
-	framework.ExpectNoError(framework.DeleteRCAndPods(rc.framework.Client, rc.framework.ClientSet, rc.framework.Namespace.Name, rc.controllerName))
-	framework.ExpectNoError(rc.framework.Client.Services(rc.framework.Namespace.Name).Delete(rc.controllerName))
+	framework.ExpectNoError(framework.DeleteRCAndPods(rc.framework.ClientSet, rc.framework.Namespace.Name, rc.name))
+	framework.ExpectNoError(rc.framework.ClientSet.Core().Services(rc.framework.Namespace.Name).Delete(rc.name, nil))
+	framework.ExpectNoError(framework.DeleteRCAndPods(rc.framework.ClientSet, rc.framework.Namespace.Name, 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_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 {
-	nodeList := framework.GetReadySchedulableNodesOrDie(cs)
+func clearDaemonSetNodeLabels(c clientset.Interface) error {
+	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) {
-	nodeClient := c.Nodes()
+func setDaemonSetNodeLabels(c clientset.Interface, nodeName string, labels map[string]string) (*api.Node, error) {
+	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
@@ -484,7 +482,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"},
@@ -499,7 +497,6 @@ var _ = framework.KubeDescribe("Density", func() {
 			}
 
 			dConfig := DensityTestConfig{
-				Client:       c,
 				ClientSet:    f.ClientSet,
 				Configs:      RCConfigs,
 				PodCount:     totalPods,
@@ -550,11 +547,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{},
@@ -593,7 +591,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()
@@ -623,7 +621,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 {
@@ -707,7 +705,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"},
@@ -719,7 +717,6 @@ var _ = framework.KubeDescribe("Density", func() {
 			}
 		}
 		dConfig := DensityTestConfig{
-			Client:       c,
 			ClientSet:    f.ClientSet,
 			Configs:      RCConfigs,
 			PodCount:     totalPods,
@@ -732,7 +729,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{
@@ -769,7 +766,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) {
-	proxyRequest, errProxy := framework.GetServicesProxyRequest(c, c.Get())
+func readTransactions(c clientset.Interface, ns string) (error, int) {
+	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

@@ -385,7 +385,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)
 		}
@@ -394,7 +394,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)
 		}
@@ -433,12 +433,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/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) {
-	subResourceProxyAvailable, err := ServerVersionGTE(subResourceServiceAndNodeProxyVersion, c)
+func getNodeStatsSummary(c clientset.Interface, nodeName string) (*stats.Summary, error) {
+	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
-	clientset   clientset.Interface
+	client      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 {
-	nodeAddresses, err := NodeSSHHosts(cs)
+func NewLogsVerifier(c clientset.Interface, stopChannel chan bool) *LogsSizeVerifier {
+	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) {
-	body, err := c.Get().AbsPath("/metrics").DoRaw()
+func getMetrics(c clientset.Interface) (string, error) {
+	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 {
-	return config.f.Client.Services(config.Namespace)
+func (config *NetworkingTestConfig) getServiceClient() coreclientset.ServiceInterface {
+	return config.f.ClientSet.Core().Services(config.Namespace)
 }
 
-func (config *NetworkingTestConfig) getNamespacesClient() client.NamespaceInterface {
-	return config.f.Client.Namespaces()
+func (config *NetworkingTestConfig) getNamespacesClient() coreclientset.NamespaceInterface {
+	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/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/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
-		nodes := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
+		c = 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 {
-			framework.Failf("Image puller didn't complete in %v, not running resource usage test since the metrics might be adulterated", imagePrePullingLongTimeout)
+		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 adultrated", imagePrePullingLongTimeout)
 		}
 		nodes := framework.GetReadySchedulableNodesOrDie(f.ClientSet)
 		nodeNames = sets.NewString()
 		for _, node := range nodes.Items {
 			nodeNames.Insert(node.Name)
 		}
-		om = framework.NewRuntimeOperationMonitor(f.Client)
-		rm = framework.NewResourceMonitor(f.Client, framework.TargetContainers(), containerStatsPollingPeriod)
+		om = framework.NewRuntimeOperationMonitor(f.ClientSet)
+		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) {
-	clients := make([]*client.Client, numberOfClients)
+func createClients(numberOfClients int) ([]*internalclientset.Clientset, error) {
+	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) {
-	result, err := c.Get().
+func Query(c clientset.Interface, query string) (*influxdb.Response, error) {
+	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 {
-	serviceList, err := c.Services(api.NamespaceSystem).List(api.ListOptions{})
+func expectedServicesExist(c clientset.Interface) error {
+	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 cs clientset.Interface
+	var c clientset.Interface
 	var unfilledNodeName, recoveredNodeName string
 	f := framework.NewDefaultFramework("node-outofdisk")
 
 	BeforeEach(func() {
-		c = f.Client
-		cs = f.ClientSet
+		c = 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) {
-	podClient := c.Pods(ns)
+func createOutOfDiskPod(c clientset.Interface, ns, name string, milliCPU int64) {
+	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) {
-	podClient := c.Pods(api.NamespaceAll)
+func availCpu(c clientset.Interface, node *api.Node) (int64, error) {
+	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))