mirror of
https://github.com/flutter/flutter.git
synced 2025-06-03 00:51:18 +00:00
369 lines
13 KiB
Python
369 lines
13 KiB
Python
# 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
|
|
self._device = None
|
|
self._device_type = args.device_type
|
|
self._verbose_count = args.verbose_count
|
|
self._timeouts = {
|
|
'queueing': 60 * 10,
|
|
'installing': 60 * 10,
|
|
'in-progress': 60 * 30,
|
|
'unknown': 60 * 5
|
|
}
|
|
# Example config file:
|
|
# {
|
|
# "remote_device": ["Galaxy S4", "Galaxy S3"],
|
|
# "remote_device_os": ["4.4.2", "4.4.4"],
|
|
# "remote_device_minimum_os": "4.4.2",
|
|
# "api_address": "www.example.com",
|
|
# "api_port": "80",
|
|
# "api_protocol": "http",
|
|
# "api_secret": "apisecret",
|
|
# "api_key": "apikey",
|
|
# "timeouts": {
|
|
# "queueing": 600,
|
|
# "installing": 600,
|
|
# "in-progress": 1800,
|
|
# "unknown": 300
|
|
# }
|
|
# }
|
|
if args.remote_device_file:
|
|
with open(args.remote_device_file) as device_file:
|
|
device_json = json.load(device_file)
|
|
else:
|
|
device_json = {}
|
|
|
|
self._api_address = device_json.get('api_address', None)
|
|
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._network_config = device_json.get('network_config', None)
|
|
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)
|
|
self._timeouts.update(device_json.get('timeouts', {}))
|
|
|
|
def command_line_override(
|
|
file_value, cmd_line_value, desc, print_value=True):
|
|
if cmd_line_value:
|
|
if file_value and file_value != cmd_line_value:
|
|
if print_value:
|
|
logging.info('Overriding %s from %s to %s',
|
|
desc, file_value, cmd_line_value)
|
|
else:
|
|
logging.info('overriding %s', desc)
|
|
return cmd_line_value
|
|
return file_value
|
|
|
|
self._api_address = command_line_override(
|
|
self._api_address, args.api_address, 'api_address')
|
|
self._api_port = command_line_override(
|
|
self._api_port, args.api_port, 'api_port')
|
|
self._api_protocol = command_line_override(
|
|
self._api_protocol, args.api_protocol, 'api_protocol')
|
|
self._device_oem = command_line_override(
|
|
self._device_oem, args.device_oem, 'device_oem')
|
|
self._device_type = command_line_override(
|
|
self._device_type, args.device_type, 'device_type')
|
|
self._network_config = command_line_override(
|
|
self._network_config, args.network_config, 'network_config')
|
|
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()
|
|
self._api_key = command_line_override(
|
|
self._api_key, temp_key, 'api_key', print_value=False)
|
|
self._api_key = command_line_override(
|
|
self._api_key, args.api_key, 'api_key', print_value=False)
|
|
|
|
if args.api_secret_file:
|
|
with open(args.api_secret_file) as api_secret_file:
|
|
temp_secret = api_secret_file.read().strip()
|
|
self._api_secret = command_line_override(
|
|
self._api_secret, temp_secret, 'api_secret', print_value=False)
|
|
self._api_secret = command_line_override(
|
|
self._api_secret, args.api_secret, 'api_secret', print_value=False)
|
|
|
|
if not self._api_address:
|
|
error_func('Must set api address with --api-address'
|
|
' or in --remote-device-file.')
|
|
if not self._api_key:
|
|
error_func('Must set api key with --api-key, --api-key-file'
|
|
' or in --remote-device-file')
|
|
if not self._api_port:
|
|
error_func('Must set api port with --api-port'
|
|
' or in --remote-device-file')
|
|
if not self._api_protocol:
|
|
error_func('Must set api protocol with --api-protocol'
|
|
' or in --remote-device-file. Example: http')
|
|
if not self._api_secret:
|
|
error_func('Must set api secret with --api-secret, --api-secret-file'
|
|
' or in --remote-device-file')
|
|
|
|
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
|
|
os.environ['APPURIFY_STATUS_BASE_URL'] = 'none'
|
|
self._GetAccessToken()
|
|
if self._trigger:
|
|
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
|
|
except:
|
|
self.__exit__(*sys.exc_info())
|
|
raise
|
|
|
|
def __exit__(self, exc_type, exc_val, exc_tb):
|
|
"""Tears down the test run when used as a context manager."""
|
|
self.TearDown()
|
|
|
|
def DumpTo(self, persisted_data):
|
|
env_data = {
|
|
self._DEVICE_KEY: self._device,
|
|
}
|
|
persisted_data[self._ENV_KEY] = env_data
|
|
|
|
def LoadFrom(self, persisted_data):
|
|
env_data = persisted_data[self._ENV_KEY]
|
|
self._device = env_data[self._DEVICE_KEY]
|
|
|
|
def _GetAccessToken(self):
|
|
"""Generates access token for remote device service."""
|
|
logging.info('Generating remote service access token')
|
|
with appurify_sanitized.SanitizeLogging(self._verbose_count,
|
|
logging.WARNING):
|
|
access_token_results = appurify_sanitized.api.access_token_generate(
|
|
self._api_key, self._api_secret)
|
|
remote_device_helper.TestHttpResponse(access_token_results,
|
|
'Unable to generate access token.')
|
|
self._access_token = access_token_results.json()['response']['access_token']
|
|
|
|
def _RevokeAccessToken(self):
|
|
"""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):
|
|
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.')
|
|
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 device['has_available_device']:
|
|
logging.info('Found device: %s %s',
|
|
device['name'], device['os_version'])
|
|
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 %s %s',
|
|
'OS'.ljust(10),
|
|
'Device Name'.ljust(30),
|
|
'Available'.ljust(10),
|
|
'Busy'.ljust(10),
|
|
'All'.ljust(10))
|
|
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 %s %s %s',
|
|
d['os_version'].ljust(10),
|
|
d['name'].ljust(30),
|
|
str(d['available_devices_count']).ljust(10),
|
|
str(d['busy_devices_count']).ljust(10),
|
|
str(d['all_devices_count']).ljust(10))
|
|
|
|
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.', is_infra_error=True)
|
|
|
|
@property
|
|
def collect(self):
|
|
return self._collect
|
|
|
|
@property
|
|
def device_type_id(self):
|
|
return self._device['device_type_id']
|
|
|
|
@property
|
|
def network_config(self):
|
|
return self._network_config
|
|
|
|
@property
|
|
def only_output_failures(self):
|
|
# TODO(jbudorick): Remove this once b/18981674 is fixed.
|
|
return True
|
|
|
|
@property
|
|
def results_path(self):
|
|
return self._results_path
|
|
|
|
@property
|
|
def runner_package(self):
|
|
return self._runner_package
|
|
|
|
@property
|
|
def runner_type(self):
|
|
return self._runner_type
|
|
|
|
@property
|
|
def timeouts(self):
|
|
return self._timeouts
|
|
|
|
@property
|
|
def token(self):
|
|
return self._access_token
|
|
|
|
@property
|
|
def trigger(self):
|
|
return self._trigger
|
|
|
|
@property
|
|
def verbose_count(self):
|
|
return self._verbose_count
|
|
|
|
@property
|
|
def device_type(self):
|
|
return self._device_type
|