Make git-cl-land wait

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 1875 matching lines @@
       base_svn_head += '^1'
 
     extra_commits = RunGit(['rev-list', '^' + svn_head, base_svn_head])
     if extra_commits:
       print ('This branch has %d additional commits not upstreamed yet.'
              % len(extra_commits.splitlines()))
       print ('Upstream "%s" or rebase this branch on top of the upstream trunk '
              'before attempting to %s.' % (base_branch, cmd))
       return 1
 
-  base_branch = RunGit(['merge-base', base_branch, 'HEAD']).strip()
+  merge_base = RunGit(['merge-base', base_branch, 'HEAD']).strip()
   if not options.bypass_hooks:
     author = None
     if options.contributor:
       author = re.search(r'\<(.*)\>', options.contributor).group(1)
     hook_results = cl.RunHook(
         committing=True,
         may_prompt=not options.force,
         verbose=options.verbose,
-        change=cl.GetChange(base_branch, author))
+        change=cl.GetChange(merge_base, author))
     if not hook_results.should_continue():
       return 1
 
     # Check the tree status if the tree status URL is set.
     status = GetTreeStatus()
     if 'closed' == status:
       print('The tree is closed.  Please wait for it to reopen. Use '
             '"git cl %s --bypass-hooks" to commit on a closed tree.' % cmd)
       return 1
     elif 'unknown' == status:
       print('Unable to determine tree status.  Please verify manually and '
             'use "git cl %s --bypass-hooks" to commit on a closed tree.' % cmd)
       return 1
   else:
     breakpad.SendStack(
         'GitClHooksBypassedCommit',
         'Issue %s/%s bypassed hook when committing (tree status was "%s")' %
         (cl.GetRietveldServer(), cl.GetIssue(), GetTreeStatus()),
         verbose=False)
 
   change_desc = ChangeDescription(options.message)
   if not change_desc.description and cl.GetIssue():
     change_desc = ChangeDescription(cl.GetDescription())
 
   if not change_desc.description:
     if not cl.GetIssue() and options.bypass_hooks:
-      change_desc = ChangeDescription(CreateDescriptionFromLog([base_branch]))
+      change_desc = ChangeDescription(CreateDescriptionFromLog([merge_base]))
     else:
       print 'No description set.'
       print 'Visit %s/edit to set it.' % (cl.GetIssueURL())
       return 1
 
   # Keep a separate copy for the commit message, because the commit message
   # contains the link to the Rietveld issue, while the Rietveld message contains
   # the commit viewvc url.
   # Keep a separate copy for the commit message.
   if cl.GetIssue():
     change_desc.update_reviewers(cl.GetApprovingReviewers())
 
   commit_desc = ChangeDescription(change_desc.description)
   if cl.GetIssue():
     commit_desc.append_footer('Review URL: %s' % cl.GetIssueURL())
   if options.contributor:
     commit_desc.append_footer('Patch from %s.' % options.contributor)
 
   print('Description:')
   print(commit_desc.description)
 
-  branches = [base_branch, cl.GetBranchRef()]
+  branches = [merge_base, cl.GetBranchRef()]
   if not options.force:
     print_stats(options.similarity, options.find_copies, branches)
 
   # We want to squash all this branch's commits into one commit with the proper
   # description. We do this by doing a "reset --soft" to the base branch (which
   # keeps the working copy the same), then dcommitting that.  If origin/master
   # has a submodule merge commit, we'll also need to cherry-pick the squashed
   # commit onto a branch based on the git-svn head.
   MERGE_BRANCH = 'git-cl-commit'
   CHERRY_PICK_BRANCH = 'git-cl-cherry-pick'
   # Delete the branches if they exist.
   for branch in [MERGE_BRANCH, CHERRY_PICK_BRANCH]:
     showref_cmd = ['show-ref', '--quiet', '--verify', 'refs/heads/%s' % branch]
     result = RunGitWithCode(showref_cmd)
     if result[0] == 0:
       RunGit(['branch', '-D', branch])
 
   # We might be in a directory that's present in this branch but not in the
   # trunk.  Move up to the top of the tree so that git commands that expect a
   # valid CWD won't fail after we check out the merge branch.
   rel_base_path = settings.GetRelativeRoot()
   if rel_base_path:
     os.chdir(rel_base_path)
 
   # Stuff our change into the merge branch.
   # We wrap in a try...finally block so if anything goes wrong,
   # we clean up the branches.
   retcode = -1
-  used_pending = False
+  pushed_to_pending = False
   pending_ref = None
+  revision = None
   try:
     RunGit(['checkout', '-q', '-b', MERGE_BRANCH])
-    RunGit(['reset', '--soft', base_branch])
+    RunGit(['reset', '--soft', merge_base])
     if options.contributor:
       RunGit(
           [
             'commit', '--author', options.contributor,
             '-m', commit_desc.description,
           ])
     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())
       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])
-        used_pending = pending_prefix and branch.startswith(pending_prefix)
+        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)
-        used_pending = (retcode == 0)
+        revision = RunGit(['rev-parse', 'HEAD']).strip()
+        pushed_to_pending = (retcode == 0)
       logging.debug(output)
     else:
       # dcommit the merge branch.
       retcode, output = RunGitWithCode(['svn', 'dcommit',
                                         '-C%s' % options.similarity,
                                         '--no-rebase', '--rmdir'])
   finally:
     # And then swap back to the original branch and clean up.
     RunGit(['checkout', '-q', cl.GetBranch()])
     RunGit(['branch', '-D', MERGE_BRANCH])
     if base_has_submodules:
       RunGit(['branch', '-D', CHERRY_PICK_BRANCH])
 
