def _on_task_state_change(self, task_ex, wf_ex, task_state=states.SUCCESS): task_spec = spec_parser.get_task_spec(task_ex.spec) wf_spec = spec_parser.get_workflow_spec(wf_ex.spec) # We must be sure that if task is completed, # it was also completed in previous transaction. if (task_handler.is_task_completed(task_ex, task_spec) and states.is_completed(task_state)): task_handler.after_task_complete(task_ex, task_spec, wf_spec) # Ignore DELAYED state. if task_ex.state == states.RUNNING_DELAYED: return wf_ctrl = wf_base.WorkflowController.get_controller(wf_ex, wf_spec) # Calculate commands to process next. cmds = wf_ctrl.continue_workflow() task_ex.processed = True self._dispatch_workflow_commands(wf_ex, cmds) self._check_workflow_completion(wf_ex, wf_ctrl) elif task_handler.need_to_continue(task_ex, task_spec): # Re-run existing task. cmds = [commands.RunExistingTask(task_ex, reset=False)] self._dispatch_workflow_commands(wf_ex, cmds)
def _find_next_commands(self): """Finds commands that should run next. A concrete algorithm of finding such tasks depends on a concrete workflow controller. :return: List of workflow commands. """ # Add all tasks in IDLE state. idle_tasks = wf_utils.find_tasks_with_state(self.wf_ex, states.IDLE) return [commands.RunExistingTask(t) for t in idle_tasks]
def _get_rerun_commands(self, task_exs, reset=True, env=None): """Get commands to rerun existing task executions. :param task_exs: List of task executions. :param reset: If true, then purge action executions for the tasks. :param env: A set of environment variables to overwrite. :return: List of workflow commands. """ for task_ex in task_exs: self._update_task_ex_env(task_ex, env) cmds = [commands.RunExistingTask(t_e, reset) for t_e in task_exs] LOG.debug("Found commands: %s" % cmds) return cmds
def _find_next_commands(self, env=None): """Finds commands that should run next. A concrete algorithm of finding such tasks depends on a concrete workflow controller. :param env: A set of environment variables to overwrite. :return: List of workflow commands. """ # Add all tasks in IDLE state. idle_tasks = wf_utils.find_task_executions_with_state( self.wf_ex, states.IDLE) for task_ex in idle_tasks: self._update_task_ex_env(task_ex, env) return [commands.RunExistingTask(t) for t in idle_tasks]
def rerun_tasks(self, task_execs, reset=True): """Gets commands to rerun existing task executions. :param task_execs: List of task executions. :param reset: If true, then purge action executions for the tasks. :return: List of workflow commands. """ if self._is_paused_or_completed(): return [] cmds = [ commands.RunExistingTask(self.wf_ex, self.wf_spec, t_e, reset) for t_e in task_execs ] LOG.debug("Commands to rerun workflow tasks: %s" % cmds) return cmds
def _find_next_commands(self, task_ex): """Finds commands that should run next. A concrete algorithm of finding such tasks depends on a concrete workflow controller. :return: List of workflow commands. """ # If task execution was passed then we should make all calculations # only based on it. if task_ex: return [] # Add all tasks in IDLE state. return [ commands.RunExistingTask(self.wf_ex, self.wf_spec, t) for t in self._get_task_executions(state=states.IDLE) ]
def _get_rerun_commands(self, task_exs, reset=True, env=None): """Get commands to rerun existing task executions. :param task_exs: List of task executions. :param reset: If true, then purge action executions for the tasks. :param env: A set of environment variables to overwrite. :return: List of workflow commands. """ for task_ex in task_exs: # TODO(rakhmerov): It is wrong that we update something in # workflow controller, by design it should not change system # state. Fix it, it should happen outside. self._update_task_ex_env(task_ex, env) cmds = [commands.RunExistingTask(t_e, reset) for t_e in task_exs] LOG.debug("Found commands: %s" % cmds) return cmds
def _on_task_state_change(self, task_ex, wf_ex, wf_spec): task_spec = wf_spec.get_tasks()[task_ex.name] if task_handler.is_task_completed(task_ex, task_spec): task_handler.after_task_complete(task_ex, task_spec, wf_spec) # Ignore DELAYED state. if task_ex.state == states.RUNNING_DELAYED: return wf_ctrl = wf_base.get_controller(wf_ex, wf_spec) # Calculate commands to process next. try: cmds = wf_ctrl.continue_workflow() except exc.YaqlEvaluationException as e: LOG.error( 'YAQL error occurred while calculating next workflow ' 'commands [wf_ex_id=%s, task_ex_id=%s]: %s', wf_ex.id, task_ex.id, e ) wf_handler.fail_workflow(wf_ex, str(e)) return # Mark task as processed after all decisions have been made # upon its completion. task_ex.processed = True self._dispatch_workflow_commands(wf_ex, cmds, wf_spec) self._check_workflow_completion(wf_ex, wf_ctrl, wf_spec) elif task_handler.need_to_continue(task_ex, task_spec): # Re-run existing task. cmds = [commands.RunExistingTask(task_ex, reset=False)] self._dispatch_workflow_commands(wf_ex, cmds, wf_spec)