Simplify daemon error handling and remove unused code.

Signed-off-by: Thomas Hallgren <thomas@tada.se>

Author: thallgren

integration_test/tls_test.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 	"path/filepath"
+	"regexp"
+	"strings"
 	"sync"
 	"time"
 
@@ -200,25 +202,30 @@ func (s *dockerDaemonSuite) Test_TLSAnnotations() {
 			rq.True(len(si.UserDaemon.Intercepts) == 1)
 			rq.Equal(si.UserDaemon.Intercepts[0].Name, ttSvc)
 
-			args := []string{"curl", "--max-time", "2", "-s", "-w", "\nStatus: %{http_code}\n", "-k"}
-			if tt.header != "" {
-				args = append(args, "-H", tt.header)
-			}
-			args = append(args, fmt.Sprintf("https://%s", ttSvc))
-			so, se, err := itest.Telepresence(ctx, args...)
-			s.NoError(err)
-			if se != "" {
-				clog.Error(ctx, se)
-			}
-			if tt.errorPattern != "" {
-				s.Regexp(tt.errorPattern, so)
-			} else {
-				s.Contains(so, "HTTP/2.0 GET /")
-			}
-			clog.Info(ctx, so)
+			rq.EventuallyContext(ctx, func() bool {
+				args := []string{"curl", "--max-time", "2", "-s", "-w", "\nStatus: %{http_code}\n", "-k"}
+				if tt.header != "" {
+					args = append(args, "-H", tt.header)
+				}
+				args = append(args, fmt.Sprintf("https://%s", ttSvc))
+				so, se, err := itest.Telepresence(ctx, args...)
+				if err != nil {
+					if se != "" {
+						clog.Error(ctx, se)
+					}
+					clog.Error(ctx, err)
+					return false
+				}
+				clog.Info(ctx, so)
+				if tt.errorPattern != "" {
+					ok, err := regexp.MatchString(tt.errorPattern, so)
+					return err == nil && ok
+				}
+				return strings.Contains(so, "HTTP/2.0 GET /")
+			}, 10*time.Second, 3*time.Second, "expected curl response never arrived")
 
 			// Terminate the ongoing intercept
-			so, se, err = itest.Telepresence(ctx, "leave", ttSvc)
+			so, se, err := itest.Telepresence(ctx, "leave", ttSvc)
 			if so != "" {
 				clog.Info(ctx, so)
 			}

pkg/client/cli/cmd/version.go

@@ -141,13 +141,13 @@ func managerVersion(ctx context.Context) (*common.VersionInfo, error) {
 		mv, err := userD.TrafficManagerVersion(ctx, &empty.Empty{})
 		return mv, tpGrpc.FromGRPC(err)
 	}
-	return nil, connect.ErrNoUserDaemon
+	return nil, daemon.ErrNoUserDaemon
 }
 
 func trafficAgentFQN(ctx context.Context) (*manager.AgentImageFQN, error) {
 	if userD := daemon.GetUserClient(ctx); userD != nil {
 		ai, err := userD.AgentImageFQN(ctx, &empty.Empty{})
 		return ai, tpGrpc.FromGRPC(err)
 	}
-	return nil, connect.ErrNoUserDaemon
+	return nil, daemon.ErrNoUserDaemon
 }

pkg/client/cli/connect/connector.go

@@ -44,8 +44,6 @@ import (
 	"github.com/telepresenceio/telepresence/v2/pkg/types"
 )
 
-var ErrNoUserDaemon = errors.New("telepresence user daemon is not running")
-
 //nolint:gochecknoglobals // extension point
 var QuitDaemonFuncs = []func(context.Context){
 	quitHostConnector, quitDockerDaemons,
@@ -83,7 +81,7 @@ func findHostConnectorInfo(ctx context.Context) (*daemon.Info, error) {
 			return info, nil
 		}
 	}
