Remove gclient_utils.CheckCall() usage from scm.py

scm.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.
 
 """SCM-specific utility classes."""
 
 import cStringIO
 import glob
 import logging
 import os
 import re
-import shutil
-import subprocess
 import sys
 import tempfile
 import time
 from xml.etree import ElementTree
 
 import gclient_utils
 import subprocess2
 
 
 def ValidateEmail(email):
@@ skipping 59 matching lines @@
           stdout=subprocess2.VOID,
           cwd=root)
       return 'git'
     except (OSError, subprocess2.CalledProcessError):
       return None
 
 
 class GIT(object):
   @staticmethod
   def Capture(args, **kwargs):
-    return gclient_utils.CheckCall(['git'] + args, print_error=False,
-        **kwargs)[0]
+    return subprocess2.check_output(
+        ['git'] + args, stderr=subprocess2.VOID, **kwargs)
 
   @staticmethod
   def CaptureStatus(files, upstream_branch=None):
     """Returns git status.
 
     @files can be a string (one file) or a list of files.
 
     Returns an array of (status, file) tuples."""
     if upstream_branch is None:
       upstream_branch = GIT.GetUpstreamBranch(os.getcwd())
@@ skipping 21 matching lines @@
         results.append(('%s      ' % m.group(1)[0], m.group(2)))
     return results
 
   @staticmethod
   def GetEmail(cwd):
     """Retrieves the user email address if known."""
     # We could want to look at the svn cred when it has a svn remote but it
     # should be fine for now, users should simply configure their git settings.
     try:
       return GIT.Capture(['config', 'user.email'], cwd=cwd).strip()
-    except gclient_utils.CheckCallError:
+    except subprocess2.CalledProcessError:
       return ''
 
   @staticmethod
   def ShortBranchName(branch):
     """Converts a name like 'refs/heads/foo' to just 'foo'."""
     return branch.replace('refs/heads/', '')
 
   @staticmethod
   def GetBranchRef(cwd):
     """Returns the full branch reference, e.g. 'refs/heads/master'."""
     return GIT.Capture(['symbolic-ref', 'HEAD'], cwd=cwd).strip()
 
   @staticmethod
   def GetBranch(cwd):
     """Returns the short branch name, e.g. 'master'."""
     return GIT.ShortBranchName(GIT.GetBranchRef(cwd))
 
   @staticmethod
   def IsGitSvn(cwd):
     """Returns true if this repo looks like it's using git-svn."""
     # If you have any "svn-remote.*" config keys, we think you're using svn.
     try:
       GIT.Capture(['config', '--get-regexp', r'^svn-remote\.'], cwd=cwd)
       return True
-    except gclient_utils.CheckCallError:
+    except subprocess2.CalledProcessError:
       return False
 
   @staticmethod
   def MatchSvnGlob(url, base_url, glob_spec, allow_wildcards):
     """Return the corresponding git ref if |base_url| together with |glob_spec|
     matches the full |url|.
 
     If |allow_wildcards| is true, |glob_spec| can contain wildcards (see below).
     """
     fetch_suburl, as_ref = glob_spec.split(':')
@@ skipping 39 matching lines @@
     # 1) iterate through our branch history and find the svn URL.
     # 2) find the svn-remote that fetches from the URL.
 
     # regexp matching the git-svn line that contains the URL.
     git_svn_re = re.compile(r'^\s*git-svn-id: (\S+)@', re.MULTILINE)
 
     # We don't want to go through all of history, so read a line from the
     # pipe at a time.
     # The -100 is an arbitrary limit so we don't search forever.
     cmd = ['git', 'log', '-100', '--pretty=medium']
