[Android] Blacklist devices on failures during environment set up + tear down.

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

 # Copyright 2014 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 fnmatch
-import functools
 import imp
 import logging
 import signal
 import thread
 import threading
 
-from devil import base_error
-from devil.android import device_errors
 from devil.utils import signal_handler
 from pylib import valgrind_tools
 from pylib.base import base_test_result
 from pylib.base import test_run
 from pylib.base import test_collection
+from pylib.local.device import local_device_environment
 
 
 def IncrementalInstall(device, apk_helper, installer_script):
   """Performs an incremental install.
 
   Args:
     device: Device to install on.
     apk_helper: ApkHelper instance for the _incremental.apk.
     installer_script: Path to the installer script for the incremental apk.
   """
   try:
     install_wrapper = imp.load_source('install_wrapper', installer_script)
   except IOError:
     raise Exception('Incremental install script not found: %s\n' %
                     installer_script)
   params = install_wrapper.GetInstallParameters()
 
   from incremental_install import installer
   installer.Install(device, apk_helper, split_globs=params['splits'],
                     native_libs=params['native_libs'],
                     dex_files=params['dex_files'],
                     permissions=None)  # Auto-grant permissions from manifest.
 
 
-def handle_shard_failures(f):
-  """A decorator that handles device failures for per-device functions.
-
-  Args:
-    f: the function being decorated. The function must take at least one
-      argument, and that argument must be the device.
-  """
-  return handle_shard_failures_with(None)(f)
-
-
-def handle_shard_failures_with(on_failure):
-  """A decorator that handles device failures for per-device functions.
-
-  This calls on_failure in the event of a failure.
-
-  Args:
-    f: the function being decorated. The function must take at least one
-      argument, and that argument must be the device.
-    on_failure: A binary function to call on failure.
-  """
-  def decorator(f):
-    @functools.wraps(f)
-    def wrapper(dev, *args, **kwargs):
-      try:
-        return f(dev, *args, **kwargs)
-      except device_errors.CommandTimeoutError:
-        logging.exception('Shard timed out: %s(%s)', f.__name__, str(dev))
-      except device_errors.DeviceUnreachableError:
-        logging.exception('Shard died: %s(%s)', f.__name__, str(dev))
-      except base_error.BaseError:
-        logging.exception('Shard failed: %s(%s)', f.__name__, str(dev))
-      except SystemExit:
-        logging.exception('Shard killed: %s(%s)', f.__name__, str(dev))
-        raise
-      if on_failure:
-        on_failure(dev, f.__name__)
-      return None
-
-    return wrapper
-
-  return decorator
-
-
 class LocalDeviceTestRun(test_run.TestRun):
 
   def __init__(self, env, test_instance):
     super(LocalDeviceTestRun, self).__init__(env, test_instance)
     self._tools = {}
 
   #override
   def RunTests(self):
     tests = self._GetTests()
 
     exit_now = threading.Event()
 
-    @handle_shard_failures
+    @local_device_environment.handle_shard_failures
     def run_tests_on_device(dev, tests, results):
       for test in tests:
         if exit_now.isSet():
           thread.exit()
 
         result = None
         try:
           result = self._RunTest(dev, test)
           if isinstance(result, base_test_result.BaseTestResult):
             results.AddResult(result)
@@ skipping 109 matching lines @@
 
   def _RunTest(self, device, test):
     raise NotImplementedError
 
   def _ShouldShard(self):
     raise NotImplementedError
 
 
 class NoTestsError(Exception):
   """Error for when no tests are found."""