endpoint: concurrent queries

client/holds.go

@@ -33,15 +33,17 @@ type holdsFilterFlags struct {
 	Filesystems FilesystemsFilterFlag
 	Job         JobIDFlag
 	Types       AbstractionTypesFlag
+	Concurrency int64
 }
 
 // produce a query from the CLI flags
 func (f holdsFilterFlags) Query() (endpoint.ListZFSHoldsAndBookmarksQuery, error) {
 	q := endpoint.ListZFSHoldsAndBookmarksQuery{
-		FS:    f.Filesystems.FlagValue(),
-		What:  f.Types.FlagValue(),
-		JobID: f.Job.FlagValue(),
-		Until: nil, // TODO support this as a flag
+		FS:          f.Filesystems.FlagValue(),
+		What:        f.Types.FlagValue(),
+		JobID:       f.Job.FlagValue(),
+		Until:       nil, // TODO support this as a flag
+		Concurrency: f.Concurrency,
 	}
 	return q, q.Validate()
 }
@@ -58,6 +60,8 @@ func (f *holdsFilterFlags) registerHoldsFilterFlags(s *pflag.FlagSet, verb strin
 	variants = sort.StringSlice(variants)
 	variantsJoined := strings.Join(variants, "|")
 	s.Var(&f.Types, "type", fmt.Sprintf("only %s holds of the specified type [default: all] [comma-separated list of %s]", verb, variantsJoined))
+
+	s.Int64VarP(&f.Concurrency, "concurrency", "p", 1, "number of concurrently queried filesystems")
 }
 
 type JobIDFlag struct{ J *endpoint.JobID }
@@ -106,7 +110,7 @@ type FilesystemsFilterFlag struct {
 
 func (flag *FilesystemsFilterFlag) Set(s string) error {
 	mappings := strings.Split(s, ",")
-	if len(mappings) == 1 {
+	if len(mappings) == 1 && !strings.Contains(mappings[0], ":") {
 		flag.F = endpoint.ListZFSHoldsAndBookmarksQueryFilesystemFilter{
 			FS: &mappings[0],
 		}

client/holds_list.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"sync"
 
 	"github.com/fatih/color"
 	"github.com/pkg/errors"
@@ -12,6 +13,7 @@ import (
 
 	"github.com/zrepl/zrepl/cli"
 	"github.com/zrepl/zrepl/endpoint"
+	"github.com/zrepl/zrepl/util/chainlock"
 )
 
 var holdsListFlags struct {
@@ -43,30 +45,56 @@ func doHoldsList(sc *cli.Subcommand, args []string) error {
 		return errors.Wrap(err, "invalid filter specification on command line")
 	}
 
-	abstractions, errors, err := endpoint.ListAbstractions(ctx, q)
+	abstractions, errors, err := endpoint.ListAbstractionsStreamed(ctx, q)
 	if err != nil {
 		return err // context clear by invocation of command
 	}
 
-	// always print what we got
-	if holdsListFlags.Json {
-		enc := json.NewEncoder(os.Stdout)
-		enc.SetIndent("", "  ")
-		if err := enc.Encode(abstractions); err != nil {
-			panic(err)
-		}
-		fmt.Println()
-	} else {
-		for _, a := range abstractions {
-			fmt.Println(a)
-		}
-	}
+	var line chainlock.L
+	var wg sync.WaitGroup
+	defer wg.Wait()
+	wg.Add(1)
 
-	// then potential errors, so that users always see them
-	if len(errors) > 0 {
-		color.New(color.FgRed).Fprintf(os.Stderr, "there were errors in listing the abstractions:\n%s\n", errors)
+	// print results
+	go func() {
+		defer wg.Done()
+		enc := json.NewEncoder(os.Stdout)
+		for a := range abstractions {
+			func() {
+				defer line.Lock().Unlock()
+				if holdsListFlags.Json {
+					enc.SetIndent("", "  ")
+					if err := enc.Encode(abstractions); err != nil {
+						panic(err)
+					}
+					fmt.Println()
+				} else {
+					fmt.Println(a)
+				}
+			}()
+		}
+	}()
+
+	// print errors to stderr
+	errorColor := color.New(color.FgRed)
+	var errorsSlice []endpoint.ListAbstractionsError
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		for err := range errors {
+			func() {
+				defer line.Lock().Unlock()
+				errorsSlice = append(errorsSlice, err)
+				errorColor.Fprintf(os.Stderr, "%s\n", err)
+			}()
+		}
+	}()
+	wg.Wait()
+	if len(errorsSlice) > 0 {
+		errorColor.Add(color.Bold).Fprintf(os.Stderr, "there were errors in listing the abstractions")
 		return fmt.Errorf("")
 	} else {
 		return nil
 	}
+
 }