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

@@ -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):

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)

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,34 +90,34 @@ 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:
             self.petri_net_generator = PetriNetGenerator(
                 "",
                 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))

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": <service_id>})
+        - Event(event_type="service_finished", data={"service_uuid": <service_uuid>})
 
     Attributes:
         event_type: A string representing the type of the event.

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,

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",

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)