Implement server control API and enhance server management UI

Author: AntoineBuirey

client/src/header/header.template

@@ -1,9 +1,9 @@
 <link rel="stylesheet" href="header.css" />
 <header class="dashboard-header">
-    <button id="dashboard" onclick="window.location.href='dashboard.html'" {{"disabled" if page.name == "dashboard" else ""}}>
+    <button id="dashboard" onclick="window.location.href='dashboard'" {{"disabled" if page.name == "dashboard" else ""}}>
         Dashboard
     </button>
-    <button id="account" onclick="window.location.href='account.html'" {{"disabled" if page.name == "account" else ""}}>
+    <button id="account" onclick="window.location.href='account'" {{"disabled" if page.name == "account" else ""}}>
         Account Management
     </button>
     <button id="disconnect">

client/src/scripts/api.ts

@@ -308,4 +308,58 @@ export default class API {
         }
     }
 
+    public static async start_server(server_name: string) {
+        if (!Cookies.has('token')) {
+            console.error('No token found in cookies');
+            return false;
+        }
+        const {data, status} = await API.post(`/api/start_server/${server_name}`, {});
+        if (status === 200) {
+            return true;
+        }
+        else if (status === 500) {
+            console.error('Error starting server:', data['message']);
+            throw new Error('Error starting server');
+        }
+        else{
+            return false;
+        }
+    }
+
+    public static async stop_server(server_name: string) {
+        if (!Cookies.has('token')) {
+            console.error('No token found in cookies');
+            return false;
+        }
+        const {data, status} = await API.post(`/api/stop_server/${server_name}`, {});
+        if (status === 200) {
+            return true;
+        }
+        else if (status === 500) {
+            console.error('Error stopping server:', data['message']);
+            throw new Error('Error stopping server');
+        }
+        else{
+            return false;
+        }
+    }
+
+    public static async restart_server(server_name: string) {
+        if (!Cookies.has('token')) {
+            console.error('No token found in cookies');
+            return false;
+        }
+        const {data, status} = await API.post(`/api/restart_server/${server_name}`, {});
+        if (status === 200) {
+            return true;
+        }
+        else if (status === 500) {
+            console.error('Error restarting server:', data['message']);
+            throw new Error('Error restarting server');
+        }
+        else{
+            return false;
+        }
+    }
+
 }

client/src/server/index.template.html

@@ -10,20 +10,21 @@
     {{ insert("header/header") }}
     <main>
         <h1 id="server-name"></h1>
-        <div>
-            <span id="mc-version"></span>
+        <div class="elements">
+            Minecraft <span id="mc-version"></span> <span id="modloader-version"></span>
         </div>
-        <div>
-            <span id="modloader-version"></span>
+        <div class="elements">
+            Allocated RAM: <span id="ram"></span> MB
         </div>
-        <div>
-            <span id="ram"></span>
+        <div class="elements">
+            Started at: <span id="started-at"></span> (<span id="running-for"></span>)
         </div>
-        <div>
-            <span id="started-at"></span>
-        </div>
-        <div>
-            <span id="running-for"></span>
+        <div class="elements">
+            <button disabled id="start-server">Start Server</button>
+            <button disabled id="stop-server">Stop Server</button>
+            <button disabled id="restart-server">Restart Server</button>
+            <input type="checkbox" id="auto-start" />
+            <label for="auto-start">Auto Start</label>
         </div>
     </main>
     <script type="module" src="server.js"></script>

client/src/server/server.scss

@@ -1 +1,11 @@
 @use '../common.scss';
+
+h1 {
+    text-align: center;
+}
+
+.elements {
+    display: inline-block;
+    margin: 10px;
+    text-align: center;
+}

client/src/server/server.ts

