def check_task_trigger(self, state: State,
upstream_states: Dict[Edge, State]) -> State:
"""
Checks if the task's trigger function passes.
Args:
- state (State): the current state of this task
- upstream_states (Dict[Edge, Union[State, List[State]]]): the upstream states
Returns:
- State: the state of the task after running the check
Raises:
- ENDRUN: if the trigger raises an error
"""
all_states = set() # type: Set[State]
for upstream_state in upstream_states.values():
if isinstance(upstream_state, Mapped):
all_states.update(upstream_state.map_states)
else:
all_states.add(upstream_state)
try:
if not self.task.trigger(all_states):
raise signals.TRIGGERFAIL(message="Trigger failed")
except signals.PrefectStateSignal as exc:
self.logger.debug(
"Task '{name}': {signal} signal raised during execution.".
format(
name=prefect.context.get("task_full_name", self.task.name),
signal=type(exc).__name__,
))
if prefect.context.get("raise_on_exception"):
raise exc
raise ENDRUN(exc.state)
# Exceptions are trapped and turned into TriggerFailed states
except Exception as exc:
self.logger.exception(
"Task '{name}': unexpected error while evaluating task trigger: {exc}"
.format(
exc=repr(exc),
name=prefect.context.get("task_full_name", self.task.name),
))
if prefect.context.get("raise_on_exception"):
raise exc
raise ENDRUN(
TriggerFailed(
"Unexpected error while checking task trigger: {}".format(
repr(exc)),
result=exc,
))
return state
async def test_trigger_failed_state_does_not_set_end_time(
self, flow_run_id):
# there is no logic in Prefect that would create this sequence of
# events, but a user could manually do this
await states.set_flow_run_state(flow_run_id=flow_run_id,
state=TriggerFailed())
flow_run_info = await models.FlowRun.where(id=flow_run_id).first(
{"id", "start_time", "end_time"})
assert not flow_run_info.start_time
assert not flow_run_info.end_time
def test_children_method_on_leaf_state_returns_hierarchy():
assert set(TriggerFailed.parents()) == {Finished, Failed, State}
def test_children_method_on_leaf_state_returns_empty():
assert TriggerFailed.children() == []
dict(state=Mapped(),
assert_true={"is_finished", "is_mapped", "is_successful"}),
dict(state=Paused(), assert_true={"is_pending", "is_scheduled"}),
dict(state=Pending(), assert_true={"is_pending"}),
dict(state=Queued(), assert_true={"is_meta_state", "is_queued"}),
dict(state=Resume(), assert_true={"is_pending", "is_scheduled"}),
dict(state=Retrying(),
assert_true={"is_pending", "is_scheduled", "is_retrying"}),
dict(state=Running(), assert_true={"is_running"}),
dict(state=Scheduled(), assert_true={"is_pending", "is_scheduled"}),
dict(state=Skipped(),
assert_true={"is_finished", "is_successful", "is_skipped"}),
dict(state=Submitted(), assert_true={"is_meta_state", "is_submitted"}),
dict(state=Success(), assert_true={"is_finished", "is_successful"}),
dict(state=TimedOut(), assert_true={"is_finished", "is_failed"}),
dict(state=TriggerFailed(), assert_true={"is_finished", "is_failed"}),
],
)
def test_state_is_methods(state_check):
"""
Iterates over all of the "is_*()" methods of the state, asserting that each one is
False, unless the name of that method is provided as `assert_true`.
For example, if `state_check == (Pending(), {'is_pending'})`, then this method will
assert that `state.is_running()` is False, `state.is_successful()` is False, etc. but
`state.is_pending()` is True.
"""
state = state_check["state"]
assert_true = state_check["assert_true"]
for attr in dir(state):
def test_children_method_on_leaf_state_returns_hierarchy(include_self):
expected = {Finished, Failed, State}
if include_self:
expected.add(TriggerFailed)
assert set(TriggerFailed.parents(include_self=include_self)) == expected
def test_children_method_names_only_returns_strings():
assert TriggerFailed.children(include_self=True,
names_only=True) == ["TriggerFailed"]
def test_state_type_methods_with_trigger_failed_state(self):
state = TriggerFailed(message="")
assert not state.is_cached()
assert not state.is_pending()
assert not state.is_retrying()
assert not state.is_running()
assert state.is_finished()
assert not state.is_skipped()
assert not state.is_scheduled()
assert not state.is_successful()
assert state.is_failed()
assert not state.is_mapped()
assert not state.is_meta_state()
