async def build_profile(self, device, headless):
scenario = self.scenario
profile = self.env.profile
customization_data = self.customization_data
scenario_func = scenarii[scenario]
if scenario in customization_data.get("scenario", {}):
options = customization_data["scenario"][scenario]
LOG("Loaded options for that scenario %s" % str(options))
else:
options = {}
# Adding general options
options["platform"] = self.env.target_platform
if not self.force_new:
try:
custom_name = customization_data["name"]
get_profile(profile, self.env.target_platform, scenario, custom_name)
except ProfileNotFoundError:
# XXX we'll use a fresh profile for now
fresh_profile(profile, customization_data)
else:
fresh_profile(profile, customization_data)
LOG("Updating profile located at %r" % profile)
metadata = Metadata(profile)
LOG("Starting the Gecko app...")
self.env.prepare(logfile=self._log_filename("adb"))
geckodriver_logs = self._log_filename("geckodriver")
LOG("Writing geckodriver logs in %s" % geckodriver_logs)
try:
firefox_instance = Firefox(**self.env.get_browser_args(headless))
with open(geckodriver_logs, "w") as glog:
async with get_session(
self.env.get_geckodriver(log_file=glog), firefox_instance
) as session:
self.env.check_session(session)
LOG("Running the %s scenario" % scenario)
metadata.update(await scenario_func(session, options))
LOG("%s scenario done." % scenario)
except Exception:
ERROR("%s scenario broke!" % scenario)
self.env.stop_browser()
self.env.collect_profile()
# writing metadata
metadata.write(
name=self.scenario,
customization=self.customization_data["name"],
version=self.env.get_browser_version(),
platform=self.env.target_platform,
)
LOG("Profile at %s" % profile)
LOG("Done.")
return metadata
def main(args=sys.argv[1:]):
parser = argparse.ArgumentParser(description="Profile Creator")
parser.add_argument("profile", help="Profile Dir", type=str)
parser.add_argument("archive", help="Archives Dir", type=str, default=None)
parser.add_argument("--max-urls",
help="How many URLS to visit",
type=int,
default=115)
parser.add_argument("--firefox",
help="Firefox Binary",
type=str,
default=None)
parser.add_argument("--scenarii",
help="Scenarii to use",
type=str,
default="all")
parser.add_argument(
"--archives-server",
help="Archives server",
type=str,
default="http://condprof.dev.mozaws.net",
)
parser.add_argument(
"--fresh-profile",
help="Create a fresh profile",
action="store_true",
default=False,
)
parser.add_argument("--archives-dir",
help="Archives local dir",
type=str,
default="/tmp/archives")
parser.add_argument("--force-new",
help="Create from scratch",
action="store_true",
default=False)
args = parser.parse_args(args=args)
if not os.path.exists(args.profile):
fresh_profile(args.profile)
loop = asyncio.get_event_loop()
async def run_all(args):
if args.scenarii != "all":
return await run(args)
res = []
for name in scenario.keys():
args.scenarii = name
res.append(await run(args))
return res
try:
loop.run_until_complete(run_all(args))
finally:
loop.close()
raise Exception("Allow retriggers with this exception")
def setUp(self):
self.profile_dir = fresh_profile()
self.archives_dir = os.path.join(tempfile.mkdtemp())
self.args = args = namedtuple(
"args", ["scenarii", "profile", "firefox", "max_urls"])
args.scenarii = "heavy"
args.profile = self.profile_dir
args.firefox = None
args.max_urls = 2
args.profile_dir = self.profile_dir
args.archives_server = None
args.force_new = True
args.archives_dir = self.archives_dir
self.archiver = Archiver(args.profile_dir, args.archives_dir)
async def build_profile(self, device, headless):
scenario = self.scenario
profile = self.env.profile
customization_data = self.customization_data
scenario_func = scenarii[scenario]
if scenario in customization_data.get("scenario", {}):
options = customization_data["scenario"][scenario]
logger.info("Loaded options for that scenario %s" % str(options))
else:
options = {}
# Adding general options
options["platform"] = self.env.target_platform
if not self.force_new:
try:
custom_name = customization_data["name"]
get_profile(profile, self.env.target_platform, scenario,
custom_name)
except ProfileNotFoundError:
# XXX we'll use a fresh profile for now
fresh_profile(profile, customization_data)
else:
fresh_profile(profile, customization_data)
logger.info("Updating profile located at %r" % profile)
metadata = Metadata(profile)
logger.info("Starting the Gecko app...")
adb_logs = self._log_filename("adb")
self.env.prepare(logfile=adb_logs)
geckodriver_logs = self._log_filename("geckodriver")
logger.info("Writing geckodriver logs in %s" % geckodriver_logs)
step = START
try:
firefox_instance = Firefox(**self.env.get_browser_args(headless))
step = INIT_GECKODRIVER
with open(geckodriver_logs, "w") as glog:
geckodriver = self.env.get_geckodriver(log_file=glog)
step = START_SESSION
async with get_session(geckodriver,
firefox_instance) as session:
step = START_SCENARIO
self.env.check_session(session)
logger.info("Running the %s scenario" % scenario)
metadata.update(await scenario_func(session, options))
logger.info("%s scenario done." % scenario)
await close_extra_windows(session)
except Exception:
logger.error("%s scenario broke!" % scenario)
if step == START:
logger.info("Could not initialize the browser")
elif step == INIT_GECKODRIVER:
logger.info("Could not initialize Geckodriver")
elif step == START_SESSION:
logger.info("Could not start the session, check %s first" %
geckodriver_logs)
else:
logger.info(
"Could not run the scenario, probably a faulty scenario")
raise
finally:
self.env.stop_browser()
for logfile in (adb_logs, geckodriver_logs):
if os.path.exists(logfile):
obfuscate_file(logfile)
self.env.collect_profile()
# writing metadata
metadata.write(
name=self.scenario,
customization=self.customization_data["name"],
version=self.env.get_browser_version(),
platform=self.env.target_platform,
)
logger.info("Profile at %s.\nDone." % profile)
return metadata