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

[szager1, 2013/07/03 16:49:52]

str(None) == repr(None), so for the sake of consistency, maybe make this
%(cache_dir)s

[iannucci, 2013/07/03 19:07:32]

Ah, but str('foobar') != repr('foobar') :)

we need the quotes.

 """)
 
   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.SCMWrapper.cache_dir = (gclient_scm.SCMWrapper.cache_dir or
+                                        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 401 matching lines @@
     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.')
+  parser.add_option('--cache-dir',

[szager1, 2013/07/03 16:49:52]

I think I'd prefer that --cache-dir can only be specified when running 'gclient
init'.  For all other commands, the setting must come from the .gclient file.  I
can't think of a good reason to allow people to override --cache-dir on
individual gclient invocations, and it creates an opportunity for lots of
mistakes.

[iannucci, 2013/07/03 19:07:32]

Fair enough.

+                    help='(git only) Cache all repos into this dir and do '
+                         'shared clones from the cache, instead of cloning '
+                         'directly from the remote. (experimental)')
   # 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 12 matching lines @@
     if not hasattr(options, 'nohooks'):
       options.nohooks = True
     if not hasattr(options, 'deps_os'):
       options.deps_os = None
     if not hasattr(options, 'manually_grab_svn_rev'):
       options.manually_grab_svn_rev = None
     if not hasattr(options, 'force'):
       options.force = None
     if options.no_nag_max:
       gclient_scm.SCMWrapper.nag_max = None
+    if options.cache_dir:
+      gclient_scm.SCMWrapper.cache_dir = options.cache_dir
     return (options, args)
   parser.parse_args = Parse
   # We don't want wordwrapping in epilog (usually examples)
   parser.format_epilog = lambda _: parser.epilog or ''
   return parser
 
 
 def Main(argv):
   """Doesn't parse the arguments here, just find the right subcommand to
   execute."""
@@ skipping 40 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: