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 _generate_task(self, sub_suite_name: str, sub_task_name: str,
target_dir: str, timeout_est: TimeoutEstimate) -> Task:
"""
Generate a shrub evergreen config for a resmoke task.
:param sub_suite_name: Name of suite being generated.
:param sub_task_name: Name of task to generate.
:param target_dir: Directory containing generated suite files.
:param timeout_est: Estimated runtime to use for calculating timeouts.
:return: Shrub configuration for the described task.
"""
# pylint: disable=too-many-arguments
LOGGER.debug("Generating task", sub_suite=sub_suite_name)
# Evergreen always uses a unix shell, even on Windows, so instead of using os.path.join
# here, just use the forward slash; otherwise the path separator will be treated as
# the escape character on Windows.
target_suite_file = '/'.join(
[target_dir, os.path.basename(sub_suite_name)])
run_tests_vars = self._get_run_tests_vars(target_suite_file)
use_multiversion = self.options.use_multiversion
timeout_cmd = timeout_est.generate_timeout_cmd(
self.options.is_patch, self.options.repeat_suites,
self.options.use_default_timeouts)
commands = resmoke_commands("run generated tests", run_tests_vars,
timeout_cmd, use_multiversion)
return Task(sub_task_name, commands, self._get_dependencies())
def generate_tasks(self, gen_suite: GeneratedSuite,
params: BurnInGenTaskParams) -> List[Task]:
"""Create the task configuration for the given test using the given index."""
tasks = set()
for index, suite in enumerate(gen_suite.sub_suites):
if len(suite.test_list) != 1:
raise ValueError(
f"Can only run one test per suite in burn-in; got {suite.test_list}"
)
test_name = suite.test_list[0]
test_unix_style = test_name.replace('\\', '/')
run_tests_vars = {
"suite":
gen_suite.suite_name,
"resmoke_args":
self._generate_resmoke_args(gen_suite.task_name, params,
test_unix_style)
}
timeout_cmd = self.generate_timeouts(test_name)
commands = resmoke_commands("run tests", run_tests_vars,
timeout_cmd,
params.require_multiversion_setup)
dependencies = {TaskDependency(ARCHIVE_DIST_TEST_DEBUG_TASK)}
tasks.add(
Task(self._generate_task_name(gen_suite, index), commands,
dependencies))
return tasks
def decorate_tasks_with_dynamically_generated_files(
self, sub_tasks: Set[Task],
params: MultiversionDecoratorParams) -> Set[Task]:
"""
Make multiversion subtasks based on generated subtasks, for tasks with generated files. E.g. fuzzers.
@param sub_tasks: set of existing sub-tasks to be converted to multiversion.
@param params: decoration parameters.
@return: Set of multiversion tasks.
"""
fixture_type = self._get_suite_fixture_type(params.base_suite)
versions_combinations = self._get_versions_combinations(fixture_type)
decorated_tasks = set()
for old_version in self.old_versions:
for mixed_bin_versions in versions_combinations:
for index, sub_task in enumerate(sub_tasks):
commands = list(sub_task.commands)
base_task_name = self._build_name(params.task, old_version,
mixed_bin_versions)
sub_task_name = taskname.name_generated_task(
base_task_name, index, params.num_tasks,
params.variant)
suite_name = self._build_name(params.base_suite,
old_version,
mixed_bin_versions)
self._update_execution_task_suite_info(
commands, suite_name, old_version)
commands = self._add_multiversion_commands(commands)
decorated_tasks.add(
Task(name=sub_task_name,
commands=commands,
dependencies=sub_task.dependencies))
return decorated_tasks
def create_task(self, index: int, test_name: str) -> Task:
"""
Create the task configuration for the given test using the given index.
:param index: Index of sub-task being created.
:param test_name: Name of test that should be executed.
:return: Configuration for generating the specified task.
"""
resmoke_args = self.task_info.resmoke_args
sub_task_name = self.generate_name(index)
LOGGER.debug("Generating sub-task", sub_task=sub_task_name)
test_unix_style = test_name.replace('\\', '/')
run_tests_vars = {
"resmoke_args":
f"{resmoke_args} {self.repeat_config.generate_resmoke_options()} {test_unix_style}"
}
timeout = self.generate_timeouts(test_name)
commands = resmoke_commands("run tests", run_tests_vars, timeout,
self.task_info.require_multiversion)
dependencies = {TaskDependency(ARCHIVE_DIST_TEST_TASK)}
return Task(sub_task_name, commands, dependencies)
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 decorate_tasks(self, sub_tasks: Set[Task], params) -> Set[Task]:
"""Make multiversion subtasks based on generated subtasks."""
fixture_type = self._get_suite_fixture_type(params.suite)
versions_combinations = self._get_versions_combinations(fixture_type)
decorated_tasks = set()
for old_version in self.old_versions:
for mixed_bin_versions in versions_combinations:
for index, sub_task in enumerate(sub_tasks):
commands = list(sub_task.commands)
base_task_name = self._build_name(
params.task_name, old_version,
mixed_bin_versions.replace("-", "_"))
sub_task_name = taskname.name_generated_task(
base_task_name, index, params.num_tasks,
params.variant)
suite_name = self._build_name(
params.suite, old_version,
mixed_bin_versions.replace("-", "_"))
self._update_suite_name(commands, suite_name)
commands = self._add_multiversion_commands(commands)
decorated_tasks.add(
Task(name=sub_task_name,
commands=commands,
dependencies=sub_task.dependencies))
return decorated_tasks
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 _generate_task(self, sub_suite_name: str, sub_task_name: str,
timeout_est: TimeoutEstimate,
params: ResmokeGenTaskParams,
suite: GeneratedSuite) -> Task:
"""
Generate a shrub evergreen config for a resmoke task.
:param sub_suite_name: Name of suite being generated.
:param sub_task_name: Name of task to generate.
: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.
:return: Shrub configuration for the described task.
"""
# pylint: disable=too-many-arguments
LOGGER.debug("Generating task", sub_suite=sub_suite_name)
target_suite_file = self.gen_task_options.suite_location(
sub_suite_name)
run_tests_vars = self._get_run_tests_vars(target_suite_file,
suite.suite_name, params,
suite.build_variant)
require_multiversion = params.require_multiversion
timeout_cmd = timeout_est.generate_timeout_cmd(
self.gen_task_options.is_patch, params.repeat_suites,
self.gen_task_options.use_default_timeouts)
commands = resmoke_commands("run generated tests", run_tests_vars,
timeout_cmd, require_multiversion)
return Task(sub_task_name, commands, self._get_dependencies())
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 test_display_task_with_different_task_types(self):
bv = under_test.BuildVariant("build variant")
n_tasks = 5
tasks = {Task(f"task {i}", []) for i in range(n_tasks)}
n_task_groups = 3
task_groups = {TaskGroup(f"task group {i}", []) for i in range(n_task_groups)}
n_existing_tasks = 4
existing_tasks = {ExistingTask(f"existing task {i}") for i in range(n_existing_tasks)}
bv.display_task(
"display",
execution_tasks=tasks,
execution_task_groups=task_groups,
execution_existing_tasks=existing_tasks,
distros=["the distro"],
)
d = bv.as_dict()
assert d["name"] == "build variant"
assert len(d["tasks"]) == n_tasks + n_task_groups # Existing tasks should already exist.
assert len(d["display_tasks"]) == 1
display_task = d["display_tasks"][0]
assert display_task["name"] == "display"
assert len(display_task["execution_tasks"]) == n_tasks + n_task_groups + n_existing_tasks
all_generated_execution_tasks = {t for t in display_task["execution_tasks"]}
for task in chain(tasks, task_groups, existing_tasks):
assert task.name in all_generated_execution_tasks
for task in d["tasks"]:
assert "the distro" in task["distros"]
def decorate_tasks_with_explicit_files(
self, sub_tasks: List[ResmokeTask],
params: MultiversionDecoratorParams) -> List[ResmokeTask]:
"""
Make multiversion subtasks based on generated subtasks for explicit tasks.
Explicit tasks need to have new resmoke.py suite files created for each one with a
unique list of test roots.
"""
fixture_type = self._get_suite_fixture_type(params.base_suite)
versions_combinations = self._get_versions_combinations(fixture_type)
decorated_tasks = []
for old_version in self.old_versions:
for mixed_bin_versions in versions_combinations:
for index, sub_task in enumerate(sub_tasks):
shrub_task = sub_task.shrub_task
commands = list(shrub_task.commands)
# Decorate the task name.
base_task_name = self._build_name(params.task, old_version,
mixed_bin_versions)
sub_task_name = taskname.name_generated_task(
base_task_name, index, params.num_tasks,
params.variant)
# Decorate the suite name
resmoke_suite_name = self._build_name(
sub_task.resmoke_suite_name, old_version,
mixed_bin_versions)
execution_task_suite_name = taskname.name_generated_task(
resmoke_suite_name, index, params.num_tasks)
execution_task_suite_yaml_dir = os.path.dirname(
sub_task.execution_task_suite_yaml_path)
execution_task_suite_yaml_file = f"{execution_task_suite_name}.yml"
execution_task_suite_yaml_path = os.path.join(
execution_task_suite_yaml_dir,
execution_task_suite_yaml_file)
# Decorate the command invocation options.
self._update_execution_task_suite_info(
commands, execution_task_suite_yaml_path, old_version)
commands = self._add_multiversion_commands(commands)
# Store the result.
shrub_task = Task(name=sub_task_name,
commands=commands,
dependencies=shrub_task.dependencies)
decorated_tasks.append(
ResmokeTask(shrub_task=shrub_task,
resmoke_suite_name=resmoke_suite_name,
execution_task_suite_yaml_name=
execution_task_suite_yaml_file,
execution_task_suite_yaml_path=
execution_task_suite_yaml_path,
test_list=sub_task.test_list,
excludes=sub_task.excludes))
return decorated_tasks
def test_tasks_with_no_distros(self):
bv = under_test.BuildVariant("build variant")
task_1 = Task("task 1", [])
task_2 = Task("task 2", [])
bv.add_task(task_1)
bv.add_tasks({task_2})
d = bv.as_dict()
assert d["name"] == "build variant"
assert len(d["tasks"]) == 2
assert d["tasks"][0]["name"] == "task 1"
assert "distros" not in d["tasks"][0]
assert d["tasks"][1]["name"] == "task 2"
assert "distros" not in d["tasks"][1]
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 test_tasks_with_activate(self):
bv = under_test.BuildVariant("build variant")
task_1 = Task("task 1", [])
task_2 = Task("task 2", [])
task_3 = Task("task 3", [])
bv.add_task(task_1, activate=True)
bv.add_tasks({task_2}, activate=False)
bv.display_task("my display task", execution_tasks={task_3}, activate=False)
d = bv.as_dict()
assert d["name"] == "build variant"
assert len(d["tasks"]) == 3
assert d["tasks"][0]["name"] == "task 1"
assert d["tasks"][0]["activate"] is True
assert d["tasks"][1]["name"] == "task 2"
assert d["tasks"][1]["activate"] is False
assert d["tasks"][2]["name"] == "task 3"
assert d["tasks"][2]["activate"] is False
def test_display_tasks(self):
bv = under_test.BuildVariant("build variant")
n_tasks = 5
tasks = {Task(f"task {i}", []) for i in range(n_tasks)}
bv.display_task("display", tasks)
d = bv.as_dict()
assert d["name"] == "build variant"
assert len(d["tasks"]) == n_tasks
assert len(d["display_tasks"]) == 1
assert d["display_tasks"][0]["name"] == "display"
assert len(d["display_tasks"][0]["execution_tasks"]) == n_tasks
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
timeout_info = TimeoutInfo.overridden(timeout=params.timeout_secs)
commands = []
if params.require_multiversion:
commands += [FunctionCall("git get project no modules")]
commands += [
timeout_info.cmd,
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_TASK)})
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 _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 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("configure evergreen api credentials")
if options.use_multiversion else None,
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("archive_dist_test_debug")})
def decorate_single_multiversion_tasks(self, sub_tasks: List[ResmokeTask]):
"""Decorate a multiversion version of a task without all multiversion combinations."""
decorated_sub_tasks = []
for sub_task in sub_tasks:
shrub_task = sub_task.shrub_task
commands = self._add_multiversion_commands(shrub_task.commands)
shrub_task = Task(name=shrub_task.name,
commands=commands,
dependencies=shrub_task.dependencies)
decorated_sub_tasks.append(
ResmokeTask(shrub_task=shrub_task,
resmoke_suite_name=sub_task.resmoke_suite_name,
execution_task_suite_yaml_path=sub_task.
execution_task_suite_yaml_path,
execution_task_suite_yaml_name=sub_task.
execution_task_suite_yaml_name,
test_list=sub_task.test_list,
excludes=sub_task.excludes))
return decorated_sub_tasks
def _generate_task(self, sub_suite_file, sub_task_name: str,
timeout_est: TimeoutEstimate,
params: ResmokeGenTaskParams,
suite: GeneratedSuite) -> Task:
"""
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 timeout_est: Estimated runtime to use for calculating timeouts.
:param params: Parameters describing how tasks should be generated.
:param suite: Parent suite being created.
:return: Shrub configuration for the described task.
"""
# pylint: disable=too-many-arguments
LOGGER.debug("Generating task running suite",
sub_task_name=sub_task_name,
sub_suite_file=sub_suite_file)
# Some splits don't generate new physical config files.
if params.config_location is not None:
sub_suite_file_path = self.gen_task_options.suite_location(
sub_suite_file)
else:
sub_suite_file_path = None
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)
require_multiversion_setup = params.require_multiversion_setup
timeout_cmd = timeout_est.generate_timeout_cmd(
self.gen_task_options.is_patch, params.repeat_suites,
self.gen_task_options.use_default_timeouts)
commands = resmoke_commands("run generated tests", run_tests_vars,
timeout_cmd, require_multiversion_setup)
return Task(sub_task_name, commands, self._get_dependencies())
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)
suite_arg = f"--suites={params.suite}"
run_tests_vars = {
"continue_on_failure": params.continue_on_failure,
"resmoke_args": f"{suite_arg} {params.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.task_name,
"gen_task_config_location": params.config_location,
} # yapf: disable
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 _create_task(index: int, test_count: int, test: str, task_data: Dict,
task_runtime_stats: List[TestRuntime],
generate_config: GenerateConfig, repeat_config: RepeatConfig,
task_prefix: str) -> Task:
# pylint: disable=too-many-arguments,too-many-locals
"""
Create the described shrub sub task.
:param index: Index of task being created.
:param test_count: Total number of testing being created.
:param test: Test task is being generated for.
:param task_data: Data about task to create.
:param task_runtime_stats: Historical runtime of test.
:param generate_config: Configuration of how to generate the task.
:param repeat_config: Configuration of how the task should be repeated.
:param task_prefix: String to prefix generated task with.
:return: Shrub task for given configuration.
"""
# TODO: Extract multiversion related code into separate tooling - SERVER-47137
multiversion_path = task_data.get("use_multiversion")
display_task_name = task_data["display_task_name"]
resmoke_args = task_data["resmoke_args"]
sub_task_name = name_generated_task(f"{task_prefix}:{display_task_name}",
index, test_count,
generate_config.run_build_variant)
LOGGER.debug("Generating sub-task", sub_task=sub_task_name)
test_unix_style = test.replace('\\', '/')
run_tests_vars = {
"resmoke_args":
f"{resmoke_args} {repeat_config.generate_resmoke_options()} {test_unix_style}"
}
if multiversion_path:
run_tests_vars["task_path_suffix"] = multiversion_path
timeout = _generate_timeouts(repeat_config, test, task_runtime_stats)
commands = resmoke_commands("run tests", run_tests_vars, timeout,
multiversion_path)
dependencies = {TaskDependency("compile")}
return Task(sub_task_name, commands, dependencies)
def define_task(target):
name = f"make-lint-{target}"
return Task(name, [FunctionCall("run-make", {"target": name})])