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 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 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 __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, 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 __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): 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)