Added common git 'fetch' function

gclient_scm.py

 # Copyright (c) 2012 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."""
 
 from __future__ import print_function
 
 import errno
 import logging
@@ skipping 282 matching lines @@
         cwd=self.checkout_path,
         filter_fn=GitDiffFilterer(self.relpath).Filter, print_func=self.Print)
 
   def _FetchAndReset(self, revision, file_list, options):
     """Equivalent to git fetch; git reset."""
     quiet = []
     if not options.verbose:
       quiet = ['--quiet']
     self._UpdateBranchHeads(options, fetch=False)
 
-    cfg = gclient_utils.DefaultIndexPackConfig(self.url)
-    fetch_cmd = cfg + ['fetch', self.remote, '--prune']
-    self._Run(fetch_cmd + quiet, options, retry=True)
+    self._Fetch(options, prune=True, quiet=options.verbose)
     self._Run(['reset', '--hard', revision] + quiet, options)
     if file_list is not None:
       files = self._Capture(['ls-files']).splitlines()
       file_list.extend([os.path.join(self.checkout_path, f) for f in files])
 
   def _DisableHooks(self):
     hook_dir = os.path.join(self.checkout_path, '.git', 'hooks')
     if not os.path.isdir(hook_dir):
       return
     for f in os.listdir(hook_dir):
@@ skipping 399 matching lines @@
     elif rev.isdigit() and len(rev) < 7:
       # Handles an SVN rev.  As an optimization, only verify an SVN revision as
       # [0-9]{1,6} for now to avoid making a network request.
       if scm.GIT.IsGitSvn(cwd=self.checkout_path):
         local_head = scm.GIT.GetGitSvnHeadRev(cwd=self.checkout_path)
         if not local_head or local_head < int(rev):
           try:
             logging.debug('Looking for git-svn configuration optimizations.')
             if scm.GIT.Capture(['config', '--get', 'svn-remote.svn.fetch'],
                              cwd=self.checkout_path):
-              scm.GIT.Capture(['fetch'], cwd=self.checkout_path)
+              self._Fetch(options)
           except subprocess2.CalledProcessError:
             logging.debug('git config --get svn-remote.svn.fetch failed, '
                           'ignoring possible optimization.')
           if options.verbose:
             self.Print('Running git svn fetch. This might take a while.\n')
           scm.GIT.Capture(['svn', 'fetch'], cwd=self.checkout_path)
         try:
           sha1 = scm.GIT.GetBlessedSha1ForSvnRev(
               cwd=self.checkout_path, rev=rev)
         except gclient_utils.Error, e:
           sha1 = e.message
           self.Print('Warning: Could not find a git revision with accurate\n'
                  '.DEPS.git that maps to SVN revision %s.  Sync-ing to\n'
                  'the closest sane git revision, which is:\n'
                  '  %s\n' % (rev, e.message))
         if not sha1:
           raise gclient_utils.Error(
               ( 'It appears that either your git-svn remote is incorrectly\n'
                 'configured or the revision in your safesync_url is\n'
                 'higher than git-svn remote\'s HEAD as we couldn\'t find a\n'
                 'corresponding git hash for SVN rev %s.' ) % rev)
     else:
       if scm.GIT.IsValidRevision(cwd=self.checkout_path, rev=rev):
         sha1 = rev
       else:
         # May exist in origin, but we don't have it yet, so fetch and look
         # again.
-        scm.GIT.Capture(['fetch', self.remote], cwd=self.checkout_path)
+        self._Fetch(options)
         if scm.GIT.IsValidRevision(cwd=self.checkout_path, rev=rev):
           sha1 = rev
 
     if not sha1:
       raise gclient_utils.Error(
           ( 'We could not find a valid hash for safesync_url response "%s".\n'
             'Safesync URLs with a git checkout currently require a git-svn\n'
             'remote or a safesync_url that provides git sha1s. Please add a\n'
             'git-svn remote or change your safesync_url. For more info, see:\n'
             'http://code.google.com/p/chromium/wiki/UsingNewGit'
@@ skipping 266 matching lines @@
     if quiet is None:
       quiet = (not options.verbose)
     checkout_args = ['checkout']
     if force:
       checkout_args.append('--force')
     if quiet:
       checkout_args.append('--quiet')
     checkout_args.append(ref)
     return self._Capture(checkout_args)
 
+  def _Fetch(self, options, remote=None, prune=False, quiet=False):
+    cfg = gclient_utils.DefaultIndexPackConfig(self.url)
+    fetch_cmd =  cfg + [
+        'fetch',
+        remote or self.remote,
+    ]
+
+    if prune:
+      fetch_cmd.append('--prune')
+    if options.verbose:
+      fetch_cmd.append('--verbose')
+    elif quiet:
+      fetch_cmd.append('--quiet')
+    self._Run(fetch_cmd, options, show_header=options.verbose, retry=True)
+
+    # Return the revision that was fetched; this will be stored in 'FETCH_HEAD'
+    return self._Capture(['rev-parse', '--verify', 'FETCH_HEAD'])
+
   def _UpdateBranchHeads(self, options, fetch=False):
     """Adds, and optionally fetches, "branch-heads" refspecs if requested."""
     if hasattr(options, 'with_branch_heads') and options.with_branch_heads:
       config_cmd = ['config', 'remote.%s.fetch' % self.remote,
                     '+refs/branch-heads/*:refs/remotes/branch-heads/*',
                     '^\\+refs/branch-heads/\\*:.*$']
       self._Run(config_cmd, options)
       if fetch:
-        cfg = gclient_utils.DefaultIndexPackConfig(self.url)
-        fetch_cmd =  cfg + ['fetch', self.remote]
-        if options.verbose:
-          fetch_cmd.append('--verbose')
-        self._Run(fetch_cmd, options, retry=True)
+        self._Fetch(options)
 
-  def _Run(self, args, options, **kwargs):
+  def _Run(self, args, options, show_header=True, **kwargs):
+    # Disable 'unused options' warning | pylint: disable=W0613
     cwd = kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('stdout', self.out_fh)
     kwargs['filter_fn'] = self.filter
     kwargs.setdefault('print_stdout', False)
     env = scm.GIT.ApplyEnvVars(kwargs)
     cmd = ['git'] + args
-    header = "running '%s' in '%s'" % (' '.join(cmd), cwd)
-    self.filter(header)
+    if show_header:
+      header = "running '%s' in '%s'" % (' '.join(cmd), cwd)
+      self.filter(header)
     return gclient_utils.CheckCallAndFilter(cmd, env=env, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
   name = 'svn'
 
   @staticmethod
   def BinaryExists():
     """Returns true if the command exists."""
@@ skipping 452 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command