def build_fuzzer_sub_task(task_index: int, params: FuzzerGenTaskParams) -> Task: """ Build a shrub task to run the fuzzer. :param task_index: Index of sub task being generated. :param params: Parameters describing how tasks should be generated. :return: Shrub task to run the fuzzer. """ sub_task_name = taskname.name_generated_task(params.task_name, task_index, params.num_tasks, params.variant) run_tests_vars = { "continue_on_failure": params.continue_on_failure, "resmoke_args": params.get_resmoke_args(), "resmoke_jobs_max": params.resmoke_jobs_max, "should_shuffle": params.should_shuffle, "require_multiversion_setup": params.require_multiversion_setup, "timeout_secs": params.timeout_secs, "task": params.task_name, "gen_task_config_location": params.config_location, "suite": params.suite, } # yapf: disable timeout_info = TimeoutInfo.overridden(timeout=params.timeout_secs) commands = [ timeout_info.cmd, FunctionCall("do setup"), FunctionCall(CONFIGURE_EVG_CREDENTIALS), FunctionCall("setup jstestfuzz"), FunctionCall("run jstestfuzz", params.jstestfuzz_params()), FunctionCall(RUN_GENERATED_TESTS, run_tests_vars) ] return Task(sub_task_name, commands, {TaskDependency(ARCHIVE_DIST_TEST_DEBUG_TASK)})
def _generate_task(self, sub_task_name: str, sub_suite_name: str, mixed_version_config: str, params: MultiversionGenTaskParams, build_variant: str) -> Task: """ Generate a sub task to be run with the provided suite and mixed version config. :param sub_task_name: Name of task being generated. :param sub_suite_name: Name of suite to run. :param mixed_version_config: Versions task is being generated for. :param params: Parameters for how tasks should be generated. :return: Shrub configuration for task specified. """ suite_file = self.gen_task_options.suite_location(f"{sub_suite_name}_{build_variant}.yml") run_tests_vars = { "resmoke_args": self._build_resmoke_args(suite_file, mixed_version_config, params), "task": params.parent_task_name, "gen_task_config_location": params.config_location, } commands = [ FunctionCall("do setup"), # Fetch and download the proper mongod binaries before running multiversion tests. FunctionCall("configure evergreen api credentials"), FunctionCall("do multiversion setup"), FunctionCall("run generated tests", run_tests_vars), ] return Task(sub_task_name, commands, {TaskDependency("archive_dist_test_debug")})
def resmoke_commands( run_tests_fn_name: str, run_tests_vars: Dict[str, Any], timeout_info: TimeoutInfo, require_multiversion: Optional[bool] = None) -> List[ShrubCommand]: """ Create a list of commands to run a resmoke task. :param run_tests_fn_name: Name of function to run resmoke tests. :param run_tests_vars: Dictionary of variables to pass to run_tests function. :param timeout_info: Timeout info for task. :param require_multiversion: Requires downloading Multiversion binaries. :return: List of commands to run a resmoke task. """ commands = [ timeout_info.cmd, FunctionCall("do setup"), FunctionCall("configure evergreen api credentials") if require_multiversion else None, FunctionCall("do multiversion setup") if require_multiversion else None, FunctionCall(run_tests_fn_name, run_tests_vars), ] return [cmd for cmd in commands if cmd]
def gen_lint_config(): targets = ["src", "test"] max_hosts = 5 task_group_name = "lint group" variant_name = "lint variant" def define_task(target): name = f"make-lint-{target}" return Task(name, [FunctionCall("run-make", {"target": name})]) task_group = TaskGroup( task_group_name, [define_task(target) for target in targets], max_hosts=max_hosts, setup_group=[ git_get_project("src").set_type(CommandType.SYSTEM), FunctionCall("set-up-credentials"), ], teardown_group=[ FunctionCall("attach-test-results"), FunctionCall("remove-test-results"), ], ) variant = BuildVariant(variant_name).add_task_group(task_group) project = ShrubProject({variant}) return project
def main(expansions_file: str = "expansions.yml", output_file: str = "powercycle_tasks.json") -> None: """Generate multiple powercycle tasks to run in evergreen.""" config = make_config(expansions_file) build_variant = BuildVariant(config.build_variant) for task_name in config.task_names: if "skip_compile" in task_name: commands, task_dependency = get_skip_compile_setup_commands() else: commands, task_dependency = get_setup_commands() commands.extend([ FunctionCall("set up remote credentials", config.remote_credentials_vars), BuiltInCommand("timeout.update", config.timeout_params), FunctionCall("set up EC2 instance", config.set_up_ec2_instance_vars), FunctionCall("run powercycle test", config.run_powercycle_vars), ]) build_variant.display_task( task_name, { Task( name_generated_task(task_name, index, config.num_tasks, config.build_variant), commands, task_dependency) for index in range(config.num_tasks) }, distros=[config.distro]) shrub_project = ShrubProject.empty() shrub_project.add_build_variant(build_variant) write_file(output_file, shrub_project.json())
def define_task(index): name = f"aggregation_multiversion_fuzzer_{index:03d}" return Task( name, [ FunctionCall("do setup"), FunctionCall("do multiversion setup"), FunctionCall( "run jstestfuzz", { "jstestfuzz_var": "--numGeneratedFiles 5", "npm_command": "agg-fuzzer" }, ), FunctionCall( "run tests", { "continue_on_failure": "false", "resmoke_args": "--suites=generational_fuzzer", "should_shuffle": "false", "task_path_suffix": "false", "timeout_secs": "1800", }, ), ], ).dependency("compile")
def _generate_task(self, sub_suite_file, sub_task_name: str, sub_suite_roots: List[str], timeout_est: TimeoutEstimate, params: ResmokeGenTaskParams, suite: GeneratedSuite, excludes: List[str]) -> ResmokeTask: """ Generate a shrub evergreen config for a resmoke task. :param sub_suite_file: Name of the suite file to run in the generated task. :param sub_task_name: Name of task to generate. :param sub_suite_roots: List of files to run. :param timeout_est: Estimated runtime to use for calculating timeouts. :param params: Parameters describing how tasks should be generated. :param suite: Parent suite being created. :param excludes: List of tests to exclude. :return: ResmokeTask object describing the task. """ # pylint: disable=too-many-arguments LOGGER.debug("Generating task running suite", sub_task_name=sub_task_name, sub_suite_file=sub_suite_file) sub_suite_file_path = self.gen_task_options.suite_location( sub_suite_file) run_tests_vars = self._get_run_tests_vars( sub_suite_file_path=sub_suite_file_path, suite_file=suite.suite_name, task_name=suite.task_name, params=params) if timeout_est.is_specified(): build_variant = self.evg_project_config.get_variant( suite.build_variant) timeout_info = timeout_est.generate_timeout_cmd( self.gen_task_options.is_patch, params.repeat_suites, build_variant.idle_timeout_factor, build_variant.exec_timeout_factor, self.gen_task_options.use_default_timeouts) else: timeout_info = self.gen_task_options.build_defualt_timeout() commands = [ timeout_info.cmd, FunctionCall("do setup"), FunctionCall(CONFIGURE_EVG_CREDENTIALS), FunctionCall(RUN_GENERATED_TESTS, run_tests_vars), ] shrub_task = Task(sub_task_name, [cmd for cmd in commands if cmd], self._get_dependencies(params)) return ResmokeTask(shrub_task=shrub_task, resmoke_suite_name=suite.suite_name, execution_task_suite_yaml_path=sub_suite_file_path, execution_task_suite_yaml_name=sub_suite_file, test_list=sub_suite_roots, excludes=excludes)
def get_skip_compile_setup_commands() -> Tuple[List[FunctionCall], set]: """Return skip compile setup commands.""" return [ FunctionCall("set up venv"), FunctionCall("upload pip requirements"), FunctionCall("f_expansions_write"), FunctionCall("configure evergreen api credentials"), FunctionCall("get compiled binaries"), ], set()
def _add_multiversion_commands( commands: List[Union[FunctionCall, ShrubCommand]] ) -> List[Union[FunctionCall, ShrubCommand]]: res = [ FunctionCall("git get project no modules"), FunctionCall("add git tag"), ] for command in commands: res.append(command) if hasattr(command, "name") and command.name == CONFIGURE_EVG_CREDENTIALS: # Run multiversion setup after getting EVG credentials. res.append(FunctionCall(DO_MULTIVERSION_SETUP)) return res
def _generate_sub_task(self, mixed_version_config: str, task: str, task_index: int, suite: str, num_suites: int, is_sharded: bool, burn_in_test: Optional[str] = None) -> Task: # pylint: disable=too-many-arguments """ Generate a sub task to be run with the provided suite and mixed version config. :param mixed_version_config: mixed version configuration. :param task: Name of task. :param task_index: Index of task to generate. :param suite: Name of suite being generated. :param num_suites: Number os suites being generated. :param is_sharded: If this is being generated for a sharded configuration. :param burn_in_test: If generation is for burn_in, burn_in options to use. :return: Shrub configuration for task specified. """ # Create a sub task name appended with the task_index and build variant name. task_name = f"{task}_{mixed_version_config}" sub_task_name = taskname.name_generated_task(task_name, task_index, num_suites, self.options.variant) gen_task_name = BURN_IN_TASK if burn_in_test is not None else self.task run_tests_vars = { "resmoke_args": _generate_resmoke_args(suite, mixed_version_config, is_sharded, self.options, burn_in_test), "task": gen_task_name, } commands = [ FunctionCall("do setup"), # Fetch and download the proper mongod binaries before running multiversion tests. FunctionCall("configure evergreen api credentials"), FunctionCall("do multiversion setup"), FunctionCall("run generated tests", run_tests_vars), ] return Task(sub_task_name, commands, {TaskDependency("archive_dist_test_debug")})
def resmoke_commands( run_tests_fn_name: str, run_tests_vars: Dict[str, Any], timeout_info: TimeoutInfo, require_multiversion_setup: Optional[bool] = False ) -> List[ShrubCommand]: """ Create a list of commands to run a resmoke task. Used by burn_in* only. Other tasks use a standalone multiversion decorator. :param run_tests_fn_name: Name of function to run resmoke tests. :param run_tests_vars: Dictionary of variables to pass to run_tests function. :param timeout_info: Timeout info for task. :param require_multiversion_setup: Requires downloading Multiversion binaries. :return: List of commands to run a resmoke task. """ commands = [ timeout_info.cmd, FunctionCall("git get project no modules") if require_multiversion_setup else None, FunctionCall("add git tag") if require_multiversion_setup else None, FunctionCall("do setup"), FunctionCall(CONFIGURE_EVG_CREDENTIALS), FunctionCall(DO_MULTIVERSION_SETUP) if require_multiversion_setup else None, FunctionCall(run_tests_fn_name, run_tests_vars), FunctionCall("validate resmoke tests runtime"), ] return [cmd for cmd in commands if cmd]
def _update_suite_name(self, commands: List[Union[FunctionCall, ShrubCommand]], suite_name: str): index, run_test_func = self._find_command(RUN_GENERATED_TESTS, commands) if run_test_func is not None: run_test_vars = copy.deepcopy(run_test_func.parameters) run_test_vars["suite"] = suite_name commands[index] = FunctionCall(RUN_GENERATED_TESTS, run_test_vars)
def build_fuzzer_sub_task(task_name: str, task_index: int, options: ConfigOptions) -> Task: """ Build a shrub task to run the fuzzer. :param task_name: Parent name of task. :param task_index: Index of sub task being generated. :param options: Options to use for task. :return: Shrub task to run the fuzzer. """ sub_task_name = taskname.name_generated_task(task_name, task_index, options.num_tasks, options.variant) run_jstestfuzz_vars = { "jstestfuzz_vars": "--numGeneratedFiles {0} {1}".format(options.num_files, options.jstestfuzz_vars), "npm_command": options.npm_command, } suite_arg = f"--suites={options.suite}" run_tests_vars = { "continue_on_failure": options.continue_on_failure, "resmoke_args": f"{suite_arg} {options.resmoke_args}", "resmoke_jobs_max": options.resmoke_jobs_max, "should_shuffle": options.should_shuffle, "task_path_suffix": options.use_multiversion, "timeout_secs": options.timeout_secs, "task": options.name } # yapf: disable commands = [ FunctionCall("do setup"), FunctionCall("do multiversion setup") if options.use_multiversion else None, FunctionCall("setup jstestfuzz"), FunctionCall("run jstestfuzz", run_jstestfuzz_vars), FunctionCall("run generated tests", run_tests_vars) ] commands = [command for command in commands if command is not None] return Task(sub_task_name, commands, {TaskDependency("compile")})
def get_skip_compile_setup_commands() -> Tuple[List[FunctionCall], set]: """Return skip compile setup commands.""" return [ BuiltInCommand("manifest.load", {}), FunctionCall("git get project"), FunctionCall("f_expansions_write"), FunctionCall("kill processes"), FunctionCall("cleanup environment"), FunctionCall("set up venv"), FunctionCall("upload pip requirements"), FunctionCall("configure evergreen api credentials"), FunctionCall("get compiled binaries"), ], set()
def resmoke_commands( run_tests_fn_name: str, run_tests_vars: Dict[str, Any], timeout_info: TimeoutInfo, use_multiversion: Optional[str] = None) -> List[ShrubCommand]: """ Create a list of commands to run a resmoke task. :param run_tests_fn_name: Name of function to run resmoke tests. :param run_tests_vars: Dictionary of variables to pass to run_tests function. :param timeout_info: Timeout info for task. :param use_multiversion: If True include multiversion setup. :return: List of commands to run a resmoke task. """ commands = [ timeout_info.cmd, FunctionCall("do setup"), FunctionCall("do multiversion setup") if use_multiversion else None, FunctionCall(run_tests_fn_name, run_tests_vars), ] return [cmd for cmd in commands if cmd]
def _update_execution_task_suite_info(self, commands: List[Union[FunctionCall, ShrubCommand]], multiversion_suite_path: str, old_bin_version: str): index, run_test_func = self._find_command(RUN_GENERATED_TESTS, commands) if run_test_func is not None: run_test_vars = copy.deepcopy(run_test_func.parameters) run_test_vars["suite"] = multiversion_suite_path run_test_vars[ "multiversion_exclude_tags_version"] = old_bin_version commands[index] = FunctionCall(RUN_GENERATED_TESTS, run_test_vars) return run_test_vars["suite"] return None
def build_fuzzer_sub_task(task_index: int, params: FuzzerGenTaskParams) -> Task: """ Build a shrub task to run the fuzzer. :param task_index: Index of sub task being generated. :param params: Parameters describing how tasks should be generated. :return: Shrub task to run the fuzzer. """ sub_task_name = taskname.name_generated_task(params.task_name, task_index, params.num_tasks, params.variant) run_tests_vars = { "continue_on_failure": params.continue_on_failure, "resmoke_args": params.get_resmoke_args(), "resmoke_jobs_max": params.resmoke_jobs_max, "should_shuffle": params.should_shuffle, "require_multiversion_setup": params.require_multiversion_setup, "timeout_secs": params.timeout_secs, "task": params.task_name, "gen_task_config_location": params.config_location, "suite": params.suite, } # yapf: disable timeout_info = TimeoutInfo.overridden(timeout=params.timeout_secs) commands = [] if params.require_multiversion_setup: commands += [FunctionCall("git get project no modules")] commands += [FunctionCall("add git tag")] commands += [ timeout_info.cmd, FunctionCall("do setup"), FunctionCall("configure evergreen api credentials") if params.require_multiversion_setup else None, FunctionCall("do multiversion setup") if params.require_multiversion_setup else None, FunctionCall("setup jstestfuzz"), FunctionCall("run jstestfuzz", params.jstestfuzz_params()), FunctionCall("run generated tests", run_tests_vars) ] commands = [command for command in commands if command is not None] return Task(sub_task_name, commands, {TaskDependency(ARCHIVE_DIST_TEST_DEBUG_TASK)})
def build_fuzzer_sub_task(task_index: int, params: FuzzerGenTaskParams, version: str) -> Task: """ Build a shrub task to run the fuzzer. :param task_index: Index of sub task being generated. :param params: Parameters describing how tasks should be generated. :param version: Multiversion version to generate against. :return: Shrub task to run the fuzzer. """ sub_task_name = taskname.name_generated_task( params.get_task_name(version), task_index, params.num_tasks, params.variant) suite_arg = f"--suites={params.suite}" run_tests_vars = { "continue_on_failure": params.continue_on_failure, "resmoke_args": f"{suite_arg} {params.get_resmoke_args()}", "resmoke_jobs_max": params.resmoke_jobs_max, "should_shuffle": params.should_shuffle, "require_multiversion": params.require_multiversion, "timeout_secs": params.timeout_secs, "task": params.get_task_name(version), "gen_task_config_location": params.config_location, } # yapf: disable commands = [] if params.require_multiversion: commands += [FunctionCall("git get project no modules")] commands += [ FunctionCall("do setup"), FunctionCall("configure evergreen api credentials") if params.require_multiversion else None, FunctionCall("do multiversion setup") if params.require_multiversion else None, FunctionCall("setup jstestfuzz"), FunctionCall("run jstestfuzz", params.jstestfuzz_params()), FunctionCall("run generated tests", run_tests_vars) ] commands = [command for command in commands if command is not None] return Task(sub_task_name, commands, {TaskDependency("archive_dist_test_debug")})
def build_fuzzer_sub_task(task_index: int, params: FuzzerGenTaskParams) -> Task: """ Build a shrub task to run the fuzzer. :param task_index: Index of sub task being generated. :param params: Parameters describing how tasks should be generated. :return: Shrub task to run the fuzzer. """ sub_task_name = taskname.name_generated_task(params.task_name, task_index, params.num_tasks, params.variant) run_tests_vars = { "continue_on_failure": params.continue_on_failure, "resmoke_args": params.get_resmoke_args(), "resmoke_jobs_max": params.resmoke_jobs_max, "should_shuffle": params.should_shuffle, "require_multiversion_setup": params.require_multiversion_setup, "timeout_secs": params.timeout_secs, "task": params.task_name, # This expansion's name was shortened to reduce the overall size of # the generated configuration file # gtcl = gen_task_config_location "gtcl": params.config_location, "suite": params.suite, } # yapf: disable timeout_info = TimeoutInfo.overridden(timeout=params.timeout_secs) commands = [ timeout_info.cmd, FunctionCall("do setup"), FunctionCall(CONFIGURE_EVG_CREDENTIALS), FunctionCall("setup jstestfuzz"), FunctionCall("run jstestfuzz", params.jstestfuzz_params()), FunctionCall(RUN_GENERATED_TESTS, run_tests_vars), FunctionCall("minimize jstestfuzz") ] dependencies = { TaskDependency(dependency) for dependency in params.dependencies } return Task(sub_task_name, commands, dependencies)
def define_task(target): name = f"make-lint-{target}" return Task(name, [FunctionCall("run-make", {"target": name})])
def get_setup_commands() -> Tuple[List[FunctionCall], Set[TaskDependency]]: """Return setup commands.""" return [ FunctionCall("do setup"), ], {TaskDependency("archive_dist_test_debug")}