Update server_manager.py

server_manager.py

@@ -11,7 +11,8 @@ import psutil
 from functools import wraps
 
 # Constants for stats monitoring
-STATS_INTERVAL = 5 # seconds
+GLOBAL_STATUS_INTERVAL = 5 # seconds for global status/stats check
+PROCESS_STATS_INTERVAL = 1 # seconds for detailed running process stats
 
 class MinecraftServerManager:
     def __init__(self, socketio=None):
@@ -21,7 +22,11 @@ class MinecraftServerManager:
         self.stopping = False
         self.socketio = socketio
         self.output_thread = None
-        self.stats_thread = None
+        
+        # Threads for live data
+        self.process_stats_thread = None  # Runs only when MC server process is active
+        self.global_monitor_thread = None # Runs perpetually to send status updates
+        
         self.console_history = []
         self.max_history = 1000
         self.start_time = None
@@ -33,6 +38,9 @@ class MinecraftServerManager:
             'uptime': 0.0
         }
         self._lock = threading.Lock()
+        
+        # Start the global monitor immediately upon initialization
+        self.start_global_monitor()
 
     # --- Utility Methods ---
 
@@ -62,8 +70,6 @@ class MinecraftServerManager:
 
     def _emit_event(self, event, data):
         """Emit a socketio event safely"""
-        # Note: We must use socketio.start_background_task or run in the main thread context
-        # when emitting from a non-Flask thread. Flask-SocketIO handles this.
         if self.socketio:
             self.socketio.emit(event, data)
 
@@ -92,8 +98,7 @@ class MinecraftServerManager:
 
             self.starting = True
         
-        # CRITICAL FIX: Emit status change immediately
-        self._emit_status_update()
+        self._emit_status_update() # Notify client 'Starting...' status
 
         try:
             # Ensure eula is accepted
@@ -123,18 +128,17 @@ class MinecraftServerManager:
             self.output_thread = threading.Thread(target=self._read_output, daemon=True)
             self.output_thread.start()
 
-            # Start stats monitoring thread
-            self.stats_thread = threading.Thread(target=self._monitor_stats, daemon=True)
-            self.stats_thread.start()
+            # Start the detailed process stats monitoring thread
+            self.process_stats_thread = threading.Thread(target=self._monitor_stats_process, daemon=True)
+            self.process_stats_thread.start()
             
-            # CRITICAL FIX: Final status update
-            self._emit_status_update()
+            self._emit_status_update() # Final status update (Online)
             self.log("Server process started successfully")
             return {"success": True, "message": "Server starting..."}
 
         except Exception as e:
             self.starting = False
-            self._emit_status_update() # Notify client of failure
+            self._emit_status_update() 
             self.log(f"Failed to start server: {str(e)}", "error")
             return {"success": False, "message": str(e)}
 
@@ -146,8 +150,7 @@ class MinecraftServerManager:
 
             self.stopping = True
         
-        # CRITICAL FIX: Emit status change immediately
-        self._emit_status_update()
+        self._emit_status_update() # Notify client 'Stopping...' status
 
         try:
             if force:
@@ -158,32 +161,32 @@ class MinecraftServerManager:
 
                 # Wait for graceful shutdown
                 for _ in range(30):  # 30 second timeout
-                    if self.process.poll() is not None:
+                    if self.process and self.process.poll() is not None:
                         break
                     time.sleep(1)
                 else:
                     # Force kill if not stopped
-                    self.process.kill()
+                    if self.process:
+                        self.process.kill()
             
-            # Ensure threads are cleaned up
+            # Clean up state
             self.running = False
             self.stopping = False
             self.start_time = None
             self.players_online = []
             
-            # Reset stats
+            # Reset stats to zero
             self.server_stats = {'cpu': 0.0, 'memory': 0.0, 'tps': 0.0, 'uptime': 0.0}
-            self._emit_stats_update() # Push zero stats
-
-            self._emit_status_update() # Final status update (Offline)
-            self._emit_player_update() # Push empty player list
+            
+            self._emit_status_update() 
+            self._emit_player_update() 
             self.log("Server stopped")
             return {"success": True, "message": "Server stopped"}
 
         except Exception as e:
             self.stopping = False
             self.log(f"Error stopping server: {str(e)}", "error")
-            self._emit_status_update() # Revert status if error
+            self._emit_status_update() 
             return {"success": False, "message": str(e)}
 
     def restart(self):
