LogDog: Add project namespacing to `logdog_cat`

client/cmd/logdog_cat/main.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package main
 
 import (
         "errors"
         "flag"
+        "fmt"
         "os"
         "os/signal"
 
         "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/config"
         "github.com/luci/luci-go/common/logdog/coordinator"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/common/prpc"
 )
 
 func init() {
         prpc.DefaultUserAgent = "logdog_cat"
 }
 
 type application struct {
         cli.Application
         context.Context
 
+        project     config.ProjectName
         authFlags   authcli.Flags
         coordinator string
         insecure    bool
 
         coord *coordinator.Client
 }
 
 func (a *application) addToFlagSet(ctx context.Context, fs *flag.FlagSet) {
         fs.StringVar(&a.coordinator, "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.")
 }
 
 func (a *application) validate() error {
         if a.coordinator == "" {
                 return errors.New("main: missing coordinator URL (-url)")
         }
+        // TODO(dnj): Error on empty project once that's disallowed.
+        if a.project != "" {
+                if err := a.project.Validate(); err != nil {
+                        return fmt.Errorf("main: invalid project name (-project): %s", err)
+                }
+        }
         return nil
 }
 
 func mainImpl() int {
         ctx := context.Background()
         ctx = gologger.StdConfig.Use(ctx)
 
         authOptions := auth.Options{
                 Scopes: coordinator.Scopes,
         }
@@ skipping 60 matching lines @@
                 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.SilentLogin, authOpts).Client()
+        httpClient, err := auth.NewAuthenticator(ctx, auth.OptionalLogin, authOpts).Client()
         if 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.coordinator,
                 Options: prpc.DefaultOptions(),
         }
         prpcClient.Options.Insecure = a.insecure
 
-        a.coord = coordinator.NewClient(prpcClient)
+        a.coord = coordinator.NewClient(prpcClient, a.project)
         a.Context = ctx
         return subcommands.Run(&a, flags.Args())
 }
 
 func main() {
         os.Exit(mainImpl())
 }