git recipe_module: add experimental git-cache support.

recipe_modules/git/api.py

 # Copyright 2013 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.
 
 import itertools
 import re
 
 from recipe_engine import recipe_api
 
 class GitApi(recipe_api.RecipeApi):
   _GIT_HASH_RE = re.compile('[0-9a-f]{40}', re.IGNORECASE)
 
   def __init__(self, *args, **kwargs):
     super(GitApi, self).__init__(*args, **kwargs)
     self.initialized_win_git = False
 
   def __call__(self, *args, **kwargs):
     """Return a git command step."""
-    name = kwargs.pop('name', 'git '+args[0])
+    name = kwargs.pop('name', 'git ' + args[0])
     infra_step = kwargs.pop('infra_step', True)
     if 'cwd' not in kwargs:
       kwargs.setdefault('cwd', self.m.path['checkout'])
     git_cmd = ['git']
     if self.m.platform.is_win:
       self.ensure_win_git_tooling()
       git_cmd = [self.package_repo_resource('git.bat')]
     options = kwargs.pop('git_config_options', {})
     for k, v in sorted(options.iteritems()):
       git_cmd.extend(['-c', '%s=%s' % (k, v)])
@@ skipping 96 matching lines @@
       if can_fail_build:
         raise recipe_api.InfraFailure('count-objects failed: %s' % ex)
       return None
 
   def checkout(self, url, ref=None, dir_path=None, recursive=False,
                submodules=True, submodule_update_force=False,
                keep_paths=None, step_suffix=None,
                curl_trace_file=None, can_fail_build=True,
                set_got_revision=False, remote_name=None,
                display_fetch_size=None, file_name=None,
-               submodule_update_recursive=True):
-    """Returns an iterable of steps to perform a full git checkout.
+               submodule_update_recursive=True,
+               use_git_cache=False):
+    """Performs a full git checkout and returns sha1 of checked out revision.
+
     Args:
       url (str): url of remote repo to use as upstream
       ref (str): ref to fetch and check out
       dir_path (Path): optional directory to clone into
       recursive (bool): whether to recursively fetch submodules or not
       submodules (bool): whether to sync and update submodules or not
       submodule_update_force (bool): whether to update submodules with --force
       keep_paths (iterable of strings): paths to ignore during git-clean;
           paths are gitignore-style patterns relative to checkout_path.
       step_suffix (str): suffix to add to a each step name
       curl_trace_file (Path): if not None, dump GIT_CURL_VERBOSE=1 trace to that
           file. Useful for debugging git issue reproducible only on bots. It has
           a side effect of all stderr output of 'git fetch' going to that file.
       can_fail_build (bool): if False, ignore errors during fetch or checkout.
       set_got_revision (bool): if True, resolves HEAD and sets got_revision
           property.
       remote_name (str): name of the git remote to use
       display_fetch_size (bool): if True, run `git count-objects` before and
         after fetch and display delta. Adds two more steps. Defaults to False.
       file_name (str): optional path to a single file to checkout.
       submodule_update_recursive (bool): if True, updates submodules
           recursively.
+      use_git_cache (bool): if True, git cache will be used for this checkout.
+          WARNING, this is EXPERIMENTAL!!! This wasn't tested with:
+           * submodules
+           * since origin url is modified
+             to a local path, may cause problem with scripts that do
+             "git fetch origin" or "git push origin".
+           * arbitrary refs such refs/whatever/not-fetched-by-default-to-cache
 
     Returns: If the checkout was successful, this returns the commit hash of
       the checked-out-repo. Otherwise this returns None.
     """
     retVal = None
 
     # TODO(robertocn): Break this function and refactor calls to it.
     #     The problem is that there are way too many unrealated use cases for
     #     it, and the function's signature is getting unwieldy and its body
     #     unreadable.
@@ skipping 22 matching lines @@
       self.ensure_win_git_tooling()
       git_setup_args += [
           '--git_cmd_path', self.package_repo_resource('git.bat')]
 
     step_suffix = '' if step_suffix is  None else ' (%s)' % step_suffix
     self.m.python(
         'git setup%s' % step_suffix,
         self.resource('git_setup.py'),
         git_setup_args)
 
+    if use_git_cache:
+      self('retry', 'cache', 'fetch', '-c', self.m.path['git_cache'],
+           cwd=dir_path,
+           name='fetch cache',
+           can_fail_build=can_fail_build)
+
     # There are five kinds of refs we can be handed:
     # 0) None. In this case, we default to properties['branch'].
     # 1) A 40-character SHA1 hash.
     # 2) A fully-qualifed arbitrary ref, e.g. 'refs/foo/bar/baz'.
     # 3) A fully qualified branch name, e.g. 'refs/heads/master'.
     #    Chop off 'refs/heads' and now it matches case (4).
     # 4) A branch name, e.g. 'master'.
     # Note that 'FETCH_HEAD' can be many things (and therefore not a valid
     # checkout target) if many refs are fetched, but we only explicitly fetch
     # one ref here, so this is safe.
@@ skipping 157 matching lines @@
 
     Args:
       bundle_path (Path): The path of the output bundle.
       refs (list): The list of refs to include in the bundle. If None, all
           refs in the Git checkout will be bundled.
       kwargs: Forwarded to '__call__'.
     """
     if not rev_list_args:
       rev_list_args = ['--all']
     self('bundle', 'create', bundle_path, *rev_list_args, **kwargs)