@@ -19,16 +19,22 @@ async function load_data(){
         serverNameElement.textContent = server_info.name;
 
         const mcVersionElement = document.getElementById("mc-version") as HTMLSpanElement;
-        mcVersionElement.textContent = `Minecraft Version: ${server_info.mc_version}`;
+        mcVersionElement.textContent = server_info.mc_version;
 
+        
         const modloaderVersionElement = document.getElementById("modloader-version") as HTMLSpanElement;
-        modloaderVersionElement.textContent = `Modloader Version: ${server_info.modloader_version}`;
+        if (server_info.type === "vanilla") {
+            modloaderVersionElement.textContent = "Vanilla";
+        }
+        else {
+            modloaderVersionElement.textContent = `${server_info.type} ${server_info.modloader_version}`;
+        }
 
         const ramElement = document.getElementById("ram") as HTMLSpanElement;
-        ramElement.textContent = `RAM: ${server_info.ram} MB`;
+        ramElement.textContent = `${server_info.ram}`;
 
         const startedAtElement = document.getElementById("started-at") as HTMLSpanElement;
-        startedAtElement.textContent = server_info.started_at ? `Started At: ${new Date(server_info.started_at).toLocaleString()}` : "Not Started";
+        startedAtElement.textContent = server_info.started_at ? `${new Date(server_info.started_at).toLocaleString()}` : "N/A";
 
         const runningForElement = document.getElementById("running-for") as HTMLSpanElement;
         if (server_info.started_at) {
@@ -40,15 +46,66 @@ async function load_data(){
                 const hours = Math.floor(diff / 3600);
                 const minutes = Math.floor((diff % 3600) / 60);
                 const seconds = diff % 60;
-                runningForElement.textContent = `Running For: ${hours}h ${minutes}m ${seconds}s`;
+                runningForElement.textContent = `${hours}h ${minutes}m ${seconds}s`;
             }
 
             updateRunningFor();
             setInterval(updateRunningFor, 1000);
         }
         else {
-            runningForElement.textContent = "Not Running";
+            runningForElement.textContent = "Server is not running";
+        }
+
+        const startServerButton = document.getElementById("start-server") as HTMLButtonElement;
+        if (server_info.started_at) {
+            startServerButton.disabled = true;
+            startServerButton.textContent = "Server is running";
+        } else {
+            startServerButton.disabled = false;
+            startServerButton.textContent = "Start Server";
+        }
+        startServerButton.addEventListener("click", () => {
+            API.start_server(server_name as string).then(() => {
+                window.location.reload();
+            }).catch((error) => {
+                console.error("Error starting server:", error);
+                alert("Failed to start the server. Check the console for details.");
+            });
+        });
+
+        const stopServerButton = document.getElementById("stop-server") as HTMLButtonElement;
+        if (!server_info.started_at) {
+            stopServerButton.disabled = true;
+            stopServerButton.textContent = "Server is not running";
+        } else {
+            stopServerButton.disabled = false;
+            stopServerButton.textContent = "Stop Server";
+        }
+        stopServerButton.addEventListener("click", () => {
+            API.stop_server(server_name as string).then(() => {
+                window.location.reload();
+            }).catch((error) => {
+                console.error("Error stopping server:", error);
+                alert("Failed to stop the server. Check the console for details.");
+            });
+        });
+
+        const restartServerButton = document.getElementById("restart-server") as HTMLButtonElement;
+        if (!server_info.started_at) {
+            restartServerButton.disabled = true;
+            restartServerButton.textContent = "Server is not running";
+        } else {
+            restartServerButton.disabled = false;
+            restartServerButton.textContent = "Restart Server";
         }
+        restartServerButton.addEventListener("click", () => {
+            API.restart_server(server_name as string).then(() => {
+                window.location.reload();
+            }).catch((error) => {
+                console.error("Error restarting server:", error);
+                alert("Failed to restart the server. Check the console for details.");
+            });
+        });
 
     }).catch((error) => {
         console.error("Error loading server info:", error);

server/src/bus/bus.py

@@ -231,7 +231,7 @@ def a():
                                 self.__exec_callback(event, prefix.source_id, **args)
                             except Exception as e:
                                 Logger.error(f"Error processing event {event.name} with args {args}: {e.__class__.__name__} : {e}")
-                                Logger.trace(traceback.format_exc())
+                                Logger.debug(traceback.format_exc())
                         t = th.Thread(target=a, daemon=True, name=f"BusCallback-{event.name}")
                         Logger.trace(f"Starting thread for event {event.name} with args {args}\nthread hash: {t.__hash__()}\nthread name: {t.name}")
                         t.start()
@@ -283,7 +283,7 @@ def start(self):
             except RuntimeError as e:
                 Logger.error(f"Failed to start bus listener thread: {e}")
                 Logger.trace(f"Thread:\n alive: {self.__thread.is_alive()}\n name: {self.__thread.name}\n hash: {self.__thread.__hash__()}\n repr: {self.__thread.__repr__()}")
-                Logger.trace(traceback.format_exc())
+                Logger.debug(traceback.format_exc())
                 return
             Logger.info("Bus is now listening for events")
         else:

server/src/bus/bus_dispatcher.py

@@ -145,7 +145,7 @@ def mainloop(self):
                     self.__move_forward(rec_key)
                 except Exception as e:
                     Logger.error(f"Error processing message {msg} from {rec_key}: {e}")
-                    Logger.trace(traceback.format_exc())
+                    Logger.debug(traceback.format_exc())
             time.sleep(0.01)
 
     def stop(self):

server/src/core/core.py

@@ -166,6 +166,59 @@ def __stop_user_interfaces(self):
                 Logger.info(f"User interface process {ui_name} stopped successfully.")
 
 
+    def __start_server(self, server_name: str):
+        """
+        Starts the specified server.
+        :param server_name: Name of the server to start
+        """
+        Logger.info(f"Initializing server {server_name}...")
+        try:
+            server_type = self._srv_config.get(f"{server_name}.type")
+            server_path = self._srv_config.get(f"{server_name}.path")
+
+            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"))
+            def __start_mc_server():
+                srv = Server(server_name, server_path, ram, mc_version, bus_data)
+                srv.start()
+            p = mp.Process(
+                target=__start_mc_server,
+                name=f"Server_{server_name}",
+                daemon=True
+            )
+            Logger.info(f"Starting Minecraft server {server_name} of type {server_type} at {server_path} with RAM {ram}MB...")
+            p.start()  # Start the process
+            self.__mc_servers[server_name] = p  # Store the process
+        except Exception as e:
+            Logger.error(f"Failed to init server {server_name}: {e}")
+            Logger.debug(traceback.format_exc())
+
+    def __stop_server(self, server_name: str):
+        srv_process = self.__mc_servers[server_name]
+        if srv_process.is_alive():
+            Logger.info(f"Stopping Minecraft server {server_name} with PID {srv_process.pid}...")
+            self.__bus.trigger(
+                Events['SERVER.STOP'],
+                server_name=server_name,
+                timeout=30  # Wait for 30 seconds for the server to stop
+            )
+            srv_process.join(timeout=30)
+            if srv_process.is_alive():
+                Logger.warning(f"Minecraft server {server_name} did not stop gracefully. Terminating...")
+                srv_process.terminate()
+                srv_process.join()
+            Logger.info(f"Minecraft server {server_name} stopped successfully.")
+
+    def __restart_server(self, server_name: str):
+        """
+        Restarts the specified server.
+        :param server_name: Name of the server to restart
+        """
+        Logger.info(f"Restarting server {server_name}...")
+        self.__stop_server(server_name)
+        self.__start_server(server_name)
 
     def __start_mc_servers(self):
         """
@@ -175,29 +228,7 @@ def __start_mc_servers(self):
         Logger.info("Initializing Minecraft servers...")
         for server_name, srv_info in self._srv_config.items():
             if srv_info.get("autostart", False):
-                Logger.info(f"Initializing server {server_name}...")
-                try:
-                    server_type = self._srv_config.get(f"{server_name}.type")
-                    server_path = self._srv_config.get(f"{server_name}.path")
-
-                    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"))
-                    def __start_mc_server():
-                        srv = Server(server_name, server_path, ram, mc_version, bus_data)
-                        srv.start()
-                    p = mp.Process(
-                        target=__start_mc_server,
-                        name=f"Server_{server_name}",
-                        daemon=True
-                    )
-                    Logger.info(f"Starting Minecraft server {server_name} of type {server_type} at {server_path} with RAM {ram}MB...")
-                    p.start()  # Start the process
-                    self.__mc_servers[server_name] = p  # Store the process
-                except Exception as e:
-                    Logger.error(f"Failed to init server {server_name}: {e}")
-                    Logger.debug(traceback.format_exc())
+                self.__start_server(server_name)
             else:
                 Logger.info(f"Server {server_name} is not set to autostart. Skipping.")
 
@@ -207,15 +238,8 @@ def __stop_mc_servers(self):
         This method is called when the core is stopped.
         """
         Logger.info("Stopping Minecraft servers...")
-        for srv_name, srv_process in self.__mc_servers.items():
-            if srv_process.is_alive():
-                Logger.info(f"Stopping Minecraft server {srv_name} with PID {srv_process.pid}...")
-                srv_process.join(timeout=30)
-                if srv_process.is_alive():
-                    Logger.warning(f"Minecraft server {srv_name} did not stop gracefully. Terminating...")
-                    srv_process.terminate()
-                    srv_process.join()
-                Logger.info(f"Minecraft server {srv_name} stopped successfully.")
+        for srv_name in self.__mc_servers.keys():
+            self.__stop_server(srv_name)
 
 
 
@@ -317,24 +341,7 @@ def on_server_restart(self, timestamp : datetime, server_name: str):
             Logger.warning(f"Server {server_name} is not running. Cannot restart.")
             return
         Logger.info(f"Restarting server {server_name}...")
-        self.__bus.trigger( # Will wait for the server to stop
-            Events['SERVER.STOP'],
-            server_name=server_name
-        )
-        if self.__get_server_status(server_name):
-            Logger.error(f"Server {server_name} did not stop properly. Cannot restart.")
-            return
-        Logger.info(f"Server {server_name} stopped successfully. Starting it again...")
-        srv_info = self._srv_config[server_name]
-        server_type = srv_info['type']
-        server_path = srv_info['path']
-        if not self.__is_server_path_valid(server_path):
-            Logger.error(f"Server path {server_path} is not valid. Cannot restart server {server_name}.")
-            return
-        if server_type not in McServersModules:
-            Logger.error(f"Server type {server_type} is not recognized. Cannot restart server {server_name}.")
-            return
-        self.__start_server(server_name, server_type, server_path)
+        self.__restart_server(server_name)
 
     def on_server_create(self,
         timestamp : datetime,
@@ -395,6 +402,7 @@ def on_server_create(self,
             )
         except Exception as e:
             Logger.error(f"Failed to install server {server_name} of type {server_type}: {e}")
+            Logger.debug(traceback.format_exc())
             return
         else:
             self._srv_config.set(server_name, {

server/src/minecraft/Base_mc_server.py

@@ -186,7 +186,6 @@ def on_started_at(self, timestamp: datetime, server_name: str) -> datetime:
         :return: The timestamp when the server started.
         """
         if server_name == self.name:
-            Logger.info(f"Server {self.name} started at {timestamp}.")
             return self.__started_at
         Logger.debug(f"Started at event received for server {server_name}, but this is not the current server ({self.name}). Ignoring.")
         return None