Enhance server creation process by adding 'started_at' field and improve error handling for bus configuration

Author: AntoineBuirey

client/src/dashboard/dashboard.ts

@@ -141,7 +141,8 @@ async function on_create_server_button() {
                 autostart: autostart,
                 ram: parseInt(ram, 10), // Convert to integer
                 mc_version: mc_version,
-                modloader_version: modloader_version
+                modloader_version: modloader_version,
+                started_at: null,
             };
             const success = await API.create_server(server_info);
             if (success) {

forge-server-manager.code-workspace

@@ -20,6 +20,9 @@
 			"*.template": "html",
 			"python.h": "c",
 			"*/config.json": "jsonc"
-		}
+		},
+		"python.analysis.inlayHints.callArgumentNames": "partial",
+		"python.analysis.inlayHints.functionReturnTypes": true,
+		"python.analysis.typeCheckingMode": "basic"
 	}
 }

server/src/bus/bus.py

@@ -75,7 +75,7 @@ def __check_callback(self, event: Event, callback: Callback):
                 )
             if arg_type.__name__ != event[arg_name].type:
                 raise ValueError(
-                    f"Callback for event {event.name} has argument {arg_name} with wrong type (expected {event.args[arg_name].type}, got {arg_type.__name__})"
+                    f"Callback for event {event.name} has argument {arg_name} with wrong type (expected {event[arg_name].type}, got {arg_type.__name__})"
                 )
 
     def __register(self, event: Event, callback: Callback):
@@ -117,10 +117,10 @@ def __read_prefix(self, encoded: str) -> tuple[BusMessagePrefix, str]:
         prefix = BusMessagePrefix.from_string(prefix_str)
         return prefix, data
 
-    def __write(self, raw_msg: str, __to : int, fragment_number: int, fragment_count: int, msg_id : int):
+    def __write(self, raw_msg: str, _to : int, fragment_number: int, fragment_count: int, msg_id : int):
         # add the id at the beginning, followed by a 0 for the target
         prefix = BusMessagePrefix(source_id=self.__id,
-                                  target_id=__to,
+                                  target_id=_to,
                                   message_id=msg_id,
                                   fragment_number=fragment_number,
                                   fragment_count=fragment_count)
