From 3faa540201d10611427c29a9453c3fec536ddee2 Mon Sep 17 00:00:00 2001 From: Oliver Stolz Date: Tue, 9 Jan 2024 15:24:04 +0100 Subject: [PATCH] Rename id to uuid for consistency - Use the term "uuid" wherever a uuid is assigned - Avoid inconsistent variable naming --- pfdl_scheduler/petri_net/drawer.py | 4 +- pfdl_scheduler/petri_net/generator.py | 480 +++++++++--------- pfdl_scheduler/petri_net/logic.py | 20 +- pfdl_scheduler/scheduler.py | 52 +- pfdl_scheduler/scheduling/event.py | 2 +- pfdl_scheduler/utils/dashboard_observer.py | 14 +- pfdl_scheduler/utils/log_entry_observer.py | 4 +- scheduler_demo.py | 20 +- .../test_scheduling_callbacks.py | 54 +- .../test_scheduling_marking.py | 58 +-- 10 files changed, 359 insertions(+), 349 deletions(-) diff --git a/pfdl_scheduler/petri_net/drawer.py b/pfdl_scheduler/petri_net/drawer.py index 8e5aacf..5327690 100644 --- a/pfdl_scheduler/petri_net/drawer.py +++ b/pfdl_scheduler/petri_net/drawer.py @@ -47,7 +47,7 @@ def draw_place(place, attr): else: attr["xlabel"] = place.name - attr["group"] = place.label("group_id") + attr["group"] = place.label("group_uuid") if 1 in place: attr["label"] = "•" @@ -65,7 +65,7 @@ def draw_transition(trans, attr): attr["height"] = TRANSITION_HEIGHT attr["width"] = TRANSITION_WIDTH attr["fillcolor"] = TRANSITION_FILL_COLOR - attr["group"] = trans.label("group_id") + attr["group"] = trans.label("group_uuid") def draw_arcs(arc, attr): diff --git a/pfdl_scheduler/petri_net/generator.py b/pfdl_scheduler/petri_net/generator.py index 809af2d..e986f9c 100644 --- a/pfdl_scheduler/petri_net/generator.py +++ b/pfdl_scheduler/petri_net/generator.py @@ -37,8 +37,8 @@ class Node(object): - def __init__(self, group_id: str, name="", parent: "Node" = None): - self.group_id: str = group_id + def __init__(self, group_uuid: str, name="", parent: "Node" = None): + self.group_uuid: str = group_uuid self.name: str = name self.children: List[Node] = [] self.cluster = None @@ -54,7 +54,7 @@ def toJSON(self): for child in self.children: child_dict = child.toJSON() children_list.append(child_dict) - json_dict = {"id": self.group_id, "name": self.name, "children": children_list} + json_dict = {"id": self.group_uuid, "name": self.name, "children": children_list} return json_dict @@ -66,8 +66,8 @@ class PetriNetGenerator: net: The snakes Petri Net instance. tasks: A dict representing the Tasks of the given Process object. transition_dict: A dict for mapping the UUIDs of the Transitions to their behavior. - place_dict: A dict for mapping the service id to the place name. - task_started_id: The id of the 'Task started' place. + place_dict: A dict for mapping the service uuid to the place name. + task_started_uuid: The uuid of the 'Task started' place. callbacks: A PetriNetCallbacks instance representing functions called while execution. generate_test_ids: A boolean indicating if test ids (counting from 0) should be generated. used_in_extension: A boolean indicating if the Generator is used within the extension. @@ -104,7 +104,7 @@ def __init__( self.tasks: Dict[str, Task] = None self.transition_dict: OrderedDict = OrderedDict() self.place_dict: Dict = {} - self.task_started_id: str = "" + self.task_started_uuid: str = "" self.callbacks: PetriNetCallbacks = PetriNetCallbacks() self.generate_test_ids: bool = generate_test_ids self.used_in_extension: bool = used_in_extension @@ -112,23 +112,23 @@ def __init__( self.file_name = file_name self.cluster = None - def add_callback(self, transition_id: str, callback_function: Callable, *args: Any) -> None: + def add_callback(self, transition_uuid: str, callback_function: Callable, *args: Any) -> None: """Registers the given callback function in the transition_dict. - If the transition the transition_id refers to is fired, the callback function + If the transition the transition_uuid refers to is fired, the callback function will be called with the given arguments inside the PetriNetLogic class. Args: - transition_id: The UUID of the transition where the callback is called if fired. + transition_uuid: The UUID of the transition where the callback is called if fired. callback_function: The callback function which should be called. *args: Arguments with which the callback function is called. """ if not self.used_in_extension: callback = functools.partial(callback_function, *args) - if transition_id not in self.transition_dict: - self.transition_dict[transition_id] = [] + if transition_uuid not in self.transition_dict: + self.transition_dict[transition_uuid] = [] - self.transition_dict[transition_id].append(callback) + self.transition_dict[transition_uuid].append(callback) def generate_petri_net(self, process: Process) -> PetriNet: """Generates a Petri Net from the given Process object. @@ -143,39 +143,47 @@ def generate_petri_net(self, process: Process) -> PetriNet: self.tasks = process.tasks for task in process.tasks.values(): if task.name == "productionTask": - group_id = str(uuid.uuid4()) - self.tree = Node(group_id, task.name) + group_uuid = str(uuid.uuid4()) + self.tree = Node(group_uuid, task.name) task_context = TaskAPI(task, None) if self.generate_test_ids: task_context.uuid = "0" - self.task_started_id = create_place( - task.name + "_started", self.net, group_id, [0, 0] + self.task_started_uuid = create_place( + task.name + "_started", self.net, group_uuid, [0, 0] ) - connection_id = create_transition("", "", self.net, group_id) + connection_uuid = create_transition("", "", self.net, group_uuid) - self.add_callback(connection_id, self.callbacks.task_started, task_context) + self.add_callback(connection_uuid, self.callbacks.task_started, task_context) - self.net.add_input(self.task_started_id, connection_id, Value(1)) - self.task_finished_id = create_place(task.name + "_finished", self.net, group_id) + self.net.add_input(self.task_started_uuid, connection_uuid, Value(1)) + self.task_finished_uuid = create_place( + task.name + "_finished", self.net, group_uuid + ) - second_connection_id = create_transition("", "", self.net, group_id) + second_connection_uuid = create_transition("", "", self.net, group_uuid) self.tree.cluster = Cluster( [ - self.task_started_id, - connection_id, - second_connection_id, - self.task_finished_id, + self.task_started_uuid, + connection_uuid, + second_connection_uuid, + self.task_finished_uuid, ] ) self.generate_statements( - task_context, task.statements, connection_id, second_connection_id, self.tree + task_context, + task.statements, + connection_uuid, + second_connection_uuid, + self.tree, ) - self.net.add_output(self.task_finished_id, second_connection_id, Value(1)) + self.net.add_output(self.task_finished_uuid, second_connection_uuid, Value(1)) - self.add_callback(second_connection_id, self.callbacks.task_finished, task_context) + self.add_callback( + second_connection_uuid, self.callbacks.task_finished, task_context + ) # assign new clusters before drawing self.net.clusters = self.tree.cluster @@ -194,8 +202,8 @@ def generate_statements( self, task_context: TaskAPI, statements: List, - first_connection_id: str, - last_connection_id: str, + first_connection_uuid: str, + last_connection_uuid: str, node: Node, in_loop: bool = False, ) -> List[str]: @@ -206,12 +214,12 @@ def generate_statements( transition. Returns: - The ids of the last connections (transitions). + The uuids of the last connections (transitions). """ - current_connection_id = "" - previous_connection_id = first_connection_id + current_connection_uuid = "" + previous_connection_uuid = first_connection_uuid - connection_ids = [] + connection_uuids = [] for i, statement in enumerate(statements): multiple_statements = len(statements) > 1 @@ -219,50 +227,50 @@ def generate_statements( # and we are not in the last iteration if multiple_statements: if i < len(statements) - 1: - current_connection_id = create_transition( - "connection", "", self.net, node.group_id + current_connection_uuid = create_transition( + "connection", "", self.net, node.group_uuid ) - node.cluster.add_node(current_connection_id) + node.cluster.add_node(current_connection_uuid) else: - current_connection_id = last_connection_id + current_connection_uuid = last_connection_uuid else: - previous_connection_id = first_connection_id - current_connection_id = last_connection_id + previous_connection_uuid = first_connection_uuid + current_connection_uuid = last_connection_uuid args = ( statement, task_context, - previous_connection_id, - current_connection_id, + previous_connection_uuid, + current_connection_uuid, node, in_loop, ) if isinstance(statement, Service): - connection_ids = [self.generate_service(*args)] + connection_uuids = [self.generate_service(*args)] elif isinstance(statement, TaskCall): - connection_ids, new_task_context = self.generate_task_call(*args) + connection_uuids, new_task_context = self.generate_task_call(*args) elif isinstance(statement, Parallel): - connection_ids = [self.generate_parallel(*args)] + connection_uuids = [self.generate_parallel(*args)] elif isinstance(statement, CountingLoop): - connection_ids = [self.generate_counting_loop(*args)] + connection_uuids = [self.generate_counting_loop(*args)] elif isinstance(statement, WhileLoop): - connection_ids = [self.generate_while_loop(*args)] + connection_uuids = [self.generate_while_loop(*args)] elif isinstance(statement, Condition): - connection_ids = self.generate_condition(*args) + connection_uuids = self.generate_condition(*args) else: - connection_ids = self.handle_other_statements(*args) + connection_uuids = self.handle_other_statements(*args) - previous_connection_id = current_connection_id + previous_connection_uuid = current_connection_uuid - return connection_ids + return connection_uuids def handle_other_statements( self, statement: Any, task_context: TaskAPI, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, in_loop: bool = False, ) -> List[str]: @@ -272,7 +280,7 @@ def handle_other_statements( if they add new components through their plugin. Returns: - A list of ids of the last transition in the respective component. + A list of uuids of the last transition in the respective component. """ return None @@ -280,115 +288,117 @@ def generate_service( self, service: Service, task_context: TaskAPI, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, in_loop: bool = False, ) -> str: """Generate the Petri Net components for a Service Call. Returns: - The id of the last transition of the Service petri net component. + The uuid of the last transition of the Service petri net component. """ - group_id = str(uuid.uuid4()) - Node(group_id, service.name, node) + group_uuid = str(uuid.uuid4()) + Node(group_uuid, service.name, node) service_api = ServiceAPI(service, task_context, in_loop=in_loop) - service_started_id = create_place(service.name + " started", self.net, group_id) - service_finished_id = create_place(service.name + " finished", self.net, group_id) + service_started_uuid = create_place(service.name + " started", self.net, group_uuid) + service_finished_uuid = create_place(service.name + " finished", self.net, group_uuid) - self.place_dict[service_api.uuid] = service_finished_id + self.place_dict[service_api.uuid] = service_finished_uuid - service_done_id = create_place(service.name + " done", self.net, group_id) - service_done_transition_id = create_transition("service_done", "", self.net, group_id) + service_done_uuid = create_place(service.name + " done", self.net, group_uuid) + service_done_transition_uuid = create_transition("service_done", "", self.net, group_uuid) - self.add_callback(first_transition_id, self.callbacks.service_started, service_api) - self.add_callback(service_done_transition_id, self.callbacks.service_finished, service_api) + self.add_callback(first_transition_uuid, self.callbacks.service_started, service_api) + self.add_callback( + service_done_transition_uuid, self.callbacks.service_finished, service_api + ) - self.net.add_input(service_started_id, service_done_transition_id, Value(1)) - self.net.add_input(service_finished_id, service_done_transition_id, Value(1)) - self.net.add_output(service_done_id, service_done_transition_id, Value(1)) + self.net.add_input(service_started_uuid, service_done_transition_uuid, Value(1)) + self.net.add_input(service_finished_uuid, service_done_transition_uuid, Value(1)) + self.net.add_output(service_done_uuid, service_done_transition_uuid, Value(1)) - self.net.add_output(service_started_id, first_transition_id, Value(1)) - self.net.add_input(service_done_id, second_transition_id, Value(1)) + self.net.add_output(service_started_uuid, first_transition_uuid, Value(1)) + self.net.add_input(service_done_uuid, second_transition_uuid, Value(1)) node.cluster.add_child( ( Cluster( [ - service_started_id, - service_finished_id, - service_done_transition_id, - service_done_id, + service_started_uuid, + service_finished_uuid, + service_done_transition_uuid, + service_done_uuid, ] ) ) ) - return service_done_transition_id + return service_done_transition_uuid def generate_task_call( self, task_call: TaskCall, task_context: TaskAPI, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, in_loop: bool = False, ) -> List[str]: """Generate the Petri Net components for a Task Call. Returns: - The ids of the last transitions of the TaskCall petri net component. + The uuids of the last transitions of the TaskCall petri net component. """ called_task = self.tasks[task_call.name] new_task_context = TaskAPI(called_task, task_context, task_call=task_call, in_loop=in_loop) - group_id = str(uuid.uuid4()) - task_node = Node(group_id, task_call.name, node) + group_uuid = str(uuid.uuid4()) + task_node = Node(group_uuid, task_call.name, node) task_cluster = Cluster([]) node.cluster.add_child(task_cluster) task_node.cluster = task_cluster # Order for callbacks important: Task starts before statement and finishes after - self.add_callback(first_transition_id, self.callbacks.task_started, new_task_context) - last_connection_ids = self.generate_statements( + self.add_callback(first_transition_uuid, self.callbacks.task_started, new_task_context) + last_connection_uuids = self.generate_statements( new_task_context, called_task.statements, - first_transition_id, - second_transition_id, + first_transition_uuid, + second_transition_uuid, task_node, in_loop, ) - for last_connection_id in last_connection_ids: - self.add_callback(last_connection_id, self.callbacks.task_finished, new_task_context) + for last_connection_uuid in last_connection_uuids: + self.add_callback(last_connection_uuid, self.callbacks.task_finished, new_task_context) - return last_connection_ids, new_task_context + return last_connection_uuids, new_task_context def generate_parallel( self, parallel: Parallel, task_context: TaskAPI, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, in_loop: bool = False, ) -> str: """Generate the Petri Net components for a Parallel statement. Returns: - The id of the last transition of the Parallel petri net component. + The uuid of the last transition of the Parallel petri net component. """ - group_id = str(uuid.uuid4()) - parallel_node = Node(group_id, "Parallel", node) + group_uuid = str(uuid.uuid4()) + parallel_node = Node(group_uuid, "Parallel", node) - sync_id = create_transition("", "", self.net, group_id) - parallel_finished_id = create_place("Parallel finished", self.net, group_id) + sync_uuid = create_transition("", "", self.net, group_uuid) + parallel_finished_uuid = create_place("Parallel finished", self.net, group_uuid) - cluster = Cluster([], Cluster([sync_id, parallel_finished_id])) + cluster = Cluster([], Cluster([sync_uuid, parallel_finished_uuid])) node.cluster.add_child(cluster) parallel_node.cluster = cluster @@ -397,58 +407,58 @@ def generate_parallel( cluster.add_child(parallel_cluster) parallel_node.cluster = parallel_cluster self.generate_task_call( - task_call, task_context, first_transition_id, sync_id, parallel_node, in_loop + task_call, task_context, first_transition_uuid, sync_uuid, parallel_node, in_loop ) - self.net.add_output(parallel_finished_id, sync_id, Value(1)) - self.net.add_input(parallel_finished_id, second_transition_id, Value(1)) - return sync_id + self.net.add_output(parallel_finished_uuid, sync_uuid, Value(1)) + self.net.add_input(parallel_finished_uuid, second_transition_uuid, Value(1)) + return sync_uuid def generate_condition( self, condition: Condition, task_context: TaskAPI, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, in_loop: bool = False, ) -> List[str]: """Generate Petri Net components for the Condition statement. Returns: - The ids of the last transitions of the Condition petri net component. + The uuids of the last transitions of the Condition petri net component. """ - group_id = str(uuid.uuid4()) - condition_node = Node(group_id, "Condition", node) + group_uuid = str(uuid.uuid4()) + condition_node = Node(group_uuid, "Condition", node) - passed_id = create_place("Passed", self.net, group_id) - failed_id = create_place("Failed", self.net, group_id) + passed_uuid = create_place("Passed", self.net, group_uuid) + failed_uuid = create_place("Failed", self.net, group_uuid) - expression_id = create_place( + expression_uuid = create_place( "If " + self.parse_expression(condition.expression), self.net, - group_id, + group_uuid, ) - first_passed_transition_id = create_transition("", "", self.net, group_id) - first_failed_transition_id = create_transition("", "", self.net, group_id) + first_passed_transition_uuid = create_transition("", "", self.net, group_uuid) + first_failed_transition_uuid = create_transition("", "", self.net, group_uuid) - self.net.add_input(expression_id, first_passed_transition_id, Value(1)) - self.net.add_input(expression_id, first_failed_transition_id, Value(1)) + self.net.add_input(expression_uuid, first_passed_transition_uuid, Value(1)) + self.net.add_input(expression_uuid, first_failed_transition_uuid, Value(1)) - self.net.add_input(passed_id, first_passed_transition_id, Value(1)) - self.net.add_input(failed_id, first_failed_transition_id, Value(1)) + self.net.add_input(passed_uuid, first_passed_transition_uuid, Value(1)) + self.net.add_input(failed_uuid, first_failed_transition_uuid, Value(1)) - finished_id = create_place("Condition_Finished", self.net, group_id) + finished_uuid = create_place("Condition_Finished", self.net, group_uuid) - second_passed_transition_id = create_transition("", "", self.net, group_id) - self.net.add_output(finished_id, second_passed_transition_id, Value(1)) + second_passed_transition_uuid = create_transition("", "", self.net, group_uuid) + self.net.add_output(finished_uuid, second_passed_transition_uuid, Value(1)) - cluster = Cluster([passed_id, failed_id, expression_id, finished_id]) + cluster = Cluster([passed_uuid, failed_uuid, expression_uuid, finished_uuid]) node.cluster.add_child(cluster) - cluster_passed = Cluster([first_passed_transition_id, second_passed_transition_id]) - cluster_failed = Cluster([first_failed_transition_id]) + cluster_passed = Cluster([first_passed_transition_uuid, second_passed_transition_uuid]) + cluster_failed = Cluster([first_failed_transition_uuid]) cluster.add_child(cluster_passed) cluster.add_child(cluster_failed) condition_node.cluster = cluster_passed @@ -456,86 +466,86 @@ def generate_condition( self.generate_statements( task_context, condition.passed_stmts, - first_passed_transition_id, - second_passed_transition_id, + first_passed_transition_uuid, + second_passed_transition_uuid, condition_node, in_loop, ) - self.net.add_output(expression_id, first_transition_id, Value(1)) - self.net.add_input(finished_id, second_transition_id, Value(1)) + self.net.add_output(expression_uuid, first_transition_uuid, Value(1)) + self.net.add_input(finished_uuid, second_transition_uuid, Value(1)) - args = (condition, passed_id, failed_id, task_context) - self.add_callback(first_transition_id, self.callbacks.condition_started, *args) + args = (condition, passed_uuid, failed_uuid, task_context) + self.add_callback(first_transition_uuid, self.callbacks.condition_started, *args) if condition.failed_stmts: condition_node.cluster = cluster_failed - second_failed_transition_id = create_transition("", "", self.net, group_id) - cluster_failed.add_node(second_failed_transition_id) + second_failed_transition_uuid = create_transition("", "", self.net, group_uuid) + cluster_failed.add_node(second_failed_transition_uuid) self.generate_statements( task_context, condition.failed_stmts, - first_failed_transition_id, - second_failed_transition_id, + first_failed_transition_uuid, + second_failed_transition_uuid, condition_node, in_loop, ) - self.net.add_output(finished_id, second_failed_transition_id, Value(1)) - return [second_passed_transition_id, second_failed_transition_id] + self.net.add_output(finished_uuid, second_failed_transition_uuid, Value(1)) + return [second_passed_transition_uuid, second_failed_transition_uuid] else: - self.net.add_output(finished_id, first_failed_transition_id, Value(1)) - return [second_passed_transition_id, first_failed_transition_id] + self.net.add_output(finished_uuid, first_failed_transition_uuid, Value(1)) + return [second_passed_transition_uuid, first_failed_transition_uuid] def generate_counting_loop( self, loop: CountingLoop, task_context: TaskAPI, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, in_loop: bool = False, ) -> str: """Generates the Petri Net components for a Couting Loop. Returns: - The id of the last transition of the CountingLoop petri net component. + The uuid of the last transition of the CountingLoop petri net component. """ if loop.parallel: return self.generate_parallel_loop( - loop, task_context, first_transition_id, second_transition_id, node + loop, task_context, first_transition_uuid, second_transition_uuid, node ) - group_id = str(uuid.uuid4()) - counting_loop_node = Node(group_id, "Counting Loop", node) - loop_id = create_place("Loop", self.net, group_id) + group_uuid = str(uuid.uuid4()) + counting_loop_node = Node(group_uuid, "Counting Loop", node) + loop_uuid = create_place("Loop", self.net, group_uuid) loop_text = "Loop" - loop_statements_id = create_place(loop_text, self.net, group_id) - loop_finished_id = create_place("Number of Steps Done", self.net, group_id) + loop_statements_uuid = create_place(loop_text, self.net, group_uuid) + loop_finished_uuid = create_place("Number of Steps Done", self.net, group_uuid) - condition_passed_transition_id = create_transition("", "", self.net, group_id) - condition_failed_transition_id = create_transition("", "", self.net, group_id) - iteration_step_done_transition_id = create_transition("", "", self.net, group_id) + condition_passed_transition_uuid = create_transition("", "", self.net, group_uuid) + condition_failed_transition_uuid = create_transition("", "", self.net, group_uuid) + iteration_step_done_transition_uuid = create_transition("", "", self.net, group_uuid) - self.net.add_input(loop_id, condition_passed_transition_id, Value(1)) - self.net.add_input(loop_statements_id, condition_passed_transition_id, Value(1)) - self.net.add_input(loop_id, condition_failed_transition_id, Value(1)) - self.net.add_input(loop_finished_id, condition_failed_transition_id, Value(1)) - self.net.add_output(loop_id, iteration_step_done_transition_id, Value(1)) + self.net.add_input(loop_uuid, condition_passed_transition_uuid, Value(1)) + self.net.add_input(loop_statements_uuid, condition_passed_transition_uuid, Value(1)) + self.net.add_input(loop_uuid, condition_failed_transition_uuid, Value(1)) + self.net.add_input(loop_finished_uuid, condition_failed_transition_uuid, Value(1)) + self.net.add_output(loop_uuid, iteration_step_done_transition_uuid, Value(1)) - loop_done_id = create_place("Loop Done", self.net, group_id) + loop_done_uuid = create_place("Loop Done", self.net, group_uuid) cluster = Cluster( [ - loop_id, - loop_statements_id, - loop_finished_id, - condition_passed_transition_id, - condition_failed_transition_id, - iteration_step_done_transition_id, - loop_done_id, + loop_uuid, + loop_statements_uuid, + loop_finished_uuid, + condition_passed_transition_uuid, + condition_failed_transition_uuid, + iteration_step_done_transition_uuid, + loop_done_uuid, ] ) @@ -545,30 +555,30 @@ def generate_counting_loop( self.generate_statements( task_context, loop.statements, - condition_passed_transition_id, - iteration_step_done_transition_id, + condition_passed_transition_uuid, + iteration_step_done_transition_uuid, counting_loop_node, True, ) - self.net.add_output(loop_done_id, condition_failed_transition_id, Value(1)) - self.net.add_output(loop_id, first_transition_id, Value(1)) - self.net.add_input(loop_done_id, second_transition_id, Value(1)) + self.net.add_output(loop_done_uuid, condition_failed_transition_uuid, Value(1)) + self.net.add_output(loop_uuid, first_transition_uuid, Value(1)) + self.net.add_input(loop_done_uuid, second_transition_uuid, Value(1)) - args = (loop, loop_statements_id, loop_finished_id, task_context) - self.add_callback(first_transition_id, self.callbacks.counting_loop_started, *args) + args = (loop, loop_statements_uuid, loop_finished_uuid, task_context) + self.add_callback(first_transition_uuid, self.callbacks.counting_loop_started, *args) self.add_callback( - iteration_step_done_transition_id, self.callbacks.counting_loop_started, *args + iteration_step_done_transition_uuid, self.callbacks.counting_loop_started, *args ) - return condition_failed_transition_id + return condition_failed_transition_uuid def generate_parallel_loop( self, loop: CountingLoop, task_context: TaskAPI, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, ) -> str: """Generates the static petri net components for a ParallelLoop. @@ -577,101 +587,101 @@ def generate_parallel_loop( of parallel startet Tasks is only known at runtime. Returns: - The id of the last transition of the ParallelLoop petri net component. + The uuid of the last transition of the ParallelLoop petri net component. """ - group_id = str(uuid.uuid4()) - parallel_loop_node = Node(group_id, "Parallel Loop", node) + group_uuid = str(uuid.uuid4()) + parallel_loop_node = Node(group_uuid, "Parallel Loop", node) parallel_loop_started = create_place( "Start " + loop.statements[0].name + " in parallel", self.net, - group_id, + group_uuid, ) cluster = Cluster([parallel_loop_started]) node.cluster.add_child(cluster) parallel_loop_node.cluster = cluster - self.net.add_output(parallel_loop_started, first_transition_id, Value(1)) - self.net.add_input(parallel_loop_started, second_transition_id, Value(1)) + self.net.add_output(parallel_loop_started, first_transition_uuid, Value(1)) + self.net.add_input(parallel_loop_started, second_transition_uuid, Value(1)) args = ( loop, task_context, loop.statements[0], parallel_loop_started, - first_transition_id, - second_transition_id, + first_transition_uuid, + second_transition_uuid, parallel_loop_node, ) - self.add_callback(first_transition_id, self.callbacks.parallel_loop_started, *args) - return second_transition_id + self.add_callback(first_transition_uuid, self.callbacks.parallel_loop_started, *args) + return second_transition_uuid - def remove_place_on_runtime(self, place_id: str) -> None: + def remove_place_on_runtime(self, place_uuid: str) -> None: """Removes a place from the petri net at runtime. Args: - place_id: The id as string of the task which should be removed from the net. + place_uuid: The uuid as string of the task which should be removed from the net. """ - if self.net.has_place(place_id): + if self.net.has_place(place_uuid): # temporary fix - # self.net.clusters.remove_node(self.task_started_id) - # self.net.remove_place(self.task_started_id) + # self.net.clusters.remove_node(self.task_started_uuid) + # self.net.remove_place(self.task_started_uuid) if self.draw_net: draw_petri_net(self.net, self.path_for_image) def generate_empty_parallel_loop( - self, first_transition_id: str, second_transition_id: str + self, first_transition_uuid: str, second_transition_uuid: str ) -> None: empty_loop_place = create_place("Execute 0 tasks", self.net) - self.net.add_output(empty_loop_place, first_transition_id, Value(1)) - self.net.add_input(empty_loop_place, second_transition_id, Value(1)) + self.net.add_output(empty_loop_place, first_transition_uuid, Value(1)) + self.net.add_input(empty_loop_place, second_transition_uuid, Value(1)) def generate_while_loop( self, loop: CountingLoop, task_context: TaskAPI, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, in_loop: bool = False, ) -> str: """Generate the Petri Net components for a While Loop. Returns: - The id of the last transition of the WhileLoop petri net component. + The uuid of the last transition of the WhileLoop petri net component. """ - group_id = str(uuid.uuid4()) - while_loop_node = Node(group_id, "While Loop", node) + group_uuid = str(uuid.uuid4()) + while_loop_node = Node(group_uuid, "While Loop", node) - loop_id = create_place("Loop", self.net, group_id) + loop_uuid = create_place("Loop", self.net, group_uuid) loop_text = "Loop" - loop_statements_id = create_place(loop_text, self.net, group_id) - loop_finished_id = create_place("Number of Steps Done", self.net, group_id) + loop_statements_uuid = create_place(loop_text, self.net, group_uuid) + loop_finished_uuid = create_place("Number of Steps Done", self.net, group_uuid) - condition_passed_transition_id = create_transition("", "", self.net, group_id) - condition_failed_transition_id = create_transition("", "", self.net, group_id) - iteration_step_done_transition_id = create_transition("", "", self.net, group_id) + condition_passed_transition_uuid = create_transition("", "", self.net, group_uuid) + condition_failed_transition_uuid = create_transition("", "", self.net, group_uuid) + iteration_step_done_transition_uuid = create_transition("", "", self.net, group_uuid) - self.net.add_input(loop_id, condition_passed_transition_id, Value(1)) - self.net.add_input(loop_statements_id, condition_passed_transition_id, Value(1)) - self.net.add_input(loop_id, condition_failed_transition_id, Value(1)) - self.net.add_input(loop_finished_id, condition_failed_transition_id, Value(1)) - self.net.add_output(loop_id, iteration_step_done_transition_id, Value(1)) + self.net.add_input(loop_uuid, condition_passed_transition_uuid, Value(1)) + self.net.add_input(loop_statements_uuid, condition_passed_transition_uuid, Value(1)) + self.net.add_input(loop_uuid, condition_failed_transition_uuid, Value(1)) + self.net.add_input(loop_finished_uuid, condition_failed_transition_uuid, Value(1)) + self.net.add_output(loop_uuid, iteration_step_done_transition_uuid, Value(1)) - loop_done_id = create_place("Loop Done", self.net, group_id) + loop_done_uuid = create_place("Loop Done", self.net, group_uuid) cluster = Cluster( [ - loop_id, - loop_statements_id, - loop_finished_id, - condition_failed_transition_id, - loop_done_id, - condition_passed_transition_id, - iteration_step_done_transition_id, + loop_uuid, + loop_statements_uuid, + loop_finished_uuid, + condition_failed_transition_uuid, + loop_done_uuid, + condition_passed_transition_uuid, + iteration_step_done_transition_uuid, ] ) @@ -680,24 +690,24 @@ def generate_while_loop( self.generate_statements( task_context, loop.statements, - condition_passed_transition_id, - iteration_step_done_transition_id, + condition_passed_transition_uuid, + iteration_step_done_transition_uuid, while_loop_node, True, ) - self.net.add_output(loop_id, first_transition_id, Value(1)) - self.net.add_input(loop_done_id, second_transition_id, Value(1)) + self.net.add_output(loop_uuid, first_transition_uuid, Value(1)) + self.net.add_input(loop_done_uuid, second_transition_uuid, Value(1)) - args = (loop, loop_statements_id, loop_finished_id, task_context) - self.add_callback(first_transition_id, self.callbacks.while_loop_started, *args) + args = (loop, loop_statements_uuid, loop_finished_uuid, task_context) + self.add_callback(first_transition_uuid, self.callbacks.while_loop_started, *args) self.add_callback( - iteration_step_done_transition_id, self.callbacks.while_loop_started, *args + iteration_step_done_transition_uuid, self.callbacks.while_loop_started, *args ) - self.net.add_output(loop_done_id, condition_failed_transition_id, Value(1)) + self.net.add_output(loop_done_uuid, condition_failed_transition_uuid, Value(1)) - return condition_failed_transition_id + return condition_failed_transition_uuid def parse_expression(self, expression: Dict) -> str: """Parses the given expression to a printable format. @@ -727,7 +737,7 @@ def parse_expression(self, expression: Dict) -> str: ) -def create_place(name: str, net: PetriNet, group_id: str, cluster: List = []) -> str: +def create_place(name: str, net: PetriNet, group_uuid: str, cluster: List = []) -> str: """Utility function for creating a place with the snakes module. This function is used to add a place with the given name and to add labels for @@ -736,19 +746,19 @@ def create_place(name: str, net: PetriNet, group_id: str, cluster: List = []) -> Args: name: A string representing the displayed name of the place. net: The petri net instance this place should be added to. - group_id: + group_uuid: Returns: A UUID as string for the added place. """ - place_id = str(uuid.uuid4()) - net.add_place(Place(place_id, []), cluster=cluster) - net.place(place_id).label(name=name, group_id=group_id) - return place_id + place_uuid = str(uuid.uuid4()) + net.add_place(Place(place_uuid, []), cluster=cluster) + net.place(place_uuid).label(name=name, group_uuid=group_uuid) + return place_uuid def create_transition( - transition_name: str, transition_type: str, net: PetriNet, group_id: str + transition_name: str, transition_type: str, net: PetriNet, group_uuid: str ) -> str: """Utility function for creating a transition with the snakes module. @@ -758,16 +768,16 @@ def create_transition( Args: transition_name: A string representing the displayed name of the transition. net: The petri net instance this transition should be added to. - group_id: + group_uuid: Returns: A UUID as string for the added transition. """ - transition_id = str(uuid.uuid4()) - net.add_transition(Transition(transition_id)) - net.transition(transition_id).label( + transition_uuid = str(uuid.uuid4()) + net.add_transition(Transition(transition_uuid)) + net.transition(transition_uuid).label( name=transition_name, transitionType=transition_type, - group_id=group_id, + group_uuid=group_uuid, ) - return transition_id + return transition_uuid diff --git a/pfdl_scheduler/petri_net/logic.py b/pfdl_scheduler/petri_net/logic.py index df7fae6..7916183 100644 --- a/pfdl_scheduler/petri_net/logic.py +++ b/pfdl_scheduler/petri_net/logic.py @@ -30,7 +30,7 @@ class PetriNetLogic: petri_net_generator: A reference to the PetriNetGenerator. petri_net: A reference to the generated petri net. draw_net: Indiciating whether the net should be drawn. - transition_dict: A reference to the dict in the generator which maps the ids to callbacks. + transition_dict: A reference to the dict in the generator which maps the uuids to callbacks. """ def __init__( @@ -73,11 +73,11 @@ def evaluate_petri_net(self) -> None: transitions = list(self.petri_net._trans) while index < len(transitions): - transition_id = transitions[index] + transition_uuid = transitions[index] - if self.petri_net.transition(transition_id).enabled(Value(1)): - if transition_id in self.transition_dict: - callbacks = self.transition_dict[transition_id] + if self.petri_net.transition(transition_uuid).enabled(Value(1)): + if transition_uuid in self.transition_dict: + callbacks = self.transition_dict[transition_uuid] temp = None for callback in callbacks: @@ -93,12 +93,12 @@ def evaluate_petri_net(self) -> None: temp() return else: - self.petri_net.transition(transition_id).fire(Value(1)) + self.petri_net.transition(transition_uuid).fire(Value(1)) for callback in callbacks: callback() else: - self.petri_net.transition(transition_id).fire(Value(1)) + self.petri_net.transition(transition_uuid).fire(Value(1)) index = 0 else: @@ -115,11 +115,11 @@ def fire_event(self, event: Event) -> bool: name_in_petri_net = "" if event.event_type == START_PRODUCTION_TASK: - name_in_petri_net = self.petri_net_generator.task_started_id + name_in_petri_net = self.petri_net_generator.task_started_uuid elif event.event_type == SET_PLACE: - name_in_petri_net = event.data["place_id"] + name_in_petri_net = event.data["place_uuid"] elif event.event_type == SERVICE_FINISHED: - name_in_petri_net = self.petri_net_generator.place_dict[event.data["service_id"]] + name_in_petri_net = self.petri_net_generator.place_dict[event.data["service_uuid"]] if self.petri_net.has_place(name_in_petri_net): self.petri_net.place(name_in_petri_net).add(1) diff --git a/pfdl_scheduler/scheduler.py b/pfdl_scheduler/scheduler.py index 9f05c7b..216bd22 100644 --- a/pfdl_scheduler/scheduler.py +++ b/pfdl_scheduler/scheduler.py @@ -63,7 +63,7 @@ class Scheduler(Subject): petri_net_logic: A PetriNetLogic instance for execution of the petri net. task_callbacks: TaskCallbacks instance which holds the registered callbacks. variable_access_function: The function which will be called when the scheduler needs a variable. - loop_counters: A dict for mapping task ids to the current loop counter (counting loops). + loop_counters: A dict for mapping task uuids to the current loop counter (counting loops). awaited_events: A list of awaited `Event`s. Only these events can be passed to the net. generate_test_ids: Indicates whether test ids should be generated. test_id_counters: A List consisting of counters for the test ids of tasks and services. @@ -75,7 +75,7 @@ def __init__( pfdl_program: str, generate_test_ids: bool = False, draw_petri_net: bool = True, - scheduler_id: str = "", + scheduler_uuid: str = "", dashboard_host_address: str = "", ) -> None: """Initialize the object. @@ -90,10 +90,10 @@ def __init__( pfdl_program: A path to the PFDL file or directly the PFDL program as a string. generate_test_ids: A boolean indicating whether test ids should be generated. draw_petri_net: A boolean indicating whether the petri net should be drawn. - scheduler_id: A unique ID to identify the Scheduer / Production Order + scheduler_uuid: A unique ID to identify the Scheduer / Production Order dashboard_host_address: The address of the Dashboard (if existing) """ - self.init_scheduler(scheduler_id, generate_test_ids) + self.init_scheduler(scheduler_uuid, generate_test_ids) self.pfdl_file_valid, self.process, pfdl_string = parse_program(pfdl_program) if self.pfdl_file_valid: @@ -101,23 +101,23 @@ def __init__( "", generate_test_ids=self.generate_test_ids, draw_net=draw_petri_net, - file_name=self.scheduler_id, + file_name=self.scheduler_uuid, ) self.setup_scheduling(draw_petri_net) # enable logging - # self.attach(LogEntryObserver(self.scheduler_id)) + # self.attach(LogEntryObserver(self.scheduler_uuid)) if dashboard_host_address != "": self.attach( - DashboardObserver(dashboard_host_address, self.scheduler_id, pfdl_string) + DashboardObserver(dashboard_host_address, self.scheduler_uuid, pfdl_string) ) - def init_scheduler(self, scheduler_id: str, generate_test_ids: bool): - if scheduler_id == "": - self.scheduler_id: str = str(uuid.uuid4()) + def init_scheduler(self, scheduler_uuid: str, generate_test_ids: bool): + if scheduler_uuid == "": + self.scheduler_uuid: str = str(uuid.uuid4()) else: - self.scheduler_id: str = scheduler_id + self.scheduler_uuid: str = scheduler_uuid self.running: bool = False self.pfdl_file_valid: bool = False self.process: Process = None @@ -136,7 +136,7 @@ def setup_scheduling(self, draw_petri_net: bool): self.petri_net_generator.generate_petri_net(self.process) self.petri_net_logic = PetriNetLogic( - self.petri_net_generator, draw_petri_net, file_name=self.scheduler_id + self.petri_net_generator, draw_petri_net, file_name=self.scheduler_uuid ) awaited_event = Event(event_type=START_PRODUCTION_TASK, data={}) @@ -189,7 +189,7 @@ def fire_event(self, event: Event) -> bool: if event in self.awaited_events: if self.petri_net_logic.fire_event(event): self.awaited_events.remove(event) - self.notify(NotificationType.PETRI_NET, self.scheduler_id) + self.notify(NotificationType.PETRI_NET, self.scheduler_uuid) return True return False @@ -337,7 +337,7 @@ def on_service_started(self, service_api: ServiceAPI) -> None: ] service_api.uuid = new_uuid - awaited_event = Event(event_type=SERVICE_FINISHED, data={"service_id": service_api.uuid}) + awaited_event = Event(event_type=SERVICE_FINISHED, data={"service_uuid": service_api.uuid}) self.awaited_events.append(awaited_event) for callback in self.task_callbacks.service_started: @@ -367,11 +367,11 @@ def on_condition_started( ) -> None: """Executes Scheduling logic when a Condition statement is started.""" if self.check_expression(condition.expression, task_context): - awaited_event = Event(event_type=SET_PLACE, data={"place_id": then_uuid}) + awaited_event = Event(event_type=SET_PLACE, data={"place_uuid": then_uuid}) self.awaited_events.append(awaited_event) self.fire_event(awaited_event) else: - awaited_event = Event(event_type=SET_PLACE, data={"place_id": else_uuid}) + awaited_event = Event(event_type=SET_PLACE, data={"place_uuid": else_uuid}) self.awaited_events.append(awaited_event) self.fire_event(awaited_event) @@ -380,11 +380,11 @@ def on_while_loop_started( ) -> None: """Executes Scheduling logic when a While Loop is started.""" if self.check_expression(loop.expression, task_context): - awaited_event = Event(event_type=SET_PLACE, data={"place_id": then_uuid}) + awaited_event = Event(event_type=SET_PLACE, data={"place_uuid": then_uuid}) self.awaited_events.append(awaited_event) self.fire_event(awaited_event) else: - awaited_event = Event(event_type=SET_PLACE, data={"place_id": else_uuid}) + awaited_event = Event(event_type=SET_PLACE, data={"place_uuid": else_uuid}) self.awaited_events.append(awaited_event) self.fire_event(awaited_event) @@ -407,12 +407,12 @@ def on_counting_loop_started( loop_limit = self.get_loop_limit(loop, task_context) if loop_counter < loop_limit: - awaited_event = Event(event_type=SET_PLACE, data={"place_id": then_uuid}) + awaited_event = Event(event_type=SET_PLACE, data={"place_uuid": then_uuid}) self.awaited_events.append(awaited_event) self.fire_event(awaited_event) else: - awaited_event = Event(event_type=SET_PLACE, data={"place_id": else_uuid}) + awaited_event = Event(event_type=SET_PLACE, data={"place_uuid": else_uuid}) self.awaited_events.append(awaited_event) # loop is done so reset loop counter for this task context @@ -428,8 +428,8 @@ def on_parallel_loop_started( task_context: TaskAPI, parallelTask: Task, parallel_loop_started, - first_transition_id: str, - second_transition_id: str, + first_transition_uuid: str, + second_transition_uuid: str, node: Node, ) -> None: """Executes Scheduling logic when a Parallel Loop is started.""" @@ -441,8 +441,8 @@ def on_parallel_loop_started( self.petri_net_generator.generate_task_call( parallelTask, task_context, - first_transition_id, - second_transition_id, + first_transition_uuid, + second_transition_uuid, node, False, ) @@ -454,7 +454,7 @@ def on_parallel_loop_started( ] = ParallelLoopCounter() else: self.petri_net_generator.generate_empty_parallel_loop( - first_transition_id, second_transition_id + first_transition_uuid, second_transition_uuid ) self.petri_net_generator.remove_place_on_runtime(parallel_loop_started) @@ -484,7 +484,7 @@ def on_task_finished(self, task_api: TaskAPI) -> None: self.running = False order_finished = True self.petri_net_logic.draw_petri_net() - self.notify(NotificationType.PETRI_NET, self.scheduler_id) + self.notify(NotificationType.PETRI_NET, self.scheduler_uuid) log_entry = "Task " + task_api.task.name + " with UUID '" + task_api.uuid + "' finished." self.notify(NotificationType.LOG_EVENT, (log_entry, logging.INFO, order_finished)) diff --git a/pfdl_scheduler/scheduling/event.py b/pfdl_scheduler/scheduling/event.py index 664a342..2fec82f 100644 --- a/pfdl_scheduler/scheduling/event.py +++ b/pfdl_scheduler/scheduling/event.py @@ -22,7 +22,7 @@ class Event: """Data class for controlling the PetriNet instance. Currently avaiable Events: - - Event(event_type="service_finished", data={"service_id": }) + - Event(event_type="service_finished", data={"service_uuid": }) Attributes: event_type: A string representing the type of the event. diff --git a/pfdl_scheduler/utils/dashboard_observer.py b/pfdl_scheduler/utils/dashboard_observer.py index 4635deb..f23cb84 100644 --- a/pfdl_scheduler/utils/dashboard_observer.py +++ b/pfdl_scheduler/utils/dashboard_observer.py @@ -39,9 +39,9 @@ class DashboardObserver(Observer): The Observer will send a post request to the dashboard with the data. """ - def __init__(self, host: str, scheduler_id: str, pfdl_string: str) -> None: + def __init__(self, host: str, scheduler_uuid: str, pfdl_string: str) -> None: self.host: str = host - self.scheduler_id: str = scheduler_id + self.scheduler_uuid: str = scheduler_uuid current_timestamp: int = int(round(datetime.timestamp(datetime.now()))) self.starting_date: int = current_timestamp self.pfdl_string: str = pfdl_string @@ -50,7 +50,7 @@ def __init__(self, host: str, scheduler_id: str, pfdl_string: str) -> None: threading.Thread(target=send_post_requests, daemon=True).start() request_data = { - "order_id": scheduler_id, + "order_uuid": scheduler_uuid, "starting_date": current_timestamp, "last_update": current_timestamp, "status": 2, @@ -63,11 +63,11 @@ def update(self, notification_type: NotificationType, data: Any) -> None: if notification_type == NotificationType.PETRI_NET: if not self.order_finished: content = "" - with open("temp/" + self.scheduler_id + ".dot") as file: + with open("temp/" + self.scheduler_uuid + ".dot") as file: content = file.read() request_data = { - "order_id": self.scheduler_id, + "order_uuid": self.scheduler_uuid, "content": content, "type_pn": "dot", } @@ -82,7 +82,7 @@ def update(self, notification_type: NotificationType, data: Any) -> None: self.order_finished = True request_data = { - "order_id": self.scheduler_id, + "order_uuid": self.scheduler_uuid, "log_message": log_event, "log_date": int(round(datetime.timestamp(datetime.now()))), "log_level": log_level, @@ -94,7 +94,7 @@ def update(self, notification_type: NotificationType, data: Any) -> None: order_status = 4 request_data = { - "order_id": self.scheduler_id, + "order_uuid": self.scheduler_uuid, "starting_date": self.starting_date, "last_update": int(round(datetime.timestamp(datetime.now()))), "status": order_status, diff --git a/pfdl_scheduler/utils/log_entry_observer.py b/pfdl_scheduler/utils/log_entry_observer.py index 2ff6282..814ae28 100644 --- a/pfdl_scheduler/utils/log_entry_observer.py +++ b/pfdl_scheduler/utils/log_entry_observer.py @@ -24,9 +24,9 @@ class LogEntryObserver(Observer): LogLevels are based of https://docs.python.org/3/library/logging.html#logging-levels """ - def __init__(self, scheduler_id: str): + def __init__(self, scheduler_uuid: str): logging.basicConfig( - filename="temp/" + scheduler_id + ".log", + filename="temp/" + scheduler_uuid + ".log", encoding="utf-8", level=logging.DEBUG, filemode="w", diff --git a/scheduler_demo.py b/scheduler_demo.py index d582f16..de19463 100644 --- a/scheduler_demo.py +++ b/scheduler_demo.py @@ -37,23 +37,23 @@ def __init__(self, scheduler: Scheduler) -> None: def cb_task_started(self, task_api: TaskAPI) -> None: task_name = task_api.task.name - task_id = task_api.uuid - print("Task " + task_name + " with UUID '" + task_id + "' started") + task_uuid = task_api.uuid + print("Task " + task_name + " with UUID '" + task_uuid + "' started") def cb_service_started(self, service_api: ServiceAPI) -> None: service_name = service_api.service.name - service_id = service_api.uuid - print("Service " + service_name + " with UUID '" + service_id + "' started") + service_uuid = service_api.uuid + print("Service " + service_name + " with UUID '" + service_uuid + "' started") def cb_service_finished(self, service_api: ServiceAPI) -> None: service_name = service_api.service.name - service_id = service_api.uuid - print("Service " + service_name + " with UUID '" + service_id + "' finished") + service_uuid = service_api.uuid + print("Service " + service_name + " with UUID '" + service_uuid + "' finished") def cb_task_finished(self, task_api: TaskAPI) -> None: task_name = task_api.task.name - task_id = task_api.uuid - print("Task " + task_name + " with UUID '" + task_id + "' finished") + task_uuid = task_api.uuid + print("Task " + task_name + " with UUID '" + task_uuid + "' finished") def variable_access_function(self, var_name, task_context: TaskAPI) -> Struct: """Simulate a variable access function which returns a Struct variable. @@ -84,10 +84,10 @@ def start(self): while self.scheduler.running: input_str = str(input("Wait for input:>")) splitted = input_str.split(",") - service_id = splitted[0] + service_uuid = splitted[0] event_type = splitted[1] - event = Event(event_type=event_type, data={"service_id": service_id}) + event = Event(event_type=event_type, data={"service_uuid": service_uuid}) self.scheduler.fire_event(event) diff --git a/tests/integration_tests/test_scheduling_callbacks.py b/tests/integration_tests/test_scheduling_callbacks.py index 99d6cd2..c9bded6 100644 --- a/tests/integration_tests/test_scheduling_callbacks.py +++ b/tests/integration_tests/test_scheduling_callbacks.py @@ -86,7 +86,7 @@ def test_simple_task(self) -> None: self.assertEqual(self.task_started_triggered, ["0", "1"]) self.assertEqual(self.service_started_triggered, ["0"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.service_finished_triggered, ["0"]) self.assertEqual(self.task_finished_triggered, ["1", "0"]) @@ -97,7 +97,7 @@ def test_multiple_services(self) -> None: self.assertEqual(self.task_started_triggered, ["0", "1"]) self.assertEqual(self.service_started_triggered, ["0"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.task_started_triggered, []) self.assertEqual(self.task_finished_triggered, []) @@ -105,7 +105,7 @@ def test_multiple_services(self) -> None: self.assertEqual(self.service_finished_triggered, ["0"]) self.assertEqual(self.service_started_triggered, ["1"]) - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertEqual(self.service_finished_triggered, ["1"]) self.assertEqual(self.task_finished_triggered, ["1", "0"]) @@ -120,7 +120,7 @@ def test_parallel_loop(self) -> None: self.assertEqual(self.task_started_triggered, ["0"]) self.assertEqual(self.service_started_triggered, ["0"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.task_started_triggered, ["1", "2", "3"]) self.assertEqual(self.task_finished_triggered, []) @@ -128,17 +128,17 @@ def test_parallel_loop(self) -> None: self.assertEqual(self.service_finished_triggered, ["0"]) self.assertEqual(self.service_started_triggered, ["1", "2", "3"]) - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertEqual(self.service_finished_triggered, ["1"]) self.assertEqual(self.task_finished_triggered, ["1"]) - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertEqual(self.service_finished_triggered, ["2"]) self.assertEqual(self.task_finished_triggered, ["2"]) - self.fire_event(Event("service_finished", data={"service_id": "3"})) + self.fire_event(Event("service_finished", data={"service_uuid": "3"})) self.assertEqual(self.service_finished_triggered, ["3"]) self.assertEqual(self.task_finished_triggered, ["3", "0"]) @@ -149,12 +149,12 @@ def test_parallel_tasks(self) -> None: self.assertEqual(self.task_started_triggered, ["0", "1", "2"]) self.assertEqual(self.service_started_triggered, ["0", "1"]) - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertEqual(self.service_finished_triggered, ["1"]) self.assertEqual(self.task_finished_triggered, ["2"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.service_finished_triggered, ["0"]) self.assertEqual(self.task_finished_triggered, ["1", "0"]) @@ -168,17 +168,17 @@ def test_service_and_condition(self) -> None: self.assertEqual(self.task_started_triggered, ["0", "1"]) self.assertEqual(self.service_started_triggered, ["0"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.service_finished_triggered, ["0"]) self.assertEqual(self.task_finished_triggered, []) - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertEqual(self.service_finished_triggered, ["1"]) self.assertEqual(self.task_finished_triggered, []) - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertEqual(self.service_finished_triggered, ["2"]) self.assertEqual(self.task_finished_triggered, ["1", "0"]) @@ -190,22 +190,22 @@ def test_service_and_condition(self) -> None: self.assertEqual(self.task_started_triggered, ["0", "1"]) self.assertEqual(self.service_started_triggered, ["0"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.service_finished_triggered, ["0"]) self.assertEqual(self.task_finished_triggered, []) - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertEqual(self.service_finished_triggered, ["1"]) self.assertEqual(self.task_finished_triggered, []) - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertEqual(self.service_finished_triggered, ["2"]) self.assertEqual(self.task_finished_triggered, []) - self.fire_event(Event("service_finished", data={"service_id": "3"})) + self.fire_event(Event("service_finished", data={"service_uuid": "3"})) self.assertEqual(self.service_finished_triggered, ["3"]) self.assertEqual(self.task_finished_triggered, ["1", "0"]) @@ -215,23 +215,23 @@ def test_task_synchronisation(self) -> None: self.assertEqual(self.task_started_triggered, ["0", "1", "2"]) self.assertEqual(self.service_started_triggered, ["0", "1"]) - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertEqual(self.service_finished_triggered, ["1"]) self.assertEqual(self.task_finished_triggered, ["2"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.service_finished_triggered, ["0"]) self.assertEqual(self.task_finished_triggered, ["1"]) - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertEqual(self.service_finished_triggered, ["2"]) self.assertEqual(self.task_finished_triggered, ["3", "0"]) def test_counting_loop(self) -> None: - # service and task ids dont follow number order cause of scheduling logic for loops + # service and task uuids dont follow number order cause of scheduling logic for loops self.setup("task_with_counting_loop") # iterate 3 times @@ -241,25 +241,25 @@ def test_counting_loop(self) -> None: self.assertEqual(self.task_started_triggered, ["0", "1"]) self.assertEqual(self.service_started_triggered, ["0"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.service_started_triggered, ["1"]) self.assertEqual(self.service_finished_triggered, ["0"]) self.assertEqual(self.task_started_triggered, ["2"]) - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertEqual(self.service_started_triggered, ["2"]) self.assertEqual(self.service_finished_triggered, ["1"]) self.assertEqual(self.task_started_triggered, ["3"]) - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertEqual(self.service_started_triggered, ["3"]) self.assertEqual(self.service_finished_triggered, ["2"]) self.assertEqual(self.task_started_triggered, ["4"]) - self.fire_event(Event("service_finished", data={"service_id": "3"})) + self.fire_event(Event("service_finished", data={"service_uuid": "3"})) self.assertEqual(self.service_started_triggered, []) self.assertEqual(self.service_finished_triggered, ["3"]) @@ -277,7 +277,7 @@ def test_while_loop(self) -> None: self.assertEqual(self.task_started_triggered, ["0", "1"]) self.assertEqual(self.service_started_triggered, ["0"]) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertEqual(self.service_started_triggered, ["1"]) self.assertEqual(self.service_finished_triggered, ["0"]) @@ -285,7 +285,7 @@ def test_while_loop(self) -> None: wetness = 2 - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertEqual(self.service_started_triggered, ["2"]) self.assertEqual(self.service_finished_triggered, ["1"]) @@ -293,7 +293,7 @@ def test_while_loop(self) -> None: wetness = 1 - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertEqual(self.service_started_triggered, []) self.assertEqual(self.service_finished_triggered, ["2"]) diff --git a/tests/integration_tests/test_scheduling_marking.py b/tests/integration_tests/test_scheduling_marking.py index 59719a5..aed8ccb 100644 --- a/tests/integration_tests/test_scheduling_marking.py +++ b/tests/integration_tests/test_scheduling_marking.py @@ -61,7 +61,7 @@ def fire_event(self, event: Event) -> None: self.scheduler.fire_event(event) def token_in_last_place(self) -> bool: - last_place_marking = {self.scheduler.petri_net_generator.task_finished_id: MultiSet(1)} + last_place_marking = {self.scheduler.petri_net_generator.task_finished_uuid: MultiSet(1)} final_marking = Marking(last_place_marking) return self.petri_net.get_marking() == final_marking @@ -69,7 +69,7 @@ def token_in_last_place(self) -> bool: def test_simple_task(self) -> None: self.setup("simple_task") - event = Event("service_finished", data={"service_id": "0"}) + event = Event("service_finished", data={"service_uuid": "0"}) self.fire_event(event) self.assertTrue(self.token_in_last_place()) @@ -83,7 +83,7 @@ def test_simple_task_with_pfdl_string(self) -> None: # directly pass the pfdl string to the scheduler self.setup(file_content, True) - event = Event("service_finished", data={"service_id": "0"}) + event = Event("service_finished", data={"service_uuid": "0"}) self.fire_event(event) self.assertTrue(self.token_in_last_place()) @@ -91,8 +91,8 @@ def test_simple_task_with_pfdl_string(self) -> None: def test_multiple_services(self) -> None: self.setup("multiple_services") - self.fire_event(Event("service_finished", data={"service_id": "0"})) - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) self.assertTrue(self.token_in_last_place()) @@ -103,18 +103,18 @@ def test_parallel_loop(self) -> None: access_func = lambda var, context: Struct(attributes={"parts_count": 3}) self.scheduler.register_variable_access_function(access_func) - self.fire_event(Event("service_finished", data={"service_id": "0"})) - self.fire_event(Event("service_finished", data={"service_id": "1"})) - self.fire_event(Event("service_finished", data={"service_id": "2"})) - self.fire_event(Event("service_finished", data={"service_id": "3"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "3"})) self.assertTrue(self.token_in_last_place()) def test_parallel_tasks(self) -> None: self.setup("parallel_tasks") - self.fire_event(Event("service_finished", data={"service_id": "1"})) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) self.assertTrue(self.token_in_last_place()) @@ -124,9 +124,9 @@ def test_service_and_condition(self) -> None: access_func = lambda var, context: Struct(attributes={"wetness": 11}) self.scheduler.register_variable_access_function(access_func) - self.fire_event(Event("service_finished", data={"service_id": "0"})) - self.fire_event(Event("service_finished", data={"service_id": "1"})) - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertTrue(self.token_in_last_place()) @@ -135,34 +135,34 @@ def test_service_and_condition(self) -> None: access_func = lambda var, context: Struct(attributes={"wetness": 3}) self.scheduler.register_variable_access_function(access_func) - self.fire_event(Event("service_finished", data={"service_id": "0"})) - self.fire_event(Event("service_finished", data={"service_id": "1"})) - self.fire_event(Event("service_finished", data={"service_id": "2"})) - self.fire_event(Event("service_finished", data={"service_id": "3"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "3"})) self.assertTrue(self.token_in_last_place()) def test_task_synchronisation(self) -> None: self.setup("task_synchronisation") - self.fire_event(Event("service_finished", data={"service_id": "1"})) - self.fire_event(Event("service_finished", data={"service_id": "0"})) - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertTrue(self.token_in_last_place()) def test_counting_loop(self) -> None: - # service and task ids dont follow number order cause of scheduling logic for loops + # service and task uuids dont follow number order cause of scheduling logic for loops self.setup("task_with_counting_loop") # iterate 3 times access_func = lambda var, context: Struct(attributes={"parts_count": 3}) self.scheduler.register_variable_access_function(access_func) - self.fire_event(Event("service_finished", data={"service_id": "0"})) - self.fire_event(Event("service_finished", data={"service_id": "1"})) - self.fire_event(Event("service_finished", data={"service_id": "2"})) - self.fire_event(Event("service_finished", data={"service_id": "3"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "3"})) self.assertTrue(self.token_in_last_place()) @@ -174,13 +174,13 @@ def test_while_loop(self) -> None: access_func = lambda var, context: Struct(attributes={"wetness": wetness}) self.scheduler.register_variable_access_function(access_func) - self.fire_event(Event("service_finished", data={"service_id": "0"})) + self.fire_event(Event("service_finished", data={"service_uuid": "0"})) wetness = 2 - self.fire_event(Event("service_finished", data={"service_id": "1"})) + self.fire_event(Event("service_finished", data={"service_uuid": "1"})) wetness = 1 - self.fire_event(Event("service_finished", data={"service_id": "2"})) + self.fire_event(Event("service_finished", data={"service_uuid": "2"})) self.assertTrue(self.token_in_last_place())