[Android] Log once per minute while waiting for timeout_retry thread completion.

build/android/devil/utils/reraiser_thread.py

 # Copyright 2013 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.
 
 """Thread and ThreadGroup that reraise exceptions on the main thread."""
 # pylint: disable=W0212
 
 import logging
 import sys
 import threading
+import time
 import traceback
 
 from devil.utils import watchdog_timer
 
 
 class TimeoutError(Exception):
   """Module-specific timeout exception."""
   pass
 
 
@@ skipping 76 matching lines @@
     Args:
       thread: a ReraiserThread object.
     """
     self._threads.append(thread)
 
   def StartAll(self):
     """Start all threads."""
     for thread in self._threads:
       thread.start()
 
-  def _JoinAll(self, watcher=None):
+  def _JoinAll(self, watcher=None, timeout=None):
     """Join all threads without stack dumps.
 
     Reraises exceptions raised by the child threads and supports breaking
     immediately on exceptions raised on the main thread.
 
     Args:
-      watcher: Watchdog object providing timeout, by default waits forever.
+      watcher: Watchdog object providing the thread timeout. If none is
+          provided, the thread will never be timed out.
+      timeout: An optional number of seconds to wait before timing out the join
+          operation. This will not time out the threads.
     """
     if watcher is None:
       watcher = watchdog_timer.WatchdogTimer(None)
     alive_threads = self._threads[:]
-    while alive_threads:
+    end_time = (time.time() + timeout) if timeout else None
+    while alive_threads and (end_time is None or end_time > time.time()):
       for thread in alive_threads[:]:
         if watcher.IsTimedOut():
           raise TimeoutError('Timed out waiting for %d of %d threads.' %
                              (len(alive_threads), len(self._threads)))
         # Allow the main thread to periodically check for interrupts.
         thread.join(0.1)
         if not thread.isAlive():
           alive_threads.remove(thread)
     # All threads are allowed to complete before reraising exceptions.
     for thread in self._threads:
       thread.ReraiseIfException()
 
-  def JoinAll(self, watcher=None):
+  def IsAlive(self):
+    """Check whether any of the threads are still alive.
+
+    Returns:
+      Whether any of the threads are still alive.
+    """
+    return any(t.isAlive() for t in self._threads)
+
+  def JoinAll(self, watcher=None, timeout=None):
     """Join all threads.
 
     Reraises exceptions raised by the child threads and supports breaking
     immediately on exceptions raised on the main thread. Unfinished threads'
     stacks will be logged on watchdog timeout.
 
     Args:
-      watcher: Watchdog object providing timeout, by default waits forever.
+      watcher: Watchdog object providing the thread timeout. If none is
+          provided, the thread will never be timed out.
+      timeout: An optional number of seconds to wait before timing out the join
+          operation. This will not time out the threads.
     """
     try:
-      self._JoinAll(watcher)
+      self._JoinAll(watcher, timeout)
     except TimeoutError:
       logging.critical('Timed out. Dumping threads.')
       for thread in (t for t in self._threads if t.isAlive()):
         LogThreadStack(thread)
       raise
 
   def GetAllReturnValues(self, watcher=None):
     """Get all return values, joining all threads if necessary.
 
     Args:
@@ skipping 10 matching lines @@
   Args:
     funcs: List of functions to perform on their own threads.
     watcher: Watchdog object providing timeout, by default waits forever.
 
   Returns:
     A list of return values in the order of the given functions.
   """
   thread_group = ReraiserThreadGroup(ReraiserThread(f) for f in funcs)
   thread_group.StartAll()
   return thread_group.GetAllReturnValues(watcher=watcher)