@@ -138,7 +138,7 @@ def __write(self, raw_msg: str, __to : int, fragment_number: int, fragment_count
             else:
                 raise ValueError("No free position in shared list to send data.")
 
-    def __send(self, event: Event, __to : int, timeout : int = 5, **kwargs: Any) -> Any:
+    def __send(self, event: Event, _to : int, timeout : float = 5, **kwargs: Any) -> Any:
         if "timestamp" not in kwargs:
             for a in event.args:
                 if a.name == "timestamp" and a.type == "datetime":
@@ -160,7 +160,7 @@ def __send(self, event: Event, __to : int, timeout : int = 5, **kwargs: Any) ->
         message_id = random.randint(0, 255)  # Generate a random message ID for the event
 
         for i, part in enumerate(parts):
-            self.__write(part, __to, i, len(parts), message_id)
+            self.__write(part, _to, i, len(parts), message_id)
 
         if event.return_type != "None":
             res = self.wait_for(event.return_event(), timeout=timeout)  # Wait for the event to be processed and return the result
@@ -173,7 +173,7 @@ def __send(self, event: Event, __to : int, timeout : int = 5, **kwargs: Any) ->
             Logger.debug(f"Event {event.name} triggered without return type, no waiting for result.")
             return None
 
-    def trigger(self, event: Event, timeout : int = 5, **kwargs: Any) -> Any:
+    def trigger(self, event: Event, timeout : float = 5, **kwargs: Any) -> Any:
         """
         Trigger an event with the given name and arguments.
         If the event requires a timestamp and it is not provided, it will be added automatically.
@@ -295,36 +295,3 @@ def stop(self):
             self.__thread.join()
         else:
             Logger.warning("Bus is not listening")
-
-
-
-
-
-
-
-
-
-
-
-
-if __name__ == "__main__":
-    from datetime import datetime
-    bus1 = Bus()
-
-    def _get_players_1(timestamp: datetime, server_name: str) -> list[str]:
-        if server_name == "TestServer":
-            return ["Player1", "Player2", "Player3"]
-        return None
-
-    def _get_players_2(timestamp: datetime, server_name: str) -> list[str]:
-        if server_name == "TestServer2":
-            return ["Player4", "Player5", "Player6"]
-        return None
-
-
-    bus1.register(Events["PLAYERS.LIST"], _get_players_1)
-    bus1.register(Events["PLAYERS.LIST"], _get_players_2)
-
-
-    bus2 = Bus()
-    print(bus2.trigger(Events["PLAYERS.LIST"], timestamp=datetime.now(), server_name="TestServer2"))

server/src/bus/events.py

@@ -237,7 +237,7 @@ def __load_events(self, xml_path: str):
             raise ValueError(f"Failed to parse XML file {xml_path}: {e}") from None
         root = tree.getroot()
         for namespace in root.findall('namespace'):
-            self.__parse_namespace(namespace, namespace.get('name'))
+            self.__parse_namespace(namespace, namespace.get('name') or "global")
         Logger.info(f"Loaded {len(self.events)} events from XML file.")
 
     def __parse_namespace(self, namespace : ET.Element, namespace_name: str):
@@ -249,18 +249,18 @@ def __parse_namespace(self, namespace : ET.Element, namespace_name: str):
             )
         for event in namespace.findall('event'):
             event_name = f"{namespace_name}.{event.get('name')}"
-            event_id = int(event.get('id'), 16)
+            event_id = int(event.get('id'), 16) #type: ignore
             if not event_id:
                 raise ValueError(f"Event {event_name} does not have an ID")
             args = [
-                EventArg(arg.get('name'), arg.get('type'), int(arg.get('id', 0), 16))
-                for arg in event.find('args').findall('arg')
+                EventArg(arg.get('name'), arg.get('type'), int(arg.get('id', 0), 16)) #type: ignore
+                for arg in event.find('args').findall('arg') #type: ignore
             ]
-            return_type = event.find('return').get('type')
+            return_type = event.find('return').get('type') #type: ignore
             Logger.debug(f"Registering event: {event_name} (ID: {event_id})")
             if event_id in self.events:
                 Logger.warning(f"Event ID {event_id} already exists, overwriting: {self.events[event_id].name} -> {event_name}")
-            self.events[event_id] = Event(event_name, event_id, args, return_type)
+            self.events[event_id] = Event(event_name, event_id, args, return_type) #type: ignore
 
     def __getitem__(self, item: str|int) -> Event:
         if isinstance(item, str):

server/src/core/core.py

@@ -25,10 +25,18 @@ def __init__(self, config_file: str):
         self.__running = False
 
         # Initialize the bus dispatcher (will run in a separate thread)
-        self.__bus_dispatcher = BusDispatcher(
-            self.__config.get("bus.memory_size", default=8, set_if_not_found=True),
-            self.__config.get("bus.max_string_length", default=8192, set_if_not_found=True) # default of 8KB
-        )
+        
+        mem_size = self.__config.get("bus.memory_size", default=8, set_if_not_found=True)
+        max_str_len = self.__config.get("bus.max_string_length", default=8192, set_if_not_found=True) # default of 8KB  
+        
+        if not isinstance(mem_size, int) or mem_size <= 0:
+            Logger.error(f"Invalid bus memory size: {mem_size}. Must be a positive integer. Using default of 8MB.")
+            raise ValueError("Invalid bus memory size in configuration.")
+        if not isinstance(max_str_len, int) or max_str_len <= 0:
+            Logger.error(f"Invalid bus max string length: {max_str_len}. Must be a positive integer. Using default of 8192 bytes.")
+            raise ValueError("Invalid bus max string length in configuration.")
+        
+        self.__bus_dispatcher = BusDispatcher( mem_size, max_str_len)
         self.__bus_dispatcher_thread = th.Thread(
             target=self.__bus_dispatcher.mainloop,
             daemon=True,
@@ -38,7 +46,7 @@ def __init__(self, config_file: str):
         # Initialize the bus to communicate with modules through the dispatcher
         bus_data = self.__bus_dispatcher.get_bus_data("core")
         self.__bus = Bus(bus_data)
-        self._srv_config = JSONConfig(self.__config.get("server_config_path"))
+        self._srv_config = JSONConfig(str(self.__config.get("server_config_path")))
 
         self.__ui_processes: Dict[str, mp.Process] = {}
         self.__mc_servers  : Dict[str, mp.Process] = {}
@@ -98,7 +106,7 @@ def __start_user_interfaces(self):
         Initializes and start user interface modules based on the configuration.
         This method is called when the core is started.
         """
-        to_load : dict[str, dict[str, Any]] = self.__config.get("user_interface_modules")
+        to_load : dict[str, dict[str, Any]] = self.__config.get("user_interface_modules") #type: ignore
         for module_type, config in to_load.items():
             Logger.info(f"Initializing user interface module {config['name']} of type {module_type}...")
             if module_type not in UserInterfaceModules:
@@ -175,11 +183,26 @@ def __start_server(self, server_name: str):
         try:
             server_type = self._srv_config.get(f"{server_name}.type")
             server_path = self._srv_config.get(f"{server_name}.path")
+            
+            if not isinstance(server_type, str) or server_type not in McServersModules:
+                Logger.error(f"Invalid or unknown server type for server {server_name}. Cannot start server.")
+                return
+            if not isinstance(server_path, str) or not os.path.exists(server_path):
+                Logger.error(f"Invalid or non-existent server path for server {server_name}. Cannot start server.")
+                return
 
             Server = McServersModules[server_type]
             bus_data = self.__bus_dispatcher.get_bus_data(server_name)
             ram = self._srv_config.get(f"{server_name}.ram", default=1024, set_if_not_found=True)
-            mc_version = Version.from_string(self._srv_config.get(f"{server_name}.mc_version"))
+            if not isinstance(ram, int) or ram <= 0:
+                Logger.error(f"Invalid RAM value for server {server_name}. Cannot start server.")
+                return
+            mc_version_raw = self._srv_config.get(f"{server_name}.mc_version")
+            if not isinstance(mc_version_raw, str):
+                Logger.error(f"Invalid Minecraft version for server {server_name}. Cannot start server.")
+                return
+            mc_version = Version.from_string(mc_version_raw)
+            
             def __start_mc_server():
                 srv = Server(server_name, server_path, ram, mc_version, bus_data)
                 srv.start()
@@ -290,7 +313,7 @@ def __get_server_status(self, server_name: str) -> ServerStatus:
         """
         if server_name not in self._srv_config:
             Logger.error(f"Server {server_name} not found.")
-            return False
+            return ServerStatus.STOPPED
 
         pinged : str = self.__bus.trigger(
             Events['SERVER.PING'],
@@ -303,8 +326,11 @@ def __get_mc_dirs(self) -> List[str]:
         try:
             data = []
             Logger.trace("Fetching Minecraft server directories from configuration.")
-            for i in range(len(self.__config.get("minecraft_servers_dirs", []))):
+            for i in range(len(self.__config.get("minecraft_servers_dirs", []))): # type: ignore
                 dir_path = self.__config.get(f"minecraft_servers_dirs.{i}")
+                if not isinstance(dir_path, str):
+                    Logger.warning(f"Invalid directory path at index {i}: {dir_path}. Skipping.")
+                    continue
                 data.append(os.path.normpath(dir_path))
             Logger.trace(f"Found Minecraft server directories: {data}")
             return data