[depot_tools] New "git cl upload" flag to traverse dependent branches and re-upload them

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
 from multiprocessing.pool import ThreadPool
 import base64
+import collections
 import glob
 import httplib
 import json
 import logging
 import optparse
 import os
 import Queue
 import re
 import stat
 import sys
@@ skipping 1475 matching lines @@
               else len(branches_to_fetch))
       for x in pool.imap_unordered(fetch, branches_to_fetch):
         yield x
   else:
     # Do not use GetApprovingReviewers(), since it requires an HTTP request.
     for b in branches:
       c = Changelist(branchref=b, auth_config=auth_config)
       url = c.GetIssueURL()
       yield (b, url, Fore.BLUE if url else Fore.WHITE)
 
+
+def CMDupload_branch_deps(parser, args):
+  """Uploads CLs of local branches that are dependents of the current branch.
+
+  If the local branch dependency tree looks like:
+  test1 -> test2.1 -> test3.1
+                   -> test3.2
+        -> test2.2 -> test3.3
+
+  and you run this command from test1 then "git cl upload" is run on the
+  dependent branches in this order:
+  test2.1, test3.1, test3.2, test2.2, test3.3
+
+  Note: This command does not rebase your local dependent branches. Use it when
+        you make a change to the parent branch that will not conflict with its
+        dependent branches, and you would like their dependencies updated in
+        Rietveld.
+  """
+  auth.add_auth_options(parser)
+  (options, args) = parser.parse_args(args)
+  auth_config = auth.extract_auth_config_from_options(options)
+
+  if git_common.is_dirty_git_tree('upload-branch-deps'):
+    return 1
+
+  cl = Changelist(auth_config=auth_config)
+  root_branch = cl.GetBranch()
+  if root_branch is None:
+    DieWithError('Can\'t find dependent branches from detached HEAD state. '
+                 'Get on a branch!')
+  if not cl.GetIssue() or not cl.GetPatchset():
+    DieWithError('Current branch does not have an uploaded CL. We cannot set '
+                 'patchset dependencies without an uploaded CL.')
+
+  branches = RunGit(['for-each-ref',
+                     '--format=%(refname:short) %(upstream:short)',
+                     'refs/heads'])
+  if not branches:
+    print('No local branches found.')
+    return 0
+
+  # Create a dictionary of all local branches to the branches that are dependent

[agable, 2015/06/17 18:13:34]

Seems like you should be able to reuse code from git-map-branches for this? It
creates the whole dependency tree, you could just reuse that and then grab the
subtree you care about here.

[rmistry, 2015/06/18 17:52:40]

My comment for this is similar to my earlier comment about get_branch_tree and
topo_iter:

I took a look at git_map_branches, I'm sure its possible to refactor it and
extract out, but it is not obvious and straightforward to me how to do this
cleanly without complicated changes (which I would like to avoid). I prefer the
code here because it is specific and optimized for this particular usecase.

+  # on it.
+  tracked_to_dependents = collections.defaultdict(list)
+  for b in branches.splitlines():
+    tokens = b.split()
+    if len(tokens) == 2:
+      branch_name, tracked = tokens
+      tracked_to_dependents[tracked].append(branch_name)
+
+  print
+  print 'The dependent local branches of %s are:' % root_branch
+  dependents = []
+  def traverse_dependents_preorder(branch, padding=''):
+    dependents_to_process = tracked_to_dependents.get(branch, [])
+    padding += '  '
+    for dependent in dependents_to_process:
+      print '%s%s' % (padding, dependent)
+      dependents.append(dependent)
+      traverse_dependents_preorder(dependent, padding)
+  traverse_dependents_preorder(root_branch)
+  print
+
+  print ('This command will checkout all dependent branches and run '
+         '"git cl upload".')
+  ask_for_data('[Press enter to continue or ctrl-C to quit]')
+
+  if not dependents:

[agable, 2015/06/17 18:13:34]

Do this before requiring user input above.

[rmistry, 2015/06/18 17:52:39]

Done.

+    print 'There are no dependent local branches for %s' % root_branch
+    return 0
+
+  # Add a default patchset title to all upload calls.
+  args.extend(['-t', 'Updated patchset dependency with upload-branch-deps'])
+  # Go through all dependents, checkout the branch and upload.
+  try:
+    for dependent_branch in dependents:
+      print
+      print '--------------------------------------'
+      print 'Running "git cl upload" from %s:' % dependent_branch
+      RunGit(['checkout', '-q', dependent_branch])
+      print
+      if CMDupload(OptionParser(), args) != 0:
+        print 'Upload failed for %s!' % dependent_branch
+        return 1
+      print
+  finally:
+    # Swap back to the original root branch.
+    RunGit(['checkout', '-q', root_branch])
+
+  print
+  print 'All dependent branches %s have been updated!' % dependents
+  print
+
+  return 0
+
+
 def CMDstatus(parser, args):
   """Show status of changelists.
 
   Colors are used to tell the state of the CL unless --fast is used:
     - Red      not sent for review or broken
     - Blue     waiting for review
     - Yellow   waiting for you to reply to review
     - Green    LGTM'ed
     - Magenta  in the commit queue
     - Cyan     was committed, branch can be deleted
@@ skipping 1847 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)