def run_sapphire(args):
logging.info('loading pre-trained model')
model = fasttext.FastText.load_model(args.model_path)
logging.info('loading completed')
aligner = Sapphire(model=model)
aligner.set_params(lambda_=args.lambda_,
delta=args.delta,
alpha=args.alpha,
hungarian=args.use_hungarian)
try:
while True:
print('\n' + '=' * 80)
sentence_src = input('Input tokenized sentence (A)\n>>> ')
sentence_trg = input('Input tokenized sentence (B)\n>>> ')
if sentence_src == '' or sentence_trg == '':
logging.warning('please input two sentences!')
continue
tokens_src = sentence_src.split()
tokens_trg = sentence_trg.split()
_, alignment = aligner(tokens_src, tokens_trg)
print('{:-^48}'.format(' Result '))
print('{0:^24}{1:^24}'.format('Sentence A', 'Sentence B'))
for src_s, src_e, trg_s, trg_e in alignment:
src_txt = ' '.join(tokens_src[src_s - 1:src_e])
trg_txt = ' '.join(tokens_trg[trg_s - 1:trg_e])
print('{0:>20}{1:^8}{2:<20}'.format(src_txt, '<-->', trg_txt))
except KeyboardInterrupt:
print()
logging.info('interrupted')
def main(cls, args):
configure_logging(args.log_level)
if args.fuzzmanager:
FuzzManagerReporter.sanity_check(args.binary)
# TODO: add fuzzmanager support
LOG.info("Starting Grizzly Replay")
if args.ignore:
LOG.info("Ignoring: %s", ", ".join(args.ignore))
if args.xvfb:
LOG.info("Running with Xvfb")
if args.rr:
LOG.info("Running with RR")
elif args.valgrind:
LOG.info("Running with Valgrind. This will be SLOW!")
if args.sig:
signature = CrashSignature.fromFile(args.sig)
else:
signature = None
try:
testcases = cls.load_testcases(args.input,
args.prefs is None,
subset=args.test_index)
except TestCaseLoadFailure as exc:
LOG.error("Error: %s", str(exc))
return Session.EXIT_ERROR
results = None
target = None
tmp_prefs = None
try:
if args.no_harness and len(testcases) > 1:
LOG.error(
"'--no-harness' cannot be used with multiple testcases. " \
"Perhaps '--test-index' can help.")
return Session.EXIT_ARGS
repeat = max(args.min_crashes, args.repeat)
relaunch = min(args.relaunch, repeat)
LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d", repeat,
args.min_crashes, relaunch)
LOG.debug("initializing the Target")
target = load_target(args.platform)(args.binary,
args.extension,
args.launch_timeout,
args.log_limit,
args.memory,
rr=args.rr,
valgrind=args.valgrind,
xvfb=args.xvfb)
# prioritize specified prefs.js file over included file
if args.prefs is not None:
for testcase in testcases:
testcase.add_meta(
TestFile.from_file(args.prefs, "prefs.js"))
LOG.info("Using specified prefs.js")
target.prefs = args.prefs
else:
for testcase in testcases:
prefs_tf = testcase.get_file("prefs.js")
if prefs_tf:
tmp_prefs = mkdtemp(prefix="prefs_",
dir=grz_tmp("replay"))
prefs_tf.dump(tmp_prefs)
LOG.info("Using prefs.js from testcase")
target.prefs = pathjoin(tmp_prefs, "prefs.js")
break
LOG.debug("starting sapphire server")
# launch HTTP server used to serve test cases
with Sapphire(auto_close=1, timeout=args.timeout) as server:
target.reverse(server.port, server.port)
with cls(args.ignore,
server,
target,
any_crash=args.any_crash,
relaunch=relaunch,
signature=signature,
use_harness=not args.no_harness) as replay:
results = replay.run(testcases,
idle_delay=args.idle_delay,
idle_threshold=args.idle_threshold,
min_results=args.min_crashes,
repeat=repeat)
# handle results
success = any(x.expected for x in results)
if success:
LOG.info("Result successfully reproduced")
else:
LOG.info("Failed to reproduce results")
if args.logs and results:
cls.report_to_filesystem(
args.logs, results,
testcases if args.include_test else None)
# TODO: add fuzzmanager reporting
return Session.EXIT_SUCCESS if success else Session.EXIT_FAILURE
except KeyboardInterrupt:
return Session.EXIT_ABORT
except (TargetLaunchError, TargetLaunchTimeout) as exc:
LOG.error(str(exc))
if isinstance(exc, TargetLaunchError) and exc.report:
path = grz_tmp("launch_failures")
LOG.error("Logs can be found here %r", path)
reporter = FilesystemReporter(path, major_bucket=False)
reporter.submit([], exc.report)
return Session.EXIT_LAUNCH_FAILURE
finally:
LOG.info("Shutting down...")
if results:
# cleanup unreported results
for result in results:
result.report.cleanup()
if target is not None:
target.cleanup()
for testcase in testcases:
testcase.cleanup()
if tmp_prefs is not None:
rmtree(tmp_prefs, ignore_errors=True)
LOG.info("Done.")
def main(cls, args):
"""CLI for `grizzly.reduce`.
Arguments:
args (argparse.Namespace): Result from `ReduceArgs.parse_args`.
Returns:
int: 0 for success. non-0 indicates a problem.
"""
# pylint: disable=too-many-return-statements
configure_logging(args.log_level)
setlocale(LC_ALL, "")
if args.fuzzmanager:
FuzzManagerReporter.sanity_check(args.binary)
LOG.info("Starting Grizzly Reduce")
if args.ignore:
LOG.info("Ignoring: %s", ", ".join(args.ignore))
if args.xvfb:
LOG.info("Running with Xvfb")
if args.pernosco:
LOG.info("Running with RR (Pernosco mode)")
elif args.rr:
LOG.info("Running with RR")
elif args.valgrind:
LOG.info("Running with Valgrind. This will be SLOW!")
assets = None
signature = None
signature_desc = None
target = None
testcases = []
try:
if args.sig:
signature = CrashSignature.fromFile(args.sig)
meta = Path(args.sig).with_suffix(".metadata")
if meta.is_file():
meta = json.loads(meta.read_text())
signature_desc = meta["shortDescription"]
try:
testcases, assets, env_vars = ReplayManager.load_testcases(
str(args.input), subset=args.test_index)
except TestCaseLoadFailure as exc:
LOG.error("Error: %s", str(exc))
return Exit.ERROR
if args.tool is None and testcases[0].adapter_name is not None:
LOG.warning(
"Setting default --tool=grizzly-%s from testcase",
testcases[0].adapter_name,
)
args.tool = "grizzly-%s" % (testcases[0].adapter_name, )
expect_hang = ReplayManager.expect_hang(args.ignore, signature,
testcases)
if args.no_harness:
if len(testcases) > 1:
LOG.error(
"Error: '--no-harness' cannot be used with multiple "
"testcases. Perhaps '--test-index' can help.")
return Exit.ARGS
LOG.debug("--no-harness specified relaunch set to 1")
args.relaunch = 1
# check test time limit and timeout
# TODO: add support for test time limit, use timeout in both cases for now
_, timeout = ReplayManager.time_limits(args.timeout, args.timeout,
testcases)
args.repeat = max(args.min_crashes, args.repeat)
relaunch = min(args.relaunch, args.repeat)
LOG.debug("initializing the Target")
target = load_plugin(args.platform, "grizzly_targets", Target)(
args.binary,
args.launch_timeout,
args.log_limit,
args.memory,
assets=assets,
pernosco=args.pernosco,
rr=args.rr,
valgrind=args.valgrind,
xvfb=args.xvfb,
)
# local environ takes priority over environ loaded from test case
if env_vars is not None:
env_vars.update(target.environ)
target.environ = env_vars
env_vars = None
# TODO: support overriding existing assets
# prioritize specified assets over included
target.assets.add_batch(args.asset)
target.process_assets()
LOG.debug("starting sapphire server")
# launch HTTP server used to serve test cases
with Sapphire(auto_close=1, timeout=timeout) as server:
target.reverse(server.port, server.port)
mgr = ReduceManager(
args.ignore,
server,
target,
testcases,
args.strategies,
args.logs,
any_crash=args.any_crash,
expect_hang=expect_hang,
idle_delay=args.idle_delay,
idle_threshold=args.idle_threshold,
reducer_crash_id=args.original_crash_id,
relaunch=relaunch,
report_period=args.report_period,
report_to_fuzzmanager=args.fuzzmanager,
signature=signature,
signature_desc=signature_desc,
static_timeout=args.static_timeout,
tool=args.tool,
use_analysis=not args.no_analysis,
use_harness=not args.no_harness,
)
return_code = mgr.run(repeat=args.repeat,
min_results=args.min_crashes)
return return_code
except ConfigError as exc:
LOG.error(str(exc))
return exc.exit_code
except KeyboardInterrupt as exc:
LOG.error("Exception: %r", exc)
return Exit.ABORT
except (TargetLaunchError, TargetLaunchTimeout) as exc:
LOG.error("Exception: %s", exc)
if isinstance(exc, TargetLaunchError) and exc.report:
path = grz_tmp("launch_failures")
LOG.error("Logs can be found here %r", path)
reporter = FilesystemReporter(path, major_bucket=False)
reporter.submit([], exc.report)
return Exit.LAUNCH_FAILURE
except GrizzlyReduceBaseException as exc:
LOG.error(exc.msg)
return exc.code
except Exception: # pylint: disable=broad-except
LOG.exception("Exception during reduction!")
return Exit.ERROR
finally:
LOG.info("Shutting down...")
if target is not None:
target.cleanup()
for testcase in testcases:
testcase.cleanup()
if assets:
assets.cleanup()
LOG.info("Done.")
def main(args):
configure_logging(args.log_level)
LOG.info("Starting Grizzly (%d)", getpid())
if args.fuzzmanager:
FuzzManagerReporter.sanity_check(args.binary)
elif args.s3_fuzzmanager:
S3FuzzManagerReporter.sanity_check(args.binary)
if args.ignore:
LOG.info("Ignoring: %s", ", ".join(args.ignore))
if args.xvfb:
LOG.info("Running with Xvfb")
if args.pernosco:
LOG.info("Running with RR (Pernosco mode)")
elif args.rr:
LOG.info("Running with RR")
elif args.valgrind:
LOG.info("Running with Valgrind. This will be SLOW!")
adapter = None
session = None
target = None
try:
LOG.debug("initializing Adapter %r", args.adapter)
adapter = load_plugin(args.adapter, "grizzly_adapters",
Adapter)(args.adapter)
# test case time limit and timeout sanity checking
if args.time_limit:
time_limit = args.time_limit
else:
assert adapter.TIME_LIMIT >= 1
time_limit = adapter.TIME_LIMIT
if args.timeout:
timeout = args.timeout
else:
timeout = time_limit + TIMEOUT_DELAY
LOG.info("Using test time limit: %ds, timeout: %ds", time_limit,
timeout)
if timeout < time_limit:
LOG.error(
"Timeout must be at least test time limit if not greater")
return Exit.ARGS
if adapter.HARNESS_FILE and time_limit == timeout:
LOG.warning("To avoid relaunches due to tests failing to close"
" themselves use a timeout greater than time limit")
if adapter.RELAUNCH > 0:
LOG.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
relaunch = adapter.RELAUNCH
else:
relaunch = args.relaunch
LOG.debug("initializing the Target %r", args.platform)
target = load_plugin(args.platform, "grizzly_targets", Target)(
args.binary,
args.launch_timeout,
args.log_limit,
args.memory,
pernosco=args.pernosco,
rr=args.rr,
valgrind=args.valgrind,
xvfb=args.xvfb,
)
# add specified assets
target.assets.add_batch(args.asset)
target.process_assets()
adapter.monitor = target.monitor
LOG.debug("initializing the Reporter")
if args.fuzzmanager:
LOG.info("Results will be reported via FuzzManager")
reporter = FuzzManagerReporter(tool=args.tool)
elif args.s3_fuzzmanager:
LOG.info(
"Results will be reported via FuzzManager w/ large attachments in S3"
)
reporter = S3FuzzManagerReporter(tool=args.tool)
else:
reporter = FilesystemReporter(args.logs / "results")
LOG.info("Results will be stored in %r", str(reporter.report_path))
reporter.display_logs = args.smoke_test or reporter.display_logs
# make sure an iteration limit is set if smoke_test is True
iteration_limit = (args.limit or 10) if args.smoke_test else args.limit
if iteration_limit:
LOG.info("%r iteration(s) will be attempted", iteration_limit)
if args.runtime:
LOG.info("Runtime is limited to %rs", args.runtime)
# set 'auto_close=1' so the client error pages (code 4XX) will
# call 'window.close()' after a second.
# launch http server used to serve test cases
LOG.debug("starting Sapphire server")
with Sapphire(auto_close=1, timeout=timeout) as server:
target.reverse(server.port, server.port)
LOG.debug("initializing the Session")
session = Session(
adapter,
reporter,
server,
target,
coverage=args.coverage,
enable_profiling=args.enable_profiling,
relaunch=relaunch,
report_limit=args.limit_reports,
report_size=args.collect,
)
if args.log_level == DEBUG or args.verbose:
display_mode = Session.DISPLAY_VERBOSE
else:
display_mode = Session.DISPLAY_NORMAL
session.run(
args.ignore,
time_limit,
input_path=str(args.input),
iteration_limit=iteration_limit,
result_limit=1 if args.smoke_test else 0,
runtime_limit=args.runtime,
display_mode=display_mode,
)
except KeyboardInterrupt:
LOG.info("Ctrl+C detected.")
return Exit.ABORT
except (TargetLaunchError, TargetLaunchTimeout) as exc:
LOG.error(str(exc))
return Exit.LAUNCH_FAILURE
finally:
LOG.info("Shutting down...")
if session is not None:
LOG.debug("calling session.close()")
session.close()
if target is not None:
LOG.debug("calling target.cleanup()")
target.cleanup()
if adapter is not None:
LOG.debug("calling adapter.cleanup()")
adapter.cleanup()
LOG.info("Done.")
if session and session.status.results.total > 0:
return Exit.ERROR
return Exit.SUCCESS
def main(cls, args):
configure_logging(args.log_level)
if args.fuzzmanager:
FuzzManagerReporter.sanity_check(args.binary)
# TODO: add fuzzmanager support
LOG.info("Starting Grizzly Replay")
if args.ignore:
LOG.info("Ignoring: %s", ", ".join(args.ignore))
if args.xvfb:
LOG.info("Running with Xvfb")
if args.pernosco:
LOG.info("Running with RR (Pernosco mode)")
elif args.rr:
LOG.info("Running with RR")
elif args.valgrind:
LOG.info("Running with Valgrind. This will be SLOW!")
if args.sig:
signature = CrashSignature.fromFile(args.sig)
else:
signature = None
try:
testcases, assets, env_vars = cls.load_testcases(
str(args.input), subset=args.test_index
)
except TestCaseLoadFailure as exc:
LOG.error("Error: %s", str(exc))
return Exit.ERROR
results = None
target = None
try:
if args.no_harness and len(testcases) > 1:
LOG.error(
"'--no-harness' cannot be used with multiple testcases. "
"Perhaps '--test-index' can help."
)
return Exit.ARGS
# check if hangs are expected
expect_hang = cls.expect_hang(args.ignore, signature, testcases)
# check test time limit and timeout
time_limit, timeout = cls.time_limits(
args.time_limit, args.timeout, testcases
)
LOG.info("Using time limit: %ds, timeout: %ds", time_limit, timeout)
repeat = max(args.min_crashes, args.repeat)
if args.no_harness:
LOG.debug("no-harness enabled, forcing relaunch=1")
relaunch = 1
else:
relaunch = min(args.relaunch, repeat)
LOG.info(
"Repeat: %d, Minimum crashes: %d, Relaunch %d",
repeat,
args.min_crashes,
relaunch,
)
LOG.debug("initializing the Target")
target = load_plugin(args.platform, "grizzly_targets", Target)(
args.binary,
args.launch_timeout,
args.log_limit,
args.memory,
assets=assets,
pernosco=args.pernosco,
rr=args.rr,
valgrind=args.valgrind,
xvfb=args.xvfb,
)
# local environ takes priority over environ loaded from test case
if env_vars is not None:
env_vars.update(target.environ)
target.environ = env_vars
env_vars = None
# TODO: support overriding existing assets
# prioritize specified assets over included
target.assets.add_batch(args.asset)
target.process_assets()
LOG.debug("starting sapphire server")
# launch HTTP server used to serve test cases
with Sapphire(auto_close=1, timeout=timeout) as server:
target.reverse(server.port, server.port)
with cls(
args.ignore,
server,
target,
any_crash=args.any_crash,
relaunch=relaunch,
signature=signature,
use_harness=not args.no_harness,
) as replay:
results = replay.run(
testcases,
time_limit,
expect_hang=expect_hang,
idle_delay=args.idle_delay,
idle_threshold=args.idle_threshold,
min_results=args.min_crashes,
repeat=repeat,
)
# handle results
success = any(x.expected for x in results)
if success:
LOG.info("Result successfully reproduced")
else:
LOG.info("Failed to reproduce results")
if args.logs and results:
# add target assets to test cases
if not target.assets.is_empty():
for test in testcases:
test.assets = target.assets
# add target environment variables
if target.filtered_environ():
for test in testcases:
test.env_vars = target.filtered_environ()
cls.report_to_filesystem(
args.logs, results, testcases if args.include_test else None
)
# TODO: add fuzzmanager reporting
return Exit.SUCCESS if success else Exit.FAILURE
except ConfigError as exc:
LOG.error(str(exc))
return exc.exit_code
except KeyboardInterrupt:
return Exit.ABORT
except (TargetLaunchError, TargetLaunchTimeout) as exc:
LOG.error(str(exc))
if isinstance(exc, TargetLaunchError) and exc.report:
path = grz_tmp("launch_failures")
LOG.error("Logs can be found here %r", path)
reporter = FilesystemReporter(path, major_bucket=False)
reporter.submit([], exc.report)
return Exit.LAUNCH_FAILURE
finally:
LOG.info("Shutting down...")
if results:
# cleanup unreported results
for result in results:
result.report.cleanup()
if target is not None:
target.cleanup()
for testcase in testcases:
testcase.cleanup()
if assets:
assets.cleanup()
LOG.info("Done.")
def main(cls, args):
configure_logging(args.log_level)
if args.fuzzmanager:
FuzzManagerReporter.sanity_check(args.binary)
LOG.info("Starting Grizzly Replay")
if args.ignore:
LOG.info("Ignoring: %s", ", ".join(args.ignore))
if args.xvfb:
LOG.info("Running with Xvfb")
if args.valgrind:
LOG.info("Running with Valgrind. This will be SLOW!")
if args.rr:
LOG.info("Running with RR")
if args.sig:
signature = CrashSignature.fromFile(args.sig)
else:
signature = None
try:
LOG.debug("loading the TestCase")
testcase = TestCase.load_path(args.input)
if isfile(args.input):
testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
except TestCaseLoadFailure as exc:
LOG.error("Error: %s", str(exc))
return 1
replay = None
target = None
try:
relaunch = min(args.relaunch, args.repeat)
LOG.debug("initializing the Target")
target = load_target(args.platform)(args.binary,
args.extension,
args.launch_timeout,
args.log_limit,
args.memory,
args.prefs,
relaunch,
rr=args.rr,
valgrind=args.valgrind,
xvfb=args.xvfb)
if testcase.env_vars.get("GRZ_FORCED_CLOSE") == "0":
LOG.debug("setting target.forced_close=False")
target.forced_close = False
LOG.debug("starting sapphire server")
# launch HTTP server used to serve test cases
with Sapphire(auto_close=1, timeout=args.timeout) as server:
target.reverse(server.port, server.port)
if args.no_harness:
LOG.debug("--no-harness specified relaunch set to 1")
args.relaunch = 1
args.repeat = max(args.min_crashes, args.repeat)
LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
args.repeat, args.min_crashes, relaunch)
replay = ReplayManager(args.ignore,
server,
target,
testcase,
any_crash=args.any_crash,
signature=signature,
use_harness=not args.no_harness)
success = replay.run(repeat=args.repeat,
min_results=args.min_crashes)
if args.logs:
replay.report_to_filesystem(
args.logs, replay.reports, replay.other_reports,
replay.testcase if args.include_test else None)
# TODO: add fuzzmanager reporting
return 0 if success else 1
except KeyboardInterrupt:
return 1
except (TargetLaunchError, TargetLaunchTimeout):
if args.logs:
replay.report_to_filesystem(args.logs, replay.reports,
replay.other_reports)
return 1
finally:
LOG.warning("Shutting down...")
if replay is not None:
replay.cleanup()
if target is not None:
target.cleanup()
if testcase is not None:
testcase.cleanup()
LOG.info("Done.")
def main(args):
configure_logging(args.log_level)
LOG.info("Starting Grizzly (%d)", getpid())
if args.fuzzmanager:
FuzzManagerReporter.sanity_check(args.binary)
elif args.s3_fuzzmanager:
S3FuzzManagerReporter.sanity_check(args.binary)
if args.ignore:
LOG.info("Ignoring: %s", ", ".join(args.ignore))
if args.xvfb:
LOG.info("Running with Xvfb")
if args.rr:
LOG.info("Running with RR")
elif args.valgrind:
LOG.info("Running with Valgrind. This will be SLOW!")
adapter = None
iomanager = None
session = None
target = None
try:
LOG.debug("initializing the IOManager")
# TODO: move this into Session
iomanager = IOManager(report_size=(max(args.cache, 0) + 1))
LOG.debug("initializing Adapter %r", args.adapter)
adapter = get_adapter(args.adapter)()
if args.timeout <= adapter.TEST_DURATION:
LOG.info("Using minimum adapter timeout: %ds",
adapter.TEST_DURATION)
if adapter.HARNESS_FILE:
LOG.info(
"To avoid Target relaunches due to tests failing to close"
" themselves use a timeout > 'adapter.TEST_DURATION'")
timeout = adapter.TEST_DURATION
else:
timeout = args.timeout
if adapter.RELAUNCH > 0:
LOG.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
relaunch = adapter.RELAUNCH
else:
relaunch = args.relaunch
LOG.debug("initializing the Target")
target = load_target(args.platform)(args.binary,
args.extension,
args.launch_timeout,
args.log_limit,
args.memory,
rr=args.rr,
valgrind=args.valgrind,
xvfb=args.xvfb)
if args.prefs:
target.prefs = args.prefs
LOG.info("Using prefs %r", args.prefs)
adapter.monitor = target.monitor
LOG.debug("calling adapter setup()")
adapter.setup(args.input, iomanager.server_map)
LOG.debug("configuring harness")
iomanager.harness = adapter.get_harness()
LOG.debug("initializing the Reporter")
if args.fuzzmanager:
LOG.info("Results will be reported via FuzzManager")
reporter = FuzzManagerReporter(tool=args.tool)
elif args.s3_fuzzmanager:
LOG.info(
"Results will be reported via FuzzManager w/ large attachments in S3"
)
reporter = S3FuzzManagerReporter(tool=args.tool)
else:
reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
LOG.info("Results will be stored in %r", reporter.report_path)
if args.limit > 0:
LOG.info("%r iteration(s) will be attempted", args.limit)
# set 'auto_close=1' so the client error pages (code 4XX) will
# call 'window.close()' after a second.
# launch http server used to serve test cases
LOG.debug("starting Sapphire server")
with Sapphire(auto_close=1, timeout=timeout) as server:
target.reverse(server.port, server.port)
LOG.debug("initializing the Session")
session = Session(adapter,
iomanager,
reporter,
server,
target,
coverage=args.coverage,
enable_profiling=args.enable_profiling,
relaunch=relaunch)
if args.log_level == DEBUG or args.verbose:
display_mode = Session.DISPLAY_VERBOSE
else:
display_mode = Session.DISPLAY_NORMAL
session.run(args.ignore,
iteration_limit=args.limit,
display_mode=display_mode)
except KeyboardInterrupt:
LOG.info("Ctrl+C detected.")
return Session.EXIT_ABORT
except (TargetLaunchError, TargetLaunchTimeout) as exc:
LOG.error(str(exc))
return Session.EXIT_LAUNCH_FAILURE
finally:
LOG.info("Shutting down...")
if session is not None:
LOG.debug("calling session.close()")
session.close()
if target is not None:
LOG.debug("calling target.cleanup()")
target.cleanup()
if adapter is not None:
LOG.debug("calling adapter.cleanup()")
adapter.cleanup()
if iomanager is not None:
LOG.debug("calling iomanager.cleanup()")
iomanager.cleanup()
LOG.info("Done.")
return Session.EXIT_SUCCESS
def main(cls, args):
"""CLI for `grizzly.reduce`.
Arguments:
args (argparse.Namespace): Result from `ReduceArgs.parse_args`.
Returns:
int: 0 for success. non-0 indicates a problem.
"""
configure_logging(args.log_level)
setlocale(LC_ALL, "")
if args.fuzzmanager:
FuzzManagerReporter.sanity_check(args.binary)
LOG.info("Starting Grizzly Reduce")
if args.ignore:
LOG.info("Ignoring: %s", ", ".join(args.ignore))
if args.xvfb:
LOG.info("Running with Xvfb")
if args.valgrind:
LOG.info("Running with Valgrind. This will be SLOW!")
if args.rr:
LOG.info("Running with RR")
signature = None
signature_desc = None
target = None
testcases = []
tmp_prefs = None
try:
if args.sig:
signature = CrashSignature.fromFile(args.sig)
meta = Path(args.sig).with_suffix(".metadata")
if meta.is_file():
meta = json.loads(meta.read_text())
signature_desc = meta["shortDescription"]
try:
testcases = ReplayManager.load_testcases(
args.input, args.prefs is None, subset=args.test_index)
except TestCaseLoadFailure as exc:
LOG.error("Error: %s", str(exc))
return Session.EXIT_ERROR
if args.tool is None and testcases[0].adapter_name is not None:
LOG.warning("Setting default --tool=grizzly-%s from testcase",
testcases[0].adapter_name)
args.tool = "grizzly-%s" % (testcases[0].adapter_name, )
if args.no_harness:
if len(testcases) > 1:
LOG.error(
"Error: '--no-harness' cannot be used with multiple " \
"testcases. Perhaps '--test-index' can help.")
return Session.EXIT_ARGS
LOG.debug("--no-harness specified relaunch set to 1")
args.relaunch = 1
args.repeat = max(args.min_crashes, args.repeat)
relaunch = min(args.relaunch, args.repeat)
LOG.debug("initializing the Target")
target = load_target(args.platform)(args.binary,
args.extension,
args.launch_timeout,
args.log_limit,
args.memory,
relaunch,
rr=args.rr,
valgrind=args.valgrind,
xvfb=args.xvfb)
# prioritize specified prefs.js file over included file
if args.prefs is not None:
for testcase in testcases:
testcase.add_meta(
TestFile.from_file(args.prefs, "prefs.js"))
LOG.info("Using specified prefs.js")
target.prefs = args.prefs
else:
for testcase in testcases:
prefs_tf = testcase.get_file("prefs.js")
if prefs_tf:
tmp_prefs = Path(
mkdtemp(prefix="prefs_", dir=grz_tmp("replay")))
prefs_tf.dump(str(tmp_prefs))
LOG.info("Using prefs.js from testcase")
target.prefs = str(tmp_prefs / "prefs.js")
break
if testcases[0].env_vars.get("GRZ_FORCED_CLOSE") == "0":
LOG.debug("setting target.forced_close=False")
target.forced_close = False
LOG.debug("starting sapphire server")
# launch HTTP server used to serve test cases
with Sapphire(auto_close=1, timeout=args.timeout) as server:
target.reverse(server.port, server.port)
mgr = ReduceManager(args.ignore,
server,
target,
testcases,
args.strategies,
args.logs,
any_crash=args.any_crash,
idle_delay=args.idle_delay,
idle_threshold=args.idle_threshold,
report_period=args.report_period,
report_to_fuzzmanager=args.fuzzmanager,
signature=signature,
signature_desc=signature_desc,
static_timeout=args.static_timeout,
tool=args.tool,
use_analysis=not args.no_analysis,
use_harness=not args.no_harness)
return_code = mgr.run(repeat=args.repeat,
min_results=args.min_crashes)
return return_code
except KeyboardInterrupt as exc:
LOG.error("Exception: %r", exc)
return Session.EXIT_ABORT
except (TargetLaunchError, TargetLaunchTimeout) as exc:
LOG.error("Exception: %s", exc)
if isinstance(exc, TargetLaunchError) and exc.report:
path = grz_tmp("launch_failures")
LOG.error("Logs can be found here %r", path)
reporter = FilesystemReporter(path, major_bucket=False)
reporter.submit([], exc.report)
return Session.EXIT_LAUNCH_FAILURE
except GrizzlyReduceBaseException as exc:
LOG.error(exc.msg)
return exc.code
except Exception: # noqa pylint: disable=broad-except
LOG.exception("Exception during reduction!")
return Session.EXIT_ERROR
finally:
LOG.info("Shutting down...")
if target is not None:
target.cleanup()
for testcase in testcases:
testcase.cleanup()
if tmp_prefs is not None:
rmtree(str(tmp_prefs), ignore_errors=True)
LOG.info("Done.")
def main(args):
configure_logging(args.log_level)
log.info("Starting Grizzly")
if args.fuzzmanager:
FuzzManagerReporter.sanity_check(args.binary)
elif args.s3_fuzzmanager:
S3FuzzManagerReporter.sanity_check(args.binary)
if args.ignore:
log.info("Ignoring: %s", ", ".join(args.ignore))
if args.xvfb:
log.info("Running with Xvfb")
if args.rr:
log.info("Running with RR")
elif args.valgrind:
log.info("Running with Valgrind. This will be SLOW!")
adapter = None
iomanager = None
session = None
target = None
try:
log.debug("initializing the IOManager")
# TODO: move this into Session
iomanager = IOManager(report_size=(max(args.cache, 0) + 1))
log.debug("initializing Adapter %r", args.adapter)
adapter = get_adapter(args.adapter)()
if adapter.TEST_DURATION >= args.timeout:
raise RuntimeError(
"Test duration (%ds) should be less than browser timeout (%ds)"
% (adapter.TEST_DURATION, args.timeout))
if adapter.RELAUNCH > 0:
log.debug("relaunch (%d) set in Adapter", adapter.RELAUNCH)
relaunch = adapter.RELAUNCH
else:
relaunch = args.relaunch
log.debug("initializing the Target")
target = load_target(args.platform)(args.binary,
args.extension,
args.launch_timeout,
args.log_limit,
args.memory,
relaunch,
rr=args.rr,
valgrind=args.valgrind,
xvfb=args.xvfb)
if args.prefs:
target.prefs = args.prefs
log.info("Using prefs %r", args.prefs)
adapter.monitor = target.monitor
if args.coverage and relaunch == 1 and target.forced_close:
# this is a workaround to avoid not dumping coverage
# GRZ_FORCED_CLOSE=0 is also an option but the browser MUST
# close itself.
raise RuntimeError("Coverage must be run with --relaunch > 1")
log.debug("calling adapter setup()")
adapter.setup(args.input, iomanager.server_map)
log.debug("configuring harness")
iomanager.harness = adapter.get_harness()
log.debug("initializing the Reporter")
if args.fuzzmanager:
log.info("Results will be reported via FuzzManager")
reporter = FuzzManagerReporter(tool=args.tool)
elif args.s3_fuzzmanager:
log.info(
"Results will be reported via FuzzManager w/ large attachments in S3"
)
reporter = S3FuzzManagerReporter(tool=args.tool)
else:
reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
log.info("Results will be stored in %r", reporter.report_path)
# set 'auto_close=1' so the client error pages (code 4XX) will
# call 'window.close()' after a second.
# launch http server used to serve test cases
log.debug("starting Sapphire server")
with Sapphire(auto_close=1, timeout=args.timeout) as server:
target.reverse(server.port, server.port)
log.debug("initializing the Session")
session = Session(adapter,
iomanager,
reporter,
server,
target,
coverage=args.coverage)
if args.log_level == DEBUG or args.verbose:
display_mode = Session.DISPLAY_VERBOSE
else:
display_mode = Session.DISPLAY_NORMAL
session.run(args.ignore, display_mode=display_mode)
except KeyboardInterrupt:
log.info("Ctrl+C detected.")
return Session.EXIT_ABORT
except (TargetLaunchError, TargetLaunchTimeout) as exc:
log.error(str(exc))
if isinstance(exc, TargetLaunchError) and exc.report:
path = grz_tmp("launch_failures")
log.error("Logs can be found here %r", path)
reporter = FilesystemReporter(path, major_bucket=False)
reporter.submit([], exc.report)
return Session.EXIT_LAUNCH_FAILURE
finally:
log.warning("Shutting down...")
if session is not None:
log.debug("calling session.close()")
session.close()
if target is not None:
log.debug("calling target.cleanup()")
target.cleanup()
if adapter is not None:
log.debug("calling adapter.cleanup()")
adapter.cleanup()
if iomanager is not None:
log.debug("calling iomanager.cleanup()")
iomanager.cleanup()
log.info("Done.")
return Session.EXIT_SUCCESS