feat: add DevSpace sleep mode handling

Author: FabianKramm

pkg/devspace/config/loader/imports.go

@@ -3,16 +3,15 @@ package loader
 import (
 	"context"
 	"fmt"
-	"io/ioutil"
-	"path/filepath"
-
 	"github.com/loft-sh/devspace/pkg/devspace/config/loader/variable"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/util"
 	dependencyutil "github.com/loft-sh/devspace/pkg/devspace/dependency/util"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/loft-sh/devspace/pkg/util/yamlutil"
 	"github.com/pkg/errors"
+	"io/ioutil"
+	"path/filepath"
 )
 
 var ImportSections = []string{

pkg/devspace/config/loader/loader.go

@@ -3,7 +3,11 @@ package loader
 import (
 	"context"
 	"fmt"
+	"github.com/loft-sh/devspace/pkg/devspace/config/localcache"
+	"github.com/loft-sh/devspace/pkg/devspace/config/remotecache"
 	"github.com/loft-sh/devspace/pkg/devspace/context/values"
+	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
+	"github.com/loft-sh/devspace/pkg/util/command"
 	"github.com/loft-sh/devspace/pkg/util/encoding"
 	"github.com/loft-sh/devspace/pkg/util/yamlutil"
 	"io/ioutil"
@@ -13,11 +17,6 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/loft-sh/devspace/pkg/devspace/config/localcache"
-	"github.com/loft-sh/devspace/pkg/devspace/config/remotecache"
-	"github.com/loft-sh/devspace/pkg/devspace/kubectl"
-	"github.com/loft-sh/devspace/pkg/util/command"
-
 	"github.com/loft-sh/devspace/pkg/util/constraint"
 
 	"github.com/loft-sh/devspace/pkg/devspace/plugin"

pkg/devspace/config/loader/parser.go

@@ -125,7 +125,7 @@ func fillVariablesExcludeAndParse(ctx context.Context, resolver variable.Resolve
 }
 
 func fillVariablesAndParse(ctx context.Context, resolver variable.Resolver, preparedConfig map[string]interface{}, log log.Logger, excludedPaths ...string) (*latest.Config, map[string]interface{}, error) {
-	// fill in variables and expressions (leave out
+	// fill in variables and expressions
 	preparedConfigInterface, err := resolver.FillVariablesExclude(ctx, preparedConfig, excludedPaths)
 	if err != nil {
 		return nil, nil, err

pkg/devspace/devpod/devpod.go

@@ -166,7 +166,9 @@ func (d *devPod) startWithRetry(ctx devspacecontext.Context, devPodConfig *lates
 				return true, nil
 			}, ctx.Context().Done())
 			if err != nil {
-				ctx.Log().Errorf("error restarting dev: %v", err)
+				if err != wait.ErrWaitTimeout {
+					ctx.Log().Errorf("error restarting dev: %v", err)
+				}
 			} else if shouldRestart {
 				d.restart(ctx, devPodConfig, options)
 				return

pkg/devspace/kubectl/client.go

@@ -6,16 +6,16 @@ import (
 	"github.com/loft-sh/devspace/pkg/devspace/config/localcache"
 	"github.com/loft-sh/devspace/pkg/devspace/kubectl/util"
 	"github.com/loft-sh/devspace/pkg/devspace/upgrade"
-	"io"
-	"net"
-	"net/url"
-	"os"
-	"sort"
-
+	"github.com/loft-sh/devspace/pkg/util/idle"
 	"github.com/loft-sh/devspace/pkg/util/kubeconfig"
 	"github.com/loft-sh/devspace/pkg/util/log"
 	"github.com/loft-sh/devspace/pkg/util/survey"
 	"github.com/loft-sh/devspace/pkg/util/terminal"
+	"io"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"net/http"
+	"os"
+	"time"
 
 	"github.com/mgutz/ansi"
 	"github.com/pkg/errors"
@@ -27,6 +27,10 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 )
 
+var (
+	stopPingAfter = time.Second * 600
+)
+
 // Client holds all kubernetes related functions
 type Client interface {
 	// CurrentContext returns the current kube context name
@@ -108,6 +112,17 @@ func NewClientFromContext(context, namespace string, switchContext bool, kubeLoa
 		return nil, err
 	}
 	restConfig.UserAgent = "DevSpace Version " + upgrade.GetVersion()
+	restConfig.WrapTransport = func(rt http.RoundTripper) http.RoundTripper {
+		return &devSpaceRoundTripper{
+			roundTripper: rt,
+			requestType:  "Regular",
+			callback: func(response *http.Response) {
+				if response.Header.Get("X-DevSpace-Response-Type") == "Blocked" {
+					log.GetInstance().Fatalf("Targeted Kubernetes environment has begun sleeping. Please restart DevSpace to wake up the environment")
+				}
+			},
+		}
+	}
 
 	kubeClient, err := kubernetes.NewForConfig(restConfig)
 	if err != nil {
@@ -126,56 +141,6 @@ func NewClientFromContext(context, namespace string, switchContext bool, kubeLoa
 	}, nil
 }
 
-// NewClientBySelect creates a new kubernetes client by user select @Factory
-func NewClientBySelect(allowPrivate bool, switchContext bool, kubeLoader kubeconfig.Loader, log log.Logger) (Client, error) {
-	kubeConfig, err := kubeLoader.LoadRawConfig()
-	if err != nil {
-		return nil, err
-	}
-
-	// Get all kube contexts
-	options := make([]string, 0, len(kubeConfig.Contexts))
-	for context := range kubeConfig.Contexts {
-		options = append(options, context)
-	}
-	if len(options) == 0 {
-		return nil, errors.New("No kubectl context found. Make sure kubectl is installed and you have a working kubernetes context configured")
-	}
-
-	sort.Strings(options)
-	for {
-		kubeContext, err := log.Question(&survey.QuestionOptions{
-			Question:     "Which kube context do you want to use",
-			DefaultValue: kubeConfig.CurrentContext,
-			Options:      options,
-		})
-		if err != nil {
-			return nil, err
-		}
-
-		// Check if cluster is in private network
-		if !allowPrivate {
-			context := kubeConfig.Contexts[kubeContext]
-			cluster := kubeConfig.Clusters[context.Cluster]
-
-			url, err := url.Parse(cluster.Server)
-			if err != nil {
-				return nil, errors.Wrap(err, "url parse")
-			}
-
-			ip := net.ParseIP(url.Hostname())
-			if ip != nil {
-				if IsPrivateIP(ip) {
-					log.Infof("Clusters with private ips (%s) cannot be used", url.Hostname())
-					continue
-				}
-			}
-		}
-
-		return NewClientFromContext(kubeContext, "", switchContext, kubeLoader)
-	}
-}
-
 // ClientConfig returns the underlying kube client config
 func (client *client) ClientConfig() clientcmd.ClientConfig {
 	return client.clientConfig
@@ -312,7 +277,17 @@ func CheckKubeContext(client Client, localCache localcache.Cache, noWarning, aut
 	log.Infof("Using namespace '%s'", ansi.Color(currentConfigContext.Namespace, "white+b"))
 	log.Infof("Using kube context '%s'", ansi.Color(currentConfigContext.Context, "white+b"))
 	if resetClient {
-		return NewClientFromContext(currentConfigContext.Context, currentConfigContext.Namespace, true, client.KubeConfigLoader())
+		var err error
+		client, err = NewClientFromContext(currentConfigContext.Context, currentConfigContext.Namespace, true, client.KubeConfigLoader())
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// wake up and ping
+	err := wakeUpAndPing(context.TODO(), client, log)
+	if err != nil {
+		return nil, errors.Wrap(err, "wakeup environment")
 	}
 
 	return client, nil
@@ -337,3 +312,127 @@ func (client *client) RestConfig() *rest.Config {
 func (client *client) KubeConfigLoader() kubeconfig.Loader {
 	return client.kubeLoader
 }
+
+func wakeUpAndPing(ctx context.Context, client Client, log log.Logger) error {
+	err := wakeUp(ctx, client, log)
+	if err != nil {
+		return err
+	}
+
+	// create ping config
+	pingConfig := rest.CopyConfig(client.RestConfig())
+	pingConfig.WrapTransport = func(rt http.RoundTripper) http.RoundTripper {
+		return &devSpaceRoundTripper{
+			roundTripper: rt,
+			requestType:  "Ping",
+			callback: func(response *http.Response) {
+				if response.Header.Get("X-DevSpace-Response-Type") == "Blocked" {
+					log.Fatalf("Targeted Kubernetes environment has begun sleeping. Please restart DevSpace to wake up the environment")
+				}
+			},
+		}
+	}
+
+	// create kube client
+	kubeClient, err := kubernetes.NewForConfig(pingConfig)
+	if err != nil {
+		return err
+	}
+
+	// start pinging
+	go func() {
+		getter, _ := idle.NewIdleGetter()
+		wait.UntilWithContext(ctx, func(ctx context.Context) {
+			if getter != nil {
+				amountIdle, err := getter.Idle()
+				if err == nil && amountIdle > stopPingAfter {
+					return
+				}
+			}
+
+			_, err = kubeClient.CoreV1().Pods(client.Namespace()).List(ctx, metav1.ListOptions{LabelSelector: "devspace=ping"})
+			if err != nil {
+				log.Debugf("Error pinging Kubernetes environment: %v", err)
+			}
+		}, time.Minute*3)
+	}()
+
+	return nil
+}
+
+func wakeUp(ctx context.Context, client Client, log log.Logger) error {
+	// check if environment is sleeping
+	var isSleeping bool
+	isSleepingConfig := rest.CopyConfig(client.RestConfig())
+	isSleepingConfig.WrapTransport = func(rt http.RoundTripper) http.RoundTripper {
+		return &devSpaceRoundTripper{
+			roundTripper: rt,
+			requestType:  "Ping",
+			callback: func(response *http.Response) {
+				if response.Header.Get("X-DevSpace-Response-Type") == "Blocked" {
+					isSleeping = true
+				}
+			},
+		}
+	}
+
+	// create kube client
+	kubeClient, err := kubernetes.NewForConfig(isSleepingConfig)
+	if err != nil {
+		return err
+	}
+
+	// wake up the environment
+	_, err = kubeClient.CoreV1().Pods(client.Namespace()).List(ctx, metav1.ListOptions{LabelSelector: "devspace=wakeup"})
+	if err != nil && !isSleeping {
+		return fmt.Errorf("Please make sure you have an existing valid kube config. You might want to check one of the following things:\n\n* Make sure you can use 'kubectl get namespaces' locally\n* If you are using Loft, you might want to run 'devspace create space' or 'loft create space'")
+	} else if !isSleeping {
+		return nil
+	}
+
+	// wake up the environment
+	wakeUpConfig := rest.CopyConfig(client.RestConfig())
+	wakeUpConfig.WrapTransport = func(rt http.RoundTripper) http.RoundTripper {
+		return &devSpaceRoundTripper{
+			roundTripper: rt,
+			requestType:  "WakeUp",
+			callback: func(response *http.Response) {
+				if response.Header.Get("X-DevSpace-Response-Type") == "WokenUp" {
+					log.Infof("Successfully woken up Kubernetes environment")
+				}
+			},
+		}
+	}
+
+	// create kube client
+	kubeClient, err = kubernetes.NewForConfig(wakeUpConfig)
+	if err != nil {
+		return err
+	}
+
+	// print message if it takes too long
+	log.Infof("DevSpace is waking up the Kubernetes environment, please wait a second...")
+
+	// wake up the environment
+	_, err = kubeClient.CoreV1().Pods(client.Namespace()).List(ctx, metav1.ListOptions{LabelSelector: "devspace=wakeup"})
+	if err != nil {
+		return errors.Wrap(err, "error waking up the environment")
+	}
+
+	return nil
+}
+
+type devSpaceRoundTripper struct {
+	roundTripper http.RoundTripper
+	requestType  string
+	callback     func(response *http.Response)
+}
+
+func (d *devSpaceRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	req.Header.Set("X-DevSpace-Request-Type", d.requestType)
+	response, err := d.roundTripper.RoundTrip(req)
+	if response != nil && d.callback != nil {
+		d.callback(response)
+	}
+	return response, err
+}

pkg/devspace/kubectl/util/util.go

@@ -1,15 +1,14 @@
 package util
 
 import (
-	"io/ioutil"
-	"os"
-
 	"github.com/loft-sh/devspace/pkg/util/kubeconfig"
 	"github.com/pkg/errors"
+	"io/ioutil"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
+	"os"
 )
 
 const localContext = "incluster"

pkg/devspace/services/logs/logs.go

@@ -65,6 +65,7 @@ func StartLogs(
 		lines = devContainer.Logs.LastLines
 	}
 
+	ctx.Log().Infof("Streaming logs of pod:container %s:%s", ansi.Color(containerObj.Pod.Name, "white+b"), ansi.Color(containerObj.Container.Name, "white+b"))
 	reader, err := ctx.KubeClient().Logs(ctx.Context(), containerObj.Pod.Namespace, containerObj.Pod.Name, containerObj.Container.Name, false, &lines, true)
 	if err != nil {
 		return err

pkg/util/downloader/commands/kubectl.go

@@ -63,7 +63,13 @@ func (k *kubectlCommand) DownloadURL() string {
 }
 
 func (k *kubectlCommand) IsValid(ctx context.Context, path string) (bool, error) {
-	out, err := command.Output(ctx, "", expand.ListEnviron(os.Environ()...), path, "version", "--client")
+	environ := []string{}
+	environ = append(environ, os.Environ()...)
+	// this is a hack because kubectl sometimes tries to reach the server anyways, so
+	// we make sure this is not gonna actually contact the server
+	environ = append(environ, "KUBECONFIG=does-not-exist.yaml")
+
+	out, err := command.Output(ctx, "", expand.ListEnviron(environ...), path, "version", "--client")
 	if err != nil {
 		return false, nil
 	}

pkg/util/factory/factory.go

@@ -31,7 +31,6 @@ type Factory interface {
 	// NewKubeDefaultClient creates a new kube client
 	NewKubeDefaultClient() (kubectl.Client, error)
 	NewKubeClientFromContext(context, namespace string) (kubectl.Client, error)
-	NewKubeClientBySelect(allowPrivate bool, switchContext bool, log log.Logger) (kubectl.Client, error)
 
 	// NewHelmClient creates a new helm client
 	NewHelmClient(log log.Logger) (types.Client, error)
@@ -140,12 +139,6 @@ func (f *DefaultFactoryImpl) NewKubeClientFromContext(context, namespace string)
 	return client, nil
 }
 
-// NewKubeClientBySelect implements interface
-func (f *DefaultFactoryImpl) NewKubeClientBySelect(allowPrivate bool, switchContext bool, log log.Logger) (kubectl.Client, error) {
-	kubeLoader := f.NewKubeConfigLoader()
-	return kubectl.NewClientBySelect(allowPrivate, switchContext, kubeLoader, log)
-}
-
 // NewHelmClient implements interface
 func (f *DefaultFactoryImpl) NewHelmClient(log log.Logger) (types.Client, error) {
 	return helm.NewClient(log)

pkg/util/factory/testing/factory.go

@@ -112,11 +112,6 @@ func (f *Factory) NewKubeClientFromContext(context, namespace string) (kubectl.C
 	return f.KubeClient, nil
 }
 
-// NewKubeClientBySelect implements interface
-func (f *Factory) NewKubeClientBySelect(allowPrivate bool, switchContext bool, log log.Logger) (kubectl.Client, error) {
-	return f.KubeClient, nil
-}
-
 // NewHelmClient implements interface
 func (f *Factory) NewHelmClient(log log.Logger) (types.Client, error) {
 	return f.HelmClient, nil