Fix hanging issue with git map-branches.

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 multiprocessing
 import optparse
 import os
 import Queue
 import re
 import stat
 import sys
 import tempfile
 import textwrap
 import time
 import traceback
@@ skipping 1664 matching lines @@
   status = cl.GetStatus()
 
   if url and (not status or status == 'error'):
     # The issue probably doesn't exist anymore.
     url += ' (broken)'
 
   return (branch, url, status)
 
 def get_cl_statuses(
     branches, fine_grained, max_processes=None, auth_config=None):
-  """Returns a blocking iterable of (branch, issue, color) for given branches.
+  """Returns a blocking iterable of (branch, issue, status) for given branches.
 
   If fine_grained is true, this will fetch CL statuses from the server.
   Otherwise, simply indicate if there's a matching url for the given branches.
 
   If max_processes is specified, it is used as the maximum number of processes
   to spawn to fetch CL status from the server. Otherwise 1 process per branch is
   spawned.
+
+  See GetStatus() for a list of possible statuses.
   """
+  def fetch(branch):
+    if not branch:
+      return None
+
+    return fetch_cl_status(branch, auth_config=auth_config)
+
   # Silence upload.py otherwise it becomes unwieldly.
   upload.verbosity = 0
 
   if fine_grained:
     # Process one branch synchronously to work through authentication, then
     # spawn processes to process all the other branches in parallel.
     if branches:
-      fetch = lambda branch: fetch_cl_status(branch, auth_config=auth_config)
+
       yield fetch(branches[0])
 
       branches_to_fetch = branches[1:]
       pool = ThreadPool(
           min(max_processes, len(branches_to_fetch))
               if max_processes is not None
               else len(branches_to_fetch))
-      for x in pool.imap_unordered(fetch, branches_to_fetch):
-        yield x
+
+      fetched_branches = set()
+      it = pool.imap_unordered(fetch, branches_to_fetch).__iter__()
+      while True:
+        try:
+          row = it.next(timeout=5)
+          fetched_branches.add(row[0])

[Matt Giuca, 2016/04/01 03:52:04]

Move the last two lines out of the try block.

[calamity, 2016/04/28 21:43:47]

Done.

+          yield row
+        except multiprocessing.TimeoutError:
+          break
+
+      # Add any branches that failed to fetch.
+      for b in set(branches_to_fetch) - fetched_branches:
+        cl = Changelist(branchref=b, auth_config=auth_config)
+        yield (b, cl.GetIssueURL() if b else None, 'error')
+
   else:
     # Do not use GetApprovingReviewers(), since it requires an HTTP request.
     for b in branches:
       cl = Changelist(branchref=b, auth_config=auth_config)
-      url = cl.GetIssueURL()
+      url = cl.GetIssueURL() if b else None
       yield (b, url, 'waiting' if url else 'error')
 
 
 def upload_branch_deps(cl, 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
@@ skipping 2264 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)