LogDog/Butler: Enable direct output forwarding.

logdog/client/cmd/logdog_butler/subcommand_run.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 main
 
 import (
         "encoding/json"
         "io"
         "os"
@@ skipping 29 matching lines @@
                 cmd.Flags.StringVar(&cmd.chdir, "chdir", "",
                         "If specified, switch to this directory prior to running the command.")
                 cmd.Flags.Var(&cmd.streamServerURI, "streamserver-uri",
                         "The stream server URI to bind to (e.g., "+string(exampleStreamServerURI)+").")
                 cmd.Flags.BoolVar(&cmd.attach, "attach", true,
                         "If true, attaches the bootstrapped process' STDOUT and STDERR streams.")
                 cmd.Flags.BoolVar(&cmd.stdin, "forward-stdin", false,
                         "If true, forward STDIN to the bootstrapped process.")
 
                 // "stdout" command-line option.
-                cmd.stdout.Name = "stdout"
                 stdoutFlag := new(nestedflagset.FlagSet)
                 cmd.stdout.addFlags(&stdoutFlag.F)
                 cmd.Flags.Var(stdoutFlag, "stdout", "STDOUT stream parameters.")
 
                 // "stderr" command-line option.
-                cmd.stderr.Name = "stderr"
                 stderrFlag := new(nestedflagset.FlagSet)
                 cmd.stderr.addFlags(&stderrFlag.F)
                 cmd.Flags.Var(stderrFlag, "stderr", "STDERR stream parameters.")
 
                 return cmd
         },
 }
 
 type runCommandRun struct {
         subcommands.CommandRunBase
@@ skipping 134 matching lines @@
                 Cmd: exec.Command(commandPath, args...),
         }
         proc.Dir = cmd.chdir
         proc.Env = env.Sorted()
         if cmd.stdin {
                 proc.Stdin = os.Stdin
         }
 
         // Attach STDOUT / STDERR pipes if configured to do so.
         //
-        // We track them with a sync.WaitGroup because we have to wait for them to
-        // close before reaping the process (see exec.Cmd's StdoutPipe method).
+        // This will happen in one of two ways:
+        // - If no stream name is provided, we will not create a Butler stream for
+        //   this output; instead, we will connect them directly to the bootstrapped
+        //   process.
+        // - If a stream name is provided, we will create a Butler stream for this
+        //   output, and tee as necessary.
+        //
+        // When connecting the stream to the Butler, we track them with a
+        // sync.WaitGroup because we have to wait for them to close before reaping the
+        // process (see exec.Cmd's StdoutPipe method).
         //
         // In this case, we will hand them to the Butler, which will Close then when
         // it counters io.EOF.
         var (
                 stdout, stderr io.ReadCloser
                 streamWG       sync.WaitGroup
         )
         if cmd.attach {
-                stdout, err = proc.StdoutPipe()
-                if err != nil {
-                        log.WithError(err).Errorf(a, "Failed to get STDOUT pipe.")
-                        return runtimeErrorReturnCode
+                // STDOUT
+                if cmd.stdout.Name == "" {
+                        // Forward directly.
+                        proc.Stdout = os.Stdout
+                } else {
+                        // Connect to Butler.
+                        stdout, err = proc.StdoutPipe()
+                        if err != nil {
+                                log.WithError(err).Errorf(a, "Failed to get STDOUT pipe.")
+                                return runtimeErrorReturnCode
+                        }
+                        stdout = &callbackReadCloser{stdout, streamWG.Done}
+                        streamWG.Add(1)
                 }
-                stdout = &callbackReadCloser{stdout, streamWG.Done}
 
-                // Get our STDERR pipe
-                stderr, err = proc.StderrPipe()
-                if err != nil {
-                        log.WithError(err).Errorf(a, "Failed to get STDERR pipe.")
-                        return runtimeErrorReturnCode
+                // STDERR
+                if cmd.stderr.Name == "" {
+                        // Forward directly.
+                        proc.Stderr = os.Stderr
+                } else {
+                        // Connect to Butler.
+                        stderr, err = proc.StderrPipe()
+                        if err != nil {
+                                log.WithError(err).Errorf(a, "Failed to get STDERR pipe.")
+                                return runtimeErrorReturnCode
+                        }
+                        stderr = &callbackReadCloser{stderr, streamWG.Done}
+                        streamWG.Add(1)
                 }
-                stderr = &callbackReadCloser{stderr, streamWG.Done}
-                streamWG.Add(2)
         }
 
         if log.IsLogging(a, log.Debug) {
                 log.Fields{
                         "commandPath": commandPath,
                         "cwd":         cwd,
                         "args":        args,
                 }.Debugf(a, "Executing application.")
                 for _, entry := range proc.Env {
                         log.Debugf(a, "Environment variable: %s", entry)
@@ skipping 126 matching lines @@
 // 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()
 }