Enhance logging in WebSocket server: Add detailed logging for TLS initialization, TCP connection acceptance, and WebSocket handshake processes. Improve error messages to provide clearer feedback on potential issues, enhancing overall server diagnostics and user awareness.

src/websocket_server.rs

@@ -238,7 +238,10 @@ impl WebSocketServer {
                 self.cert_path.as_deref(),
                 self.key_path.as_deref(),
             ) {
-                Ok(acc) => Some(acc),
+                Ok(acc) => {
+                    println!("[WebSocketServer] TLS erfolgreich initialisiert. Server akzeptiert wss:// Verbindungen.");
+                    Some(acc)
+                }
                 Err(err) => {
                     eprintln!(
                         "[WebSocketServer] TLS-Initialisierung fehlgeschlagen, starte ohne SSL: {err}"
@@ -250,6 +253,7 @@ impl WebSocketServer {
                 }
             }
         } else {
+            println!("[WebSocketServer] TLS deaktiviert. Server akzeptiert nur ws:// Verbindungen (nicht wss://).");
             None
         };
 
@@ -300,48 +304,75 @@ async fn run_accept_loop(
     tls_acceptor: Option<TlsAcceptor>,
 ) {
     let listener = match TcpListener::bind(&addr).await {
-        Ok(l) => l,
+        Ok(l) => {
+            println!("[WebSocketServer] Erfolgreich gebunden an {}", addr);
+            l
+        }
         Err(e) => {
-            eprintln!("[WebSocketServer] Fehler beim Binden an {}: {}", addr, e);
+            eprintln!("[WebSocketServer] FEHLER: Konnte nicht an {} binden: {}", addr, e);
+            eprintln!("[WebSocketServer] Mögliche Ursachen: Port bereits belegt, keine Berechtigung, oder Firewall blockiert.");
             running.store(false, Ordering::SeqCst);
             return;
         }
     };
 
-    println!("[WebSocketServer] Lauscht auf {}", addr);
+    println!("[WebSocketServer] Lauscht auf {} (TLS: {})", addr, tls_acceptor.is_some());
+
+    // Heartbeat: Logge regelmäßig, dass der Server läuft
+    let mut heartbeat_interval = interval(TokioDuration::from_secs(300)); // Alle 5 Minuten
+    let server_start = std::time::Instant::now();
 
     while running.load(Ordering::SeqCst) {
-        let (stream, peer) = match listener.accept().await {
-            Ok(v) => v,
-            Err(e) => {
-                eprintln!("[WebSocketServer] accept() fehlgeschlagen: {}", e);
-                continue;
+        tokio::select! {
+            // Heartbeat: Logge alle 5 Minuten, dass der Server läuft
+            _ = heartbeat_interval.tick() => {
+                let uptime = server_start.elapsed().as_secs();
+                println!("[WebSocketServer] Heartbeat: Server läuft seit {} Sekunden auf {} (TLS: {})", 
+                    uptime, addr, tls_acceptor.is_some());
             }
-        };
+            // Neue Verbindung akzeptieren
+            result = listener.accept() => {
+                match result {
+                    Ok((stream, peer)) => {
 
-        let peer_addr = peer;
-        let rx = tx.subscribe();
-        let registry_clone = registry.clone();
-        let ws_log_clone = ws_log.clone();
-        let tls_acceptor_clone = tls_acceptor.clone();
+                        let peer_addr = peer;
+                        let rx = tx.subscribe();
+                        let registry_clone = registry.clone();
+                        let ws_log_clone = ws_log.clone();
+                        let tls_acceptor_clone = tls_acceptor.clone();
 
-        tokio::spawn(async move {
-            if let Some(acc) = tls_acceptor_clone {
-                match acc.accept(stream).await {
-                    Ok(tls_stream) => {
-                        handle_connection(tls_stream, peer_addr, rx, registry_clone, ws_log_clone)
-                            .await
+                        tokio::spawn(async move {
+                            if let Some(acc) = tls_acceptor_clone {
+                                println!("[WebSocketServer] Neue TCP-Verbindung von {} (TLS-Handshake wird durchgeführt...)", peer_addr);
+                                match acc.accept(stream).await {
+                                    Ok(tls_stream) => {
+                                        println!("[WebSocketServer] TLS-Handshake erfolgreich für {}", peer_addr);
+                                        handle_connection(tls_stream, peer_addr, rx, registry_clone, ws_log_clone)
+                                            .await
+                                    }
+                                    Err(err) => {
+                                        eprintln!(
+                                            "[WebSocketServer] TLS-Handshake fehlgeschlagen ({peer_addr}): {err}"
+                                        );
+                                        eprintln!(
+                                            "[WebSocketServer] Mögliche Ursachen: Ungültiges Zertifikat, unsupported Cipher, oder Client verwendet ws:// statt wss://"
+                                        );
+                                    }
+                                }
+                            } else {
+                                println!("[WebSocketServer] Neue TCP-Verbindung von {} (ohne TLS)", peer_addr);
+                                handle_connection(stream, peer_addr, rx, registry_clone, ws_log_clone).await;
+                            }
+                        });
                     }
-                    Err(err) => {
-                        eprintln!(
-                            "[WebSocketServer] TLS-Handshake fehlgeschlagen ({peer_addr}): {err}"
-                        );
+                    Err(e) => {
+                        eprintln!("[WebSocketServer] accept() fehlgeschlagen: {}", e);
+                        // Kurz warten, um CPU-Last zu reduzieren bei wiederholten Fehlern
+                        tokio::time::sleep(TokioDuration::from_millis(100)).await;
                     }
                 }
-            } else {
-                handle_connection(stream, peer_addr, rx, registry_clone, ws_log_clone).await;
             }
-        });
+        }
     }
 }
 
@@ -355,14 +386,18 @@ async fn handle_connection<S>(
     S: AsyncRead + AsyncWrite + Unpin + Send + 'static,
 {
     let ws_stream = match accept_async(stream).await {
-        Ok(ws) => ws,
+        Ok(ws) => {
+            println!("[WebSocketServer] WebSocket-Handshake erfolgreich für {}", peer_addr);
+            ws
+        }
         Err(e) => {
             eprintln!("[WebSocketServer] WebSocket-Handshake fehlgeschlagen ({peer_addr}): {e}");
+            eprintln!("[WebSocketServer] Mögliche Ursachen: Client sendet kein WebSocket-Request, falscher Upgrade-Header, oder Protokoll-Mismatch");
             return;
         }
     };
 
-    println!("[WebSocketServer] Neue Verbindung von {}", peer_addr);
+    println!("[WebSocketServer] Neue WebSocket-Verbindung etabliert von {}", peer_addr);
 
     let (mut ws_sender, mut ws_receiver) = ws_stream.split();