Add options argument to _Run() to redirect output.

gclient_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.
 
 """Gclient-specific SCM-specific operations."""
 
 import logging
 import os
 import posixpath
 import re
@@ skipping 110 matching lines @@
 
   @staticmethod
   def cleanup(options, args, file_list):
     """'Cleanup' the repo.
 
     There's no real git equivalent for the svn cleanup command, do a no-op.
     """
 
   def diff(self, options, args, file_list):
     merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
-    self._Run(['diff', merge_base])
+    self._Run(['diff', merge_base], options)
 
   def export(self, options, args, file_list):
     """Export a clean directory tree into the given path.
 
     Exports into the specified directory, creating the path if it does
     already exist.
     """
     assert len(args) == 1
     export_path = os.path.abspath(os.path.join(args[0], self.relpath))
     if not os.path.exists(export_path):
       os.makedirs(export_path)
-    self._Run(['checkout-index', '-a', '--prefix=%s/' % export_path])
+    self._Run(['checkout-index', '-a', '--prefix=%s/' % export_path],
+              options)
 
   def pack(self, options, args, file_list):
     """Generates a patch file which can be applied to the root of the
     repository.
 
     The patch file is generated from a diff of the merge base of HEAD and
     its upstream branch.
     """
     merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
     gclient_utils.CheckCallAndFilter(
@@ skipping 121 matching lines @@
           continue
         raise
 
     if verbose:
       options.stdout.write(remote_output.strip() + '\n')
       # git remote update prints to stderr when used with --verbose
       options.stdout.write(remote_err.strip() + '\n')
 
     # This is a big hammer, debatable if it should even be here...
     if options.force or options.reset:
-      self._Run(['reset', '--hard', 'HEAD'])
+      self._Run(['reset', '--hard', 'HEAD'], options)
 
     if current_type == 'detached':
       # case 0
       self._CheckClean(rev_str)
       self._CheckDetachedHead(rev_str, options)
       self._Capture(['checkout', '--quiet', '%s^0' % revision])
       if not printed_path:
         options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
     elif current_type == 'hash':
       # case 1
@@ skipping 123 matching lines @@
       return self.update(options, [], file_list)
 
     default_rev = "refs/heads/master"
     _, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     if not deps_revision:
       deps_revision = default_rev
     if deps_revision.startswith('refs/heads/'):
       deps_revision = deps_revision.replace('refs/heads/', 'origin/')
 
     files = self._Capture(['diff', deps_revision, '--name-only']).split()
-    self._Run(['reset', '--hard', deps_revision])
+    self._Run(['reset', '--hard', deps_revision], options)
     file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def revinfo(self, options, args, file_list):
     """Returns revision"""
     return self._Capture(['rev-parse', 'HEAD'])
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
     if not os.path.isdir(self.checkout_path):
       options.stdout.write(
           ('\n________ couldn\'t run status in %s:\nThe directory '
            'does not exist.\n') % self.checkout_path)
     else:
       merge_base = self._Capture(['merge-base', 'HEAD', 'origin'])
-      self._Run(['diff', '--name-status', merge_base])
+      self._Run(['diff', '--name-status', merge_base], options)
       files = self._Capture(['diff', '--name-only', merge_base]).split()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def FullUrlForRelativeUrl(self, url):
     # Strip from last '/'
     # Equivalent to unix basename
     base_url = self.url
     return base_url[:base_url.rfind('/')] + url
 
   def _Clone(self, revision, url, options):
@@ skipping 15 matching lines @@
       detach_head = False
     else:
       clone_cmd.append('--no-checkout')
       detach_head = True
     if options.verbose:
       clone_cmd.append('--verbose')
     clone_cmd.extend([url, self.checkout_path])
 
     for _ in range(3):
       try:
-        self._Run(clone_cmd, cwd=self._root_dir)
+        self._Run(clone_cmd, options, cwd=self._root_dir)
         break
       except gclient_utils.Error, e:
         # TODO(maruel): Hackish, should be fixed by moving _Run() to
         # CheckCall().
         # Too bad we don't have access to the actual output.
         # We should check for "transfer closed with NNN bytes remaining to
         # read". In the meantime, just make sure .git exists.
         if (e.args[0] == 'git command clone returned 128' and
             os.path.exists(os.path.join(self.checkout_path, '.git'))):
           options.stdout.write(str(e) + '\n')
@@ skipping 43 matching lines @@
       if re.match(r'cannot rebase: you have unstaged changes', e.stderr) or \
          re.match(r'cannot rebase: your index contains uncommitted changes',
                   e.stderr):
         while True:
           rebase_action = str(raw_input("Cannot rebase because of unstaged "
                                         "changes.\n'git reset --hard HEAD' ?\n"
                                         "WARNING: destroys any uncommitted "
                                         "work in your current branch!"
                                         " (y)es / (q)uit / (s)how : "))
           if re.match(r'yes|y', rebase_action, re.I):
-            self._Run(['reset', '--hard', 'HEAD'])
+            self._Run(['reset', '--hard', 'HEAD'], options)
             # Should this be recursive?
             rebase_output, rebase_err = scm.GIT.Capture(rebase_cmd,
                                                         self.checkout_path)
             break
           elif re.match(r'quit|q', rebase_action, re.I):
             raise gclient_utils.Error("Please merge or rebase manually\n"
                                       "cd %s && git " % self.checkout_path
                                       + "%s" % ' '.join(rebase_cmd))
           elif re.match(r'show|s', rebase_action, re.I):
             options.stdout.write('\n%s\n' % e.stderr.strip())
@@ skipping 90 matching lines @@
     # Returns name of current branch or None for detached HEAD
     branch = self._Capture(['rev-parse', '--abbrev-ref=strict', 'HEAD'])
     if branch == 'HEAD':
       return None
     return branch
 
   def _Capture(self, args):
     return gclient_utils.CheckCall(['git'] + args,
                                    cwd=self.checkout_path)[0].strip()
 
-  def _Run(self, args, **kwargs):
+  def _Run(self, args, options, **kwargs):
     kwargs.setdefault('cwd', self.checkout_path)
-    try:
-      gclient_utils.Popen(['git'] + args, **kwargs).communicate()
-    except OSError:
-      raise gclient_utils.Error("git command '%s' failed to run." %
-              ' '.join(cmd) + "\nCheck that you have git installed.")
+    gclient_utils.CheckCallAndFilterAndHeader(['git'] + args,
+        always=options.verbose, stdout=options.stdout, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
     self._Run(['cleanup'] + args, options)
 
   def diff(self, options, args, file_list):
@@ skipping 287 matching lines @@
 
     This method returns a new list to be used as a command."""
     new_command = command[:]
     if revision:
       new_command.extend(['--revision', str(revision).strip()])
     # --force was added to 'svn update' in svn 1.5.
     if ((options.force or options.manually_grab_svn_rev) and
         scm.SVN.AssertVersion("1.5")[0]):
       new_command.append('--force')
     return new_command