Update server.py

server.py

@@ -1,30 +1,40 @@
-from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect, status
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 import json
+import asyncio
 import uvicorn
+from typing import Dict, Set
+import logging
 
-app = FastAPI()
+# Logging konfigurieren
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-# Configure CORS
+app = FastAPI(title="EFT Group Map API")
+
+# CORS optimiert
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=["*"],  # In Produktion spezifische Origins verwenden
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Serve static files
 app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Set up Jinja2 templates
 templates = Jinja2Templates(directory="templates")
 
-with open("data.json", "r", encoding="utf8") as file:
-    maps_data = json.load(file)
+# Caching für Maps-Daten
+maps_data = {}
+try:
+    with open("data.json", "r", encoding="utf8") as file:
+        maps_data = json.load(file)
+except FileNotFoundError:
+    logger.error("data.json nicht gefunden")
+    maps_data = {}
 
 
 @app.get("/", response_class=HTMLResponse)
@@ -35,53 +45,66 @@ async def read_index(request: Request):
 @app.get("/map/{normalized_name}", response_class=HTMLResponse)
 async def get_map_by_normalized_name(request: Request, normalized_name: str):
     map_entry = maps_data.get(normalized_name)
-    if map_entry:
-        filtered_maps = [map_entry]
-    else:
-        filtered_maps = []
+    filtered_maps = [map_entry] if map_entry else []
     return templates.TemplateResponse("map.html", {"request": request, "maps": filtered_maps})
 
 
 class ConnectionManager:
     def __init__(self):
-        self.groups: dict[str, set[WebSocket]] = {}
-        self.connections: dict[WebSocket, str] = {}
+        self.groups: Dict[str, Set[WebSocket]] = {}
+        self.connections: Dict[WebSocket, str] = {}
+        self.message_stats = {"total_sent": 0, "total_received": 0}
 
     async def connect(self, websocket: WebSocket):
         await websocket.accept()
+        logger.info(f"Neue WebSocket-Verbindung: {websocket.client}")
 
     def disconnect(self, websocket: WebSocket):
         if websocket in self.connections:
             group_name = self.connections[websocket]
             self.remove_from_group(websocket, group_name)
+            logger.info(f"Client disconnected from group '{group_name}'")
 
     async def join_group(self, websocket: WebSocket, group_name: str):
         # Remove from previous group if exists
         if websocket in self.connections:
             old_group = self.connections[websocket]
             self.remove_from_group(websocket, old_group)
-        
+
         # Add to new group
         if group_name not in self.groups:
             self.groups[group_name] = set()
         self.groups[group_name].add(websocket)
         self.connections[websocket] = group_name
-        print(f"Client joined group '{group_name}'")
+        logger.info(f"Client joined group '{group_name}' (Total groups: {len(self.groups)})")
 
     def remove_from_group(self, websocket: WebSocket, group_name: str):
         if group_name in self.groups and websocket in self.groups[group_name]:
             self.groups[group_name].remove(websocket)
-            if len(self.groups[group_name]) == 0:
+            if not self.groups[group_name]:  # Leere Gruppen entfernen
                 del self.groups[group_name]
-                print(f"Group '{group_name}' deleted (no members)")
+                logger.info(f"Group '{group_name}' deleted (no members)")
+
         if websocket in self.connections:
             del self.connections[websocket]
-        print(f"Client removed from group '{group_name}'")
 
     async def broadcast_to_group(self, message: str, group_name: str):
         if group_name in self.groups:
-            for connection in self.groups[group_name]:
-                await connection.send_text(message)
+            disconnected = set()
+            for connection in self.groups[group_name].copy():  # Kopie für sichere Iteration
+                try:
+                    await connection.send_text(message)
+                    self.message_stats["total_sent"] += 1
+                except Exception as e:
+                    logger.error(f"Fehler beim Senden an Client: {e}")
+                    disconnected.add(connection)
+
+            # Entferne defekte Verbindungen
+            for conn in disconnected:
+                self.disconnect(conn)
+
+    def get_stats(self):
+        return {"active_groups": len(self.groups), "total_connections": len(self.connections), **self.message_stats}
 
 
 manager = ConnectionManager()
@@ -93,41 +116,54 @@ async def websocket_endpoint(websocket: WebSocket):
     try:
         while True:
             data = await websocket.receive_text()
+            manager.message_stats["total_received"] += 1
+
             try:
                 message = json.loads(data)
+
                 # Handle join messages
-                if message.get('type') == 'join':
-                    group_name = message.get('group')
+                if message.get("type") == "join":
+                    group_name = message.get("group")
                     if group_name:
                         await manager.join_group(websocket, group_name)
+                        # Bestätigungsmessage
+                        await websocket.send_text(json.dumps({"type": "joined", "group": group_name, "message": f"Erfolgreich Gruppe '{group_name}' beigetreten"}))
                     else:
-                        error = json.dumps({
-                            "type": "error",
-                            "message": "Missing group name in join request"
-                        })
-                        await websocket.send_text(error)
-                
+                        error_msg = {"type": "error", "message": "Missing group name in join request"}
+                        await websocket.send_text(json.dumps(error_msg))
+
+                # Ping/Pong für Verbindungsprüfung
+                elif message.get("type") == "ping":
+                    await websocket.send_text(json.dumps({"type": "pong"}))
+
                 # Broadcast all other messages to the group
                 else:
                     if websocket in manager.connections:
                         group_name = manager.connections[websocket]
                         await manager.broadcast_to_group(data, group_name)
                     else:
-                        error = json.dumps({
-                            "type": "error",
-                            "message": "Join a group before sending messages"
-                        })
-                        await websocket.send_text(error)
-            
+                        error_msg = {"type": "error", "message": "Join a group before sending messages"}
+                        await websocket.send_text(json.dumps(error_msg))
+
             except json.JSONDecodeError:
-                # Handle non-JSON messages by broadcasting directly
+                logger.warning(f"Invalid JSON received: {data}")
                 if websocket in manager.connections:
                     group_name = manager.connections[websocket]
                     await manager.broadcast_to_group(data, group_name)
-    
+
     except WebSocketDisconnect:
+        logger.info("WebSocket disconnected")
         manager.disconnect(websocket)
+    except Exception as e:
+        logger.error(f"Unerwarteter Fehler: {e}")
+        manager.disconnect(websocket)
+
+
+# Health Check Endpoint
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "websocket_stats": manager.get_stats()}
 
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")