Remove trychange.RunCommand and replace it by gclient_utils.CheckCall.

trychange.py

 #!/usr/bin/python
 # Copyright (c) 2009 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.
 """Client-side script to send a try job to the try server. It communicates to
 the try server by either writting to a svn repository or by directly connecting
 to the server by HTTP.
 """
 
 import datetime
 import getpass
 import logging
 import optparse
 import os
 import shutil
 import socket
 import subprocess
 import sys
 import tempfile
 import urllib
 
 import breakpad
 
 import gcl
+import gclient_utils
 import scm
 import presubmit_support
 import upload
 
 __version__ = '1.1.2'
 
 
 # Constants
 HELP_STRING = "Sorry, Tryserver is not available."
 USAGE = r"""%prog [change_name] [options]
@@ skipping 76 matching lines @@
     settings['default_transport'] = 'http'
   elif settings.get('svn_repo'):
     settings['default_transport'] = 'svn'
   return settings
 
 
 def EscapeDot(name):
   return name.replace('.', '-')
 
 
-def RunCommand(command):
-  output, retcode = gcl.RunShellWithReturnCode(command)
-  if retcode:
-    raise NoTryServerAccess(' '.join(command) + '\nOuput:\n' + output)
-  return output
-
-
 class SCM(object):
   """Simplistic base class to implement one function: ProcessOptions."""
   def __init__(self, options):
     self.options = options
 
   def ProcessOptions(self):
     raise NotImplementedError
 
 
 class SVN(SCM):
@@ skipping 157 matching lines @@
                             ' try server svn repository to connect to.')
 
   values = _ParseSendChangeOptions(options)
   description = ''
   for (k,v) in values.iteritems():
     description += "%s=%s\n" % (k,v)
 
   # Do an empty checkout.
   temp_dir = tempfile.mkdtemp()
   temp_file = tempfile.NamedTemporaryFile()
-  temp_file_name = temp_file.name
   try:
-    # Don't use  '--non-interactive', since we want it to prompt for
-    # crendentials if necessary.
-    command = ['svn', 'checkout', '--depth', 'empty', '-q',
-               options.svn_repo, temp_dir]
-    if options.email:
-      command += ['--username', options.email]
-    # Don't use RunCommand() since svn may prompt for information.
-    use_shell = sys.platform.startswith("win")
-    subprocess.Popen(command, shell=use_shell).communicate()
+    try:
+      command = ['svn', 'checkout', '--depth', 'empty', '-q',
+                 options.svn_repo, temp_dir]
+      if options.email:
+        command += ['--username', options.email]
+      gclient_utils.CheckCall(command)
 
-    # TODO(maruel): Use a subdirectory per user?
-    current_time = str(datetime.datetime.now()).replace(':', '.')
-    file_name = (EscapeDot(options.user) + '.' + EscapeDot(options.name) +
-                 '.%s.diff' % current_time)
-    full_path = os.path.join(temp_dir, file_name)
-    full_url = options.svn_repo + '/' + file_name
-    file_found = False
-    try:
-      RunCommand(['svn', 'ls', full_url])
-      file_found = True
-    except NoTryServerAccess:
-      pass
-    if file_found:
-      # The file already exists in the repo. Note that commiting a file is a
-      # no-op if the file's content (the diff) is not modified. This is why the
-      # file name contains the date and time.
-      RunCommand(['svn', 'update', full_path])
-      f = open(full_path, 'wb')
-      f.write(options.diff)
-      f.close()
-    else:
-      # Add the file to the repo
-      f = open(full_path, 'wb')
-      f.write(options.diff)
-      f.close()
-      RunCommand(["svn", "add", full_path])
-    temp_file.write(description)
-    temp_file.flush()
-    RunCommand(["svn", "commit", full_path, '--file',
-                temp_file_name])
+      # TODO(maruel): Use a subdirectory per user?
+      current_time = str(datetime.datetime.now()).replace(':', '.')
+      file_name = (EscapeDot(options.user) + '.' + EscapeDot(options.name) +
+                   '.%s.diff' % current_time)
+      full_path = os.path.join(temp_dir, file_name)
+      full_url = options.svn_repo + '/' + file_name
+      file_found = False
+      try:
+        gclient_utils.CheckCall(['svn', 'ls', full_url])
+        file_found = True
+      except gclient_utils.CheckCallError:
+        pass
+      if file_found:
+        # The file already exists in the repo. Note that commiting a file is a
+        # no-op if the file's content (the diff) is not modified. This is why
+        # the file name contains the date and time.
+        gclient_utils.CheckCall(['svn', 'update', full_path])
+        f = open(full_path, 'wb')
+        f.write(options.diff)
+        f.close()
+      else:
+        # Add the file to the repo
+        f = open(full_path, 'wb')
+        f.write(options.diff)
+        f.close()
+        gclient_utils.CheckCall(["svn", "add", full_path])
+      temp_file.write(description)
+      temp_file.flush()
+      gclient_utils.CheckCall(["svn", "commit", full_path, '--file',
+                               temp_file.name])
+    except gclient_utils.CheckCallError, e:
+      raise NoTryServerAccess(' '.join(e.command) + '\nOuput:\n' +
+                              e.stdout)
   finally:
     temp_file.close()
     shutil.rmtree(temp_dir, True)
 
 
 def GuessVCS(options):
   """Helper to guess the version control system.
 
   NOTE: Very similar to upload.GuessVCS. Doesn't look for hg since we don't
   support it yet.
 
   This examines the current directory, guesses which SCM we're using, and
   returns an instance of the appropriate class.  Exit with an error if we can't
   figure it out.
 
   Returns:
     A SCM instance. Exits if the SCM can't be guessed.
   """
   __pychecker__ = 'no-returnvalues'
   # Subversion has a .svn in all working directories.
   if os.path.isdir('.svn'):
     logging.info("Guessed VCS = Subversion")
     return SVN(options)
 
   # Git has a command to test if you're in a git tree.
   # Try running it, but don't die if we don't have git installed.
   try:
-    out, returncode = gcl.RunShellWithReturnCode(["git", "rev-parse",
-                                                  "--is-inside-work-tree"])
+    out, returncode = subprocess.Popen(
+        ["git", "rev-parse", "--is-inside-work-tree"],
+        shell=sys.platform.startswith('win'),
+        stdout=subprocess.PIPE).communicate()[0]
     if returncode == 0:
       logging.info("Guessed VCS = Git")
       return GIT(options)
   except OSError, (errno, message):
     if errno != 2:  # ENOENT -- they don't have git installed.
       raise
 
   raise NoTryServerAccess("Could not guess version control system. "
                           "Are you in a working copy directory?")
 
@@ skipping 127 matching lines @@
       not options.diff and not options.url):
     # TODO(maruel): It should just try the modified files showing up in a
     # svn status.
     parser.error('Nothing to try, changelist is empty.')
 
   try:
     # Convert options.diff into the content of the diff.
     if options.url:
       options.diff = urllib.urlopen(options.url).read()
     elif options.diff:
-      options.diff = gcl.gclient_utils.FileRead(options.diff, 'rb')
+      options.diff = gclient_utils.FileRead(options.diff, 'rb')
     # Process the VCS in any case at least to retrieve the email address.
     try:
       options.scm = GuessVCS(options)
       options.scm.ProcessOptions()
     except NoTryServerAccess, e:
       # If we got the diff, we don't care.
       if not options.diff:
         # TODO(maruel): Raise what?
         raise
 
@@ skipping 27 matching lines @@
   except (InvalidScript, NoTryServerAccess), e:
     if swallow_exception:
       return 1
     print e
     return 1
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(TryChange(None, None, False))