Add combine_stdout_stderr as well as make success less verbose.

lib/cros_build_lib.py

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Common python commands used by various build scripts."""
 
 import inspect
 import os
 import re
 import subprocess
@@ skipping 10 matching lines @@
 
 def GetCallerName():
   """Returns the name of the calling module with __main__."""
   top_frame = inspect.stack()[-1][0]
   return os.path.basename(top_frame.f_code.co_filename)
 
 
 def RunCommand(cmd, print_cmd=True, error_ok=False, error_message=None,
                exit_code=False, redirect_stdout=False, redirect_stderr=False,
                cwd=None, input=None, enter_chroot=False, num_retries=0,
-               log_to_file=None):
+               log_to_file=None, combine_stdout_stderr=False):
   """Runs a shell command.
 
   Arguments:
     cmd: cmd to run.  Should be input to subprocess.POpen.  If a string,
       converted to an array using split().
     print_cmd: prints the command before running it.
     error_ok: does not raise an exception on error.
     error_message: prints out this message when an error occurrs.
     exit_code: returns the return code of the shell command.
     redirect_stdout: returns the stdout.
     redirect_stderr: holds stderr output until input is communicated.
     cwd: the working directory to run this cmd.
     input: input to pipe into this command through stdin.
     enter_chroot: this command should be run from within the chroot.  If set,
       cwd must point to the scripts directory.
     num_retries: the number of retries to perform before dying
     log_to_file: Redirects all stderr and stdout to file specified by this path.
+    combine_stdout_stderr: Combines stdout and stdin streams into stdout. Auto
+      set to true if log_to_file specifies a file.
 
   Returns:
     If exit_code is True, returns the return code of the shell command.
     Else returns the output of the shell command.
 
   Raises:
     Exception:  Raises RunCommandException on error with optional error_message,
 
                 but only if exit_code, and error_ok are both False. 
   """
   # Set default for variables.
   stdout = None
   stderr = None
   stdin = None
   file_handle = None
   output = ''
 
   # Modify defaults based on parameters.
   if log_to_file:
     file_handle = open(log_to_file, 'w+')
     stdout = file_handle
     stderr = file_handle
   else:
     if redirect_stdout:  stdout = subprocess.PIPE
     if redirect_stderr:  stderr = subprocess.PIPE
+    if combine_stdout_stderr: stderr = subprocess.STDOUT
 
   if input:  stdin = subprocess.PIPE
   if enter_chroot:  cmd = ['./enter_chroot.sh', '--'] + cmd
 
   # Print out the command before running.
   cmd_string = 'PROGRAM(%s) -> RunCommand: %r in dir %s' % (GetCallerName(),
                                                             cmd, cwd)
   if print_cmd:
     if not log_to_file:
       Info(cmd_string)
@@ skipping 15 matching lines @@
     if proc.returncode == 0:
       break
 
   if file_handle: file_handle.close()
 
   # If they asked for an exit_code, give it to them on success or failure
   if exit_code:
     return proc.returncode
 
   # If the command (and all retries) failed, handle error result
-  if proc.returncode != 0:
-    if error_ok:
-      Warning('Command "%r" failed.\n' % (cmd) +
-              (error_message or error or output or ''))
-    else:
-      raise RunCommandException('Command "%r" failed.\n' % (cmd) +
-                                (error_message or error or output or ''))
+  if proc.returncode != 0 and not error_ok:
+    error_info = ('Command "%r" failed.\n' % (cmd) +
+                  (error_message or error or output or ''))
+    if log_to_file: error_info += '\nOutput logged to %s' % log_to_file
+    raise RunCommandException(error_info)
 
   # return final result
   return output
 
 
 def RunCommandCaptureOutput(cmd, print_cmd=True, cwd=None, input=None,
                             enter_chroot=False,
                             combine_stdout_stderr=True,
                             verbose=False):
   """Runs a shell command. Differs from RunCommand, because it allows
@@ skipping 228 matching lines @@
   return os.path.join(GetCrosUtilsPath(source_dir_path), 'bin')
 
 
 def IsInsideChroot():
   """Returns True if we are inside chroot."""
   return os.path.exists('/etc/debian_chroot')
 
 
 # TODO(sosa): Remove once all callers use method.
 CROSUTILS_DIRECTORY = GetCrosUtilsPath(True)