def create_running_job_exe(agent_id='agent_1', job_type=None, job=None, node=None, timeout=None, input_file_size=10.0,
queued=None, started=None, resources=None, priority=None, num_exes=1):
"""Creates a running job execution for unit testing
:returns: The running job execution
:rtype: :class:`job.execution.job_exe.RunningJobExecution`
"""
when = timezone.now()
if not job:
job = create_job(job_type=job_type, status='RUNNING', input_file_size=input_file_size, num_exes=num_exes)
job_type = job.job_type
# Configuration that occurs at queue time
input_files = {}
input_file_ids = job.get_job_data().get_input_file_ids()
if input_file_ids:
for input_file in ScaleFile.objects.get_files_for_queued_jobs(input_file_ids):
input_files[input_file.id] = input_file
exe_config = QueuedExecutionConfigurator(input_files).configure_queued_job(job)
job_exe = JobExecution()
job_exe.set_cluster_id('1234', job.id, job.num_exes)
job_exe.job = job
job_exe.job_type = job_type
job_exe.exe_num = job.num_exes
if not node:
node = node_utils.create_node()
job_exe.node = node
if not timeout:
timeout = job.timeout
job_exe.timeout = timeout
job_exe.input_file_size = input_file_size
if not resources:
resources = job.get_resources()
job_exe.resources = resources.get_json().get_dict()
job_exe.configuration = exe_config.get_dict()
if not queued:
queued = when
job_exe.queued = queued
if not started:
started = when + datetime.timedelta(seconds=1)
job_exe.started = started
job_exe.save()
if not priority:
priority = job.priority
# Configuration that occurs at schedule time
workspaces = {}
for workspace in Workspace.objects.all():
workspaces[workspace.name] = workspace
secret_config = ScheduledExecutionConfigurator(workspaces).configure_scheduled_job(job_exe, job_type,
job_type.get_job_interface(),'INFO')
return RunningJobExecution(agent_id, job_exe, job_type, secret_config, priority)
def _process_scheduled_job_executions(self, framework_id,
queued_job_executions, job_types,
workspaces):
"""Processes the given queued job executions that have been scheduled and returns the new running job
executions. All database updates occur in an atomic transaction.
:param framework_id: The scheduling framework ID
:type framework_id: string
:param queued_job_executions: A list of queued job executions that have been scheduled
:type queued_job_executions: list
:param job_types: A dict of all job types stored by ID
:type job_types: dict
:param workspaces: A dict of all workspaces stored by name
:type workspaces: dict
:returns: The running job executions stored in lists by node ID
:rtype: dict
"""
started = now()
running_job_exes = {}
configurator = ScheduledExecutionConfigurator(workspaces)
with transaction.atomic():
# Bulk create the job execution models
job_exe_models = []
scheduled_models = {} # {queue ID: (job_exe model, config)}
canceled_models = {} # {queue ID: job_exe model}
for queued_job_exe in queued_job_executions:
job_exe_model = queued_job_exe.create_job_exe_model(
framework_id, started)
job_exe_models.append(job_exe_model)
if queued_job_exe.is_canceled:
canceled_models[queued_job_exe.id] = job_exe_model
else:
job_type = job_types[job_exe_model.job_type_id]
# The configuration stored in the job_exe model has been censored so it is safe to save in database
# The returned configuration may contain secrets and should be passed to running job_exe for use
config = configurator.configure_scheduled_job(
job_exe_model, job_type, queued_job_exe.interface,
scheduler_mgr.config.system_logging_level)
scheduled_models[queued_job_exe.id] = (job_exe_model,
config)
JobExecution.objects.bulk_create(job_exe_models)
# Create running and canceled job executions
queue_ids = []
canceled_job_exe_end_models = []
for queued_job_exe in queued_job_executions:
queue_ids.append(queued_job_exe.id)
if queued_job_exe.is_canceled:
job_exe_model = canceled_models[queued_job_exe.id]
canceled_job_exe_end_models.append(
job_exe_model.create_canceled_job_exe_end_model(
started))
else:
agent_id = queued_job_exe.scheduled_agent_id
job_exe_model = scheduled_models[queued_job_exe.id][0]
job_type = job_types[job_exe_model.job_type_id]
config = scheduled_models[queued_job_exe.id][
1] # May contain secrets!
priority = queued_job_exe.priority
running_job_exe = RunningJobExecution(
agent_id, job_exe_model, job_type, config, priority)
if running_job_exe.node_id in running_job_exes:
running_job_exes[running_job_exe.node_id].append(
running_job_exe)
else:
running_job_exes[running_job_exe.node_id] = [
running_job_exe
]
# Add canceled job execution end models to manager to be sent to messaging backend
if canceled_job_exe_end_models:
job_exe_mgr.add_canceled_job_exes(canceled_job_exe_end_models)
# Delete queue models
Queue.objects.filter(id__in=queue_ids).delete()
duration = now() - started
msg = 'Queries to process scheduled jobs took %.3f seconds'
if duration > SCHEDULE_QUERY_WARN_THRESHOLD:
logger.warning(msg, duration.total_seconds())
else:
logger.debug(msg, duration.total_seconds())
return running_job_exes