[Android] Add heartbeat of platform mode perf test runner.

build/android/pylib/local/device/local_device_perf_test_run.py

 # Copyright 2016 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.
 
 import io
 import json
 import logging
 import os
 import pickle
 import shutil
 import tempfile
+import threading
 import time
 import zipfile
 
 from devil.android import battery_utils
 from devil.android import device_errors
 from devil.android import device_list
 from devil.android import device_utils
 from devil.android import forwarder
 from devil.android.tools import device_recovery
 from devil.android.tools import device_status
 from devil.utils import cmd_helper
 from devil.utils import parallelizer
 from pylib import constants
 from pylib.base import base_test_result
 from pylib.constants import host_paths
 from pylib.local.device import local_device_test_run
 
 
+class HeartBeat(object):
+
+  def __init__(self, shard, wait_time=60*10):

[mikecase (-- gone --), 2016/07/25 17:01:27]

nit: Add some documentation. Specifically, to just say what units wait_time is
in.

[rnephew (Reviews Here), 2016/07/25 17:06:42]

Done.

+    self._shard = shard
+    self._running = False
+    self._timer = None
+    self._wait_time = wait_time
+
+  def Start(self):
+    if not self._running:
+      self._timer = threading.Timer(self._wait_time, self._LogMessage)
+      self._timer.start()
+      self._running = True
+
+  def Stop(self):
+    if self._running:
+      self._timer.cancel()
+      self._running = False
+
+  def _LogMessage(self):
+    logging.info('Currently working on test %s', self._shard.current_test)
+    self._timer = threading.Timer(self._wait_time, self._LogMessage)
+    self._timer.start()
+
+
 class TestShard(object):
   def __init__(
       self, env, test_instance, device, index, tests, retries=3, timeout=None):
     logging.info('Create shard %s for device %s to run the following tests:',
                  index, device)
     for t in tests:
       logging.info('  %s', t)
     self._battery = battery_utils.BatteryUtils(device)
+    self._current_test = None
     self._device = device
     self._env = env
     self._index = index
     self._output_dir = None
     self._retries = retries
     self._test_instance = test_instance
     self._tests = tests
     self._timeout = timeout
+    self._heart_beat = HeartBeat(self)
 
   @local_device_test_run.handle_shard_failures
   def RunTestsOnShard(self):
     results = base_test_result.TestRunResults()
     for test in self._tests:
       tries_left = self._retries
       result_type = None
       while (result_type != base_test_result.ResultType.PASS
              and tries_left > 0):
         try:
@@ skipping 33 matching lines @@
       self._battery.LetBatteryCoolToTemperature(
           self._test_instance.max_battery_temp)
 
     if not self._device.IsScreenOn():
       self._device.SetScreen(True)
 
     if (self._test_instance.collect_chartjson_data
         or self._tests[test].get('archive_output_dir')):
       self._output_dir = tempfile.mkdtemp()
 
+    self._current_test = test
+    self._heart_beat.Start()
+
   def _RunSingleTest(self, test):
     self._test_instance.WriteBuildBotJson(self._output_dir)
 
     timeout = self._tests[test].get('timeout', self._timeout)
     cmd = self._CreateCmd(test)
     cwd = os.path.abspath(host_paths.DIR_SOURCE_ROOT)
 
     logging.debug("Running %s with command '%s' on shard %d with timeout %d",
                   test, cmd, self._index, timeout)
 
@@ skipping 88 matching lines @@
 
   def _TestTearDown(self):
     if self._output_dir:
       shutil.rmtree(self._output_dir, ignore_errors=True)
       self._output_dir = None
     try:
       logging.info('Unmapping device ports for %s.', self._device)
       forwarder.Forwarder.UnmapAllDevicePorts(self._device)
     except Exception: # pylint: disable=broad-except
       logging.exception('Exception when resetting ports.')
+    finally:
+      self._heart_beat.Stop()
+      self._current_test = None
 
+  @property
+  def current_test(self):
+    return self._current_test
 
 class LocalDevicePerfTestRun(local_device_test_run.LocalDeviceTestRun):
 
   _DEFAULT_TIMEOUT = 60 * 60
   _CONFIG_VERSION = 1
 
   def __init__(self, env, test_instance):
     super(LocalDevicePerfTestRun, self).__init__(env, test_instance)
     self._devices = None
     self._env = env
@@ skipping 155 matching lines @@
   # override
   def _RunTest(self, _device, _test):
     raise NotImplementedError
 
 
 class TestDictVersionError(Exception):
   pass
 
 class PerfTestRunGetStepsError(Exception):
   pass