Set returncode to subprocess2.TIMED_OUT instead of -9 when a process times out.

subprocess2.py

 # coding=utf8
 # Copyright (c) 2011 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.
 """Collection of subprocess wrapper functions.
 
 In theory you shouldn't need anything else in subprocess, or this module failed.
 """
 
 from __future__ import with_statement
+import errno
 import logging
 import os
 import subprocess
 import sys
 import tempfile
 import time
 import threading
 
 # Constants forwarded from subprocess.
 PIPE = subprocess.PIPE
 STDOUT = subprocess.STDOUT
 # Sends stdout or stderr to os.devnull.
 VOID = '/dev/null'
-
+# Error code when a process was killed because it timed out.
+TIMED_OUT = -2001

[Dirk Pranke, 2011/04/07 02:03:46]

Where did -2001 come from?

 
 # Globals.
 # Set to True if you somehow need to disable this hack.
 SUBPROCESS_CLEANUP_HACKED = False
 
 
 class CalledProcessError(subprocess.CalledProcessError):
   """Augment the standard exception with more data."""
   def __init__(self, returncode, cmd, cwd, stdout, stderr):
     super(CalledProcessError, self).__init__(returncode, cmd)
     self.stdout = stdout
     self.stderr = stderr
     self.cwd = cwd
 
   def __str__(self):
     out = 'Command %s returned non-zero exit status %s' % (
         ' '.join(self.cmd), self.returncode)
     if self.cwd:
       out += ' in ' + self.cwd
     return '\n'.join(filter(None, (out, self.stdout, self.stderr)))
 
 
+class CygwinRebaseError(CalledProcessError):
+  """Occurs when cygwin's fork() emulation fails due to rebased dll."""
+
+
 ## Utility functions
 
 
 def kill_pid(pid):
   """Kills a process by its process id."""
   try:
     # Unable to import 'module'
     # pylint: disable=E1101,F0401
     import signal
     return os.kill(pid, signal.SIGKILL)
@@ skipping 92 matching lines @@
     # *Sigh*:  Windows needs shell=True, or else it won't search %PATH% for the
     # executable, but shell=True makes subprocess on Linux fail when it's called
     # with a list because it only tries to execute the first item in the list.
     kwargs['shell'] = bool(sys.platform=='win32')
 
   tmp_str = ' '.join(args)
   if kwargs.get('cwd', None):
     tmp_str += ';  cwd=%s' % kwargs['cwd']
   logging.debug(tmp_str)
 
-  # Replaces VOID with handle to /dev/null.
-  if kwargs.get('stdout') in (VOID, os.devnull):
-    kwargs['stdout'] = open(os.devnull, 'w')
-  if kwargs.get('stderr') in (VOID, os.devnull):
-    kwargs['stderr'] = open(os.devnull, 'w')
-  return subprocess.Popen(args, **kwargs)
+  def fix(stream):
+    if kwargs.get(stream) in (VOID, os.devnull):
+      # Replaces VOID with handle to /dev/null.
+      # Create a temporary file to workaround python's deadlock.
+      # http://docs.python.org/library/subprocess.html#subprocess.Popen.wait
+      # When the pipe fills up, it will deadlock this process. Using a real file
+      # works around that issue.
+      kwargs[stream] = open(os.devnull, 'w')
+
+  fix('stdout')
+  fix('stderr')
+
+  try:
+    return subprocess.Popen(args, **kwargs)
+  except OSError, e:
+    if e.errno == errno.EAGAIN and sys.platform == 'cygwin':
+      # Convert fork() emulation failure into a CygwinRebaseError().
+      raise CygwinRebaseError(
+          e.errno,
+          args,
+          kwargs.get('cwd'),
+          None,
+          'Visit '
+          'http://code.google.com/p/chromium/wiki/CygwinDllRemappingFailure to '
+          'learn how to fix this error; you need to rebase your cygwin dlls')
+    # Popen() can throw OSError when cwd or args[0] doesn't exist. Let it go
+    # through
+    raise
 
 
 def call(args, timeout=None, **kwargs):
   """Wraps subprocess.Popen().communicate().
 
   Returns ((stdout, stderr), returncode).
 
-  - The process will be kill with error code -9 after |timeout| seconds if set.
+  - The process will be kill with error code TIMED_OUT after |timeout| seconds

[Dirk Pranke, 2011/04/07 02:03:46]

You're not actually killing with an error code; I would rephrase this as:

"- The process will be killed after |timeout| seconds and returncode set to
TIMED_OUT"

+    if set.
   - Automatically passes stdin content as input so do not specify stdin=PIPE.
   """
   stdin = kwargs.pop('stdin', None)
   if stdin is not None:
     assert stdin != PIPE
     # When stdin is passed as an argument, use it as the actual input data and
     # set the Popen() parameter accordingly.
     kwargs['stdin'] = PIPE
 
   if not timeout:
     # Normal workflow.
     proc = Popen(args, **kwargs)
     if stdin is not None:
