Redo of r56893 with fix to support python 2.5.

gclient_utils.py

 # Copyright 2009 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Generic utils."""
 
 import errno
 import logging
 import os
 import re
 import stat
 import subprocess
 import sys
 import threading
 import time
-import threading
 import xml.dom.minidom
 import xml.parsers.expat
 
 
 class CheckCallError(OSError):
   """CheckCall() returned non-0."""
   def __init__(self, command, cwd, retcode, stdout, stderr=None):
     OSError.__init__(self, command, cwd, retcode, stdout, stderr)
     self.command = command
     self.cwd = cwd
     self.retcode = retcode
     self.stdout = stdout
     self.stderr = stderr
 
 
+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.
+  """
+  copied = False
+  if not 'env' in kwargs:
+    copied = True
+    kwargs = kwargs.copy()
+    # 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:
+    if not copied:
+      kwargs = kwargs.copy()
+    # *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')
+  return subprocess.Popen(*args, **kwargs)
+
+
 def CheckCall(command, cwd=None, print_error=True):
-  """Like subprocess.check_call() but returns stdout.
+  """Similar subprocess.check_call() but redirects stdout and
+  returns (stdout, stderr).
 
   Works on python 2.4
   """
   logging.debug('%s, cwd=%s' % (str(command), str(cwd)))
   try:
     stderr = None
     if not print_error:
       stderr = subprocess.PIPE
-    env = os.environ.copy()
-    env['LANGUAGE'] = 'en'
-    process = subprocess.Popen(command, cwd=cwd,
-                               shell=sys.platform.startswith('win'),
-                               stdout=subprocess.PIPE,
-                               stderr=stderr,
-                               env=env)
+    process = Popen(command, cwd=cwd, stdout=subprocess.PIPE, stderr=stderr)
     std_out, std_err = process.communicate()
   except OSError, e:
     raise CheckCallError(command, cwd, e.errno, None)
   if process.returncode:
     raise CheckCallError(command, cwd, process.returncode, std_out, std_err)
   return std_out, std_err
 
 
 def SplitUrlRevision(url):
   """Splits url and returns a two-tuple: url, rev"""
@@ skipping 199 matching lines @@
   trimmed.
 
   If the command fails, as indicated by a nonzero exit status, gclient will
   exit with an exit status of fail_status.  If fail_status is None (the
   default), gclient will raise an Error exception.
   """
   logging.debug(command)
   if print_messages:
     print('\n________ running \'%s\' in \'%s\''
           % (' '.join(command), in_directory))
-  env = os.environ.copy()
-  env['LANGUAGE'] = 'en'
 
-  # *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.
-  kid = subprocess.Popen(command, bufsize=0, cwd=in_directory,
-      shell=(sys.platform == 'win32'), stdout=subprocess.PIPE,
-      stderr=subprocess.STDOUT, env=env)
+  kid = Popen(command, bufsize=0, cwd=in_directory,
+              stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
   # Do a flush of sys.stdout before we begin reading from the subprocess's
   # stdout.
   last_flushed_at = time.time()
   sys.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.
@@ skipping 19 matching lines @@
       if (time.time() - last_flushed_at) > 10:
         last_flushed_at = time.time()
         sys.stdout.flush()
     in_byte = kid.stdout.read(1)
   rv = kid.wait()
 
   if rv:
     msg = 'failed to run command: %s' % ' '.join(command)
 
     if fail_status != None:
-      print >>sys.stderr, msg
+      print >> sys.stderr, msg
       sys.exit(fail_status)
 
     raise Error(msg)
 
 
 def FindGclientRoot(from_dir, filename='.gclient'):
   """Tries to find the gclient root."""
   path = os.path.realpath(from_dir)
   while not os.path.exists(os.path.join(path, filename)):
-    next = os.path.split(path)
-    if not next[1]:
+    split_path = os.path.split(path)
+    if not split_path[1]:
       return None
-    path = next[0]
+    path = split_path[0]
   logging.info('Found gclient root at ' + path)
   return path
 
 
 def PathDifference(root, subpath):
   """Returns the difference subpath minus root."""
   root = os.path.realpath(root)
   subpath = os.path.realpath(subpath)
   if not subpath.startswith(root):
     return None
@@ skipping 170 matching lines @@
         if exception:
           self.parent.exceptions.append(exception)
         if self.parent.progress:
           self.parent.progress.update(1)
         assert not self.item.name in self.parent.ran
         if not self.item.name in self.parent.ran:
           self.parent.ran.append(self.item.name)
       finally:
         self.parent.ready_cond.notifyAll()
         self.parent.ready_cond.release()