-	return nil, fs.ErrNotExist
+	return nil, fmt.Errorf("unable to find host connector info: %w", fs.ErrNotExist)
 }
 
 func quitHostConnector(ctx context.Context) {
@@ -158,7 +156,7 @@ func EnsureUserDaemon(ctx context.Context, required bool) (rc context.Context, e
 			// The RootDaemon must be started if the UserDaemon was started
 			err = EnsureRootDaemonRunning(ctx)
 		}
-		if err != nil && !(errors.Is(err, ErrNoUserDaemon) && !required) {
+		if err != nil && !(errors.Is(err, daemon.ErrNoUserDaemon) && !required) {
 			err = progress.MaybeWriteError(ctx, err)
 		} else if launched {
 			progress.PrintDone(ctx, "Launched Daemon")
@@ -481,7 +479,7 @@ func findOrLaunchConnectorDaemon(ctx context.Context, daemonID *daemon.Identifie
 		return ctx, false, errcat.NoDaemonLogs.New(err)
 	}
 	if !required {
-		return ctx, false, ErrNoUserDaemon
+		return ctx, false, daemon.ErrNoUserDaemon
 	}
 	ctx = progress.WithEventId(ctx, daemonID.Name)
 	progress.Working(ctx, "Launching Daemon")

pkg/client/cli/connect/init_command.go

@@ -62,7 +62,7 @@ func InitCommand(cmd *cobra.Command) (err error) {
 		progressStarted = true
 		ctx, err = EnsureUserDaemon(ctx, v == ann.Required)
 		if err != nil {
-			if v == ann.Optional && (errors.Is(err, ErrNoUserDaemon) || errcat.GetCategory(err) == errcat.Config) {
+			if v == ann.Optional && (errors.Is(err, daemon.ErrNoUserDaemon) || errcat.GetCategory(err) == errcat.Config) {
 				// This is OK, but further initialization is not possible
 				err = nil
 			}

pkg/client/cli/daemon/dial.go

@@ -11,6 +11,8 @@ const InfoFileName = "daemon.json"
 
 var ErrNoRootDaemon = errors.New("telepresence root daemon is not running")
 
+var ErrNoUserDaemon = errors.New("telepresence user daemon is not running")
+
 func DialRootDaemon(ctx context.Context, waitForConnect bool) (conn *grpc.ClientConn, err error) {
 	if ri, err := LoadRootServiceInfo(ctx); err == nil {
 		return dialDaemon(ctx, "root", ri.DaemonPort)

pkg/client/cli/daemon/info.go

@@ -194,16 +194,26 @@ func (il *InfoLoader[T]) DialDaemon(ctx context.Context, waitForConnect bool) (c
 	}
 	defer cancel()
 	if err != nil {
-		return nil, fs.ErrNotExist
+		return nil, err
 	}
+
+	var daemonName string
+	var daemonPort uint16
 	if ii, ok := any(info).(*Info); ok {
-		conn, err = dialDaemon(ctx, "user", ii.DaemonPort)
+		daemonName = "user"
+		daemonPort = ii.DaemonPort
 	} else {
-		conn, err = dialDaemon(ctx, "root", (any(info).(*RootInfo)).DaemonPort)
+		daemonName = "root"
+		daemonPort = (any(info).(*RootInfo)).DaemonPort
 	}
+	conn, err = dialDaemon(ctx, daemonName, daemonPort)
 	if errors.Is(err, context.DeadlineExceeded) && !waitForConnect {
 		// A race may occur where the daemon is shutting down. We found the info file, but the daemon has since stopped responding.
-		err = fs.ErrNotExist
+		if daemonName == "user" {
+			err = ErrNoUserDaemon
+		} else {
+			err = ErrNoRootDaemon
+		}
 	}
 	return conn, err
 }
@@ -252,7 +262,7 @@ func (il *InfoLoader[T]) deleteIfStale(name string, fi fs.FileInfo) error {
 		if err := cache.DeleteFromUserCache(il.ctx, name); err != nil {
 			return err
 		}
-		return fs.ErrNotExist
+		return fmt.Errorf("%s: %w (file stale and removed)", name, fs.ErrNotExist)
 	}
 	return nil
 }
@@ -306,7 +316,12 @@ func (il *InfoLoader[T]) LoadMatchingInfo(match *regexp.Regexp) (*T, error) {
 	}
 	switch len(infos) {
 	case 0:
-		return nil, os.ErrNotExist
+		if match == nil {
+			err = fmt.Errorf("unable to find daemon info matching %s: %w", match, os.ErrNotExist)
+		} else {
+			err = fmt.Errorf("unable to find daemon info: %w", os.ErrNotExist)
+		}
+		return nil, err
 	case 1:
 		return infos[0], nil
 	default:

pkg/client/cli/docker/compose/config.go

@@ -20,7 +20,6 @@ import (
 	"github.com/telepresenceio/clog"
 	"github.com/telepresenceio/telepresence/cmd/cobraparser/v2/generate"
 	"github.com/telepresenceio/telepresence/cmd/cobraparser/v2/types"
-	"github.com/telepresenceio/telepresence/v2/pkg/client/cli/connect"
 	"github.com/telepresenceio/telepresence/v2/pkg/client/cli/daemon"
 	"github.com/telepresenceio/telepresence/v2/pkg/client/cli/flags"
 	"github.com/telepresenceio/telepresence/v2/pkg/client/cli/global"
@@ -256,7 +255,7 @@ func (c *config) run(cmd *cobra.Command) (err error) {
 	progress.Start(ctx, "Connecting")
 	existingComposeFile, err := c.connect(ctx, es, connections)
 	if err != nil {
-		if c.mustBeConnected && errors.Is(err, connect.ErrNoUserDaemon) {
+		if c.mustBeConnected && errors.Is(err, daemon.ErrNoUserDaemon) {
 			// The daemon is not running, although the command expects it to. This means that no services should be running either.
 			// So let's just run the command without any extensions so that docker compose produces the expected error output.
 			err = tr.runCommand(ctx, name)

pkg/client/cli/docker/runner.go

@@ -15,7 +15,6 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/cenkalti/backoff/v4"
 	"github.com/containerd/errdefs"
 
 	"github.com/telepresenceio/clog"
@@ -314,23 +313,3 @@ func EnsureStopContainer(ctx context.Context, name, containerID string, volumes
 	}
 	done <- err
 }
-
-// ReadContainerID reads the containerID that docker run --cidfile <cidfils> writes to a file, and then
-// removes the file. It returns fs.ErrNotExist if no such file has been produced within 200 ms.
-func ReadContainerID(ctx context.Context, cidFile string) (containerID string, err error) {
-	defer func() {
-		_ = os.Remove(cidFile)
-	}()
-	err = backoff.Retry(func() error {
-		cid, err := os.ReadFile(cidFile)
-		if err != nil {
-			return err
-		}
-		if len(cid) == 0 {
-			return fs.ErrNotExist
-		}
-		containerID = string(cid)
-		return nil
-	}, backoff.WithContext(backoff.WithMaxRetries(backoff.NewConstantBackOff(10*time.Millisecond), 200), ctx))
-	return containerID, err
-}

pkg/client/docker/daemon.go

@@ -274,7 +274,7 @@ func readPortFile(ctx context.Context, portFile string, configFiles []string) (u
 	if err := os.Remove(portFile); err != nil {
 		return 0, err
 	}
-	return 0, os.ErrNotExist
+	return 0, fmt.Errorf("%s: %w", portFile, os.ErrNotExist)
 }
 
 func startAuthenticatorService(ctx context.Context, portFile string, kubeFlags map[string]string, configFiles []string) (uint16, error) {