LogDog: Implement prefix registration in Butler.

client/cmd/logdog_butler/subcommand_run.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"
         "fmt"
         "io"
@@ skipping 163 matching lines @@
                         log.Errorf(log.SetError(a, err), "Failed to connect to stream server.")
                         return runtimeErrorReturnCode
                 }
                 defer func() {
                         if streamServerOwned {
                                 streamServer.Close()
                         }
                 }()
         }
 
+        // We're about ready to execute our command. Initialize our Output instance.
+        // We want to do this before we execute our subprocess so that if this fails,
+        // we don't have to interrupt an already-running process.
+        output, err := a.configOutput()
+        if err != nil {
+                log.WithError(err).Errorf(a, "Failed to create output instance.")
+                return runtimeErrorReturnCode
+        }
+        defer output.Close()
+
         // Construct and execute the command
         proc := ctxcmd.CtxCmd{
                 Cmd: exec.Command(commandPath, args...),
         }
         proc.Dir = cmd.chdir
         proc.Env = env.sorted()
         if cmd.stdin {
                 proc.Stdin = os.Stdin
         }
 
@@ skipping 75 matching lines @@
                         }
                 } else {
                         returnCode = 0
                 }
 
                 log.Fields{
                         "returnCode": returnCode,
                 }.Infof(ctx, "Process completed.")
         }()
 
-        err = a.Main(func(b *butler.Butler) error {
+        err = a.runWithButler(output, func(b *butler.Butler) error {
                 // We will execute the bootstrapped command, then the Butler. Since we are
                 // hooking the Butler up to the command, the Butler's execution will be
                 // bounded by the availability of the command's STDOUT/STDERR streams. If
                 // both of those close, the command is finished (as far as the Butler is
                 // concerned).
 
                 // Execute the command. The bootstrapped application will begin executing in
                 // the background.
 
                 // If we have configured a stream server, add it.
@@ skipping 48 matching lines @@
         args := []string(nil)
         if err := dec.Decode(&args); err != nil {
                 return nil, err
         }
         return args, nil
 }
 
 // updateEnvironment adds common Butler bootstrapping environment variables
 // to the environment.
 func (cmd *runCommandRun) updateEnvironment(e environ, a *application) {
-        e.set(bootstrap.EnvStreamPrefix, string(a.butler.Prefix))
-        e.set(bootstrap.EnvStreamProject, string(a.butler.Project))
+        e.set(bootstrap.EnvStreamPrefix, string(a.prefix))
+        e.set(bootstrap.EnvStreamProject, string(a.project))
 
         // Set stream server path (if applicable)
         if cmd.streamServerURI != "" {
                 e.set(bootstrap.EnvStreamServerPath, string(cmd.streamServerURI))
         }
 }
 
 // callbackReadCloser invokes a callback method when closed.
 type callbackReadCloser struct {
         io.ReadCloser
         callback func()
 }
 
 func (c *callbackReadCloser) Close() error {
         defer c.callback()
         return c.ReadCloser.Close()
 }