-      out = proc.communicate(stdin)
+      return proc.communicate(stdin), proc.returncode
     else:
-      out = proc.communicate()
-  else:
-    # Create a temporary file to workaround python's deadlock.
-    # http://docs.python.org/library/subprocess.html#subprocess.Popen.wait
-    # When the pipe fills up, it will deadlock this process. Using a real file
-    # works around that issue.
-    with tempfile.TemporaryFile() as buff:
-      start = time.time()
-      kwargs['stdout'] = buff
-      proc = Popen(args, **kwargs)
-      if stdin is not None:
-        proc.stdin.write(stdin)
-      while proc.returncode is None:
-        proc.poll()
-        if timeout and (time.time() - start) > timeout:
-          proc.kill()
-          proc.wait()
-          # It's -9 on linux and 1 on Windows. Standardize to -9.
-          # Do not throw an exception here, the user must use
-          # check_call(timeout=60) and check for e.returncode == -9 instead.
-          # or look at call()[1] == -9.
-          proc.returncode = -9
-        time.sleep(0.001)
-      # Now that the process died, reset the cursor and read the file.
-      buff.seek(0)
-      out = [buff.read(), None]
+      return proc.communicate(), proc.returncode
+
+  # Create a temporary file to workaround python's deadlock.
+  # http://docs.python.org/library/subprocess.html#subprocess.Popen.wait
+  # When the pipe fills up, it will deadlock this process. Using a real file
+  # works around that issue.
+  with tempfile.TemporaryFile() as buff:
+    start = time.time()
+    kwargs['stdout'] = buff
+    proc = Popen(args, **kwargs)
+    if stdin is not None:
+      proc.stdin.write(stdin)
+    while proc.returncode is None:
+      proc.poll()
+      if timeout and (time.time() - start) > timeout:
+        proc.kill()
+        proc.wait()
+        # It's -9 on linux and 1 on Windows. Standardize to TIMED_OUT.
+        proc.returncode = TIMED_OUT
+      time.sleep(0.001)
+    # Now that the process died, reset the cursor and read the file.
+    buff.seek(0)
+    out = [buff.read(), None]
   return out, proc.returncode
 
 
 def check_call(args, **kwargs):
   """Improved version of subprocess.check_call().
 
   Returns (stdout, stderr), unlike subprocess.check_call().
   """
   out, returncode = call(args, **kwargs)
   if returncode:
@@ skipping 24 matching lines @@
 
   - Discards stderr. By default sets stderr=STDOUT.
   - Throws if return code is not 0.
   - Works even prior to python 2.7.
   """
   if kwargs.get('stdout') is None:
     kwargs['stdout'] = PIPE
   if kwargs.get('stderr') is None:
     kwargs['stderr'] = STDOUT
   return check_call(args, **kwargs)[0]