-    proc = gclient_utils.Popen(cmd, stdout=subprocess.PIPE)
+    proc = subprocess2.Popen(cmd, stdout=subprocess2.PIPE)
     url = None
     for line in proc.stdout:
       match = git_svn_re.match(line)
       if match:
         url = match.group(1)
         proc.stdout.close()  # Cut pipe.
         break
 
     if url:
       svn_remote_re = re.compile(r'^svn-remote\.([^.]+)\.url (.*)$')
       remotes = GIT.Capture(['config', '--get-regexp',
                             r'^svn-remote\..*\.url'], cwd=cwd).splitlines()
       for remote in remotes:
         match = svn_remote_re.match(remote)
         if match:
           remote = match.group(1)
           base_url = match.group(2)
           try:
             fetch_spec = GIT.Capture(
                 ['config', 'svn-remote.%s.fetch' % remote],
                 cwd=cwd).strip()
             branch = GIT.MatchSvnGlob(url, base_url, fetch_spec, False)
-          except gclient_utils.CheckCallError:
+          except subprocess2.CalledProcessError:
             branch = None
           if branch:
             return branch
           try:
             branch_spec = GIT.Capture(
                 ['config', 'svn-remote.%s.branches' % remote],
                 cwd=cwd).strip()
             branch = GIT.MatchSvnGlob(url, base_url, branch_spec, True)
-          except gclient_utils.CheckCallError:
+          except subprocess2.CalledProcessError:
             branch = None
           if branch:
             return branch
           try:
             tag_spec = GIT.Capture(
                 ['config', 'svn-remote.%s.tags' % remote],
                 cwd=cwd).strip()
             branch = GIT.MatchSvnGlob(url, base_url, tag_spec, True)
-          except gclient_utils.CheckCallError:
+          except subprocess2.CalledProcessError:
             branch = None
           if branch:
             return branch
 
   @staticmethod
   def FetchUpstreamTuple(cwd):
     """Returns a tuple containg remote and remote ref,
        e.g. 'origin', 'refs/heads/master'
        Tries to be intelligent and understand git-svn.
     """
     remote = '.'
     branch = GIT.GetBranch(cwd)
     try:
       upstream_branch = GIT.Capture(
           ['config', 'branch.%s.merge' % branch], cwd=cwd).strip()
-    except (gclient_utils.Error, subprocess2.CalledProcessError):
+    except subprocess2.CalledProcessError:
       upstream_branch = None
     if upstream_branch:
       try:
         remote = GIT.Capture(
             ['config', 'branch.%s.remote' % branch], cwd=cwd).strip()
-      except (gclient_utils.Error, subprocess2.CalledProcessError):
+      except subprocess2.CalledProcessError:
         pass
     else:
       try:
         upstream_branch = GIT.Capture(
             ['config', 'rietveld.upstream-branch'], cwd=cwd).strip()
-      except (gclient_utils.Error, subprocess2.CalledProcessError):
+      except subprocess2.CalledProcessError:
         upstream_branch = None
       if upstream_branch:
         try:
           remote = GIT.Capture(
               ['config', 'rietveld.upstream-remote'], cwd=cwd).strip()
-        except (gclient_utils.Error, subprocess2.CalledProcessError):
+        except subprocess2.CalledProcessError:
           pass
       else:
         # Fall back on trying a git-svn upstream branch.
         if GIT.IsGitSvn(cwd):
           upstream_branch = GIT.GetSVNBranch(cwd)
         else:
           # Else, try to guess the origin remote.
           remote_branches = GIT.Capture(['branch', '-r'], cwd=cwd).split()
           if 'origin/master' in remote_branches:
             # Fall back on origin/master if it exits.
@@ skipping 83 matching lines @@
     return (True, current_version)
 
 
 class SVN(object):
   current_version = None
 
   @staticmethod
   def Capture(args, **kwargs):
     """Always redirect stderr.
 
-    Throws an exception if non-0 is returned."""
-    return gclient_utils.CheckCall(['svn'] + args, print_error=False,
-        **kwargs)[0]
+    Throws an exception if non-0 is returned.
+    """
+    return subprocess2.check_output(['svn'] + args, **kwargs)
 
   @staticmethod
   def RunAndGetFileList(verbose, args, cwd, file_list, stdout=None):
     """Runs svn checkout, update, or status, output to stdout.
 
     The first item in args must be either "checkout", "update", or "status".
 
     svn's stdout is parsed to collect a list of files checked out or updated.
     These files are appended to file_list.  svn's stdout is also printed to
     sys.stdout as in Run.
