Butler: export Coordinator host in environment.

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 144 matching lines @@
                         log.Fields{
                                 "path": cwd,
                         }.Errorf(a, "Target `chdir` path is not a directory.")
                         return runtimeErrorReturnCode
                 }
         } else {
                 // Just for output.
                 cwd, _ = os.Getwd()
         }
 
+        // Get our output factory.
+        of, err := a.getOutputFactory()
+        if err != nil {
+                log.WithError(err).Errorf(a, "Failed to get output factory instance.")
+                return runtimeErrorReturnCode
+        }
+
         // Update our environment for the child process to inherit
         bsEnv := bootstrap.Environment{
                 Project: a.project,
                 Prefix:  a.prefix,
         }
 
+        // If our output factory has a Coordinator host, fill that in too.
+        if cho, ok := of.(coordinatorHostOutput); ok {
+                bsEnv.CoordinatorHost = cho.getCoordinatorHost()
+        }
+
         // Configure stream server
         streamServer := streamserver.StreamServer(nil)
         streamServerOwned := true
         if cmd.streamServerURI != "" {
                 log.Fields{
                         "url": cmd.streamServerURI,
                 }.Infof(a, "Creating stream server.")
                 streamServer = createStreamServer(a, cmd.streamServerURI)
 
                 if err := streamServer.Listen(); err != nil {
@@ skipping 81 matching lines @@
                         "args":        args,
                 }.Debugf(a, "Executing application.")
                 for _, entry := range proc.Env {
                         log.Debugf(a, "Environment variable: %s", entry)
                 }
         }
 
         // 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()
+        output, err := of.configOutput(a)
         if err != nil {
                 log.WithError(err).Errorf(a, "Failed to create output instance.")
                 return runtimeErrorReturnCode
         }
         defer output.Close()
 
         // Attach and run our Butler instance.
         var (
                 executed   = false
                 returnCode = runtimeErrorReturnCode
@@ skipping 109 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()
 }