feat(pro): reopen devpod desktop if daemon is not reachable and user tries to ssh into workspace

Author: pascalbreuninger

cmd/ssh.go

@@ -156,6 +156,12 @@ func (cmd *SSHCmd) jumpContainerTailscale(
 	log log.Logger,
 ) error {
 	log.Debugf("Starting tailscale connection")
+
+	err := client.CheckWorkspaceReachable(ctx)
+	if err != nil {
+		return err
+	}
+
 	toolSSHClient, sshClient, err := client.SSHClients(ctx, cmd.User)
 	if err != nil {
 		return err

pkg/client/client.go

@@ -81,6 +81,9 @@ type DaemonClient interface {
 	// SSHClients returns an SSH client for the tool and one for the actual user
 	SSHClients(ctx context.Context, user string) (*ssh.Client, *ssh.Client, error)
 
+	// CheckWorkspaceReachable checks if the given workspace is reachable from the current machine
+	CheckWorkspaceReachable(ctx context.Context) error
+
 	// DirectTunnel forwards stdio to the workspace
 	DirectTunnel(ctx context.Context, stdin io.Reader, stdout io.Writer) error
 

pkg/client/clientimplementation/daemonclient/client.go

@@ -22,6 +22,7 @@ import (
 	"github.com/loft-sh/devpod/pkg/ts"
 	"github.com/loft-sh/log"
 	perrors "github.com/pkg/errors"
+	"github.com/skratchdot/open-golang/open"
 	"golang.org/x/crypto/ssh"
 	"tailscale.com/client/tailscale"
 	"tailscale.com/tailcfg"
@@ -123,28 +124,55 @@ func (c *client) RefreshOptions(ctx context.Context, userOptionsRaw []string, re
 	return nil
 }
 
-func (c *client) SSHClients(ctx context.Context, user string) (toolClient *ssh.Client, userClient *ssh.Client, err error) {
+func (c *client) CheckWorkspaceReachable(ctx context.Context) error {
 	wAddr, err := c.getWorkspaceAddress()
 	if err != nil {
-		return nil, nil, fmt.Errorf("resolve workspace hostname: %w", err)
+		return fmt.Errorf("resolve workspace hostname: %w", err)
 	}
-
-	err = ts.WaitHostReachable(ctx, c.tsClient, wAddr, c.log)
+	err = ts.WaitHostReachable(ctx, c.tsClient, wAddr, 5, false, c.log)
 	if err != nil {
 		instance, getWorkspaceErr := c.localClient.GetWorkspace(ctx, c.workspace.UID)
+		// if we can't reach the daemon try to start the desktop app
+		if daemon.IsDaemonNotAvailableError(getWorkspaceErr) {
+			deeplink := fmt.Sprintf("devpod://open?workspace=%s&provider=%s&source=%s&ide=%s", c.workspace.ID, c.config.Name, c.workspace.Source.String(), c.workspace.IDE.Name)
+			openErr := open.Run(deeplink)
+			if openErr != nil {
+				return getWorkspaceErr // inform user about daemon state
+			}
+			// give desktop app a chance to start
+			time.Sleep(2 * time.Second)
+
+			// let's try again
+			err = ts.WaitHostReachable(ctx, c.tsClient, wAddr, 20, true, c.log)
+			if err != nil {
+				instance, getWorkspaceErr = c.localClient.GetWorkspace(ctx, c.workspace.UID)
+			} else {
+				return nil
+			}
+		}
+
 		if getWorkspaceErr != nil {
-			return nil, nil, fmt.Errorf("couldn't get workspace: %w", getWorkspaceErr)
+			return fmt.Errorf("couldn't get workspace: %w", getWorkspaceErr)
 		} else if instance.Status.Phase != storagev1.InstanceReady {
-			return nil, nil, fmt.Errorf("workspace is '%s', please run `devpod up %s` to start it again", instance.Status.Phase, c.workspace.ID)
+			return fmt.Errorf("workspace is '%s', please run `devpod up %s` to start it again", instance.Status.Phase, c.workspace.ID)
 		} else if instance.Status.LastWorkspaceStatus != storagev1.WorkspaceStatusRunning {
-			return nil, nil, fmt.Errorf("workspace is '%s', please run `devpod up %s` to start it again", instance.Status.LastWorkspaceStatus, c.workspace.ID)
+			return fmt.Errorf("workspace is '%s', please run `devpod up %s` to start it again", instance.Status.LastWorkspaceStatus, c.workspace.ID)
 		}
 
-		return nil, nil, fmt.Errorf("reach host: %w", err)
+		return fmt.Errorf("reach host: %w", err)
 	}
 
 	c.log.Debugf("Host %s is reachable. Proceeding with SSH session...", wAddr.Host())
 
+	return nil
+}
+
+func (c *client) SSHClients(ctx context.Context, user string) (toolClient *ssh.Client, userClient *ssh.Client, err error) {
+	wAddr, err := c.getWorkspaceAddress()
+	if err != nil {
+		return nil, nil, fmt.Errorf("resolve workspace hostname: %w", err)
+	}
+
 	toolClient, err = ts.WaitForSSHClient(ctx, c.tsClient, wAddr.Host(), wAddr.Port(), "root", c.log)
 	if err != nil {
 		return nil, nil, fmt.Errorf("create SSH tool client: %w", err)

pkg/daemon/platform/client.go

@@ -149,7 +149,7 @@ func (c *LocalClient) doRequest(ctx context.Context, method string, path string,
 	res, err := c.httpClient.Do(req)
 	if err != nil {
 		if isConnectToDaemonError(err) {
-			return nil, daemonNotAvailableError{Err: err, Provider: c.provider}
+			return nil, &DaemonNotAvailableError{Err: err, Provider: c.provider}
 		}
 
 		return nil, err

pkg/daemon/platform/error.go

@@ -1,20 +1,29 @@
 package daemon
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 
 	"github.com/loft-sh/devpod/pkg/platform/client"
 )
 
-type daemonNotAvailableError struct {
+type DaemonNotAvailableError struct {
 	Err      error
 	Provider string
 }
 
-func (e daemonNotAvailableError) Error() string {
+func (e *DaemonNotAvailableError) Error() string {
 	return fmt.Sprintf("The DevPod Daemon for provider %s isn't reachable. Is DevPod Desktop or `devpod pro daemon start --host=$YOUR_PRO_HOST` running? %v", e.Provider, e.Err)
 }
+func (e *DaemonNotAvailableError) Unwrap() error {
+	return e.Err
+}
+
+func IsDaemonNotAvailableError(err error) bool {
+	var e *DaemonNotAvailableError
+	return errors.As(err, &e)
+}
 
 func IsAccessKeyNotFound(err error) bool {
 	// we have to check against the string because the error is coming from the server

pkg/ts/util.go

@@ -49,9 +49,7 @@ func GetURL(host string, port int) string {
 }
 
 // WaitHostReachable polls until the given host is reachable via ts.
-func WaitHostReachable(ctx context.Context, lc *tailscale.LocalClient, addr Addr, log log.Logger) error {
-	const maxRetries = 20
-
+func WaitHostReachable(ctx context.Context, lc *tailscale.LocalClient, addr Addr, maxRetries int, withDelay bool, log log.Logger) error {
 	for i := 0; i < maxRetries; i++ {
 		timeoutCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
 		defer cancel()
@@ -61,6 +59,9 @@ func WaitHostReachable(ctx context.Context, lc *tailscale.LocalClient, addr Addr
 			return nil // Host is reachable
 		}
 		log.Debugf("Host %s not reachable, retrying... (%d/%d)", addr.String(), i+1, maxRetries)
+		if withDelay {
+			time.Sleep(200 * time.Millisecond)
+		}
 
 		select {
 		case <-ctx.Done():

pkg/ts/workspace_server.go

@@ -29,6 +29,8 @@ import (
 const (
 	// TSPortForwardPort is the fixed port on which the workspace WebSocket reverse proxy listens.
 	TSPortForwardPort string = "12051"
+
+	netMapCooldown = 30 * time.Second
 )
 
 // WorkspaceServer holds the TSNet server and its listeners.
@@ -84,21 +86,24 @@ func (s *WorkspaceServer) Start(ctx context.Context) error {
 		return err
 	}
 
-	// debug: write the netmap to a file
-	if os.Getenv("DEVPOD_DEBUG_DAEMON") == "true" {
-		go func() {
-			if err := WatchNetmap(ctx, lc, func(netMap *netmap.NetworkMap) {
-				nm, err := json.Marshal(netMap)
-				if err != nil {
-					s.log.Errorf("Failed to marshal netmap: %v", err)
-				} else {
-					_ = os.WriteFile(filepath.Join(s.config.RootDir, "netmap.json"), nm, 0o644)
-				}
-			}); err != nil {
-				s.log.Errorf("Failed to watch netmap: %v", err)
+	go func() {
+		lastUpdate := time.Now()
+		if err := WatchNetmap(ctx, lc, func(netMap *netmap.NetworkMap) {
+			if time.Since(lastUpdate) < netMapCooldown {
+				return
 			}
-		}()
-	}
+			lastUpdate = time.Now()
+
+			nm, err := json.Marshal(netMap)
+			if err != nil {
+				s.log.Errorf("Failed to marshal netmap: %v", err)
+			} else {
+				_ = os.WriteFile(filepath.Join(s.config.RootDir, "netmap.json"), nm, 0o644)
+			}
+		}); err != nil {
+			s.log.Errorf("Failed to watch netmap: %v", err)
+		}
+	}()
 
 	// Wait until the context is canceled.
 	<-ctx.Done()