multimodalsim-viewer 0.1.2.0__py3-none-any.whl → 0.1.3.0__py3-none-any.whl

multimodalsim_viewer/server/simulation_manager.py

@@ -1,8 +1,11 @@
+import dataclasses
 import inspect
 import logging
 import multiprocessing
+import time
+from threading import Lock, Thread
 
-from flask_socketio import emit
+from flask_socketio import SocketIO
 
 from multimodalsim_viewer.common.utils import (
     CLIENT_ROOM,
@@ -69,15 +72,203 @@ class SimulationHandler:  # pylint: disable=too-many-instance-attributes, too-fe
         self.polylines_version = None
 
 
+@dataclasses.dataclass
+class ScheduledTask:
+    task: Thread | None
+    last_run: float | None = None
+
+
+class SimulationNotFoundError(Exception):
+    def __init__(self, simulation_id: str):
+        super().__init__(f"Simulation {simulation_id} not found")
+
+
+class MultipleSimulationsMatchingSocketIdError(Exception):
+    def __init__(self, socket_id: str, simulation_ids: list[str]):
+        super().__init__(f"Multiple simulations matching socket id {socket_id} : {', '.join(simulation_ids)}")
+
+
+# MARK: SimulationManager
 class SimulationManager:
-    simulations: dict[str, SimulationHandler]
+    def __init__(self, socketio: SocketIO):
+        self.socketio = socketio
 
-    def __init__(self):
         self.simulations = {}
 
-    def start_simulation(
-        self, name: str, data: str, response_event: str, max_duration: float | None
-    ) -> SimulationHandler:
+        self.task_by_simulation_id: dict[str, ScheduledTask] = {}
+
+        self.lock = Lock()
+
+    # MARK: +- Multi-threading
+    def __add_simulation_handler(self, simulation_handler: SimulationHandler) -> None:
+        with self.lock:
+            self.simulations[simulation_handler.simulation_id] = simulation_handler
+
+    def __set_socket_id(self, simulation_id: str, socket_id: str) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].socket_id = socket_id
+
+    def __set_status(self, simulation_id: str, status: SimulationStatus) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].status = status
+
+    def __set_start_time(self, simulation_id: str, start_time: float) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].start_time = start_time
+
+    def __set_max_duration(self, simulation_id: str, max_duration: float | None) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].max_duration = max_duration
+
+    def __set_simulation_time(self, simulation_id: str, simulation_time: float | None) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].simulation_time = simulation_time
+
+    def __set_simulation_estimated_end_time(
+        self, simulation_id: str, simulation_estimated_end_time: float | None
+    ) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].simulation_estimated_end_time = simulation_estimated_end_time
+
+    def __set_polylines_version(self, simulation_id: str, polylines_version: int | None) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].polylines_version = polylines_version
+
+    def __set_name(self, simulation_id: str, name: str) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].name = name
+
+    def __set_data(self, simulation_id: str, data: str) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].data = data
+
+    def __set_simulation_start_time(self, simulation_id: str, simulation_start_time: float) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].simulation_start_time = simulation_start_time
+
+    def __set_size(self, simulation_id: str, size: int) -> None:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            self.simulations[simulation_id].size = size
+
+    def __get_socket_id(self, simulation_id: str) -> str | None:
+        with self.lock:
+            if simulation_id in self.simulations:
+                return self.simulations[simulation_id].socket_id
+            raise SimulationNotFoundError(simulation_id)
+
+    def __get_status(self, simulation_id: str) -> SimulationStatus:
+        with self.lock:
+            if simulation_id in self.simulations:
+                return self.simulations[simulation_id].status
+            raise SimulationNotFoundError(simulation_id)
+
+    def __get_status_if_exists(self, simulation_id: str) -> SimulationStatus | None:
+        with self.lock:
+            if simulation_id in self.simulations:
+                return self.simulations[simulation_id].status
+            return None
+
+    def __get_matching_simulation_id_by_socket_id(self, socket_id: str) -> str | None:
+        with self.lock:
+            matching_simulation_ids = [
+                simulation_id
+                for simulation_id, simulation in self.simulations.items()
+                if simulation.socket_id == socket_id
+            ]
+
+            if len(matching_simulation_ids) == 1:
+                return matching_simulation_ids[0]
+
+            if len(matching_simulation_ids) > 1:
+                raise MultipleSimulationsMatchingSocketIdError(socket_id, matching_simulation_ids)
+            return None
+
+    def __get_all_simulation_ids(self) -> list[str]:
+        with self.lock:
+            return list(self.simulations.keys())
+
+    def __get_serialized_simulation(self, simulation_id: str) -> dict:
+        with self.lock:
+            if simulation_id not in self.simulations:
+                raise SimulationNotFoundError(simulation_id)
+
+            simulation = self.simulations[simulation_id]
+
+            serialized_simulation = {
+                "id": simulation_id,
+                "name": simulation.name,
+                "status": simulation.status.value,
+                "startTime": simulation.start_time,
+                "data": simulation.data,
+            }
+
+            if simulation.simulation_start_time is not None:
+                serialized_simulation["simulationStartTime"] = simulation.simulation_start_time
+
+            if simulation.simulation_end_time is not None:
+                serialized_simulation["simulationEndTime"] = simulation.simulation_end_time
+
+            if simulation.simulation_time is not None:
+                serialized_simulation["simulationTime"] = simulation.simulation_time
+
+            if simulation.simulation_estimated_end_time is not None:
+                serialized_simulation["simulationEstimatedEndTime"] = simulation.simulation_estimated_end_time
+
+            if simulation.max_duration is not None:
+                serialized_simulation["configuration"] = {"maxDuration": simulation.max_duration}
+
+            if simulation.polylines_version is not None:
+                serialized_simulation["polylinesVersion"] = simulation.polylines_version
+
+            if simulation.size is not None:
+                serialized_simulation["size"] = simulation.size
+
+            return serialized_simulation
+
+    def __does_simulation_exist(self, simulation_id: str) -> bool:
+        with self.lock:
+            return simulation_id in self.simulations
+
+    def __delete_simulation_handler_if_exists(self, simulation_id: str) -> None:
+        with self.lock:
+            if simulation_id in self.simulations:
+                del self.simulations[simulation_id]
+
+    # MARK: +- Simulation control
+    def start_simulation(self, name: str, data: str, response_event: str, max_duration: float | None):
         simulation_id, start_time = build_simulation_id(name)
 
         simulation_process = multiprocessing.Process(
@@ -96,199 +287,194 @@ class SimulationManager:
             simulation_process,
         )
 
