burnettk d581ac9b22 Squashed 'SpiffWorkflow/' changes from bee868d38..96ad2a2b0
96ad2a2b0 Merge pull request #311 from sartography/feature/error-message-on-bad-child-task
3fb69038d Merge remote-tracking branch 'origin/main' into feature/error-message-on-bad-child-task
df703ebb8 Merge remote-tracking branch 'origin/feature/add_task_not_found_error'
d6e244bcf also raise TaskNotFoundException from bpmn workflow w/ burnettk
37d7ae679 Merge pull request #310 from sartography/feature/add_task_not_found_error
7f4d38ce2 give us a better error if for some reason a task does not exist
b98efbd20 added an exception for task not found w/ burnettk
e1add839d Merge pull request #308 from sartography/bugfix/execute-event-gateways-on-ready
964c0231a do not predict tasks when deserializing, add method to predict all unfinished tasks
114f87aa9 update event gateway
62454c99c Merge pull request #307 from sartography/feature/standardize-task-execution
a087d29ea update task_spec._run to return a boolean & misc cleanup
9864d753d reenable recursion test
1bb1246a0 rename methods & move ready_before tasks from run to ready
12ce08519 move event task execution to run
d51bb68eb cleanup predictions
5e05458a3 make all tasks execute when run rather than completed (except bpmn events)
273d7b325 create a run method for tasks
3c3345c85 Merge pull request #306 from sartography/feature/create-core-test-package
ed85547d7 hopefully fix CI job, also update some deprecated assertions
80d68c231 cleanup around finding tasks
ea5ffff41 create tests based on individual patterns
afe41fba1 move core tests into one package
c075d52bc remove locks from task spec -- they don't do anything
d78c7cc04 reorganize so that related methods are near each other
f162aac43 Merge pull request #305 from sartography/feature/remove-loop-reset
6cad29817 'fix' old serializer to remove loop resets -- or at least get the tests to pass
a95d2fc12 add serialization migration that removes loop resets
c076175c8 account for DST in timers
42b483054 Merge pull request #303 from sartography/bugfix/execute-tasks-on-ready
2bb08aae1 update script/service tasks to execute on ready
0bd23a0ab fix scripts in business rule tasks
13034aaf1 prevent loop reset tasks from being inserted
3fb80518d update join execution model

git-subtree-dir: SpiffWorkflow
git-subtree-split: 96ad2a2b060deb445c39374f065690023351de19
2023-04-07 11:46:14 -04:00

391 lines
13 KiB
Python

