Enable git-cl-land for git-cache checkouts.

git_cl.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.
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 """A git-command for integrating reviews on Rietveld."""
 
 from distutils.version import LooseVersion
@@ skipping 29 matching lines @@
 from third_party import colorama
 from third_party import httplib2
 from third_party import upload
 import auth
 from luci_hacks import trigger_luci_job as luci_trigger
 import clang_format
 import commit_queue
 import dart_format
 import fix_encoding
 import gclient_utils
+import git_cache
 import git_common
 import git_footers
 import owners
 import owners_finder
 import presubmit_support
 import rietveld
 import scm
 import subcommand
 import subprocess2
 import watchlists
@@ skipping 561 matching lines @@
 
   @staticmethod
   def GetRelativeRoot():
     return RunGit(['rev-parse', '--show-cdup']).strip()
 
   def GetRoot(self):
     if self.root is None:
       self.root = os.path.abspath(self.GetRelativeRoot())
     return self.root
 
+  def GetGitMirror(self, remote='origin'):
+    """If this checkout is from a local git mirror, return a Mirror object."""
+    local_url = RunGit(['remote', 'get-url', remote]).strip()

[smut, 2016/03/09 22:17:31]

"git remote get-url" is not available in all versions of git, and this is
causing failures for iOS now (https://crbug.com/593279). Can you change this to
"git config remote.<remote>.url"?

+    if not os.path.isdir(local_url):
+      return None
+    git_cache.Mirror.SetCachePath(os.path.dirname(local_url))
+    remote_url = git_cache.Mirror.CacheDirToUrl(local_url)
+    # Use the /dev/null print_func to avoid terminal spew in WaitForRealCommit.
+    mirror = git_cache.Mirror(remote_url, print_func = lambda *args: None)
+    if mirror.exists():
+      return mirror
+    return None
+
   def GetIsGitSvn(self):
     """Return true if this repo looks like it's using git-svn."""
     if self.is_git_svn is None:
       if self.GetPendingRefPrefix():
         # If PENDING_REF_PREFIX is set then it's a pure git repo no matter what.
         self.is_git_svn = False
       else:
         # If you have any "svn-remote.*" config keys, we think you're using svn.
         self.is_git_svn = RunGitWithCode(
             ['config', '--local', '--get-regexp', r'^svn-remote\.'])[0] == 0
@@ skipping 2217 matching lines @@
           ])
     else:
       RunGit(['commit', '-m', commit_desc.description])
     if base_has_submodules:
       cherry_pick_commit = RunGit(['rev-list', 'HEAD^!']).rstrip()
       RunGit(['branch', CHERRY_PICK_BRANCH, svn_head])
       RunGit(['checkout', CHERRY_PICK_BRANCH])
       RunGit(['cherry-pick', cherry_pick_commit])
     if cmd == 'land':
       remote, branch = cl.FetchUpstreamTuple(cl.GetBranch())
+      mirror = settings.GetGitMirror(remote)
+      pushurl = mirror.url if mirror else remote
       pending_prefix = settings.GetPendingRefPrefix()
       if not pending_prefix or branch.startswith(pending_prefix):
         # If not using refs/pending/heads/* at all, or target ref is already set
         # to pending, then push to the target ref directly.
         retcode, output = RunGitWithCode(
-            ['push', '--porcelain', remote, 'HEAD:%s' % branch])
+            ['push', '--porcelain', pushurl, 'HEAD:%s' % branch])
         pushed_to_pending = pending_prefix and branch.startswith(pending_prefix)
       else:
         # Cherry-pick the change on top of pending ref and then push it.
         assert branch.startswith('refs/'), branch
         assert pending_prefix[-1] == '/', pending_prefix
         pending_ref = pending_prefix + branch[len('refs/'):]
-        retcode, output = PushToGitPending(remote, pending_ref, branch)
+        retcode, output = PushToGitPending(pushurl, pending_ref, branch)
         pushed_to_pending = (retcode == 0)
       if retcode == 0:
         revision = RunGit(['rev-parse', 'HEAD']).strip()
     else:
       # dcommit the merge branch.
       cmd_args = [
         'svn', 'dcommit',
         '-C%s' % options.similarity,
         '--no-rebase', '--rmdir',
       ]
@@ skipping 67 matching lines @@
 
   return 1 if killed else 0
 
 
 def WaitForRealCommit(remote, pushed_commit, local_base_ref, real_ref):
   print
   print 'Waiting for commit to be landed on %s...' % real_ref
   print '(If you are impatient, you may Ctrl-C once without harm)'
   target_tree = RunGit(['rev-parse', '%s:' % pushed_commit]).strip()
   current_rev = RunGit(['rev-parse', local_base_ref]).strip()
+  mirror = settings.GetGitMirror(remote)
 
   loop = 0
   while True:
     sys.stdout.write('fetching (%d)...        \r' % loop)
     sys.stdout.flush()
     loop += 1
 
+    if mirror:
+      mirror.populate()
     RunGit(['retry', 'fetch', remote, real_ref], stderr=subprocess2.VOID)
     to_rev = RunGit(['rev-parse', 'FETCH_HEAD']).strip()
     commits = RunGit(['rev-list', '%s..%s' % (current_rev, to_rev)])
     for commit in commits.splitlines():
       if RunGit(['rev-parse', '%s:' % commit]).strip() == target_tree:
         print 'Found commit on %s' % real_ref
         return commit
 
     current_rev = to_rev
 
@@ skipping 979 matching lines @@
 if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
   colorama.init()
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)