Having working minikube service & minikube dashboard wait until ready

functionality using endpoints.

cmd/minikube/cmd/dashboard.go

@@ -19,13 +19,15 @@ package cmd
 import (
 	"fmt"
 	"os"
+	"time"
 
 	"github.com/docker/machine/libmachine"
-	"github.com/golang/glog"
 	"github.com/pkg/browser"
 	"github.com/spf13/cobra"
 	"k8s.io/minikube/pkg/minikube/cluster"
 	"k8s.io/minikube/pkg/minikube/constants"
+
+	commonutil "k8s.io/minikube/pkg/util"
 )
 
 var (
@@ -40,9 +42,20 @@ var dashboardCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		api := libmachine.NewClient(constants.Minipath, constants.MakeMiniPath("certs"))
 		defer api.Close()
-		url, err := cluster.GetServiceURL(api, "kube-system", "kubernetes-dashboard")
+
+		cluster.EnsureMinikubeRunningOrExit(api)
+		namespace := "kube-system"
+		service := "kubernetes-dashboard"
+
+		if err := commonutil.RetryAfter(20, func() error { return CheckService(namespace, service) }, 6*time.Second); err != nil {
+			fmt.Println("Could not find healthy pod being pointed to by %s: %s", service, err)
+			os.Exit(1)
+		}
+
+		url, err := cluster.GetServiceURL(api, namespace, service)
 		if err != nil {
-			glog.Errorln("Error accessing the kubernetes dashboard (is minikube running?): Error: ", err)
+			fmt.Fprintln(os.Stderr, err)
+			fmt.Fprintln(os.Stderr, "Check that minikube is running.")
 			os.Exit(1)
 		}
 		if dashboardURLMode {
@@ -51,6 +64,7 @@ var dashboardCmd = &cobra.Command{
 			fmt.Fprintln(os.Stdout, "Opening kubernetes dashboard in default browser...")
 			browser.OpenURL(url)
 		}
+
 	},
 }
 

cmd/minikube/cmd/service.go

@@ -19,12 +19,15 @@ package cmd
 import (
 	"fmt"
 	"os"
+	"time"
 
 	"github.com/docker/machine/libmachine"
 	"github.com/pkg/browser"
 	"github.com/spf13/cobra"
 	"k8s.io/minikube/pkg/minikube/cluster"
 	"k8s.io/minikube/pkg/minikube/constants"
+
+	commonutil "k8s.io/minikube/pkg/util"
 )
 
 var (
@@ -44,9 +47,15 @@ var serviceCmd = &cobra.Command{
 		}
 
 		service := args[0]
-
 		api := libmachine.NewClient(constants.Minipath, constants.MakeMiniPath("certs"))
 		defer api.Close()
+
+		cluster.EnsureMinikubeRunningOrExit(api)
+		if err := commonutil.RetryAfter(20, func() error { return CheckService(namespace, service) }, 6*time.Second); err != nil {
+			fmt.Println("Could not find finalized endpoint being pointed to by %s: %s", service, err)
+			os.Exit(1)
+		}
+
 		url, err := cluster.GetServiceURL(api, namespace, service)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
@@ -67,3 +76,27 @@ func init() {
 	serviceCmd.Flags().BoolVar(&serviceURLMode, "url", false, "Display the kubernetes service URL in the CLI instead of opening it in the default browser")
 	RootCmd.AddCommand(serviceCmd)
 }
+
+// CheckService waits for the specified service to be ready by returning an error until the service is up
+// The check is done by polling the endpoint associated with the service and when the endpoint exists, returning no error->service-online
+func CheckService(namespace string, service string) error {
+	endpoints, err := cluster.GetKubernetesEndpointsWithNamespace(namespace)
+	if err != nil {
+		return err
+	}
+	endpoint, err := endpoints.Get(service)
+	if err != nil {
+		return err
+	}
+	if len(endpoint.Subsets) == 0 {
+		fmt.Printf("Waiting, endpoint for service: %s is not ready yet...\n", service)
+		return fmt.Errorf("Endpoint for service: %s is not ready yet\n", service)
+	}
+	for _, subset := range endpoint.Subsets {
+		if len(subset.NotReadyAddresses) != 0 {
+			fmt.Printf("Waiting, endpoint for service: %s is not ready yet...\n", service)
+			return fmt.Errorf("Endpoint for service: %s is not ready yet\n", service)
+		}
+	}
+	return nil
+}

pkg/minikube/cluster/cluster.go

@@ -563,8 +563,12 @@ type serviceGetter interface {
 	Get(name string) (*kubeApi.Service, error)
 }
 
+type endpointGetter interface {
+	Get(name string) (*kubeApi.Endpoints, error)
+}
+
 func getServicePort(namespace, service string) (int, error) {
-	services, err := getKubernetesServicesWithNamespace(namespace)
+	services, err := GetKubernetesServicesWithNamespace(namespace)
 	if err != nil {
 		return 0, err
 	}
@@ -586,7 +590,7 @@ func getServicePortFromServiceGetter(services serviceGetter, service string) (in
 	return nodePort, nil
 }
 
-func getKubernetesServicesWithNamespace(namespace string) (serviceGetter, error) {
+func GetKubernetesServicesWithNamespace(namespace string) (serviceGetter, error) {
 	loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
 	configOverrides := &clientcmd.ConfigOverrides{}
 	kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
@@ -601,3 +605,33 @@ func getKubernetesServicesWithNamespace(namespace string) (serviceGetter, error)
 	services := client.Services(namespace)
 	return services, nil
 }
+
+func GetKubernetesEndpointsWithNamespace(namespace string) (endpointGetter, error) {
+	loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
+	configOverrides := &clientcmd.ConfigOverrides{}
+	kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
+	config, err := kubeConfig.ClientConfig()
+	if err != nil {
+		return nil, fmt.Errorf("Error creating kubeConfig: %s", err)
+	}
+	client, err := unversioned.New(config)
+	if err != nil {
+		return nil, err
+	}
+	endpoints := client.Endpoints(namespace)
+	return endpoints, nil
+}
+
+// EnsureMinikubeRunningOrExit checks that minikube has a status available and that
+// that the status is `Running`, otherwise it will exit
+func EnsureMinikubeRunningOrExit(api libmachine.API) {
+	s, err := GetHostStatus(api)
+	if err != nil {
+		glog.Errorln("Error getting machine status:", err)
+		os.Exit(1)
+	}
+	if s != state.Running.String() {
+		fmt.Fprintln(os.Stdout, "minikube is not currently running so the service cannot be accessed")
+		os.Exit(1)
+	}
+}