# -*- coding: utf-8 -*-
# Copyright (C) 2007 Samuel Abels
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301 USA
import logging
from .specs.Simple import Simple
from .task import Task, TaskState
from .util.compat import mutex
from .util.event import Event
from .exceptions import TaskNotFoundException, WorkflowException
logger = logging.getLogger('spiff')
class Workflow(object):
"""
The engine that executes a workflow.
It is a essentially a facility for managing all branches.
A Workflow is also the place that holds the data of a running workflow.
"""
def __init__(self, workflow_spec, deserializing=False, **kwargs):
"""
Constructor.
:type workflow_spec: specs.WorkflowSpec
:param workflow_spec: The workflow specification.
:type deserializing: bool
:param deserializing: set to true when deserializing to avoid
generating tasks twice (and associated problems with multiple
hierarchies of tasks)
"""
self.name = None
assert workflow_spec is not None
self.spec = workflow_spec
self.data = {}
self.outer_workflow = kwargs.get('parent', self)
self.locks = {}
self.last_task = None
if 'Root' in workflow_spec.task_specs:
root = workflow_spec.task_specs['Root']
else:
root = Simple(workflow_spec, 'Root')
# Setting TaskState.COMPLETED prevents the root task from being executed.
self.task_tree = Task(self, root, state=TaskState.COMPLETED)
start = self.task_tree._add_child(self.spec.start, state=TaskState.FUTURE)
self.success = True
self.debug = False
# Events.
self.completed_event = Event()
if not deserializing:
self._predict()
if 'parent' not in kwargs:
start.task_spec._update(start)
logger.info('Initialize', extra=self.log_info())
self.task_mapping = self._get_task_mapping()
def log_info(self, dct=None):
extra = dct or {}
extra.update({
'workflow_spec': self.spec.name,
'workflow_name': self.spec.description,
'task_spec': '-',
'task_type': None,
'task_id': None,
'data': None,
})
return extra
def is_completed(self):
"""
Returns True if the entire Workflow is completed, False otherwise.
:rtype: bool
:return: Whether the workflow is completed.
"""
mask = TaskState.NOT_FINISHED_MASK
iter = Task.Iterator(self.task_tree, mask)
try:
nexttask = next(iter)
except StopIteration:
# No waiting tasks found.
return True
return False
def _predict(self, mask=TaskState.NOT_FINISHED_MASK):
for task in Workflow.get_tasks(self,TaskState.NOT_FINISHED_MASK):
task.task_spec._predict(task, mask=mask)
def _get_waiting_tasks(self):
waiting = Task.Iterator(self.task_tree, TaskState.WAITING)
return [w for w in waiting]
def _task_completed_notify(self, task):
if task.get_name() == 'End':
self.data.update(task.data)
# Update the state of every WAITING task.
for thetask in self._get_waiting_tasks():
thetask.task_spec._update(thetask)
if self.completed_event.n_subscribers() == 0:
# Since is_completed() is expensive it makes sense to bail
# out if calling it is not necessary.
return
if self.is_completed():
self.completed_event(self)
def _get_mutex(self, name):
if name not in self.locks:
self.locks[name] = mutex()
return self.locks[name]
def _get_task_mapping(self):
task_mapping = {}
for task in self.task_tree:
thread_task_mapping = task_mapping.get(task.thread_id, {})
tasks = thread_task_mapping.get(task.task_spec, set())
tasks.add(task)
thread_task_mapping[task.task_spec] = tasks
task_mapping[task.thread_id] = thread_task_mapping
return task_mapping
def update_task_mapping(self):
"""
Update the task_mapping of workflow, make sure the method is called
every time you reconstruct task instance.
"""
self.task_mapping = self._get_task_mapping()
def set_data(self, **kwargs):
"""
Defines the given attribute/value pairs.
"""
self.data.update(kwargs)
def get_data(self, name, default=None):
"""
Returns the value of the data field with the given name, or the given
default value if the data field does not exist.
:type name: str
:param name: A data field name.
:type default: obj
:param default: Return this value if the data field does not exist.
:rtype: obj
:returns: The value of the data field.
"""
return self.data.get(name, default)
def cancel(self, success=False):
"""
Cancels all open tasks in the workflow.
:type success: bool
:param success: Whether the Workflow should be marked as successfully
completed.
"""
self.success = success
cancel = []
mask = TaskState.NOT_FINISHED_MASK
for task in Task.Iterator(self.task_tree, mask):
cancel.append(task)
for task in cancel:
task.cancel()
logger.info(f'Cancel with {len(cancel)} remaining', extra=self.log_info())
def get_task_spec_from_name(self, name):
"""
Returns the task spec with the given name.
:type name: str
:param name: The name of the task.
:rtype: TaskSpec
:returns: The task spec with the given name.
"""
return self.spec.get_task_spec_from_name(name)
def get_tasks_from_spec_name(self, name):
"""
Returns all tasks whose spec has the given name.
:type name: str
:param name: The name of a task spec.
:rtype: list[Task]
:returns: A list of tasks that relate to the spec with the given name.
"""
return [task for task in self.get_tasks_iterator() if task.task_spec.name == name]
def get_tasks(self, state=TaskState.ANY_MASK):
"""
Returns a list of Task objects with the given state.
:type state: integer
:param state: A bitmask of states.
:rtype: list[Task]
:returns: A list of tasks.
"""
return [t for t in Task.Iterator(self.task_tree, state)]
def get_tasks_iterator(self, state=TaskState.ANY_MASK):
"""
Returns a iterator of Task objects with the given state.
:type state: integer
:param state: A bitmask of states.
:rtype: Task.Iterator
:returns: A list of tasks.
"""
return Task.Iterator(self.task_tree, state)
def get_task_from_id(self, task_id, tasklist=None):
"""
Returns the task with the given id.
:type id:integer
:param id: The id of a task.
:param tasklist: Optional cache of get_tasks for operations
where we are calling multiple times as when we
are deserializing the workflow
:rtype: Task
:returns: The task with the given id.
"""
if task_id is None:
raise WorkflowException('task_id is None', task_spec=self.spec)
tasklist = tasklist or self.task_tree
for task in self.task_tree:
if task.id == task_id:
return task
msg = 'A task with the given task_id (%s) was not found' % task_id
raise TaskNotFoundException(msg, task_spec=self.spec)
def run_task_from_id(self, task_id):
"""
Runs the task with the given id.
:type task_id: integer
:param task_id: The id of the Task object.
"""
task = self.get_task_from_id(task_id)
return task.run()
def reset_task_from_id(self, task_id):
"""
Runs the task with the given id.
:type task_id: integer
:param task_id: The id of the Task object.
"""
# Given that this is a BPMN thing it's questionable whether this belongs here at all
# However, since it calls a BPMN thing on `task`, I guess I'll leave it here
# At least it's not in both places any more
data = {}
if self.last_task and self.last_task.data:
data = self.last_task.data
task = self.get_task_from_id(task_id)
return task.reset_token(data)
def run_next(self, pick_up=True, halt_on_manual=True):
"""
Runs the next task.
Returns True if completed, False otherwise.
:type pick_up: bool
:param pick_up: When True, this method attempts to choose the next
task not by searching beginning at the root, but by
searching from the position at which the last call
of complete_next() left off.
:type halt_on_manual: bool
:param halt_on_manual: When True, this method will not attempt to
complete any tasks that have manual=True.
See :meth:`SpiffWorkflow.specs.TaskSpec.__init__`
:rtype: bool
:returns: True if all tasks were completed, False otherwise.
"""
# Try to pick up where we left off.
blacklist = []
if pick_up and self.last_task is not None:
try:
iter = Task.Iterator(self.last_task, TaskState.READY)
task = next(iter)
except StopIteration:
task = None
self.last_task = None
if task is not None:
if not (halt_on_manual and task.task_spec.manual):
if task.run():
self.last_task = task
return True
blacklist.append(task)
# Walk through all ready tasks.
for task in Task.Iterator(self.task_tree, TaskState.READY):
for blacklisted_task in blacklist:
if task._is_descendant_of(blacklisted_task):
continue
if not (halt_on_manual and task.task_spec.manual):
if task.run():
self.last_task = task
return True
blacklist.append(task)
# Walk through all waiting tasks.
for task in Task.Iterator(self.task_tree, TaskState.WAITING):
task.task_spec._update(task)
if not task._has_state(TaskState.WAITING):
self.last_task = task
return True
return False
def run_all(self, pick_up=True, halt_on_manual=True):
"""
Runs all branches until completion. This is a convenience wrapper
around :meth:`complete_next`, and the pick_up argument is passed
along.
:type pick_up: bool
:param pick_up: Passed on to each call of complete_next().
:type halt_on_manual: bool
:param halt_on_manual: When True, this method will not attempt to
complete any tasks that have manual=True.
See :meth:`SpiffWorkflow.specs.TaskSpec.__init__`
"""
while self.run_next(pick_up, halt_on_manual):
pass
def get_dump(self):
"""
Returns a complete dump of the current internal task tree for
debugging.
:rtype: str
:returns: The debug information.
"""
return self.task_tree.get_dump()
def dump(self):
"""
Like :meth:`get_dump`, but prints the output to the terminal instead
of returning it.
"""
print(self.task_tree.dump())
def serialize(self, serializer, **kwargs):
"""
Serializes a Workflow instance using the provided serializer.
:type serializer: :class:`SpiffWorkflow.serializer.base.Serializer`
:param serializer: The serializer to use.
:type kwargs: dict
:param kwargs: Passed to the serializer.
:rtype: object
:returns: The serialized workflow.
"""
return serializer.serialize_workflow(self, **kwargs)
@classmethod
def deserialize(cls, serializer, s_state, **kwargs):
"""
Deserializes a Workflow instance using the provided serializer.
:type serializer: :class:`SpiffWorkflow.serializer.base.Serializer`
:param serializer: The serializer to use.
:type s_state: object
:param s_state: The serialized workflow.
:type kwargs: dict
:param kwargs: Passed to the serializer.
:rtype: Workflow
:returns: The workflow instance.
"""
return serializer.deserialize_workflow(s_state, **kwargs)