When switching to/from a cache git dir, try to reuse as much data as possible.

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."""
 
 import collections
 import logging
 import os
 import posixpath
@@ skipping 380 matching lines @@
         url != 'git://foo' and
         subprocess2.capture(
             ['git', 'config', 'remote.origin.gclient-auto-fix-url'],
             cwd=self.checkout_path).strip() != 'False'):
       print('_____ switching %s to a new upstream' % self.relpath)
       # Make sure it's clean
       self._CheckClean(rev_str)
       # Switch over to the new upstream
       self._Run(['remote', 'set-url', 'origin', url], options)
       self._FetchAndReset(revision, file_list, options)
+
+      # If we switched from a cached git repo to an uncached one or vice versa,
+      # set up the objects link and pack appropriately.
+      altfile = os.path.join(
+        self.checkout_path, '.git', 'objects', 'info', 'alternates')
+      if self.cache_dir:
+        with open(altfile, 'wa') as f:
+          f.write(os.path.join(url, 'objects'))
+        self._Run(['repack', '-ad'], options)
+        self._Run(['repack', '-adl'], options)
+      elif os.path.exists(altfile):
+        self._Run(['repack', '-a'], options)
+        os.remove(altfile)

[iannucci, 2013/07/12 23:32:10]

Actually, we should do this in the non-switch case as well, in case we did the
url rewrite, but haven't broken the dependency yet.

       return
 
     if not self._IsValidGitRepo():
       # .git directory is hosed for some reason, set it back up.
       print('_____ %s/.git is corrupted, rebuilding' % self.relpath)
       self._Run(['init'], options)
       self._Run(['remote', 'set-url', 'origin', url], options)
 
     if not self._HasHead():
       # Previous checkout was aborted before branches could be created in repo,
@@ skipping 335 matching lines @@
 
     # Replace - with -- to avoid ambiguity. / with - to flatten folder structure
     folder = os.path.join(
       self.cache_dir,
       self._NormalizeGitURL(url).replace('-', '--').replace('/', '-'))
 
     v = ['-v'] if options.verbose else []
     filter_fn = lambda l: '[up to date]' not in l
     with self.cache_locks[folder]:
       gclient_utils.safe_makedirs(self.cache_dir)
+      do_fetch = True
       if not os.path.exists(os.path.join(folder, 'config')):
+        do_fetch = False
         gclient_utils.rmtree(folder)
-        self._Run(['clone'] + v + ['-c', 'core.deltaBaseCacheLimit=2g',
-                                   '--progress', '--mirror', url, folder],
+        cmd = ['clone'] + v + ['-c', 'core.deltaBaseCacheLimit=2g',
+                               '--progress', '--mirror']
+        if os.path.exists(self.checkout_path):
+          cmd += ['--reference', os.path.abspath(self.checkout_path)]
+        self._Run(cmd + [url, folder],
                   options, git_filter=True, filter_fn=filter_fn,
                   cwd=self.cache_dir)
-      else:
+
+      # If the clone has an object dependency on the existing repo, break it
+      # with repack and remove the linkage.
+      cache_alt_file = os.path.join(folder, 'objects', 'info', 'alternates')
+      if os.path.exists(cache_alt_file):
+        self._Run(['repack', '-a'], options, cwd=folder)
+        os.remove(cache_alt_file)
+
+      if do_fetch:
         # For now, assert that host/path/to/repo.git is identical. We may want
         # to relax this restriction in the future to allow for smarter cache
         # repo update schemes (such as pulling the same repo, but from a
         # different host).
         existing_url = self._Capture(['config', 'remote.origin.url'],
-                                     cwd=folder)
+                                      cwd=folder)
         assert self._NormalizeGitURL(existing_url) == self._NormalizeGitURL(url)
 
         # Would normally use `git remote update`, but it doesn't support
         # --progress, so use fetch instead.
         self._Run(['fetch'] + v + ['--multiple', '--progress', '--all'],
                   options, git_filter=True, filter_fn=filter_fn, cwd=folder)
     return folder
 
   def _Clone(self, revision, url, options):
     """Clone a git repository from the given URL.
@@ skipping 646 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