forked from mirrors/gecko-dev
aa78ee9e95
Currently 'stop-emulator' is its own action in mozharness. This means that anytime the mozharness script finishes emulators will get shutdown. Usually, this is what we want to do. But if the user passes in --no-run-tests, then presumably they are intending to run tests at a later time for some reason. But when they do this, the emulator will be terminated, and then running tests later no longer works. The main place where this becomes a problem is on interactive loaners in taskcluster. This patch fixes the problem by instead running 'stop-emulator' only after the 'run-tests' step finishes. So if --no-run-tests is passed in, the emulator will be left open. MozReview-Commit-ID: 4lsKGpizfH7 --HG-- extra : rebase_source : e29733a4a69d4d063f225754d2ad8886e22b4782
750 lines
31 KiB
Python
750 lines
31 KiB
Python
#!/usr/bin/env python
|
|
# ***** BEGIN LICENSE BLOCK *****
|
|
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
# You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
# ***** END LICENSE BLOCK *****
|
|
|
|
import copy
|
|
import datetime
|
|
import glob
|
|
import os
|
|
import re
|
|
import sys
|
|
import signal
|
|
import socket
|
|
import subprocess
|
|
import telnetlib
|
|
import time
|
|
import tempfile
|
|
|
|
# load modules from parent dir
|
|
sys.path.insert(1, os.path.dirname(sys.path[0]))
|
|
|
|
from mozprocess import ProcessHandler
|
|
|
|
from mozharness.base.log import FATAL
|
|
from mozharness.base.script import BaseScript, PreScriptAction, PostScriptAction
|
|
from mozharness.base.vcs.vcsbase import VCSMixin
|
|
from mozharness.mozilla.blob_upload import BlobUploadMixin, blobupload_config_options
|
|
from mozharness.mozilla.mozbase import MozbaseMixin
|
|
from mozharness.mozilla.testing.testbase import TestingMixin, testing_config_options
|
|
from mozharness.mozilla.testing.unittest import EmulatorMixin
|
|
|
|
|
|
class AndroidEmulatorTest(BlobUploadMixin, TestingMixin, EmulatorMixin, VCSMixin, BaseScript, MozbaseMixin):
|
|
config_options = [[
|
|
["--test-suite"],
|
|
{"action": "store",
|
|
"dest": "test_suite",
|
|
}
|
|
], [
|
|
["--adb-path"],
|
|
{"action": "store",
|
|
"dest": "adb_path",
|
|
"default": None,
|
|
"help": "Path to adb",
|
|
}
|
|
], [
|
|
["--total-chunk"],
|
|
{"action": "store",
|
|
"dest": "total_chunks",
|
|
"default": None,
|
|
"help": "Number of total chunks",
|
|
}
|
|
], [
|
|
["--this-chunk"],
|
|
{"action": "store",
|
|
"dest": "this_chunk",
|
|
"default": None,
|
|
"help": "Number of this chunk",
|
|
}
|
|
]] + copy.deepcopy(testing_config_options) + \
|
|
copy.deepcopy(blobupload_config_options)
|
|
|
|
error_list = [
|
|
]
|
|
|
|
virtualenv_requirements = [
|
|
]
|
|
|
|
virtualenv_modules = [
|
|
]
|
|
|
|
app_name = None
|
|
|
|
def __init__(self, require_config_file=False):
|
|
super(AndroidEmulatorTest, self).__init__(
|
|
config_options=self.config_options,
|
|
all_actions=['clobber',
|
|
'read-buildbot-config',
|
|
'setup-avds',
|
|
'start-emulator',
|
|
'download-and-extract',
|
|
'create-virtualenv',
|
|
'verify-emulator',
|
|
'install',
|
|
'run-tests',
|
|
],
|
|
default_actions=['clobber',
|
|
'start-emulator',
|
|
'download-and-extract',
|
|
'create-virtualenv',
|
|
'verify-emulator',
|
|
'install',
|
|
'run-tests',
|
|
],
|
|
require_config_file=require_config_file,
|
|
config={
|
|
'virtualenv_modules': self.virtualenv_modules,
|
|
'virtualenv_requirements': self.virtualenv_requirements,
|
|
'require_test_zip': True,
|
|
# IP address of the host as seen from the emulator
|
|
'remote_webserver': '10.0.2.2',
|
|
}
|
|
)
|
|
|
|
# these are necessary since self.config is read only
|
|
c = self.config
|
|
abs_dirs = self.query_abs_dirs()
|
|
self.adb_path = self.query_exe('adb')
|
|
self.installer_url = c.get('installer_url')
|
|
self.installer_path = c.get('installer_path')
|
|
self.test_url = c.get('test_url')
|
|
self.test_packages_url = c.get('test_packages_url')
|
|
self.test_manifest = c.get('test_manifest')
|
|
self.robocop_path = os.path.join(abs_dirs['abs_work_dir'], "robocop.apk")
|
|
self.minidump_stackwalk_path = c.get("minidump_stackwalk_path")
|
|
self.emulator = c.get('emulator')
|
|
self.test_suite = c.get('test_suite')
|
|
self.this_chunk = c.get('this_chunk')
|
|
self.total_chunks = c.get('total_chunks')
|
|
if self.test_suite not in self.config["suite_definitions"]:
|
|
# accept old-style test suite name like "mochitest-3"
|
|
m = re.match("(.*)-(\d*)", self.test_suite)
|
|
if m:
|
|
self.test_suite = m.group(1)
|
|
if self.this_chunk is None:
|
|
self.this_chunk = m.group(2)
|
|
self.sdk_level = None
|
|
self.xre_path = None
|
|
|
|
def _query_tests_dir(self):
|
|
dirs = self.query_abs_dirs()
|
|
try:
|
|
test_dir = self.config["suite_definitions"][self.test_suite]["testsdir"]
|
|
except:
|
|
test_dir = self.test_suite
|
|
return os.path.join(dirs['abs_test_install_dir'], test_dir)
|
|
|
|
def query_abs_dirs(self):
|
|
if self.abs_dirs:
|
|
return self.abs_dirs
|
|
abs_dirs = super(AndroidEmulatorTest, self).query_abs_dirs()
|
|
dirs = {}
|
|
dirs['abs_test_install_dir'] = os.path.join(
|
|
abs_dirs['abs_work_dir'], 'tests')
|
|
dirs['abs_xre_dir'] = os.path.join(
|
|
abs_dirs['abs_work_dir'], 'hostutils')
|
|
dirs['abs_modules_dir'] = os.path.join(
|
|
dirs['abs_test_install_dir'], 'modules')
|
|
dirs['abs_blob_upload_dir'] = os.path.join(
|
|
abs_dirs['abs_work_dir'], 'blobber_upload_dir')
|
|
dirs['abs_emulator_dir'] = os.path.join(
|
|
abs_dirs['abs_work_dir'], 'emulator')
|
|
dirs['abs_mochitest_dir'] = os.path.join(
|
|
dirs['abs_test_install_dir'], 'mochitest')
|
|
dirs['abs_marionette_dir'] = os.path.join(
|
|
dirs['abs_test_install_dir'], 'marionette', 'marionette')
|
|
dirs['abs_marionette_tests_dir'] = os.path.join(
|
|
dirs['abs_test_install_dir'], 'marionette', 'tests', 'testing',
|
|
'marionette', 'harness', 'marionette', 'tests')
|
|
dirs['abs_avds_dir'] = self.config.get("avds_dir", "/home/cltbld/.android")
|
|
|
|
for key in dirs.keys():
|
|
if key not in abs_dirs:
|
|
abs_dirs[key] = dirs[key]
|
|
self.abs_dirs = abs_dirs
|
|
return self.abs_dirs
|
|
|
|
@PreScriptAction('create-virtualenv')
|
|
def _pre_create_virtualenv(self, action):
|
|
dirs = self.query_abs_dirs()
|
|
requirements = None
|
|
if os.path.isdir(dirs['abs_mochitest_dir']):
|
|
# mochitest is the only thing that needs this
|
|
requirements = os.path.join(dirs['abs_mochitest_dir'],
|
|
'websocketprocessbridge',
|
|
'websocketprocessbridge_requirements.txt')
|
|
elif self.test_suite == 'marionette':
|
|
requirements = os.path.join(dirs['abs_test_install_dir'],
|
|
'config', 'marionette_requirements.txt')
|
|
if requirements:
|
|
self.register_virtualenv_module(requirements=[requirements],
|
|
two_pass=True)
|
|
|
|
def _launch_emulator(self):
|
|
env = self.query_env()
|
|
|
|
# Set $LD_LIBRARY_PATH to self.dirs['abs_work_dir'] so that
|
|
# the emulator picks up the symlink to libGL.so.1 that we
|
|
# constructed in start_emulator.
|
|
env['LD_LIBRARY_PATH'] = self.abs_dirs['abs_work_dir']
|
|
|
|
# Set environment variables to help emulator find the AVD.
|
|
# In newer versions of the emulator, ANDROID_AVD_HOME should
|
|
# point to the 'avd' directory.
|
|
# For older versions of the emulator, ANDROID_SDK_HOME should
|
|
# point to the directory containing the '.android' directory
|
|
# containing the 'avd' directory.
|
|
avd_home_dir = self.abs_dirs['abs_avds_dir']
|
|
env['ANDROID_AVD_HOME'] = os.path.join(avd_home_dir, 'avd')
|
|
env['ANDROID_SDK_HOME'] = os.path.abspath(os.path.join(avd_home_dir, '..'))
|
|
|
|
command = [
|
|
"emulator", "-avd", self.emulator["name"],
|
|
"-port", str(self.emulator["emulator_port"]),
|
|
]
|
|
if "emulator_extra_args" in self.config:
|
|
command += self.config["emulator_extra_args"].split()
|
|
|
|
tmp_file = tempfile.NamedTemporaryFile(mode='w')
|
|
tmp_stdout = open(tmp_file.name, 'w')
|
|
self.info("Created temp file %s." % tmp_file.name)
|
|
self.info("Trying to start the emulator with this command: %s" % ' '.join(command))
|
|
proc = subprocess.Popen(command, stdout=tmp_stdout, stderr=tmp_stdout, env=env)
|
|
return {
|
|
"process": proc,
|
|
"tmp_file": tmp_file,
|
|
}
|
|
|
|
def _retry(self, max_attempts, interval, func, description, max_time = 0):
|
|
'''
|
|
Execute func until it returns True, up to max_attempts times, waiting for
|
|
interval seconds between each attempt. description is logged on each attempt.
|
|
If max_time is specified, no further attempts will be made once max_time
|
|
seconds have elapsed; this provides some protection for the case where
|
|
the run-time for func is long or highly variable.
|
|
'''
|
|
status = False
|
|
attempts = 0
|
|
if max_time > 0:
|
|
end_time = datetime.datetime.now() + datetime.timedelta(seconds = max_time)
|
|
else:
|
|
end_time = None
|
|
while attempts < max_attempts and not status:
|
|
if (end_time is not None) and (datetime.datetime.now() > end_time):
|
|
self.info("Maximum retry run-time of %d seconds exceeded; remaining attempts abandoned" % max_time)
|
|
break
|
|
if attempts != 0:
|
|
self.info("Sleeping %d seconds" % interval)
|
|
time.sleep(interval)
|
|
attempts += 1
|
|
self.info(">> %s: Attempt #%d of %d" % (description, attempts, max_attempts))
|
|
status = func()
|
|
return status
|
|
|
|
def _run_with_timeout(self, timeout, cmd):
|
|
timeout_cmd = ['timeout', '%s' % timeout] + cmd
|
|
return self._run_proc(timeout_cmd)
|
|
|
|
def _run_proc(self, cmd):
|
|
self.info('Running %s' % subprocess.list2cmdline(cmd))
|
|
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
|
|
out, err = p.communicate()
|
|
if out:
|
|
self.info('%s' % str(out.strip()))
|
|
if err:
|
|
self.info('stderr: %s' % str(err.strip()))
|
|
return out
|
|
|
|
def _telnet_cmd(self, telnet, command):
|
|
telnet.write('%s\n' % command)
|
|
result = telnet.read_until('OK', 10)
|
|
self.info('%s: %s' % (command, result))
|
|
return result
|
|
|
|
def _verify_adb(self):
|
|
self.info('Verifying adb connectivity')
|
|
self._run_with_timeout(180, [self.adb_path, 'wait-for-device'])
|
|
return True
|
|
|
|
def _verify_adb_device(self):
|
|
out = self._run_with_timeout(30, [self.adb_path, 'devices'])
|
|
if (self.emulator['device_id'] in out) and ("device" in out):
|
|
return True
|
|
return False
|
|
|
|
def _is_boot_completed(self):
|
|
boot_cmd = [self.adb_path, '-s', self.emulator['device_id'],
|
|
'shell', 'getprop', 'sys.boot_completed']
|
|
out = self._run_with_timeout(30, boot_cmd)
|
|
if out.strip() == '1':
|
|
return True
|
|
return False
|
|
|
|
def _telnet_to_emulator(self):
|
|
port = self.emulator["emulator_port"]
|
|
telnet_ok = False
|
|
try:
|
|
tn = telnetlib.Telnet('localhost', port, 10)
|
|
if tn is not None:
|
|
self.info('Connected to port %d' % port)
|
|
res = tn.read_until('OK', 10)
|
|
self.info(res)
|
|
self._telnet_cmd(tn, 'avd status')
|
|
self._telnet_cmd(tn, 'redir list')
|
|
self._telnet_cmd(tn, 'network status')
|
|
tn.write('quit\n')
|
|
tn.read_all()
|
|
telnet_ok = True
|
|
else:
|
|
self.warning('Unable to connect to port %d' % port)
|
|
except socket.error, e:
|
|
self.info('Trying again after socket error: %s' % str(e))
|
|
pass
|
|
except EOFError:
|
|
self.info('Trying again after EOF')
|
|
pass
|
|
except:
|
|
self.info('Trying again after unexpected exception')
|
|
pass
|
|
finally:
|
|
if tn is not None:
|
|
tn.close()
|
|
return telnet_ok
|
|
|
|
def _verify_emulator(self):
|
|
adb_ok = self._verify_adb()
|
|
if not adb_ok:
|
|
self.warning('Unable to communicate with adb')
|
|
return False
|
|
adb_device_ok = self._retry(4, 30, self._verify_adb_device, "Verify emulator visible to adb")
|
|
if not adb_device_ok:
|
|
self.warning('Unable to communicate with emulator via adb')
|
|
return False
|
|
boot_ok = self._retry(30, 10, self._is_boot_completed, "Verify Android boot completed", max_time = 330)
|
|
if not boot_ok:
|
|
self.warning('Unable to verify Android boot completion')
|
|
return False
|
|
telnet_ok = self._retry(4, 30, self._telnet_to_emulator, "Verify telnet to emulator")
|
|
if not telnet_ok:
|
|
self.warning('Unable to telnet to emulator on port %d' % self.emulator["emulator_port"])
|
|
return False
|
|
return True
|
|
|
|
def _verify_emulator_and_restart_on_fail(self):
|
|
emulator_ok = self._verify_emulator()
|
|
if not emulator_ok:
|
|
self._dump_host_state()
|
|
self._screenshot("emulator-startup-screenshot-")
|
|
self._kill_processes(self.config["emulator_process_name"])
|
|
self._run_proc(['ps', '-ef'])
|
|
self._dump_emulator_log()
|
|
# remove emulator tmp files
|
|
for dir in glob.glob("/tmp/android-*"):
|
|
self.rmtree(dir)
|
|
self._restart_adbd()
|
|
time.sleep(5)
|
|
self.emulator_proc = self._launch_emulator()
|
|
return emulator_ok
|
|
|
|
def _install_fennec_apk(self):
|
|
install_ok = False
|
|
if int(self.sdk_level) >= 23:
|
|
cmd = [self.adb_path, '-s', self.emulator['device_id'], 'install', '-r', '-g', self.installer_path]
|
|
else:
|
|
cmd = [self.adb_path, '-s', self.emulator['device_id'], 'install', '-r', self.installer_path]
|
|
out = self._run_with_timeout(300, cmd)
|
|
if 'Success' in out:
|
|
install_ok = True
|
|
return install_ok
|
|
|
|
def _install_robocop_apk(self):
|
|
install_ok = False
|
|
if int(self.sdk_level) >= 23:
|
|
cmd = [self.adb_path, '-s', self.emulator['device_id'], 'install', '-r', '-g', self.robocop_path]
|
|
else:
|
|
cmd = [self.adb_path, '-s', self.emulator['device_id'], 'install', '-r', self.robocop_path]
|
|
out = self._run_with_timeout(300, cmd)
|
|
if 'Success' in out:
|
|
install_ok = True
|
|
return install_ok
|
|
|
|
def _dump_host_state(self):
|
|
self._run_proc(['ps', '-ef'])
|
|
self._run_proc(['netstat', '-a', '-p', '-n', '-t', '-u'])
|
|
|
|
def _dump_emulator_log(self):
|
|
self.info("##### %s emulator log begins" % self.emulator["name"])
|
|
output = self.read_from_file(self.emulator_proc["tmp_file"].name, verbose=False)
|
|
if output:
|
|
self.info(output)
|
|
self.info("##### %s emulator log ends" % self.emulator["name"])
|
|
|
|
def _kill_processes(self, process_name):
|
|
p = subprocess.Popen(['ps', '-A'], stdout=subprocess.PIPE)
|
|
out, err = p.communicate()
|
|
self.info("Let's kill every process called %s" % process_name)
|
|
for line in out.splitlines():
|
|
if process_name in line:
|
|
pid = int(line.split(None, 1)[0])
|
|
self.info("Killing pid %d." % pid)
|
|
os.kill(pid, signal.SIGKILL)
|
|
|
|
def _restart_adbd(self):
|
|
self._run_with_timeout(30, [self.adb_path, 'kill-server'])
|
|
self._run_with_timeout(30, [self.adb_path, 'start-server'])
|
|
|
|
def _screenshot(self, prefix):
|
|
"""
|
|
Save a screenshot of the entire screen to the blob upload directory.
|
|
"""
|
|
dirs = self.query_abs_dirs()
|
|
utility = os.path.join(self.xre_path, "screentopng")
|
|
if not os.path.exists(utility):
|
|
self.warning("Unable to take screenshot: %s does not exist" % utility)
|
|
return
|
|
try:
|
|
tmpfd, filename = tempfile.mkstemp(prefix=prefix, suffix='.png',
|
|
dir=dirs['abs_blob_upload_dir'])
|
|
os.close(tmpfd)
|
|
self.info("Taking screenshot with %s; saving to %s" % (utility, filename))
|
|
subprocess.call([utility, filename], env=self.query_env())
|
|
except OSError, err:
|
|
self.warning("Failed to take screenshot: %s" % err.strerror)
|
|
|
|
def _query_package_name(self):
|
|
if self.app_name is None:
|
|
#find appname from package-name.txt - assumes download-and-extract has completed successfully
|
|
apk_dir = self.abs_dirs['abs_work_dir']
|
|
self.apk_path = os.path.join(apk_dir, self.installer_path)
|
|
unzip = self.query_exe("unzip")
|
|
package_path = os.path.join(apk_dir, 'package-name.txt')
|
|
unzip_cmd = [unzip, '-q', '-o', self.apk_path]
|
|
self.run_command(unzip_cmd, cwd=apk_dir, halt_on_failure=True)
|
|
self.app_name = str(self.read_from_file(package_path, verbose=True)).rstrip()
|
|
return self.app_name
|
|
|
|
def preflight_install(self):
|
|
# in the base class, this checks for mozinstall, but we don't use it
|
|
pass
|
|
|
|
def _build_command(self):
|
|
c = self.config
|
|
dirs = self.query_abs_dirs()
|
|
|
|
if self.test_suite not in self.config["suite_definitions"]:
|
|
self.fatal("Key '%s' not defined in the config!" % self.test_suite)
|
|
|
|
cmd = [
|
|
self.query_python_path('python'),
|
|
'-u',
|
|
os.path.join(
|
|
self._query_tests_dir(),
|
|
self.config["suite_definitions"][self.test_suite]["run_filename"]
|
|
),
|
|
]
|
|
|
|
raw_log_file = os.path.join(dirs['abs_blob_upload_dir'],
|
|
'%s_raw.log' % self.test_suite)
|
|
|
|
error_summary_file = os.path.join(dirs['abs_blob_upload_dir'],
|
|
'%s_errorsummary.log' % self.test_suite)
|
|
str_format_values = {
|
|
'app': self._query_package_name(),
|
|
'remote_webserver': c['remote_webserver'],
|
|
'xre_path': self.xre_path,
|
|
'utility_path': self.xre_path,
|
|
'http_port': self.emulator['http_port'],
|
|
'ssl_port': self.emulator['ssl_port'],
|
|
'certs_path': os.path.join(dirs['abs_work_dir'], 'tests/certs'),
|
|
# TestingMixin._download_and_extract_symbols() will set
|
|
# self.symbols_path when downloading/extracting.
|
|
'symbols_path': self.symbols_path,
|
|
'modules_dir': dirs['abs_modules_dir'],
|
|
'installer_path': self.installer_path,
|
|
'raw_log_file': raw_log_file,
|
|
'error_summary_file': error_summary_file,
|
|
'dm_trans': c['device_manager'],
|
|
# marionette options
|
|
'address': c.get('marionette_address'),
|
|
'gecko_log': os.path.join(dirs["abs_blob_upload_dir"], 'gecko.log'),
|
|
'test_manifest': os.path.join(
|
|
dirs['abs_marionette_tests_dir'],
|
|
self.config.get('marionette_test_manifest', '')
|
|
),
|
|
}
|
|
for option in self.config["suite_definitions"][self.test_suite]["options"]:
|
|
opt = option.split('=')[0]
|
|
# override configured chunk options with script args, if specified
|
|
if opt == '--this-chunk' and self.this_chunk is not None:
|
|
continue
|
|
if opt == '--total-chunks' and self.total_chunks is not None:
|
|
continue
|
|
cmd.extend([option % str_format_values])
|
|
|
|
if self.this_chunk is not None:
|
|
cmd.extend(['--this-chunk', self.this_chunk])
|
|
if self.total_chunks is not None:
|
|
cmd.extend(['--total-chunks', self.total_chunks])
|
|
|
|
try_options, try_tests = self.try_args(self.test_suite)
|
|
cmd.extend(try_options)
|
|
cmd.extend(self.query_tests_args(
|
|
self.config["suite_definitions"][self.test_suite].get("tests"),
|
|
None,
|
|
try_tests))
|
|
|
|
return cmd
|
|
|
|
def _get_repo_url(self, path):
|
|
"""
|
|
Return a url for a file (typically a tooltool manifest) in this hg repo
|
|
and using this revision (or mozilla-central/default if repo/rev cannot
|
|
be determined).
|
|
|
|
:param path specifies the directory path to the file of interest.
|
|
"""
|
|
if 'GECKO_HEAD_REPOSITORY' in os.environ and 'GECKO_HEAD_REV' in os.environ:
|
|
# probably taskcluster
|
|
repo = os.environ['GECKO_HEAD_REPOSITORY']
|
|
revision = os.environ['GECKO_HEAD_REV']
|
|
elif self.buildbot_config and 'properties' in self.buildbot_config:
|
|
# probably buildbot
|
|
repo = 'https://hg.mozilla.org/%s' % self.buildbot_config['properties']['repo_path']
|
|
revision = self.buildbot_config['properties']['revision']
|
|
else:
|
|
# something unexpected!
|
|
repo = 'https://hg.mozilla.org/mozilla-central'
|
|
revision = 'default'
|
|
self.warning('Unable to find repo/revision for manifest; using mozilla-central/default')
|
|
url = '%s/raw-file/%s/%s' % (
|
|
repo,
|
|
revision,
|
|
path)
|
|
return url
|
|
|
|
def _tooltool_fetch(self, url, dir):
|
|
c = self.config
|
|
|
|
manifest_path = self.download_file(
|
|
url,
|
|
file_name='releng.manifest',
|
|
parent_dir=dir
|
|
)
|
|
|
|
if not os.path.exists(manifest_path):
|
|
self.fatal("Could not retrieve manifest needed to retrieve "
|
|
"artifacts from %s" % manifest_path)
|
|
|
|
self.tooltool_fetch(manifest_path,
|
|
output_dir=dir,
|
|
cache=c.get("tooltool_cache", None))
|
|
|
|
##########################################
|
|
### Actions for AndroidEmulatorTest ###
|
|
##########################################
|
|
def setup_avds(self):
|
|
'''
|
|
If tooltool cache mechanism is enabled, the cached version is used by
|
|
the fetch command. If the manifest includes an "unpack" field, tooltool
|
|
will unpack all compressed archives mentioned in the manifest.
|
|
'''
|
|
c = self.config
|
|
dirs = self.query_abs_dirs()
|
|
|
|
# FIXME
|
|
# Clobbering and re-unpacking would not be needed if we had a way to
|
|
# check whether the unpacked content already present match the
|
|
# contents of the tar ball
|
|
self.rmtree(dirs['abs_avds_dir'])
|
|
self.mkdir_p(dirs['abs_avds_dir'])
|
|
url = self._get_repo_url(c["tooltool_manifest_path"])
|
|
self._tooltool_fetch(url, dirs['abs_avds_dir'])
|
|
|
|
avd_home_dir = self.abs_dirs['abs_avds_dir']
|
|
if avd_home_dir != "/home/cltbld/.android":
|
|
# Modify the downloaded avds to point to the right directory.
|
|
cmd = [
|
|
'bash', '-c',
|
|
'sed -i "s|/home/cltbld/.android|%s|" %s/test-*.ini' %
|
|
(avd_home_dir, os.path.join(avd_home_dir, 'avd'))
|
|
]
|
|
proc = ProcessHandler(cmd)
|
|
proc.run()
|
|
proc.wait()
|
|
|
|
def start_emulator(self):
|
|
'''
|
|
Starts the emulator
|
|
'''
|
|
if 'emulator_url' in self.config or 'emulator_manifest' in self.config or 'tools_manifest' in self.config:
|
|
self.install_emulator()
|
|
|
|
if not os.path.isfile(self.adb_path):
|
|
self.fatal("The adb binary '%s' is not a valid file!" % self.adb_path)
|
|
self._restart_adbd()
|
|
|
|
if not self.config.get("developer_mode"):
|
|
# We kill compiz because it sometimes prevents us from starting the emulator
|
|
self._kill_processes("compiz")
|
|
self._kill_processes("xpcshell")
|
|
|
|
# We add a symlink for libGL.so because the emulator dlopen()s it by that name
|
|
# even though the installed library on most systems without dev packages is
|
|
# libGL.so.1
|
|
linkfile = os.path.join(self.abs_dirs['abs_work_dir'], "libGL.so")
|
|
self.info("Attempting to establish symlink for %s" % linkfile)
|
|
try:
|
|
os.unlink(linkfile)
|
|
except OSError:
|
|
pass
|
|
for libdir in ["/usr/lib/x86_64-linux-gnu/mesa",
|
|
"/usr/lib/i386-linux-gnu/mesa",
|
|
"/usr/lib/mesa"]:
|
|
libfile = os.path.join(libdir, "libGL.so.1")
|
|
if os.path.exists(libfile):
|
|
self.info("Symlinking %s -> %s" % (linkfile, libfile))
|
|
self.mkdir_p(self.abs_dirs['abs_work_dir'])
|
|
os.symlink(libfile, linkfile)
|
|
break
|
|
self.emulator_proc = self._launch_emulator()
|
|
|
|
def verify_emulator(self):
|
|
'''
|
|
Check to see if the emulator can be contacted via adb and telnet.
|
|
If any communication attempt fails, kill the emulator, re-launch, and re-check.
|
|
'''
|
|
self.mkdir_p(self.query_abs_dirs()['abs_blob_upload_dir'])
|
|
max_restarts = 5
|
|
emulator_ok = self._retry(max_restarts, 10, self._verify_emulator_and_restart_on_fail, "Check emulator")
|
|
if not emulator_ok:
|
|
self.fatal('INFRA-ERROR: Unable to start emulator after %d attempts' % max_restarts)
|
|
# Start logcat for the emulator. The adb process runs until the
|
|
# corresponding emulator is killed. Output is written directly to
|
|
# the blobber upload directory so that it is uploaded automatically
|
|
# at the end of the job.
|
|
logcat_filename = 'logcat-%s.log' % self.emulator["device_id"]
|
|
logcat_path = os.path.join(self.abs_dirs['abs_blob_upload_dir'], logcat_filename)
|
|
logcat_cmd = '%s -s %s logcat -v threadtime Trace:S StrictMode:S ExchangeService:S > %s &' % \
|
|
(self.adb_path, self.emulator["device_id"], logcat_path)
|
|
self.info(logcat_cmd)
|
|
os.system(logcat_cmd)
|
|
# Get a post-boot emulator process list for diagnostics
|
|
ps_cmd = [self.adb_path, '-s', self.emulator["device_id"], 'shell', 'ps']
|
|
self._run_with_timeout(30, ps_cmd)
|
|
|
|
def download_and_extract(self):
|
|
"""
|
|
Download and extract fennec APK, tests.zip, host utils, and robocop (if required).
|
|
"""
|
|
super(AndroidEmulatorTest, self).download_and_extract(suite_categories=[self.test_suite])
|
|
dirs = self.query_abs_dirs()
|
|
if self.test_suite.startswith('robocop'):
|
|
robocop_url = self.installer_url[:self.installer_url.rfind('/')] + '/robocop.apk'
|
|
self.info("Downloading robocop...")
|
|
self.download_file(robocop_url, 'robocop.apk', dirs['abs_work_dir'], error_level=FATAL)
|
|
self.rmtree(dirs['abs_xre_dir'])
|
|
self.mkdir_p(dirs['abs_xre_dir'])
|
|
if self.config["hostutils_manifest_path"]:
|
|
url = self._get_repo_url(self.config["hostutils_manifest_path"])
|
|
self._tooltool_fetch(url, dirs['abs_xre_dir'])
|
|
for p in glob.glob(os.path.join(dirs['abs_xre_dir'], 'host-utils-*')):
|
|
if os.path.isdir(p) and os.path.isfile(os.path.join(p, 'xpcshell')):
|
|
self.xre_path = p
|
|
if not self.xre_path:
|
|
self.fatal("xre path not found in %s" % dirs['abs_xre_dir'])
|
|
else:
|
|
self.fatal("configure hostutils_manifest_path!")
|
|
|
|
def install(self):
|
|
"""
|
|
Install APKs on the emulator
|
|
"""
|
|
assert self.installer_path is not None, \
|
|
"Either add installer_path to the config or use --installer-path."
|
|
install_needed = self.config["suite_definitions"][self.test_suite].get("install")
|
|
if install_needed == False:
|
|
self.info("Skipping apk installation for %s" % self.test_suite)
|
|
return
|
|
|
|
self.sdk_level = self._run_with_timeout(30, [self.adb_path, '-s', self.emulator['device_id'],
|
|
'shell', 'getprop', 'ro.build.version.sdk'])
|
|
|
|
# Install Fennec
|
|
install_ok = self._retry(3, 30, self._install_fennec_apk, "Install Fennec APK")
|
|
if not install_ok:
|
|
self.fatal('INFRA-ERROR: Failed to install %s on %s' % (self.installer_path, self.emulator["name"]))
|
|
|
|
# Install Robocop if required
|
|
if self.test_suite.startswith('robocop'):
|
|
install_ok = self._retry(3, 30, self._install_robocop_apk, "Install Robocop APK")
|
|
if not install_ok:
|
|
self.fatal('INFRA-ERROR: Failed to install %s on %s' % (self.robocop_path, self.emulator["name"]))
|
|
|
|
self.info("Finished installing apps for %s" % self.emulator["name"])
|
|
|
|
def run_tests(self):
|
|
"""
|
|
Run the tests
|
|
"""
|
|
cmd = self._build_command()
|
|
|
|
try:
|
|
cwd = self._query_tests_dir()
|
|
except:
|
|
self.fatal("Don't know how to run --test-suite '%s'!" % self.test_suite)
|
|
env = self.query_env()
|
|
if self.query_minidump_stackwalk():
|
|
env['MINIDUMP_STACKWALK'] = self.minidump_stackwalk_path
|
|
env['MOZ_UPLOAD_DIR'] = self.query_abs_dirs()['abs_blob_upload_dir']
|
|
env['MINIDUMP_SAVE_PATH'] = self.query_abs_dirs()['abs_blob_upload_dir']
|
|
|
|
self.info("Running on %s the command %s" % (self.emulator["name"], subprocess.list2cmdline(cmd)))
|
|
self.info("##### %s log begins" % self.test_suite)
|
|
|
|
# TinderBoxPrintRe does not know about the '-debug' categories
|
|
aliases = {
|
|
'reftest-debug': 'reftest',
|
|
'jsreftest-debug': 'jsreftest',
|
|
'crashtest-debug': 'crashtest',
|
|
}
|
|
suite_category = aliases.get(self.test_suite, self.test_suite)
|
|
parser = self.get_test_output_parser(
|
|
suite_category,
|
|
config=self.config,
|
|
log_obj=self.log_obj,
|
|
error_list=self.error_list)
|
|
self.run_command(cmd, cwd=cwd, env=env, output_parser=parser)
|
|
tbpl_status, log_level = parser.evaluate_parser(0)
|
|
parser.append_tinderboxprint_line(self.test_suite)
|
|
|
|
self.info("##### %s log ends" % self.test_suite)
|
|
self._dump_emulator_log()
|
|
self.buildbot_status(tbpl_status, level=log_level)
|
|
|
|
@PostScriptAction('run-tests')
|
|
def stop_emulator(self, action, success=None):
|
|
'''
|
|
Report emulator health, then make sure that the emulator has been stopped
|
|
'''
|
|
self._verify_emulator()
|
|
self._kill_processes(self.config["emulator_process_name"])
|
|
|
|
def upload_blobber_files(self):
|
|
'''
|
|
Override BlobUploadMixin.upload_blobber_files to ensure emulator is killed
|
|
first (if the emulator is still running, logcat may still be running, which
|
|
may lock the blob upload directory, causing a hang).
|
|
'''
|
|
if self.config.get('blob_upload_branch'):
|
|
# Except on interactive workers, we want the emulator to keep running
|
|
# after the script is finished. So only kill it if blobber would otherwise
|
|
# have run anyway (it doesn't get run on interactive workers).
|
|
self._kill_processes(self.config["emulator_process_name"])
|
|
super(AndroidEmulatorTest, self).upload_blobber_files()
|
|
|
|
if __name__ == '__main__':
|
|
emulatorTest = AndroidEmulatorTest()
|
|
emulatorTest.run_and_exit()
|