Add a git cache for gclient sync operations.

gclient.py

 #!/usr/bin/env python
 # 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.
 
 """Meta checkout manager supporting both Subversion and GIT.
 
 Files
   .gclient      : Current client configuration, written by 'config' command.
                   Format is a Python script defining 'solutions', a list whose
@@ skipping 880 matching lines @@
 solutions = [
   { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
     "deps_file"   : "%(deps_file)s",
     "managed"     : %(managed)s,
     "custom_deps" : {
     },
     "safesync_url": "%(safesync_url)s",
   },
 ]
+cache_dir = %(cache_dir)r
 """)
 
   DEFAULT_SNAPSHOT_SOLUTION_TEXT = ("""\
   { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
     "deps_file"   : "%(deps_file)s",
     "managed"     : %(managed)s,
     "custom_deps" : {
 %(solution_deps)s    },
     "safesync_url": "%(safesync_url)s",
@@ skipping 32 matching lines @@
     except SyntaxError, e:
       gclient_utils.SyntaxErrorToError('.gclient', e)
 
     # Append any target OS that is not already being enforced to the tuple.
     target_os = config_dict.get('target_os', [])
     if config_dict.get('target_os_only', False):
       self._enforced_os = tuple(set(target_os))
     else:
       self._enforced_os = tuple(set(self._enforced_os).union(target_os))
 
+    gclient_scm.GitWrapper.cache_dir = config_dict.get('cache_dir')
+
     if not target_os and config_dict.get('target_os_only', False):
       raise gclient_utils.Error('Can\'t use target_os_only if target_os is '
                                 'not specified')
 
     deps_to_add = []
     for s in config_dict.get('solutions', []):
       try:
         deps_to_add.append(Dependency(
             self, s['name'], s['url'],
             s.get('safesync_url', None),
@@ skipping 34 matching lines @@
       print >> sys.stderr, (
           'You must specify the full solution name like --revision %s@%s\n'
           'when you have multiple solutions setup in your .gclient file.\n'
           'Other solutions present are: %s.') % (
               client.dependencies[0].name,
               options.revisions[0],
               ', '.join(s.name for s in client.dependencies[1:]))
     return client
 
   def SetDefaultConfig(self, solution_name, deps_file, solution_url,
-                       safesync_url, managed=True):
+                       safesync_url, managed=True, cache_dir=None):
     self.SetConfig(self.DEFAULT_CLIENT_FILE_TEXT % {
       'solution_name': solution_name,
       'solution_url': solution_url,
       'deps_file': deps_file,
       'safesync_url' : safesync_url,
       'managed': managed,
+      'cache_dir': cache_dir,
     })
 
   def _SaveEntries(self):
     """Creates a .gclient_entries file to record the list of unique checkouts.
 
     The .gclient_entries file lives in the same directory as .gclient.
     """
     # Sometimes pprint.pformat will use {', sometimes it'll use { ' ... It
     # makes testing a bit too fun.
     result = 'entries = {\n'
@@ skipping 374 matching lines @@
   parser.add_option('--deps-file', default='DEPS',
                     help='overrides the default name for the DEPS file for the'
                          'main solutions and all sub-dependencies')
   parser.add_option('--unmanaged', action='store_true', default=False,
                     help='overrides the default behavior to make it possible '
                          'to have the main solution untouched by gclient '
                          '(gclient will check out unmanaged dependencies but '
                          'will never sync them)')
   parser.add_option('--git-deps', action='store_true',
                     help='sets the deps file to ".DEPS.git" instead of "DEPS"')
+  parser.add_option('--cache-dir',
+                    help='(git only) Cache all git repos into this dir and do '
+                         'shared clones from the cache, instead of cloning '
+                         'directly from the remote. (experimental)')
   parser.set_defaults(config_filename=None)
   (options, args) = parser.parse_args(args)
   if options.output_config_file:
     setattr(options, 'config_filename', getattr(options, 'output_config_file'))
   if ((options.spec and args) or len(args) > 2 or
       (not options.spec and not args)):
     parser.error('Inconsistent arguments. Use either --spec or one or 2 args')
 
   client = GClient('.', options)
   if options.spec:
     client.SetConfig(options.spec)
   else:
     base_url = args[0].rstrip('/')
     if not options.name:
       name = base_url.split('/')[-1]
       if name.endswith('.git'):
         name = name[:-4]
     else:
       # specify an alternate relpath for the given URL.
       name = options.name
     deps_file = options.deps_file
     if options.git_deps:
       deps_file = '.DEPS.git'
     safesync_url = ''
     if len(args) > 1:
       safesync_url = args[1]
     client.SetDefaultConfig(name, deps_file, base_url, safesync_url,
-                            managed=not options.unmanaged)
+                            managed=not options.unmanaged,
+                            cache_dir=options.cache_dir)
   client.SaveConfig()
   return 0
 
 
 @attr('epilog', """Example:
   gclient pack > patch.txt
     generate simple patch for configured client and dependences
 """)
 def CMDpack(parser, args):
   """Generate a patch which can be applied at the root of the tree.
@@ skipping 267 matching lines @@
   parser.add_option('--gclientfile', dest='config_filename',
                     default=None,
                     help='Specify an alternate %s file' % gclientfile_default)
   parser.add_option('--spec',
                     default=None,
                     help='create a gclient file containing the provided '
                          'string. Due to Cygwin/Python brokenness, it '
                          'probably can\'t contain any newlines.')
   parser.add_option('--no-nag-max', default=False, action='store_true',
                     help='If a subprocess runs for too long without generating'
-                    ' terminal output, generate warnings, but do not kill'
-                    ' the process.')
+                         ' terminal output, generate warnings, but do not kill'
+                         ' the process.')
   # Integrate standard options processing.
   old_parser = parser.parse_args
   def Parse(args):
     (options, args) = old_parser(args)
     level = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG][
         min(options.verbose, 3)]
     logging.basicConfig(level=level,
         format='%(module)s(%(lineno)d) %(funcName)s:%(message)s')
     if options.config_filename and options.spec:
       parser.error('Cannot specifiy both --gclientfile and --spec')
@@ skipping 72 matching lines @@
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   fix_encoding.fix_encoding()
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: