Uniformize error messages.

client/jobfile/reader.go

@@ -39,21 +39,21 @@ func Read(file string, options ReadOptions) (job *proto.Job, err error) {
 
 	var buf []byte
 	if buf, err = os.ReadFile(file); err != nil {
-		return nil, fmt.Errorf("read file: %w", err)
+		return nil, fmt.Errorf("failed to read file: %w", err)
 	}
 
 	source, err := evaluateTemplate(string(buf), workDir, options)
 	if err != nil {
-		return nil, fmt.Errorf("evaluate template: %w", err)
+		return nil, fmt.Errorf("failed to evaluate template: %w", err)
 	}
 
 	var jobfile Jobfile
 	if err = yaml.Unmarshal([]byte(source), &jobfile); err != nil {
-		return nil, UnmarshalError{fmt.Errorf("unmarshal: %w", err), source}
+		return nil, UnmarshalError{fmt.Errorf("failed to unmarshal jobfile: %w", err), source}
 	}
 	jobfile.path = workDir
 	if err = jobfile.Validate(); err != nil {
-		return nil, UnmarshalError{fmt.Errorf("validate: %w", err), source}
+		return nil, UnmarshalError{fmt.Errorf("failed to validate jobfile: %w", err), source}
 	}
 
 	job.Name = jobfile.Name
@@ -66,7 +66,7 @@ func Read(file string, options ReadOptions) (job *proto.Job, err error) {
 			step.Options,
 			options,
 		); err != nil {
-			return nil, fmt.Errorf("build (%d): %w", i+1, err)
+			return nil, fmt.Errorf("failed to build image for jobfile step (%d): %w", i+1, err)
 		}
 	}
 
@@ -204,7 +204,7 @@ func buildImage(dockerfile string, dir string, buildOptions []string, readOption
 	// Create a temporary file to store the image ID (@see --iidfile flag).
 	tmp, err := os.CreateTemp("", "alfred-image-id-")
 	if err != nil {
-		return "", fmt.Errorf("create temp file: %w", err)
+		return "", fmt.Errorf("failed to create temp file: %w", err)
 	}
 
 	// We can close the file descriptor because Docker will override the file anyway.
@@ -219,12 +219,12 @@ func buildImage(dockerfile string, dir string, buildOptions []string, readOption
 	cmd.Stderr = lo.Ternary(readOptions.Verbose, os.Stderr, nil)
 
 	if err := cmd.Run(); err != nil {
-		return "", fmt.Errorf("%w", err)
+		return "", fmt.Errorf("failed to build image: %w", err)
 	}
 
 	imageId, err := os.ReadFile(tmp.Name())
 	if err != nil {
-		return "", fmt.Errorf("read image id: %w", err)
+		return "", fmt.Errorf("failed to read image id: %w", err)
 	}
 
 	return string(imageId), nil

client/main.go

@@ -35,7 +35,7 @@ var alfredCmd = &cobra.Command{
 	PersistentPreRunE: func(cmd *cobra.Command, args []string) (err error) {
 		defer func() {
 			if err != nil {
-				err = fmt.Errorf("client connect: %w", err)
+				err = fmt.Errorf("failed to connect to gRPC client: %w", err)
 			}
 		}()
 
@@ -70,7 +70,7 @@ var alfredCmd = &cobra.Command{
 			}),
 		)
 		if err != nil {
-			return fmt.Errorf("dial: %w", err)
+			return fmt.Errorf("failed to dial gRPC: %w", err)
 		}
 
 		client = proto.NewAlfredClient(clientConn)

client/run.go

@@ -121,7 +121,7 @@ func sendImageToServer(cmd *cobra.Command, image string) error {
 		cmd.Stderr = os.Stderr
 		reader := lo.Must(cmd.StdoutPipe())
 		if err := cmd.Start(); err != nil {
-			return fmt.Errorf("docker save: %w", err)
+			return fmt.Errorf("failed to 'docker save' image '%s' locally: %w", image, err)
 		}
 		chunk := make([]byte, *resp.ChunkSize)
 		for {
@@ -134,7 +134,7 @@ func sendImageToServer(cmd *cobra.Command, image string) error {
 						},
 					})
 				} else {
-					return fmt.Errorf("read: %w", err)
+					return fmt.Errorf("failed to read docker image chunk: %w", err)
 				}
 			} else {
 				if err = c.Send(&proto.LoadImageMessage{
@@ -145,7 +145,7 @@ func sendImageToServer(cmd *cobra.Command, image string) error {
 						},
 					},
 				}); err != nil {
-					return fmt.Errorf("send: %w", err)
+					return fmt.Errorf("failed to send docker image chunk to server: %w", err)
 				}
 			}
 		}

