Update common.py.utils to be used in Skia repo

py/utils/shell_utils.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """ This module contains tools for running commands in a shell. """
 
 import datetime
 import os
 import Queue
 import select
 import subprocess
 import sys
 import threading
 import time
 
 if 'nt' in os.name:
   import ctypes
 
 
 DEFAULT_SECS_BETWEEN_ATTEMPTS = 10
 POLL_MILLIS = 250
+VERBOSE = True
 
 
 class CommandFailedException(Exception):
   """Exception which gets raised when a command fails."""
 
   def __init__(self, output, *args):
     """Initialize the CommandFailedException.
 
     Args:
         output: string; output from the command.
     """
     Exception.__init__(self, *args)
     self._output = output
 
   @property
   def output(self):
     """Output from the command."""
     return self._output
 
 
 class TimeoutException(CommandFailedException):
   """CommandFailedException which gets raised when a subprocess exceeds its
   timeout. """
   pass
 
 
-def run_async(cmd, echo=True, shell=False):
+def run_async(cmd, echo=None, shell=False):
   """ Run 'cmd' in a subprocess, returning a Popen class instance referring to
   that process.  (Non-blocking) """
+  if echo is None:
+    echo = VERBOSE
   if echo:
     print cmd
   if 'nt' in os.name:
     # Windows has a bad habit of opening a dialog when a console program
     # crashes, rather than just letting it crash.  Therefore, when a program
     # crashes on Windows, we don't find out until the build step times out.
     # This code prevents the dialog from appearing, so that we find out
     # immediately and don't waste time waiting around.
     SEM_NOGPFAULTERRORBOX = 0x0002
     ctypes.windll.kernel32.SetErrorMode(SEM_NOGPFAULTERRORBOX)
@@ skipping 30 matching lines @@
       # Python-style.
       for line in iter(self._file.readline, ''):
         self._queue.put(line)
         if self._stopped:
           break
 
   def stop(self):
     self._stopped = True
 
 
-def log_process_in_real_time(proc, echo=True, timeout=None, log_file=None,
+def log_process_in_real_time(proc, echo=None, timeout=None, log_file=None,
                              halt_on_output=None, print_timestamps=True):
   """ Log the output of proc in real time until it completes. Return a tuple
   containing the exit code of proc and the contents of stdout.
 
   proc: an instance of Popen referring to a running subprocess.
   echo: boolean indicating whether to print the output received from proc.stdout
   timeout: number of seconds allotted for the process to run. Raises a
       TimeoutException if the run time exceeds the timeout.
   log_file: an open file for writing output
   halt_on_output: string; kill the process and return if this string is found
       in the output stream from the process.
   print_timestamps: boolean indicating whether a formatted timestamp should be
       prepended to each line of output.
   """
+  if echo is None:
+    echo = VERBOSE
   stdout_queue = Queue.Queue()
   log_thread = EnqueueThread(proc.stdout, stdout_queue)
   log_thread.start()
   try:
     all_output = []
     t_0 = time.time()
     while True:
       code = proc.poll()
       try:
         output = stdout_queue.get_nowait()
@@ skipping 19 matching lines @@
         proc.terminate()
         raise TimeoutException(
             ''.join(all_output),
             'Subprocess exceeded timeout of %ds' % timeout)
   finally:
     log_thread.stop()
     log_thread.join()
   return (code, ''.join(all_output))
 
 
-def log_process_after_completion(proc, echo=True, timeout=None, log_file=None):
+def log_process_after_completion(proc, echo=None, timeout=None,
+                                 log_file=None):
   """ Wait for proc to complete and return a tuple containing the exit code of
   proc and the contents of stdout. Unlike log_process_in_real_time, does not
   attempt to read stdout from proc in real time.
 
   proc: an instance of Popen referring to a running subprocess.
   echo: boolean indicating whether to print the output received from proc.stdout
   timeout: number of seconds allotted for the process to run. Raises a
       TimeoutException if the run time exceeds the timeout.
   log_file: an open file for writing outout
   """
+  if echo is None:
+    echo = VERBOSE
   t_0 = time.time()
   code = None
   while code is None:
     if timeout and time.time() - t_0 > timeout:
       raise TimeoutException(
           proc.communicate()[0],
           'Subprocess exceeded timeout of %ds' % timeout)
     time.sleep(0.5)
     code = proc.poll()
   output = proc.communicate()[0]
   if echo:
     print output
   if log_file:
     log_file.write(output)
     log_file.flush()
   return (code, output)
 
 
-def run(cmd, echo=True, shell=False, timeout=None, print_timestamps=True,
+def run(cmd, echo=None, shell=False, timeout=None, print_timestamps=True,
         log_in_real_time=True):
   """ Run 'cmd' in a shell and return the combined contents of stdout and
   stderr (Blocking).  Throws an exception if the command exits non-zero.
 
   cmd: list of strings (or single string, iff shell==True) indicating the
       command to run
   echo: boolean indicating whether we should print the command and log output
   shell: boolean indicating whether we are using advanced shell features. Use
       only when absolutely necessary, since this allows a lot more freedom which
       could be exploited by malicious code. See the warning here:
       http://docs.python.org/library/subprocess.html#popen-constructor
   timeout: optional, integer indicating the maximum elapsed time in seconds
   print_timestamps: boolean indicating whether a formatted timestamp should be
       prepended to each line of output. Unused if echo or log_in_real_time is
       False.
   log_in_real_time: boolean indicating whether to read stdout from the
       subprocess in real time instead of when the process finishes. If echo is
       False, we never log in real time, even if log_in_real_time is True.
   """
+  if echo is None:
+    echo = VERBOSE
   proc = run_async(cmd, echo=echo, shell=shell)
   # If we're not printing the output, we don't care if the output shows up in
   # real time, so don't bother.
   if log_in_real_time and echo:
     (returncode, output) = log_process_in_real_time(proc, echo=echo,
         timeout=timeout, print_timestamps=print_timestamps)
   else:
     (returncode, output) = log_process_after_completion(proc, echo=echo,
                                                         timeout=timeout)
   if returncode != 0:
     raise CommandFailedException(
         output,
         'Command failed with code %d: %s' % (returncode, cmd))
   return output
 
 
-def run_retry(cmd, echo=True, shell=False, attempts=1,
+def run_retry(cmd, echo=None, shell=False, attempts=1,
               secs_between_attempts=DEFAULT_SECS_BETWEEN_ATTEMPTS,
               timeout=None, print_timestamps=True):
   """ Wrapper for run() which makes multiple attempts until either the command
   succeeds or the maximum number of attempts is reached. """
+  if echo is None:
+    echo = VERBOSE
   attempt = 1
   while True:
     try:
       return run(cmd, echo=echo, shell=shell, timeout=timeout,
                  print_timestamps=print_timestamps)
     except CommandFailedException:
       if attempt >= attempts:
         raise
     print 'Command failed. Retrying in %d seconds...' % secs_between_attempts
     time.sleep(secs_between_attempts)
     attempt += 1