Update from https://crrev.com/316786

build/android/pylib/remote/device/remote_device_environment.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.
 
 """Environment setup and teardown for remote devices."""
 
 import distutils.version
 import json
 import logging
 import os
 import random
 import sys
 
 from pylib import constants
 from pylib.base import environment
 from pylib.remote.device import appurify_sanitized
 from pylib.remote.device import remote_device_helper
+from pylib.utils import timeout_retry
+from pylib.utils import reraiser_thread
 
 class RemoteDeviceEnvironment(environment.Environment):
   """An environment for running on remote devices."""
 
   _ENV_KEY = 'env'
   _DEVICE_KEY = 'device'
+  _DEFAULT_RETRIES = 0
 
   def __init__(self, args, error_func):
     """Constructor.
 
     Args:
       args: Command line arguments.
       error_func: error to show when using bad command line arguments.
     """
     super(RemoteDeviceEnvironment, self).__init__()
     self._access_token = None
@@ skipping 33 matching lines @@
     self._api_key = device_json.get('api_key', None)
     self._api_port = device_json.get('api_port', None)
     self._api_protocol = device_json.get('api_protocol', None)
     self._api_secret = device_json.get('api_secret', None)
     self._device_oem = device_json.get('device_oem', None)
     self._device_type = device_json.get('device_type', 'Android')
     self._remote_device = device_json.get('remote_device', None)
     self._remote_device_minimum_os = device_json.get(
         'remote_device_minimum_os', None)
     self._remote_device_os = device_json.get('remote_device_os', None)
+    self._remote_device_timeout = device_json.get('remote_device_timeout', None)
     self._results_path = device_json.get('results_path', None)
     self._runner_package = device_json.get('runner_package', None)
     self._runner_type = device_json.get('runner_type', None)
     if 'timeouts' in device_json:
       for key in device_json['timeouts']:
         self._timeouts[key] = device_json['timeouts'][key]
 
     def command_line_override(
         file_value, cmd_line_value, desc, print_value=True):
       if cmd_line_value:
@@ skipping 16 matching lines @@
         self._device_oem, args.device_oem, 'device_oem')
     self._device_type = command_line_override(
         self._device_type, args.device_type, 'device_type')
     self._remote_device = command_line_override(
         self._remote_device, args.remote_device, 'remote_device')
     self._remote_device_minimum_os = command_line_override(
         self._remote_device_minimum_os, args.remote_device_minimum_os,
         'remote_device_minimum_os')
     self._remote_device_os = command_line_override(
         self._remote_device_os, args.remote_device_os, 'remote_device_os')
+    self._remote_device_timeout = command_line_override(
+        self._remote_device_timeout, args.remote_device_timeout,
+        'remote_device_timeout')
     self._results_path = command_line_override(
         self._results_path, args.results_path, 'results_path')
     self._runner_package = command_line_override(
         self._runner_package, args.runner_package, 'runner_package')
     self._runner_type = command_line_override(
         self._runner_type, args.runner_type, 'runner_type')
 
     if args.api_key_file:
       with open(args.api_key_file) as api_key_file:
         temp_key = api_key_file.read().strip()
@@ skipping 28 matching lines @@
 
     logging.info('Api address: %s', self._api_address)
     logging.info('Api port: %s', self._api_port)
     logging.info('Api protocol: %s', self._api_protocol)
     logging.info('Remote device: %s', self._remote_device)
     logging.info('Remote device minimum OS: %s',
                  self._remote_device_minimum_os)
     logging.info('Remote device OS: %s', self._remote_device_os)
     logging.info('Remote device OEM: %s', self._device_oem)
     logging.info('Remote device type: %s', self._device_type)
+    logging.info('Remote device timout: %s', self._remote_device_timeout)
     logging.info('Results Path: %s', self._results_path)
     logging.info('Runner package: %s', self._runner_package)
     logging.info('Runner type: %s', self._runner_type)
     logging.info('Timeouts: %s', self._timeouts)
 
     if not args.trigger and not args.collect:
       self._trigger = True
       self._collect = True
     else:
       self._trigger = args.trigger
       self._collect = args.collect
 
   def SetUp(self):
     """Set up the test environment."""
     os.environ['APPURIFY_API_PROTO'] = self._api_protocol
     os.environ['APPURIFY_API_HOST'] = self._api_address
     os.environ['APPURIFY_API_PORT'] = self._api_port
     self._GetAccessToken()
     if self._trigger:
-      self._device = self._SelectDevice()
+      self._SelectDevice()
 
   def TearDown(self):
     """Teardown the test environment."""
     self._RevokeAccessToken()
 
   def __enter__(self):
     """Set up the test run when used as a context manager."""
     try:
       self.SetUp()
       return self
@@ skipping 30 matching lines @@
     """Destroys access token for remote device service."""
     logging.info('Revoking remote service access token')
     with appurify_sanitized.SanitizeLogging(self._verbose_count,
                                             logging.WARNING):
       revoke_token_results = appurify_sanitized.api.access_token_revoke(
           self._access_token)
     remote_device_helper.TestHttpResponse(revoke_token_results,
                                           'Unable to revoke access token.')
 
   def _SelectDevice(self):
-    """Select which device to use."""
+    if self._remote_device_timeout:
+      try:
+        timeout_retry.Run(self._FindDeviceWithTimeout,
+                          self._remote_device_timeout, self._DEFAULT_RETRIES)
+      except reraiser_thread.TimeoutError:
+        self._NoDeviceFound()
+    else:
+      if not self._FindDevice():
+        self._NoDeviceFound()
+
+  def _FindDevice(self):
+    """Find which device to use."""
     logging.info('Finding device to run tests on.')
-    with appurify_sanitized.SanitizeLogging(self._verbose_count,
-                                            logging.WARNING):
-      dev_list_res = appurify_sanitized.api.devices_list(self._access_token)
-    remote_device_helper.TestHttpResponse(dev_list_res,
-                                          'Unable to generate access token.')
-    device_list = dev_list_res.json()['response']
+    device_list = self._GetDeviceList()
     random.shuffle(device_list)
     for device in device_list:
       if device['os_name'] != self._device_type:
         continue
       if self._remote_device and device['name'] not in self._remote_device:
         continue
       if (self._remote_device_os
           and device['os_version'] not in self._remote_device_os):
         continue
       if self._device_oem and device['brand'] not in self._device_oem:
         continue
       if (self._remote_device_minimum_os
           and distutils.version.LooseVersion(device['os_version'])
           < distutils.version.LooseVersion(self._remote_device_minimum_os)):
         continue
-      if ((self._remote_device and self._remote_device_os)
-          or device['available_devices_count']):
+      if device['has_available_device']:
         logging.info('Found device: %s %s',
                      device['name'], device['os_version'])
-        return device
-    self._NoDeviceFound(device_list)
+        self._device = device
+        return True
+    return False
+
+  def _FindDeviceWithTimeout(self):
+    """Find which device to use with timeout."""
+    timeout_retry.WaitFor(self._FindDevice, wait_period=1)
 
   def _PrintAvailableDevices(self, device_list):
     def compare_devices(a,b):
       for key in ('os_version', 'name'):
         c = cmp(a[key], b[key])
         if c:
           return c
       return 0
 
     logging.critical('Available %s Devices:', self._device_type)
+    logging.critical('  %s %s %s', 'OS'.ljust(7),
+                     'Device Name'.ljust(20), '# Available')
     devices = (d for d in device_list if d['os_name'] == self._device_type)
     for d in sorted(devices, compare_devices):
-      logging.critical('  %s %s', d['os_version'].ljust(7), d['name'])
+      logging.critical('  %s %s %s', d['os_version'].ljust(7),
+                       d['name'].ljust(20), d['available_devices_count'])
 
-  def _NoDeviceFound(self, device_list):
-    self._PrintAvailableDevices(device_list)
+  def _GetDeviceList(self):
+    with appurify_sanitized.SanitizeLogging(self._verbose_count,
+                                            logging.WARNING):
+      dev_list_res = appurify_sanitized.api.devices_list(self._access_token)
+    remote_device_helper.TestHttpResponse(dev_list_res,
+                                         'Unable to generate access token.')
+    return dev_list_res.json()['response']
+
+  def _NoDeviceFound(self):
+    self._PrintAvailableDevices(self._GetDeviceList())
     raise remote_device_helper.RemoteDeviceError('No device found.')
 
   @property
   def collect(self):
     return self._collect
 
   @property
   def device_type_id(self):
     return self._device['device_type_id']
 
@@ skipping 26 matching lines @@
   def trigger(self):
     return self._trigger
 
   @property
   def verbose_count(self):
     return self._verbose_count
 
   @property
   def device_type(self):
     return self._device_type