@@ skipping 44 matching lines @@
         if line.startswith('svn: '):
           failure.append(line)
 
       try:
         gclient_utils.CheckCallAndFilterAndHeader(
             ['svn'] + args,
             cwd=cwd,
             always=verbose,
             filter_fn=CaptureMatchingLines,
             stdout=stdout)
-      except (gclient_utils.Error, subprocess2.CalledProcessError):
+      except subprocess2.CalledProcessError:
         def IsKnownFailure():
           for x in failure:
             if (x.startswith('svn: OPTIONS of') or
                 x.startswith('svn: PROPFIND of') or
                 x.startswith('svn: REPORT of') or
                 x.startswith('svn: Unknown hostname') or
                 x.startswith('svn: Server sent unexpected return value')):
               return True
           return False
 
@@ skipping 180 matching lines @@
       filename: The file to check
       property_name: The name of the SVN property, e.g. "svn:mime-type"
 
     Returns:
       The value of the property, which will be the empty string if the property
       is not set on the file.  If the file is not under version control, the
       empty string is also returned.
     """
     try:
       return SVN.Capture(['propget', property_name, filename])
-    except (gclient_utils.Error, subprocess2.CalledProcessError):
+    except subprocess2.CalledProcessError:
       return ''
 
   @staticmethod
   def DiffItem(filename, full_move=False, revision=None):
     """Diffs a single file.
 
     Should be simple, eh? No it isn't.
     Be sure to be in the appropriate directory before calling to have the
     expected relative path.
     full_move means that move or copy operations should completely recreate the
     files, usually in the prospect to apply the patch for a try job."""
     # If the user specified a custom diff command in their svn config file,
     # then it'll be used when we do svn diff, which we don't want to happen
     # since we want the unified diff.  Using --diff-cmd=diff doesn't always
     # work, since they can have another diff executable in their path that
     # gives different line endings.  So we use a bogus temp directory as the
     # config directory, which gets around these problems.
     bogus_dir = tempfile.mkdtemp()
     try:
       # Use "svn info" output instead of os.path.isdir because the latter fails
       # when the file is deleted.
       return SVN._DiffItemInternal(filename, SVN.CaptureInfo(filename),
                                    bogus_dir,
                                    full_move=full_move, revision=revision)
     finally:
-      shutil.rmtree(bogus_dir)
+      gclient_utils.RemoveDirectory(bogus_dir)
 
   @staticmethod
   def _DiffItemInternal(filename, info, bogus_dir, full_move=False,
                         revision=None):
     """Grabs the diff data."""
     command = ["diff", "--config-dir", bogus_dir, filename]
     if revision:
       command.extend(['--revision', revision])
     data = None
     if SVN.IsMovedInfo(info):
@@ skipping 29 matching lines @@
           data = SVN.Capture(command)
           if not data:
             # We put in an empty Index entry so upload.py knows about them.
             data = "Index: %s\n" % filename.replace(os.sep, '/')
         # Otherwise silently ignore directories.
     else:
       if info.get("Node Kind") != "directory":
         # Normal simple case.
         try:
           data = SVN.Capture(command)
-        except gclient_utils.CheckCallError:
+        except subprocess2.CalledProcessError:
           if revision:
             data = GenFakeDiff(filename)
           else:
             raise
       # Otherwise silently ignore directories.
     return data
 
   @staticmethod
   def GenerateDiff(filenames, root=None, full_move=False, revision=None):
     """Returns a string containing the diff for the given file list.
@@ skipping 43 matching lines @@
           if SVN.IsMovedInfo(info):
             # for now, the most common case is a head copy,
             # so let's just encode that as a straight up cp.
             srcurl = info.get('Copied From URL')
             root = info.get('Repository Root')
             rev = int(info.get('Copied From Rev'))
             assert srcurl.startswith(root)
             src = srcurl[len(root)+1:]
             try:
               srcinfo = SVN.CaptureInfo(srcurl)