+  if retcode == 0 and pushed_to_pending:
+    try:
+      revision = WaitForRealCommit(remote, revision, base_branch, branch)
+      # We set pushed_to_pending to False, since it made it all the way to the
+      # real ref.
+      pushed_to_pending = False
+    except KeyboardInterrupt:
+      pass
+
   if cl.GetIssue():
-    if cmd == 'dcommit' and 'Committed r' in output:
-      revision = re.match('.*?\nCommitted r(\\d+)', output, re.DOTALL).group(1)
-    elif cmd == 'land' and retcode == 0:
-      match = (re.match(r'.*?([a-f0-9]{7,})\.\.([a-f0-9]{7,})$', l)
-               for l in output.splitlines(False))
-      match = filter(None, match)
-      if len(match) != 1:
-        DieWithError("Couldn't parse ouput to extract the committed hash:\n%s" %
-            output)
-      revision = match[0].group(2)
-    else:
-      return 1
-    to_pending = ' to pending queue' if used_pending else ''
+    if not revision:
+      if cmd == 'dcommit' and 'Committed r' in output:
+        revision = re.match(
+          '.*?\nCommitted r(\\d+)', output, re.DOTALL).group(1)
+      elif cmd == 'land' and retcode == 0:
+        match = (re.match(r'.*?([a-f0-9]{7,})\.\.([a-f0-9]{7,})$', l)
+                 for l in output.splitlines(False))
+        match = filter(None, match)
+        if len(match) != 1:
+          DieWithError(
+            "Couldn't parse ouput to extract the committed hash:\n%s" % output)
+        revision = match[0].group(2)
+      else:
+        return 1
+
+    revision = revision[:7]
+
+    to_pending = ' to pending queue' if pushed_to_pending else ''
     viewvc_url = settings.GetViewVCUrl()
-    if viewvc_url and revision:
-      change_desc.append_footer(
-          'Committed%s: %s%s' % (to_pending, viewvc_url, revision))
-    elif revision:
-      change_desc.append_footer('Committed%s: %s' % (to_pending, revision))
+    if not to_pending:
+      if viewvc_url and revision:
+        change_desc.append_footer(
+            'Committed: %s%s' % (viewvc_url, revision))
+      elif revision:
+        change_desc.append_footer('Committed: %s' % (revision,))
     print ('Closing issue '
            '(you may be prompted for your codereview password)...')
     cl.UpdateDescription(change_desc.description)
     cl.CloseIssue()
     props = cl.GetIssueProperties()
     patch_num = len(props['patchsets'])
     comment = "Committed patchset #%d (id:%d)%s manually as %s" % (
         patch_num, props['patchsets'][-1], to_pending, revision)
     if options.bypass_hooks:
       comment += ' (tree was closed).' if GetTreeStatus() == 'closed' else '.'
     else:
       comment += ' (presubmit successful).'
     cl.RpcServer().add_comment(cl.GetIssue(), comment)
     cl.SetIssue(None)
 
-  if used_pending and retcode == 0:
+  if pushed_to_pending and retcode == 0:
     _, branch = cl.FetchUpstreamTuple(cl.GetBranch())
     print 'The commit is in the pending queue (%s).' % pending_ref
     print (
         'It will show up on %s in ~1 min, once it gets Cr-Commit-Position '
         'footer.' % branch)
 
   if retcode == 0:
     hook = POSTUPSTREAM_HOOK_PATTERN % cmd
     if os.path.isfile(hook):
-      RunCommand([hook, base_branch], error_ok=True)
+      RunCommand([hook, merge_base], error_ok=True)
 
   return 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()
+
+  loop = 0
+  while True:
+    sys.stdout.write('fetching (%d)...        \r' % loop)
+    sys.stdout.flush()
+    loop += 1
+
+    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
+
+
 def PushToGitPending(remote, pending_ref, upstream_ref):
   """Fetches pending_ref, cherry-picks current HEAD on top of it, pushes.
 
   Returns:
     (retcode of last operation, output log of last operation).
   """
   assert pending_ref.startswith('refs/'), pending_ref
   local_pending_ref = 'refs/git-cl/' + pending_ref[len('refs/'):]
   cherry = RunGit(['rev-parse', 'HEAD']).strip()
   code = 0
@@ skipping 27 matching lines @@
       print 'Please rebase your patch and try again.'
       RunGitWithCode(['cherry-pick', '--abort'])
       return code, out
 
     # Applied cleanly, try to push now. Retry on error (flake or non-ff push).
     print 'Pushing commit to %s... It can take a while.' % pending_ref
     code, out = RunGitWithCode(
         ['retry', 'push', '--porcelain', remote, 'HEAD:%s' % pending_ref])
     if code == 0:
       # Success.
+      print 'Commit pushed to pending ref successfully!'
       return code, out
 
     print 'Push failed with exit code %d.' % code
     if out.strip():
       print out.strip()
     if IsFatalPushFailure(out):
       print (
           'Fatal push error. Make sure your .netrc credentials and git '
           'user.email are correct and you have push access to the repo.')
       return code, out
@@ skipping 628 matching lines @@
         ('AppEngine is misbehaving and returned HTTP %d, again. Keep faith '
           'and retry or visit go/isgaeup.\n%s') % (e.code, str(e)))
 
 
 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()
   sys.exit(main(sys.argv[1:]))