rename kube pkg to kapi

cmd/minikube/cmd/start.go

@@ -150,7 +150,7 @@ func initMinikubeFlags() {
 	startCmd.Flags().String(networkPlugin, "", "The name of the network plugin.")
 	startCmd.Flags().Bool(enableDefaultCNI, false, "Enable the default CNI plugin (/etc/cni/net.d/k8s.conf). Used in conjunction with \"--network-plugin=cni\".")
 	startCmd.Flags().Bool(waitUntilHealthy, true, "Wait until Kubernetes core services are healthy before exiting.")
-	startCmd.Flags().Duration(waitTimeout, 3*time.Minute, "max time to wait for Kubernetes core services to be healthy.")
+	startCmd.Flags().Duration(waitTimeout, 3*time.Minute, "max time to wait per Kubernetes core services to be healthy.")
 }
 
 // initKubernetesFlags inits the commandline flags for kubernetes related options

pkg/kube/kube.go → pkg/kapi/kapi.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package kube
+package kapi
 
 import (
 	"context"
@@ -77,7 +77,7 @@ func WaitForPodsWithLabelRunning(c kubernetes.Interface, ns string, label labels
 		listOpts := meta.ListOptions{LabelSelector: label.String()}
 		pods, err := c.CoreV1().Pods(ns).List(listOpts)
 		if err != nil {
-			glog.Infof("temproary error: getting Pods with label selector %q : [%v]\n", label.String(), err)
+			glog.Infof("temporary error: getting Pods with label selector %q : [%v]\n", label.String(), err)
 			return false, nil
 		}
 
@@ -92,7 +92,7 @@ func WaitForPodsWithLabelRunning(c kubernetes.Interface, ns string, label labels
 
 		for _, pod := range pods.Items {
 			if pod.Status.Phase != core.PodRunning {
-				glog.Infof("temporary error: for Pod with label %q expected status to be running but got %s : [%v]\n", label.String(), pod.Status.Phase, err)
+				glog.Infof("waiting for pod %q, current state: %s: [%v]\n", label.String(), pod.Status.Phase, err)
 				return false, nil
 			}
 		}
@@ -104,8 +104,7 @@ func WaitForPodsWithLabelRunning(c kubernetes.Interface, ns string, label labels
 		t = timeOut[0]
 	}
 	err := wait.PollImmediate(kconst.APICallRetryInterval, t, f)
-	elapsed := time.Since(start)
-	glog.Infof("duration metric: took %s to wait for %s ...", elapsed, label)
+	glog.Infof("duration metric: took %s to wait for %s ...", time.Since(start), label)
 	return err
 }
 

pkg/minikube/bootstrapper/kubeadm/kubeadm.go

@@ -35,7 +35,7 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/wait"
 	kconst "k8s.io/kubernetes/cmd/kubeadm/app/constants"
-	"k8s.io/minikube/pkg/kube"
+	"k8s.io/minikube/pkg/kapi"
 	"k8s.io/minikube/pkg/minikube/assets"
 	"k8s.io/minikube/pkg/minikube/bootstrapper"
 	"k8s.io/minikube/pkg/minikube/command"
@@ -311,7 +311,7 @@ func (k *Bootstrapper) WaitCluster(k8s config.KubernetesConfig, timeout time.Dur
 	// up. Otherwise, minikube won't start, as "k8s-app" pods are not ready.
 	componentsOnly := k8s.NetworkPlugin == "cni"
 	out.T(out.WaitingPods, "Waiting for:")
-	client, err := kube.Client()
+	client, err := kapi.Client()
 	if err != nil {
 		return errors.Wrap(err, "k8s client")
 	}
@@ -329,7 +329,7 @@ func (k *Bootstrapper) WaitCluster(k8s config.KubernetesConfig, timeout time.Dur
 		}
 		out.String(" %s", p.name)
 		selector := labels.SelectorFromSet(labels.Set(map[string]string{p.key: p.value}))
-		if err := kube.WaitForPodsWithLabelRunning(client, "kube-system", selector, timeout); err != nil {
+		if err := kapi.WaitForPodsWithLabelRunning(client, "kube-system", selector, timeout); err != nil {
 			return errors.Wrap(err, fmt.Sprintf("waiting for %s=%s", p.key, p.value))
 		}
 	}
@@ -398,8 +398,7 @@ func (k *Bootstrapper) waitForAPIServer(k8s config.KubernetesConfig) error {
 		return true, nil
 	}
 	err := wait.PollImmediate(kconst.APICallRetryInterval, kconst.DefaultControlPlaneTimeout, f)
-	elapsed := time.Since(start)
-	glog.Infof("duration metric: took %s to wait for apiserver status ...", elapsed)
+	glog.Infof("duration metric: took %s to wait for apiserver status ...", time.Since(start))
 	return err
 }
 

pkg/minikube/bootstrapper/kubeadm/versions.go

@@ -159,7 +159,7 @@ func Supports(featureName string) bool {
 	return false
 }
 
-// arseKubernetesVersion parses the kubernetes version
+// parseKubernetesVersion parses the kubernetes version
 func parseKubernetesVersion(version string) (semver.Version, error) {
 	// Strip leading 'v' prefix from version for semver parsing
 	v, err := semver.Make(version[1:])

test/integration/containerd_test.go

@@ -25,7 +25,7 @@ import (
 	"github.com/docker/machine/libmachine/state"
 	"github.com/pkg/errors"
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/minikube/pkg/kube"
+	"k8s.io/minikube/pkg/kapi"
 	"k8s.io/minikube/test/integration/util"
 )
 
@@ -107,27 +107,27 @@ func deleteUntrustedWorkload(t *testing.T, profile string) {
 
 // waitForGvisorControllerRunning waits for the gvisor controller pod to be running
 func waitForGvisorControllerRunning(p string) error {
-	client, err := kube.Client(p)
+	client, err := kapi.Client(p)
 	if err != nil {
 		return errors.Wrap(err, "getting kubernetes client")
 	}
 
 	selector := labels.SelectorFromSet(labels.Set(map[string]string{"kubernetes.io/minikube-addons": "gvisor"}))
-	if err := kube.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
 		return errors.Wrap(err, "waiting for gvisor controller pod to stabilize")
 	}
 	return nil
 }
 
 // waitForUntrustedNginxRunning waits for the untrusted nginx pod to start running
 func waitForUntrustedNginxRunning(miniProfile string) error {
-	client, err := kube.Client(miniProfile)
+	client, err := kapi.Client(miniProfile)
 	if err != nil {
 		return errors.Wrap(err, "getting kubernetes client")
 	}
 
 	selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx"}))
-	if err := kube.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
 		return errors.Wrap(err, "waiting for nginx pods")
 	}
 	return nil

test/integration/fn_addons.go

@@ -34,20 +34,20 @@ import (
 
 	retryablehttp "github.com/hashicorp/go-retryablehttp"
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/minikube/pkg/kube"
+	"k8s.io/minikube/pkg/kapi"
 	"k8s.io/minikube/pkg/util/retry"
 	"k8s.io/minikube/test/integration/util"
 )
 
 func testAddons(t *testing.T) {
 	t.Parallel()
 	p := profileName(t)
-	client, err := kube.Client(p)
+	client, err := kapi.Client(p)
 	if err != nil {
 		t.Fatalf("Could not get kubernetes client: %v", err)
 	}
 	selector := labels.SelectorFromSet(labels.Set(map[string]string{"component": "kube-addon-manager"}))
-	if err := kube.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
 		t.Errorf("Error waiting for addon manager to be up")
 	}
 }
@@ -192,22 +192,22 @@ func testRegistry(t *testing.T) {
 	p := profileName(t)
 	mk := NewMinikubeRunner(t, p)
 	mk.RunCommand("addons enable registry", true)
-	client, err := kube.Client(p)
+	client, err := kapi.Client(p)
 	if err != nil {
 		t.Fatalf("getting kubernetes client: %v", err)
 	}
-	if err := kube.WaitForRCToStabilize(client, "kube-system", "registry", time.Minute*5); err != nil {
+	if err := kapi.WaitForRCToStabilize(client, "kube-system", "registry", time.Minute*5); err != nil {
 		t.Fatalf("waiting for registry replicacontroller to stabilize: %v", err)
 	}
 	rs := labels.SelectorFromSet(labels.Set(map[string]string{"actual-registry": "true"}))
-	if err := kube.WaitForPodsWithLabelRunning(client, "kube-system", rs); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "kube-system", rs); err != nil {
 		t.Fatalf("waiting for registry pods: %v", err)
 	}
 	ps, err := labels.Parse("kubernetes.io/minikube-addons=registry,actual-registry!=true")
 	if err != nil {
 		t.Fatalf("Unable to parse selector: %v", err)
 	}
-	if err := kube.WaitForPodsWithLabelRunning(client, "kube-system", ps); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "kube-system", ps); err != nil {
 		t.Fatalf("waiting for registry-proxy pods: %v", err)
 	}
 	ip, stderr := mk.RunCommand("ip", true)
@@ -264,36 +264,36 @@ func testRegistry(t *testing.T) {
 
 // waitForNginxRunning waits for nginx service to be up
 func waitForNginxRunning(t *testing.T, miniProfile string) error {
-	client, err := kube.Client(miniProfile)
+	client, err := kapi.Client(miniProfile)
 
 	if err != nil {
 		return errors.Wrap(err, "getting kubernetes client")
 	}
 
 	selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx"}))
-	if err := kube.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
 		return errors.Wrap(err, "waiting for nginx pods")
 	}
 
-	if err := kube.WaitForService(client, "default", "nginx", true, time.Millisecond*500, time.Minute*10); err != nil {
+	if err := kapi.WaitForService(client, "default", "nginx", true, time.Millisecond*500, time.Minute*10); err != nil {
 		t.Errorf("Error waiting for nginx service to be up")
 	}
 	return nil
 }
 
 // waitForIngressControllerRunning waits until ingress controller pod to be running
 func waitForIngressControllerRunning(miniProfile string) error {
-	client, err := kube.Client(miniProfile)
+	client, err := kapi.Client(miniProfile)
 	if err != nil {
 		return errors.Wrap(err, "getting kubernetes client")
 	}
 
-	if err := kube.WaitForDeploymentToStabilize(client, "kube-system", "nginx-ingress-controller", time.Minute*10); err != nil {
+	if err := kapi.WaitForDeploymentToStabilize(client, "kube-system", "nginx-ingress-controller", time.Minute*10); err != nil {
 		return errors.Wrap(err, "waiting for ingress-controller deployment to stabilize")
 	}
 
 	selector := labels.SelectorFromSet(labels.Set(map[string]string{"app.kubernetes.io/name": "nginx-ingress-controller"}))
-	if err := kube.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
 		return errors.Wrap(err, "waiting for ingress-controller pods")
 	}
 

test/integration/fn_cluster_dns.go

@@ -26,15 +26,15 @@ import (
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
-	"k8s.io/minikube/pkg/kube"
+	"k8s.io/minikube/pkg/kapi"
 	"k8s.io/minikube/pkg/util/retry"
 	"k8s.io/minikube/test/integration/util"
 )
 
 func testClusterDNS(t *testing.T) {
 	t.Parallel()
 	p := profileName(t)
-	client, err := kube.Client(p)
+	client, err := kapi.Client(p)
 	if err != nil {
 		t.Fatalf("Error getting kubernetes client %v", err)
 	}

test/integration/fn_mount.go

@@ -29,7 +29,7 @@ import (
 	"time"
 
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/minikube/pkg/kube"
+	"k8s.io/minikube/pkg/kapi"
 	"k8s.io/minikube/pkg/util/lock"
 	"k8s.io/minikube/pkg/util/retry"
 	"k8s.io/minikube/test/integration/util"
@@ -132,12 +132,12 @@ func writeFilesFromHost(mountedDir string, files []string, content string) error
 }
 
 func waitForPods(s map[string]string, profile string) error {
-	client, err := kube.Client(profile)
+	client, err := kapi.Client(profile)
 	if err != nil {
 		return fmt.Errorf("getting kubernetes client: %v", err)
 	}
 	selector := labels.SelectorFromSet(labels.Set(s))
-	if err := kube.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
 		return err
 	}
 	return nil

test/integration/fn_pv.go

@@ -29,7 +29,7 @@ import (
 	core "k8s.io/api/core/v1"
 	storage "k8s.io/api/storage/v1"
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/minikube/pkg/kube"
+	"k8s.io/minikube/pkg/kapi"
 	"k8s.io/minikube/pkg/util/retry"
 	"k8s.io/minikube/test/integration/util"
 )
@@ -73,13 +73,13 @@ func testProvisioning(t *testing.T) {
 	// Check that the storage provisioner pod is running
 
 	checkPodRunning := func() error {
-		client, err := kube.Client(p)
+		client, err := kapi.Client(p)
 		if err != nil {
 			return errors.Wrap(err, "getting kubernetes client")
 		}
 		selector := labels.SelectorFromSet(labels.Set(map[string]string{"integration-test": "storage-provisioner"}))
 
-		if err := kube.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
+		if err := kapi.WaitForPodsWithLabelRunning(client, "kube-system", selector); err != nil {
 			return err
 		}
 		return nil

test/integration/fn_tunnel.go

@@ -31,7 +31,7 @@ import (
 
 	"github.com/pkg/errors"
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/minikube/pkg/kube"
+	"k8s.io/minikube/pkg/kapi"
 	"k8s.io/minikube/pkg/minikube/tunnel"
 	"k8s.io/minikube/pkg/util/retry"
 	"k8s.io/minikube/test/integration/util"
@@ -70,18 +70,18 @@ func testTunnel(t *testing.T) {
 		t.Fatalf("creating nginx ingress resource: %s", err)
 	}
 
-	client, err := kube.Client(p)
+	client, err := kapi.Client(p)
 
 	if err != nil {
 		t.Fatal(errors.Wrap(err, "getting kubernetes client"))
 	}
 
 	selector := labels.SelectorFromSet(labels.Set(map[string]string{"run": "nginx-svc"}))
-	if err := kube.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
+	if err := kapi.WaitForPodsWithLabelRunning(client, "default", selector); err != nil {
 		t.Fatal(errors.Wrap(err, "waiting for nginx pods"))
 	}
 
-	if err := kube.WaitForService(client, "default", "nginx-svc", true, 1*time.Second, 2*time.Minute); err != nil {
+	if err := kapi.WaitForService(client, "default", "nginx-svc", true, 1*time.Second, 2*time.Minute); err != nil {
 		t.Fatal(errors.Wrap(err, "Error waiting for nginx service to be up"))
 	}
 
@@ -121,7 +121,7 @@ func getIngress(kr *util.KubectlRunner) (string, error) {
 		case err == nil:
 			nginxIP = string(stdout)
 			return len(stdout) != 0, nil
-		case !kube.IsRetryableAPIError(err):
+		case !kapi.IsRetryableAPIError(err):
 			ret = fmt.Errorf("`%s` failed with non retriable error: %v", cmd, err)
 			return false, err
 		default:

test/integration/util/common.go

@@ -23,17 +23,17 @@ import (
 
 	"github.com/pkg/errors"
 	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/minikube/pkg/kube"
+	"k8s.io/minikube/pkg/kapi"
 )
 
 // WaitForBusyboxRunning waits until busybox pod to be running
 func WaitForBusyboxRunning(t *testing.T, namespace string, miniProfile string) error {
-	client, err := kube.Client(miniProfile)
+	client, err := kapi.Client(miniProfile)
 	if err != nil {
 		return errors.Wrap(err, "getting kubernetes client")
 	}
 	selector := labels.SelectorFromSet(labels.Set(map[string]string{"integration-test": "busybox"}))
-	return kube.WaitForPodsWithLabelRunning(client, namespace, selector)
+	return kapi.WaitForPodsWithLabelRunning(client, namespace, selector)
 }
 
 // Logf writes logs to stdout if -v is set.