-            except gclient_utils.CheckCallError, e:
+            except subprocess2.CalledProcessError, e:
               if not 'Not a valid URL' in e.stderr:
                 raise
               # Assume the file was deleted. No idea how to figure out at which
               # revision the file was deleted.
               srcinfo = {'Revision': rev}
             if (srcinfo.get('Revision') != rev and
                 SVN.Capture(['diff', '-r', '%d:head' % rev, srcurl])):
               metaheaders.append("#$ svn cp -r %d %s %s "
                                  "### WARNING: note non-trunk copy\n" %
                                  (rev, src, filename))
@@ skipping 13 matching lines @@
       # Use StringIO since it can be messy when diffing a directory move with
       # full_move=True.
       buf = cStringIO.StringIO()
       for d in filter(None, diffs):
         buf.write(d)
       result = buf.getvalue()
       buf.close()
       return result
     finally:
       os.chdir(previous_cwd)
-      shutil.rmtree(bogus_dir)
+      gclient_utils.RemoveDirectory(bogus_dir)
 
   @staticmethod
   def GetEmail(repo_root):
     """Retrieves the svn account which we assume is an email address."""
     try:
       infos = SVN.CaptureInfo(repo_root)
-    except (gclient_utils.Error, subprocess2.CalledProcessError):
+    except subprocess2.CalledProcessError:
       return None
 
     # Should check for uuid but it is incorrectly saved for https creds.
     root = infos['Repository Root']
     realm = root.rsplit('/', 1)[0]
     uuid = infos['UUID']
     if root.startswith('https') or not uuid:
       regexp = re.compile(r'<%s:\d+>.*' % realm)
     else:
       regexp = re.compile(r'<%s:\d+> %s' % (realm, uuid))
@@ skipping 41 matching lines @@
   def GetCheckoutRoot(directory):
     """Returns the top level directory of the current repository.
 
     The directory is returned as an absolute path.
     """
     directory = os.path.abspath(directory)
     try:
       info = SVN.CaptureInfo(directory)
       cur_dir_repo_root = info['Repository Root']
       url = info['URL']
-    except (gclient_utils.Error, subprocess2.CalledProcessError):
+    except subprocess2.CalledProcessError:
       return None
     while True:
       parent = os.path.dirname(directory)
       try:
         info = SVN.CaptureInfo(parent)
         if (info['Repository Root'] != cur_dir_repo_root or
             info['URL'] != os.path.dirname(url)):
           break
         url = info['URL']
-      except (gclient_utils.Error, subprocess2.CalledProcessError):
+      except subprocess2.CalledProcessError:
         break
       directory = parent
     return GetCasedPath(directory)
 
   @staticmethod
   def AssertVersion(min_version):
     """Asserts svn's version is at least min_version."""
     def only_int(val):
       if val.isdigit():
         return int(val)
@@ skipping 34 matching lines @@
       if os.path.exists(file_path):
         # svn revert is really stupid. It fails on inconsistent line-endings,
         # on switched directories, etc. So take no chance and delete everything!
         # In theory, it wouldn't be necessary for property-only change but then
         # it'd have to look for switched directories, etc so it's not worth
         # optimizing this use case.
         if os.path.isfile(file_path) or os.path.islink(file_path):
           logging.info('os.remove(%s)' % file_path)
           os.remove(file_path)
         elif os.path.isdir(file_path):
-          logging.info('gclient_utils.RemoveDirectory(%s)' % file_path)
+          logging.info('RemoveDirectory(%s)' % file_path)
           gclient_utils.RemoveDirectory(file_path)
         else:
           logging.critical(
             ('No idea what is %s.\nYou just found a bug in gclient'
               ', please ping maruel@chromium.org ASAP!') % file_path)
 
       if (file_status[0][0] in ('D', 'A', '!') or
           not file_status[0][1:].isspace()):
         # Added, deleted file requires manual intervention and require calling
         # revert, like for properties.
         try:
           SVN.Capture(['revert', file_status[1]], cwd=repo_root)
-        except gclient_utils.CheckCallError:
+        except subprocess2.CalledProcessError:
           if not os.path.exists(file_path):
             continue
           raise