Add new clog.ErrGroup

cmoog · cmoog · commit 99a751f978f4 · 2020-10-23T14:32:30.000-05:00
diff --git a/internal/clog/doc.go b/internal/clog/doc.go
@@ -0,0 +1,7 @@
+// package clog provides rich error types and logging helpers for coder-cli.
+//
+// To preserve the modularity of the code, clog encourages returning error types rather than
+// logging them and failing with os.Exit as they happen.
+// Error, Fatal, and Warn allow downstream functions to return errors with rich formatting information
+// while preserving the original, single-line error chain.
+package clog
diff --git a/internal/clog/errgroup.go b/internal/clog/errgroup.go
@@ -0,0 +1,57 @@
+package clog
+
+import (
+	"fmt"
+	"sync/atomic"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+)
+
+// ErrGroup wraps the /x/sync/errgroup.(Group) and adds clog logging and rich error propagation.
+//
+// Take for example, a case in which we are concurrently stopping a slice of environments.
+// In this case, we want to log errors as they happen, not pass them through the callstack as errors.
+// When the operations complete, we want to log how many, if any, failed.
+type ErrGroup interface {
+	Go(f func() error)
+	Wait() error
+}
+
+type group struct {
+	egroup   errgroup.Group
+	failures int32
+}
+
+// NewErrGroup gives an error group with logging and error propagation handled automatically.
+func NewErrGroup() ErrGroup {
+	return &group{
+		egroup:   errgroup.Group{},
+		failures: 0,
+	}
+}
+
+func (g *group) Go(f func() error) {
+	g.egroup.Go(func() error {
+		if err := f(); err != nil {
+			atomic.AddInt32(&g.failures, 1)
+			Log(err)
+
+			// this error does not matter because we discard it in Wait.
+			return xerrors.New("")
+		}
+		return nil
+	})
+}
+
+func (g *group) Wait() error {
+	_ = g.egroup.Wait() // ignore this error because we are already tracking failures manually
+	if g.failures == 0 {
+		return nil
+	}
+	failureWord := "failure"
+	if g.failures > 1 {
+		failureWord += "s"
+	}
+	return Fatal(fmt.Sprintf("%d %s emitted", g.failures, failureWord))
+}
diff --git a/internal/cmd/envs.go b/internal/cmd/envs.go
@@ -4,13 +4,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"sync/atomic"
 
 	"cdr.dev/coder-cli/coder-sdk"
 	"cdr.dev/coder-cli/internal/clog"
 	"cdr.dev/coder-cli/internal/x/xtabwriter"
 	"github.com/spf13/cobra"
-	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
 )
 
@@ -102,34 +100,28 @@ coder envs --user charlie@coder.com ls -o json \
 				return xerrors.Errorf("new client: %w", err)
 			}
 
-			var egroup errgroup.Group
-			var fails int32
+			egroup := clog.NewErrGroup()
 			for _, envName := range args {
 				envName := envName
 				egroup.Go(func() error {
 					env, err := findEnv(cmd.Context(), client, envName, *user)
 					if err != nil {
-						atomic.AddInt32(&fails, 1)
-						clog.Log(err)
-						return xerrors.Errorf("find env by name: %w", err)
+						return err
 					}
 
 					if err = client.StopEnvironment(cmd.Context(), env.ID); err != nil {
-						atomic.AddInt32(&fails, 1)
-						err = clog.Fatal(fmt.Sprintf("stop environment %q", env.Name),
+						return clog.Fatal(fmt.Sprintf("stop environment %q", env.Name),
 							clog.Causef(err.Error()), clog.BlankLine,
 							clog.Hintf("current environment status is %q", env.LatestStat.ContainerStatus),
 						)
-						clog.Log(err)
-						return err
 					}
 					clog.LogSuccess(fmt.Sprintf("successfully stopped environment %q", envName))
 					return nil
 				})
 			}
 
-			if err = egroup.Wait(); err != nil {
-				return clog.Fatal(fmt.Sprintf("%d failure(s) emitted", fails))
+			if err := egroup.Wait(); err != nil {
+				return err
 			}
 			return nil
 		},
