Remove CheckCall, CheckCallError and Popen from gclient_utils.

gclient_utils.py

 # Copyright (c) 2010 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.
 
 """Generic utils."""
 
 import errno
 import logging
 import os
 import Queue
 import re
 import stat
-import subprocess
 import sys
 import threading
 import time
 
 import subprocess2
 
 
-def hack_subprocess():
-  """subprocess functions may throw exceptions when used in multiple threads.
-
-  See http://bugs.python.org/issue1731717 for more information.
-  """
-  subprocess._cleanup = lambda: None
-
-
 class Error(Exception):
   """gclient exception class."""
   pass
 
 
-class CheckCallError(subprocess2.CalledProcessError, Error):
-  """CheckCall() returned non-0."""
-  def __init__(self, cmd, cwd, returncode, stdout, stderr=None):
-    subprocess2.CalledProcessError.__init__(
-        self, returncode, cmd, cwd, stdout, stderr)
-    Error.__init__(self, cmd)
-
-  def __str__(self):
-    return subprocess2.CalledProcessError.__str__(self)
-
-
-def Popen(args, **kwargs):
-  """Calls subprocess.Popen() with hacks to work around certain behaviors.
-
-  Ensure English outpout for svn and make it work reliably on Windows.
-  """
-  logging.debug(u'%s, cwd=%s' % (u' '.join(args), kwargs.get('cwd', '')))
-  if not 'env' in kwargs:
-    # It's easier to parse the stdout if it is always in English.
-    kwargs['env'] = os.environ.copy()
-    kwargs['env']['LANGUAGE'] = 'en'
-  if not 'shell' in kwargs:
-    # *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'] = (sys.platform=='win32')
-  try:
-    return subprocess.Popen(args, **kwargs)
-  except OSError, e:
-    if e.errno == errno.EAGAIN and sys.platform == 'cygwin':
-      raise Error(
-          'Visit '
-          'http://code.google.com/p/chromium/wiki/CygwinDllRemappingFailure to '
-          'learn how to fix this error; you need to rebase your cygwin dlls')
-    raise
-
-
-def CheckCall(command, print_error=True, **kwargs):
-  """Similar subprocess.check_call() but redirects stdout and
-  returns (stdout, stderr).
-
-  Works on python 2.4
-  """
-  try:
-    stderr = None
-    if not print_error:
-      stderr = subprocess.PIPE
-    process = Popen(command, stdout=subprocess.PIPE, stderr=stderr, **kwargs)
-    std_out, std_err = process.communicate()
-  except OSError, e:
-    raise CheckCallError(command, kwargs.get('cwd', None), e.errno, None)
-  if process.returncode:
-    raise CheckCallError(command, kwargs.get('cwd', None), process.returncode,
-        std_out, std_err)
-  return std_out, std_err
-
-
 def SplitUrlRevision(url):
   """Splits url and returns a two-tuple: url, rev"""
   if url.startswith('ssh:'):
     # Make sure ssh://user-name@example.com/~/test.git@stable works
     regex = r'(ssh://(?:[-\w]+@)?[-\w:\.]+/[-~\w\./]+)(?:@(.+))?'
     components = re.search(regex, url).groups()
   else:
     components = url.split('@', 1)
     if len(components) == 1:
       components += [None]
@@ skipping 291 matching lines @@
                of the subprocess's output. Each line has the trailing newline
                character trimmed.
     stdout: Can be any bufferable output.
 
   stderr is always redirected to stdout.
   """
   assert print_stdout or filter_fn
   stdout = stdout or sys.stdout
   filter_fn = filter_fn or (lambda x: None)
   assert not 'stderr' in kwargs
-  kid = Popen(args, bufsize=0,
-              stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-              **kwargs)
+  kid = subprocess2.Popen(
+      args, bufsize=0, stdout=subprocess2.PIPE, stderr=subprocess2.STDOUT,
+      **kwargs)
 
   # Do a flush of stdout before we begin reading from the subprocess's stdout
   stdout.flush()
 
   # Also, we need to forward stdout to prevent weird re-ordering of output.
   # This has to be done on a per byte basis to make sure it is not buffered:
   # normally buffering is done for each line, but if svn requests input, no
   # end-of-line character is output after the prompt and it would not show up.
   in_byte = kid.stdout.read(1)
   if in_byte:
     if call_filter_on_first_line:
       filter_fn(None)
     in_line = ''
     while in_byte:
       if in_byte != '\r':
         if print_stdout:
           stdout.write(in_byte)
         if in_byte != '\n':
           in_line += in_byte
         else:
           filter_fn(in_line)
           in_line = ''
       in_byte = kid.stdout.read(1)
     # Flush the rest of buffered output. This is only an issue with
     # stdout/stderr not ending with a \n.
     if len(in_line):
       filter_fn(in_line)
   rv = kid.wait()
   if rv:
-    raise CheckCallError(args, kwargs.get('cwd', None), rv, None)
+    raise subprocess2.CalledProcessError(
+        rv, args, kwargs.get('cwd', None), None, None)
   return 0
 
 
 def FindGclientRoot(from_dir, filename='.gclient'):
   """Tries to find the gclient root."""
   real_from_dir = os.path.realpath(from_dir)
   path = real_from_dir
   while not os.path.exists(os.path.join(path, filename)):
     split_path = os.path.split(path)
     if not split_path[1]:
@@ skipping 91 matching lines @@
 
   In gclient's case, Dependencies sometime needs to be run out of order due to
   From() keyword. This class manages that all the required dependencies are run
   before running each one.
 
   Methods of this class are thread safe.
   """
   def __init__(self, jobs, progress):
     """jobs specifies the number of concurrent tasks to allow. progress is a
     Progress instance."""
-    hack_subprocess()
     # Set when a thread is done or a new item is enqueued.
     self.ready_cond = threading.Condition()
     # Maximum number of concurrent tasks.
     self.jobs = jobs
     # List of WorkItem, for gclient, these are Dependency instances.
     self.queued = []
     # List of strings representing each Dependency.name that was run.
     self.ran = []
     # List of items currently running.
     self.running = []
@@ skipping 123 matching lines @@
         logging.info('Caught exception in thread %s' % self.item.name)
         logging.info(str(sys.exc_info()))
         work_queue.exceptions.put(sys.exc_info())
       logging.info('Task %s done' % self.item.name)
 
       work_queue.ready_cond.acquire()
       try:
         work_queue.ready_cond.notifyAll()
       finally:
         work_queue.ready_cond.release()