-        self.simulations[simulation_id] = simulation_handler
+        self.__add_simulation_handler(simulation_handler)
 
         simulation_process.start()
 
-        self.emit_simulations()
-
         log(f'Emitting response event "{response_event}"', "server")
-        emit(response_event, simulation_id, to=CLIENT_ROOM)
 
-        return simulation_handler
+        self.socketio.emit(response_event, simulation_id, to=CLIENT_ROOM)
 
-    def on_simulation_start(self, simulation_id, socket_id, simulation_start_time):
-        if simulation_id not in self.simulations:
-            log(
-                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
-                "server",
-                logging.ERROR,
-            )
-            return
+        log(f"Started simulation {simulation_id}", "server")
 
-        simulation = self.simulations[simulation_id]
+        self.emit_simulation(simulation_id)
+
+    def stop_simulation(self, simulation_id):
+        try:
+            self.__set_status(simulation_id, SimulationStatus.STOPPING)
 
-        simulation.socket_id = socket_id
-        simulation.status = SimulationStatus.RUNNING
-        simulation.simulation_start_time = simulation_start_time
+            self.socketio.emit("stop-simulation", to=self.__get_socket_id(simulation_id))
 
-        self.emit_simulations()
+            log(f"Stopping simulation {simulation_id}", "server")
 
