def _check_if_is_in_lab(self):
"""Checks if Chameleon host is in lab and set self._is_in_lab.
If self.hostname is an IP address, we treat it as is not in lab zone.
"""
self._is_in_lab = (False if dnsname_mangler.is_ip_address(
self.hostname) else utils.host_is_in_lab_zone(self.hostname))
def create_chameleon_host(dut, chameleon_args):
"""Create a ChameleonHost object.
There three possible cases:
1) If the DUT is in Cros Lab and has a chameleon board, then create
a ChameleonHost object pointing to the board. chameleon_args
is ignored.
2) If not case 1) and chameleon_args is neither None nor empty, then
create a ChameleonHost object using chameleon_args.
3) If neither case 1) or 2) applies, return None.
@param dut: host name of the host that chameleon connects. It can be used
to lookup the chameleon in test lab using naming convention.
If dut is an IP address, it can not be used to lookup the
chameleon in test lab.
@param chameleon_args: A dictionary that contains args for creating
a ChameleonHost object,
e.g. {'chameleon_host': '172.11.11.112',
'chameleon_port': 9992}.
@returns: A ChameleonHost object or None.
"""
if not utils.is_in_container():
is_moblab = utils.is_moblab()
else:
is_moblab = _CONFIG.get_config_value('SSP',
'is_moblab',
type=bool,
default=False)
if not is_moblab:
dut_is_hostname = not dnsname_mangler.is_ip_address(dut)
if dut_is_hostname:
chameleon_hostname = chameleon.make_chameleon_hostname(dut)
if utils.host_is_in_lab_zone(chameleon_hostname):
# Be more tolerant on chameleon in the lab because
# we don't want dead chameleon blocks non-chameleon tests.
if utils.ping(chameleon_hostname, deadline=3):
logging.warning(
'Chameleon %s is not accessible. Please file a bug'
' to test lab', chameleon_hostname)
return None
return ChameleonHost(chameleon_host=chameleon_hostname)
if chameleon_args:
return ChameleonHost(**chameleon_args)
else:
return None
else:
afe = frontend_wrappers.RetryingAFE(timeout_min=5, delay_sec=10)
hosts = afe.get_hosts(hostname=dut)
if hosts and CHAMELEON_HOST_ATTR in hosts[0].attributes:
return ChameleonHost(
chameleon_host=hosts[0].attributes[CHAMELEON_HOST_ATTR],
chameleon_port=hosts[0].attributes.get(CHAMELEON_PORT_ATTR,
9992))
else:
return None
def __init__(self,
name,
testbed,
testbed_name=None,
run_result=None,
log_directory=None,
exception=None):
"""
@param name: A name to identify the test run.
@param testbed: The testbed that ran the test.
@param testbed_name: The name the testbed was run with, if none the
default name of the testbed is used.
@param run_result: The raw i/o result of the test run.
@param log_directory: The directory that acts logged to.
@param exception: An exception that was thrown while running the test.
"""
self.name = name
self.run_result = run_result
self.exception = exception
self.log_directory = log_directory
self.test_station = testbed.teststation
self.testbed = testbed
if not testbed_name:
# If no override is given get the name from the hostname.
hostname = testbed.hostname
if dnsname_mangler.is_ip_address(hostname):
self.testbed_name = hostname
else:
self.testbed_name = hostname.split('.')[0]
else:
self.testbed_name = testbed_name
self.reported_to = set()
self.json_results = {}
self.results_dir = None
if self.log_directory:
self.results_dir = os.path.join(self.log_directory,
self.testbed_name, 'latest')
results_file = os.path.join(self.results_dir,
'test_run_summary.json')
cat_log_result = self.test_station.run('cat %s' % results_file,
ignore_status=True)
if not cat_log_result.exit_status:
self.json_results = json.loads(cat_log_result.stdout)
def __init__(self, testbed, testbed_name=None):
"""Creates a new android testing enviroment.
@param testbed: The testbed to test on.
@param testbed_name: An overriding name for the testbed.
"""
self.testbed = testbed
if not testbed_name:
# If no override is given get the name from the hostname.
hostname = testbed.hostname
if dnsname_mangler.is_ip_address(hostname):
testbed_name = hostname
else:
testbed_name = hostname.split('.')[0]
self.testbed_name = testbed_name
def run_once(self,
testbed=None,
install_sl4a=True,
additional_apks=[]):
"""When run the testbed will be setup.
@param testbed: The testbed to setup.
@param install_sl4a: When true sl4a will be installed.
@param additional_apks: An array of apk info dictionaries.
apk = Name of the apk (eg. sl4a.apk)
package = Name of the package (eg. test.tools)
artifact = Name of the artifact, if not given
package is used.
"""
hostname = testbed.hostname
if dnsname_mangler.is_ip_address(hostname):
testbed_name = hostname
else:
testbed_name = hostname.split('.')[0]
valid_hosts = []
for v in testbed.get_adb_devices().values():
try:
info = v.host_info_store.get()
except host_info.StoreError:
pass
else:
if v.job_repo_url_attribute in info.attributes:
valid_hosts.append(v)
if not valid_hosts:
logging.error('No valid devices.')
return
testbed_env = acts_lib.AndroidTestingEnvironment(
devices=valid_hosts,
testbed_name=testbed_name)
if install_sl4a:
testbed_env.install_sl4a_apk()
for apk in additional_apks:
testbed_env.install_apk(apk)
def _get_standard_servo_args(dut_host):
"""Return servo data associated with a given DUT.
This checks for the presence of servo host and port attached to the
given `dut_host`. This data should be stored in the
`_afe_host.attributes` field in the provided `dut_host` parameter.
@param dut_host Instance of `Host` on which to find the servo
attributes.
@return A tuple of `servo_args` dict with host and an option port,
plus an `is_in_lab` flag indicating whether this in the CrOS
test lab, or some different environment.
"""
servo_args = None
is_in_lab = False
is_ssp_moblab = False
if utils.is_in_container():
is_moblab = _CONFIG.get_config_value('SSP',
'is_moblab',
type=bool,
default=False)
is_ssp_moblab = is_moblab
else:
is_moblab = utils.is_moblab()
attrs = dut_host._afe_host.attributes
if attrs and SERVO_HOST_ATTR in attrs:
servo_host = attrs[SERVO_HOST_ATTR]
if (is_ssp_moblab and servo_host in ['localhost', '127.0.0.1']):
servo_host = _CONFIG.get_config_value('SSP',
'host_container_ip',
type=str,
default=None)
servo_args = {SERVO_HOST_ATTR: servo_host}
if SERVO_PORT_ATTR in attrs:
try:
servo_port = attrs[SERVO_PORT_ATTR]
servo_args[SERVO_PORT_ATTR] = int(servo_port)
except ValueError:
logging.error('servo port is not an int: %s', servo_port)
# Let's set the servo args to None since we're not creating
# the ServoHost object with the proper port now.
servo_args = None
if SERVO_SERIAL_ATTR in attrs:
servo_args[SERVO_SERIAL_ATTR] = attrs[SERVO_SERIAL_ATTR]
is_in_lab = (not is_moblab and utils.host_is_in_lab_zone(servo_host))
# TODO(jrbarnette): This test to use the default lab servo hostname
# is a legacy that we need only until every host in the DB has
# proper attributes.
elif (not is_moblab
and not dnsname_mangler.is_ip_address(dut_host.hostname)):
servo_host = make_servo_hostname(dut_host.hostname)
is_in_lab = utils.host_is_in_lab_zone(servo_host)
if is_in_lab:
servo_args = {SERVO_HOST_ATTR: servo_host}
if servo_args is not None:
info = dut_host.host_info_store.get()
if info.board:
servo_args[SERVO_BOARD_ATTR] = _map_afe_board_to_servo_board(
info.board)
return servo_args, is_in_lab