LogDog: CLI can use stream URLs, fix auth.

logdog/client/cli/main.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package cli
 
 import (
         "flag"
         "fmt"
+        "net/http"
         "os"
         "os/signal"
         "strings"
         "time"
 
         "github.com/maruel/subcommands"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/client/authcli"
         "github.com/luci/luci-go/common/auth"
         "github.com/luci/luci-go/common/cli"
         "github.com/luci/luci-go/common/clock/clockflag"
+        "github.com/luci/luci-go/common/errors"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/grpc/prpc"
         "github.com/luci/luci-go/logdog/client/coordinator"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
 )
 
 func init() {
         prpc.DefaultUserAgent = "logdog CLI"
@@ skipping 22 matching lines @@
 
         // project is the project name. This may either be a valid project name or
         // empty. Subcommands that support "unified" project-in-path paths should use
         // splitPath to get the project form the path. Those that don't should assert
         // that this is non-empty.
         project   cfgtypes.ProjectName
         authFlags authcli.Flags
         insecure  bool
         timeout   clockflag.Duration
 
-        coord *coordinator.Client
+        // httpClient is an authenticated HTTP client to use for connections to the
+        // Coordinator.
+        httpClient *http.Client
 }
 
 func (a *application) addToFlagSet(ctx context.Context, fs *flag.FlagSet) {
         fs.StringVar(&a.p.Host, "host", a.p.Host,
                 "The LogDog Coordinator [host][:port].")
         fs.BoolVar(&a.insecure, "insecure", false,
                 "Use insecure transport for RPC.")
         fs.Var(&a.project, "project",
                 "The log stream's project.")
 
@@ skipping 21 matching lines @@
         }
 
         if len(parts) == 2 {
                 p = parts[1]
         } else {
                 p = ""
         }
         return project, p, true, nil
 }
 
+func (a *application) resolveHost(host string) (string, error) {
+        switch {
+        case host != "":
+                return host, nil
+        case a.p.Host != "":
+                return a.p.Host, nil
+        default:
+                return "", errors.New("a Coordinator host must be specified (-host)")
+        }
+}
+
+// coordinatorClient returns a Coordinator client for the specified host. If
+// no host is provided, the command-line host will be used.
+func (a *application) coordinatorClient(host string) (*coordinator.Client, error) {
+        host, err := a.resolveHost(host)
+        if err != nil {
+                return nil, errors.Annotate(err).Err()
+        }
+
+        // Get our Coordinator client instance.
+        prpcClient := prpc.Client{
+                C:       a.httpClient,
+                Host:    host,
+                Options: prpc.DefaultOptions(),
+        }
+        prpcClient.Options.Insecure = a.insecure
+        return coordinator.NewClient(&prpcClient), nil
+}
+
 func (a *application) timeoutCtx(c context.Context) (context.Context, context.CancelFunc) {
         if a.timeout <= 0 {
                 return context.WithCancel(c)
         }
         return context.WithTimeout(c, time.Duration(a.timeout))
 }
 
 // Main is the entry point for the CLI application.
 func Main(ctx context.Context, params Parameters) int {
         ctx = gologger.StdConfig.Use(ctx)
@@ skipping 11 matching lines @@
                                 subcommands.CmdHelp,
                                 newCatCommand(),
                                 newQueryCommand(),
                                 newListCommand(),
                                 newLatestCommand(),
                                 authcli.SubcommandLogin(authOptions, "auth-login", false),
                                 authcli.SubcommandLogout(authOptions, "auth-logout", false),
                                 authcli.SubcommandInfo(authOptions, "auth-info", false),
                         },
                 },
-                p: params,
+                p:         params,
+                authFlags: authcli.Flags{},
         }
         loggingConfig := log.Config{
                 Level: log.Level(log.Info),
         }
 
         flags := &flag.FlagSet{}
         a.addToFlagSet(ctx, flags)
         loggingConfig.AddFlags(flags)
         a.authFlags.Register(flags, authOptions)
 
         // Parse flags.
         if err := flags.Parse(params.Args); err != nil {
                 log.Errorf(log.SetError(ctx, err), "Failed to parse command-line.")
                 return 1
         }
 
         // Install our log formatter.
         ctx = loggingConfig.Set(ctx)
 
-        if a.p.Host == "" {
-                log.Errorf(ctx, "Missing coordinator host (-host).")
-                return 1
-        }
-
         // Signal handler will cancel our context when interrupted.
         ctx, cancelFunc := context.WithCancel(ctx)
         signalC := make(chan os.Signal)
         signal.Notify(signalC, os.Interrupt, os.Kill)
         go func() {
                 triggered := false
                 for sig := range signalC {
                         if triggered {
                                 os.Exit(2)
                         }
 
                         triggered = true
                         log.Fields{
                                 "signal": sig,
                         }.Warningf(ctx, "Caught signal; terminating.")
                         cancelFunc()
                 }
         }()
         defer func() {
                 signal.Stop(signalC)
                 close(signalC)
         }()
 
         // Instantiate our authenticated HTTP client.
         authOpts, err := a.authFlags.Options()
         if err != nil {
                 log.Errorf(log.SetError(ctx, err), "Failed to create auth options.")
                 return 1
         }
-        httpClient, err := auth.NewAuthenticator(ctx, auth.OptionalLogin, authOpts).Client()
-        if err != nil {
+
+        if a.httpClient, err = auth.NewAuthenticator(ctx, auth.OptionalLogin, authOpts).Client(); err != nil {
                 log.Errorf(log.SetError(ctx, err), "Failed to create authenticated client.")
                 return 1
         }
 
-        // Get our Coordinator client instance.
-        prpcClient := &prpc.Client{
-                C:       httpClient,
-                Host:    a.p.Host,
-                Options: prpc.DefaultOptions(),
-        }
-        prpcClient.Options.Insecure = a.insecure
-
-        a.coord = coordinator.NewClient(prpcClient)
         a.Context = ctx
         return subcommands.Run(&a, flags.Args())
 }