Fix silent failures in test runner that lead to long timeouts

build/android/pylib/cmd_helper.py

 # 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.
 
 """A wrapper for subprocess to make calling shell commands easier."""
 
+import fcntl
 import logging
+import os
 import pipes
+import select
 import signal
+import StringIO
 import subprocess
-import tempfile
-
-from pylib.utils import timeout_retry
+import time
 
 
 def Popen(args, stdout=None, stderr=None, shell=None, cwd=None, env=None):
   return subprocess.Popen(
       args=args, cwd=cwd, stdout=stdout, stderr=stderr,
       shell=shell, close_fds=True, env=env,
       preexec_fn=lambda: signal.signal(signal.SIGPIPE, signal.SIG_DFL))
 
 
 def Call(args, stdout=None, stderr=None, shell=None, cwd=None, env=None):
@@ skipping 57 matching lines @@
   elif shell:
     raise Exception('array args must be run with shell=False')
   else:
     args_repr = ' '.join(map(pipes.quote, args))
 
   s = '[host]'
   if cwd:
     s += ':' + cwd
   s += '> ' + args_repr
   logging.info(s)
-  tmpout = tempfile.TemporaryFile(bufsize=0)
-  tmperr = tempfile.TemporaryFile(bufsize=0)
-  exit_code = Call(args, cwd=cwd, stdout=tmpout, stderr=tmperr, shell=shell)
-  tmperr.seek(0)
-  stderr = tmperr.read()
-  tmperr.close()
+  pipe = Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+               shell=shell, cwd=cwd)
+  stdout, stderr = pipe.communicate()
+
   if stderr:
     logging.critical(stderr)
-  tmpout.seek(0)
-  stdout = tmpout.read()
-  tmpout.close()
   if len(stdout) > 4096:
     logging.debug('Truncated output:')
   logging.debug(stdout[:4096])
-  return (exit_code, stdout)
+  return (pipe.returncode, stdout)
 
 
-def GetCmdStatusAndOutputWithTimeoutAndRetries(args, timeout, retries):
-  """Executes a subprocess with a timeout and retries.
+class TimeoutError(Exception):
+  """Module-specific timeout exception."""
+  pass
+
+
+def GetCmdStatusAndOutputWithTimeout(args, timeout, cwd=None, shell=False,
+                                     logfile=None):
+  """Executes a subprocess with a timeout.
 
   Args:
     args: List of arguments to the program, the program to execute is the first
       element.
-    timeout: the timeout in seconds.
-    retries: the number of retries.
+    timeout: the timeout in seconds or None to wait forever.
+    cwd: If not None, the subprocess's current directory will be changed to
+      |cwd| before it's executed.
+    shell: Whether to execute args as a shell command.
+    logfile: Optional file-like object that will receive output from the
+      command as it is running.
 
   Returns:
     The 2-tuple (exit code, output).
   """
-  return timeout_retry.Run(GetCmdStatusAndOutput, timeout, retries, [args])
+  try:
+    process = Popen(args, cwd=cwd, stdout=subprocess.PIPE, shell=shell)
+    end_time = (time.time() + timeout) if timeout else None
+    poll_interval = 1
+    buffer_size = 4096
+    child_fd = process.stdout.fileno()
+    output = StringIO.StringIO()
+
+    # Enable non-blocking reads from the child's stdout.
+    fl = fcntl.fcntl(child_fd, fcntl.F_GETFL)
+    fcntl.fcntl(child_fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
+
+    while not process.poll():
+      if end_time and time.time() > end_time:
+        raise TimeoutError
+      read_fds, _, _ = select.select([child_fd], [], [], poll_interval)
+      if child_fd in read_fds:
+        data = os.read(child_fd, buffer_size)
+        if not data:
+          break
+        if logfile:
+          logfile.write(data)
+        output.write(data)
+    return process.returncode, output.getvalue()
+  finally:
+    if not process.poll():
+      process.kill()
+      process.wait()