def _sync_running_job_executions(self): """Syncs job executions that are currently running by handling any canceled or timed out executions """ running_job_exes = {} for job_exe in running_job_mgr.get_all_job_exes(): running_job_exes[job_exe.id] = job_exe right_now = now() for job_exe_model in JobExecution.objects.filter(id__in=running_job_exes.keys()).iterator(): running_job_exe = running_job_exes[job_exe_model.id] task_to_kill = None if job_exe_model.status == 'CANCELED': try: task_to_kill = running_job_exe.execution_canceled() except DatabaseError: logger.exception('Error canceling job execution %i', running_job_exe.id) elif job_exe_model.is_timed_out(right_now): try: task_to_kill = running_job_exe.execution_timed_out(right_now) except DatabaseError: logger.exception('Error failing timed out job execution %i', running_job_exe.id) if task_to_kill: pb_task_to_kill = mesos_pb2.TaskID() pb_task_to_kill.value = task_to_kill.id logger.info('Killing task %s', task_to_kill.id) self._driver.killTask(pb_task_to_kill) if running_job_exe.is_finished(): running_job_mgr.remove_job_exe(running_job_exe.id) cleanup_mgr.add_job_execution(running_job_exe)
def slaveLost(self, driver, slaveId): """ Invoked when a slave has been determined unreachable (e.g., machine failure, network partition.) Most frameworks will need to reschedule any tasks launched on this slave on a new slave. See documentation for :meth:`mesos_api.mesos.Scheduler.slaveLost`. """ started = now() agent_id = slaveId.value node = node_mgr.get_node(agent_id) if node: logger.warning('Node lost on host %s', node.hostname) else: logger.warning('Node lost on agent %s', agent_id) node_mgr.lost_node(agent_id) resource_mgr.lost_agent(agent_id) # Fail job executions that were running on the lost node if node: for finished_job_exe in job_exe_mgr.lost_node(node.id, started): cleanup_mgr.add_job_execution(finished_job_exe) duration = now() - started msg = 'Scheduler slaveLost() took %.3f seconds' if duration > ScaleScheduler.NORMAL_WARN_THRESHOLD: logger.warning(msg, duration.total_seconds()) else: logger.debug(msg, duration.total_seconds())
def slaveLost(self, driver, slaveId): """ Invoked when a slave has been determined unreachable (e.g., machine failure, network partition.) Most frameworks will need to reschedule any tasks launched on this slave on a new slave. See documentation for :meth:`mesos_api.mesos.Scheduler.slaveLost`. """ started = now() agent_id = slaveId.value node = node_mgr.get_node(agent_id) if node: logger.error('Node lost on host %s', node.hostname) else: logger.error('Node lost on agent %s', agent_id) node_mgr.lost_node(agent_id) offer_mgr.lost_node(agent_id) # Fail job executions that were running on the lost node if node: for running_job_exe in running_job_mgr.get_job_exes_on_node(node.id): try: running_job_exe.execution_lost(started) except DatabaseError: logger.exception('Error failing lost job execution: %s', running_job_exe.id) # Error failing execution, add task so it can be reconciled task = running_job_exe.current_task if task: recon_mgr.add_task_ids([task.id]) if running_job_exe.is_finished(): running_job_mgr.remove_job_exe(running_job_exe.id) cleanup_mgr.add_job_execution(running_job_exe) duration = now() - started msg = 'Scheduler slaveLost() took %.3f seconds' if duration > ScaleScheduler.DATABASE_WARN_THRESHOLD: logger.warning(msg, duration.total_seconds()) else: logger.debug(msg, duration.total_seconds())
def _execute(self): """See :meth:`scheduler.threads.base_thread.BaseSchedulerThread._execute` """ scheduler_mgr.sync_with_database() job_type_mgr.sync_with_database() job_exe_mgr.sync_with_database() workspace_mgr.sync_with_database() node_mgr.sync_with_database(scheduler_mgr.config) cleanup_mgr.update_nodes(node_mgr.get_nodes()) mesos_master = scheduler_mgr.mesos_address resource_mgr.sync_with_mesos(mesos_master.hostname, mesos_master.port) # Handle canceled job executions for finished_job_exe in job_exe_mgr.sync_with_database(): cleanup_mgr.add_job_execution(finished_job_exe) if settings.SECRETS_URL: secrets_mgr.sync_with_backend()
def _schedule_waiting_tasks(self, nodes, running_job_exes, when): """Schedules all waiting tasks for which there are sufficient resources and updates the resource manager with any resource shortages. All scheduling nodes that have fulfilled all of their waiting tasks will be returned so new job executions can be added to them. :param nodes: The dict of scheduling nodes stored by node ID :type nodes: dict :param running_job_exes: The currently running job executions :type running_job_exes: list :param when: The current time :type when: :class:`datetime.datetime` :returns: The dict of scheduling nodes stored by node ID that have no more waiting tasks :rtype: dict """ fulfilled_nodes = {} # {Node ID: SchedulingNode} waiting_tasks = [] # Schedule waiting node tasks first for node in nodes.values(): has_waiting_tasks = node.accept_node_tasks(when, waiting_tasks) if node.is_ready_for_next_job_task and not has_waiting_tasks: # A node can only be fulfilled if it is able to run waiting tasks and it has no more waiting tasks fulfilled_nodes[node.node_id] = node # Schedule job executions already on the node waiting for their next task node_lost_job_exes_ids = [] for running_job_exe in running_job_exes: if running_job_exe.node_id not in nodes: # Unknown/lost node node_lost_job_exes_ids.append(running_job_exe.id) else: node = nodes[running_job_exe.node_id] if not node.is_ready_for_next_job_task or node.agent_id != running_job_exe.agent_id: # Node is deprecated, offline, or has switched agent IDs node_lost_job_exes_ids.append(running_job_exe.id) elif running_job_exe.is_next_task_ready(): has_waiting_tasks = node.accept_job_exe_next_task( running_job_exe, waiting_tasks) if has_waiting_tasks and node.node_id in fulfilled_nodes: # Node has tasks waiting for resources del fulfilled_nodes[node.node_id] # Handle any running job executions that have lost their node or become starved finished_job_exes = job_exe_mgr.check_for_starvation(when) if node_lost_job_exes_ids: finished_job_exes.extend( job_exe_mgr.lost_job_exes(node_lost_job_exes_ids, when)) for finished_job_exe in finished_job_exes: cleanup_mgr.add_job_execution(finished_job_exe) # Update waiting task counts and calculate shortages agent_shortages = {} # {Agent ID: NodeResources} new_waiting_tasks = {} # {Task ID: int} for task in waiting_tasks: if task.id in self._waiting_tasks: count = self._waiting_tasks[task.id] + 1 else: count = 1 new_waiting_tasks[task.id] = count if count >= TASK_SHORTAGE_WAIT_COUNT: # This task has waited too long for resources, generate a shortage if task.agent_id in agent_shortages: agent_shortages[task.agent_id].add(task.get_resources()) else: resources = NodeResources() resources.add(task.get_resources()) agent_shortages[task.agent_id] = resources self._waiting_tasks = new_waiting_tasks resource_mgr.set_agent_shortages(agent_shortages) return fulfilled_nodes
def update(self, status): """ Invoked when the status of a task has changed (e.g., a slave is lost and so the task is lost, a task finishes and an executor sends a status update saying so, etc.) Note that returning from this callback acknowledges receipt of this status update. If for whatever reason the scheduler aborts during this callback (or the process exits) another status update will be delivered. Note, however, that this is currently not true if the slave sending the status update is lost or fails during that time. """ started = now() model = utils.create_task_update_model(status) mesos_status = model.status task_update = TaskStatusUpdate(model, utils.get_status_agent_id(status), utils.get_status_data(status)) task_id = task_update.task_id was_task_finished = task_update.status in TaskStatusUpdate.TERMINAL_STATUSES was_job_finished = False if mesos_status == 'TASK_ERROR': logger.error('Status update for task %s: %s', task_id, mesos_status) if mesos_status == 'TASK_LOST': logger.warning('Status update for task %s: %s', task_id, mesos_status) else: logger.info('Status update for task %s: %s', task_id, mesos_status) # Since we have a status update for this task, remove it from reconciliation set recon_mgr.remove_task_id(task_id) # Hand off task update to be saved in the database if task_id.startswith(JOB_TASK_ID_PREFIX): # Grab job execution ID from manager cluster_id = JobExecution.parse_cluster_id(task_id) job_exe = job_exe_mgr.get_running_job_exe(cluster_id) if job_exe: model.job_exe_id = job_exe.id task_update_mgr.add_task_update(model) # Update task with latest status # This should happen before the job execution or node manager are updated, since they will assume that the task # has already been updated task_mgr.handle_task_update(task_update) if task_id.startswith(JOB_TASK_ID_PREFIX): # Job task, so update the job execution try: job_exe = job_exe_mgr.handle_task_update(task_update) if job_exe and job_exe.is_finished(): logger.info("job_exe with job id %s and node id %s is finished", job_exe.job_id, job_exe.node_id) was_job_finished = True cleanup_mgr.add_job_execution(job_exe) GPUManager.release_gpus(job_exe.node_id, job_exe.job_id) except Exception: cluster_id = JobExecution.parse_cluster_id(task_id) logger.exception('Error handling status update for job execution: %s', cluster_id) # Error handling status update, add task so it can be reconciled task = task_mgr.get_task(task_id) if task: recon_mgr.add_tasks([task]) else: # Not a job task, so must be either a node or system task node_mgr.handle_task_update(task_update) system_task_mgr.handle_task_update(task_update) scheduler_mgr.add_task_update_counts(was_task_finished, was_job_finished) duration = now() - started msg = 'Scheduler statusUpdate() took %.3f seconds' if duration > ScaleScheduler.NORMAL_WARN_THRESHOLD: logger.warning(msg, duration.total_seconds()) else: logger.debug(msg, duration.total_seconds())
def statusUpdate(self, driver, status): """ Invoked when the status of a task has changed (e.g., a slave is lost and so the task is lost, a task finishes and an executor sends a status update saying so, etc.) Note that returning from this callback acknowledges receipt of this status update. If for whatever reason the scheduler aborts during this callback (or the process exits) another status update will be delivered. Note, however, that this is currently not true if the slave sending the status update is lost or fails during that time. See documentation for :meth:`mesos_api.mesos.Scheduler.statusUpdate`. """ started = now() model = utils.create_task_update_model(status) mesos_status = model.status task_update = TaskStatusUpdate(model, utils.get_status_agent_id(status)) task_id = task_update.task_id if mesos_status == 'TASK_LOST': logger.warning('Status update for task %s: %s', task_id, mesos_status) else: logger.info('Status update for task %s: %s', task_id, mesos_status) # Since we have a status update for this task, remove it from reconciliation set recon_mgr.remove_task_id(task_id) # Hand off task update to be saved in the database task_update_mgr.add_task_update(model) if task_id.startswith(CLEANUP_TASK_ID_PREFIX): cleanup_mgr.handle_task_update(task_update) else: job_exe_id = JobExecution.get_job_exe_id(task_id) try: running_job_exe = running_job_mgr.get_job_exe(job_exe_id) if running_job_exe: running_job_exe.task_update(task_update) # Remove finished job execution if running_job_exe.is_finished(): running_job_mgr.remove_job_exe(job_exe_id) cleanup_mgr.add_job_execution(running_job_exe) else: # Scheduler doesn't have any knowledge of this job execution Queue.objects.handle_job_failure(job_exe_id, now(), [], Error.objects.get_builtin_error('scheduler-lost')) except Exception: logger.exception('Error handling status update for job execution: %s', job_exe_id) # Error handling status update, add task so it can be reconciled recon_mgr.add_task_ids([task_id]) duration = now() - started msg = 'Scheduler statusUpdate() took %.3f seconds' if duration > ScaleScheduler.DATABASE_WARN_THRESHOLD: logger.warning(msg, duration.total_seconds()) else: logger.debug(msg, duration.total_seconds())