-    def stop_simulation(self, simulation_id):
-        if simulation_id not in self.simulations:
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
             log(
                 f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
-
-        simulation = self.simulations[simulation_id]
-        simulation.status = SimulationStatus.STOPPING
-
-        emit("stop-simulation", to=simulation.socket_id)
 
     def pause_simulation(self, simulation_id):
-        if simulation_id not in self.simulations:
+        try:
+            self.socketio.emit("pause-simulation", to=self.__get_socket_id(simulation_id))
+
+            log(f"Pausing simulation {simulation_id}", "server")
+        except SimulationNotFoundError:
             log(
                 f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
-
-        simulation = self.simulations[simulation_id]
 
-        emit("pause-simulation", to=simulation.socket_id)
+    def resume_simulation(self, simulation_id):
+        try:
+            self.socketio.emit("resume-simulation", to=self.__get_socket_id(simulation_id))
 
-    def on_simulation_pause(self, simulation_id):
-        if simulation_id not in self.simulations:
+            log(f"Resuming simulation {simulation_id}", "server")
+        except SimulationNotFoundError:
             log(
                 f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
 
-        simulation = self.simulations[simulation_id]
+    def edit_simulation_configuration(self, simulation_id: str, max_duration: float | None) -> None:
+        try:
+            self.__set_max_duration(simulation_id, max_duration)
 
-        simulation.status = SimulationStatus.PAUSED
+            self.socketio.emit("edit-simulation-configuration", (max_duration,), to=self.__get_socket_id(simulation_id))
 
-        self.emit_simulations()
+            log(f"Edited simulation {simulation_id} configuration", "server")
 
-    def resume_simulation(self, simulation_id):
-        if simulation_id not in self.simulations:
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
             log(
                 f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
 
-        simulation = self.simulations[simulation_id]
+    # MARK: +- Simulation events
+    def on_simulation_start(self, simulation_id, socket_id, simulation_start_time):
+        try:
+            self.__set_socket_id(simulation_id, socket_id)
+            self.__set_status(simulation_id, SimulationStatus.RUNNING)
+            self.__set_simulation_start_time(simulation_id, simulation_start_time)
 
-        emit("resume-simulation", to=simulation.socket_id)
+            log(f"Simulation {simulation_id} started", "server")
 
-    def on_simulation_resume(self, simulation_id):
-        if simulation_id not in self.simulations:
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
             log(
                 f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
-
-        simulation = self.simulations[simulation_id]
 
-        simulation.status = SimulationStatus.RUNNING
+    def on_simulation_pause(self, simulation_id):
+        try:
+            self.__set_status(simulation_id, SimulationStatus.PAUSED)
 
-        self.emit_simulations()
+            log(f"Simulation {simulation_id} paused", "server")
 
-    def edit_simulation_configuration(self, simulation_id: str, max_duration: float | None) -> None:
-        if simulation_id not in self.simulations:
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
             log(
                 f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
 
-        simulation = self.simulations[simulation_id]
-
-        simulation.max_duration = max_duration
-
-        emit("edit-simulation-configuration", (max_duration,), to=simulation.socket_id)
+    def on_simulation_resume(self, simulation_id):
+        try:
+            self.__set_status(simulation_id, SimulationStatus.RUNNING)
 
-        self.emit_simulations()
+            log(f"Simulation {simulation_id} resumed", "server")
 
-        log(
-            f"Emitted simulations with new max duration {max_duration} for simulation {simulation_id}",
-            "server",
-            logging.WARN,
-        )
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
+            log(
+                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
+                "server",
+                logging.ERROR,
+            )
 
     def on_simulation_disconnect(self, socket_id):
-        matching_simulation_ids = [
-            simulation_id for simulation_id, simulation in self.simulations.items() if simulation.socket_id == socket_id
-        ]
-
-        if len(matching_simulation_ids) != 1:
-            # The simulation has already been disconnected properly
-            return
+        try:
+            simulation_id = self.__get_matching_simulation_id_by_socket_id(socket_id)
 
-        simulation_id = matching_simulation_ids[0]
+            if simulation_id is None:
+                # Simulation already disconnected properly
+                return
 
-        # Get the simulation information from the save file
-        simulation_information = SimulationVisualizationDataManager.get_simulation_information(simulation_id)
+            status = self.__get_status(simulation_id)
 
-        simulation = self.simulations[simulation_id]
+            simulation_information = SimulationVisualizationDataManager.get_simulation_information(simulation_id)
 
-        if simulation.status in RUNNING_SIMULATION_STATUSES:
-            if simulation_information.simulation_end_time is None:
-                # The simulation has been lost
-                simulation.status = SimulationStatus.LOST
-            else:
-                # The simulation has been completed
-                simulation.status = SimulationStatus.COMPLETED
+            if status in RUNNING_SIMULATION_STATUSES:
+                if simulation_information.simulation_end_time is None:
+                    # The simulation has been lost
+                    self.__set_status(simulation_id, SimulationStatus.LOST)
+                else:
+                    # The simulation has been completed
+                    self.__set_status(simulation_id, SimulationStatus.COMPLETED)
 
-        simulation.socket_id = None
+            self.__set_socket_id(simulation_id, None)
 
-        self.emit_simulations()
+            log(f"Simulation {simulation_id} disconnected", "server")
 
-    def on_simulation_update_time(self, simulation_id, timestamp):
-        if simulation_id not in self.simulations:
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
             log(
-                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
+                f"{__file__} {inspect.currentframe().f_lineno}: Simulation with socket ID {socket_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
 
-        simulation = self.simulations[simulation_id]
-
-        simulation.simulation_time = timestamp
+    def on_simulation_update_time(self, simulation_id, timestamp):
+        try:
+            self.__set_simulation_time(simulation_id, timestamp)
 
-        self.emit_simulations()
+            log(f"Simulation {simulation_id} time updated to {timestamp}", "server")
 
-    def on_simulation_update_estimated_end_time(self, simulation_id, estimated_end_time):
-        if simulation_id not in self.simulations:
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
             log(
                 f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
-
-        simulation = self.simulations[simulation_id]
 
-        simulation.simulation_estimated_end_time = estimated_end_time
+    def on_simulation_update_estimated_end_time(self, simulation_id, estimated_end_time):
+        try:
+            self.__set_simulation_estimated_end_time(simulation_id, estimated_end_time)
 
-        self.emit_simulations()
+            log(f"Simulation {simulation_id} estimated end time updated to {estimated_end_time}", "server")
 
-    def on_simulation_update_polylines_version(self, simulation_id):
-        if simulation_id not in self.simulations:
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
             log(
                 f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
                 "server",
                 logging.ERROR,
             )
-            return
 
-        simulation = self.simulations[simulation_id]
+    def on_simulation_update_polylines_version(self, simulation_id):
+        try:
+            self.__set_polylines_version(
+                simulation_id, SimulationVisualizationDataManager.get_polylines_version_with_lock(simulation_id)
+            )
 
-        simulation.polylines_version = SimulationVisualizationDataManager.get_polylines_version_with_lock(simulation_id)
+            log(f"Simulation {simulation_id} polylines version updated", "server")
 
-        self.emit_simulations()
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError:
+            log(
+                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
+                "server",
+                logging.ERROR,
+            )
 
     def on_simulation_identification(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
@@ -301,89 +487,66 @@ class SimulationManager:
         status,
         socket_id,
     ):
-
-        log(
-            f"Identifying simulation {simulation_id}",
-            "simulation",
-        )
-
-        start_time, name = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)
-
-        if simulation_id in self.simulations:
-            simulation = self.simulations[simulation_id]
-        else:
-            start_time, name = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)
-
-            simulation = SimulationHandler(
-                simulation_id,
-                name,
-                start_time,
-                data,
-                SimulationStatus(status),
-                max_duration,
-                None,
+        try:
+            log(
+                f"Identifying simulation {simulation_id}",
+                "simulation",
             )
 
-            self.simulations[simulation_id] = simulation
-
-        simulation.name = name
-        simulation.start_time = start_time
-        simulation.data = data
-        simulation.simulation_start_time = simulation_start_time
-        simulation.simulation_time = simulation_time
-        simulation.simulation_estimated_end_time = simulation_estimated_end_time
-        simulation.max_duration = max_duration
-        simulation.status = SimulationStatus(status)
-        simulation.socket_id = socket_id
-
-        simulation.polylines_version = SimulationVisualizationDataManager.get_polylines_version_with_lock(simulation_id)
-
-        self.emit_simulations()
-
-    def emit_simulations(self):
-        self.query_simulations()
-
-        serialized_simulations = []
-
-        for simulation_id, simulation in self.simulations.items():
-            serialized_simulation = {
-                "id": simulation_id,
-                "name": simulation.name,
-                "status": simulation.status.value,
-                "startTime": simulation.start_time,
-                "data": simulation.data,
-            }
-
-            if simulation.simulation_start_time is not None:
-                serialized_simulation["simulationStartTime"] = simulation.simulation_start_time
-
-            if simulation.simulation_end_time is not None:
-                serialized_simulation["simulationEndTime"] = simulation.simulation_end_time
+            start_time, name = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)
 
-            if simulation.simulation_time is not None:
-                serialized_simulation["simulationTime"] = simulation.simulation_time
+            if not self.__does_simulation_exist(simulation_id):
+                start_time, name = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)
 
-            if simulation.simulation_estimated_end_time is not None:
-                serialized_simulation["simulationEstimatedEndTime"] = simulation.simulation_estimated_end_time
+                simulation = SimulationHandler(
+                    simulation_id,
+                    name,
+                    start_time,
+                    data,
+                    SimulationStatus(status),
+                    max_duration,
+                    None,
+                )
 
-            if simulation.max_duration is not None:
-                serialized_simulation["configuration"] = {"maxDuration": simulation.max_duration}
+                self.__add_simulation_handler(simulation)
+
+            self.__set_name(simulation_id, name)
+            self.__set_start_time(simulation_id, start_time)
+            self.__set_data(simulation_id, data)
+            self.__set_simulation_start_time(simulation_id, simulation_start_time)
+            self.__set_simulation_time(simulation_id, simulation_time)
+            self.__set_simulation_estimated_end_time(simulation_id, simulation_estimated_end_time)
+            self.__set_max_duration(simulation_id, max_duration)
+            self.__set_status(simulation_id, SimulationStatus(status))
+            self.__set_socket_id(simulation_id, socket_id)
+            self.__set_polylines_version(
+                simulation_id, SimulationVisualizationDataManager.get_polylines_version_with_lock(simulation_id)
+            )
 
-            if simulation.polylines_version is not None:
-                serialized_simulation["polylinesVersion"] = simulation.polylines_version
+            self.emit_simulation(simulation_id)
+        except SimulationNotFoundError as error:
+            print(error)
+            log(
+                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
+                "server",
+                logging.ERROR,
+            )
 
-            if simulation.size is not None:
-                serialized_simulation["size"] = simulation.size
+    # MARK: +- Visualization
+    def emit_simulation_polylines(self, simulation_id):
+        if not self.__does_simulation_exist(simulation_id):
+            log(
+                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
+                "server",
+                logging.ERROR,
+            )
+            return
 
-            serialized_simulations.append(serialized_simulation)
+        polylines, version = SimulationVisualizationDataManager.get_polylines(simulation_id)
 
-        emit(
-            "simulations",
-            serialized_simulations,
-            to=CLIENT_ROOM,
-        )
+        self.socketio.emit(f"polylines-{simulation_id}", (polylines, version), to=CLIENT_ROOM)
 
-        log("Emitting simulations", "server")
+        log(f"Emitted polylines for simulation {simulation_id}", "server")
 
     def emit_missing_simulation_states(
         self,
@@ -391,30 +554,28 @@ class SimulationManager:
         visualization_time: float,
         complete_state_update_indexes: list[int],
     ) -> None:
-        if simulation_id not in self.simulations:
-            log(
-                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
-                "server",
-                logging.ERROR,
-            )
-            return
-
-        simulation = self.simulations[simulation_id]
 
         try:
             (missing_states, missing_updates, has_all_states) = SimulationVisualizationDataManager.get_missing_states(
                 simulation_id,
                 visualization_time,
                 complete_state_update_indexes,
-                simulation.status not in RUNNING_SIMULATION_STATUSES,
+                self.__get_status(simulation_id) not in RUNNING_SIMULATION_STATUSES,
             )
 
-            emit(
+            self.socketio.emit(
                 "missing-simulation-states",
                 (missing_states, missing_updates, has_all_states),
                 to=get_session_id(),
             )
 
+        except SimulationNotFoundError:
+            log(
+                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
+                "server",
+                logging.ERROR,
+            )
+            return
         except Exception as e:  # pylint: disable=broad-exception-caught
             log(
                 f"Error while emitting missing simulation states for {simulation_id}: {e}",
@@ -427,52 +588,120 @@ class SimulationManager:
                 logging.ERROR,
             )
 
-            simulation.status = SimulationStatus.CORRUPTED
+            self.__set_status(simulation_id, SimulationStatus.CORRUPTED)
 
             SimulationVisualizationDataManager.mark_simulation_as_corrupted(simulation_id)
 
-            self.emit_simulations()
+            self.emit_simulation(simulation_id)
 
-    def emit_simulation_polylines(self, simulation_id):
-        if simulation_id not in self.simulations:
+    # MARK: +- Simulation list
+    def on_simulation_delete(self, simulation_id: str) -> None:
+        self.__delete_simulation_handler_if_exists(simulation_id)
+
+        self.socketio.emit("delete-simulation", simulation_id, to=CLIENT_ROOM)
+
+        log(f"Deleted simulation {simulation_id} from simulation manager", "server")
+
+    def emit_simulations(self, loaded_simulations_ids: list[str]):
+        try:
+            all_simulation_ids = SimulationVisualizationDataManager.get_all_saved_simulation_ids()
+
+            log("Emitting simulations", "server")
+
+            simulation_ids_to_delete: set[str] = set()
+
+            for simulation_id in self.__get_all_simulation_ids():
+                if simulation_id not in all_simulation_ids and self.__get_status(simulation_id) not in [
+                    SimulationStatus.RUNNING,
+                    SimulationStatus.PAUSED,
+                    SimulationStatus.STOPPING,
+                    SimulationStatus.STARTING,
+                    SimulationStatus.LOST,
+                ]:
+                    simulation_ids_to_delete.add(simulation_id)
+
+            for loaded_simulation_id in loaded_simulations_ids:
+                if not loaded_simulation_id in all_simulation_ids:
+                    simulation_ids_to_delete.add(loaded_simulation_id)
+
+            for simulation_id in simulation_ids_to_delete:
+                self.on_simulation_delete(simulation_id)
+
+            for simulation_id in all_simulation_ids:
+                self.emit_simulation(simulation_id)
+
+            log("Emitted simulations", "server")
+        except SimulationNotFoundError:
             log(
-                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
+                f"{__file__} {inspect.currentframe().f_lineno}: One or more simulations not found",
                 "server",
                 logging.ERROR,
             )
-            return
 
-        polylines, version = SimulationVisualizationDataManager.get_polylines(simulation_id)
+    def emit_simulation(self, simulation_id: str) -> None:
+        scheduled_task = self.task_by_simulation_id.get(simulation_id, None)
+        if scheduled_task is None:
+            scheduled_task = ScheduledTask(None)
+            self.task_by_simulation_id[simulation_id] = scheduled_task
+
+        minimum_debounce_time = 1
+        actual_debounce_time = 0
+        now = time.monotonic()
+
+        if scheduled_task.last_run is not None and scheduled_task.last_run + minimum_debounce_time > now:
+            actual_debounce_time = scheduled_task.last_run + minimum_debounce_time - now
 
-        emit(f"polylines-{simulation_id}", (polylines, version), to=CLIENT_ROOM)
+        def action():
+            self.socketio.sleep(actual_debounce_time)
+
+            try:
+                self.query_simulation(simulation_id)
 
-    def query_simulations(self):
-        all_simulation_ids = SimulationVisualizationDataManager.get_all_saved_simulation_ids()
+                log(f"Emitting simulation {simulation_id}", "server")
 
-        for simulation_id, _ in list(self.simulations.items()):
-            if simulation_id not in all_simulation_ids and self.simulations[simulation_id].status not in [
+                serialized_simulation = self.__get_serialized_simulation(simulation_id)
+
+                self.socketio.emit("simulation", serialized_simulation, to=CLIENT_ROOM)
+
+                log(f"Emitted simulation {simulation_id}", "server")
+
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                log(
+                    f"Error while emitting simulation {simulation_id}: {e}",
+                    "server",
+                    logging.ERROR,
+                )
+            finally:
+                scheduled_task.last_run = time.monotonic()
+                scheduled_task.task = None
+
+        if scheduled_task.task is None:
+            if actual_debounce_time > 0:
+                scheduled_task.task = self.socketio.start_background_task(action)
+                log(f"Scheduled emit of simulation {simulation_id} in {actual_debounce_time}s", "server")
+            else:
+                action()
+                log(f"Emitted simulation {simulation_id} immediately", "server")
+        else:
+            log(f"Simulation {simulation_id} is already scheduled", "server")
+
+    def query_simulation(self, simulation_id) -> None:
+        log(f"Querying simulation {simulation_id}", "server")
+
+        try:
+            if self.__get_status_if_exists(simulation_id) in [
                 SimulationStatus.RUNNING,
                 SimulationStatus.PAUSED,
                 SimulationStatus.STOPPING,
                 SimulationStatus.STARTING,
                 SimulationStatus.LOST,
             ]:
-                del self.simulations[simulation_id]
-
-        for simulation_id in all_simulation_ids:
-            # Non valid save files might throw an exception
-            self.query_simulation(simulation_id)
-
-    def query_simulation(self, simulation_id) -> None:
-        if simulation_id in self.simulations and self.simulations[simulation_id].status in [
-            SimulationStatus.RUNNING,
-            SimulationStatus.PAUSED,
-            SimulationStatus.STOPPING,
-            SimulationStatus.STARTING,
-            SimulationStatus.LOST,
-        ]:
-            simulation = self.simulations[simulation_id]
-            simulation.size = SimulationVisualizationDataManager.get_saved_simulation_size(simulation_id)
+                self.__set_size(
+                    simulation_id, SimulationVisualizationDataManager.get_saved_simulation_size(simulation_id)
+                )
+                return
+        except SimulationNotFoundError:
+            log(f"Simulation {simulation_id} not found", "server", logging.ERROR)
             return
 
         is_corrupted = SimulationVisualizationDataManager.is_simulation_corrupted(simulation_id)
@@ -499,13 +728,11 @@ class SimulationManager:
                     log(
                         f"Simulation {simulation_id} version is outdated",
                         "server",
-                        logging.DEBUG,
                     )
                 if status == SimulationStatus.FUTURE:
                     log(
                         f"Simulation {simulation_id} version is future",
                         "server",
-                        logging.DEBUG,
                     )
 
                 simulation = SimulationHandler(
@@ -529,13 +756,13 @@ class SimulationManager:
                     # The simulation is not running but the end time is not set
                     raise Exception("Simulation is corrupted")  # pylint: disable=broad-exception-raised
 
-                self.simulations[simulation_id] = simulation
+                self.__add_simulation_handler(simulation)
 
             except Exception:  # pylint: disable=broad-exception-caught
                 is_corrupted = True
 
         if is_corrupted:
-            log(f"Simulation {simulation_id} is corrupted", "server", logging.DEBUG)
+            log(f"Simulation {simulation_id} is corrupted", "server")
 
             simulation = SimulationHandler(
                 simulation_id,
@@ -547,23 +774,8 @@ class SimulationManager:
                 None,
             )
 
-            self.simulations[simulation_id] = simulation
+            self.__add_simulation_handler(simulation)
 
             SimulationVisualizationDataManager.mark_simulation_as_corrupted(simulation_id)
-
-    def get_all_simulation_states(self, simulation_id: str) -> None:
-        if simulation_id not in self.simulations:
-            log(
-                f"{__file__} {inspect.currentframe().f_lineno}: Simulation {simulation_id} not found",
-                "server",
-                logging.ERROR,
-            )
-            return
-
-        states, updates = SimulationVisualizationDataManager.get_all_simulation_states(simulation_id)
-
-        emit(
-            "all-simulation-states",
-            (states, updates),
-            to=CLIENT_ROOM,
-        )
+        else:
+            log(f"Simulation {simulation_id} queried successfully", "server")