Merge pull request #35258 from feiskyer/package-aliase

cmd/kube-dns/app/server.go

@@ -33,7 +33,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/restclient"
 	kclientcmd "k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
 	kdns "k8s.io/kubernetes/pkg/dns"
-	dnsConfig "k8s.io/kubernetes/pkg/dns/config"
+	dnsconfig "k8s.io/kubernetes/pkg/dns/config"
 	"k8s.io/kubernetes/pkg/runtime/schema"
 )
 
@@ -58,15 +58,15 @@ func NewKubeDNSServerDefault(config *options.KubeDNSConfig) *KubeDNSServer {
 	ks.dnsBindAddress = config.DNSBindAddress
 	ks.dnsPort = config.DNSPort
 
-	var configSync dnsConfig.Sync
+	var configSync dnsconfig.Sync
 	if config.ConfigMap == "" {
 		glog.V(0).Infof("ConfigMap not configured, using values from command line flags")
-		configSync = dnsConfig.NewNopSync(
-			&dnsConfig.Config{Federations: config.Federations})
+		configSync = dnsconfig.NewNopSync(
+			&dnsconfig.Config{Federations: config.Federations})
 	} else {
 		glog.V(0).Infof("Using configuration read from ConfigMap: %v:%v",
 			config.ConfigMapNs, config.ConfigMap)
-		configSync = dnsConfig.NewSync(
+		configSync = dnsconfig.NewSync(
 			kubeClient, config.ConfigMapNs, config.ConfigMap)
 	}
 

federation/client/cache/cluster_cache.go

@@ -19,13 +19,13 @@ package cache
 import (
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/federation/apis/federation/v1beta1"
-	kubeCache "k8s.io/kubernetes/pkg/client/cache"
+	kubecache "k8s.io/kubernetes/pkg/client/cache"
 )
 
 // StoreToClusterLister makes a Store have the List method of the unversioned.ClusterInterface
 // The Store must contain (only) clusters.
 type StoreToClusterLister struct {
-	kubeCache.Store
+	kubecache.Store
 }
 
 func (s *StoreToClusterLister) List() (clusters v1beta1.ClusterList, err error) {
@@ -41,7 +41,7 @@ type ClusterConditionPredicate func(cluster v1beta1.Cluster) bool
 
 // storeToClusterConditionLister filters and returns nodes matching the given type and status from the store.
 type storeToClusterConditionLister struct {
-	store     kubeCache.Store
+	store     kubecache.Store
 	predicate ClusterConditionPredicate
 }
 

federation/pkg/federation-controller/cluster/clustercontroller.go

@@ -21,8 +21,8 @@ import (
 	"time"
 
 	"github.com/golang/glog"
-	federation_v1beta1 "k8s.io/kubernetes/federation/apis/federation/v1beta1"
-	cluster_cache "k8s.io/kubernetes/federation/client/cache"
+	federationv1beta1 "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	clustercache "k8s.io/kubernetes/federation/client/cache"
 	federationclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5"
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/cache"
@@ -43,14 +43,14 @@ type ClusterController struct {
 	// clusterMonitorPeriod is the period for updating status of cluster
 	clusterMonitorPeriod time.Duration
 	// clusterClusterStatusMap is a mapping of clusterName and cluster status of last sampling
-	clusterClusterStatusMap map[string]federation_v1beta1.ClusterStatus
+	clusterClusterStatusMap map[string]federationv1beta1.ClusterStatus
 
 	// clusterKubeClientMap is a mapping of clusterName and restclient
 	clusterKubeClientMap map[string]ClusterClient
 
 	// cluster framework and store
 	clusterController *cache.Controller
-	clusterStore      cluster_cache.StoreToClusterLister
+	clusterStore      clustercache.StoreToClusterLister
 }
 
 // NewclusterController returns a new cluster controller
@@ -59,7 +59,7 @@ func NewclusterController(federationClient federationclientset.Interface, cluste
 		knownClusterSet:         make(sets.String),
 		federationClient:        federationClient,
 		clusterMonitorPeriod:    clusterMonitorPeriod,
-		clusterClusterStatusMap: make(map[string]federation_v1beta1.ClusterStatus),
+		clusterClusterStatusMap: make(map[string]federationv1beta1.ClusterStatus),
 		clusterKubeClientMap:    make(map[string]ClusterClient),
 	}
 	cc.clusterStore.Store, cc.clusterController = cache.NewInformer(
@@ -71,7 +71,7 @@ func NewclusterController(federationClient federationclientset.Interface, cluste
 				return cc.federationClient.Federation().Clusters().Watch(options)
 			},
 		},
-		&federation_v1beta1.Cluster{},
+		&federationv1beta1.Cluster{},
 		controller.NoResyncPeriodFunc(),
 		cache.ResourceEventHandlerFuncs{
 			DeleteFunc: cc.delFromClusterSet,
@@ -84,7 +84,7 @@ func NewclusterController(federationClient federationclientset.Interface, cluste
 // delFromClusterSet delete a cluster from clusterSet and
 // delete the corresponding restclient from the map clusterKubeClientMap
 func (cc *ClusterController) delFromClusterSet(obj interface{}) {
-	cluster := obj.(*federation_v1beta1.Cluster)
+	cluster := obj.(*federationv1beta1.Cluster)
 	cc.knownClusterSet.Delete(cluster.Name)
 	delete(cc.clusterKubeClientMap, cluster.Name)
 }
@@ -92,7 +92,7 @@ func (cc *ClusterController) delFromClusterSet(obj interface{}) {
 // addToClusterSet insert the new cluster to clusterSet and create a corresponding
 // restclient to map clusterKubeClientMap
 func (cc *ClusterController) addToClusterSet(obj interface{}) {
-	cluster := obj.(*federation_v1beta1.Cluster)
+	cluster := obj.(*federationv1beta1.Cluster)
 	cc.knownClusterSet.Insert(cluster.Name)
 	// create the restclient of cluster
 	restClient, err := NewClusterClientSet(cluster)
@@ -115,7 +115,7 @@ func (cc *ClusterController) Run() {
 	}, cc.clusterMonitorPeriod, wait.NeverStop)
 }
 
-func (cc *ClusterController) GetClusterStatus(cluster *federation_v1beta1.Cluster) (*federation_v1beta1.ClusterStatus, error) {
+func (cc *ClusterController) GetClusterStatus(cluster *federationv1beta1.Cluster) (*federationv1beta1.ClusterStatus, error) {
 	// just get the status of cluster, by requesting the restapi "/healthz"
 	clusterClient, found := cc.clusterKubeClientMap[cluster.Name]
 	if !found {

federation/pkg/federation-controller/cluster/clustercontroller_test.go

@@ -23,9 +23,9 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	federation_v1beta1 "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	federationv1beta1 "k8s.io/kubernetes/federation/apis/federation/v1beta1"
 	federationclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5"
-	controller_util "k8s.io/kubernetes/federation/pkg/federation-controller/util"
+	controllerutil "k8s.io/kubernetes/federation/pkg/federation-controller/util"
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/v1"
@@ -35,15 +35,15 @@ import (
 	"k8s.io/kubernetes/pkg/util/uuid"
 )
 
-func newCluster(clusterName string, serverUrl string) *federation_v1beta1.Cluster {
-	cluster := federation_v1beta1.Cluster{
+func newCluster(clusterName string, serverUrl string) *federationv1beta1.Cluster {
+	cluster := federationv1beta1.Cluster{
 		TypeMeta: unversioned.TypeMeta{APIVersion: testapi.Federation.GroupVersion().String()},
 		ObjectMeta: v1.ObjectMeta{
 			UID:  uuid.NewUUID(),
 			Name: clusterName,
 		},
-		Spec: federation_v1beta1.ClusterSpec{
-			ServerAddressByClientCIDRs: []federation_v1beta1.ServerAddressByClientCIDR{
+		Spec: federationv1beta1.ClusterSpec{
+			ServerAddressByClientCIDRs: []federationv1beta1.ServerAddressByClientCIDR{
 				{
 					ClientCIDR:    "0.0.0.0/0",
 					ServerAddress: serverUrl,
@@ -54,13 +54,13 @@ func newCluster(clusterName string, serverUrl string) *federation_v1beta1.Cluste
 	return &cluster
 }
 
-func newClusterList(cluster *federation_v1beta1.Cluster) *federation_v1beta1.ClusterList {
-	clusterList := federation_v1beta1.ClusterList{
+func newClusterList(cluster *federationv1beta1.Cluster) *federationv1beta1.ClusterList {
+	clusterList := federationv1beta1.ClusterList{
 		TypeMeta: unversioned.TypeMeta{APIVersion: testapi.Federation.GroupVersion().String()},
 		ListMeta: unversioned.ListMeta{
 			SelfLink: "foobar",
 		},
-		Items: []federation_v1beta1.Cluster{},
+		Items: []federationv1beta1.Cluster{},
 	}
 	clusterList.Items = append(clusterList.Items, *cluster)
 	return &clusterList
@@ -68,7 +68,7 @@ func newClusterList(cluster *federation_v1beta1.Cluster) *federation_v1beta1.Clu
 
 // init a fake http handler, simulate a federation apiserver, response the "DELETE" "PUT" "GET" "UPDATE"
 // when "canBeGotten" is false, means that user can not get the cluster cluster from apiserver
-func createHttptestFakeHandlerForFederation(clusterList *federation_v1beta1.ClusterList, canBeGotten bool) *http.HandlerFunc {
+func createHttptestFakeHandlerForFederation(clusterList *federationv1beta1.ClusterList, canBeGotten bool) *http.HandlerFunc {
 	fakeHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		clusterListString, _ := json.Marshal(*clusterList)
 		w.Header().Set("Content-Type", "application/json")
@@ -125,8 +125,8 @@ func TestUpdateClusterStatusOK(t *testing.T) {
 	federationClientSet := federationclientset.NewForConfigOrDie(restclient.AddUserAgent(restClientCfg, "cluster-controller"))
 
 	// Override KubeconfigGetterForCluster to avoid having to setup service accounts and mount files with secret tokens.
-	originalGetter := controller_util.KubeconfigGetterForCluster
-	controller_util.KubeconfigGetterForCluster = func(c *federation_v1beta1.Cluster) clientcmd.KubeconfigGetter {
+	originalGetter := controllerutil.KubeconfigGetterForCluster
+	controllerutil.KubeconfigGetterForCluster = func(c *federationv1beta1.Cluster) clientcmd.KubeconfigGetter {
 		return func() (*clientcmdapi.Config, error) {
 			return &clientcmdapi.Config{}, nil
 		}
@@ -141,11 +141,11 @@ func TestUpdateClusterStatusOK(t *testing.T) {
 	if !found {
 		t.Errorf("Failed to Update Cluster Status")
 	} else {
-		if (clusterStatus.Conditions[1].Status != v1.ConditionFalse) || (clusterStatus.Conditions[1].Type != federation_v1beta1.ClusterOffline) {
+		if (clusterStatus.Conditions[1].Status != v1.ConditionFalse) || (clusterStatus.Conditions[1].Type != federationv1beta1.ClusterOffline) {
 			t.Errorf("Failed to Update Cluster Status")
 		}
 	}
 
 	// Reset KubeconfigGetterForCluster
-	controller_util.KubeconfigGetterForCluster = originalGetter
+	controllerutil.KubeconfigGetterForCluster = originalGetter
 }

federation/pkg/federation-controller/configmap/configmap_controller.go

@@ -19,17 +19,17 @@ package configmap
 import (
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
 	federationclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util/eventsink"
 	"k8s.io/kubernetes/pkg/api"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/cache"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/controller"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util/flowcontrol"
 	"k8s.io/kubernetes/pkg/watch"
@@ -79,7 +79,7 @@ type ConfigMapController struct {
 func NewConfigMapController(client federationclientset.Interface) *ConfigMapController {
 	broadcaster := record.NewBroadcaster()
 	broadcaster.StartRecordingToSink(eventsink.NewFederatedEventSink(client))
-	recorder := broadcaster.NewRecorder(api_v1.EventSource{Component: "federated-configmaps-controller"})
+	recorder := broadcaster.NewRecorder(apiv1.EventSource{Component: "federated-configmaps-controller"})
 
 	configmapcontroller := &ConfigMapController{
 		federatedApiClient:    client,
@@ -98,43 +98,43 @@ func NewConfigMapController(client federationclientset.Interface) *ConfigMapCont
 	// Start informer on federated API servers on configmaps that should be federated.
 	configmapcontroller.configmapInformerStore, configmapcontroller.configmapInformerController = cache.NewInformer(
 		&cache.ListWatch{
-			ListFunc: func(options api_v1.ListOptions) (pkg_runtime.Object, error) {
-				return client.Core().ConfigMaps(api_v1.NamespaceAll).List(options)
+			ListFunc: func(options apiv1.ListOptions) (pkgruntime.Object, error) {
+				return client.Core().ConfigMaps(apiv1.NamespaceAll).List(options)
 			},
-			WatchFunc: func(options api_v1.ListOptions) (watch.Interface, error) {
-				return client.Core().ConfigMaps(api_v1.NamespaceAll).Watch(options)
+			WatchFunc: func(options apiv1.ListOptions) (watch.Interface, error) {
+				return client.Core().ConfigMaps(apiv1.NamespaceAll).Watch(options)
 			},
 		},
-		&api_v1.ConfigMap{},
+		&apiv1.ConfigMap{},
 		controller.NoResyncPeriodFunc(),
-		util.NewTriggerOnAllChanges(func(obj pkg_runtime.Object) { configmapcontroller.deliverConfigMapObj(obj, 0, false) }))
+		util.NewTriggerOnAllChanges(func(obj pkgruntime.Object) { configmapcontroller.deliverConfigMapObj(obj, 0, false) }))
 
 	// Federated informer on configmaps in members of federation.
 	configmapcontroller.configmapFederatedInformer = util.NewFederatedInformer(
 		client,
-		func(cluster *federation_api.Cluster, targetClient kubeclientset.Interface) (cache.Store, cache.ControllerInterface) {
+		func(cluster *federationapi.Cluster, targetClient kubeclientset.Interface) (cache.Store, cache.ControllerInterface) {
 			return cache.NewInformer(
 				&cache.ListWatch{
-					ListFunc: func(options api_v1.ListOptions) (pkg_runtime.Object, error) {
-						return targetClient.Core().ConfigMaps(api_v1.NamespaceAll).List(options)
+					ListFunc: func(options apiv1.ListOptions) (pkgruntime.Object, error) {
+						return targetClient.Core().ConfigMaps(apiv1.NamespaceAll).List(options)
 					},
-					WatchFunc: func(options api_v1.ListOptions) (watch.Interface, error) {
-						return targetClient.Core().ConfigMaps(api_v1.NamespaceAll).Watch(options)
+					WatchFunc: func(options apiv1.ListOptions) (watch.Interface, error) {
+						return targetClient.Core().ConfigMaps(apiv1.NamespaceAll).Watch(options)
 					},
 				},
-				&api_v1.ConfigMap{},
+				&apiv1.ConfigMap{},
 				controller.NoResyncPeriodFunc(),
 				// Trigger reconciliation whenever something in federated cluster is changed. In most cases it
 				// would be just confirmation that some configmap opration succeeded.
 				util.NewTriggerOnAllChanges(
-					func(obj pkg_runtime.Object) {
+					func(obj pkgruntime.Object) {
 						configmapcontroller.deliverConfigMapObj(obj, configmapcontroller.configmapReviewDelay, false)
 					},
 				))
 		},
 
 		&util.ClusterLifecycleHandlerFuncs{
-			ClusterAvailable: func(cluster *federation_api.Cluster) {
+			ClusterAvailable: func(cluster *federationapi.Cluster) {
 				// When new cluster becomes available process all the configmaps again.
 				configmapcontroller.clusterDeliverer.DeliverAt(allClustersKey, nil, time.Now().Add(configmapcontroller.clusterAvailableDelay))
 			},
@@ -143,19 +143,19 @@ func NewConfigMapController(client federationclientset.Interface) *ConfigMapCont
 
 	// Federated updater along with Create/Update/Delete operations.
 	configmapcontroller.federatedUpdater = util.NewFederatedUpdater(configmapcontroller.configmapFederatedInformer,
-		func(client kubeclientset.Interface, obj pkg_runtime.Object) error {
-			configmap := obj.(*api_v1.ConfigMap)
+		func(client kubeclientset.Interface, obj pkgruntime.Object) error {
+			configmap := obj.(*apiv1.ConfigMap)
 			_, err := client.Core().ConfigMaps(configmap.Namespace).Create(configmap)
 			return err
 		},
-		func(client kubeclientset.Interface, obj pkg_runtime.Object) error {
-			configmap := obj.(*api_v1.ConfigMap)
+		func(client kubeclientset.Interface, obj pkgruntime.Object) error {
+			configmap := obj.(*apiv1.ConfigMap)
 			_, err := client.Core().ConfigMaps(configmap.Namespace).Update(configmap)
 			return err
 		},
-		func(client kubeclientset.Interface, obj pkg_runtime.Object) error {
-			configmap := obj.(*api_v1.ConfigMap)
-			err := client.Core().ConfigMaps(configmap.Namespace).Delete(configmap.Name, &api_v1.DeleteOptions{})
+		func(client kubeclientset.Interface, obj pkgruntime.Object) error {
+			configmap := obj.(*apiv1.ConfigMap)
+			err := client.Core().ConfigMaps(configmap.Namespace).Delete(configmap.Name, &apiv1.DeleteOptions{})
 			return err
 		})
 	return configmapcontroller
@@ -179,7 +179,7 @@ func (configmapcontroller *ConfigMapController) Run(stopChan <-chan struct{}) {
 }
 
 func (configmapcontroller *ConfigMapController) deliverConfigMapObj(obj interface{}, delay time.Duration, failed bool) {
-	configmap := obj.(*api_v1.ConfigMap)
+	configmap := obj.(*apiv1.ConfigMap)
 	configmapcontroller.deliverConfigMap(types.NamespacedName{Namespace: configmap.Namespace, Name: configmap.Name}, delay, failed)
 }
 
@@ -220,7 +220,7 @@ func (configmapcontroller *ConfigMapController) reconcileConfigMapsOnClusterChan
 		configmapcontroller.clusterDeliverer.DeliverAt(allClustersKey, nil, time.Now().Add(configmapcontroller.clusterAvailableDelay))
 	}
 	for _, obj := range configmapcontroller.configmapInformerStore.List() {
-		configmap := obj.(*api_v1.ConfigMap)
+		configmap := obj.(*apiv1.ConfigMap)
 		configmapcontroller.deliverConfigMap(types.NamespacedName{Namespace: configmap.Namespace, Name: configmap.Name},
 			configmapcontroller.smallDelay, false)
 	}
@@ -247,7 +247,7 @@ func (configmapcontroller *ConfigMapController) reconcileConfigMap(configmap typ
 		glog.V(8).Infof("Skipping not federated config map: %s", key)
 		return
 	}
-	baseConfigMap := baseConfigMapObj.(*api_v1.ConfigMap)
+	baseConfigMap := baseConfigMapObj.(*apiv1.ConfigMap)
 
 	clusters, err := configmapcontroller.configmapFederatedInformer.GetReadyClusters()
 	if err != nil {
@@ -266,7 +266,7 @@ func (configmapcontroller *ConfigMapController) reconcileConfigMap(configmap typ
 		}
 
 		// Do not modify data.
-		desiredConfigMap := &api_v1.ConfigMap{
+		desiredConfigMap := &apiv1.ConfigMap{
 			ObjectMeta: util.DeepCopyRelevantObjectMeta(baseConfigMap.ObjectMeta),
 			Data:       baseConfigMap.Data,
 		}
@@ -281,7 +281,7 @@ func (configmapcontroller *ConfigMapController) reconcileConfigMap(configmap typ
 				ClusterName: cluster.Name,
 			})
 		} else {
-			clusterConfigMap := clusterConfigMapObj.(*api_v1.ConfigMap)
+			clusterConfigMap := clusterConfigMapObj.(*apiv1.ConfigMap)
 
 			// Update existing configmap, if needed.
 			if !util.ConfigMapEquivalent(desiredConfigMap, clusterConfigMap) {

federation/pkg/federation-controller/configmap/configmap_controller_test.go

@@ -21,13 +21,13 @@ import (
 	"testing"
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
-	fake_fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	fakefedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util"
 	. "k8s.io/kubernetes/federation/pkg/federation-controller/util/test"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	fake_kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
+	fakekubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -36,29 +36,29 @@ import (
 )
 
 func TestConfigMapController(t *testing.T) {
-	cluster1 := NewCluster("cluster1", api_v1.ConditionTrue)
-	cluster2 := NewCluster("cluster2", api_v1.ConditionTrue)
+	cluster1 := NewCluster("cluster1", apiv1.ConditionTrue)
+	cluster2 := NewCluster("cluster2", apiv1.ConditionTrue)
 
-	fakeClient := &fake_fedclientset.Clientset{}
-	RegisterFakeList("clusters", &fakeClient.Fake, &federation_api.ClusterList{Items: []federation_api.Cluster{*cluster1}})
-	RegisterFakeList("configmaps", &fakeClient.Fake, &api_v1.ConfigMapList{Items: []api_v1.ConfigMap{}})
+	fakeClient := &fakefedclientset.Clientset{}
+	RegisterFakeList("clusters", &fakeClient.Fake, &federationapi.ClusterList{Items: []federationapi.Cluster{*cluster1}})
+	RegisterFakeList("configmaps", &fakeClient.Fake, &apiv1.ConfigMapList{Items: []apiv1.ConfigMap{}})
 	configmapWatch := RegisterFakeWatch("configmaps", &fakeClient.Fake)
 	clusterWatch := RegisterFakeWatch("clusters", &fakeClient.Fake)
 
-	cluster1Client := &fake_kubeclientset.Clientset{}
+	cluster1Client := &fakekubeclientset.Clientset{}
 	cluster1Watch := RegisterFakeWatch("configmaps", &cluster1Client.Fake)
-	RegisterFakeList("configmaps", &cluster1Client.Fake, &api_v1.ConfigMapList{Items: []api_v1.ConfigMap{}})
+	RegisterFakeList("configmaps", &cluster1Client.Fake, &apiv1.ConfigMapList{Items: []apiv1.ConfigMap{}})
 	cluster1CreateChan := RegisterFakeCopyOnCreate("configmaps", &cluster1Client.Fake, cluster1Watch)
 	cluster1UpdateChan := RegisterFakeCopyOnUpdate("configmaps", &cluster1Client.Fake, cluster1Watch)
 
-	cluster2Client := &fake_kubeclientset.Clientset{}
+	cluster2Client := &fakekubeclientset.Clientset{}
 	cluster2Watch := RegisterFakeWatch("configmaps", &cluster2Client.Fake)
-	RegisterFakeList("configmaps", &cluster2Client.Fake, &api_v1.ConfigMapList{Items: []api_v1.ConfigMap{}})
+	RegisterFakeList("configmaps", &cluster2Client.Fake, &apiv1.ConfigMapList{Items: []apiv1.ConfigMap{}})
 	cluster2CreateChan := RegisterFakeCopyOnCreate("configmaps", &cluster2Client.Fake, cluster2Watch)
 
 	configmapController := NewConfigMapController(fakeClient)
 	informer := ToFederatedInformerForTestOnly(configmapController.configmapFederatedInformer)
-	informer.SetClientFactory(func(cluster *federation_api.Cluster) (kubeclientset.Interface, error) {
+	informer.SetClientFactory(func(cluster *federationapi.Cluster) (kubeclientset.Interface, error) {
 		switch cluster.Name {
 		case cluster1.Name:
 			return cluster1Client, nil
@@ -77,8 +77,8 @@ func TestConfigMapController(t *testing.T) {
 	stop := make(chan struct{})
 	configmapController.Run(stop)
 
-	configmap1 := &api_v1.ConfigMap{
-		ObjectMeta: api_v1.ObjectMeta{
+	configmap1 := &apiv1.ConfigMap{
+		ObjectMeta: apiv1.ObjectMeta{
 			Name:      "test-configmap",
 			Namespace: "ns",
 			SelfLink:  "/api/v1/namespaces/ns/configmaps/test-configmap",
@@ -136,7 +136,7 @@ func TestConfigMapController(t *testing.T) {
 	close(stop)
 }
 
-func GetConfigMapFromChan(c chan runtime.Object) *api_v1.ConfigMap {
-	configmap := GetObjectFromChan(c).(*api_v1.ConfigMap)
+func GetConfigMapFromChan(c chan runtime.Object) *apiv1.ConfigMap {
+	configmap := GetObjectFromChan(c).(*apiv1.ConfigMap)
 	return configmap
 }

federation/pkg/federation-controller/daemonset/daemonset_controller.go

@@ -21,21 +21,21 @@ import (
 	"reflect"
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
 	federationclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util/deletionhelper"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util/eventsink"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	extensionsv1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
 	"k8s.io/kubernetes/pkg/client/cache"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/conversion"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util/flowcontrol"
 	"k8s.io/kubernetes/pkg/watch"
@@ -87,7 +87,7 @@ type DaemonSetController struct {
 func NewDaemonSetController(client federationclientset.Interface) *DaemonSetController {
 	broadcaster := record.NewBroadcaster()
 	broadcaster.StartRecordingToSink(eventsink.NewFederatedEventSink(client))
-	recorder := broadcaster.NewRecorder(api_v1.EventSource{Component: "federated-daemonset-controller"})
+	recorder := broadcaster.NewRecorder(apiv1.EventSource{Component: "federated-daemonset-controller"})
 
 	daemonsetcontroller := &DaemonSetController{
 		federatedApiClient:    client,
@@ -106,28 +106,28 @@ func NewDaemonSetController(client federationclientset.Interface) *DaemonSetCont
 	// Start informer in federated API servers on daemonsets that should be federated.
 	daemonsetcontroller.daemonsetInformerStore, daemonsetcontroller.daemonsetInformerController = cache.NewInformer(
 		&cache.ListWatch{
-			ListFunc: func(options api_v1.ListOptions) (pkg_runtime.Object, error) {
-				return client.Extensions().DaemonSets(api_v1.NamespaceAll).List(options)
+			ListFunc: func(options apiv1.ListOptions) (pkgruntime.Object, error) {
+				return client.Extensions().DaemonSets(apiv1.NamespaceAll).List(options)
 			},
-			WatchFunc: func(options api_v1.ListOptions) (watch.Interface, error) {
-				return client.Extensions().DaemonSets(api_v1.NamespaceAll).Watch(options)
+			WatchFunc: func(options apiv1.ListOptions) (watch.Interface, error) {
+				return client.Extensions().DaemonSets(apiv1.NamespaceAll).Watch(options)
 			},
 		},
 		&extensionsv1.DaemonSet{},
 		controller.NoResyncPeriodFunc(),
-		util.NewTriggerOnAllChanges(func(obj pkg_runtime.Object) { daemonsetcontroller.deliverDaemonSetObj(obj, 0, false) }))
+		util.NewTriggerOnAllChanges(func(obj pkgruntime.Object) { daemonsetcontroller.deliverDaemonSetObj(obj, 0, false) }))
 
 	// Federated informer on daemonsets in members of federation.
 	daemonsetcontroller.daemonsetFederatedInformer = util.NewFederatedInformer(
 		client,
-		func(cluster *federation_api.Cluster, targetClient kubeclientset.Interface) (cache.Store, cache.ControllerInterface) {
+		func(cluster *federationapi.Cluster, targetClient kubeclientset.Interface) (cache.Store, cache.ControllerInterface) {
 			return cache.NewInformer(
 				&cache.ListWatch{
-					ListFunc: func(options api_v1.ListOptions) (pkg_runtime.Object, error) {
-						return targetClient.Extensions().DaemonSets(api_v1.NamespaceAll).List(options)
+					ListFunc: func(options apiv1.ListOptions) (pkgruntime.Object, error) {
+						return targetClient.Extensions().DaemonSets(apiv1.NamespaceAll).List(options)
 					},
-					WatchFunc: func(options api_v1.ListOptions) (watch.Interface, error) {
-						return targetClient.Extensions().DaemonSets(api_v1.NamespaceAll).Watch(options)
+					WatchFunc: func(options apiv1.ListOptions) (watch.Interface, error) {
+						return targetClient.Extensions().DaemonSets(apiv1.NamespaceAll).Watch(options)
 					},
 				},
 				&extensionsv1.DaemonSet{},
@@ -135,14 +135,14 @@ func NewDaemonSetController(client federationclientset.Interface) *DaemonSetCont
 				// Trigger reconciliation whenever something in federated cluster is changed. In most cases it
 				// would be just confirmation that some daemonset opration succeeded.
 				util.NewTriggerOnAllChanges(
-					func(obj pkg_runtime.Object) {
+					func(obj pkgruntime.Object) {
 						daemonsetcontroller.deliverDaemonSetObj(obj, daemonsetcontroller.daemonsetReviewDelay, false)
 					},
 				))
 		},
 
 		&util.ClusterLifecycleHandlerFuncs{
-			ClusterAvailable: func(cluster *federation_api.Cluster) {
+			ClusterAvailable: func(cluster *federationapi.Cluster) {
 				// When new cluster becomes available process all the daemonsets again.
 				daemonsetcontroller.clusterDeliverer.DeliverAt(allClustersKey, nil, time.Now().Add(daemonsetcontroller.clusterAvailableDelay))
 			},
@@ -151,7 +151,7 @@ func NewDaemonSetController(client federationclientset.Interface) *DaemonSetCont
 
 	// Federated updater along with Create/Update/Delete operations.
 	daemonsetcontroller.federatedUpdater = util.NewFederatedUpdater(daemonsetcontroller.daemonsetFederatedInformer,
-		func(client kubeclientset.Interface, obj pkg_runtime.Object) error {
+		func(client kubeclientset.Interface, obj pkgruntime.Object) error {
 			daemonset := obj.(*extensionsv1.DaemonSet)
 			glog.V(4).Infof("Attempting to create daemonset: %s/%s", daemonset.Namespace, daemonset.Name)
 			_, err := client.Extensions().DaemonSets(daemonset.Namespace).Create(daemonset)
@@ -162,7 +162,7 @@ func NewDaemonSetController(client federationclientset.Interface) *DaemonSetCont
 			}
 			return err
 		},
-		func(client kubeclientset.Interface, obj pkg_runtime.Object) error {
+		func(client kubeclientset.Interface, obj pkgruntime.Object) error {
 			daemonset := obj.(*extensionsv1.DaemonSet)
 			glog.V(4).Infof("Attempting to update daemonset: %s/%s", daemonset.Namespace, daemonset.Name)
 			_, err := client.Extensions().DaemonSets(daemonset.Namespace).Update(daemonset)
@@ -173,10 +173,10 @@ func NewDaemonSetController(client federationclientset.Interface) *DaemonSetCont
 			}
 			return err
 		},
-		func(client kubeclientset.Interface, obj pkg_runtime.Object) error {
+		func(client kubeclientset.Interface, obj pkgruntime.Object) error {
 			daemonset := obj.(*extensionsv1.DaemonSet)
 			glog.V(4).Infof("Attempting to delete daemonset: %s/%s", daemonset.Namespace, daemonset.Name)
-			err := client.Extensions().DaemonSets(daemonset.Namespace).Delete(daemonset.Name, &api_v1.DeleteOptions{})
+			err := client.Extensions().DaemonSets(daemonset.Namespace).Delete(daemonset.Name, &apiv1.DeleteOptions{})
 			if err != nil {
 				glog.Errorf("Error deleting daemonset %s/%s/: %v", daemonset.Namespace, daemonset.Name, err)
 			} else {
@@ -190,7 +190,7 @@ func NewDaemonSetController(client federationclientset.Interface) *DaemonSetCont
 		daemonsetcontroller.removeFinalizerFunc,
 		daemonsetcontroller.addFinalizerFunc,
 		// objNameFunc
-		func(obj pkg_runtime.Object) string {
+		func(obj pkgruntime.Object) string {
 			daemonset := obj.(*extensionsv1.DaemonSet)
 			return daemonset.Name
 		},
@@ -204,7 +204,7 @@ func NewDaemonSetController(client federationclientset.Interface) *DaemonSetCont
 }
 
 // Returns true if the given object has the given finalizer in its ObjectMeta.
-func (daemonsetcontroller *DaemonSetController) hasFinalizerFunc(obj pkg_runtime.Object, finalizer string) bool {
+func (daemonsetcontroller *DaemonSetController) hasFinalizerFunc(obj pkgruntime.Object, finalizer string) bool {
 	daemonset := obj.(*extensionsv1.DaemonSet)
 	for i := range daemonset.ObjectMeta.Finalizers {
 		if string(daemonset.ObjectMeta.Finalizers[i]) == finalizer {
@@ -216,7 +216,7 @@ func (daemonsetcontroller *DaemonSetController) hasFinalizerFunc(obj pkg_runtime
 
 // Removes the finalizer from the given objects ObjectMeta.
 // Assumes that the given object is a daemonset.
-func (daemonsetcontroller *DaemonSetController) removeFinalizerFunc(obj pkg_runtime.Object, finalizer string) (pkg_runtime.Object, error) {
+func (daemonsetcontroller *DaemonSetController) removeFinalizerFunc(obj pkgruntime.Object, finalizer string) (pkgruntime.Object, error) {
 	daemonset := obj.(*extensionsv1.DaemonSet)
 	newFinalizers := []string{}
 	hasFinalizer := false
@@ -241,7 +241,7 @@ func (daemonsetcontroller *DaemonSetController) removeFinalizerFunc(obj pkg_runt
 
 // Adds the given finalizer to the given objects ObjectMeta.
 // Assumes that the given object is a daemonset.
-func (daemonsetcontroller *DaemonSetController) addFinalizerFunc(obj pkg_runtime.Object, finalizer string) (pkg_runtime.Object, error) {
+func (daemonsetcontroller *DaemonSetController) addFinalizerFunc(obj pkgruntime.Object, finalizer string) (pkgruntime.Object, error) {
 	daemonset := obj.(*extensionsv1.DaemonSet)
 	daemonset.ObjectMeta.Finalizers = append(daemonset.ObjectMeta.Finalizers, finalizer)
 	daemonset, err := daemonsetcontroller.federatedApiClient.Extensions().DaemonSets(daemonset.Namespace).Update(daemonset)

federation/pkg/federation-controller/daemonset/daemonset_controller_test.go

@@ -22,16 +22,16 @@ import (
 	"testing"
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
-	fake_fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	fakefedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util"
 	//"k8s.io/kubernetes/federation/pkg/federation-controller/util/deletionhelper"
 	. "k8s.io/kubernetes/federation/pkg/federation-controller/util/test"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	extensionsv1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	fake_kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
+	fakekubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/wait"
 
@@ -39,30 +39,30 @@ import (
 )
 
 func TestDaemonSetController(t *testing.T) {
-	cluster1 := NewCluster("cluster1", api_v1.ConditionTrue)
-	cluster2 := NewCluster("cluster2", api_v1.ConditionTrue)
+	cluster1 := NewCluster("cluster1", apiv1.ConditionTrue)
+	cluster2 := NewCluster("cluster2", apiv1.ConditionTrue)
 
-	fakeClient := &fake_fedclientset.Clientset{}
-	RegisterFakeList("clusters", &fakeClient.Fake, &federation_api.ClusterList{Items: []federation_api.Cluster{*cluster1}})
+	fakeClient := &fakefedclientset.Clientset{}
+	RegisterFakeList("clusters", &fakeClient.Fake, &federationapi.ClusterList{Items: []federationapi.Cluster{*cluster1}})
 	RegisterFakeList("daemonsets", &fakeClient.Fake, &extensionsv1.DaemonSetList{Items: []extensionsv1.DaemonSet{}})
 	daemonsetWatch := RegisterFakeWatch("daemonsets", &fakeClient.Fake)
 	// daemonsetUpdateChan := RegisterFakeCopyOnUpdate("daemonsets", &fakeClient.Fake, daemonsetWatch)
 	clusterWatch := RegisterFakeWatch("clusters", &fakeClient.Fake)
 
-	cluster1Client := &fake_kubeclientset.Clientset{}
+	cluster1Client := &fakekubeclientset.Clientset{}
 	cluster1Watch := RegisterFakeWatch("daemonsets", &cluster1Client.Fake)
 	RegisterFakeList("daemonsets", &cluster1Client.Fake, &extensionsv1.DaemonSetList{Items: []extensionsv1.DaemonSet{}})
 	cluster1CreateChan := RegisterFakeCopyOnCreate("daemonsets", &cluster1Client.Fake, cluster1Watch)
 	// cluster1UpdateChan := RegisterFakeCopyOnUpdate("daemonsets", &cluster1Client.Fake, cluster1Watch)
 
-	cluster2Client := &fake_kubeclientset.Clientset{}
+	cluster2Client := &fakekubeclientset.Clientset{}
 	cluster2Watch := RegisterFakeWatch("daemonsets", &cluster2Client.Fake)
 	RegisterFakeList("daemonsets", &cluster2Client.Fake, &extensionsv1.DaemonSetList{Items: []extensionsv1.DaemonSet{}})
 	cluster2CreateChan := RegisterFakeCopyOnCreate("daemonsets", &cluster2Client.Fake, cluster2Watch)
 
 	daemonsetController := NewDaemonSetController(fakeClient)
 	informer := ToFederatedInformerForTestOnly(daemonsetController.daemonsetFederatedInformer)
-	informer.SetClientFactory(func(cluster *federation_api.Cluster) (kubeclientset.Interface, error) {
+	informer.SetClientFactory(func(cluster *federationapi.Cluster) (kubeclientset.Interface, error) {
 		switch cluster.Name {
 		case cluster1.Name:
 			return cluster1Client, nil
@@ -82,7 +82,7 @@ func TestDaemonSetController(t *testing.T) {
 	daemonsetController.Run(stop)
 
 	daemonset1 := extensionsv1.DaemonSet{
-		ObjectMeta: api_v1.ObjectMeta{
+		ObjectMeta: apiv1.ObjectMeta{
 			Name:      "test-daemonset",
 			Namespace: "ns",
 			SelfLink:  "/api/v1/namespaces/ns/daemonsets/test-daemonset",
@@ -102,7 +102,7 @@ func TestDaemonSetController(t *testing.T) {
 		updatedDaemonSet := GetDaemonSetFromChan(daemonsetUpdateChan)
 		assert.True(t, daemonsetController.hasFinalizerFunc(updatedDaemonSet, deletionhelper.FinalizerDeleteFromUnderlyingClusters))
 		updatedDaemonSet = GetDaemonSetFromChan(daemonsetUpdateChan)
-		assert.True(t, daemonsetController.hasFinalizerFunc(updatedDaemonSet, api_v1.FinalizerOrphan))
+		assert.True(t, daemonsetController.hasFinalizerFunc(updatedDaemonSet, apiv1.FinalizerOrphan))
 		daemonset1 = *updatedDaemonSet
 	*/
 	createdDaemonSet := GetDaemonSetFromChan(cluster1CreateChan)

federation/pkg/federation-controller/deployment/deploymentcontroller_test.go

@@ -23,13 +23,13 @@ import (
 	"time"
 
 	fedv1 "k8s.io/kubernetes/federation/apis/federation/v1beta1"
-	fake_fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
+	fakefedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
 	. "k8s.io/kubernetes/federation/pkg/federation-controller/util/test"
 	"k8s.io/kubernetes/pkg/api/meta"
 	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	extensionsv1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	fake_kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
+	fakekubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -83,19 +83,19 @@ func TestDeploymentController(t *testing.T) {
 	cluster1 := NewCluster("cluster1", apiv1.ConditionTrue)
 	cluster2 := NewCluster("cluster2", apiv1.ConditionTrue)
 
-	fakeClient := &fake_fedclientset.Clientset{}
+	fakeClient := &fakefedclientset.Clientset{}
 	RegisterFakeList("clusters", &fakeClient.Fake, &fedv1.ClusterList{Items: []fedv1.Cluster{*cluster1}})
 	deploymentsWatch := RegisterFakeWatch("deployments", &fakeClient.Fake)
 	clusterWatch := RegisterFakeWatch("clusters", &fakeClient.Fake)
 
-	cluster1Client := &fake_kubeclientset.Clientset{}
+	cluster1Client := &fakekubeclientset.Clientset{}
 	cluster1Watch := RegisterFakeWatch("deployments", &cluster1Client.Fake)
 	_ = RegisterFakeWatch("pods", &cluster1Client.Fake)
 	RegisterFakeList("deployments", &cluster1Client.Fake, &extensionsv1.DeploymentList{Items: []extensionsv1.Deployment{}})
 	cluster1CreateChan := RegisterFakeCopyOnCreate("deployments", &cluster1Client.Fake, cluster1Watch)
 	cluster1UpdateChan := RegisterFakeCopyOnUpdate("deployments", &cluster1Client.Fake, cluster1Watch)
 
-	cluster2Client := &fake_kubeclientset.Clientset{}
+	cluster2Client := &fakekubeclientset.Clientset{}
 	cluster2Watch := RegisterFakeWatch("deployments", &cluster2Client.Fake)
 	_ = RegisterFakeWatch("pods", &cluster2Client.Fake)
 	RegisterFakeList("deployments", &cluster2Client.Fake, &extensionsv1.DeploymentList{Items: []extensionsv1.Deployment{}})

federation/pkg/federation-controller/namespace/namespace_controller_test.go

@@ -21,16 +21,16 @@ import (
 	"testing"
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
-	fake_fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	fakefedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util/deletionhelper"
 	. "k8s.io/kubernetes/federation/pkg/federation-controller/util/test"
 	"k8s.io/kubernetes/pkg/api/unversioned"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	extensionsv1 "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	fake_kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
+	fakekubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
 	"k8s.io/kubernetes/pkg/client/testing/core"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -39,51 +39,51 @@ import (
 )
 
 func TestNamespaceController(t *testing.T) {
-	cluster1 := NewCluster("cluster1", api_v1.ConditionTrue)
-	cluster2 := NewCluster("cluster2", api_v1.ConditionTrue)
-	ns1 := api_v1.Namespace{
-		ObjectMeta: api_v1.ObjectMeta{
+	cluster1 := NewCluster("cluster1", apiv1.ConditionTrue)
+	cluster2 := NewCluster("cluster2", apiv1.ConditionTrue)
+	ns1 := apiv1.Namespace{
+		ObjectMeta: apiv1.ObjectMeta{
 			Name:     "test-namespace",
 			SelfLink: "/api/v1/namespaces/test-namespace",
 		},
-		Spec: api_v1.NamespaceSpec{
-			Finalizers: []api_v1.FinalizerName{api_v1.FinalizerKubernetes},
+		Spec: apiv1.NamespaceSpec{
+			Finalizers: []apiv1.FinalizerName{apiv1.FinalizerKubernetes},
 		},
 	}
 
-	fakeClient := &fake_fedclientset.Clientset{}
-	RegisterFakeList("clusters", &fakeClient.Fake, &federation_api.ClusterList{Items: []federation_api.Cluster{*cluster1}})
-	RegisterFakeList("namespaces", &fakeClient.Fake, &api_v1.NamespaceList{Items: []api_v1.Namespace{}})
+	fakeClient := &fakefedclientset.Clientset{}
+	RegisterFakeList("clusters", &fakeClient.Fake, &federationapi.ClusterList{Items: []federationapi.Cluster{*cluster1}})
+	RegisterFakeList("namespaces", &fakeClient.Fake, &apiv1.NamespaceList{Items: []apiv1.Namespace{}})
 	namespaceWatch := RegisterFakeWatch("namespaces", &fakeClient.Fake)
 	namespaceCreateChan := RegisterFakeCopyOnCreate("namespaces", &fakeClient.Fake, namespaceWatch)
 	clusterWatch := RegisterFakeWatch("clusters", &fakeClient.Fake)
 
-	cluster1Client := &fake_kubeclientset.Clientset{}
+	cluster1Client := &fakekubeclientset.Clientset{}
 	cluster1Watch := RegisterFakeWatch("namespaces", &cluster1Client.Fake)
-	RegisterFakeList("namespaces", &cluster1Client.Fake, &api_v1.NamespaceList{Items: []api_v1.Namespace{}})
+	RegisterFakeList("namespaces", &cluster1Client.Fake, &apiv1.NamespaceList{Items: []apiv1.Namespace{}})
 	cluster1CreateChan := RegisterFakeCopyOnCreate("namespaces", &cluster1Client.Fake, cluster1Watch)
 	//	cluster1UpdateChan := RegisterFakeCopyOnUpdate("namespaces", &cluster1Client.Fake, cluster1Watch)
 
-	cluster2Client := &fake_kubeclientset.Clientset{}
+	cluster2Client := &fakekubeclientset.Clientset{}
 	cluster2Watch := RegisterFakeWatch("namespaces", &cluster2Client.Fake)
-	RegisterFakeList("namespaces", &cluster2Client.Fake, &api_v1.NamespaceList{Items: []api_v1.Namespace{}})
+	RegisterFakeList("namespaces", &cluster2Client.Fake, &apiv1.NamespaceList{Items: []apiv1.Namespace{}})
 	cluster2CreateChan := RegisterFakeCopyOnCreate("namespaces", &cluster2Client.Fake, cluster2Watch)
 
 	RegisterFakeList("replicasets", &fakeClient.Fake, &extensionsv1.ReplicaSetList{Items: []extensionsv1.ReplicaSet{
 		{
-			ObjectMeta: api_v1.ObjectMeta{
+			ObjectMeta: apiv1.ObjectMeta{
 				Name:      "test-rs",
 				Namespace: ns1.Namespace,
 			}}}})
-	RegisterFakeList("secrets", &fakeClient.Fake, &api_v1.SecretList{Items: []api_v1.Secret{
+	RegisterFakeList("secrets", &fakeClient.Fake, &apiv1.SecretList{Items: []apiv1.Secret{
 		{
-			ObjectMeta: api_v1.ObjectMeta{
+			ObjectMeta: apiv1.ObjectMeta{
 				Name:      "test-secret",
 				Namespace: ns1.Namespace,
 			}}}})
-	RegisterFakeList("services", &fakeClient.Fake, &api_v1.ServiceList{Items: []api_v1.Service{
+	RegisterFakeList("services", &fakeClient.Fake, &apiv1.ServiceList{Items: []apiv1.Service{
 		{
-			ObjectMeta: api_v1.ObjectMeta{
+			ObjectMeta: apiv1.ObjectMeta{
 				Name:      "test-service",
 				Namespace: ns1.Namespace,
 			}}}})
@@ -93,7 +93,7 @@ func TestNamespaceController(t *testing.T) {
 	secretDeleteChan := RegisterDeleteCollection(&fakeClient.Fake, "secrets")
 
 	namespaceController := NewNamespaceController(fakeClient)
-	informerClientFactory := func(cluster *federation_api.Cluster) (kubeclientset.Interface, error) {
+	informerClientFactory := func(cluster *federationapi.Cluster) (kubeclientset.Interface, error) {
 		switch cluster.Name {
 		case cluster1.Name:
 			return cluster1Client, nil
@@ -155,7 +155,7 @@ func TestNamespaceController(t *testing.T) {
 	// Delete the namespace with orphan finalizer (let namespaces
 	// in underlying clusters be as is).
 	// TODO: Add a test without orphan finalizer.
-	ns1.ObjectMeta.Finalizers = append(ns1.ObjectMeta.Finalizers, api_v1.FinalizerOrphan)
+	ns1.ObjectMeta.Finalizers = append(ns1.ObjectMeta.Finalizers, apiv1.FinalizerOrphan)
 	ns1.DeletionTimestamp = &unversioned.Time{Time: time.Now()}
 	namespaceWatch.Modify(&ns1)
 	assert.Equal(t, ns1.Name, GetStringFromChan(nsDeleteChan))
@@ -166,7 +166,7 @@ func TestNamespaceController(t *testing.T) {
 	close(stop)
 }
 
-func setClientFactory(informer util.FederatedInformer, informerClientFactory func(*federation_api.Cluster) (kubeclientset.Interface, error)) {
+func setClientFactory(informer util.FederatedInformer, informerClientFactory func(*federationapi.Cluster) (kubeclientset.Interface, error)) {
 	testInformer := ToFederatedInformerForTestOnly(informer)
 	testInformer.SetClientFactory(informerClientFactory)
 }
@@ -199,8 +199,8 @@ func GetStringFromChan(c chan string) string {
 	}
 }
 
-func GetNamespaceFromChan(c chan runtime.Object) *api_v1.Namespace {
-	namespace := GetObjectFromChan(c).(*api_v1.Namespace)
+func GetNamespaceFromChan(c chan runtime.Object) *apiv1.Namespace {
+	namespace := GetObjectFromChan(c).(*apiv1.Namespace)
 	return namespace
 
 }

federation/pkg/federation-controller/secret/secret_controller_test.go

@@ -22,14 +22,14 @@ import (
 	"testing"
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
-	fake_fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	fakefedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util/deletionhelper"
 	. "k8s.io/kubernetes/federation/pkg/federation-controller/util/test"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	fake_kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
+	fakekubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -38,29 +38,29 @@ import (
 )
 
 func TestSecretController(t *testing.T) {
-	cluster1 := NewCluster("cluster1", api_v1.ConditionTrue)
-	cluster2 := NewCluster("cluster2", api_v1.ConditionTrue)
+	cluster1 := NewCluster("cluster1", apiv1.ConditionTrue)
+	cluster2 := NewCluster("cluster2", apiv1.ConditionTrue)
 
-	fakeClient := &fake_fedclientset.Clientset{}
-	RegisterFakeList("clusters", &fakeClient.Fake, &federation_api.ClusterList{Items: []federation_api.Cluster{*cluster1}})
-	RegisterFakeList("secrets", &fakeClient.Fake, &api_v1.SecretList{Items: []api_v1.Secret{}})
+	fakeClient := &fakefedclientset.Clientset{}
+	RegisterFakeList("clusters", &fakeClient.Fake, &federationapi.ClusterList{Items: []federationapi.Cluster{*cluster1}})
+	RegisterFakeList("secrets", &fakeClient.Fake, &apiv1.SecretList{Items: []apiv1.Secret{}})
 	secretWatch := RegisterFakeWatch("secrets", &fakeClient.Fake)
 	secretUpdateChan := RegisterFakeCopyOnUpdate("secrets", &fakeClient.Fake, secretWatch)
 	clusterWatch := RegisterFakeWatch("clusters", &fakeClient.Fake)
 
-	cluster1Client := &fake_kubeclientset.Clientset{}
+	cluster1Client := &fakekubeclientset.Clientset{}
 	cluster1Watch := RegisterFakeWatch("secrets", &cluster1Client.Fake)
-	RegisterFakeList("secrets", &cluster1Client.Fake, &api_v1.SecretList{Items: []api_v1.Secret{}})
+	RegisterFakeList("secrets", &cluster1Client.Fake, &apiv1.SecretList{Items: []apiv1.Secret{}})
 	cluster1CreateChan := RegisterFakeCopyOnCreate("secrets", &cluster1Client.Fake, cluster1Watch)
 	//	cluster1UpdateChan := RegisterFakeCopyOnUpdate("secrets", &cluster1Client.Fake, cluster1Watch)
 
-	cluster2Client := &fake_kubeclientset.Clientset{}
+	cluster2Client := &fakekubeclientset.Clientset{}
 	cluster2Watch := RegisterFakeWatch("secrets", &cluster2Client.Fake)
-	RegisterFakeList("secrets", &cluster2Client.Fake, &api_v1.SecretList{Items: []api_v1.Secret{}})
+	RegisterFakeList("secrets", &cluster2Client.Fake, &apiv1.SecretList{Items: []apiv1.Secret{}})
 	cluster2CreateChan := RegisterFakeCopyOnCreate("secrets", &cluster2Client.Fake, cluster2Watch)
 
 	secretController := NewSecretController(fakeClient)
-	informerClientFactory := func(cluster *federation_api.Cluster) (kubeclientset.Interface, error) {
+	informerClientFactory := func(cluster *federationapi.Cluster) (kubeclientset.Interface, error) {
 		switch cluster.Name {
 		case cluster1.Name:
 			return cluster1Client, nil
@@ -80,8 +80,8 @@ func TestSecretController(t *testing.T) {
 	stop := make(chan struct{})
 	secretController.Run(stop)
 
-	secret1 := api_v1.Secret{
-		ObjectMeta: api_v1.ObjectMeta{
+	secret1 := apiv1.Secret{
+		ObjectMeta: apiv1.ObjectMeta{
 			Name:      "test-secret",
 			Namespace: "ns",
 			SelfLink:  "/api/v1/namespaces/ns/secrets/test-secret",
@@ -90,7 +90,7 @@ func TestSecretController(t *testing.T) {
 			"A": []byte("ala ma kota"),
 			"B": []byte("quick brown fox"),
 		},
-		Type: api_v1.SecretTypeOpaque,
+		Type: apiv1.SecretTypeOpaque,
 	}
 
 	// Test add federated secret.
@@ -99,7 +99,7 @@ func TestSecretController(t *testing.T) {
 	updatedSecret := GetSecretFromChan(secretUpdateChan)
 	assert.True(t, secretController.hasFinalizerFunc(updatedSecret, deletionhelper.FinalizerDeleteFromUnderlyingClusters))
 	updatedSecret = GetSecretFromChan(secretUpdateChan)
-	assert.True(t, secretController.hasFinalizerFunc(updatedSecret, api_v1.FinalizerOrphan))
+	assert.True(t, secretController.hasFinalizerFunc(updatedSecret, apiv1.FinalizerOrphan))
 	secret1 = *updatedSecret
 
 	// Verify that the secret is created in underlying cluster1.
@@ -161,12 +161,12 @@ func TestSecretController(t *testing.T) {
 	close(stop)
 }
 
-func setClientFactory(informer util.FederatedInformer, informerClientFactory func(*federation_api.Cluster) (kubeclientset.Interface, error)) {
+func setClientFactory(informer util.FederatedInformer, informerClientFactory func(*federationapi.Cluster) (kubeclientset.Interface, error)) {
 	testInformer := ToFederatedInformerForTestOnly(informer)
 	testInformer.SetClientFactory(informerClientFactory)
 }
 
-func secretsEqual(a, b api_v1.Secret) bool {
+func secretsEqual(a, b apiv1.Secret) bool {
 	// Clear the SelfLink and ObjectMeta.Finalizers since they will be different
 	// in resoure in federation control plane and resource in underlying cluster.
 	a.SelfLink = ""
@@ -176,20 +176,20 @@ func secretsEqual(a, b api_v1.Secret) bool {
 	return reflect.DeepEqual(a, b)
 }
 
-func GetSecretFromChan(c chan runtime.Object) *api_v1.Secret {
-	secret := GetObjectFromChan(c).(*api_v1.Secret)
+func GetSecretFromChan(c chan runtime.Object) *apiv1.Secret {
+	secret := GetObjectFromChan(c).(*apiv1.Secret)
 	return secret
 }
 
 // Wait till the store is updated with latest secret.
-func WaitForSecretStoreUpdate(store util.FederatedReadOnlyStore, clusterName, key string, desiredSecret *api_v1.Secret, timeout time.Duration) error {
+func WaitForSecretStoreUpdate(store util.FederatedReadOnlyStore, clusterName, key string, desiredSecret *apiv1.Secret, timeout time.Duration) error {
 	retryInterval := 100 * time.Millisecond
 	err := wait.PollImmediate(retryInterval, timeout, func() (bool, error) {
 		obj, found, err := store.GetByKey(clusterName, key)
 		if !found || err != nil {
 			return false, err
 		}
-		equal := secretsEqual(*obj.(*api_v1.Secret), *desiredSecret)
+		equal := secretsEqual(*obj.(*apiv1.Secret), *desiredSecret)
 		return equal, err
 	})
 	return err

federation/pkg/federation-controller/service/cluster_helper.go

@@ -24,7 +24,7 @@ import (
 	cache "k8s.io/kubernetes/pkg/client/cache"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
 	"k8s.io/kubernetes/pkg/client/restclient"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/pkg/util/workqueue"
 	"k8s.io/kubernetes/pkg/watch"
@@ -91,7 +91,7 @@ func (cc *clusterClientCache) startClusterLW(cluster *v1beta1.Cluster, clusterNa
 		}
 		cachedClusterClient.endpointStore.Store, cachedClusterClient.endpointController = cache.NewInformer(
 			&cache.ListWatch{
-				ListFunc: func(options v1.ListOptions) (pkg_runtime.Object, error) {
+				ListFunc: func(options v1.ListOptions) (pkgruntime.Object, error) {
 					return clientset.Core().Endpoints(v1.NamespaceAll).List(options)
 				},
 				WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
@@ -115,7 +115,7 @@ func (cc *clusterClientCache) startClusterLW(cluster *v1beta1.Cluster, clusterNa
 
 		cachedClusterClient.serviceStore.Indexer, cachedClusterClient.serviceController = cache.NewIndexerInformer(
 			&cache.ListWatch{
-				ListFunc: func(options v1.ListOptions) (pkg_runtime.Object, error) {
+				ListFunc: func(options v1.ListOptions) (pkgruntime.Object, error) {
 					return clientset.Core().Services(v1.NamespaceAll).List(options)
 				},
 				WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {

federation/pkg/federation-controller/service/servicecontroller.go

@@ -34,7 +34,7 @@ import (
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/controller"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/runtime"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -164,7 +164,7 @@ func New(federationClient fedclientset.Interface, dns dnsprovider.Interface,
 	}
 	s.serviceStore.Indexer, s.serviceController = cache.NewIndexerInformer(
 		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (pkg_runtime.Object, error) {
+			ListFunc: func(options v1.ListOptions) (pkgruntime.Object, error) {
 				return s.federationClient.Core().Services(v1.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
@@ -187,7 +187,7 @@ func New(federationClient fedclientset.Interface, dns dnsprovider.Interface,
 	)
 	s.clusterStore.Store, s.clusterController = cache.NewInformer(
 		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (pkg_runtime.Object, error) {
+			ListFunc: func(options v1.ListOptions) (pkgruntime.Object, error) {
 				return s.federationClient.Federation().Clusters().List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {

federation/pkg/federation-controller/util/eventsink/eventsink_test.go

@@ -19,9 +19,9 @@ package eventsink
 import (
 	"testing"
 
-	fake_fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
+	fakefedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
 	. "k8s.io/kubernetes/federation/pkg/federation-controller/util/test"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/testing/core"
 	"k8s.io/kubernetes/pkg/runtime"
 
@@ -29,7 +29,7 @@ import (
 )
 
 func TestEventSink(t *testing.T) {
-	fakeFederationClient := &fake_fedclientset.Clientset{}
+	fakeFederationClient := &fakefedclientset.Clientset{}
 	createdChan := make(chan runtime.Object, 100)
 	fakeFederationClient.AddReactor("create", "events", func(action core.Action) (bool, runtime.Object, error) {
 		createAction := action.(core.CreateAction)
@@ -45,8 +45,8 @@ func TestEventSink(t *testing.T) {
 		return true, obj, nil
 	})
 
-	event := api_v1.Event{
-		ObjectMeta: api_v1.ObjectMeta{
+	event := apiv1.Event{
+		ObjectMeta: apiv1.ObjectMeta{
 			Name:      "bzium",
 			Namespace: "ns",
 		},
@@ -54,7 +54,7 @@ func TestEventSink(t *testing.T) {
 	sink := NewFederatedEventSink(fakeFederationClient)
 	eventUpdated, err := sink.Create(&event)
 	assert.NoError(t, err)
-	eventV1 := GetObjectFromChan(createdChan).(*api_v1.Event)
+	eventV1 := GetObjectFromChan(createdChan).(*apiv1.Event)
 	assert.NotNil(t, eventV1)
 	// Just some simple sanity checks.
 	assert.Equal(t, event.Name, eventV1.Name)
@@ -62,7 +62,7 @@ func TestEventSink(t *testing.T) {
 
 	eventUpdated, err = sink.Update(&event)
 	assert.NoError(t, err)
-	eventV1 = GetObjectFromChan(updateChan).(*api_v1.Event)
+	eventV1 = GetObjectFromChan(updateChan).(*apiv1.Event)
 	assert.NotNil(t, eventV1)
 	// Just some simple sanity checks.
 	assert.Equal(t, event.Name, eventV1.Name)

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

@@ -20,12 +20,12 @@ import (
 	"testing"
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
 	fakefederationclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_release_1_5/fake"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/cache"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	fake_kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
+	fakekubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
 	"k8s.io/kubernetes/pkg/client/testing/core"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/watch"
@@ -39,18 +39,18 @@ func TestFederatedInformer(t *testing.T) {
 	fakeFederationClient := &fakefederationclientset.Clientset{}
 
 	// Add a single cluster to federation and remove it when needed.
-	cluster := federation_api.Cluster{
-		ObjectMeta: api_v1.ObjectMeta{
+	cluster := federationapi.Cluster{
+		ObjectMeta: apiv1.ObjectMeta{
 			Name: "mycluster",
 		},
-		Status: federation_api.ClusterStatus{
-			Conditions: []federation_api.ClusterCondition{
-				{Type: federation_api.ClusterReady, Status: api_v1.ConditionTrue},
+		Status: federationapi.ClusterStatus{
+			Conditions: []federationapi.ClusterCondition{
+				{Type: federationapi.ClusterReady, Status: apiv1.ConditionTrue},
 			},
 		},
 	}
 	fakeFederationClient.AddReactor("list", "clusters", func(action core.Action) (bool, runtime.Object, error) {
-		return true, &federation_api.ClusterList{Items: []federation_api.Cluster{cluster}}, nil
+		return true, &federationapi.ClusterList{Items: []federationapi.Cluster{cluster}}, nil
 	})
 	deleteChan := make(chan struct{})
 	fakeFederationClient.AddWatchReactor("clusters", func(action core.Action) (bool, watch.Interface, error) {
@@ -62,32 +62,32 @@ func TestFederatedInformer(t *testing.T) {
 		return true, fakeWatch, nil
 	})
 
-	fakeKubeClient := &fake_kubeclientset.Clientset{}
+	fakeKubeClient := &fakekubeclientset.Clientset{}
 	// There is a single service ns1/s1 in cluster mycluster.
-	service := api_v1.Service{
-		ObjectMeta: api_v1.ObjectMeta{
+	service := apiv1.Service{
+		ObjectMeta: apiv1.ObjectMeta{
 			Namespace: "ns1",
 			Name:      "s1",
 		},
 	}
 	fakeKubeClient.AddReactor("list", "services", func(action core.Action) (bool, runtime.Object, error) {
-		return true, &api_v1.ServiceList{Items: []api_v1.Service{service}}, nil
+		return true, &apiv1.ServiceList{Items: []apiv1.Service{service}}, nil
 	})
 	fakeKubeClient.AddWatchReactor("services", func(action core.Action) (bool, watch.Interface, error) {
 		return true, watch.NewFake(), nil
 	})
 
-	targetInformerFactory := func(cluster *federation_api.Cluster, clientset kubeclientset.Interface) (cache.Store, cache.ControllerInterface) {
+	targetInformerFactory := func(cluster *federationapi.Cluster, clientset kubeclientset.Interface) (cache.Store, cache.ControllerInterface) {
 		return cache.NewInformer(
 			&cache.ListWatch{
-				ListFunc: func(options api_v1.ListOptions) (runtime.Object, error) {
-					return clientset.Core().Services(api_v1.NamespaceAll).List(options)
+				ListFunc: func(options apiv1.ListOptions) (runtime.Object, error) {
+					return clientset.Core().Services(apiv1.NamespaceAll).List(options)
 				},
-				WatchFunc: func(options api_v1.ListOptions) (watch.Interface, error) {
-					return clientset.Core().Services(api_v1.NamespaceAll).Watch(options)
+				WatchFunc: func(options apiv1.ListOptions) (watch.Interface, error) {
+					return clientset.Core().Services(apiv1.NamespaceAll).Watch(options)
 				},
 			},
-			&api_v1.Service{},
+			&apiv1.Service{},
 			10*time.Second,
 			cache.ResourceEventHandlerFuncs{})
 	}
@@ -95,25 +95,25 @@ func TestFederatedInformer(t *testing.T) {
 	addedClusters := make(chan string, 1)
 	deletedClusters := make(chan string, 1)
 	lifecycle := ClusterLifecycleHandlerFuncs{
-		ClusterAvailable: func(cluster *federation_api.Cluster) {
+		ClusterAvailable: func(cluster *federationapi.Cluster) {
 			addedClusters <- cluster.Name
 			close(addedClusters)
 		},
-		ClusterUnavailable: func(cluster *federation_api.Cluster, _ []interface{}) {
+		ClusterUnavailable: func(cluster *federationapi.Cluster, _ []interface{}) {
 			deletedClusters <- cluster.Name
 			close(deletedClusters)
 		},
 	}
 
 	informer := NewFederatedInformer(fakeFederationClient, targetInformerFactory, &lifecycle).(*federatedInformerImpl)
-	informer.clientFactory = func(cluster *federation_api.Cluster) (kubeclientset.Interface, error) {
+	informer.clientFactory = func(cluster *federationapi.Cluster) (kubeclientset.Interface, error) {
 		return fakeKubeClient, nil
 	}
 	assert.NotNil(t, informer)
 	informer.Start()
 
 	// Wait until mycluster is synced.
-	for !informer.GetTargetStore().ClustersSynced([]*federation_api.Cluster{&cluster}) {
+	for !informer.GetTargetStore().ClustersSynced([]*federationapi.Cluster{&cluster}) {
 		time.Sleep(time.Millisecond * 100)
 	}
 	readyClusters, err := informer.GetReadyClusters()
@@ -131,7 +131,7 @@ func TestFederatedInformer(t *testing.T) {
 
 	// All checked, lets delete the cluster.
 	deleteChan <- struct{}{}
-	for !informer.GetTargetStore().ClustersSynced([]*federation_api.Cluster{}) {
+	for !informer.GetTargetStore().ClustersSynced([]*federationapi.Cluster{}) {
 		time.Sleep(time.Millisecond * 100)
 	}
 	readyClusters, err = informer.GetReadyClusters()

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

@@ -21,7 +21,7 @@ import (
 	"time"
 
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 )
 
 // Type of the operation that can be executed in Federated.
@@ -37,7 +37,7 @@ const (
 type FederatedOperation struct {
 	Type        FederatedOperationType
 	ClusterName string
-	Obj         pkg_runtime.Object
+	Obj         pkgruntime.Object
 }
 
 // A helper that executes the given set of updates on federation, in parallel.
@@ -52,7 +52,7 @@ type FederatedUpdater interface {
 }
 
 // A function that executes some operation using the passed client and object.
-type FederatedOperationHandler func(kubeclientset.Interface, pkg_runtime.Object) error
+type FederatedOperationHandler func(kubeclientset.Interface, pkgruntime.Object) error
 
 type federatedUpdaterImpl struct {
 	federation FederationView

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

@@ -21,11 +21,11 @@ import (
 	"testing"
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	fake_kubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	fakekubeclientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -38,18 +38,18 @@ type fakeFederationView struct {
 var _ FederationView = &fakeFederationView{}
 
 func (f *fakeFederationView) GetClientsetForCluster(clusterName string) (kubeclientset.Interface, error) {
-	return &fake_kubeclientset.Clientset{}, nil
+	return &fakekubeclientset.Clientset{}, nil
 }
 
-func (f *fakeFederationView) GetReadyClusters() ([]*federation_api.Cluster, error) {
-	return []*federation_api.Cluster{}, nil
+func (f *fakeFederationView) GetReadyClusters() ([]*federationapi.Cluster, error) {
+	return []*federationapi.Cluster{}, nil
 }
 
-func (f *fakeFederationView) GetUnreadyClusters() ([]*federation_api.Cluster, error) {
-	return []*federation_api.Cluster{}, nil
+func (f *fakeFederationView) GetUnreadyClusters() ([]*federationapi.Cluster, error) {
+	return []*federationapi.Cluster{}, nil
 }
 
-func (f *fakeFederationView) GetReadyCluster(name string) (*federation_api.Cluster, bool, error) {
+func (f *fakeFederationView) GetReadyCluster(name string) (*federationapi.Cluster, bool, error) {
 	return nil, false, nil
 }
 
@@ -62,13 +62,13 @@ func TestFederatedUpdaterOK(t *testing.T) {
 	updateChan := make(chan string, 5)
 
 	updater := NewFederatedUpdater(&fakeFederationView{},
-		func(_ kubeclientset.Interface, obj pkg_runtime.Object) error {
-			service := obj.(*api_v1.Service)
+		func(_ kubeclientset.Interface, obj pkgruntime.Object) error {
+			service := obj.(*apiv1.Service)
 			addChan <- service.Name
 			return nil
 		},
-		func(_ kubeclientset.Interface, obj pkg_runtime.Object) error {
-			service := obj.(*api_v1.Service)
+		func(_ kubeclientset.Interface, obj pkgruntime.Object) error {
+			service := obj.(*apiv1.Service)
 			updateChan <- service.Name
 			return nil
 		},
@@ -93,7 +93,7 @@ func TestFederatedUpdaterOK(t *testing.T) {
 
 func TestFederatedUpdaterError(t *testing.T) {
 	updater := NewFederatedUpdater(&fakeFederationView{},
-		func(_ kubeclientset.Interface, obj pkg_runtime.Object) error {
+		func(_ kubeclientset.Interface, obj pkgruntime.Object) error {
 			return fmt.Errorf("boom")
 		}, noop, noop)
 
@@ -113,7 +113,7 @@ func TestFederatedUpdaterError(t *testing.T) {
 func TestFederatedUpdaterTimeout(t *testing.T) {
 	start := time.Now()
 	updater := NewFederatedUpdater(&fakeFederationView{},
-		func(_ kubeclientset.Interface, obj pkg_runtime.Object) error {
+		func(_ kubeclientset.Interface, obj pkgruntime.Object) error {
 			time.Sleep(time.Minute)
 			return nil
 		},
@@ -134,15 +134,15 @@ func TestFederatedUpdaterTimeout(t *testing.T) {
 	assert.True(t, start.Add(10*time.Second).After(end))
 }
 
-func makeService(cluster, name string) *api_v1.Service {
-	return &api_v1.Service{
-		ObjectMeta: api_v1.ObjectMeta{
+func makeService(cluster, name string) *apiv1.Service {
+	return &apiv1.Service{
+		ObjectMeta: apiv1.ObjectMeta{
 			Namespace: "ns1",
 			Name:      name,
 		},
 	}
 }
 
-func noop(_ kubeclientset.Interface, _ pkg_runtime.Object) error {
+func noop(_ kubeclientset.Interface, _ pkgruntime.Object) error {
 	return nil
 }

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

@@ -20,25 +20,25 @@ import (
 	"fmt"
 	"reflect"
 
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/cache"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 )
 
 // Returns cache.ResourceEventHandlerFuncs that trigger the given function
 // on all object changes.
-func NewTriggerOnAllChanges(triggerFunc func(pkg_runtime.Object)) *cache.ResourceEventHandlerFuncs {
+func NewTriggerOnAllChanges(triggerFunc func(pkgruntime.Object)) *cache.ResourceEventHandlerFuncs {
 	return &cache.ResourceEventHandlerFuncs{
 		DeleteFunc: func(old interface{}) {
-			oldObj := old.(pkg_runtime.Object)
+			oldObj := old.(pkgruntime.Object)
 			triggerFunc(oldObj)
 		},
 		AddFunc: func(cur interface{}) {
-			curObj := cur.(pkg_runtime.Object)
+			curObj := cur.(pkgruntime.Object)
 			triggerFunc(curObj)
 		},
 		UpdateFunc: func(old, cur interface{}) {
-			curObj := cur.(pkg_runtime.Object)
+			curObj := cur.(pkgruntime.Object)
 			if !reflect.DeepEqual(old, cur) {
 				triggerFunc(curObj)
 			}
@@ -48,7 +48,7 @@ func NewTriggerOnAllChanges(triggerFunc func(pkg_runtime.Object)) *cache.Resourc
 
 // Returns cache.ResourceEventHandlerFuncs that trigger the given function
 // on object add and delete as well as spec/object meta on update.
-func NewTriggerOnMetaAndSpecChanges(triggerFunc func(pkg_runtime.Object)) *cache.ResourceEventHandlerFuncs {
+func NewTriggerOnMetaAndSpecChanges(triggerFunc func(pkgruntime.Object)) *cache.ResourceEventHandlerFuncs {
 	getFieldOrPanic := func(obj interface{}, fieldName string) interface{} {
 		val := reflect.ValueOf(obj).Elem().FieldByName(fieldName)
 		if val.IsValid() {
@@ -59,17 +59,17 @@ func NewTriggerOnMetaAndSpecChanges(triggerFunc func(pkg_runtime.Object)) *cache
 	}
 	return &cache.ResourceEventHandlerFuncs{
 		DeleteFunc: func(old interface{}) {
-			oldObj := old.(pkg_runtime.Object)
+			oldObj := old.(pkgruntime.Object)
 			triggerFunc(oldObj)
 		},
 		AddFunc: func(cur interface{}) {
-			curObj := cur.(pkg_runtime.Object)
+			curObj := cur.(pkgruntime.Object)
 			triggerFunc(curObj)
 		},
 		UpdateFunc: func(old, cur interface{}) {
-			curObj := cur.(pkg_runtime.Object)
-			oldMeta := getFieldOrPanic(old, "ObjectMeta").(api_v1.ObjectMeta)
-			curMeta := getFieldOrPanic(cur, "ObjectMeta").(api_v1.ObjectMeta)
+			curObj := cur.(pkgruntime.Object)
+			oldMeta := getFieldOrPanic(old, "ObjectMeta").(apiv1.ObjectMeta)
+			curMeta := getFieldOrPanic(cur, "ObjectMeta").(apiv1.ObjectMeta)
 			if !ObjectMetaEquivalent(oldMeta, curMeta) ||
 				!reflect.DeepEqual(getFieldOrPanic(old, "Spec"), getFieldOrPanic(cur, "Spec")) {
 				triggerFunc(curObj)

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

@@ -19,22 +19,22 @@ package util
 import (
 	"testing"
 
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 
 	"github.com/stretchr/testify/assert"
 )
 
 func TestHandlers(t *testing.T) {
 	// There is a single service ns1/s1 in cluster mycluster.
-	service := api_v1.Service{
-		ObjectMeta: api_v1.ObjectMeta{
+	service := apiv1.Service{
+		ObjectMeta: apiv1.ObjectMeta{
 			Namespace: "ns1",
 			Name:      "s1",
 		},
 	}
-	service2 := api_v1.Service{
-		ObjectMeta: api_v1.ObjectMeta{
+	service2 := apiv1.Service{
+		ObjectMeta: apiv1.ObjectMeta{
 			Namespace: "ns1",
 			Name:      "s1",
 			Annotations: map[string]string{
@@ -53,7 +53,7 @@ func TestHandlers(t *testing.T) {
 	}
 
 	trigger := NewTriggerOnAllChanges(
-		func(obj pkg_runtime.Object) {
+		func(obj pkgruntime.Object) {
 			triggerChan <- struct{}{}
 		})
 
@@ -67,7 +67,7 @@ func TestHandlers(t *testing.T) {
 	assert.True(t, triggered())
 
 	trigger2 := NewTriggerOnMetaAndSpecChanges(
-		func(obj pkg_runtime.Object) {
+		func(obj pkgruntime.Object) {
 			triggerChan <- struct{}{}
 		},
 	)
@@ -81,14 +81,14 @@ func TestHandlers(t *testing.T) {
 	trigger2.OnUpdate(&service, &service2)
 	assert.True(t, triggered())
 
-	service3 := api_v1.Service{
-		ObjectMeta: api_v1.ObjectMeta{
+	service3 := apiv1.Service{
+		ObjectMeta: apiv1.ObjectMeta{
 			Namespace: "ns1",
 			Name:      "s1",
 		},
-		Status: api_v1.ServiceStatus{
-			LoadBalancer: api_v1.LoadBalancerStatus{
-				Ingress: []api_v1.LoadBalancerIngress{{
+		Status: apiv1.ServiceStatus{
+			LoadBalancer: apiv1.LoadBalancerStatus{
+				Ingress: []apiv1.LoadBalancerIngress{{
 					Hostname: "A",
 				}},
 			},

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

@@ -20,19 +20,19 @@ import (
 	"hash/fnv"
 	"sort"
 
-	fed_api "k8s.io/kubernetes/federation/apis/federation"
+	fedapi "k8s.io/kubernetes/federation/apis/federation"
 )
 
 // Planner decides how many out of the given replicas should be placed in each of the
 // federated clusters.
 type Planner struct {
-	preferences *fed_api.FederatedReplicaSetPreferences
+	preferences *fedapi.FederatedReplicaSetPreferences
 }
 
 type namedClusterReplicaSetPreferences struct {
 	clusterName string
 	hash        uint32
-	fed_api.ClusterReplicaSetPreferences
+	fedapi.ClusterReplicaSetPreferences
 }
 
 type byWeight []*namedClusterReplicaSetPreferences
@@ -46,7 +46,7 @@ func (a byWeight) Less(i, j int) bool {
 	return (a[i].Weight > a[j].Weight) || (a[i].Weight == a[j].Weight && a[i].hash < a[j].hash)
 }
 
-func NewPlanner(preferences *fed_api.FederatedReplicaSetPreferences) *Planner {
+func NewPlanner(preferences *fedapi.FederatedReplicaSetPreferences) *Planner {
 	return &Planner{
 		preferences: preferences,
 	}
@@ -71,7 +71,7 @@ func (p *Planner) Plan(replicasToDistribute int64, availableClusters []string, c
 	plan := make(map[string]int64, len(preferences))
 	overflow := make(map[string]int64, len(preferences))
 
-	named := func(name string, pref fed_api.ClusterReplicaSetPreferences) *namedClusterReplicaSetPreferences {
+	named := func(name string, pref fedapi.ClusterReplicaSetPreferences) *namedClusterReplicaSetPreferences {
 		// Seems to work better than addler for our case.
 		hasher := fnv.New32()
 		hasher.Write([]byte(name))

federation/pkg/federation-controller/util/test/test_helper.go

@@ -24,10 +24,10 @@ import (
 	"sync"
 	"time"
 
-	federation_api "k8s.io/kubernetes/federation/apis/federation/v1beta1"
+	federationapi "k8s.io/kubernetes/federation/apis/federation/v1beta1"
 	"k8s.io/kubernetes/federation/pkg/federation-controller/util"
 	"k8s.io/kubernetes/pkg/api"
-	api_v1 "k8s.io/kubernetes/pkg/api/v1"
+	apiv1 "k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/testing/core"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -250,7 +250,7 @@ func CheckObjectFromChan(c chan runtime.Object, checkFunction CheckingFunction)
 }
 
 // CompareObjectMeta returns an error when the given objects are not equivalent.
-func CompareObjectMeta(a, b api_v1.ObjectMeta) error {
+func CompareObjectMeta(a, b apiv1.ObjectMeta) error {
 	if a.Namespace != b.Namespace {
 		return fmt.Errorf("Different namespace expected:%s observed:%s", a.Namespace, b.Namespace)
 	}
@@ -272,15 +272,15 @@ func ToFederatedInformerForTestOnly(informer util.FederatedInformer) util.Federa
 }
 
 // NewCluster builds a new cluster object.
-func NewCluster(name string, readyStatus api_v1.ConditionStatus) *federation_api.Cluster {
-	return &federation_api.Cluster{
-		ObjectMeta: api_v1.ObjectMeta{
+func NewCluster(name string, readyStatus apiv1.ConditionStatus) *federationapi.Cluster {
+	return &federationapi.Cluster{
+		ObjectMeta: apiv1.ObjectMeta{
 			Name:        name,
 			Annotations: map[string]string{},
 		},
-		Status: federation_api.ClusterStatus{
-			Conditions: []federation_api.ClusterCondition{
-				{Type: federation_api.ClusterReady, Status: readyStatus},
+		Status: federationapi.ClusterStatus{
+			Conditions: []federationapi.ClusterCondition{
+				{Type: federationapi.ClusterReady, Status: readyStatus},
 			},
 		},
 	}

hack/verify-pkg-names.sh

+#!/bin/bash
+
+# Copyright 2016 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Verify whether codes follow golang convention.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+KUBE_ROOT=$(dirname "${BASH_SOURCE}")/..
+source "${KUBE_ROOT}/hack/lib/init.sh"
+
+kube::golang::verify_go_version
+
+cd "${KUBE_ROOT}"
+if git --no-pager grep -E $'^(import |\t)[a-z]+[A-Z_][a-zA-Z]* "[^"]+"$' -- '**/*.go' ':(exclude)vendor/*' ':(exclude)staging/*'; then
+  echo "!!! Some package aliase break go conventions."
+  echo "To fix these errors, do not use capitalizaed or underlined characters"
+  echo "in pkg aliases. Refer to https://blog.golang.org/package-names for more info."
+  exit 1
+fi

hooks/pre-commit

@@ -62,6 +62,18 @@ else
 fi
 echo "${reset}"
 
+echo -ne "Checking for package aliases... "
+if ! hack/verify-pkg-names.sh > /dev/null; then
+  echo "${red}ERROR!"
+  echo "Some package aliase break go conventions. To fix these errors, "
+  echo "do not use capitalizaed or underlined characters in pkg aliases. "
+  echo "Refer to https://blog.golang.org/package-names for more info."
+  exit_code=1
+else
+  echo "${green}OK"
+fi
+echo "${reset}"
+
 echo -ne "Checking for files that need boilerplate... "
 files=($(git diff --cached --name-only --diff-filter ACM))
 # We always make sure there is one file in the files list. Some tools check

pkg/cloudprovider/providers/aws/aws.go

@@ -45,7 +45,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/api/v1/service"
 	"k8s.io/kubernetes/pkg/cloudprovider"
-	aws_credentials "k8s.io/kubernetes/pkg/credentialprovider/aws"
+	awscredentials "k8s.io/kubernetes/pkg/credentialprovider/aws"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/volume"
@@ -172,7 +172,7 @@ const DefaultVolumeType = "gp2"
 // See http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/volume_limits.html#linux-specific-volume-limits
 const DefaultMaxEBSVolumes = 39
 
-// Used to call aws_credentials.Init() just once
+// Used to call awscredentials.Init() just once
 var once sync.Once
 
 // Services is an abstraction over AWS, to allow mocking/other implementations
@@ -720,7 +720,7 @@ func getAvailabilityZone(metadata EC2Metadata) (string, error) {
 }
 
 func isRegionValid(region string) bool {
-	for _, r := range aws_credentials.AWSRegions {
+	for _, r := range awscredentials.AWSRegions {
 		if r == region {
 			return true
 		}
@@ -836,7 +836,7 @@ func newAWSCloud(config io.Reader, awsServices Services) (*Cloud, error) {
 
 	// Register handler for ECR credentials
 	once.Do(func() {
-		aws_credentials.Init()
+		awscredentials.Init()
 	})
 
 	return awsCloud, nil

pkg/controller/petset/fakes.go

@@ -25,7 +25,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/v1"
-	api_pod "k8s.io/kubernetes/pkg/api/v1/pod"
+	apipod "k8s.io/kubernetes/pkg/api/v1/pod"
 	apps "k8s.io/kubernetes/pkg/apis/apps/v1beta1"
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/types"
@@ -211,8 +211,8 @@ func (f *fakePetClient) Update(expected, wanted *pcb) error {
 	pets := []*pcb{}
 	for i, pet := range f.pets {
 		if wanted.pod.Name == pet.pod.Name {
-			f.pets[i].pod.Annotations[api_pod.PodHostnameAnnotation] = wanted.pod.Annotations[api_pod.PodHostnameAnnotation]
-			f.pets[i].pod.Annotations[api_pod.PodSubdomainAnnotation] = wanted.pod.Annotations[api_pod.PodSubdomainAnnotation]
+			f.pets[i].pod.Annotations[apipod.PodHostnameAnnotation] = wanted.pod.Annotations[apipod.PodHostnameAnnotation]
+			f.pets[i].pod.Annotations[apipod.PodSubdomainAnnotation] = wanted.pod.Annotations[apipod.PodSubdomainAnnotation]
 			f.pets[i].pod.Spec = wanted.pod.Spec
 			found = true
 		}

pkg/controller/petset/identity_mappers_test.go

@@ -24,7 +24,7 @@ import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/api/v1"
-	api_pod "k8s.io/kubernetes/pkg/api/v1/pod"
+	apipod "k8s.io/kubernetes/pkg/api/v1/pod"
 )
 
 func TestPetIDName(t *testing.T) {
@@ -54,11 +54,11 @@ func TestPetIDDNS(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Failed to generate pet %v", err)
 		}
-		if hostname, ok := pod.Annotations[api_pod.PodHostnameAnnotation]; !ok || hostname != petName {
+		if hostname, ok := pod.Annotations[apipod.PodHostnameAnnotation]; !ok || hostname != petName {
 			t.Errorf("Wrong hostname: %v", hostname)
 		}
 		// TODO: Check this against the governing service.
-		if subdomain, ok := pod.Annotations[api_pod.PodSubdomainAnnotation]; !ok || subdomain != petSubdomain {
+		if subdomain, ok := pod.Annotations[apipod.PodSubdomainAnnotation]; !ok || subdomain != petSubdomain {
 			t.Errorf("Wrong subdomain: %v", subdomain)
 		}
 	}

pkg/controller/petset/pet_set_test.go

@@ -25,7 +25,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/v1"
 	apps "k8s.io/kubernetes/pkg/apis/apps/v1beta1"
 	"k8s.io/kubernetes/pkg/client/cache"
-	fake_internal "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
+	fakeinternal "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/fake"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/typed/apps/v1beta1"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/typed/apps/v1beta1/fake"
 	"k8s.io/kubernetes/pkg/controller"
@@ -281,7 +281,7 @@ func TestSyncStatefulSetBlockedPet(t *testing.T) {
 }
 
 type fakeClient struct {
-	fake_internal.Clientset
+	fakeinternal.Clientset
 	statefulsetClient *fakeStatefulSetClient
 }
 

pkg/controller/podautoscaler/horizontal_test.go

@@ -43,7 +43,7 @@ import (
 	"k8s.io/kubernetes/pkg/watch"
 
 	heapster "k8s.io/heapster/metrics/api/v1/types"
-	metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
+	metricsapi "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -298,15 +298,15 @@ func (tc *testCase) prepareTestClient(t *testing.T) *fake.Clientset {
 		var heapsterRawMemResponse []byte
 
 		if tc.useMetricsApi {
-			metrics := metrics_api.PodMetricsList{}
+			metrics := metricsapi.PodMetricsList{}
 			for i, cpu := range tc.reportedLevels {
-				podMetric := metrics_api.PodMetrics{
+				podMetric := metricsapi.PodMetrics{
 					ObjectMeta: v1.ObjectMeta{
 						Name:      fmt.Sprintf("%s-%d", podNamePrefix, i),
 						Namespace: namespace,
 					},
 					Timestamp: unversioned.Time{Time: time.Now()},
-					Containers: []metrics_api.ContainerMetrics{
+					Containers: []metricsapi.ContainerMetrics{
 						{
 							Name: "container",
 							Usage: v1.ResourceList{

pkg/controller/podautoscaler/metrics/metrics_client.go

@@ -29,7 +29,7 @@ import (
 	"k8s.io/kubernetes/pkg/labels"
 
 	heapster "k8s.io/heapster/metrics/api/v1/types"
-	metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
+	metricsapi "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
 )
 
 // PodResourceInfo contains pod resourcemetric values as a map from pod names to
@@ -92,7 +92,7 @@ func (h *HeapsterMetricsClient) GetResourceMetric(resource v1.ResourceName, name
 
 	glog.V(4).Infof("Heapster metrics result: %s", string(resultRaw))
 
-	metrics := metrics_api.PodMetricsList{}
+	metrics := metricsapi.PodMetricsList{}
 	err = json.Unmarshal(resultRaw, &metrics)
 	if err != nil {
 		return nil, time.Time{}, fmt.Errorf("failed to unmarshal heapster response: %v", err)

pkg/controller/podautoscaler/metrics/metrics_client_test.go

@@ -34,7 +34,7 @@ import (
 	"k8s.io/kubernetes/pkg/runtime"
 
 	heapster "k8s.io/heapster/metrics/api/v1/types"
-	metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
+	metricsapi "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -103,18 +103,18 @@ func (tc *testCase) prepareTestClient(t *testing.T) *fake.Clientset {
 
 	if isResource {
 		fakeClient.AddProxyReactor("services", func(action core.Action) (handled bool, ret restclient.ResponseWrapper, err error) {
-			metrics := metrics_api.PodMetricsList{}
+			metrics := metricsapi.PodMetricsList{}
 			for i, containers := range tc.reportedPodMetrics {
-				metric := metrics_api.PodMetrics{
+				metric := metricsapi.PodMetrics{
 					ObjectMeta: v1.ObjectMeta{
 						Name:      fmt.Sprintf("%s-%d", podNamePrefix, i),
 						Namespace: namespace,
 					},
 					Timestamp:  unversioned.Time{Time: fixedTimestamp.Add(time.Duration(tc.targetTimestamp) * time.Minute)},
-					Containers: []metrics_api.ContainerMetrics{},
+					Containers: []metricsapi.ContainerMetrics{},
 				}
 				for j, cpu := range containers {
-					cm := metrics_api.ContainerMetrics{
+					cm := metricsapi.ContainerMetrics{
 						Name: fmt.Sprintf("%s-%d-container-%d", podNamePrefix, i, j),
 						Usage: v1.ResourceList{
 							v1.ResourceCPU: *resource.NewMilliQuantity(

pkg/controller/podautoscaler/replica_calculator_test.go

@@ -36,7 +36,7 @@ import (
 	"k8s.io/kubernetes/pkg/runtime"
 
 	heapster "k8s.io/heapster/metrics/api/v1/types"
-	metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
+	metricsapi "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -131,15 +131,15 @@ func (tc *replicaCalcTestCase) prepareTestClient(t *testing.T) *fake.Clientset {
 		var heapsterRawMemResponse []byte
 
 		if tc.resource != nil {
-			metrics := metrics_api.PodMetricsList{}
+			metrics := metricsapi.PodMetricsList{}
 			for i, resValue := range tc.resource.levels {
-				podMetric := metrics_api.PodMetrics{
+				podMetric := metricsapi.PodMetrics{
 					ObjectMeta: v1.ObjectMeta{
 						Name:      fmt.Sprintf("%s-%d", podNamePrefix, i),
 						Namespace: testNamespace,
 					},
 					Timestamp: unversioned.Time{Time: tc.timestamp},
-					Containers: []metrics_api.ContainerMetrics{
+					Containers: []metricsapi.ContainerMetrics{
 						{
 							Name: "container1",
 							Usage: v1.ResourceList{

pkg/controller/service/servicecontroller.go

@@ -29,12 +29,12 @@ import (
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	unversioned_core "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/typed/core/v1"
+	unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/typed/core/v1"
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/fields"
-	pkg_runtime "k8s.io/kubernetes/pkg/runtime"
+	pkgruntime "k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/metrics"
 	"k8s.io/kubernetes/pkg/util/runtime"
 	"k8s.io/kubernetes/pkg/util/wait"
@@ -99,7 +99,7 @@ type ServiceController struct {
 // (like load balancers) in sync with the registry.
 func New(cloud cloudprovider.Interface, kubeClient clientset.Interface, clusterName string) (*ServiceController, error) {
 	broadcaster := record.NewBroadcaster()
-	broadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{Interface: kubeClient.Core().Events("")})
+	broadcaster.StartRecordingToSink(&unversionedcore.EventSinkImpl{Interface: kubeClient.Core().Events("")})
 	recorder := broadcaster.NewRecorder(v1.EventSource{Component: "service-controller"})
 
 	if kubeClient != nil && kubeClient.Core().RESTClient().GetRateLimiter() != nil {
@@ -121,7 +121,7 @@ func New(cloud cloudprovider.Interface, kubeClient clientset.Interface, clusterN
 	}
 	s.serviceStore.Indexer, s.serviceController = cache.NewIndexerInformer(
 		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (pkg_runtime.Object, error) {
+			ListFunc: func(options v1.ListOptions) (pkgruntime.Object, error) {
 				return s.kubeClient.Core().Services(v1.NamespaceAll).List(options)
 			},
 			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {

pkg/controller/volume/persistentvolume/pv_controller_base.go

@@ -27,7 +27,7 @@ import (
 	storage "k8s.io/kubernetes/pkg/apis/storage/v1beta1"
 	"k8s.io/kubernetes/pkg/client/cache"
 	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
-	unversioned_core "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/typed/core/v1"
+	unversionedcore "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5/typed/core/v1"
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/conversion"
@@ -62,7 +62,7 @@ func NewController(p ControllerParameters) *PersistentVolumeController {
 	eventRecorder := p.EventRecorder
 	if eventRecorder == nil {
 		broadcaster := record.NewBroadcaster()
-		broadcaster.StartRecordingToSink(&unversioned_core.EventSinkImpl{Interface: p.KubeClient.Core().Events("")})
+		broadcaster.StartRecordingToSink(&unversionedcore.EventSinkImpl{Interface: p.KubeClient.Core().Events("")})
 		eventRecorder = broadcaster.NewRecorder(v1.EventSource{Component: "persistentvolume-controller"})
 	}
 

pkg/dns/dns_test.go

@@ -29,7 +29,7 @@ import (
 	etcd "github.com/coreos/etcd/client"
 	"github.com/miekg/dns"
 	skymsg "github.com/skynetservices/skydns/msg"
-	skyServer "github.com/skynetservices/skydns/server"
+	skyserver "github.com/skynetservices/skydns/server"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"k8s.io/kubernetes/pkg/api/unversioned"
@@ -171,9 +171,9 @@ func assertSRVRecordsMatchPort(t *testing.T, records []dns.RR, port ...int) {
 
 func TestSkySimpleSRVLookup(t *testing.T) {
 	kd := newKubeDNS()
-	skydnsConfig := &skyServer.Config{Domain: testDomain, DnsAddr: "0.0.0.0:53"}
-	skyServer.SetDefaults(skydnsConfig)
-	s := skyServer.New(kd, skydnsConfig)
+	skydnsConfig := &skyserver.Config{Domain: testDomain, DnsAddr: "0.0.0.0:53"}
+	skyserver.SetDefaults(skydnsConfig)
+	s := skyserver.New(kd, skydnsConfig)
 
 	service := newHeadlessService()
 	endpointIPs := []string{"10.0.0.1", "10.0.0.2"}
@@ -201,9 +201,9 @@ func TestSkySimpleSRVLookup(t *testing.T) {
 
 func TestSkyPodHostnameSRVLookup(t *testing.T) {
 	kd := newKubeDNS()
-	skydnsConfig := &skyServer.Config{Domain: testDomain, DnsAddr: "0.0.0.0:53"}
-	skyServer.SetDefaults(skydnsConfig)
-	s := skyServer.New(kd, skydnsConfig)
+	skydnsConfig := &skyserver.Config{Domain: testDomain, DnsAddr: "0.0.0.0:53"}
+	skyserver.SetDefaults(skydnsConfig)
+	s := skyserver.New(kd, skydnsConfig)
 
 	service := newHeadlessService()
 	endpointIPs := []string{"10.0.0.1", "10.0.0.2"}
@@ -240,9 +240,9 @@ func TestSkyPodHostnameSRVLookup(t *testing.T) {
 
 func TestSkyNamedPortSRVLookup(t *testing.T) {
 	kd := newKubeDNS()
-	skydnsConfig := &skyServer.Config{Domain: testDomain, DnsAddr: "0.0.0.0:53"}
-	skyServer.SetDefaults(skydnsConfig)
-	s := skyServer.New(kd, skydnsConfig)
+	skydnsConfig := &skyserver.Config{Domain: testDomain, DnsAddr: "0.0.0.0:53"}
+	skyserver.SetDefaults(skydnsConfig)
+	s := skyserver.New(kd, skydnsConfig)
 
 	service := newHeadlessService()
 	eip := "10.0.0.1"

pkg/kubectl/cmd/top_pod_test.go

@@ -25,7 +25,7 @@ import (
 
 	"net/url"
 
-	metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
+	metricsapi "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
 	"k8s.io/kubernetes/pkg/client/restclient/fake"
 	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
 )
@@ -85,14 +85,14 @@ func TestTopPodAllInNamespaceMetrics(t *testing.T) {
 	metrics := testPodMetricsData()
 	testNamespace := "testnamespace"
 	nonTestNamespace := "anothernamespace"
-	expectedMetrics := metrics_api.PodMetricsList{
+	expectedMetrics := metricsapi.PodMetricsList{
 		ListMeta: metrics.ListMeta,
 		Items:    metrics.Items[0:2],
 	}
 	for _, m := range expectedMetrics.Items {
 		m.Namespace = testNamespace
 	}
-	nonExpectedMetrics := metrics_api.PodMetricsList{
+	nonExpectedMetrics := metricsapi.PodMetricsList{
 		ListMeta: metrics.ListMeta,
 		Items:    metrics.Items[2:],
 	}
@@ -144,7 +144,7 @@ func TestTopPodWithNameMetrics(t *testing.T) {
 	initTestErrorHandler(t)
 	metrics := testPodMetricsData()
 	expectedMetrics := metrics.Items[0]
-	nonExpectedMetrics := metrics_api.PodMetricsList{
+	nonExpectedMetrics := metricsapi.PodMetricsList{
 		ListMeta: metrics.ListMeta,
 		Items:    metrics.Items[1:],
 	}
@@ -192,11 +192,11 @@ func TestTopPodWithNameMetrics(t *testing.T) {
 func TestTopPodWithLabelSelectorMetrics(t *testing.T) {
 	initTestErrorHandler(t)
 	metrics := testPodMetricsData()
-	expectedMetrics := metrics_api.PodMetricsList{
+	expectedMetrics := metricsapi.PodMetricsList{
 		ListMeta: metrics.ListMeta,
 		Items:    metrics.Items[0:2],
 	}
-	nonExpectedMetrics := metrics_api.PodMetricsList{
+	nonExpectedMetrics := metricsapi.PodMetricsList{
 		ListMeta: metrics.ListMeta,
 		Items:    metrics.Items[2:],
 	}
@@ -249,7 +249,7 @@ func TestTopPodWithContainersMetrics(t *testing.T) {
 	initTestErrorHandler(t)
 	metrics := testPodMetricsData()
 	expectedMetrics := metrics.Items[0]
-	nonExpectedMetrics := metrics_api.PodMetricsList{
+	nonExpectedMetrics := metricsapi.PodMetricsList{
 		ListMeta: metrics.ListMeta,
 		Items:    metrics.Items[1:],
 	}

pkg/kubectl/cmd/top_test.go

@@ -25,7 +25,7 @@ import (
 
 	"testing"
 
-	metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
+	metricsapi "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
@@ -59,12 +59,12 @@ func marshallBody(metrics interface{}) (io.ReadCloser, error) {
 	return ioutil.NopCloser(bytes.NewReader(result)), nil
 }
 
-func testNodeMetricsData() (*metrics_api.NodeMetricsList, *api.NodeList) {
-	metrics := &metrics_api.NodeMetricsList{
+func testNodeMetricsData() (*metricsapi.NodeMetricsList, *api.NodeList) {
+	metrics := &metricsapi.NodeMetricsList{
 		ListMeta: unversioned.ListMeta{
 			ResourceVersion: "1",
 		},
-		Items: []metrics_api.NodeMetrics{
+		Items: []metricsapi.NodeMetrics{
 			{
 				ObjectMeta: v1.ObjectMeta{Name: "node1", ResourceVersion: "10"},
 				Window:     unversioned.Duration{Duration: time.Minute},
@@ -115,16 +115,16 @@ func testNodeMetricsData() (*metrics_api.NodeMetricsList, *api.NodeList) {
 	return metrics, nodes
 }
 
-func testPodMetricsData() *metrics_api.PodMetricsList {
-	return &metrics_api.PodMetricsList{
+func testPodMetricsData() *metricsapi.PodMetricsList {
+	return &metricsapi.PodMetricsList{
 		ListMeta: unversioned.ListMeta{
 			ResourceVersion: "2",
 		},
-		Items: []metrics_api.PodMetrics{
+		Items: []metricsapi.PodMetrics{
 			{
 				ObjectMeta: v1.ObjectMeta{Name: "pod1", Namespace: "test", ResourceVersion: "10"},
 				Window:     unversioned.Duration{Duration: time.Minute},
-				Containers: []metrics_api.ContainerMetrics{
+				Containers: []metricsapi.ContainerMetrics{
 					{
 						Name: "container1-1",
 						Usage: v1.ResourceList{
@@ -146,7 +146,7 @@ func testPodMetricsData() *metrics_api.PodMetricsList {
 			{
 				ObjectMeta: v1.ObjectMeta{Name: "pod2", Namespace: "test", ResourceVersion: "11"},
 				Window:     unversioned.Duration{Duration: time.Minute},
-				Containers: []metrics_api.ContainerMetrics{
+				Containers: []metricsapi.ContainerMetrics{
 					{
 						Name: "container2-1",
 						Usage: v1.ResourceList{
@@ -176,7 +176,7 @@ func testPodMetricsData() *metrics_api.PodMetricsList {
 			{
 				ObjectMeta: v1.ObjectMeta{Name: "pod3", Namespace: "test", ResourceVersion: "12"},
 				Window:     unversioned.Duration{Duration: time.Minute},
-				Containers: []metrics_api.ContainerMetrics{
+				Containers: []metricsapi.ContainerMetrics{
 					{
 						Name: "container3-1",
 						Usage: v1.ResourceList{

pkg/kubectl/cmd/util/clientcache.go

@@ -19,7 +19,7 @@ package util
 import (
 	"sync"
 
-	fed_clientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset"
+	fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	"k8s.io/kubernetes/pkg/client/restclient"
@@ -33,7 +33,7 @@ func NewClientCache(loader clientcmd.ClientConfig) *ClientCache {
 	return &ClientCache{
 		clientsets:    make(map[schema.GroupVersion]*internalclientset.Clientset),
 		configs:       make(map[schema.GroupVersion]*restclient.Config),
-		fedClientSets: make(map[schema.GroupVersion]fed_clientset.Interface),
+		fedClientSets: make(map[schema.GroupVersion]fedclientset.Interface),
 		loader:        loader,
 	}
 }
@@ -43,7 +43,7 @@ func NewClientCache(loader clientcmd.ClientConfig) *ClientCache {
 type ClientCache struct {
 	loader        clientcmd.ClientConfig
 	clientsets    map[schema.GroupVersion]*internalclientset.Clientset
-	fedClientSets map[schema.GroupVersion]fed_clientset.Interface
+	fedClientSets map[schema.GroupVersion]fedclientset.Interface
 	configs       map[schema.GroupVersion]*restclient.Config
 
 	matchVersion bool
@@ -158,7 +158,7 @@ func (c *ClientCache) ClientSetForVersion(requiredVersion *schema.GroupVersion)
 	return clientset, nil
 }
 
-func (c *ClientCache) FederationClientSetForVersion(version *schema.GroupVersion) (fed_clientset.Interface, error) {
+func (c *ClientCache) FederationClientSetForVersion(version *schema.GroupVersion) (fedclientset.Interface, error) {
 	if version != nil {
 		if clientSet, found := c.fedClientSets[*version]; found {
 			return clientSet, nil
@@ -170,7 +170,7 @@ func (c *ClientCache) FederationClientSetForVersion(version *schema.GroupVersion
 	}
 
 	// TODO: support multi versions of client with clientset
-	clientSet, err := fed_clientset.NewForConfig(config)
+	clientSet, err := fedclientset.NewForConfig(config)
 	if err != nil {
 		return nil, err
 	}
@@ -178,7 +178,7 @@ func (c *ClientCache) FederationClientSetForVersion(version *schema.GroupVersion
 
 	if version != nil {
 		configCopy := *config
-		clientSet, err := fed_clientset.NewForConfig(&configCopy)
+		clientSet, err := fedclientset.NewForConfig(&configCopy)
 		if err != nil {
 			return nil, err
 		}

pkg/kubectl/describe.go

@@ -29,7 +29,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/federation/apis/federation"
-	fed_clientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset"
+	fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/errors"
 	"k8s.io/kubernetes/pkg/api/events"
@@ -2320,7 +2320,7 @@ func describeConfigMap(configMap *api.ConfigMap) (string, error) {
 }
 
 type ClusterDescriber struct {
-	fed_clientset.Interface
+	fedclientset.Interface
 }
 
 func (d *ClusterDescriber) Describe(namespace, name string, describerSettings DescriberSettings) (string, error) {

pkg/kubectl/describe_test.go

@@ -26,7 +26,7 @@ import (
 	"time"
 
 	"k8s.io/kubernetes/federation/apis/federation"
-	fed_fake "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/fake"
+	fedfake "k8s.io/kubernetes/federation/client/clientset_generated/federation_internalclientset/fake"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/unversioned"
@@ -665,7 +665,7 @@ func TestDescribeCluster(t *testing.T) {
 			},
 		},
 	}
-	fake := fed_fake.NewSimpleClientset(&cluster)
+	fake := fedfake.NewSimpleClientset(&cluster)
 	d := ClusterDescriber{Interface: fake}
 	out, err := d.Describe("any", "foo", DescriberSettings{ShowEvents: true})
 	if err != nil {

pkg/kubectl/metricsutil/metrics_client.go

@@ -21,7 +21,7 @@ import (
 	"errors"
 	"fmt"
 
-	metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
+	metricsapi "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/validation"
 	coreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"
@@ -97,63 +97,63 @@ func nodeMetricsUrl(name string) (string, error) {
 	return fmt.Sprintf("%s/nodes/%s", metricsRoot, name), nil
 }
 
-func (cli *HeapsterMetricsClient) GetNodeMetrics(nodeName string, selector labels.Selector) ([]metrics_api.NodeMetrics, error) {
+func (cli *HeapsterMetricsClient) GetNodeMetrics(nodeName string, selector labels.Selector) ([]metricsapi.NodeMetrics, error) {
 	params := map[string]string{"labelSelector": selector.String()}
 	path, err := nodeMetricsUrl(nodeName)
 	if err != nil {
-		return []metrics_api.NodeMetrics{}, err
+		return []metricsapi.NodeMetrics{}, err
 	}
 	resultRaw, err := GetHeapsterMetrics(cli, path, params)
 	if err != nil {
-		return []metrics_api.NodeMetrics{}, err
+		return []metricsapi.NodeMetrics{}, err
 	}
-	metrics := make([]metrics_api.NodeMetrics, 0)
+	metrics := make([]metricsapi.NodeMetrics, 0)
 	if len(nodeName) == 0 {
-		metricsList := metrics_api.NodeMetricsList{}
+		metricsList := metricsapi.NodeMetricsList{}
 		err = json.Unmarshal(resultRaw, &metricsList)
 		if err != nil {
-			return []metrics_api.NodeMetrics{}, fmt.Errorf("failed to unmarshall heapster response: %v", err)
+			return []metricsapi.NodeMetrics{}, fmt.Errorf("failed to unmarshall heapster response: %v", err)
 		}
 		metrics = append(metrics, metricsList.Items...)
 	} else {
-		var singleMetric metrics_api.NodeMetrics
+		var singleMetric metricsapi.NodeMetrics
 		err = json.Unmarshal(resultRaw, &singleMetric)
 		if err != nil {
-			return []metrics_api.NodeMetrics{}, fmt.Errorf("failed to unmarshall heapster response: %v", err)
+			return []metricsapi.NodeMetrics{}, fmt.Errorf("failed to unmarshall heapster response: %v", err)
 		}
 		metrics = append(metrics, singleMetric)
 	}
 	return metrics, nil
 }
 
-func (cli *HeapsterMetricsClient) GetPodMetrics(namespace string, podName string, allNamespaces bool, selector labels.Selector) ([]metrics_api.PodMetrics, error) {
+func (cli *HeapsterMetricsClient) GetPodMetrics(namespace string, podName string, allNamespaces bool, selector labels.Selector) ([]metricsapi.PodMetrics, error) {
 	if allNamespaces {
 		namespace = api.NamespaceAll
 	}
 	path, err := podMetricsUrl(namespace, podName)
 	if err != nil {
-		return []metrics_api.PodMetrics{}, err
+		return []metricsapi.PodMetrics{}, err
 	}
 
 	params := map[string]string{"labelSelector": selector.String()}
-	allMetrics := make([]metrics_api.PodMetrics, 0)
+	allMetrics := make([]metricsapi.PodMetrics, 0)
 
 	resultRaw, err := GetHeapsterMetrics(cli, path, params)
 	if err != nil {
-		return []metrics_api.PodMetrics{}, err
+		return []metricsapi.PodMetrics{}, err
 	}
 	if len(podName) == 0 {
-		metrics := metrics_api.PodMetricsList{}
+		metrics := metricsapi.PodMetricsList{}
 		err = json.Unmarshal(resultRaw, &metrics)
 		if err != nil {
-			return []metrics_api.PodMetrics{}, fmt.Errorf("failed to unmarshall heapster response: %v", err)
+			return []metricsapi.PodMetrics{}, fmt.Errorf("failed to unmarshall heapster response: %v", err)
 		}
 		allMetrics = append(allMetrics, metrics.Items...)
 	} else {
-		var singleMetric metrics_api.PodMetrics
+		var singleMetric metricsapi.PodMetrics
 		err = json.Unmarshal(resultRaw, &singleMetric)
 		if err != nil {
-			return []metrics_api.PodMetrics{}, fmt.Errorf("failed to unmarshall heapster response: %v", err)
+			return []metricsapi.PodMetrics{}, fmt.Errorf("failed to unmarshall heapster response: %v", err)
 		}
 		allMetrics = append(allMetrics, singleMetric)
 	}

pkg/kubectl/metricsutil/metrics_printer.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"io"
 
-	metrics_api "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
+	metricsapi "k8s.io/heapster/metrics/apis/metrics/v1alpha1"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/kubectl"
@@ -51,7 +51,7 @@ func NewTopCmdPrinter(out io.Writer) *TopCmdPrinter {
 	return &TopCmdPrinter{out: out}
 }
 
-func (printer *TopCmdPrinter) PrintNodeMetrics(metrics []metrics_api.NodeMetrics, availableResources map[string]api.ResourceList) error {
+func (printer *TopCmdPrinter) PrintNodeMetrics(metrics []metricsapi.NodeMetrics, availableResources map[string]api.ResourceList) error {
 	if len(metrics) == 0 {
 		return nil
 	}
@@ -74,7 +74,7 @@ func (printer *TopCmdPrinter) PrintNodeMetrics(metrics []metrics_api.NodeMetrics
 	return nil
 }
 
-func (printer *TopCmdPrinter) PrintPodMetrics(metrics []metrics_api.PodMetrics, printContainers bool, withNamespace bool) error {
+func (printer *TopCmdPrinter) PrintPodMetrics(metrics []metricsapi.PodMetrics, printContainers bool, withNamespace bool) error {
 	if len(metrics) == 0 {
 		return nil
 	}
@@ -104,7 +104,7 @@ func printColumnNames(out io.Writer, names []string) {
 	fmt.Fprint(out, "\n")
 }
 
-func printSinglePodMetrics(out io.Writer, m *metrics_api.PodMetrics, printContainersOnly bool, withNamespace bool) error {
+func printSinglePodMetrics(out io.Writer, m *metricsapi.PodMetrics, printContainersOnly bool, withNamespace bool) error {
 	containers := make(map[string]api.ResourceList)
 	podMetrics := make(api.ResourceList)
 	for _, res := range MeasuredResources {

pkg/kubelet/api/services.go

@@ -19,20 +19,20 @@ package api
 import (
 	"time"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 )
 
 // RuntimeVersioner contains methods for runtime name, version and API version.
 type RuntimeVersioner interface {
 	// Version returns the runtime name, runtime version and runtime API version
-	Version(apiVersion string) (*runtimeApi.VersionResponse, error)
+	Version(apiVersion string) (*runtimeapi.VersionResponse, error)
 }
 
 // ContainerManager contains methods to manipulate containers managed by a
 // container runtime. The methods are thread-safe.
 type ContainerManager interface {
 	// CreateContainer creates a new container in specified PodSandbox.
-	CreateContainer(podSandboxID string, config *runtimeApi.ContainerConfig, sandboxConfig *runtimeApi.PodSandboxConfig) (string, error)
+	CreateContainer(podSandboxID string, config *runtimeapi.ContainerConfig, sandboxConfig *runtimeapi.PodSandboxConfig) (string, error)
 	// StartContainer starts the container.
 	StartContainer(containerID string) error
 	// StopContainer stops a running container with a grace period (i.e., timeout).
@@ -40,16 +40,16 @@ type ContainerManager interface {
 	// RemoveContainer removes the container.
 	RemoveContainer(containerID string) error
 	// ListContainers lists all containers by filters.
-	ListContainers(filter *runtimeApi.ContainerFilter) ([]*runtimeApi.Container, error)
+	ListContainers(filter *runtimeapi.ContainerFilter) ([]*runtimeapi.Container, error)
 	// ContainerStatus returns the status of the container.
-	ContainerStatus(containerID string) (*runtimeApi.ContainerStatus, error)
+	ContainerStatus(containerID string) (*runtimeapi.ContainerStatus, error)
 	// ExecSync executes a command in the container, and returns the stdout output.
 	// If command exits with a non-zero exit code, an error is returned.
 	ExecSync(containerID string, cmd []string, timeout time.Duration) (stdout []byte, stderr []byte, err error)
 	// Exec prepares a streaming endpoint to execute a command in the container, and returns the address.
-	Exec(*runtimeApi.ExecRequest) (*runtimeApi.ExecResponse, error)
+	Exec(*runtimeapi.ExecRequest) (*runtimeapi.ExecResponse, error)
 	// Attach prepares a streaming endpoint to attach to a running container, and returns the address.
-	Attach(req *runtimeApi.AttachRequest) (*runtimeApi.AttachResponse, error)
+	Attach(req *runtimeapi.AttachRequest) (*runtimeapi.AttachResponse, error)
 }
 
 // PodSandboxManager contains methods for operating on PodSandboxes. The methods
@@ -57,7 +57,7 @@ type ContainerManager interface {
 type PodSandboxManager interface {
 	// RunPodSandbox creates and starts a pod-level sandbox. Runtimes should ensure
 	// the sandbox is in ready state.
-	RunPodSandbox(config *runtimeApi.PodSandboxConfig) (string, error)
+	RunPodSandbox(config *runtimeapi.PodSandboxConfig) (string, error)
 	// StopPodSandbox stops the sandbox. If there are any running containers in the
 	// sandbox, they should be force terminated.
 	StopPodSandbox(podSandboxID string) error
@@ -65,11 +65,11 @@ type PodSandboxManager interface {
 	// sandbox, they should be forcibly removed.
 	RemovePodSandbox(podSandboxID string) error
 	// PodSandboxStatus returns the Status of the PodSandbox.
-	PodSandboxStatus(podSandboxID string) (*runtimeApi.PodSandboxStatus, error)
+	PodSandboxStatus(podSandboxID string) (*runtimeapi.PodSandboxStatus, error)
 	// ListPodSandbox returns a list of Sandbox.
-	ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]*runtimeApi.PodSandbox, error)
+	ListPodSandbox(filter *runtimeapi.PodSandboxFilter) ([]*runtimeapi.PodSandbox, error)
 	// PortForward prepares a streaming endpoint to forward ports from a PodSandbox, and returns the address.
-	PortForward(*runtimeApi.PortForwardRequest) (*runtimeApi.PortForwardResponse, error)
+	PortForward(*runtimeapi.PortForwardRequest) (*runtimeapi.PortForwardResponse, error)
 }
 
 // RuntimeService interface should be implemented by a container runtime.
@@ -80,9 +80,9 @@ type RuntimeService interface {
 	PodSandboxManager
 
 	// UpdateRuntimeConfig updates runtime configuration if specified
-	UpdateRuntimeConfig(runtimeConfig *runtimeApi.RuntimeConfig) error
+	UpdateRuntimeConfig(runtimeConfig *runtimeapi.RuntimeConfig) error
 	// Status returns the status of the runtime.
-	Status() (*runtimeApi.RuntimeStatus, error)
+	Status() (*runtimeapi.RuntimeStatus, error)
 }
 
 // ImageManagerService interface should be implemented by a container image
@@ -90,11 +90,11 @@ type RuntimeService interface {
 // The methods should be thread-safe.
 type ImageManagerService interface {
 	// ListImages lists the existing images.
-	ListImages(filter *runtimeApi.ImageFilter) ([]*runtimeApi.Image, error)
+	ListImages(filter *runtimeapi.ImageFilter) ([]*runtimeapi.Image, error)
 	// ImageStatus returns the status of the image.
-	ImageStatus(image *runtimeApi.ImageSpec) (*runtimeApi.Image, error)
+	ImageStatus(image *runtimeapi.ImageSpec) (*runtimeapi.Image, error)
 	// PullImage pulls an image with the authentication config.
-	PullImage(image *runtimeApi.ImageSpec, auth *runtimeApi.AuthConfig) error
+	PullImage(image *runtimeapi.ImageSpec, auth *runtimeapi.AuthConfig) error
 	// RemoveImage removes the image.
-	RemoveImage(image *runtimeApi.ImageSpec) error
+	RemoveImage(image *runtimeapi.ImageSpec) error
 }

pkg/kubelet/api/testing/fake_image_service.go

@@ -19,7 +19,7 @@ package testing
 import (
 	"sync"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/util/sliceutils"
 )
 
@@ -28,14 +28,14 @@ type FakeImageService struct {
 
 	FakeImageSize uint64
 	Called        []string
-	Images        map[string]*runtimeApi.Image
+	Images        map[string]*runtimeapi.Image
 }
 
 func (r *FakeImageService) SetFakeImages(images []string) {
 	r.Lock()
 	defer r.Unlock()
 
-	r.Images = make(map[string]*runtimeApi.Image)
+	r.Images = make(map[string]*runtimeapi.Image)
 	for _, image := range images {
 		r.Images[image] = r.makeFakeImage(image)
 	}
@@ -51,25 +51,25 @@ func (r *FakeImageService) SetFakeImageSize(size uint64) {
 func NewFakeImageService() *FakeImageService {
 	return &FakeImageService{
 		Called: make([]string, 0),
-		Images: make(map[string]*runtimeApi.Image),
+		Images: make(map[string]*runtimeapi.Image),
 	}
 }
 
-func (r *FakeImageService) makeFakeImage(image string) *runtimeApi.Image {
-	return &runtimeApi.Image{
+func (r *FakeImageService) makeFakeImage(image string) *runtimeapi.Image {
+	return &runtimeapi.Image{
 		Id:       &image,
 		Size_:    &r.FakeImageSize,
 		RepoTags: []string{image},
 	}
 }
 
-func (r *FakeImageService) ListImages(filter *runtimeApi.ImageFilter) ([]*runtimeApi.Image, error) {
+func (r *FakeImageService) ListImages(filter *runtimeapi.ImageFilter) ([]*runtimeapi.Image, error) {
 	r.Lock()
 	defer r.Unlock()
 
 	r.Called = append(r.Called, "ListImages")
 
-	images := make([]*runtimeApi.Image, 0)
+	images := make([]*runtimeapi.Image, 0)
 	for _, img := range r.Images {
 		if filter != nil && filter.Image != nil {
 			if !sliceutils.StringInSlice(filter.Image.GetImage(), img.RepoTags) {
@@ -82,7 +82,7 @@ func (r *FakeImageService) ListImages(filter *runtimeApi.ImageFilter) ([]*runtim
 	return images, nil
 }
 
-func (r *FakeImageService) ImageStatus(image *runtimeApi.ImageSpec) (*runtimeApi.Image, error) {
+func (r *FakeImageService) ImageStatus(image *runtimeapi.ImageSpec) (*runtimeapi.Image, error) {
 	r.Lock()
 	defer r.Unlock()
 
@@ -91,7 +91,7 @@ func (r *FakeImageService) ImageStatus(image *runtimeApi.ImageSpec) (*runtimeApi
 	return r.Images[image.GetImage()], nil
 }
 
-func (r *FakeImageService) PullImage(image *runtimeApi.ImageSpec, auth *runtimeApi.AuthConfig) error {
+func (r *FakeImageService) PullImage(image *runtimeapi.ImageSpec, auth *runtimeapi.AuthConfig) error {
 	r.Lock()
 	defer r.Unlock()
 
@@ -107,7 +107,7 @@ func (r *FakeImageService) PullImage(image *runtimeApi.ImageSpec, auth *runtimeA
 	return nil
 }
 
-func (r *FakeImageService) RemoveImage(image *runtimeApi.ImageSpec) error {
+func (r *FakeImageService) RemoveImage(image *runtimeapi.ImageSpec) error {
 	r.Lock()
 	defer r.Unlock()
 

pkg/kubelet/api/testing/fake_runtime_service.go

@@ -22,7 +22,7 @@ import (
 	"sync"
 	"time"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 )
 
 var (
@@ -34,12 +34,12 @@ var (
 
 type FakePodSandbox struct {
 	// PodSandboxStatus contains the runtime information for a sandbox.
-	runtimeApi.PodSandboxStatus
+	runtimeapi.PodSandboxStatus
 }
 
 type FakeContainer struct {
 	// ContainerStatus contains the runtime information for a container.
-	runtimeApi.ContainerStatus
+	runtimeapi.ContainerStatus
 
 	// the sandbox id of this container
 	SandboxID string
@@ -50,7 +50,7 @@ type FakeRuntimeService struct {
 
 	Called []string
 
-	FakeStatus *runtimeApi.RuntimeStatus
+	FakeStatus *runtimeapi.RuntimeStatus
 	Containers map[string]*FakeContainer
 	Sandboxes  map[string]*FakePodSandbox
 }
@@ -96,13 +96,13 @@ func NewFakeRuntimeService() *FakeRuntimeService {
 	}
 }
 
-func (r *FakeRuntimeService) Version(apiVersion string) (*runtimeApi.VersionResponse, error) {
+func (r *FakeRuntimeService) Version(apiVersion string) (*runtimeapi.VersionResponse, error) {
 	r.Lock()
 	defer r.Unlock()
 
 	r.Called = append(r.Called, "Version")
 
-	return &runtimeApi.VersionResponse{
+	return &runtimeapi.VersionResponse{
 		Version:           &version,
 		RuntimeName:       &FakeRuntimeName,
 		RuntimeVersion:    &version,
@@ -110,7 +110,7 @@ func (r *FakeRuntimeService) Version(apiVersion string) (*runtimeApi.VersionResp
 	}, nil
 }
 
-func (r *FakeRuntimeService) Status() (*runtimeApi.RuntimeStatus, error) {
+func (r *FakeRuntimeService) Status() (*runtimeapi.RuntimeStatus, error) {
 	r.Lock()
 	defer r.Unlock()
 
@@ -119,7 +119,7 @@ func (r *FakeRuntimeService) Status() (*runtimeApi.RuntimeStatus, error) {
 	return r.FakeStatus, nil
 }
 
-func (r *FakeRuntimeService) RunPodSandbox(config *runtimeApi.PodSandboxConfig) (string, error) {
+func (r *FakeRuntimeService) RunPodSandbox(config *runtimeapi.PodSandboxConfig) (string, error) {
 	r.Lock()
 	defer r.Unlock()
 
@@ -129,14 +129,14 @@ func (r *FakeRuntimeService) RunPodSandbox(config *runtimeApi.PodSandboxConfig)
 	// fixed name from BuildSandboxName() for easily making fake sandboxes.
 	podSandboxID := BuildSandboxName(config.Metadata)
 	createdAt := time.Now().Unix()
-	readyState := runtimeApi.PodSandboxState_SANDBOX_READY
+	readyState := runtimeapi.PodSandboxState_SANDBOX_READY
 	r.Sandboxes[podSandboxID] = &FakePodSandbox{
-		PodSandboxStatus: runtimeApi.PodSandboxStatus{
+		PodSandboxStatus: runtimeapi.PodSandboxStatus{
 			Id:        &podSandboxID,
 			Metadata:  config.Metadata,
 			State:     &readyState,
 			CreatedAt: &createdAt,
-			Network: &runtimeApi.PodSandboxNetworkStatus{
+			Network: &runtimeapi.PodSandboxNetworkStatus{
 				Ip: &FakePodSandboxIP,
 			},
 			Labels:      config.Labels,
@@ -153,7 +153,7 @@ func (r *FakeRuntimeService) StopPodSandbox(podSandboxID string) error {
 
 	r.Called = append(r.Called, "StopPodSandbox")
 
-	notReadyState := runtimeApi.PodSandboxState_SANDBOX_NOTREADY
+	notReadyState := runtimeapi.PodSandboxState_SANDBOX_NOTREADY
 	if s, ok := r.Sandboxes[podSandboxID]; ok {
 		s.State = &notReadyState
 	} else {
@@ -175,7 +175,7 @@ func (r *FakeRuntimeService) RemovePodSandbox(podSandboxID string) error {
 	return nil
 }
 
-func (r *FakeRuntimeService) PodSandboxStatus(podSandboxID string) (*runtimeApi.PodSandboxStatus, error) {
+func (r *FakeRuntimeService) PodSandboxStatus(podSandboxID string) (*runtimeapi.PodSandboxStatus, error) {
 	r.Lock()
 	defer r.Unlock()
 
@@ -190,13 +190,13 @@ func (r *FakeRuntimeService) PodSandboxStatus(podSandboxID string) (*runtimeApi.
 	return &status, nil
 }
 
-func (r *FakeRuntimeService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]*runtimeApi.PodSandbox, error) {
+func (r *FakeRuntimeService) ListPodSandbox(filter *runtimeapi.PodSandboxFilter) ([]*runtimeapi.PodSandbox, error) {
 	r.Lock()
 	defer r.Unlock()
 
 	r.Called = append(r.Called, "ListPodSandbox")
 
-	result := make([]*runtimeApi.PodSandbox, 0)
+	result := make([]*runtimeapi.PodSandbox, 0)
 	for id, s := range r.Sandboxes {
 		if filter != nil {
 			if filter.Id != nil && filter.GetId() != id {
@@ -210,7 +210,7 @@ func (r *FakeRuntimeService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter)
 			}
 		}
 
-		result = append(result, &runtimeApi.PodSandbox{
+		result = append(result, &runtimeapi.PodSandbox{
 			Id:          s.Id,
 			Metadata:    s.Metadata,
 			State:       s.State,
@@ -223,15 +223,15 @@ func (r *FakeRuntimeService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter)
 	return result, nil
 }
 
-func (r *FakeRuntimeService) PortForward(*runtimeApi.PortForwardRequest) (*runtimeApi.PortForwardResponse, error) {
+func (r *FakeRuntimeService) PortForward(*runtimeapi.PortForwardRequest) (*runtimeapi.PortForwardResponse, error) {
 	r.Lock()
 	defer r.Unlock()
 
 	r.Called = append(r.Called, "PortForward")
-	return &runtimeApi.PortForwardResponse{}, nil
+	return &runtimeapi.PortForwardResponse{}, nil
 }
 
-func (r *FakeRuntimeService) CreateContainer(podSandboxID string, config *runtimeApi.ContainerConfig, sandboxConfig *runtimeApi.PodSandboxConfig) (string, error) {
+func (r *FakeRuntimeService) CreateContainer(podSandboxID string, config *runtimeapi.ContainerConfig, sandboxConfig *runtimeapi.PodSandboxConfig) (string, error) {
 	r.Lock()
 	defer r.Unlock()
 
@@ -241,10 +241,10 @@ func (r *FakeRuntimeService) CreateContainer(podSandboxID string, config *runtim
 	// fixed BuildContainerName() for easily making fake containers.
 	containerID := BuildContainerName(config.Metadata, podSandboxID)
 	createdAt := time.Now().Unix()
-	createdState := runtimeApi.ContainerState_CONTAINER_CREATED
+	createdState := runtimeapi.ContainerState_CONTAINER_CREATED
 	imageRef := config.Image.GetImage()
 	r.Containers[containerID] = &FakeContainer{
-		ContainerStatus: runtimeApi.ContainerStatus{
+		ContainerStatus: runtimeapi.ContainerStatus{
 			Id:          &containerID,
 			Metadata:    config.Metadata,
 			Image:       config.Image,
@@ -273,7 +273,7 @@ func (r *FakeRuntimeService) StartContainer(containerID string) error {
 
 	// Set container to running.
 	startedAt := time.Now().Unix()
-	runningState := runtimeApi.ContainerState_CONTAINER_RUNNING
+	runningState := runtimeapi.ContainerState_CONTAINER_RUNNING
 	c.State = &runningState
 	c.StartedAt = &startedAt
 
@@ -293,7 +293,7 @@ func (r *FakeRuntimeService) StopContainer(containerID string, timeout int64) er
 
 	// Set container to exited state.
 	finishedAt := time.Now().Unix()
-	exitedState := runtimeApi.ContainerState_CONTAINER_EXITED
+	exitedState := runtimeapi.ContainerState_CONTAINER_EXITED
 	c.State = &exitedState
 	c.FinishedAt = &finishedAt
 
@@ -312,13 +312,13 @@ func (r *FakeRuntimeService) RemoveContainer(containerID string) error {
 	return nil
 }
 
-func (r *FakeRuntimeService) ListContainers(filter *runtimeApi.ContainerFilter) ([]*runtimeApi.Container, error) {
+func (r *FakeRuntimeService) ListContainers(filter *runtimeapi.ContainerFilter) ([]*runtimeapi.Container, error) {
 	r.Lock()
 	defer r.Unlock()
 
 	r.Called = append(r.Called, "ListContainers")
 
-	result := make([]*runtimeApi.Container, 0)
+	result := make([]*runtimeapi.Container, 0)
 	for _, s := range r.Containers {
 		if filter != nil {
 			if filter.Id != nil && filter.GetId() != s.GetId() {
@@ -335,7 +335,7 @@ func (r *FakeRuntimeService) ListContainers(filter *runtimeApi.ContainerFilter)
 			}
 		}
 
-		result = append(result, &runtimeApi.Container{
+		result = append(result, &runtimeapi.Container{
 			Id:           s.Id,
 			CreatedAt:    s.CreatedAt,
 			PodSandboxId: &s.SandboxID,
@@ -351,7 +351,7 @@ func (r *FakeRuntimeService) ListContainers(filter *runtimeApi.ContainerFilter)
 	return result, nil
 }
 
-func (r *FakeRuntimeService) ContainerStatus(containerID string) (*runtimeApi.ContainerStatus, error) {
+func (r *FakeRuntimeService) ContainerStatus(containerID string) (*runtimeapi.ContainerStatus, error) {
 	r.Lock()
 	defer r.Unlock()
 
@@ -374,22 +374,22 @@ func (r *FakeRuntimeService) ExecSync(containerID string, cmd []string, timeout
 	return nil, nil, nil
 }
 
-func (r *FakeRuntimeService) Exec(*runtimeApi.ExecRequest) (*runtimeApi.ExecResponse, error) {
+func (r *FakeRuntimeService) Exec(*runtimeapi.ExecRequest) (*runtimeapi.ExecResponse, error) {
 	r.Lock()
 	defer r.Unlock()
 
 	r.Called = append(r.Called, "Exec")
-	return &runtimeApi.ExecResponse{}, nil
+	return &runtimeapi.ExecResponse{}, nil
 }
 
-func (r *FakeRuntimeService) Attach(req *runtimeApi.AttachRequest) (*runtimeApi.AttachResponse, error) {
+func (r *FakeRuntimeService) Attach(req *runtimeapi.AttachRequest) (*runtimeapi.AttachResponse, error) {
 	r.Lock()
 	defer r.Unlock()
 
 	r.Called = append(r.Called, "Attach")
-	return &runtimeApi.AttachResponse{}, nil
+	return &runtimeapi.AttachResponse{}, nil
 }
 
-func (r *FakeRuntimeService) UpdateRuntimeConfig(runtimeCOnfig *runtimeApi.RuntimeConfig) error {
+func (r *FakeRuntimeService) UpdateRuntimeConfig(runtimeCOnfig *runtimeapi.RuntimeConfig) error {
 	return nil
 }

pkg/kubelet/api/testing/utils.go

@@ -19,15 +19,15 @@ package testing
 import (
 	"fmt"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 )
 
-func BuildContainerName(metadata *runtimeApi.ContainerMetadata, sandboxID string) string {
+func BuildContainerName(metadata *runtimeapi.ContainerMetadata, sandboxID string) string {
 	// include the sandbox ID to make the container ID unique.
 	return fmt.Sprintf("%s_%s_%d", sandboxID, metadata.GetName(), metadata.GetAttempt())
 }
 
-func BuildSandboxName(metadata *runtimeApi.PodSandboxMetadata) string {
+func BuildSandboxName(metadata *runtimeapi.PodSandboxMetadata) string {
 	return fmt.Sprintf("%s_%s_%s_%d", metadata.GetName(), metadata.GetNamespace(), metadata.GetUid(), metadata.GetAttempt())
 }
 

pkg/kubelet/cadvisor/cadvisor_linux.go

@@ -26,7 +26,7 @@ import (
 
 	"github.com/golang/glog"
 	"github.com/google/cadvisor/cache/memory"
-	cadvisorMetrics "github.com/google/cadvisor/container"
+	cadvisormetrics "github.com/google/cadvisor/container"
 	"github.com/google/cadvisor/events"
 	cadvisorfs "github.com/google/cadvisor/fs"
 	cadvisorhttp "github.com/google/cadvisor/http"
@@ -101,7 +101,7 @@ func New(port uint, runtime string, rootPath string) (Interface, error) {
 	}
 
 	// Create and start the cAdvisor container manager.
-	m, err := manager.New(memory.New(statsCacheDuration, nil), sysFs, maxHousekeepingInterval, allowDynamicHousekeeping, cadvisorMetrics.MetricSet{cadvisorMetrics.NetworkTcpUsageMetrics: struct{}{}}, http.DefaultClient)
+	m, err := manager.New(memory.New(statsCacheDuration, nil), sysFs, maxHousekeepingInterval, allowDynamicHousekeeping, cadvisormetrics.MetricSet{cadvisormetrics.NetworkTcpUsageMetrics: struct{}{}}, http.DefaultClient)
 	if err != nil {
 		return nil, err
 	}

pkg/kubelet/cadvisor/util.go

@@ -17,12 +17,12 @@ limitations under the License.
 package cadvisor
 
 import (
-	cadvisorApi "github.com/google/cadvisor/info/v1"
+	cadvisorapi "github.com/google/cadvisor/info/v1"
 	"k8s.io/kubernetes/pkg/api/resource"
 	"k8s.io/kubernetes/pkg/api/v1"
 )
 
-func CapacityFromMachineInfo(info *cadvisorApi.MachineInfo) v1.ResourceList {
+func CapacityFromMachineInfo(info *cadvisorapi.MachineInfo) v1.ResourceList {
 	c := v1.ResourceList{
 		v1.ResourceCPU: *resource.NewMilliQuantity(
 			int64(info.NumCores*1000),

pkg/kubelet/container/helpers.go

@@ -28,7 +28,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/record"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/util/format"
 	"k8s.io/kubernetes/pkg/kubelet/util/ioutils"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -209,11 +209,11 @@ func ConvertPodStatusToRunningPod(runtimeName string, podStatus *PodStatus) Pod
 // This is only needed because we need to return sandboxes as if they were
 // kubecontainer.Containers to avoid substantial changes to PLEG.
 // TODO: Remove this once it becomes obsolete.
-func SandboxToContainerState(state runtimeApi.PodSandboxState) ContainerState {
+func SandboxToContainerState(state runtimeapi.PodSandboxState) ContainerState {
 	switch state {
-	case runtimeApi.PodSandboxState_SANDBOX_READY:
+	case runtimeapi.PodSandboxState_SANDBOX_READY:
 		return ContainerStateRunning
-	case runtimeApi.PodSandboxState_SANDBOX_NOTREADY:
+	case runtimeapi.PodSandboxState_SANDBOX_NOTREADY:
 		return ContainerStateExited
 	}
 	return ContainerStateUnknown

pkg/kubelet/container/runtime.go

@@ -26,7 +26,7 @@ import (
 
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api/v1"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/types"
 	"k8s.io/kubernetes/pkg/util/flowcontrol"
 	"k8s.io/kubernetes/pkg/util/term"
@@ -299,7 +299,7 @@ type PodStatus struct {
 	ContainerStatuses []*ContainerStatus
 	// Status of the pod sandbox.
 	// Only for kuberuntime now, other runtime may keep it nil.
-	SandboxStatuses []*runtimeApi.PodSandboxStatus
+	SandboxStatuses []*runtimeapi.PodSandboxStatus
 }
 
 // ContainerStatus represents the status of a container.

pkg/kubelet/dockershim/convert.go

@@ -23,7 +23,7 @@ import (
 
 	dockertypes "github.com/docker/engine-api/types"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 )
 
 // This file contains helper functions to convert docker API types to runtime
@@ -36,13 +36,13 @@ const (
 	statusExitedPrefix  = "Exited"
 )
 
-func imageToRuntimeAPIImage(image *dockertypes.Image) (*runtimeApi.Image, error) {
+func imageToRuntimeAPIImage(image *dockertypes.Image) (*runtimeapi.Image, error) {
 	if image == nil {
 		return nil, fmt.Errorf("unable to convert a nil pointer to a runtime API image")
 	}
 
 	size := uint64(image.VirtualSize)
-	return &runtimeApi.Image{
+	return &runtimeapi.Image{
 		Id:          &image.ID,
 		RepoTags:    image.RepoTags,
 		RepoDigests: image.RepoDigests,
@@ -50,13 +50,13 @@ func imageToRuntimeAPIImage(image *dockertypes.Image) (*runtimeApi.Image, error)
 	}, nil
 }
 
-func imageInspectToRuntimeAPIImage(image *dockertypes.ImageInspect) (*runtimeApi.Image, error) {
+func imageInspectToRuntimeAPIImage(image *dockertypes.ImageInspect) (*runtimeapi.Image, error) {
 	if image == nil {
 		return nil, fmt.Errorf("unable to convert a nil pointer to a runtime API image")
 	}
 
 	size := uint64(image.VirtualSize)
-	runtimeImage := &runtimeApi.Image{
+	runtimeImage := &runtimeapi.Image{
 		Id:          &image.ID,
 		RepoTags:    image.RepoTags,
 		RepoDigests: image.RepoDigests,
@@ -77,7 +77,7 @@ func toPullableImageID(id string, image *dockertypes.ImageInspect) string {
 	return imageID
 }
 
-func toRuntimeAPIContainer(c *dockertypes.Container) (*runtimeApi.Container, error) {
+func toRuntimeAPIContainer(c *dockertypes.Container) (*runtimeapi.Container, error) {
 	state := toRuntimeAPIContainerState(c.Status)
 	if len(c.Names) == 0 {
 		return nil, fmt.Errorf("unexpected empty container name: %+v", c)
@@ -90,11 +90,11 @@ func toRuntimeAPIContainer(c *dockertypes.Container) (*runtimeApi.Container, err
 	sandboxID := c.Labels[sandboxIDLabelKey]
 	// The timestamp in dockertypes.Container is in seconds.
 	createdAt := c.Created * int64(time.Second)
-	return &runtimeApi.Container{
+	return &runtimeapi.Container{
 		Id:           &c.ID,
 		PodSandboxId: &sandboxID,
 		Metadata:     metadata,
-		Image:        &runtimeApi.ImageSpec{Image: &c.Image},
+		Image:        &runtimeapi.ImageSpec{Image: &c.Image},
 		ImageRef:     &c.ImageID,
 		State:        &state,
 		CreatedAt:    &createdAt,
@@ -103,48 +103,48 @@ func toRuntimeAPIContainer(c *dockertypes.Container) (*runtimeApi.Container, err
 	}, nil
 }
 
-func toDockerContainerStatus(state runtimeApi.ContainerState) string {
+func toDockerContainerStatus(state runtimeapi.ContainerState) string {
 	switch state {
-	case runtimeApi.ContainerState_CONTAINER_CREATED:
+	case runtimeapi.ContainerState_CONTAINER_CREATED:
 		return "created"
-	case runtimeApi.ContainerState_CONTAINER_RUNNING:
+	case runtimeapi.ContainerState_CONTAINER_RUNNING:
 		return "running"
-	case runtimeApi.ContainerState_CONTAINER_EXITED:
+	case runtimeapi.ContainerState_CONTAINER_EXITED:
 		return "exited"
-	case runtimeApi.ContainerState_CONTAINER_UNKNOWN:
+	case runtimeapi.ContainerState_CONTAINER_UNKNOWN:
 		fallthrough
 	default:
 		return "unknown"
 	}
 }
 
-func toRuntimeAPIContainerState(state string) runtimeApi.ContainerState {
+func toRuntimeAPIContainerState(state string) runtimeapi.ContainerState {
 	// Parse the state string in dockertypes.Container. This could break when
 	// we upgrade docker.
 	switch {
 	case strings.HasPrefix(state, statusRunningPrefix):
-		return runtimeApi.ContainerState_CONTAINER_RUNNING
+		return runtimeapi.ContainerState_CONTAINER_RUNNING
 	case strings.HasPrefix(state, statusExitedPrefix):
-		return runtimeApi.ContainerState_CONTAINER_EXITED
+		return runtimeapi.ContainerState_CONTAINER_EXITED
 	case strings.HasPrefix(state, statusCreatedPrefix):
-		return runtimeApi.ContainerState_CONTAINER_CREATED
+		return runtimeapi.ContainerState_CONTAINER_CREATED
 	default:
-		return runtimeApi.ContainerState_CONTAINER_UNKNOWN
+		return runtimeapi.ContainerState_CONTAINER_UNKNOWN
 	}
 }
 
-func toRuntimeAPISandboxState(state string) runtimeApi.PodSandboxState {
+func toRuntimeAPISandboxState(state string) runtimeapi.PodSandboxState {
 	// Parse the state string in dockertypes.Container. This could break when
 	// we upgrade docker.
 	switch {
 	case strings.HasPrefix(state, statusRunningPrefix):
-		return runtimeApi.PodSandboxState_SANDBOX_READY
+		return runtimeapi.PodSandboxState_SANDBOX_READY
 	default:
-		return runtimeApi.PodSandboxState_SANDBOX_NOTREADY
+		return runtimeapi.PodSandboxState_SANDBOX_NOTREADY
 	}
 }
 
-func toRuntimeAPISandbox(c *dockertypes.Container) (*runtimeApi.PodSandbox, error) {
+func toRuntimeAPISandbox(c *dockertypes.Container) (*runtimeapi.PodSandbox, error) {
 	state := toRuntimeAPISandboxState(c.Status)
 	if len(c.Names) == 0 {
 		return nil, fmt.Errorf("unexpected empty sandbox name: %+v", c)
@@ -156,7 +156,7 @@ func toRuntimeAPISandbox(c *dockertypes.Container) (*runtimeApi.PodSandbox, erro
 	labels, annotations := extractLabels(c.Labels)
 	// The timestamp in dockertypes.Container is in seconds.
 	createdAt := c.Created * int64(time.Second)
-	return &runtimeApi.PodSandbox{
+	return &runtimeapi.PodSandbox{
 		Id:          &c.ID,
 		Metadata:    metadata,
 		State:       &state,

pkg/kubelet/dockershim/convert_test.go

@@ -22,18 +22,18 @@ import (
 	dockertypes "github.com/docker/engine-api/types"
 	"github.com/stretchr/testify/assert"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 )
 
 func TestConvertDockerStatusToRuntimeAPIState(t *testing.T) {
 	testCases := []struct {
 		input    string
-		expected runtimeApi.ContainerState
+		expected runtimeapi.ContainerState
 	}{
-		{input: "Up 5 hours", expected: runtimeApi.ContainerState_CONTAINER_RUNNING},
-		{input: "Exited (0) 2 hours ago", expected: runtimeApi.ContainerState_CONTAINER_EXITED},
-		{input: "Created", expected: runtimeApi.ContainerState_CONTAINER_CREATED},
-		{input: "Random string", expected: runtimeApi.ContainerState_CONTAINER_UNKNOWN},
+		{input: "Up 5 hours", expected: runtimeapi.ContainerState_CONTAINER_RUNNING},
+		{input: "Exited (0) 2 hours ago", expected: runtimeapi.ContainerState_CONTAINER_EXITED},
+		{input: "Created", expected: runtimeapi.ContainerState_CONTAINER_CREATED},
+		{input: "Random string", expected: runtimeapi.ContainerState_CONTAINER_UNKNOWN},
 	}
 
 	for _, test := range testCases {

pkg/kubelet/dockershim/docker_container.go

@@ -28,12 +28,12 @@ import (
 	dockerstrslice "github.com/docker/engine-api/types/strslice"
 	"github.com/golang/glog"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
 )
 
 // ListContainers lists all containers matching the filter.
-func (ds *dockerService) ListContainers(filter *runtimeApi.ContainerFilter) ([]*runtimeApi.Container, error) {
+func (ds *dockerService) ListContainers(filter *runtimeapi.ContainerFilter) ([]*runtimeapi.Container, error) {
 	opts := dockertypes.ContainerListOptions{All: true}
 
 	opts.Filter = dockerfilters.NewArgs()
@@ -63,7 +63,7 @@ func (ds *dockerService) ListContainers(filter *runtimeApi.ContainerFilter) ([]*
 		return nil, err
 	}
 	// Convert docker to runtime api containers.
-	result := []*runtimeApi.Container{}
+	result := []*runtimeapi.Container{}
 	for i := range containers {
 		c := containers[i]
 
@@ -82,7 +82,7 @@ func (ds *dockerService) ListContainers(filter *runtimeApi.ContainerFilter) ([]*
 // Docker cannot store the log to an arbitrary location (yet), so we create an
 // symlink at LogPath, linking to the actual path of the log.
 // TODO: check if the default values returned by the runtime API are ok.
-func (ds *dockerService) CreateContainer(podSandboxID string, config *runtimeApi.ContainerConfig, sandboxConfig *runtimeApi.PodSandboxConfig) (string, error) {
+func (ds *dockerService) CreateContainer(podSandboxID string, config *runtimeapi.ContainerConfig, sandboxConfig *runtimeapi.PodSandboxConfig) (string, error) {
 	if config == nil {
 		return "", fmt.Errorf("container config is nil")
 	}
@@ -283,7 +283,7 @@ func getContainerTimestamps(r *dockertypes.ContainerJSON) (time.Time, time.Time,
 }
 
 // ContainerStatus inspects the docker container and returns the status.
-func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.ContainerStatus, error) {
+func (ds *dockerService) ContainerStatus(containerID string) (*runtimeapi.ContainerStatus, error) {
 	r, err := ds.client.InspectContainer(containerID)
 	if err != nil {
 		return nil, err
@@ -303,11 +303,11 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.Contai
 	imageID := toPullableImageID(r.Image, ir)
 
 	// Convert the mounts.
-	mounts := []*runtimeApi.Mount{}
+	mounts := []*runtimeapi.Mount{}
 	for i := range r.Mounts {
 		m := r.Mounts[i]
 		readonly := !m.RW
-		mounts = append(mounts, &runtimeApi.Mount{
+		mounts = append(mounts, &runtimeapi.Mount{
 			HostPath:      &m.Source,
 			ContainerPath: &m.Destination,
 			Readonly:      &readonly,
@@ -315,11 +315,11 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.Contai
 		})
 	}
 	// Interpret container states.
-	var state runtimeApi.ContainerState
+	var state runtimeapi.ContainerState
 	var reason, message string
 	if r.State.Running {
 		// Container is running.
-		state = runtimeApi.ContainerState_CONTAINER_RUNNING
+		state = runtimeapi.ContainerState_CONTAINER_RUNNING
 	} else {
 		// Container is *not* running. We need to get more details.
 		//    * Case 1: container has run and exited with non-zero finishedAt
@@ -328,7 +328,7 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.Contai
 		//              time, but a non-zero exit code.
 		//    * Case 3: container has been created, but not started (yet).
 		if !finishedAt.IsZero() { // Case 1
-			state = runtimeApi.ContainerState_CONTAINER_EXITED
+			state = runtimeapi.ContainerState_CONTAINER_EXITED
 			switch {
 			case r.State.OOMKilled:
 				// TODO: consider exposing OOMKilled via the runtimeAPI.
@@ -341,13 +341,13 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.Contai
 				reason = "Error"
 			}
 		} else if r.State.ExitCode != 0 { // Case 2
-			state = runtimeApi.ContainerState_CONTAINER_EXITED
+			state = runtimeapi.ContainerState_CONTAINER_EXITED
 			// Adjust finshedAt and startedAt time to createdAt time to avoid
 			// the confusion.
 			finishedAt, startedAt = createdAt, createdAt
 			reason = "ContainerCannotRun"
 		} else { // Case 3
-			state = runtimeApi.ContainerState_CONTAINER_CREATED
+			state = runtimeapi.ContainerState_CONTAINER_CREATED
 		}
 		message = r.State.Error
 	}
@@ -362,10 +362,10 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.Contai
 	}
 
 	labels, annotations := extractLabels(r.Config.Labels)
-	return &runtimeApi.ContainerStatus{
+	return &runtimeapi.ContainerStatus{
 		Id:          &r.ID,
 		Metadata:    metadata,
-		Image:       &runtimeApi.ImageSpec{Image: &r.Config.Image},
+		Image:       &runtimeapi.ImageSpec{Image: &r.Config.Image},
 		ImageRef:    &imageID,
 		Mounts:      mounts,
 		ExitCode:    &exitCode,

pkg/kubelet/dockershim/docker_container_test.go

@@ -24,18 +24,18 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	containertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
 )
 
 // A helper to create a basic config.
-func makeContainerConfig(sConfig *runtimeApi.PodSandboxConfig, name, image string, attempt uint32, labels, annotations map[string]string) *runtimeApi.ContainerConfig {
-	return &runtimeApi.ContainerConfig{
-		Metadata: &runtimeApi.ContainerMetadata{
+func makeContainerConfig(sConfig *runtimeapi.PodSandboxConfig, name, image string, attempt uint32, labels, annotations map[string]string) *runtimeapi.ContainerConfig {
+	return &runtimeapi.ContainerConfig{
+		Metadata: &runtimeapi.ContainerMetadata{
 			Name:    &name,
 			Attempt: &attempt,
 		},
-		Image:       &runtimeApi.ImageSpec{Image: &image},
+		Image:       &runtimeapi.ImageSpec{Image: &image},
 		Labels:      labels,
 		Annotations: annotations,
 	}
@@ -48,8 +48,8 @@ func TestListContainers(t *testing.T) {
 	podName, namespace := "foo", "bar"
 	containerName, image := "sidecar", "logger"
 
-	configs := []*runtimeApi.ContainerConfig{}
-	sConfigs := []*runtimeApi.PodSandboxConfig{}
+	configs := []*runtimeapi.ContainerConfig{}
+	sConfigs := []*runtimeapi.PodSandboxConfig{}
 	for i := 0; i < 3; i++ {
 		s := makeSandboxConfig(fmt.Sprintf("%s%d", podName, i),
 			fmt.Sprintf("%s%d", namespace, i), fmt.Sprintf("%d", i), 0)
@@ -61,8 +61,8 @@ func TestListContainers(t *testing.T) {
 		configs = append(configs, c)
 	}
 
-	expected := []*runtimeApi.Container{}
-	state := runtimeApi.ContainerState_CONTAINER_RUNNING
+	expected := []*runtimeapi.Container{}
+	state := runtimeapi.ContainerState_CONTAINER_RUNNING
 	var createdAt int64 = 0
 	for i := range configs {
 		// We don't care about the sandbox id; pass a bogus one.
@@ -75,7 +75,7 @@ func TestListContainers(t *testing.T) {
 		imageRef := "" // FakeDockerClient doesn't populate ImageRef yet.
 		// Prepend to the expected list because ListContainers returns
 		// the most recent containers first.
-		expected = append([]*runtimeApi.Container{{
+		expected = append([]*runtimeapi.Container{{
 			Metadata:     configs[i].Metadata,
 			Id:           &id,
 			PodSandboxId: &sandboxID,
@@ -105,13 +105,13 @@ func TestContainerStatus(t *testing.T) {
 	var defaultTime time.Time
 	dt := defaultTime.UnixNano()
 	ct, st, ft := dt, dt, dt
-	state := runtimeApi.ContainerState_CONTAINER_CREATED
+	state := runtimeapi.ContainerState_CONTAINER_CREATED
 	// The following variables are not set in FakeDockerClient.
 	imageRef := DockerImageIDPrefix + ""
 	exitCode := int32(0)
 	var reason, message string
 
-	expected := &runtimeApi.ContainerStatus{
+	expected := &runtimeapi.ContainerStatus{
 		State:       &state,
 		CreatedAt:   &ct,
 		StartedAt:   &st,
@@ -122,7 +122,7 @@ func TestContainerStatus(t *testing.T) {
 		ExitCode:    &exitCode,
 		Reason:      &reason,
 		Message:     &message,
-		Mounts:      []*runtimeApi.Mount{},
+		Mounts:      []*runtimeapi.Mount{},
 		Labels:      config.Labels,
 		Annotations: config.Annotations,
 	}
@@ -149,7 +149,7 @@ func TestContainerStatus(t *testing.T) {
 	// Advance the clock and start the container.
 	fClock.SetTime(time.Now())
 	*expected.StartedAt = fClock.Now().UnixNano()
-	*expected.State = runtimeApi.ContainerState_CONTAINER_RUNNING
+	*expected.State = runtimeapi.ContainerState_CONTAINER_RUNNING
 
 	err = ds.StartContainer(id)
 	assert.NoError(t, err)
@@ -159,7 +159,7 @@ func TestContainerStatus(t *testing.T) {
 	// Advance the clock and stop the container.
 	fClock.SetTime(time.Now().Add(1 * time.Hour))
 	*expected.FinishedAt = fClock.Now().UnixNano()
-	*expected.State = runtimeApi.ContainerState_CONTAINER_EXITED
+	*expected.State = runtimeapi.ContainerState_CONTAINER_EXITED
 	*expected.Reason = "Completed"
 
 	err = ds.StopContainer(id, 0)

pkg/kubelet/dockershim/docker_image.go

@@ -18,14 +18,14 @@ package dockershim
 
 import (
 	dockertypes "github.com/docker/engine-api/types"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
 )
 
 // This file implements methods in ImageManagerService.
 
 // ListImages lists existing images.
-func (ds *dockerService) ListImages(filter *runtimeApi.ImageFilter) ([]*runtimeApi.Image, error) {
+func (ds *dockerService) ListImages(filter *runtimeapi.ImageFilter) ([]*runtimeapi.Image, error) {
 	opts := dockertypes.ImageListOptions{}
 	if filter != nil {
 		if imgSpec := filter.GetImage(); imgSpec != nil {
@@ -38,7 +38,7 @@ func (ds *dockerService) ListImages(filter *runtimeApi.ImageFilter) ([]*runtimeA
 		return nil, err
 	}
 
-	result := []*runtimeApi.Image{}
+	result := []*runtimeapi.Image{}
 	for _, i := range images {
 		apiImage, err := imageToRuntimeAPIImage(&i)
 		if err != nil {
@@ -51,7 +51,7 @@ func (ds *dockerService) ListImages(filter *runtimeApi.ImageFilter) ([]*runtimeA
 }
 
 // ImageStatus returns the status of the image, returns nil if the image doesn't present.
-func (ds *dockerService) ImageStatus(image *runtimeApi.ImageSpec) (*runtimeApi.Image, error) {
+func (ds *dockerService) ImageStatus(image *runtimeapi.ImageSpec) (*runtimeapi.Image, error) {
 	imageInspect, err := ds.client.InspectImageByRef(image.GetImage())
 	if err != nil {
 		if dockertools.IsImageNotFoundError(err) {
@@ -63,7 +63,7 @@ func (ds *dockerService) ImageStatus(image *runtimeApi.ImageSpec) (*runtimeApi.I
 }
 
 // PullImage pulls an image with authentication config.
-func (ds *dockerService) PullImage(image *runtimeApi.ImageSpec, auth *runtimeApi.AuthConfig) error {
+func (ds *dockerService) PullImage(image *runtimeapi.ImageSpec, auth *runtimeapi.AuthConfig) error {
 	return ds.client.PullImage(image.GetImage(),
 		dockertypes.AuthConfig{
 			Username:      auth.GetUsername(),
@@ -77,7 +77,7 @@ func (ds *dockerService) PullImage(image *runtimeApi.ImageSpec, auth *runtimeApi
 }
 
 // RemoveImage removes the image.
-func (ds *dockerService) RemoveImage(image *runtimeApi.ImageSpec) error {
+func (ds *dockerService) RemoveImage(image *runtimeapi.ImageSpec) error {
 	// If the image has multiple tags, we need to remove all the tags
 	// TODO: We assume image.Image is image ID here, which is true in the current implementation
 	// of kubelet, but we should still clarify this in CRI.

pkg/kubelet/dockershim/docker_image_test.go

@@ -21,7 +21,7 @@ import (
 
 	dockertypes "github.com/docker/engine-api/types"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
 )
 
@@ -29,7 +29,7 @@ func TestRemoveImage(t *testing.T) {
 	ds, fakeDocker, _ := newTestDockerService()
 	id := "1111"
 	fakeDocker.Image = &dockertypes.ImageInspect{ID: id, RepoTags: []string{"foo"}}
-	ds.RemoveImage(&runtimeApi.ImageSpec{Image: &id})
+	ds.RemoveImage(&runtimeapi.ImageSpec{Image: &id})
 	fakeDocker.AssertCallDetails(dockertools.NewCalledDetail("inspect_image", nil),
 		dockertools.NewCalledDetail("remove_image", []interface{}{id, dockertypes.ImageRemoveOptions{PruneChildren: true}}))
 }
@@ -38,7 +38,7 @@ func TestRemoveImageWithMultipleTags(t *testing.T) {
 	ds, fakeDocker, _ := newTestDockerService()
 	id := "1111"
 	fakeDocker.Image = &dockertypes.ImageInspect{ID: id, RepoTags: []string{"foo", "bar"}}
-	ds.RemoveImage(&runtimeApi.ImageSpec{Image: &id})
+	ds.RemoveImage(&runtimeapi.ImageSpec{Image: &id})
 	fakeDocker.AssertCallDetails(dockertools.NewCalledDetail("inspect_image", nil),
 		dockertools.NewCalledDetail("remove_image", []interface{}{"foo", dockertypes.ImageRemoveOptions{PruneChildren: true}}),
 		dockertools.NewCalledDetail("remove_image", []interface{}{"bar", dockertypes.ImageRemoveOptions{PruneChildren: true}}))

pkg/kubelet/dockershim/docker_sandbox.go

@@ -24,7 +24,7 @@ import (
 	dockerfilters "github.com/docker/engine-api/types/filters"
 	"github.com/golang/glog"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/qos"
 	"k8s.io/kubernetes/pkg/kubelet/types"
@@ -48,7 +48,7 @@ const (
 // For docker, PodSandbox is implemented by a container holding the network
 // namespace for the pod.
 // Note: docker doesn't use LogDirectory (yet).
-func (ds *dockerService) RunPodSandbox(config *runtimeApi.PodSandboxConfig) (string, error) {
+func (ds *dockerService) RunPodSandbox(config *runtimeapi.PodSandboxConfig) (string, error) {
 	// Step 1: Pull the image for the sandbox.
 	image := defaultSandboxImage
 	podSandboxImage := ds.podSandboxImage
@@ -179,7 +179,7 @@ func (ds *dockerService) getIP(sandbox *dockertypes.ContainerJSON) (string, erro
 }
 
 // PodSandboxStatus returns the status of the PodSandbox.
-func (ds *dockerService) PodSandboxStatus(podSandboxID string) (*runtimeApi.PodSandboxStatus, error) {
+func (ds *dockerService) PodSandboxStatus(podSandboxID string) (*runtimeapi.PodSandboxStatus, error) {
 	// Inspect the container.
 	r, err := ds.client.InspectContainer(podSandboxID)
 	if err != nil {
@@ -194,15 +194,15 @@ func (ds *dockerService) PodSandboxStatus(podSandboxID string) (*runtimeApi.PodS
 	ct := createdAt.UnixNano()
 
 	// Translate container to sandbox state.
-	state := runtimeApi.PodSandboxState_SANDBOX_NOTREADY
+	state := runtimeapi.PodSandboxState_SANDBOX_NOTREADY
 	if r.State.Running {
-		state = runtimeApi.PodSandboxState_SANDBOX_READY
+		state = runtimeapi.PodSandboxState_SANDBOX_READY
 	}
 	IP, err := ds.getIP(r)
 	if err != nil {
 		return nil, err
 	}
-	network := &runtimeApi.PodSandboxNetworkStatus{Ip: &IP}
+	network := &runtimeapi.PodSandboxNetworkStatus{Ip: &IP}
 	netNS := getNetworkNamespace(r)
 
 	metadata, err := parseSandboxName(r.Name)
@@ -211,7 +211,7 @@ func (ds *dockerService) PodSandboxStatus(podSandboxID string) (*runtimeApi.PodS
 	}
 	hostNetwork := sharesHostNetwork(r)
 	labels, annotations := extractLabels(r.Config.Labels)
-	return &runtimeApi.PodSandboxStatus{
+	return &runtimeapi.PodSandboxStatus{
 		Id:          &r.ID,
 		State:       &state,
 		CreatedAt:   &ct,
@@ -219,10 +219,10 @@ func (ds *dockerService) PodSandboxStatus(podSandboxID string) (*runtimeApi.PodS
 		Labels:      labels,
 		Annotations: annotations,
 		Network:     network,
-		Linux: &runtimeApi.LinuxPodSandboxStatus{
-			Namespaces: &runtimeApi.Namespace{
+		Linux: &runtimeapi.LinuxPodSandboxStatus{
+			Namespaces: &runtimeapi.Namespace{
 				Network: &netNS,
-				Options: &runtimeApi.NamespaceOption{
+				Options: &runtimeapi.NamespaceOption{
 					HostNetwork: &hostNetwork,
 				},
 			},
@@ -231,7 +231,7 @@ func (ds *dockerService) PodSandboxStatus(podSandboxID string) (*runtimeApi.PodS
 }
 
 // ListPodSandbox returns a list of Sandbox.
-func (ds *dockerService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]*runtimeApi.PodSandbox, error) {
+func (ds *dockerService) ListPodSandbox(filter *runtimeapi.PodSandboxFilter) ([]*runtimeapi.PodSandbox, error) {
 	// By default, list all containers whether they are running or not.
 	opts := dockertypes.ContainerListOptions{All: true}
 	filterOutReadySandboxes := false
@@ -246,11 +246,11 @@ func (ds *dockerService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]
 			f.Add("id", filter.GetId())
 		}
 		if filter.State != nil {
-			if filter.GetState() == runtimeApi.PodSandboxState_SANDBOX_READY {
+			if filter.GetState() == runtimeapi.PodSandboxState_SANDBOX_READY {
 				// Only list running containers.
 				opts.All = false
 			} else {
-				// runtimeApi.PodSandboxState_SANDBOX_NOTREADY can mean the
+				// runtimeapi.PodSandboxState_SANDBOX_NOTREADY can mean the
 				// container is in any of the non-running state (e.g., created,
 				// exited). We can't tell docker to filter out running
 				// containers directly, so we'll need to filter them out
@@ -271,7 +271,7 @@ func (ds *dockerService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]
 	}
 
 	// Convert docker containers to runtime api sandboxes.
-	result := []*runtimeApi.PodSandbox{}
+	result := []*runtimeapi.PodSandbox{}
 	for i := range containers {
 		c := containers[i]
 		converted, err := toRuntimeAPISandbox(&c)
@@ -279,7 +279,7 @@ func (ds *dockerService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]
 			glog.V(4).Infof("Unable to convert docker to runtime API sandbox: %v", err)
 			continue
 		}
-		if filterOutReadySandboxes && converted.GetState() == runtimeApi.PodSandboxState_SANDBOX_READY {
+		if filterOutReadySandboxes && converted.GetState() == runtimeapi.PodSandboxState_SANDBOX_READY {
 			continue
 		}
 
@@ -289,7 +289,7 @@ func (ds *dockerService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]
 }
 
 // applySandboxLinuxOptions applies LinuxPodSandboxConfig to dockercontainer.HostConfig and dockercontainer.ContainerCreateConfig.
-func (ds *dockerService) applySandboxLinuxOptions(hc *dockercontainer.HostConfig, lc *runtimeApi.LinuxPodSandboxConfig, createConfig *dockertypes.ContainerCreateConfig, image string) error {
+func (ds *dockerService) applySandboxLinuxOptions(hc *dockercontainer.HostConfig, lc *runtimeapi.LinuxPodSandboxConfig, createConfig *dockertypes.ContainerCreateConfig, image string) error {
 	// Apply Cgroup options.
 	// TODO: Check if this works with per-pod cgroups.
 	hc.CgroupParent = lc.GetCgroupParent()
@@ -299,8 +299,8 @@ func (ds *dockerService) applySandboxLinuxOptions(hc *dockercontainer.HostConfig
 	return nil
 }
 
-// makeSandboxDockerConfig returns dockertypes.ContainerCreateConfig based on runtimeApi.PodSandboxConfig.
-func (ds *dockerService) makeSandboxDockerConfig(c *runtimeApi.PodSandboxConfig, image string) (*dockertypes.ContainerCreateConfig, error) {
+// makeSandboxDockerConfig returns dockertypes.ContainerCreateConfig based on runtimeapi.PodSandboxConfig.
+func (ds *dockerService) makeSandboxDockerConfig(c *runtimeapi.PodSandboxConfig, image string) (*dockertypes.ContainerCreateConfig, error) {
 	// Merge annotations and labels because docker supports only labels.
 	labels := makeLabels(c.GetLabels(), c.GetAnnotations())
 	// Apply a label to distinguish sandboxes from regular containers.

pkg/kubelet/dockershim/docker_sandbox_test.go

@@ -24,19 +24,19 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/types"
 )
 
 // A helper to create a basic config.
-func makeSandboxConfig(name, namespace, uid string, attempt uint32) *runtimeApi.PodSandboxConfig {
+func makeSandboxConfig(name, namespace, uid string, attempt uint32) *runtimeapi.PodSandboxConfig {
 	return makeSandboxConfigWithLabelsAndAnnotations(name, namespace, uid, attempt, map[string]string{}, map[string]string{})
 }
 
-func makeSandboxConfigWithLabelsAndAnnotations(name, namespace, uid string, attempt uint32, labels, annotations map[string]string) *runtimeApi.PodSandboxConfig {
-	return &runtimeApi.PodSandboxConfig{
-		Metadata: &runtimeApi.PodSandboxMetadata{
+func makeSandboxConfigWithLabelsAndAnnotations(name, namespace, uid string, attempt uint32, labels, annotations map[string]string) *runtimeapi.PodSandboxConfig {
+	return &runtimeapi.PodSandboxConfig{
+		Metadata: &runtimeapi.PodSandboxMetadata{
 			Name:      &name,
 			Namespace: &namespace,
 			Uid:       &uid,
@@ -52,7 +52,7 @@ func makeSandboxConfigWithLabelsAndAnnotations(name, namespace, uid string, atte
 func TestListSandboxes(t *testing.T) {
 	ds, _, _ := newTestDockerService()
 	name, namespace := "foo", "bar"
-	configs := []*runtimeApi.PodSandboxConfig{}
+	configs := []*runtimeapi.PodSandboxConfig{}
 	for i := 0; i < 3; i++ {
 		c := makeSandboxConfigWithLabelsAndAnnotations(fmt.Sprintf("%s%d", name, i),
 			fmt.Sprintf("%s%d", namespace, i), fmt.Sprintf("%d", i), 0,
@@ -62,15 +62,15 @@ func TestListSandboxes(t *testing.T) {
 		configs = append(configs, c)
 	}
 
-	expected := []*runtimeApi.PodSandbox{}
-	state := runtimeApi.PodSandboxState_SANDBOX_READY
+	expected := []*runtimeapi.PodSandbox{}
+	state := runtimeapi.PodSandboxState_SANDBOX_READY
 	var createdAt int64 = 0
 	for i := range configs {
 		id, err := ds.RunPodSandbox(configs[i])
 		assert.NoError(t, err)
 		// Prepend to the expected list because ListPodSandbox returns
 		// the most recent sandbox first.
-		expected = append([]*runtimeApi.PodSandbox{{
+		expected = append([]*runtimeapi.PodSandbox{{
 			Metadata:    configs[i].Metadata,
 			Id:          &id,
 			State:       &state,
@@ -98,15 +98,15 @@ func TestSandboxStatus(t *testing.T) {
 	fakeIP := "2.3.4.5"
 	fakeNS := fmt.Sprintf("/proc/%d/ns/net", os.Getpid())
 
-	state := runtimeApi.PodSandboxState_SANDBOX_READY
+	state := runtimeapi.PodSandboxState_SANDBOX_READY
 	ct := int64(0)
 	hostNetwork := false
-	expected := &runtimeApi.PodSandboxStatus{
+	expected := &runtimeapi.PodSandboxStatus{
 		State:       &state,
 		CreatedAt:   &ct,
 		Metadata:    config.Metadata,
-		Network:     &runtimeApi.PodSandboxNetworkStatus{Ip: &fakeIP},
-		Linux:       &runtimeApi.LinuxPodSandboxStatus{Namespaces: &runtimeApi.Namespace{Network: &fakeNS, Options: &runtimeApi.NamespaceOption{HostNetwork: &hostNetwork}}},
+		Network:     &runtimeapi.PodSandboxNetworkStatus{Ip: &fakeIP},
+		Linux:       &runtimeapi.LinuxPodSandboxStatus{Namespaces: &runtimeapi.Namespace{Network: &fakeNS, Options: &runtimeapi.NamespaceOption{HostNetwork: &hostNetwork}}},
 		Labels:      labels,
 		Annotations: annotations,
 	}
@@ -128,7 +128,7 @@ func TestSandboxStatus(t *testing.T) {
 	assert.Equal(t, expected, status)
 
 	// Stop the sandbox.
-	*expected.State = runtimeApi.PodSandboxState_SANDBOX_NOTREADY
+	*expected.State = runtimeapi.PodSandboxState_SANDBOX_NOTREADY
 	err = ds.StopPodSandbox(id)
 	assert.NoError(t, err)
 	status, err = ds.PodSandboxStatus(id)
@@ -186,9 +186,9 @@ func TestHostNetworkPluginInvocation(t *testing.T) {
 		map[string]string{"annotation": ns},
 	)
 	hostNetwork := true
-	c.Linux = &runtimeApi.LinuxPodSandboxConfig{
-		SecurityContext: &runtimeApi.LinuxSandboxSecurityContext{
-			NamespaceOptions: &runtimeApi.NamespaceOption{
+	c.Linux = &runtimeapi.LinuxPodSandboxConfig{
+		SecurityContext: &runtimeapi.LinuxSandboxSecurityContext{
+			NamespaceOptions: &runtimeapi.NamespaceOption{
 				HostNetwork: &hostNetwork,
 			},
 		},

pkg/kubelet/dockershim/docker_service.go

@@ -24,8 +24,8 @@ import (
 	"github.com/golang/protobuf/proto"
 
 	"k8s.io/kubernetes/pkg/apis/componentconfig"
-	internalApi "k8s.io/kubernetes/pkg/kubelet/api"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	internalapi "k8s.io/kubernetes/pkg/kubelet/api"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/dockershim/cm"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
@@ -141,8 +141,8 @@ func NewDockerService(client dockertools.DockerInterface, seccompProfileRoot str
 // DockerService is an interface that embeds the new RuntimeService and
 // ImageService interfaces.
 type DockerService interface {
-	internalApi.RuntimeService
-	internalApi.ImageManagerService
+	internalapi.RuntimeService
+	internalapi.ImageManagerService
 	Start() error
 	// For serving streaming calls.
 	http.Handler
@@ -160,7 +160,7 @@ type dockerService struct {
 }
 
 // Version returns the runtime name, runtime version and runtime API version
-func (ds *dockerService) Version(_ string) (*runtimeApi.VersionResponse, error) {
+func (ds *dockerService) Version(_ string) (*runtimeapi.VersionResponse, error) {
 	v, err := ds.client.Version()
 	if err != nil {
 		return nil, fmt.Errorf("docker: failed to get docker version: %v", err)
@@ -170,7 +170,7 @@ func (ds *dockerService) Version(_ string) (*runtimeApi.VersionResponse, error)
 	// Docker API version (e.g., 1.23) is not semver compatible. Add a ".0"
 	// suffix to remedy this.
 	apiVersion := fmt.Sprintf("%s.0", v.APIVersion)
-	return &runtimeApi.VersionResponse{
+	return &runtimeapi.VersionResponse{
 		Version:           &runtimeAPIVersion,
 		RuntimeName:       &name,
 		RuntimeVersion:    &v.Version,
@@ -179,7 +179,7 @@ func (ds *dockerService) Version(_ string) (*runtimeApi.VersionResponse, error)
 }
 
 // UpdateRuntimeConfig updates the runtime config. Currently only handles podCIDR updates.
-func (ds *dockerService) UpdateRuntimeConfig(runtimeConfig *runtimeApi.RuntimeConfig) (err error) {
+func (ds *dockerService) UpdateRuntimeConfig(runtimeConfig *runtimeapi.RuntimeConfig) (err error) {
 	if runtimeConfig == nil {
 		return
 	}
@@ -224,16 +224,16 @@ func (ds *dockerService) Start() error {
 
 // Status returns the status of the runtime.
 // TODO(random-liu): Set network condition accordingly here.
-func (ds *dockerService) Status() (*runtimeApi.RuntimeStatus, error) {
-	runtimeReady := &runtimeApi.RuntimeCondition{
-		Type:   proto.String(runtimeApi.RuntimeReady),
+func (ds *dockerService) Status() (*runtimeapi.RuntimeStatus, error) {
+	runtimeReady := &runtimeapi.RuntimeCondition{
+		Type:   proto.String(runtimeapi.RuntimeReady),
 		Status: proto.Bool(true),
 	}
-	networkReady := &runtimeApi.RuntimeCondition{
-		Type:   proto.String(runtimeApi.NetworkReady),
+	networkReady := &runtimeapi.RuntimeCondition{
+		Type:   proto.String(runtimeapi.NetworkReady),
 		Status: proto.Bool(true),
 	}
-	conditions := []*runtimeApi.RuntimeCondition{runtimeReady, networkReady}
+	conditions := []*runtimeapi.RuntimeCondition{runtimeReady, networkReady}
 	if _, err := ds.client.Version(); err != nil {
 		runtimeReady.Status = proto.Bool(false)
 		runtimeReady.Reason = proto.String("DockerDaemonNotReady")
@@ -244,7 +244,7 @@ func (ds *dockerService) Status() (*runtimeApi.RuntimeStatus, error) {
 		networkReady.Reason = proto.String("NetworkPluginNotReady")
 		networkReady.Message = proto.String(fmt.Sprintf("docker: network plugin is not ready: %v", err))
 	}
-	return &runtimeApi.RuntimeStatus{Conditions: conditions}, nil
+	return &runtimeapi.RuntimeStatus{Conditions: conditions}, nil
 }
 
 func (ds *dockerService) ServeHTTP(w http.ResponseWriter, r *http.Request) {

pkg/kubelet/dockershim/docker_service_test.go

@@ -24,7 +24,7 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	containertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
 	"k8s.io/kubernetes/pkg/kubelet/network"
@@ -48,7 +48,7 @@ func newTestDockerService() (*dockerService, *dockertools.FakeDockerClient, *clo
 func TestStatus(t *testing.T) {
 	ds, fDocker, _ := newTestDockerService()
 
-	assertStatus := func(expected map[string]bool, status *runtimeApi.RuntimeStatus) {
+	assertStatus := func(expected map[string]bool, status *runtimeapi.RuntimeStatus) {
 		conditions := status.GetConditions()
 		assert.Equal(t, len(expected), len(conditions))
 		for k, v := range expected {
@@ -64,8 +64,8 @@ func TestStatus(t *testing.T) {
 	status, err := ds.Status()
 	assert.NoError(t, err)
 	assertStatus(map[string]bool{
-		runtimeApi.RuntimeReady: true,
-		runtimeApi.NetworkReady: true,
+		runtimeapi.RuntimeReady: true,
+		runtimeapi.NetworkReady: true,
 	}, status)
 
 	// Should not report ready status if version returns error.
@@ -73,8 +73,8 @@ func TestStatus(t *testing.T) {
 	status, err = ds.Status()
 	assert.NoError(t, err)
 	assertStatus(map[string]bool{
-		runtimeApi.RuntimeReady: false,
-		runtimeApi.NetworkReady: true,
+		runtimeapi.RuntimeReady: false,
+		runtimeapi.NetworkReady: true,
 	}, status)
 
 	// Should not report ready status is network plugin returns error.
@@ -85,7 +85,7 @@ func TestStatus(t *testing.T) {
 	status, err = ds.Status()
 	assert.NoError(t, err)
 	assertStatus(map[string]bool{
-		runtimeApi.RuntimeReady: true,
-		runtimeApi.NetworkReady: false,
+		runtimeapi.RuntimeReady: true,
+		runtimeapi.NetworkReady: false,
 	}, status)
 }

pkg/kubelet/dockershim/helpers.go

@@ -29,7 +29,7 @@ import (
 	"github.com/golang/glog"
 
 	"k8s.io/kubernetes/pkg/api/v1"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
 	"k8s.io/kubernetes/pkg/kubelet/types"
 )
@@ -62,7 +62,7 @@ func (v apiVersion) Compare(other string) (int, error) {
 
 // generateEnvList converts KeyValue list to a list of strings, in the form of
 // '<key>=<value>', which can be understood by docker.
-func generateEnvList(envs []*runtimeApi.KeyValue) (result []string) {
+func generateEnvList(envs []*runtimeapi.KeyValue) (result []string) {
 	for _, env := range envs {
 		result = append(result, fmt.Sprintf("%s=%s", env.GetKey(), env.GetValue()))
 	}
@@ -127,7 +127,7 @@ func extractLabels(input map[string]string) (map[string]string, map[string]strin
 // '<HostPath>:<ContainerPath>:ro', if the path is read only, or
 // '<HostPath>:<ContainerPath>:Z', if the volume requires SELinux
 // relabeling and the pod provides an SELinux label
-func generateMountBindings(mounts []*runtimeApi.Mount) (result []string) {
+func generateMountBindings(mounts []*runtimeapi.Mount) (result []string) {
 	for _, m := range mounts {
 		bind := fmt.Sprintf("%s:%s", m.GetHostPath(), m.GetContainerPath())
 		readOnly := m.GetReadonly()
@@ -150,7 +150,7 @@ func generateMountBindings(mounts []*runtimeApi.Mount) (result []string) {
 	return
 }
 
-func makePortsAndBindings(pm []*runtimeApi.PortMapping) (map[dockernat.Port]struct{}, map[dockernat.Port][]dockernat.PortBinding) {
+func makePortsAndBindings(pm []*runtimeapi.PortMapping) (map[dockernat.Port]struct{}, map[dockernat.Port][]dockernat.PortBinding) {
 	exposedPorts := map[dockernat.Port]struct{}{}
 	portBindings := map[dockernat.Port][]dockernat.PortBinding{}
 	for _, port := range pm {
@@ -198,7 +198,7 @@ func makePortsAndBindings(pm []*runtimeApi.PortMapping) (map[dockernat.Port]stru
 // getContainerSecurityOpt gets container security options from container and sandbox config, currently from sandbox
 // annotations.
 // It is an experimental feature and may be promoted to official runtime api in the future.
-func getContainerSecurityOpts(containerName string, sandboxConfig *runtimeApi.PodSandboxConfig, seccompProfileRoot string) ([]string, error) {
+func getContainerSecurityOpts(containerName string, sandboxConfig *runtimeapi.PodSandboxConfig, seccompProfileRoot string) ([]string, error) {
 	appArmorOpts, err := dockertools.GetAppArmorOpts(sandboxConfig.GetAnnotations(), containerName)
 	if err != nil {
 		return nil, err
@@ -216,7 +216,7 @@ func getContainerSecurityOpts(containerName string, sandboxConfig *runtimeApi.Po
 	return opts, nil
 }
 
-func getSandboxSecurityOpts(sandboxConfig *runtimeApi.PodSandboxConfig, seccompProfileRoot string) ([]string, error) {
+func getSandboxSecurityOpts(sandboxConfig *runtimeapi.PodSandboxConfig, seccompProfileRoot string) ([]string, error) {
 	// sandboxContainerName doesn't exist in the pod, so pod security options will be returned by default.
 	return getContainerSecurityOpts(sandboxContainerName, sandboxConfig, seccompProfileRoot)
 }

pkg/kubelet/dockershim/helpers_test.go

@@ -23,7 +23,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"k8s.io/kubernetes/pkg/api/v1"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/security/apparmor"
 )
 
@@ -43,13 +43,13 @@ func TestLabelsAndAnnotationsRoundTrip(t *testing.T) {
 // TODO: Migrate the corresponding test to dockershim.
 func TestGetContainerSecurityOpts(t *testing.T) {
 	containerName := "bar"
-	makeConfig := func(annotations map[string]string) *runtimeApi.PodSandboxConfig {
+	makeConfig := func(annotations map[string]string) *runtimeapi.PodSandboxConfig {
 		return makeSandboxConfigWithLabelsAndAnnotations("pod", "ns", "1234", 1, nil, annotations)
 	}
 
 	tests := []struct {
 		msg          string
-		config       *runtimeApi.PodSandboxConfig
+		config       *runtimeapi.PodSandboxConfig
 		expectedOpts []string
 	}{{
 		msg:          "No security annotations",
@@ -106,13 +106,13 @@ func TestGetContainerSecurityOpts(t *testing.T) {
 
 // TestGetSandboxSecurityOpts tests the logic of generating sandbox security options from sandbox annotations.
 func TestGetSandboxSecurityOpts(t *testing.T) {
-	makeConfig := func(annotations map[string]string) *runtimeApi.PodSandboxConfig {
+	makeConfig := func(annotations map[string]string) *runtimeapi.PodSandboxConfig {
 		return makeSandboxConfigWithLabelsAndAnnotations("pod", "ns", "1234", 1, nil, annotations)
 	}
 
 	tests := []struct {
 		msg          string
-		config       *runtimeApi.PodSandboxConfig
+		config       *runtimeapi.PodSandboxConfig
 		expectedOpts []string
 	}{{
 		msg:          "No security annotations",

pkg/kubelet/dockershim/naming.go

@@ -21,7 +21,7 @@ import (
 	"strconv"
 	"strings"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/dockertools"
 	"k8s.io/kubernetes/pkg/kubelet/leaky"
 )
@@ -55,7 +55,7 @@ const (
 	DockerPullableImageIDPrefix = dockertools.DockerPullablePrefix
 )
 
-func makeSandboxName(s *runtimeApi.PodSandboxConfig) string {
+func makeSandboxName(s *runtimeapi.PodSandboxConfig) string {
 	return strings.Join([]string{
 		kubePrefix,                                 // 0
 		sandboxContainerName,                       // 1
@@ -66,7 +66,7 @@ func makeSandboxName(s *runtimeApi.PodSandboxConfig) string {
 	}, nameDelimiter)
 }
 
-func makeContainerName(s *runtimeApi.PodSandboxConfig, c *runtimeApi.ContainerConfig) string {
+func makeContainerName(s *runtimeapi.PodSandboxConfig, c *runtimeapi.ContainerConfig) string {
 	return strings.Join([]string{
 		kubePrefix,                                 // 0
 		c.Metadata.GetName(),                       // 1:
@@ -87,7 +87,7 @@ func parseUint32(s string) (uint32, error) {
 }
 
 // TODO: Evaluate whether we should rely on labels completely.
-func parseSandboxName(name string) (*runtimeApi.PodSandboxMetadata, error) {
+func parseSandboxName(name string) (*runtimeapi.PodSandboxMetadata, error) {
 	// Docker adds a "/" prefix to names. so trim it.
 	name = strings.TrimPrefix(name, "/")
 
@@ -104,7 +104,7 @@ func parseSandboxName(name string) (*runtimeApi.PodSandboxMetadata, error) {
 		return nil, fmt.Errorf("failed to parse the sandbox name %q: %v", name, err)
 	}
 
-	return &runtimeApi.PodSandboxMetadata{
+	return &runtimeapi.PodSandboxMetadata{
 		Name:      &parts[2],
 		Namespace: &parts[3],
 		Uid:       &parts[4],
@@ -113,7 +113,7 @@ func parseSandboxName(name string) (*runtimeApi.PodSandboxMetadata, error) {
 }
 
 // TODO: Evaluate whether we should rely on labels completely.
-func parseContainerName(name string) (*runtimeApi.ContainerMetadata, error) {
+func parseContainerName(name string) (*runtimeapi.ContainerMetadata, error) {
 	// Docker adds a "/" prefix to names. so trim it.
 	name = strings.TrimPrefix(name, "/")
 
@@ -130,7 +130,7 @@ func parseContainerName(name string) (*runtimeApi.ContainerMetadata, error) {
 		return nil, fmt.Errorf("failed to parse the container name %q: %v", name, err)
 	}
 
-	return &runtimeApi.ContainerMetadata{
+	return &runtimeapi.ContainerMetadata{
 		Name:    &parts[1],
 		Attempt: &attempt,
 	}, nil

pkg/kubelet/dockershim/naming_test.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 )
 
 func TestSandboxNameRoundTrip(t *testing.T) {
@@ -53,8 +53,8 @@ func TestNonParsableSandboxNames(t *testing.T) {
 func TestContainerNameRoundTrip(t *testing.T) {
 	sConfig := makeSandboxConfig("foo", "bar", "iamuid", 3)
 	name, attempt := "pause", uint32(5)
-	config := &runtimeApi.ContainerConfig{
-		Metadata: &runtimeApi.ContainerMetadata{
+	config := &runtimeapi.ContainerConfig{
+		Metadata: &runtimeapi.ContainerMetadata{
 			Name:    &name,
 			Attempt: &attempt,
 		},

pkg/kubelet/dockershim/remote/docker_server.go

@@ -25,7 +25,7 @@ import (
 	"github.com/golang/glog"
 	"google.golang.org/grpc"
 
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/dockershim"
 	"k8s.io/kubernetes/pkg/util/interrupt"
 )
@@ -69,8 +69,8 @@ func (s *DockerServer) Start() error {
 	}
 	// Create the grpc server and register runtime and image services.
 	s.server = grpc.NewServer()
-	runtimeApi.RegisterRuntimeServiceServer(s.server, s.service)
-	runtimeApi.RegisterImageServiceServer(s.server, s.service)
+	runtimeapi.RegisterRuntimeServiceServer(s.server, s.service)
+	runtimeapi.RegisterImageServiceServer(s.server, s.service)
 	go func() {
 		// Use interrupt handler to make sure the server to be stopped properly.
 		h := interrupt.New(nil, s.Stop)

pkg/kubelet/kubelet.go

@@ -41,7 +41,7 @@ import (
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 	"k8s.io/kubernetes/pkg/fields"
-	internalApi "k8s.io/kubernetes/pkg/kubelet/api"
+	internalapi "k8s.io/kubernetes/pkg/kubelet/api"
 	"k8s.io/kubernetes/pkg/kubelet/cadvisor"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
 	"k8s.io/kubernetes/pkg/kubelet/config"
@@ -256,7 +256,7 @@ func makePodSourceConfig(kubeCfg *componentconfig.KubeletConfiguration, kubeDeps
 	return cfg, nil
 }
 
-func getRuntimeAndImageServices(config *componentconfig.KubeletConfiguration) (internalApi.RuntimeService, internalApi.ImageManagerService, error) {
+func getRuntimeAndImageServices(config *componentconfig.KubeletConfiguration) (internalapi.RuntimeService, internalapi.ImageManagerService, error) {
 	rs, err := remote.NewRemoteRuntimeService(config.RemoteRuntimeEndpoint, config.RuntimeRequestTimeout.Duration)
 	if err != nil {
 		return nil, nil, err
@@ -529,8 +529,8 @@ func NewMainKubelet(kubeCfg *componentconfig.KubeletConfiguration, kubeDeps *Kub
 		// becomes the default.
 		klet.networkPlugin = nil
 
-		var runtimeService internalApi.RuntimeService
-		var imageService internalApi.ImageManagerService
+		var runtimeService internalapi.RuntimeService
+		var imageService internalapi.ImageManagerService
 		var err error
 
 		switch kubeCfg.ContainerRuntime {
@@ -548,8 +548,8 @@ func NewMainKubelet(kubeCfg *componentconfig.KubeletConfiguration, kubeDeps *Kub
 			}
 
 			klet.criHandler = ds
-			rs := ds.(internalApi.RuntimeService)
-			is := ds.(internalApi.ImageManagerService)
+			rs := ds.(internalapi.RuntimeService)
+			is := ds.(internalapi.ImageManagerService)
 			// This is an internal knob to switch between grpc and non-grpc
 			// integration.
 			// TODO: Remove this knob once we switch to using GRPC completely.

pkg/kubelet/kubelet_node_status.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"math"
 	"net"
-	goRuntime "runtime"
+	goruntime "runtime"
 	"sort"
 	"strings"
 	"time"
@@ -177,8 +177,8 @@ func (kl *Kubelet) initialNode() (*v1.Node, error) {
 			Name: string(kl.nodeName),
 			Labels: map[string]string{
 				unversioned.LabelHostname: kl.hostname,
-				unversioned.LabelOS:       goRuntime.GOOS,
-				unversioned.LabelArch:     goRuntime.GOARCH,
+				unversioned.LabelOS:       goruntime.GOOS,
+				unversioned.LabelArch:     goruntime.GOARCH,
 			},
 		},
 		Spec: v1.NodeSpec{
@@ -572,8 +572,8 @@ func (kl *Kubelet) setNodeStatusImages(node *v1.Node) {
 
 // Set the GOOS and GOARCH for this node
 func (kl *Kubelet) setNodeStatusGoRuntime(node *v1.Node) {
-	node.Status.NodeInfo.OperatingSystem = goRuntime.GOOS
-	node.Status.NodeInfo.Architecture = goRuntime.GOARCH
+	node.Status.NodeInfo.OperatingSystem = goruntime.GOOS
+	node.Status.NodeInfo.Architecture = goruntime.GOARCH
 }
 
 // Set status for the node.

pkg/kubelet/kuberuntime/fake_kuberuntime_manager.go

@@ -25,7 +25,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/client/record"
 	"k8s.io/kubernetes/pkg/credentialprovider"
-	internalApi "k8s.io/kubernetes/pkg/kubelet/api"
+	internalapi "k8s.io/kubernetes/pkg/kubelet/api"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/images"
 	"k8s.io/kubernetes/pkg/kubelet/lifecycle"
@@ -91,7 +91,7 @@ func (f *fakePodGetter) GetPodByUID(uid types.UID) (*v1.Pod, bool) {
 	return pod, found
 }
 
-func NewFakeKubeRuntimeManager(runtimeService internalApi.RuntimeService, imageService internalApi.ImageManagerService, machineInfo *cadvisorapi.MachineInfo, networkPlugin network.NetworkPlugin, osInterface kubecontainer.OSInterface) (*kubeGenericRuntimeManager, error) {
+func NewFakeKubeRuntimeManager(runtimeService internalapi.RuntimeService, imageService internalapi.ImageManagerService, machineInfo *cadvisorapi.MachineInfo, networkPlugin network.NetworkPlugin, osInterface kubecontainer.OSInterface) (*kubeGenericRuntimeManager, error) {
 	recorder := &record.FakeRecorder{}
 	kubeRuntimeManager := &kubeGenericRuntimeManager{
 		recorder:            recorder,

pkg/kubelet/kuberuntime/helpers.go

@@ -23,7 +23,7 @@ import (
 
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api/v1"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/types"
 )
@@ -57,7 +57,7 @@ func (b containersByID) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
 func (b containersByID) Less(i, j int) bool { return b[i].ID.ID < b[j].ID.ID }
 
 // Newest first.
-type podSandboxByCreated []*runtimeApi.PodSandbox
+type podSandboxByCreated []*runtimeapi.PodSandbox
 
 func (p podSandboxByCreated) Len() int           { return len(p) }
 func (p podSandboxByCreated) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
@@ -69,37 +69,37 @@ func (c containerStatusByCreated) Len() int           { return len(c) }
 func (c containerStatusByCreated) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }
 func (c containerStatusByCreated) Less(i, j int) bool { return c[i].CreatedAt.After(c[j].CreatedAt) }
 
-// toKubeContainerState converts runtimeApi.ContainerState to kubecontainer.ContainerState.
-func toKubeContainerState(state runtimeApi.ContainerState) kubecontainer.ContainerState {
+// toKubeContainerState converts runtimeapi.ContainerState to kubecontainer.ContainerState.
+func toKubeContainerState(state runtimeapi.ContainerState) kubecontainer.ContainerState {
 	switch state {
-	case runtimeApi.ContainerState_CONTAINER_CREATED:
+	case runtimeapi.ContainerState_CONTAINER_CREATED:
 		return kubecontainer.ContainerStateCreated
-	case runtimeApi.ContainerState_CONTAINER_RUNNING:
+	case runtimeapi.ContainerState_CONTAINER_RUNNING:
 		return kubecontainer.ContainerStateRunning
-	case runtimeApi.ContainerState_CONTAINER_EXITED:
+	case runtimeapi.ContainerState_CONTAINER_EXITED:
 		return kubecontainer.ContainerStateExited
-	case runtimeApi.ContainerState_CONTAINER_UNKNOWN:
+	case runtimeapi.ContainerState_CONTAINER_UNKNOWN:
 		return kubecontainer.ContainerStateUnknown
 	}
 
 	return kubecontainer.ContainerStateUnknown
 }
 
-// toRuntimeProtocol converts v1.Protocol to runtimeApi.Protocol.
-func toRuntimeProtocol(protocol v1.Protocol) runtimeApi.Protocol {
+// toRuntimeProtocol converts v1.Protocol to runtimeapi.Protocol.
+func toRuntimeProtocol(protocol v1.Protocol) runtimeapi.Protocol {
 	switch protocol {
 	case v1.ProtocolTCP:
-		return runtimeApi.Protocol_TCP
+		return runtimeapi.Protocol_TCP
 	case v1.ProtocolUDP:
-		return runtimeApi.Protocol_UDP
+		return runtimeapi.Protocol_UDP
 	}
 
 	glog.Warningf("Unknown protocol %q: defaulting to TCP", protocol)
-	return runtimeApi.Protocol_TCP
+	return runtimeapi.Protocol_TCP
 }
 
-// toKubeContainer converts runtimeApi.Container to kubecontainer.Container.
-func (m *kubeGenericRuntimeManager) toKubeContainer(c *runtimeApi.Container) (*kubecontainer.Container, error) {
+// toKubeContainer converts runtimeapi.Container to kubecontainer.Container.
+func (m *kubeGenericRuntimeManager) toKubeContainer(c *runtimeapi.Container) (*kubecontainer.Container, error) {
 	if c == nil || c.Id == nil || c.Image == nil || c.State == nil {
 		return nil, fmt.Errorf("unable to convert a nil pointer to a runtime container")
 	}
@@ -115,11 +115,11 @@ func (m *kubeGenericRuntimeManager) toKubeContainer(c *runtimeApi.Container) (*k
 	}, nil
 }
 
-// sandboxToKubeContainer converts runtimeApi.PodSandbox to kubecontainer.Container.
+// sandboxToKubeContainer converts runtimeapi.PodSandbox to kubecontainer.Container.
 // This is only needed because we need to return sandboxes as if they were
 // kubecontainer.Containers to avoid substantial changes to PLEG.
 // TODO: Remove this once it becomes obsolete.
-func (m *kubeGenericRuntimeManager) sandboxToKubeContainer(s *runtimeApi.PodSandbox) (*kubecontainer.Container, error) {
+func (m *kubeGenericRuntimeManager) sandboxToKubeContainer(s *runtimeapi.PodSandbox) (*kubecontainer.Container, error) {
 	if s == nil || s.Id == nil || s.State == nil {
 		return nil, fmt.Errorf("unable to convert a nil pointer to a runtime container")
 	}
@@ -149,7 +149,7 @@ func getContainerSpec(pod *v1.Pod, containerName string) *v1.Container {
 // getImageUser gets uid or user name that will run the command(s) from image. The function
 // guarantees that only one of them is set.
 func (m *kubeGenericRuntimeManager) getImageUser(image string) (*int64, *string, error) {
-	imageStatus, err := m.imageService.ImageStatus(&runtimeApi.ImageSpec{Image: &image})
+	imageStatus, err := m.imageService.ImageStatus(&runtimeapi.ImageSpec{Image: &image})
 	if err != nil {
 		return nil, nil, err
 	}
@@ -237,8 +237,8 @@ func buildPodLogsDirectory(podUID types.UID) string {
 	return filepath.Join(podLogsRootDirectory, string(podUID))
 }
 
-// toKubeRuntimeStatus converts the runtimeApi.RuntimeStatus to kubecontainer.RuntimeStatus.
-func toKubeRuntimeStatus(status *runtimeApi.RuntimeStatus) *kubecontainer.RuntimeStatus {
+// toKubeRuntimeStatus converts the runtimeapi.RuntimeStatus to kubecontainer.RuntimeStatus.
+func toKubeRuntimeStatus(status *runtimeapi.RuntimeStatus) *kubecontainer.RuntimeStatus {
 	conditions := []kubecontainer.RuntimeCondition{}
 	for _, c := range status.GetConditions() {
 		conditions = append(conditions, kubecontainer.RuntimeCondition{

pkg/kubelet/kuberuntime/instrumented_services.go

@@ -19,30 +19,30 @@ package kuberuntime
 import (
 	"time"
 
-	internalApi "k8s.io/kubernetes/pkg/kubelet/api"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	internalapi "k8s.io/kubernetes/pkg/kubelet/api"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	"k8s.io/kubernetes/pkg/kubelet/metrics"
 )
 
 // instrumentedRuntimeService wraps the RuntimeService and records the operations
 // and errors metrics.
 type instrumentedRuntimeService struct {
-	service internalApi.RuntimeService
+	service internalapi.RuntimeService
 }
 
 // Creates an instrumented RuntimeInterface from an existing RuntimeService.
-func NewInstrumentedRuntimeService(service internalApi.RuntimeService) internalApi.RuntimeService {
+func NewInstrumentedRuntimeService(service internalapi.RuntimeService) internalapi.RuntimeService {
 	return &instrumentedRuntimeService{service: service}
 }
 
 // instrumentedImageManagerService wraps the ImageManagerService and records the operations
 // and errors metrics.
 type instrumentedImageManagerService struct {
-	service internalApi.ImageManagerService
+	service internalapi.ImageManagerService
 }
 
 // Creates an instrumented ImageManagerService from an existing ImageManagerService.
-func NewInstrumentedImageManagerService(service internalApi.ImageManagerService) internalApi.ImageManagerService {
+func NewInstrumentedImageManagerService(service internalapi.ImageManagerService) internalapi.ImageManagerService {
 	return &instrumentedImageManagerService{service: service}
 }
 
@@ -59,7 +59,7 @@ func recordError(operation string, err error) {
 	}
 }
 
-func (in instrumentedRuntimeService) Version(apiVersion string) (*runtimeApi.VersionResponse, error) {
+func (in instrumentedRuntimeService) Version(apiVersion string) (*runtimeapi.VersionResponse, error) {
 	const operation = "version"
 	defer recordOperation(operation, time.Now())
 
@@ -68,7 +68,7 @@ func (in instrumentedRuntimeService) Version(apiVersion string) (*runtimeApi.Ver
 	return out, err
 }
 
-func (in instrumentedRuntimeService) Status() (*runtimeApi.RuntimeStatus, error) {
+func (in instrumentedRuntimeService) Status() (*runtimeapi.RuntimeStatus, error) {
 	const operation = "status"
 	defer recordOperation(operation, time.Now())
 
@@ -77,7 +77,7 @@ func (in instrumentedRuntimeService) Status() (*runtimeApi.RuntimeStatus, error)
 	return out, err
 }
 
-func (in instrumentedRuntimeService) CreateContainer(podSandboxID string, config *runtimeApi.ContainerConfig, sandboxConfig *runtimeApi.PodSandboxConfig) (string, error) {
+func (in instrumentedRuntimeService) CreateContainer(podSandboxID string, config *runtimeapi.ContainerConfig, sandboxConfig *runtimeapi.PodSandboxConfig) (string, error) {
 	const operation = "create_container"
 	defer recordOperation(operation, time.Now())
 
@@ -113,7 +113,7 @@ func (in instrumentedRuntimeService) RemoveContainer(containerID string) error {
 	return err
 }
 
-func (in instrumentedRuntimeService) ListContainers(filter *runtimeApi.ContainerFilter) ([]*runtimeApi.Container, error) {
+func (in instrumentedRuntimeService) ListContainers(filter *runtimeapi.ContainerFilter) ([]*runtimeapi.Container, error) {
 	const operation = "list_containers"
 	defer recordOperation(operation, time.Now())
 
@@ -122,7 +122,7 @@ func (in instrumentedRuntimeService) ListContainers(filter *runtimeApi.Container
 	return out, err
 }
 
-func (in instrumentedRuntimeService) ContainerStatus(containerID string) (*runtimeApi.ContainerStatus, error) {
+func (in instrumentedRuntimeService) ContainerStatus(containerID string) (*runtimeapi.ContainerStatus, error) {
 	const operation = "container_status"
 	defer recordOperation(operation, time.Now())
 
@@ -140,7 +140,7 @@ func (in instrumentedRuntimeService) ExecSync(containerID string, cmd []string,
 	return stdout, stderr, err
 }
 
-func (in instrumentedRuntimeService) Exec(req *runtimeApi.ExecRequest) (*runtimeApi.ExecResponse, error) {
+func (in instrumentedRuntimeService) Exec(req *runtimeapi.ExecRequest) (*runtimeapi.ExecResponse, error) {
 	const operation = "exec"
 	defer recordOperation(operation, time.Now())
 
@@ -149,7 +149,7 @@ func (in instrumentedRuntimeService) Exec(req *runtimeApi.ExecRequest) (*runtime
 	return resp, err
 }
 
-func (in instrumentedRuntimeService) Attach(req *runtimeApi.AttachRequest) (*runtimeApi.AttachResponse, error) {
+func (in instrumentedRuntimeService) Attach(req *runtimeapi.AttachRequest) (*runtimeapi.AttachResponse, error) {
 	const operation = "attach"
 	defer recordOperation(operation, time.Now())
 
@@ -158,7 +158,7 @@ func (in instrumentedRuntimeService) Attach(req *runtimeApi.AttachRequest) (*run
 	return resp, err
 }
 
-func (in instrumentedRuntimeService) RunPodSandbox(config *runtimeApi.PodSandboxConfig) (string, error) {
+func (in instrumentedRuntimeService) RunPodSandbox(config *runtimeapi.PodSandboxConfig) (string, error) {
 	const operation = "run_podsandbox"
 	defer recordOperation(operation, time.Now())
 
@@ -185,7 +185,7 @@ func (in instrumentedRuntimeService) RemovePodSandbox(podSandboxID string) error
 	return err
 }
 
-func (in instrumentedRuntimeService) PodSandboxStatus(podSandboxID string) (*runtimeApi.PodSandboxStatus, error) {
+func (in instrumentedRuntimeService) PodSandboxStatus(podSandboxID string) (*runtimeapi.PodSandboxStatus, error) {
 	const operation = "podsandbox_status"
 	defer recordOperation(operation, time.Now())
 
@@ -194,7 +194,7 @@ func (in instrumentedRuntimeService) PodSandboxStatus(podSandboxID string) (*run
 	return out, err
 }
 
-func (in instrumentedRuntimeService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]*runtimeApi.PodSandbox, error) {
+func (in instrumentedRuntimeService) ListPodSandbox(filter *runtimeapi.PodSandboxFilter) ([]*runtimeapi.PodSandbox, error) {
 	const operation = "list_podsandbox"
 	defer recordOperation(operation, time.Now())
 
@@ -203,7 +203,7 @@ func (in instrumentedRuntimeService) ListPodSandbox(filter *runtimeApi.PodSandbo
 	return out, err
 }
 
-func (in instrumentedRuntimeService) PortForward(req *runtimeApi.PortForwardRequest) (*runtimeApi.PortForwardResponse, error) {
+func (in instrumentedRuntimeService) PortForward(req *runtimeapi.PortForwardRequest) (*runtimeapi.PortForwardResponse, error) {
 	const operation = "port_forward"
 	defer recordOperation(operation, time.Now())
 
@@ -212,7 +212,7 @@ func (in instrumentedRuntimeService) PortForward(req *runtimeApi.PortForwardRequ
 	return resp, err
 }
 
-func (in instrumentedRuntimeService) UpdateRuntimeConfig(runtimeConfig *runtimeApi.RuntimeConfig) error {
+func (in instrumentedRuntimeService) UpdateRuntimeConfig(runtimeConfig *runtimeapi.RuntimeConfig) error {
 	const operation = "update_runtime_config"
 	defer recordOperation(operation, time.Now())
 
@@ -221,7 +221,7 @@ func (in instrumentedRuntimeService) UpdateRuntimeConfig(runtimeConfig *runtimeA
 	return err
 }
 
-func (in instrumentedImageManagerService) ListImages(filter *runtimeApi.ImageFilter) ([]*runtimeApi.Image, error) {
+func (in instrumentedImageManagerService) ListImages(filter *runtimeapi.ImageFilter) ([]*runtimeapi.Image, error) {
 	const operation = "list_images"
 	defer recordOperation(operation, time.Now())
 
@@ -230,7 +230,7 @@ func (in instrumentedImageManagerService) ListImages(filter *runtimeApi.ImageFil
 	return out, err
 }
 
-func (in instrumentedImageManagerService) ImageStatus(image *runtimeApi.ImageSpec) (*runtimeApi.Image, error) {
+func (in instrumentedImageManagerService) ImageStatus(image *runtimeapi.ImageSpec) (*runtimeapi.Image, error) {
 	const operation = "image_status"
 	defer recordOperation(operation, time.Now())
 
@@ -239,7 +239,7 @@ func (in instrumentedImageManagerService) ImageStatus(image *runtimeApi.ImageSpe
 	return out, err
 }
 
-func (in instrumentedImageManagerService) PullImage(image *runtimeApi.ImageSpec, auth *runtimeApi.AuthConfig) error {
+func (in instrumentedImageManagerService) PullImage(image *runtimeapi.ImageSpec, auth *runtimeapi.AuthConfig) error {
 	const operation = "pull_image"
 	defer recordOperation(operation, time.Now())
 
@@ -248,7 +248,7 @@ func (in instrumentedImageManagerService) PullImage(image *runtimeApi.ImageSpec,
 	return err
 }
 
-func (in instrumentedImageManagerService) RemoveImage(image *runtimeApi.ImageSpec) error {
+func (in instrumentedImageManagerService) RemoveImage(image *runtimeapi.ImageSpec) error {
 	const operation = "remove_image"
 	defer recordOperation(operation, time.Now())
 

pkg/kubelet/kuberuntime/kuberuntime_container.go

@@ -31,7 +31,7 @@ import (
 	"github.com/golang/glog"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/api/v1"
-	runtimeApi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
+	runtimeapi "k8s.io/kubernetes/pkg/kubelet/api/v1alpha1/runtime"
 	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
 	"k8s.io/kubernetes/pkg/kubelet/events"
 	"k8s.io/kubernetes/pkg/kubelet/qos"
@@ -49,7 +49,7 @@ import (
 // * create the container
 // * start the container
 // * run the post start lifecycle hooks (if applicable)
-func (m *kubeGenericRuntimeManager) startContainer(podSandboxID string, podSandboxConfig *runtimeApi.PodSandboxConfig, container *v1.Container, pod *v1.Pod, podStatus *kubecontainer.PodStatus, pullSecrets []v1.Secret, podIP string) (string, error) {
+func (m *kubeGenericRuntimeManager) startContainer(podSandboxID string, podSandboxConfig *runtimeapi.PodSandboxConfig, container *v1.Container, pod *v1.Pod, podStatus *kubecontainer.PodStatus, pullSecrets []v1.Secret, podIP string) (string, error) {
 	// Step 1: pull the image.
 	err, msg := m.imagePuller.EnsureImageExists(pod, container, pullSecrets)
 	if err != nil {
@@ -129,7 +129,7 @@ func (m *kubeGenericRuntimeManager) startContainer(podSandboxID string, podSandb
 }
 
 // generateContainerConfig generates container config for kubelet runtime v1.
-func (m *kubeGenericRuntimeManager) generateContainerConfig(container *v1.Container, pod *v1.Pod, restartCount int, podIP string) (*runtimeApi.ContainerConfig, error) {
+func (m *kubeGenericRuntimeManager) generateContainerConfig(container *v1.Container, pod *v1.Pod, restartCount int, podIP string) (*runtimeapi.ContainerConfig, error) {
 	opts, err := m.runtimeHelper.GenerateRunContainerOptions(pod, container, podIP)
 	if err != nil {
 		return nil, err
@@ -151,12 +151,12 @@ func (m *kubeGenericRuntimeManager) generateContainerConfig(container *v1.Contai
 	command, args := kubecontainer.ExpandContainerCommandAndArgs(container, opts.Envs)
 	containerLogsPath := buildContainerLogsPath(container.Name, restartCount)
 	restartCountUint32 := uint32(restartCount)
-	config := &runtimeApi.ContainerConfig{
-		Metadata: &runtimeApi.ContainerMetadata{
+	config := &runtimeapi.ContainerConfig{
+		Metadata: &runtimeapi.ContainerMetadata{
 			Name:    &container.Name,
 			Attempt: &restartCountUint32,
 		},
-		Image:       &runtimeApi.ImageSpec{Image: &container.Image},
+		Image:       &runtimeapi.ImageSpec{Image: &container.Image},
 		Command:     command,
 		Args:        args,
 		WorkingDir:  &container.WorkingDir,
@@ -172,10 +172,10 @@ func (m *kubeGenericRuntimeManager) generateContainerConfig(container *v1.Contai
 	}
 
 	// set environment variables
-	envs := make([]*runtimeApi.KeyValue, len(opts.Envs))
+	envs := make([]*runtimeapi.KeyValue, len(opts.Envs))
 	for idx := range opts.Envs {
 		e := opts.Envs[idx]
-		envs[idx] = &runtimeApi.KeyValue{
+		envs[idx] = &runtimeapi.KeyValue{
 			Key:   &e.Name,
 			Value: &e.Value,
 		}
@@ -186,9 +186,9 @@ func (m *kubeGenericRuntimeManager) generateContainerConfig(container *v1.Contai
 }
 
 // generateLinuxContainerConfig generates linux container config for kubelet runtime v1.
-func (m *kubeGenericRuntimeManager) generateLinuxContainerConfig(container *v1.Container, pod *v1.Pod, uid *int64, username *string) *runtimeApi.LinuxContainerConfig {
-	lc := &runtimeApi.LinuxContainerConfig{
-		Resources:       &runtimeApi.LinuxContainerResources{},
+func (m *kubeGenericRuntimeManager) generateLinuxContainerConfig(container *v1.Container, pod *v1.Pod, uid *int64, username *string) *runtimeapi.LinuxContainerConfig {
+	lc := &runtimeapi.LinuxContainerConfig{
+		Resources:       &runtimeapi.LinuxContainerResources{},
 		SecurityContext: m.determineEffectiveSecurityContext(pod, container, uid, username),
 	}
 
@@ -229,12 +229,12 @@ func (m *kubeGenericRuntimeManager) generateLinuxContainerConfig(container *v1.C
 }
 
 // makeDevices generates container devices for kubelet runtime v1.
-func makeDevices(opts *kubecontainer.RunContainerOptions) []*runtimeApi.Device {
-	devices := make([]*runtimeApi.Device, len(opts.Devices))
+func makeDevices(opts *kubecontainer.RunContainerOptions) []*runtimeapi.Device {
+	devices := make([]*runtimeapi.Device, len(opts.Devices))
 
 	for idx := range opts.Devices {
 		device := opts.Devices[idx]
-		devices[idx] = &runtimeApi.Device{
+		devices[idx] = &runtimeapi.Device{
 			HostPath:      &device.PathOnHost,
 			ContainerPath: &device.PathInContainer,
 			Permissions:   &device.Permissions,
@@ -245,13 +245,13 @@ func makeDevices(opts *kubecontainer.RunContainerOptions) []*runtimeApi.Device {
 }
 
 // makeMounts generates container volume mounts for kubelet runtime v1.
-func (m *kubeGenericRuntimeManager) makeMounts(opts *kubecontainer.RunContainerOptions, container *v1.Container) []*runtimeApi.Mount {
-	volumeMounts := []*runtimeApi.Mount{}
+func (m *kubeGenericRuntimeManager) makeMounts(opts *kubecontainer.RunContainerOptions, container *v1.Container) []*runtimeapi.Mount {
+	volumeMounts := []*runtimeapi.Mount{}
 
 	for idx := range opts.Mounts {
 		v := opts.Mounts[idx]
 		selinuxRelabel := v.SELinuxRelabel && selinux.SELinuxEnabled()
-		mount := &runtimeApi.Mount{
+		mount := &runtimeapi.Mount{
 			HostPath:       &v.HostPath,
 			ContainerPath:  &v.ContainerPath,
 			Readonly:       &v.ReadOnly,
@@ -276,7 +276,7 @@ func (m *kubeGenericRuntimeManager) makeMounts(opts *kubecontainer.RunContainerO
 		} else {
 			fs.Close()
 			selinuxRelabel := selinux.SELinuxEnabled()
-			volumeMounts = append(volumeMounts, &runtimeApi.Mount{
+			volumeMounts = append(volumeMounts, &runtimeapi.Mount{
 				HostPath:       &containerLogPath,
 				ContainerPath:  &container.TerminationMessagePath,
 				SelinuxRelabel: &selinuxRelabel,
@@ -290,12 +290,12 @@ func (m *kubeGenericRuntimeManager) makeMounts(opts *kubecontainer.RunContainerO
 // getKubeletContainers lists containers managed by kubelet.
 // The boolean parameter specifies whether returns all containers including
 // those already exited and dead containers (used for garbage collection).
-func (m *kubeGenericRuntimeManager) getKubeletContainers(allContainers bool) ([]*runtimeApi.Container, error) {
-	filter := &runtimeApi.ContainerFilter{
+func (m *kubeGenericRuntimeManager) getKubeletContainers(allContainers bool) ([]*runtimeapi.Container, error) {
+	filter := &runtimeapi.ContainerFilter{
 		LabelSelector: map[string]string{kubernetesManagedLabel: "true"},
 	}
 	if !allContainers {
-		runningState := runtimeApi.ContainerState_CONTAINER_RUNNING
+		runningState := runtimeapi.ContainerState_CONTAINER_RUNNING
 		filter.State = &runningState
 	}
 
@@ -309,7 +309,7 @@ func (m *kubeGenericRuntimeManager) getKubeletContainers(allContainers bool) ([]
 }
 
 // getContainers lists containers by filter.
-func (m *kubeGenericRuntimeManager) getContainersHelper(filter *runtimeApi.ContainerFilter) ([]*runtimeApi.Container, error) {
+func (m *kubeGenericRuntimeManager) getContainersHelper(filter *runtimeapi.ContainerFilter) ([]*runtimeapi.Container, error) {
 	resp, err := m.runtimeService.ListContainers(filter)
 	if err != nil {
 		return nil, err
@@ -324,7 +324,7 @@ func makeUID() string {
 }
 
 // getTerminationMessage gets termination message of the container.
-func getTerminationMessage(status *runtimeApi.ContainerStatus, kubeStatus *kubecontainer.ContainerStatus, terminationMessagePath string) string {
+func getTerminationMessage(status *runtimeapi.ContainerStatus, kubeStatus *kubecontainer.ContainerStatus, terminationMessagePath string) string {
 	message := ""
 
 	if !kubeStatus.FinishedAt.IsZero() || kubeStatus.ExitCode != 0 {
@@ -351,7 +351,7 @@ func getTerminationMessage(status *runtimeApi.ContainerStatus, kubeStatus *kubec
 // getPodContainerStatuses gets all containers' statuses for the pod.
 func (m *kubeGenericRuntimeManager) getPodContainerStatuses(uid kubetypes.UID, name, namespace string) ([]*kubecontainer.ContainerStatus, error) {
 	// Select all containers of the given pod.
-	containers, err := m.runtimeService.ListContainers(&runtimeApi.ContainerFilter{
+	containers, err := m.runtimeService.ListContainers(&runtimeapi.ContainerFilter{
 		LabelSelector: map[string]string{types.KubernetesPodUIDLabel: string(uid)},
 	})
 	if err != nil {
@@ -384,7 +384,7 @@ func (m *kubeGenericRuntimeManager) getPodContainerStatuses(uid kubetypes.UID, n
 			CreatedAt:    time.Unix(0, status.GetCreatedAt()),
 		}
 
-		if c.GetState() == runtimeApi.ContainerState_CONTAINER_RUNNING {
+		if c.GetState() == runtimeapi.ContainerState_CONTAINER_RUNNING {
 			cStatus.StartedAt = time.Unix(0, status.GetStartedAt())
 		} else {
 			cStatus.Reason = status.GetReason()
@@ -669,7 +669,7 @@ func (m *kubeGenericRuntimeManager) GetContainerLogs(pod *v1.Pod, containerID ku
 
 // GetExec gets the endpoint the runtime will serve the exec request from.
 func (m *kubeGenericRuntimeManager) GetExec(id kubecontainer.ContainerID, cmd []string, stdin, stdout, stderr, tty bool) (*url.URL, error) {
-	req := &runtimeApi.ExecRequest{
+	req := &runtimeapi.ExecRequest{
 		ContainerId: &id.ID,
 		Cmd:         cmd,
 		Tty:         &tty,
@@ -685,7 +685,7 @@ func (m *kubeGenericRuntimeManager) GetExec(id kubecontainer.ContainerID, cmd []
 
 // GetAttach gets the endpoint the runtime will serve the attach request from.
 func (m *kubeGenericRuntimeManager) GetAttach(id kubecontainer.ContainerID, stdin, stdout, stderr bool) (*url.URL, error) {
-	req := &runtimeApi.AttachRequest{
+	req := &runtimeapi.AttachRequest{
 		ContainerId: &id.ID,
 		Stdin:       &stdin,
 	}