def __init__(self, options):
self.options = options
self.logger = commandline.setup_logging("mozregression",
self.options,
{"mach": sys.stdout})
# allow to filter process output based on the user option
if options.process_output is None:
# process_output not user defined
log_process_output = options.build_type != 'opt'
else:
log_process_output = options.process_output == 'stdout'
get_default_logger("process").component_filter = \
lambda data: data if log_process_output else None
# filter some mozversion log lines
re_ignore_mozversion_line = re.compile(
r"^(platform_.+|application_vendor|application_remotingname"
r"|application_id|application_display_name): .+"
)
get_default_logger("mozversion").component_filter = lambda data: (
None if re_ignore_mozversion_line.match(data['message']) else data
)
self.action = None
self.fetch_config = None
def run(cls, version=None):
logger = get_default_logger()
try:
device = DeviceHelper.getDevice()
except ADBError as e:
logger.error("Error connecting to device via adb (error: %s). Please be " \
"sure device is connected and 'remote debugging' is enabled." % \
e.msg)
raise
try:
out = device.shell_output('ls -alR /', root=True)
except ADBError as e:
cls.log_status('FAIL', 'Failed to gather filesystem information from device via adb: %s' % e.msg)
return False
found = []
for f in parse_ls(out):
if f['perm'][7] == 'w' and f['mode'] != 'l':
if not cls.whitelist_check(f['name']):
found.append(f['name'])
if len(found) > 0:
cls.log_status('PASS',
'Please ensure that the following world-writable files will not pose a security risk:\n%s' % '\n'.join(
found))
else:
cls.log_status('PASS', 'No unexpected suidroot executables found.')
return True
def inner(command, *args, **kwargs):
global logger
if logger is None:
logger = get_default_logger("vcs")
repo = kwargs.pop("repo", None)
log_error = kwargs.pop("log_error", True)
if kwargs:
raise TypeError, kwargs
args = list(args)
proc_kwargs = {}
if repo is not None:
proc_kwargs["cwd"] = repo
command_line = [bin_name, command] + args
logger.debug(" ".join(command_line))
try:
return subprocess.check_output(command_line, stderr=subprocess.STDOUT, **proc_kwargs)
except subprocess.CalledProcessError as e:
if log_error:
logger.error(e.output)
raise
def __init__(self, fetch_config, test_runner, options):
self.fetch_config = fetch_config
self.options = options
self.bisector = Bisector(fetch_config, test_runner,
persist=options.persist,
dl_in_background=options.background_dl)
self._logger = get_default_logger('Bisector')
def __init__(self, total_chunks, chunk_number, **kwargs):
self.total_chunks = total_chunks
self.chunk_number = chunk_number
assert self.chunk_number <= self.total_chunks
self.logger = structured.get_default_logger()
assert self.logger
self.kwargs = kwargs
def run_groups(groups=[], version=None, host='localhost', port=2828, mode='phone'):
hasadb = mode == 'phone'
logger = get_default_logger()
if groups is None or len(groups) == 0: # run all groups
logger.debug('running securitysuite tests for all groups %s' % str(ExtraTest.group_list(mode=mode)))
groups = ExtraTest.group_list(mode=mode)
else:
logger.debug('running securitysuite tests for groups %s' % str(groups))
logger.suite_start(tests=groups)
# setup marionette before any test
marionette = DeviceHelper.getMarionette(host=host, port=port)
# setup device before any test
device = DeviceHelper.getDevice(runAdbAsRoot=True)
for g in groups:
logger.debug("running securitysuite test group %s" % g)
logger.test_start(g)
try:
ExtraTest.run(g, version=version)
logger.test_end(g, 'OK')
except:
logger.critical(traceback.format_exc())
logger.test_end(g, 'FAIL')
raise
logger.suite_end()
def __init__(self, find_fix=False):
self.find_fix = find_fix
self.found_repo = None
self.build_range = None
self.good_revision = None
self.bad_revision = None
self._logger = get_default_logger('Bisector')
def run(cls, version=None):
logger = get_default_logger()
try:
dm = mozdevice.DeviceManagerADB(runAdbAsRoot=True)
except mozdevice.DMError as e:
logger.error("Error connecting to device via adb (error: %s). Please be " \
"sure device is connected and 'remote debugging' is enabled." % \
e.msg)
raise
try:
out = dm.shellCheckOutput(['ls', '-alR', '/'], root=True)
except mozdevice.DMError as e:
cls.log_status('FAIL', 'Failed to gather filesystem information from device via adb: %s' % e.msg)
return False
found = []
for f in parse_ls(out):
if f['perm'][2] == 's' and f['uid'] == 'root':
if not cls.whitelist_check(f['name']):
found.append(f['name'])
if len(found) > 0:
cls.log_status('PASS',
'Please ensure that the following suid root files are no security risk:\n%s' % '\n'.join(
found))
else:
cls.log_status('PASS', 'No unexpected suidroot executables found.')
return True
def run_groups(groups=[], version=None, host='localhost', port=2828, mode='phone'):
hasadb = mode == 'phone'
logger = get_default_logger()
if groups is None or len(groups) == 0: # run all groups
logger.debug('running securitysuite tests for all groups %s' % str(ExtraTest.group_list(mode=mode)))
groups = ExtraTest.group_list(mode=mode)
else:
logger.debug('running securitysuite tests for groups %s' % str(groups))
logger.suite_start(tests=groups)
# setup marionette before any test
marionette = DeviceHelper.getMarionette(host=host, port=port)
# setup device before any test
device = DeviceHelper.getDevice()
for g in groups:
logger.debug("running securitysuite test group %s" % g)
logger.test_start(g)
try:
ExtraTest.run(g, version=version)
logger.test_end(g, 'OK')
except:
logger.critical(traceback.format_exc())
logger.test_end(g, 'FAIL')
raise
logger.suite_end()
def run(cls, version=None):
logger = get_default_logger()
try:
ps = b2gps()
except Exception as e:
cls.log_status('FAIL', 'Failed to retrieve b2g-ps info: %s' % e)
return False
# list of b2g versions that don't have seccomp support
without_seccomp = ['1.0', '1.1', '1.2', '1.3', '1.3t', '1.4']
if version is not None and version in without_seccomp:
cls.log_status('PASS', "Target version %s doesn't support SECCOMP" % version)
return True
if not ps.has_known_format():
cls.log_status('FAIL', "b2g-ps output from device has unknown format")
return False
if not ps.seccomp_is_enabled():
cls.log_status('FAIL', "Please enable SECCOMP support on the device. The B2G version should support it.")
return False
if not ps.b2g_uses_seccomp():
cls.log_status('FAIL', "Gonk has SECCOMP support, but the B2G process doesn't. Please enable.")
return False
cls.log_status('PASS', "SECCOMP enabled in Gonk and B2G process")
return True
def __init__(self, test_queue):
self.test_queue = test_queue
self.current_group = None
self.current_metadata = None
self.logger = structured.get_default_logger()
if self.logger is None:
self.logger = structured.structuredlog.StructuredLogger("TestSource")
def run(cls, version=None):
logger = get_default_logger()
try:
dm = DeviceHelper.getDevice(runAdbAsRoot=True)
except mozdevice.DMError as e:
logger.error("Error connecting to device via adb (error: %s). Please be " \
"sure device is connected and 'remote debugging' is enabled." % \
e.msg)
raise
try:
out = dm.shellCheckOutput(['ls', '-alR', '/'], root=True)
except mozdevice.DMError as e:
cls.log_status('FAIL', 'Failed to gather filesystem information from device via adb: %s' % e.msg)
return False
found = []
for f in parse_ls(out):
if f['perm'][7] == 'w' and f['mode'] != 'l':
if not cls.whitelist_check(f['name']):
found.append(f['name'])
if len(found) > 0:
cls.log_status('PASS',
'Please ensure that the following world-writable files will not pose a security risk:\n%s' % '\n'.join(
found))
else:
cls.log_status('PASS', 'No unexpected suidroot executables found.')
return True
def __init__(self, test_paths, force_manifest_update=False):
do_delayed_imports()
self.test_paths = test_paths
self.force_manifest_update = force_manifest_update
self.logger = structured.get_default_logger()
if self.logger is None:
self.logger = structured.structuredlog.StructuredLogger("ManifestLoader")
def __init__(self, device_serial=None):
self.device_serial = device_serial
self._logger = structured.get_default_logger(component='b2gmonkey')
if not self._logger:
self._logger = mozlog.getLogger('b2gmonkey')
self.version = mozversion.get_version(
dm_type='adb', device_serial=device_serial)
device_id = self.version.get('device_id')
if not device_id:
raise B2GMonkeyError('Firefox OS device not found.')
self.device_properties = DEVICE_PROPERTIES.get(device_id)
if not self.device_properties:
raise B2GMonkeyError('Unsupported device: \'%s\'' % device_id)
android_version = self.version.get('device_firmware_version_release')
if device_id == 'flame' and android_version == '4.4.2':
self.device_properties.update(DEVICE_PROPERTIES.get('flame-kk'))
self.temp_dir = tempfile.mkdtemp()
if 'MINIDUMP_SAVE_PATH' not in os.environ:
self.crash_dumps_path = os.path.join(self.temp_dir, 'crashes')
os.environ['MINIDUMP_SAVE_PATH'] = self.crash_dumps_path
else:
self.crash_dumps_path = os.environ['MINIDUMP_SAVE_PATH']
def __init__(self, device_serial=None):
self.device_serial = device_serial
self._logger = structured.get_default_logger(component='b2gmonkey')
if not self._logger:
self._logger = mozlog.getLogger('b2gmonkey')
self.version = mozversion.get_version(dm_type='adb',
device_serial=device_serial)
device_id = self.version.get('device_id')
if not device_id:
raise B2GMonkeyError('Firefox OS device not found.')
self.device_properties = DEVICE_PROPERTIES.get(device_id)
if not self.device_properties:
raise B2GMonkeyError('Unsupported device: \'%s\'' % device_id)
android_version = self.version.get('device_firmware_version_release')
if device_id == 'flame' and android_version == '4.4.2':
self.device_properties.update(DEVICE_PROPERTIES.get('flame-kk'))
self.temp_dir = tempfile.mkdtemp()
if 'MINIDUMP_SAVE_PATH' not in os.environ:
self.crash_dumps_path = os.path.join(self.temp_dir, 'crashes')
os.environ['MINIDUMP_SAVE_PATH'] = self.crash_dumps_path
else:
self.crash_dumps_path = os.environ['MINIDUMP_SAVE_PATH']
def run(cls, version=None):
logger = get_default_logger()
try:
device = DeviceHelper.getDevice()
except ADBError as e:
logger.error("Error connecting to device via adb (error: %s). Please be " \
"sure device is connected and 'remote debugging' is enabled." % \
e.msg)
raise
try:
out = device.shell_output('ls -alR /', root=True)
except ADBError as e:
cls.log_status(
'FAIL',
'Failed to gather filesystem information from device via adb: %s'
% e.msg)
return False
found = []
for f in parse_ls(out):
if f['perm'][2] == 's' and f['uid'] == 'root':
if not cls.whitelist_check(f['name']):
found.append(f['name'])
if len(found) > 0:
cls.log_status(
'PASS',
'Please ensure that the following suid root files are no security risk:\n%s'
% '\n'.join(found))
else:
cls.log_status('PASS', 'No unexpected suidroot executables found.')
return True
def __init__(self, test_paths, force_manifest_update=False):
do_delayed_imports()
self.test_paths = test_paths
self.force_manifest_update = force_manifest_update
self.logger = structured.get_default_logger()
if self.logger is None:
self.logger = structured.structuredlog.StructuredLogger("ManifestLoader")
def inner(command, *args, **kwargs):
global logger
if logger is None:
logger = get_default_logger("vcs")
repo = kwargs.pop("repo", None)
log_error = kwargs.pop("log_error", True)
if kwargs:
raise TypeError, kwargs
args = list(args)
proc_kwargs = {}
if repo is not None:
proc_kwargs["cwd"] = repo
command_line = [bin_name, command] + args
logger.debug(" ".join(command_line))
try:
return subprocess.check_output(command_line,
stderr=subprocess.STDOUT,
**proc_kwargs)
except subprocess.CalledProcessError as e:
if log_error:
logger.error(e.output)
raise
def checkForCrashes(self, directory, symbolsPath):
crashed = False
remote_dump_dir = self._remoteProfile + '/minidumps'
print "checking for crashes in '%s'" % remote_dump_dir
if self._devicemanager.dirExists(remote_dump_dir):
local_dump_dir = tempfile.mkdtemp()
self._devicemanager.getDirectory(remote_dump_dir, local_dump_dir)
try:
logger = get_default_logger()
if logger is not None:
crashed = mozcrash.log_crashes(logger,
local_dump_dir,
symbolsPath,
test=self.lastTestSeen)
else:
crashed = mozcrash.check_for_crashes(
local_dump_dir,
symbolsPath,
test_name=self.lastTestSeen)
except:
traceback.print_exc()
finally:
shutil.rmtree(local_dump_dir)
self._devicemanager.removeDir(remote_dump_dir)
return crashed
def __init__(self, find_fix=False):
self.find_fix = find_fix
self.found_repo = None
self.build_data = None
self.good_revision = None
self.bad_revision = None
self._logger = get_default_logger('Bisector')
def __init__(self, nightly_runner, inbound_runner, appname="firefox",
last_good_revision=None, first_bad_revision=None):
self.nightly_runner = nightly_runner
self.inbound_runner = inbound_runner
self.appname = appname
self.last_good_revision = last_good_revision
self.first_bad_revision = first_bad_revision
self._logger = get_default_logger('Bisector')
def __init__(self, inbound_branch=None, bits=mozinfo.bits, persist=None):
self.inbound_branch = inbound_branch
self.bits = bits
self.persist = persist
self.build_regex = self._get_build_regex(self.name, bits) + "$"
self.build_info_regex = \
self._get_build_regex(self.name, bits, with_ext=False) + "\.txt$"
self._logger = get_default_logger('Regression Runner')
def __init__(self, fetch_config, test_runner, options):
self.fetch_config = fetch_config
self.options = options
self.bisector = Bisector(fetch_config,
test_runner,
persist=options.persist,
dl_in_background=options.background_dl)
self._logger = get_default_logger('Bisector')
def cli(argv=None):
"""
main entry point of mozregression command line.
"""
options = parse_args(argv)
logger = commandline.setup_logging("mozregression",
options,
{"mach": sys.stdout})
check_mozregression_version(logger)
if options.list_releases:
print(formatted_valid_release_dates())
sys.exit()
cache_session = limitedfilecache.get_cache(
options.http_cache_dir, limitedfilecache.ONE_GIGABYTE,
logger=get_default_logger('Limited File Cache'))
set_http_cache_session(cache_session,
get_defaults={"timeout": options.http_timeout})
fetch_config = create_config(options.app, mozinfo.os, options.bits)
if options.command is None:
launcher_kwargs = dict(
addons=options.addons,
profile=options.profile,
cmdargs=options.cmdargs,
preferences=preference(options.prefs_files, options.prefs),
)
test_runner = ManualTestRunner(launcher_kwargs=launcher_kwargs)
else:
test_runner = CommandTestRunner(options.command)
runner = ResumeInfoBisectRunner(fetch_config, test_runner, options)
if fetch_config.is_inbound():
# this can be useful for both inbound and nightly, because we
# can go to inbound from nightly.
fetch_config.set_inbound_branch(options.inbound_branch)
# bisect inbound if last good revision or first bad revision are set
if options.first_bad_revision or options.last_good_revision:
bisect = bisect_inbound
else:
bisect = bisect_nightlies
try:
launcher_class = APP_REGISTRY.get(fetch_config.app_name)
launcher_class.check_is_runnable()
sys.exit(bisect(runner, logger))
except KeyboardInterrupt:
sys.exit("\nInterrupted.")
except UnavailableRelease as exc:
sys.exit("%s\n%s" % (exc, formatted_valid_release_dates()))
except (MozRegressionError, RequestException) as exc:
sys.exit(str(exc))
def __init__(self):
self.logger = get_default_logger()
try:
self.device = DeviceHelper.getDevice()
except ADBError as e:
self.logger.error("Error connecting to device via adb (error: %s). Please be "
"sure device is connected and 'remote debugging' is enabled." %
e.msg)
raise
def cli(argv=None):
"""
main entry point of mozregression command line.
"""
options = parse_args(argv)
logger = commandline.setup_logging("mozregression", options,
{"mach": sys.stdout})
check_mozregression_version(logger)
if options.list_releases:
print(formatted_valid_release_dates())
sys.exit()
cache_session = limitedfilecache.get_cache(
options.http_cache_dir,
limitedfilecache.ONE_GIGABYTE,
logger=get_default_logger('Limited File Cache'))
set_http_cache_session(cache_session,
get_defaults={"timeout": options.http_timeout})
fetch_config = create_config(options.app, mozinfo.os, options.bits)
if options.command is None:
launcher_kwargs = dict(
addons=options.addons,
profile=options.profile,
cmdargs=options.cmdargs,
preferences=preference(options.prefs_files, options.prefs),
)
test_runner = ManualTestRunner(launcher_kwargs=launcher_kwargs)
else:
test_runner = CommandTestRunner(options.command)
runner = ResumeInfoBisectRunner(fetch_config, test_runner, options)
if fetch_config.is_inbound():
# this can be useful for both inbound and nightly, because we
# can go to inbound from nightly.
fetch_config.set_inbound_branch(options.inbound_branch)
# bisect inbound if last good revision or first bad revision are set
if options.first_bad_revision or options.last_good_revision:
bisect = bisect_inbound
else:
bisect = bisect_nightlies
try:
launcher_class = APP_REGISTRY.get(fetch_config.app_name)
launcher_class.check_is_runnable()
sys.exit(bisect(runner, logger))
except KeyboardInterrupt:
sys.exit("\nInterrupted.")
except UnavailableRelease as exc:
sys.exit("%s\n%s" % (exc, formatted_valid_release_dates()))
except (MozRegressionError, RequestException) as exc:
sys.exit(str(exc))
def __init__(self):
self.logger = get_default_logger()
try:
self.dm = mozdevice.DeviceManagerADB(runAdbAsRoot=True)
except mozdevice.DMError as e:
self.logger.error("Error connecting to device via adb (error: %s). Please be "
"sure device is connected and 'remote debugging' is enabled." %
e.msg)
raise
def __init__(self):
self.logger = get_default_logger()
try:
self.device = DeviceHelper.getDevice()
except ADBError as e:
self.logger.error(
"Error connecting to device via adb (error: %s). Please be "
"sure device is connected and 'remote debugging' is enabled." %
e.msg)
raise
def __init__(self):
self.logger = get_default_logger()
try:
self.dm = mozdevice.DeviceManagerADB(runAdbAsRoot=True)
except mozdevice.DMError as e:
self.logger.error("Error connecting to device via adb (error: %s). Please be " \
"sure device is connected and 'remote debugging' is enabled." % \
e.msg)
raise
self.logger.debug("Attempting to set up port forwarding for marionette")
def __init__(self, test_paths, force_manifest_update=False, manifest_download=False, types=None, meta_filters=None):
do_delayed_imports()
self.test_paths = test_paths
self.force_manifest_update = force_manifest_update
self.manifest_download = manifest_download
self.types = types
self.meta_filters = meta_filters or []
self.logger = structured.get_default_logger()
if self.logger is None:
self.logger = structured.structuredlog.StructuredLogger("ManifestLoader")
def __init__(self, test_paths, force_manifest_update=False, manifest_download=False, types=None, meta_filters=None):
do_delayed_imports()
self.test_paths = test_paths
self.force_manifest_update = force_manifest_update
self.manifest_download = manifest_download
self.types = types
self.meta_filters = meta_filters or []
self.logger = structured.get_default_logger()
if self.logger is None:
self.logger = structured.structuredlog.StructuredLogger("ManifestLoader")
def __init__(self, addons=None, appname="firefox", inbound_branch=None,
profile=None, cmdargs=(), bits=mozinfo.bits, persist=None):
self.app = self.apps[appname](inbound_branch=inbound_branch, bits=bits,
persist=persist)
self.addons = addons
self.profile = profile
self.persist = persist
self.cmdargs = list(cmdargs)
self.inbound_branch = inbound_branch
self._logger = get_default_logger('Regression Runner')
def __init__(self, dest, **kwargs):
self._running = False
self._stopping = False
self._logger = get_default_logger('Test Runner')
try:
self._install(dest)
except Exception:
msg = "Unable to install %r" % dest
self._logger.error(msg, exc_info=True)
raise LauncherError(msg)
def setup_server_logging(self):
server_logger = get_default_logger(component="wptserve")
assert server_logger is not None
log_filter = handlers.LogLevelFilter(lambda x: x, "info")
# Downgrade errors to warnings for the server
log_filter = LogLevelRewriter(log_filter, ["error"], "warning")
server_logger.component_filter = log_filter
serve.logger = server_logger
#Set as the default logger for wptserve
serve.set_logger(server_logger)
def setup_server_logging(self):
server_logger = get_default_logger(component="wptserve")
assert server_logger is not None
log_filter = handlers.LogLevelFilter(lambda x:x, "info")
# Downgrade errors to warnings for the server
log_filter = LogLevelRewriter(log_filter, ["error"], "warning")
server_logger.component_filter = log_filter
serve.logger = server_logger
#Set as the default logger for wptserve
serve.set_logger(server_logger)
def _start(
self,
profile=None,
addons=(),
cmdargs=(),
preferences=None,
adb_profile_dir=None,
):
profile = self._create_profile(profile=profile,
addons=addons,
preferences=preferences)
LOG.info("Launching %s" % self.binary)
self.runner = Runner(binary=self.binary,
cmdargs=cmdargs,
profile=profile)
def _on_exit():
# if we are stopping the process do not log anything.
if not self._stopping:
# mozprocess (behind mozrunner) fire 'onFinish'
# a bit early - let's ensure the process is finished.
# we have to call wait() directly on the subprocess
# instance of the ProcessHandler, else on windows
# None is returned...
# TODO: search that bug and fix that in mozprocess or
# mozrunner. (likely mozproces)
try:
exitcode = self.runner.process_handler.proc.wait()
except Exception:
print()
LOG.error(
"Error while waiting process, consider filing a bug.",
exc_info=True,
)
return
if exitcode != 0:
# first print a blank line, to be sure we don't
# write on an already printed line without EOL.
print()
LOG.warning("Process exited with code %s" % exitcode)
# we don't need stdin, and GUI will not work in Windowed mode if set
# see: https://stackoverflow.com/a/40108817
# also, don't stream to stdout: https://bugzilla.mozilla.org/show_bug.cgi?id=1653349
devnull = open(os.devnull, "wb")
self.runner.process_args = {
"processOutputLine": [get_default_logger("process").info],
"stdin": devnull,
"stream": None,
"onFinish": _on_exit,
}
self.runner.start()
def __init__(self, parent):
self.parent = parent
self.result_array = []
self.comment_array = []
self.init_time = time.time()
self.test_num = self.parent.parent.__module__[5:]
self.detail_file = "{}/{}_detail.html".format(self.parent.general.get_config_variable('result_dir', 'output'),
self.test_num)
# config_file = self.parent.general.get_config_variable('log_cfg', 'output')
# logging.config.fileConfig(config_file)
self.custom_logger = get_default_logger()
def __init__(self, options):
self.options = options
self.logger = commandline.setup_logging("mozregression", self.options,
{"mach": sys.stdout})
# allow to filter process output based on the user option
if options.process_output is None:
# process_output not user defined
log_process_output = options.build_type != 'opt'
else:
log_process_output = options.process_output == 'stdout'
get_default_logger("process").component_filter = \
lambda data: data if log_process_output else None
# filter some mozversion log lines
re_ignore_mozversion_line = re.compile(
r"^(platform_.+|application_vendor|application_remotingname"
r"|application_id|application_display_name): .+")
get_default_logger("mozversion").component_filter = lambda data: (
None if re_ignore_mozversion_line.match(data['message']) else data)
self.action = None
self.fetch_config = None
def __exit__(self, ex_type, ex_value, tb):
args = ex_type, ex_value, tb
if ex_type in (SystemExit, KeyboardInterrupt):
logger = get_default_logger()
logger.info("Testrun interrupted")
try:
self.structured_file.__exit__(*args)
self.zip_file.write(self.structured_path)
finally:
try:
os.unlink(self.structured_path)
finally:
self.zip_file.__exit__(*args)
def run(cls, version=None):
logger = get_default_logger()
try:
dumper = certdump()
versions = dumper.nssversion_via_marionette()
except:
cls.log_status('FAIL', 'Failed to gather information from the device via Marionette.')
return False
cls.log_status('PASS', 'NSS component versions detected:\n%s' % '\n'.join(
["%s: %s" % (k, versions[k]) for k in versions]))
return True
def checkForCrashes(self, directory, symbolsPath):
self.checkForANRs()
self.checkForTombstones()
try:
logcat = self._devicemanager.getLogcat(
filterOutRegexps=fennecLogcatFilters)
except DMError:
print "getLogcat threw DMError; re-trying just once..."
time.sleep(1)
logcat = self._devicemanager.getLogcat(
filterOutRegexps=fennecLogcatFilters)
javaException = mozcrash.check_for_java_exception(logcat)
if javaException:
return True
# If crash reporting is disabled (MOZ_CRASHREPORTER!=1), we can't say
# anything.
if not self.CRASHREPORTER:
return False
try:
dumpDir = tempfile.mkdtemp()
remoteCrashDir = self._remoteProfile + '/minidumps/'
if not self._devicemanager.dirExists(remoteCrashDir):
# If crash reporting is enabled (MOZ_CRASHREPORTER=1), the
# minidumps directory is automatically created when Fennec
# (first) starts, so its lack of presence is a hint that
# something went wrong.
print "Automation Error: No crash directory (%s) found on remote device" % remoteCrashDir
# Whilst no crash was found, the run should still display as a failure
return True
self._devicemanager.getDirectory(remoteCrashDir, dumpDir)
logger = get_default_logger()
if logger is not None:
crashed = mozcrash.log_crashes(logger,
dumpDir,
symbolsPath,
test=self.lastTestSeen)
else:
crashed = Automation.checkForCrashes(self, dumpDir,
symbolsPath)
finally:
try:
shutil.rmtree(dumpDir)
except:
print "WARNING: unable to remove directory: %s" % dumpDir
return crashed
def __init__(self, addr, io_loop=None, verbose=False):
self._addr = addr
self.io_loop = io_loop or IOLoop.instance()
self.started = False
global logger
logger = get_default_logger()
self.routes = tornado.web.Application(
[(r"/tests", TestHandler),
(r"/", web.RedirectHandler, {"url": "/app.html"}),
(r"/(.*[html|css|js])$", NoCacheStaticFileHandler,
{"path": static_dir})])
self.server = tornado.httpserver.HTTPServer(
self.routes, io_loop=self.io_loop)
def run(cls, version=None):
logger = get_default_logger()
try:
dumper = certdump()
certs = dumper.get_via_marionette()
except Exception as e: # TODO: too broad exception
cls.log_status('FAIL', 'Failed to gather information from the device via Marionette: %s' % e)
return False
# TODO: just listing all of the certs, no filtering
certlist = [x['cert'][u'subjectName'] for x in certs]
cls.log_status('PASS', 'SSL certificates on device:\n%s' % '\n'.join(certlist))
return True
def setup_server_logging(self):
server_logger = get_default_logger(component="wptserve")
assert server_logger is not None
log_filter = handlers.LogLevelFilter(lambda x:x, "info")
# Downgrade errors to warnings for the server
log_filter = LogLevelRewriter(log_filter, ["error"], "warning")
server_logger.component_filter = log_filter
try:
#Set as the default logger for wptserve
serve.set_logger(server_logger)
serve.logger = server_logger
except Exception:
# This happens if logging has already been set up for wptserve
pass
def setup_server_logging(self):
server_logger = get_default_logger(component="wptserve")
assert server_logger is not None
log_filter = handlers.LogLevelFilter(lambda x:x, "info")
# Downgrade errors to warnings for the server
log_filter = LogLevelRewriter(log_filter, ["error"], "warning")
server_logger.component_filter = log_filter
try:
#Set as the default logger for wptserve
serve.set_logger(server_logger)
serve.logger = server_logger
except Exception:
# This happens if logging has already been set up for wptserve
pass
def __init__(self, fetch_config, options,
last_good_revision=None, first_bad_revision=None):
self.last_good_revision = last_good_revision
self.first_bad_revision = first_bad_revision
self.fetch_config = fetch_config
self.options = options
self.launcher_kwargs = dict(
addons=options.addons,
profile=options.profile,
cmdargs=options.cmdargs,
)
self.nightly_data = NightlyBuildData(parse_date(options.good_date),
parse_date(options.bad_date),
fetch_config)
self._logger = get_default_logger('Bisector')
def __init__(self):
self.logger = get_default_logger()
try:
self.device = DeviceHelper.getDevice()
except ADBError as e:
self.logger.error("Error connecting to device via adb (error: %s). Please be "
"sure device is connected and 'remote debugging' is enabled." %
e.msg)
raise
try:
self.ps = self.device.shell_output('b2g-ps', root=True).split('\r\n')
except ADBError as e:
self.logger.error("Error reading b2g-ps result from device: %s" % e.msg)
raise
def __init__(self):
self.logger = get_default_logger()
try:
self.dm = mozdevice.DeviceManagerADB(runAdbAsRoot=True)
except mozdevice.DMError as e:
self.logger.error("Error connecting to device via adb (error: %s). Please be "
"sure device is connected and 'remote debugging' is enabled." %
e.msg)
raise
try:
self.ps = self.dm.shellCheckOutput(['b2g-ps'], root=True).split('\n')
except mozdevice.DMError as e:
self.logger.error("Error reading b2g-ps result from device: %s" % e.msg)
raise
def run(cls, version=None):
logger = get_default_logger()
try:
dumper = certdump()
versions = dumper.nssversion_via_marionette()
except:
cls.log_status(
'FAIL',
'Failed to gather information from the device via Marionette.')
return False
cls.log_status(
'PASS', 'NSS component versions detected:\n%s' %
'\n'.join(["%s: %s" % (k, versions[k]) for k in versions]))
return True
def run(cls, version=None):
logger = get_default_logger()
try:
dumper = certdump()
certs = dumper.get_via_marionette()
except:
cls.log_status(
'FAIL',
'Failed to gather information from the device via Marionette.')
return False
# TODO: just listing all of the certs, no filtering
certlist = [x['cert'][u'subjectName'] for x in certs]
cls.log_status('PASS',
'SSL certificates on device:\n%s' % '\n'.join(certlist))
return True
def __exit__(self, ex_type, ex_value, tb):
args = ex_type, ex_value, tb
logger = get_default_logger()
if ex_type in (SystemExit, KeyboardInterrupt):
logger.info("Testrun interrupted")
try:
for handle in logger.handlers:
logger.remove_handler(handle);
self.structured_file.close()
self.zip_file.write(self.structured_path)
finally:
try:
os.unlink(self.structured_path)
except WindowsError:
pass
finally:
self.zip_file.__exit__(*args)
def __init__(self,
fetch_config,
options,
last_good_revision=None,
first_bad_revision=None):
self.last_good_revision = last_good_revision
self.first_bad_revision = first_bad_revision
self.fetch_config = fetch_config
self.options = options
self.launcher_kwargs = dict(
addons=options.addons,
profile=options.profile,
cmdargs=options.cmdargs,
)
self.nightly_data = NightlyBuildData(parse_date(options.good_date),
parse_date(options.bad_date),
fetch_config)
self._logger = get_default_logger('Bisector')
def __init__(self):
self.logger = get_default_logger()
try:
self.device = DeviceHelper.getDevice()
except ADBError as e:
self.logger.error(
"Error connecting to device via adb (error: %s). Please be "
"sure device is connected and 'remote debugging' is enabled." %
e.msg)
raise
try:
self.ps = self.device.shell_output('b2g-ps',
root=True).split('\r\n')
except ADBError as e:
self.logger.error("Error reading b2g-ps result from device: %s" %
e.msg)
raise
def _start(self,
profile=None,
addons=(),
cmdargs=(),
preferences=None,
adb_profile_dir=None):
profile = self._create_profile(profile=profile,
addons=addons,
preferences=preferences)
LOG.info("Launching %s" % self.binary)
self.runner = Runner(binary=self.binary,
cmdargs=cmdargs,
profile=profile)
def _on_exit():
# if we are stopping the process do not log anything.
if not self._stopping:
# mozprocess (behind mozrunner) fire 'onFinish'
# a bit early - let's ensure the process is finished.
# we have to call wait() directly on the subprocess
# instance of the ProcessHandler, else on windows
# None is returned...
# TODO: search that bug and fix that in mozprocess or
# mozrunner. (likely mozproces)
try:
exitcode = self.runner.process_handler.proc.wait()
except Exception:
print()
LOG.error(
"Error while waiting process, consider filing a bug.",
exc_info=True)
return
if exitcode != 0:
# first print a blank line, to be sure we don't
# write on an already printed line without EOL.
print()
LOG.warning('Process exited with code %s' % exitcode)
self.runner.process_args = {
'processOutputLine': [get_default_logger("process").info],
'onFinish': _on_exit,
}
self.runner.start()
def __init__(self, *args, **kwargs):
GaiaTestCase.__init__(self, *args, **kwargs)
self.store_reference_image = kwargs.pop('store_reference_image', False)
self.fuzz_factor = kwargs.pop('fuzz_factor')
self.reference_path = kwargs.pop('reference_path')
self.screenshots_path = kwargs.pop('screenshots_path')
self.logger = get_default_logger()
self.picture_index = 0
self.test_passed = True
self.failcomment = ""
# set up directories
if not os.path.exists(self.reference_path):
os.makedirs(self.reference_path)
if not os.path.exists(self.screenshots_path):
os.makedirs(self.screenshots_path)
def __init__(self, url, persist=None, persist_prefix=''):
self._running = False
self._logger = get_default_logger('Regression Runner')
basename = os.path.basename(url)
if persist:
dest = os.path.join(persist, '%s%s' % (persist_prefix, basename))
if not os.path.exists(dest):
self._download(url, dest)
else:
self._logger.info("Using local file: %s" % dest)
else:
dest = basename
self._download(url, dest)
try:
self._install(dest)
finally:
if not persist:
os.unlink(dest)
def check_for_crashes(self, dump_directory=None, dump_save_path=None,
test_name=None, quiet=False):
"""
Check for a possible crash and output stack trace.
:param dump_directory: Directory to search for minidump files
:param dump_save_path: Directory to save the minidump files to
:param test_name: Name to use in the crash output
:param quiet: If `True` don't print the PROCESS-CRASH message to stdout
:returns: True if a crash was detected, otherwise False
"""
if not dump_directory:
dump_directory = os.path.join(self.profile.profile, 'minidumps')
if not dump_save_path:
dump_save_path = self.dump_save_path
try:
logger = get_default_logger()
if logger is not None:
if test_name is None:
test_name = "runner.py"
self.crashed += mozcrash.log_crashes(
logger,
dump_directory,
self.symbols_path,
dump_save_path=dump_save_path,
test=test_name)
else:
crashed = mozcrash.check_for_crashes(
dump_directory,
self.symbols_path,
dump_save_path=dump_save_path,
test_name=test_name,
quiet=quiet)
if crashed:
self.crashed += 1
except:
traceback.print_exc()
return self.crashed
def __init__(self, addr, io_loop=None, verbose=False):
self._addr = addr
self.io_loop = io_loop or IOLoop.instance()
self.started = False
global logger
logger = get_default_logger()
self.routes = tornado.web.Application([
(r"/tests", TestHandler),
(r"/", web.RedirectHandler, {
"url": "/app.html"
}),
(r"/(.*[html|css|js])$", NoCacheStaticFileHandler, {
"path": static_dir
}),
(r"/img/(.*[jpg|jpeg|png|gif])$", NoCacheStaticFileHandler, {
"path": img_dir
})
])
self.server = tornado.httpserver.HTTPServer(self.routes,
io_loop=self.io_loop)
