Annotee: Add project name support.

client/cmd/logdog_annotee/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 (
         "encoding/json"
         "errors"
         "flag"
         "fmt"
         "os"
         "time"
 
         "github.com/golang/protobuf/proto"
         "github.com/luci/luci-go/client/logdog/annotee"
         "github.com/luci/luci-go/client/logdog/annotee/executor"
         "github.com/luci/luci-go/client/logdog/butlerlib/bootstrap"
         "github.com/luci/luci-go/client/logdog/butlerlib/streamclient"
         "github.com/luci/luci-go/client/logdog/butlerlib/streamproto"
         "github.com/luci/luci-go/common/clock/clockflag"
+        "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/logdog/types"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "golang.org/x/net/context"
 )
 
 const (
         // configErrorReturnCode is returned when there is an error with Annotee's
         // command-line configuration.
         configErrorReturnCode = 2
@@ skipping 18 matching lines @@
 type application struct {
         context.Context
 
         annotate           annotationMode
         jsonArgsPath       string
         butlerStreamServer string
         tee                bool
         printSummary       bool
         testingDir         string
         annotationInterval clockflag.Duration
+        project            config.ProjectName
         nameBase           streamproto.StreamNameFlag
         prefix             streamproto.StreamNameFlag
         logdogHost         string
 
         bootstrap *bootstrap.Bootstrap
 }
 
 func (a *application) addToFlagSet(fs *flag.FlagSet) {
         fs.StringVar(&a.jsonArgsPath, "json-args-path", "",
                 "If specified, this is a JSON file containing the full command to run as an "+
                         "array of strings.")
         fs.Var(&a.annotate, "annotate",
                 "Annotation handling mode. Options are: "+annotationFlagEnum.Choices())
         fs.StringVar(&a.butlerStreamServer, "butler-stream-server", "",
                 "The Butler stream server location. If empty, Annotee will check for Butler "+
                         "bootstrapping and extract the stream server from that.")
         fs.BoolVar(&a.tee, "tee", true,
                 "Tee the bootstrapped process' STDOUT/STDERR streams.")
         fs.BoolVar(&a.printSummary, "print-summary", true,
                 "Print the annotation protobufs that were emitted at the end.")
         fs.StringVar(&a.testingDir, "testing-dir", "",
                 "Rather than coupling to a Butler instance, output generated annotations "+
                         "and streams to this directory.")
         fs.Var(&a.annotationInterval, "annotation-interval",
                 "Buffer annotation updates for this amount of time. <=0 sends every update.")
+        fs.Var(&a.project, "project", "The log prefix's project name (required).")
         fs.Var(&a.nameBase, "name-base", "Base stream name to prepend to generated names.")
         fs.Var(&a.prefix, "prefix", "The log stream prefix. If missing, one will be inferred from bootstrap.")
         fs.StringVar(&a.logdogHost, "logdog-host", "",
                 "LogDog Coordinator host name. If supplied, log viewing links will be generated.")
 }
 
 func (a *application) loadJSONArgs() ([]string, error) {
         fd, err := os.Open(a.jsonArgsPath)
         if err != nil {
                 return nil, err
@@ skipping 56 matching lines @@
         if err != nil {
                 log.WithError(err).Errorf(a, "Failed to get stream client instance.")
                 return configErrorReturnCode
         }
 
         prefix := types.StreamName(a.prefix)
         if prefix == "" && a.bootstrap != nil {
                 prefix = a.bootstrap.Prefix
         }
 
+        // TODO(dnj): Require project attribute.
+        if a.project == "" {
+                a.project = a.bootstrap.Project
+        }
+
         args = fs.Args()
         if a.jsonArgsPath != "" {
                 if len(args) > 0 {
                         log.Fields{
                                 "commandLineArgs": args,
                                 "jsonArgsPath":    a.jsonArgsPath,
                         }.Errorf(a, "Cannot specify both JSON and command-line arguments.")
                         return configErrorReturnCode
                 }
 
@@ skipping 10 matching lines @@
                 log.Errorf(a, "No command-line arguments were supplied.")
                 return configErrorReturnCode
         }
 
         // Translate "<=0" flag option to Processor's "0", indicating that every
         // update should be sent.
         if a.annotationInterval < 0 {
                 a.annotationInterval = 0
         }
 
+        // Initialize our link generator, if we can.
+        linkGen := &coordinatorLinkGenerator{
+                base:    types.StreamName(a.nameBase),
+                project: a.project,
+                prefix:  prefix,
+        }
+        if !linkGen.canGenerateLinks() {
+                linkGen = nil
+        }
+
         e := executor.Executor{
                 Options: annotee.Options{
-                        Base:                   types.StreamName(a.nameBase),
-                        Prefix:                 prefix,
                         Client:                 client,
+                        LinkGenerator:          linkGen,
                         MetadataUpdateInterval: time.Duration(a.annotationInterval),
-                        LogDogHost:             a.logdogHost,
                 },
 
                 Annotate: executor.AnnotationMode(a.annotate),
                 Stdin:    os.Stdin,
         }
         if a.tee {
                 e.TeeStdout = os.Stdout
                 e.TeeStderr = os.Stderr
         }
         if err := e.Run(a, args); err != nil {
@@ skipping 13 matching lines @@
 
         if !e.Executed() {
                 return runtimeErrorReturnCode
         }
         return e.ReturnCode()
 }
 
 func main() {
         os.Exit(mainImpl(os.Args[1:]))
 }