client/sossh/dial.go

@@ -22,10 +22,10 @@ var _ net.Conn = (*SSHSocatConn)(nil)
 func (c *SSHSocatConn) Close() error {
 	c.cancel()
 	if err := c.ReadCloser.Close(); err != nil {
-		return fmt.Errorf("read close: %w", err)
+		return fmt.Errorf("failed to close ReadCloser: %w", err)
 	}
 	if err := c.WriteCloser.Close(); err != nil {
-		return fmt.Errorf("write close: %w", err)
+		return fmt.Errorf("failed to close WriteCloser: %w", err)
 	}
 	return nil
 }
@@ -84,7 +84,7 @@ func DialContext(ctx context.Context, network, addr, username, target string) (n
 
 	if err := cmd.Start(); err != nil {
 		cancel()
-		return nil, fmt.Errorf("start: %w", err)
+		return nil, fmt.Errorf("failed to start socat: %w", err)
 	}
 
 	return &SSHSocatConn{

provisioner/internal/docker.go

@@ -42,7 +42,7 @@ func RunContainer(
 	networkName := fmt.Sprintf("alfred-%s", task.FQN())
 	netResp, err := docker.NetworkCreate(ctx, networkName, types.NetworkCreate{Driver: "bridge"})
 	if err != nil {
-		return -1, fmt.Errorf("failed to create network: %w", err)
+		return -1, fmt.Errorf("failed to create docker network: %w", err)
 	}
 	networkId := netResp.ID
 	defer cleanup(
@@ -85,15 +85,15 @@ func RunContainer(
 			Filters: filters.NewArgs(filters.Arg("reference", service.Image)),
 		})
 		if err != nil {
-			return -1, fmt.Errorf("failed to list images for service '%s': %w", service.Name, err)
+			return -1, fmt.Errorf("failed to list docker images for service '%s': %w", service.Name, err)
 		}
 
 		// We only need to check that the list is non-empty, because we filtered by reference
 		if len(list) == 0 {
 			serviceLog.Debug("Pulling service image")
 			reader, err := docker.ImagePull(ctx, service.Image, types.ImagePullOptions{})
 			if err != nil {
-				return -1, fmt.Errorf("failed to pull image for service '%s': %w", service.Name, err)
+				return -1, fmt.Errorf("failed to pull docker image for service '%s': %w", service.Name, err)
 			}
 			defer reader.Close()
 
@@ -123,7 +123,7 @@ func RunContainer(
 			fmt.Sprintf("alfred-%s-%s", task.FQN(), service.Name),
 		)
 		if err != nil {
-			return -1, fmt.Errorf("failed to create container for service '%s': %w", service.Name, err)
+			return -1, fmt.Errorf("failed to create docker container for service '%s': %w", service.Name, err)
 		}
 		defer cleanup(
 			"service container",
@@ -150,7 +150,7 @@ func RunContainer(
 			containerId := serviceContainers[service.Name]
 			err := docker.ContainerStart(ctx, containerId, types.ContainerStartOptions{})
 			if err != nil {
-				serviceErrors <- fmt.Errorf("%s: failed to start container: %w", service.Name, err)
+				serviceErrors <- fmt.Errorf("failed to start docker container for service '%s': %w", service.Name, err)
 				return
 			}
 
@@ -175,7 +175,7 @@ func RunContainer(
 					AttachStdout: true, // We are piping stdout to io.Discard to "wait" for completion
 				})
 				if err != nil {
-					serviceErrors <- fmt.Errorf("%s: failed to create exec: %w", service.Name, err)
+					serviceErrors <- fmt.Errorf("failed to create docker exec for service '%s': %w", service.Name, err)
 					return
 				}
 
@@ -184,7 +184,7 @@ func RunContainer(
 				healthCheckLog.Debug("Running health check")
 				attach, err := docker.ContainerExecAttach(execCtx, exec.ID, types.ExecStartCheck{})
 				if err != nil {
-					serviceErrors <- fmt.Errorf("%s: failed to attach to exec: %w", service.Name, err)
+					serviceErrors <- fmt.Errorf("failed to attach docker exec for service '%s': %w", service.Name, err)
 					return
 				}
 
@@ -196,14 +196,14 @@ func RunContainer(
 				}()
 
 				if _, err := io.Copy(io.Discard, attach.Reader); err != nil && !healthCheckTimedOut {
-					serviceErrors <- fmt.Errorf("%s: failed during exec: %w", service.Name, err)
+					serviceErrors <- fmt.Errorf("failed during docker exec for service '%s': %w", service.Name, err)
 					return
 				}
 
 				if !healthCheckTimedOut {
 					inspect, err := docker.ContainerExecInspect(ctx, exec.ID)
 					if err != nil {
-						serviceErrors <- fmt.Errorf("%s: failed to inspect exec: %w", service.Name, err)
+						serviceErrors <- fmt.Errorf("failed to inspect docker exec for service '%s': %w", service.Name, err)
 						return
 					}
 					if inspect.ExitCode == 0 {
@@ -217,7 +217,7 @@ func RunContainer(
 				}
 			}
 
-			serviceErrors <- fmt.Errorf("%s: health check failed", service.Name)
+			serviceErrors <- fmt.Errorf("failed health check for service '%s'", service.Name)
 		}(service)
 	}
 
@@ -226,7 +226,7 @@ func RunContainer(
 	close(serviceErrors)
 
 	if err := <-serviceErrors; err != nil {
-		return -1, fmt.Errorf("service: %w", err)
+		return -1, fmt.Errorf("some service failed: %w", err)
 	}
 
 	// Create and execute steps containers
@@ -285,7 +285,7 @@ func RunContainer(
 				fmt.Sprintf("alfred-%s-%d", task.FQN(), stepIndex),
 			)
 			if err != nil {
-				return fmt.Errorf("failed to create step %d container: %w", stepIndex, err)
+				return fmt.Errorf("failed to create docker container for step %d: %w", stepIndex, err)
 			}
 			defer cleanup(
 				"step container",
@@ -299,12 +299,12 @@ func RunContainer(
 			wait, errChan := docker.ContainerWait(ctx, resp.ID, container.WaitConditionNextExit)
 			err = docker.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
 			if err != nil {
-				return fmt.Errorf("failed to start step %d container: %w", stepIndex, err)
+				return fmt.Errorf("failed to start docker container for step %d: %w", stepIndex, err)
 			}
 
 			out, err := docker.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true, ShowStderr: true, Follow: true, Timestamps: true, Details: true})
 			if err != nil {
-				return fmt.Errorf("failed to get container step %d logs: %w", stepIndex, err)
+				return fmt.Errorf("failed to get docker container logs for step %d: %w", stepIndex, err)
 			}
 			defer out.Close()
 
@@ -318,7 +318,7 @@ func RunContainer(
 					break
 				}
 			case err := <-errChan:
-				return fmt.Errorf("failed to wait for step %d container: %w", stepIndex, err)
+				return fmt.Errorf("failed while waiting for docker container for step %d: %w", stepIndex, err)
 			}
 
 			return nil
@@ -331,7 +331,7 @@ func RunContainer(
 	if runConfig.ArtifactPreserver != nil {
 		reader, err := taskFs.Archive("/output")
 		if err != nil {
-			return -1, fmt.Errorf("failed to archive output: %w", err)
+			return -1, fmt.Errorf("failed to archive 'output' directory: %w", err)
 		}
 		defer reader.Close()
 
@@ -341,7 +341,7 @@ func RunContainer(
 	}
 
 	if status.StatusCode != 0 {
-		return int(status.StatusCode), fmt.Errorf("exited status: %d", status.StatusCode)
+		return int(status.StatusCode), fmt.Errorf("task execution ended with status: %d", status.StatusCode)
 	}
 
 	return 0, nil

provisioner/openstack/node.go

@@ -57,12 +57,12 @@ func (n *Node) connect(server *servers.Server) (err error) {
 
 	pages, err := servers.ListAddresses(openstackClient, server.ID).AllPages()
 	if err != nil {
-		return fmt.Errorf("failed to get server '%s' addresses: %w", n.name, err)
+		return fmt.Errorf("failed to get server addresses for '%s': %w", n.name, err)
 	}
 
 	allAddresses, err := servers.ExtractAddresses(pages)
 	if err != nil {
-		return fmt.Errorf("failed to extract server '%s' addresses: %w", n.name, err)
+		return fmt.Errorf("failed to extract server addresses for '%s': %w", n.name, err)
 	}
 
 	var nodeAddress string
@@ -133,7 +133,7 @@ func (n *Node) connect(server *servers.Server) (err error) {
 		}),
 	)
 	if err != nil {
-		return fmt.Errorf("failed to init docker client: %w", err)
+		return fmt.Errorf("failed to initialize docker client: %w", err)
 	}
 
 	// Initialize file system
@@ -145,7 +145,7 @@ func (n *Node) connect(server *servers.Server) (err error) {
 func (n *Node) RunTask(task *scheduler.Task, runConfig scheduler.RunTaskConfig) (int, error) {
 	for _, image := range task.Job.Steps {
 		if err := n.ensureNodeHasImage(image); err != nil {
-			return -1, fmt.Errorf("failed to ensure node has image '%s': %w", image, err)
+			return -1, fmt.Errorf("failed to ensure node has docker image '%s': %w", image, err)
 		}
 	}
 
@@ -162,7 +162,7 @@ func (n *Node) ensureNodeHasImage(image string) error {
 		n.log.Debug("Image already on node", "image", image)
 		return nil
 	} else if !client.IsErrNotFound(err) {
-		return fmt.Errorf("inspect image: %w", err)
+		return fmt.Errorf("failed to inspect docker image '%s': %w", image, err)
 	}
 
 	n.log.Info("Image not on node, loading", "image", image)
@@ -179,15 +179,15 @@ func (n *Node) ensureNodeHasImage(image string) error {
 	session.Stderr = os.Stderr
 
 	if err := saveCmd.Start(); err != nil {
-		return fmt.Errorf("failed to start docker save: %w", err)
+		return fmt.Errorf("failed to 'docker save' image '%s': %w", image, err)
 	}
 
 	if err := session.Run("zstd --decompress | docker load"); err != nil {
-		return fmt.Errorf("failed docker load: %w", err)
+		return fmt.Errorf("failed to 'docker load' image '%s': %w", image, err)
 	}
 
 	if err := saveCmd.Wait(); err != nil {
-		return fmt.Errorf("failed docker save: %w", err)
+		return fmt.Errorf("failed while waiting for 'docker save' of image '%s': %w", image, err)
 	}
 
 	n.log.Debug("Image loaded on node", "image", image)
@@ -196,7 +196,7 @@ func (n *Node) ensureNodeHasImage(image string) error {
 
 func (n *Node) Terminate() error {
 	if n.terminated {
-		return fmt.Errorf("node '%s' already terminated", n.name)
+		return nil
 	}
 	n.terminated = true
 

server/server_artifacts.go

@@ -32,14 +32,14 @@ func (s *server) DownloadArtifact(req *proto.DownloadArtifactRequest, srv proto.
 			if err == io.EOF {
 				return nil
 			} else {
-				return fmt.Errorf("read: %w", err)
+				return fmt.Errorf("failed to read artifact chunk: %w", err)
 			}
 		} else {
 			if err = srv.Send(&proto.DownloadArtifactChunk{
 				Data:   chunk[:n],
 				Length: uint32(n),
 			}); err != nil {
-				return fmt.Errorf("send: %w", err)
+				return fmt.Errorf("failed to request for artifact chunk: %w", err)
 			}
 		}
 	}