@@ -210,10 +213,65 @@ class MinecraftServerManager:
 
     # --- Threaded Methods ---
 
+    def start_global_monitor(self):
+        """Starts a persistent thread to monitor status and periodically update client."""
+        if self.global_monitor_thread is None or not self.global_monitor_thread.is_alive():
+            self.global_monitor_thread = threading.Thread(target=self._monitor_stats_global, daemon=True)
+            self.global_monitor_thread.start()
+            self.log("Global status monitor started.", "internal")
+
+    def _monitor_stats_global(self):
+        """Monitors status and periodically emits status_update and stats_update."""
+        while True:
+            try:
+                # 1. Update Uptime if server is running
+                if self.running and self.start_time:
+                    with self._lock:
+                        self.server_stats['uptime'] = (datetime.now() - self.start_time).total_seconds()
+                
+                # 2. Emit updates to keep the dashboard fresh
+                self._emit_status_update()
+                self._emit_stats_update()
+
+            except Exception as e:
+                # Log any errors but keep the monitor thread running
+                print(f"Global Stats Monitor Error: {e}") 
+            
+            time.sleep(GLOBAL_STATUS_INTERVAL) 
+
+    def _monitor_stats_process(self):
+        """Monitor server resource usage, running ONLY when the MC process is active."""
+        # Use a short interval for high-detail stats (1 sec)
+        while self.running:
+            try:
+                if self.process and self.process.pid:
+                    # Check if process is still running via poll
+                    if self.process.poll() is not None:
+                        self.running = False
+                        self.log("Process stats monitor detected server termination.", "warn")
+                        break
+
+                    proc = psutil.Process(self.process.pid)
+                    
+                    with self._lock:
+                        # Non-blocking read (CPU usage since last call)
+                        self.server_stats['cpu'] = proc.cpu_percent(interval=None) 
+                        # RSS (Resident Set Size) in MB
+                        self.server_stats['memory'] = proc.memory_info().rss / (1024 * 1024) 
+                        
+                        # We don't emit here; the global monitor will use these stats
+                        # and emit them at the slower GLOBAL_STATUS_INTERVAL.
+
+                time.sleep(PROCESS_STATS_INTERVAL)
+            
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                self.running = False
+                self.log("Stats monitor lost server process.", "warn")
+                break # Exit the process-specific loop
+
     def _read_output(self):
         """Read and process server output"""
         try:
-            # Use 'iter' to continuously read the stream until the process closes
             for line in iter(self.process.stdout.readline, ''):
                 if not line:
                     break
@@ -221,13 +279,13 @@ class MinecraftServerManager:
                 line = line.strip()
                 if line:
                     self._process_line(line)
-                    self.log(line) # Logs the line and emits 'console_output'
+                    self.log(line) 
 
         except Exception as e:
             self.log(f"Error reading output: {str(e)}", "error")
         finally:
             self.log("Server process ended")
-            # CRITICAL FIX: Reset state when the process dies unexpectedly
+            # Reset state when the process dies
             self.running = False
             self.starting = False
             self.stopping = False
@@ -265,36 +323,6 @@ class MinecraftServerManager:
             with self._lock:
                 self.server_stats['tps'] = float(tps_match.group(1))
 
-    def _monitor_stats(self):
-        """Monitor server resource usage"""
-        while self.running:
-            try:
-                if self.process and self.process.pid:
-                    # Check if process is still running via poll
-                    if self.process.poll() is not None:
-                        self.running = False
-                        self.log("Stats monitor detected server process termination.", "warn")
-                        break
-
-                    proc = psutil.Process(self.process.pid)
-                    
-                    with self._lock:
-                        self.server_stats['cpu'] = proc.cpu_percent(interval=None) # Non-blocking read
-                        # Use get_memory_info() for reliable RSS value
-                        self.server_stats['memory'] = proc.memory_info().rss / (1024 * 1024)  # MB
-
-                        if self.start_time:
-                            self.server_stats['uptime'] = (datetime.now() - self.start_time).total_seconds()
-                        
-                    # CRITICAL FIX: Emit stats update here periodically
-                    self._emit_stats_update()
-            
-            except (psutil.NoSuchProcess, psutil.AccessDenied):
-                self.running = False
-                self.log("Stats monitor lost server process.", "warn")
-            
-            time.sleep(STATS_INTERVAL)
-
     # --- Client Data Methods ---
 
     def get_status(self):