diff --git a/CMBNet/README_CMBNet.md b/CMBNet/README_CMBNet.md index 716a606..5dd8654 100644 --- a/CMBNet/README_CMBNet.md +++ b/CMBNet/README_CMBNet.md @@ -48,29 +48,34 @@ Clients den Header nicht selbst setzen können. ## WebSocket-Synchronisierung -Jeder Browser-Tab erzeugt eine Sitzungs-ID, die in `sessionStorage` gespeichert -wird und ein Neuladen übersteht. Nicht zustellbare Nachrichten mit Code >= 100 -werden beim Broker pro `(Mandant, Account, Sitzungs-ID)` gepuffert und bei der -nächsten WebSocket-Verbindung mit derselben ID ausgeliefert. +Jede Webview erzeugt beim Laden einmalig eine Client-ID. Sie wird bewusst nicht +in `sessionStorage` gespeichert: Ein Seiten-Reload erzeugt eine neue Client-ID +und damit eine neue Broker-Verbindung. Nicht zustellbare Nachrichten mit +Code >= 100 werden beim Broker pro `(Mandant, Client-ID)` gepuffert und bei der +nächsten WebSocket-Verbindung mit derselben Client-ID ausgeliefert. Mehrere +Clients desselben Accounts werden getrennt verwaltet und alle beliefert. -Die beiden Zeitfenster lassen sich über Umgebungsvariablen konfigurieren: +Die Zeitfenster lassen sich über Umgebungsvariablen konfigurieren: - `CMBNET_WS_QUEUE_MAX_AGE_MINUTES` (Default `15`): Maximales Alter einer - Sitzungs-Queue. Ältere Queues werden verworfen; beim nächsten Reconnect wird - stattdessen eine Code-99-Nachricht mit Hinweis auf die zu lange Unterbrechung - zugestellt. + Client-Queue. Ältere Queues werden verworfen; beim nächsten Reconnect mit + derselben Client-ID wird stattdessen eine Code-99-Nachricht mit Hinweis auf + die zu lange Unterbrechung zugestellt. +- `CMBNET_WS_CLIENT_RETENTION_MINUTES` (Default `60`): Wie lange eine nicht mehr + verbundene Webview samt Queue registriert bleibt, bevor der Broker sie + endgültig aufräumt. - `CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS` (Default `120`): Zeit ohne Code-2- Lebenszeichen, nach der eine Gruppe von `online` auf `unterwegs` wechselt. - `CMBNET_WS_DEBUG_MESSAGES` (Default `1`): schreibt jede beim Broker - eingehende Nachricht inklusive Absender, Code und ermitteltem Empfängerkreis - nach `logs/cmbnet-ws-YYYY-MM-DD.log`. Mit `0` lässt sich die Ausgabe - abschalten. + eingehende Nachricht inklusive Absender, Client-ID, Code und ermitteltem + Empfängerkreis nach `logs/cmbnet-ws-YYYY-MM-DD.log`. Mit `0` lässt sich die + Ausgabe abschalten. -Die Sitzungs-Queues liegen im Arbeitsspeicher des Broker-Prozesses. Sie -überstehen damit WebSocket-Unterbrechungen und Seiten-Reloads, nicht aber einen -Neustart des Servers. Der mobile Client puffert zusätzlich ausgehende -fachliche Nachrichten kurzzeitig lokal und sendet sie nach erfolgreicher -Authentifizierung automatisch nach. +Die Client-Queues liegen im Arbeitsspeicher des Broker-Prozesses. Sie +überstehen damit kurze WebSocket-Unterbrechungen, nicht aber einen +Seiten-Reload mit neuer Client-ID oder einen Neustart des Servers. Der mobile +Client puffert zusätzlich ausgehende fachliche Nachrichten kurzzeitig im +Speicher und sendet sie nach erfolgreicher Authentifizierung automatisch nach. Eine ausführliche Beschreibung des Protokolls, der Brokerlogik, der Nebenläufigkeit und der aktuellen Abweichungen steht in diff --git a/CMBNet/cmbnet/admin/api.py b/CMBNet/cmbnet/admin/api.py index 81059ec..a8a4c1d 100644 --- a/CMBNet/cmbnet/admin/api.py +++ b/CMBNet/cmbnet/admin/api.py @@ -359,17 +359,20 @@ def broker_status(**kwargs): """Status aktiver WebSocket-Verbindungen""" connections = broker.connections.get(g.tenant_id, {}) if hasattr(broker, 'connections') else {} result = [] - for account_id, conn in connections.items(): - account = db = get_db().execute( + for client_id, conn in connections.items(): + account_id = conn.get('account_id') + account = get_db().execute( 'SELECT id, name, role FROM accounts WHERE id = ? AND tenant_id = ?', (account_id, g.tenant_id) ).fetchone() if not account: continue entry = { + 'client_id': client_id, 'account_id': account['id'], 'account_name': account['name'], 'role': account['role'], + 'authenticated': broker.is_authenticated(g.tenant_id, client_id), 'group_id': None, 'group_alias': None } diff --git a/CMBNet/cmbnet/ws/broker.py b/CMBNet/cmbnet/ws/broker.py index 1fa17f2..2280611 100644 --- a/CMBNet/cmbnet/ws/broker.py +++ b/CMBNet/cmbnet/ws/broker.py @@ -25,6 +25,7 @@ Wichtige Regeln aus der Spezifikation: import json import re import time +import uuid from datetime import datetime, timedelta, timezone from threading import Lock from flask import current_app @@ -35,24 +36,34 @@ from cmbnet.ws.protocol import WSMessage class WebSocketBroker: def __init__(self): - # connections[tenant_id][account_id] = { + # connections[tenant_id][client_id] = { # 'ws': , + # 'account_id': , # 'role': , # 'group_id': , # } + # Eine Client-ID gehört genau zu einer Webview. Mehrere Clients + # desselben Accounts besitzen daher getrennte Einträge. self.connections = {} - # authenticated[tenant_id][account_id] = True + # authenticated[tenant_id][client_id] = True # Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten # über die Verbindung senden. self.authenticated = {} - # Nicht zustellbare Nachrichten werden pro Client-Sitzung gepuffert. - # Schlüssel: (tenant_id, account_id, session_id). - self.session_queues = {} - # Zuletzt bekannte Sitzungs-ID je Account. Sie erlaubt es, Nachrichten - # auch dann der richtigen Queue zuzuordnen, wenn gerade keine - # WebSocket-Verbindung besteht. - self.account_sessions = {} + # Nicht zustellbare Nachrichten werden pro Client gepuffert. + # Schlüssel: (tenant_id, client_id). + self.client_queues = {} + # client_accounts[(tenant_id, client_id)] = account_id + # Bleibt auch nach einem Verbindungsabbruch erhalten, damit weitere + # Nachrichten für denselben Client gepuffert werden können. + self.client_accounts = {} + # account_clients[(tenant_id, account_id)] = {client_id, ...} + # Wird für die Empfängerermittlung benötigt: Ein Account kann mehrere + # Clients gleichzeitig betreiben. + self.account_clients = {} + # disconnected_clients[(tenant_id, client_id)] = monotonic Zeitpunkt. + # Dient dem Aufräumen dauerhaft verlassener Webviews. + self.disconnected_clients = {} self.queue_lock = Lock() # Zeitpunkt des letzten Code-2-Pongs je Gruppe (monotonic). @@ -62,12 +73,16 @@ class WebSocketBroker: # ------------------------------------------------------------------ # Verbindungen und Authentifizierung # ------------------------------------------------------------------ - def register_connection(self, tenant_id, account_id, ws, role=None, group_id=None): - """Registriert eine neue, noch nicht authentifizierte Verbindung. + def register_connection(self, tenant_id, account_id, client_id, ws, role=None, group_id=None): + """Registriert eine neue, noch nicht authentifizierte Client-Verbindung. - Rolle und Gruppenzuordnung werden direkt mitgespeichert. Sie werden - später für die Empfängerermittlung und für das Cleanup benötigt. + Die Verbindung wird anhand der Client-ID verwaltet. Die Account-ID wird + mitgeführt, damit Empfänger weiterhin über Rollen und Gruppen ermittelt + werden können und ein Account mehrere Clients parallel betreiben kann. """ + if not client_id: + return False + db = get_db() account = db.execute( 'SELECT role FROM accounts WHERE id = ? AND tenant_id = ?', @@ -76,6 +91,13 @@ class WebSocketBroker: if not account: return False + # Eine Client-ID ist an den Account gebunden, der sie im Handshake + # verwendet hat. Ein Wechsel des Accounts unter derselben ID wäre ein + # Hinweis auf eine falsche bzw. manipulierte Zuordnung. + existing_account = self.client_accounts.get((tenant_id, client_id)) + if existing_account is not None and existing_account != account_id: + return False + if role is None: role = account['role'] @@ -91,24 +113,35 @@ class WebSocketBroker: ).fetchone() group_id = group['id'] if group else None - if tenant_id not in self.connections: - self.connections[tenant_id] = {} + connections = self.connections.setdefault(tenant_id, {}) + + # Eine neue Verbindung mit derselben Client-ID ersetzt eine eventuell + # noch registrierte alte Verbindung (z. B. nach einem schnellen + # Reconnect). + existing = connections.get(client_id) + if existing and existing.get('ws') is not ws: + try: + existing['ws'].close() + except Exception: + pass # Eine neue Verbindung muss den Token-Handshake erneut durchlaufen. - # Ein eventuell noch gesetzter Auth-Status einer älteren Verbindung - # desselben Accounts darf nicht übernommen werden. - authenticated = self.authenticated.get(tenant_id) - if authenticated: - authenticated.pop(account_id, None) + authenticated = self.authenticated.setdefault(tenant_id, {}) + authenticated.pop(client_id, None) - self.connections[tenant_id][account_id] = { + connections[client_id] = { 'ws': ws, + 'account_id': account_id, + 'client_id': client_id, 'role': role, 'group_id': group_id, - 'session_id': None, 'last_ping': datetime.now(), 'connected_at': time.monotonic(), 'last_pong_at': None, + # Ob diese Client-ID bereits vor diesem Handshake bekannt war. + # Nur dann bleibt ihre Queue auch bei einem fehlgeschlagenen + # erneuten Handshake erhalten. + 'known_client': existing_account is not None, # simple-websocket schreibt Nachrichten direkt auf den Socket. # Da Heartbeat, WebSocket-Routen und HTTP-ausgelöste Broadcasts # aus unterschiedlichen Threads senden können, müssen die Frames @@ -116,11 +149,15 @@ class WebSocketBroker: # Frames überlagern und der Browser meldet "Invalid frame header". 'send_lock': Lock() } + + self.client_accounts[(tenant_id, client_id)] = account_id + self.account_clients.setdefault((tenant_id, account_id), set()).add(client_id) + self.disconnected_clients.pop((tenant_id, client_id), None) return True - def send_to_connection(self, tenant_id, account_id, data): - """Sendet einen Frame thread-sicher an eine registrierte Verbindung.""" - conn = self._get_connection(tenant_id, account_id) + def send_to_connection(self, tenant_id, client_id, data): + """Sendet einen Frame thread-sicher an eine registrierte Client-Verbindung.""" + conn = self._get_connection(tenant_id, client_id) if not conn: return False @@ -138,17 +175,21 @@ class WebSocketBroker: # Schließen der Verbindung. return False - def is_authenticated(self, tenant_id, account_id): - """Prüft, ob eine Verbindung den Code-0-Handshake erfolgreich absolviert hat.""" - return self.authenticated.get(tenant_id, {}).get(account_id, False) + def is_authenticated(self, tenant_id, client_id): + """Prüft, ob ein Client den Code-0-Handshake erfolgreich absolviert hat.""" + return self.authenticated.get(tenant_id, {}).get(client_id, False) - def authenticate(self, tenant_id, account_id, token, session_id=None): - """Authentifiziert eine Verbindung anhand des Einmal-Tokens (Code 0). + def authenticate(self, tenant_id, account_id, client_id, token): + """Authentifiziert eine Client-Verbindung anhand des Einmal-Tokens (Code 0). - Die Sitzungs-ID stammt vom Client und bleibt auch nach einem Neuladen - erhalten. Sie ordnet die Verbindung einer eventuell vorhandenen - Nachrichten-Queue zu. + Die Client-ID wird pro Webview erzeugt und ordnet die Verbindung einer + eventuell vorhandenen Nachrichten-Queue zu. Nach einem Neuladen der + Seite entsteht eine neue Client-ID und damit bewusst eine neue Sitzung. """ + conn = self._get_connection(tenant_id, client_id) + if not conn or conn.get('account_id') != account_id: + return False + db = get_db() token_row = db.execute( 'SELECT * FROM ws_tokens WHERE token = ? AND tenant_id = ? ' @@ -176,67 +217,83 @@ class WebSocketBroker: db.execute('UPDATE ws_tokens SET used = 1 WHERE id = ?', (token_row['id'],)) db.commit() - session_id = self._normalize_session_id(session_id, account_id) - conn = self._get_connection(tenant_id, account_id) - if conn: - conn['session_id'] = session_id - if conn.get('role') == 'Gruppe' and conn.get('group_id'): - # Ein frisch verbundener Gruppen-Client erhält eine - # Zwei-Minuten-Kulanz, bis der erste Code-2-Pong eintrifft. - key = (tenant_id, conn['group_id']) - self.group_online_since[key] = time.monotonic() - self.account_sessions[(tenant_id, account_id)] = session_id + if conn.get('role') == 'Gruppe' and conn.get('group_id'): + # Ein frisch verbundener Gruppen-Client erhält eine + # Zwei-Minuten-Kulanz, bis der erste Code-2-Pong eintrifft. + key = (tenant_id, conn['group_id']) + self.group_online_since[key] = time.monotonic() - if tenant_id not in self.authenticated: - self.authenticated[tenant_id] = {} - self.authenticated[tenant_id][account_id] = True + self.authenticated.setdefault(tenant_id, {})[client_id] = True + self.client_accounts[(tenant_id, client_id)] = account_id + self.account_clients.setdefault((tenant_id, account_id), set()).add(client_id) + self.disconnected_clients.pop((tenant_id, client_id), None) - # Zuerst die für diese Sitzung gepufferten Nachrichten ausliefern. + # Zuerst die für diesen Client gepufferten Nachrichten ausliefern. # Wurde die Queue wegen Überschreitung der Maximalzeit verworfen, wird # stattdessen ausschließlich ein Code-99-Hinweis gesendet. - queued_messages, suppress_late_entries = self.restore_session_queue( - tenant_id, account_id, session_id + queued_messages, suppress_late_entries = self.restore_client_queue( + tenant_id, client_id ) # Nach erfolgreicher Authentifizierung dürfen die gespeicherten # Nachrichten der letzten 8 Stunden nachgeliefert werden. Bereits aus - # der Sitzungs-Queue zugestellte Nachrichten werden dabei ausgelassen. + # der Client-Queue zugestellte Nachrichten werden dabei ausgelassen. if not suppress_late_entries: self.send_late_entries( tenant_id, account_id, + client_id, skip_messages=queued_messages ) return True - def remove_connection(self, tenant_id, account_id, ws=None): - """Entfernt eine Verbindung. + def remove_connection(self, tenant_id, client_id, ws=None): + """Entfernt eine Client-Verbindung. - Wenn ein Account mehrere Tabs/Verbindungen öffnet, wird nur die - tatsächlich beendete Verbindung entfernt (ws-Vergleich), nicht die - zuletzt registrierte. + Die Client-ID bleibt mit ihrem Account und ihrer Queue registriert, bis + sie entweder zurückkehrt oder vom Aufräumjob verworfen wird. Dadurch + können kurze Unterbrechungen überbrückt werden, ohne andere Clients + desselben Accounts zu beeinflussen. """ connections = self.connections.get(tenant_id) - if connections and account_id in connections: - conn = connections[account_id] - if ws is None or conn.get('ws') is ws: - session_id = conn.get('session_id') - del connections[account_id] - # Nur wenn die tatsächlich beendete Verbindung die aktuelle - # war, darf auch der Authentifizierungsstatus entfernt werden. - authenticated = self.authenticated.get(tenant_id) - if authenticated and account_id in authenticated: - del authenticated[account_id] + if not connections or client_id not in connections: + return - # Ab dem Trennen beginnt die Lebenszeit der Sitzungs-Queue. - if session_id: - with self.queue_lock: - self._ensure_session_queue( - tenant_id, account_id, session_id - ) + conn = connections[client_id] + if ws is not None and conn.get('ws') is not ws: + return - def _get_connection(self, tenant_id, account_id): - return self.connections.get(tenant_id, {}).get(account_id) + was_authenticated = self.is_authenticated(tenant_id, client_id) + was_known_client = conn.get('known_client', True) + + del connections[client_id] + if not connections: + self.connections.pop(tenant_id, None) + + authenticated = self.authenticated.get(tenant_id) + if authenticated: + authenticated.pop(client_id, None) + if not authenticated: + self.authenticated.pop(tenant_id, None) + + if not was_authenticated and not was_known_client: + # Ein nie erfolgreich authentifizierter neuer Client hinterlässt + # keine Zuordnung, Queue oder Empfängerregistrierung. + account_id = self.client_accounts.pop((tenant_id, client_id), None) + self.client_queues.pop((tenant_id, client_id), None) + self.disconnected_clients.pop((tenant_id, client_id), None) + if account_id is not None: + clients = self.account_clients.get((tenant_id, account_id)) + if clients is not None: + clients.discard(client_id) + if not clients: + self.account_clients.pop((tenant_id, account_id), None) + return + + self.disconnected_clients[(tenant_id, client_id)] = time.monotonic() + + def _get_connection(self, tenant_id, client_id): + return self.connections.get(tenant_id, {}).get(client_id) def log_incoming(self, tenant_id, message, sender=None, recipients=None, note=None): """Schreibt eine Debugzeile für eine beim Broker eingehende Nachricht. @@ -260,19 +317,30 @@ class WebSocketBroker: (message.sender_id, tenant_id) ).fetchone() - sender_info = None - if sender is not None: - sender_info = self._get_sender_info(tenant_id, sender) + sender_info = ( + self._get_sender_info(tenant_id, sender) + if sender is not None else None + ) + sender_client_id = ( + getattr(message, '_sender_client_id', None) + or getattr(message, 'client_id', None) + ) + if sender_info is not None and sender_client_id: + sender_info['client_id'] = sender_client_id recipient_rows = [] for recipient_id in sorted(set(recipients or [])): - account = db.execute( - 'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?', - (recipient_id, tenant_id) - ).fetchone() + account_id = self.client_accounts.get((tenant_id, recipient_id)) + account = None + if account_id is not None: + account = db.execute( + 'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?', + (account_id, tenant_id) + ).fetchone() if account is None: recipient_rows.append({ - 'account_id': recipient_id, + 'client_id': recipient_id, + 'account_id': account_id, 'known': False, 'connected': False, 'authenticated': False @@ -280,6 +348,7 @@ class WebSocketBroker: continue info = self._get_sender_info(tenant_id, account) + info['client_id'] = recipient_id info['connected'] = bool(self._get_connection(tenant_id, recipient_id)) info['authenticated'] = self.is_authenticated(tenant_id, recipient_id) recipient_rows.append(info) @@ -297,7 +366,7 @@ class WebSocketBroker: 'code': message.code, 'sender': sender_info, 'receiver_id': message.receiver_id, - 'session_id': getattr(message, 'session_id', None), + 'client_id': sender_client_id, 'ts': message.ts, 'msg': payload, 'recipients': recipient_rows, @@ -314,21 +383,23 @@ class WebSocketBroker: pass # ------------------------------------------------------------------ - # Sitzungs-Queues + # Client-Queues # ------------------------------------------------------------------ @staticmethod - def _normalize_session_id(value, account_id): - """Validiert die vom Client gelieferte Sitzungs-ID. + def normalize_client_id(value, account_id=None): + """Validiert die vom Webview gelieferte Client-ID. - Ältere Clients senden noch keine ID. Für sie wird eine stabile - Ersatz-ID je Account gebildet, damit auch dort die Queue funktioniert. + Die Client-ID wird pro Seitenaufruf neu erzeugt. Ältere Clients, die + noch keine ID senden, erhalten eine eindeutige Ersatz-ID. Diese ist + bewusst nicht accountweit stabil, weil eine neue Verbindung ohne ID + nicht sicher derselben alten Webview zugeordnet werden kann. """ text = str(value or '').strip() if re.fullmatch(r'[A-Za-z0-9._:-]{8,128}', text): return text - return f'legacy-{account_id}' + return f'legacy-{account_id or 0}-{uuid.uuid4().hex}' - def _session_queue_max_age_seconds(self): + def _client_queue_max_age_seconds(self): minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15) try: minutes = float(minutes) @@ -336,10 +407,18 @@ class WebSocketBroker: minutes = 15 return max(0.0, minutes * 60) - def _ensure_session_queue(self, tenant_id, account_id, session_id, now=None): - """Liefert die Queue einer Sitzung und legt sie bei Bedarf an.""" - key = (tenant_id, account_id, session_id) - queue = self.session_queues.get(key) + def _client_retention_seconds(self): + minutes = current_app.config.get('WS_CLIENT_RETENTION_MINUTES', 60) + try: + minutes = float(minutes) + except (TypeError, ValueError): + minutes = 60 + return max(self._client_queue_max_age_seconds(), minutes * 60) + + def _ensure_client_queue(self, tenant_id, client_id, now=None): + """Liefert die Queue eines Clients und legt sie bei Bedarf an.""" + key = (tenant_id, client_id) + queue = self.client_queues.get(key) if queue is None: queue = { 'messages': [], @@ -347,33 +426,33 @@ class WebSocketBroker: 'expired': False, 'code99_only': False, 'code99_message': None, + 'account_id': self.client_accounts.get(key), } - self.session_queues[key] = queue + self.client_queues[key] = queue return queue - def _expire_session_queue(self, queue, now=None): + def _expire_client_queue(self, queue, now=None): """Verwirft zu alte Nachrichten und hinterlässt einen Code-99-Hinweis.""" if not queue or queue.get('code99_only') or queue.get('expired'): return now = now if now is not None else time.monotonic() - if now - queue.get('created_at', now) < self._session_queue_max_age_seconds(): + if now - queue.get('created_at', now) < self._client_queue_max_age_seconds(): return queue['messages'].clear() queue['expired'] = True - def _queue_undeliverable(self, tenant_id, account_id, message): - """Puffert eine nicht zustellbare Nachricht für die letzte Sitzung.""" + def _queue_undeliverable(self, tenant_id, client_id, message): + """Puffert eine nicht zustellbare Nachricht für einen Client.""" if message.code < 100 and message.code != 99: return - session_id = self.account_sessions.get((tenant_id, account_id)) - if not session_id: + if (tenant_id, client_id) not in self.client_accounts: return with self.queue_lock: - queue = self._ensure_session_queue(tenant_id, account_id, session_id) + queue = self._ensure_client_queue(tenant_id, client_id) now = time.monotonic() if message.code == 99: @@ -385,20 +464,46 @@ class WebSocketBroker: queue['expired'] = False return - self._expire_session_queue(queue, now) + self._expire_client_queue(queue, now) if queue.get('expired') or queue.get('code99_only'): return queue['messages'].append(message.to_json()) - def cleanup_session_queues(self): - """Markiert abgelaufene Sitzungs-Queues und verwirft deren Nachrichten.""" + def cleanup_client_queues(self): + """Räumt abgelaufene Client-Queues und verwaiste Webviews auf.""" now = time.monotonic() + retention = self._client_retention_seconds() with self.queue_lock: - for queue in self.session_queues.values(): - self._expire_session_queue(queue, now) + for queue in self.client_queues.values(): + self._expire_client_queue(queue, now) - def _session_queue_timeout_message(self): + for key, disconnected_at in list(self.disconnected_clients.items()): + tenant_id, client_id = key + if self._get_connection(tenant_id, client_id): + self.disconnected_clients.pop(key, None) + continue + if now - disconnected_at < retention: + continue + + queue = self.client_queues.get(key) + # Solange noch zustellbare Nachrichten warten, bleibt der + # Client registriert. Danach darf die verwaiste Webview + # inklusive Code-99-Tombstone verworfen werden. + if queue and not queue.get('expired') and not queue.get('code99_only'): + continue + + account_id = self.client_accounts.pop(key, None) + self.client_queues.pop(key, None) + self.disconnected_clients.pop(key, None) + if account_id is not None: + clients = self.account_clients.get((tenant_id, account_id)) + if clients is not None: + clients.discard(client_id) + if not clients: + self.account_clients.pop((tenant_id, account_id), None) + + def _client_queue_timeout_message(self): minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15) return WSMessage( sender_id=0, @@ -410,8 +515,8 @@ class WebSocketBroker: ) ).to_json() - def restore_session_queue(self, tenant_id, account_id, session_id): - """Liefert gepufferte Nachrichten einer wiedererkannten Sitzung aus. + def restore_client_queue(self, tenant_id, client_id): + """Liefert gepufferte Nachrichten eines wiedererkannten Clients aus. Rückgabe: (Menge der Roh-Nachrichten aus der Queue, Late-Entry-Sperre). Die Menge dient dazu, dieselben Nachrichten nicht zusätzlich als @@ -419,23 +524,23 @@ class WebSocketBroker: war oder nur noch eine Code-99-Nachricht enthielt. In diesem Fall darf keine zusätzliche Late-Entry-Historie mehr gesendet werden. """ - key = (tenant_id, account_id, session_id) + key = (tenant_id, client_id) now = time.monotonic() with self.queue_lock: - queue = self.session_queues.get(key) + queue = self.client_queues.get(key) if not queue: return set(), False - self._expire_session_queue(queue, now) + self._expire_client_queue(queue, now) if queue.get('code99_only'): - raw_message = queue.get('code99_message') or self._session_queue_timeout_message() - self.session_queues.pop(key, None) + raw_message = queue.get('code99_message') or self._client_queue_timeout_message() + self.client_queues.pop(key, None) send_only = True messages = [] elif queue.get('expired'): - raw_message = self._session_queue_timeout_message() - self.session_queues.pop(key, None) + raw_message = self._client_queue_timeout_message() + self.client_queues.pop(key, None) send_only = True messages = [] else: @@ -445,26 +550,26 @@ class WebSocketBroker: queue['messages'] = [] if send_only: - if raw_message and not self.send_to_connection(tenant_id, account_id, raw_message): + if raw_message and not self.send_to_connection(tenant_id, client_id, raw_message): # Verbindung ist bereits wieder weg: Queue für den nächsten # Versuch erhalten. with self.queue_lock: - self.session_queues.setdefault(key, queue) + self.client_queues.setdefault(key, queue) return set(), True unsent = [] for index, raw_message in enumerate(messages): - if not self.send_to_connection(tenant_id, account_id, raw_message): + if not self.send_to_connection(tenant_id, client_id, raw_message): unsent = messages[index:] break with self.queue_lock: - current = self.session_queues.get(key) + current = self.client_queues.get(key) if current is not None: if unsent: current['messages'] = unsent + current.get('messages', []) if not current.get('messages'): - self.session_queues.pop(key, None) + self.client_queues.pop(key, None) # Auch nicht zugestellte Queue-Nachrichten von den Late Entries # ausnehmen. Sie bleiben in der Queue und werden beim nächsten @@ -474,11 +579,12 @@ class WebSocketBroker: # ------------------------------------------------------------------ # Late Entry # ------------------------------------------------------------------ - def send_late_entries(self, tenant_id, account_id, skip_messages=None): + def send_late_entries(self, tenant_id, account_id, client_id, skip_messages=None): """Sendet gespeicherte Nachrichten (Code >= 1000) der letzten 8 Stunden. Es werden ausschließlich Nachrichten zugestellt, für die der Account - laut Protokoll berechtigt ist. Die Zustellung erfolgt chronologisch. + laut Protokoll berechtigt ist. Die Zustellung erfolgt chronologisch an + genau den Client, der sich gerade authentifiziert hat. Anschließend werden abgelaufene Nachrichten gelöscht. """ db = get_db() @@ -491,8 +597,8 @@ class WebSocketBroker: (tenant_id, cutoff) ).fetchall() - conn = self._get_connection(tenant_id, account_id) - if not conn: + conn = self._get_connection(tenant_id, client_id) + if not conn or conn.get('account_id') != account_id: return for msg_row in messages: @@ -508,7 +614,7 @@ class WebSocketBroker: ) if msg.to_json() in skip_messages: continue - self._send(tenant_id, account_id, msg) + self._send(tenant_id, client_id, msg) # Abgelaufene Nachrichten werden bei jeder Anmeldung aufgeräumt. self.cleanup_old_messages(tenant_id) @@ -590,14 +696,20 @@ class WebSocketBroker: # ------------------------------------------------------------------ # Nachrichtenverarbeitung # ------------------------------------------------------------------ - def route_message(self, tenant_id, message, apply_business=False): + def route_message(self, tenant_id, message, apply_business=False, client_id=None): """Wertet den Code aus, persistiert ggf. und stellt die Nachricht zu. ``apply_business`` wird nur für Nachrichten verwendet, die direkt über die WebSocket-Route eingehen. Serverintern erzeugte Nachrichten (z. B. aus der Admin-API) haben die Datenbank bereits aktualisiert und dürfen deshalb nicht ein zweites Mal angewendet werden. + + ``client_id`` ist die Verbindung, über die die Nachricht eingegangen + ist. Sie wird z. B. für den exakten Pong-Status der Webview benötigt. """ + if client_id: + message._sender_client_id = client_id + db = get_db() # Absender muss zum Mandanten gehören. Die Absender-ID wird in der @@ -638,7 +750,7 @@ class WebSocketBroker: # an Dispatcher-Views weitergeleitet und nicht gespeichert. Gleichzeitig # dient sie als Lebenszeichen der Gruppe. if code == 2: - self._record_client_pong(tenant_id, sender['id'], sender) + self._record_client_pong(tenant_id, sender['id'], sender, client_id) self._deliver(tenant_id, message, sender) return @@ -662,6 +774,22 @@ class WebSocketBroker: ) return + # Chat-Nachrichten dürfen nur von der jeweils vorgesehenen Rolle + # gesendet werden. Bei Code 2000 muss die Zielgruppe außerdem die + # eigene Gruppe des sendenden Accounts sein. + if code >= 1000: + allowed, reason = self._validate_chat_sender(tenant_id, message, sender) + if not allowed: + current_app.logger.warning( + 'WebSocket-Chatnachricht abgelehnt: code=%s sender=%s role=%s tenant=%s reason=%s', + code, sender['id'], sender['role'], tenant_id, reason + ) + self.log_incoming( + tenant_id, message, sender, recipients=[], + note=reason + ) + return + # Ab hier: fachliche Nachrichten (>= 100). # Zustandsänderungen, die ein Client per WebSocket meldet, werden vor # der Zustellung in der Datenbank persistiert. So sind sie auch nach @@ -681,8 +809,7 @@ class WebSocketBroker: message = self._prepare_message(tenant_id, message, sender) # Ab Code 1000 werden Nachrichten für die Late-Entry-Funktion - # gespeichert. Gespeichert wird die bereits aufbereitete Nachricht - # (bei Code 1100 inklusive Aliasname-Präfix). + # gespeichert. Gespeichert wird die bereits normalisierte Nachricht. if code >= 1000: self._persist_message(tenant_id, message) @@ -709,10 +836,10 @@ class WebSocketBroker: # ------------------------------------------------------------------ # Anwesenheit von Gruppen-Clients # ------------------------------------------------------------------ - def _record_client_pong(self, tenant_id, account_id, sender): + def _record_client_pong(self, tenant_id, account_id, sender, client_id=None): """Wertet ein Code-2-Lebenszeichen eines Clients aus.""" - conn = self._get_connection(tenant_id, account_id) - if conn: + conn = self._get_connection(tenant_id, client_id) if client_id else None + if conn and conn.get('account_id') == account_id: conn['last_pong_at'] = time.monotonic() if not sender or sender['role'] != 'Gruppe': @@ -1177,6 +1304,17 @@ class WebSocketBroker: except (TypeError, ValueError): message.receiver_id = group_id normalized['group_id'] = message.receiver_id + elif message.code == 2000: + # Auch Code 2000 muss die Zielgruppe explizit im Envelope und im + # Payload tragen. Sonst können weder Dispatcher-Ansichten noch + # Late Entries die Nachricht einer Gruppe zuordnen. + group_id = self._resolve_group_id(tenant_id, message, sender, payload) + if group_id is not None: + try: + message.receiver_id = int(group_id) + except (TypeError, ValueError): + message.receiver_id = group_id + normalized['group_id'] = message.receiver_id elif message.code == 1000: normalized['broadcast'] = True else: @@ -1186,68 +1324,82 @@ class WebSocketBroker: message.msg = json.dumps(normalized, ensure_ascii=False) return message - def _prepare_message(self, tenant_id, message, sender): - """Ergänzt Nachrichten um serverseitig abgeleitete Informationen.""" - db = get_db() - payload = self._payload(message) + def _validate_chat_sender(self, tenant_id, message, sender): + """Prüft Senderrolle und Gruppenzuordnung für Chat-Nachrichten.""" code = message.code + role = sender['role'] - if code >= 1000: - return self._normalize_chat_message(tenant_id, message, sender, payload) + if code in (1000, 1100): + if role != 'Dispatcher': + return False, f'Code {code} ist nur für Dispatcher erlaubt' + return True, None - if message.code == 1100: + if code == 2000: + if role != 'Gruppe': + return False, 'Code 2000 ist nur für Gruppen-Accounts erlaubt' + + payload = self._payload(message) group_id = self._resolve_group_id(tenant_id, message, sender, payload) - group = self._fetch_group(tenant_id, group_id) - message.receiver_id = group_id - if group: - alias = group['aliasname'] or str(group['id']) - prefix = f'{alias}: ' - text = message.msg if isinstance(message.msg, str) else json.dumps(message.msg) - if not text.startswith(prefix): - message.msg = prefix + text - return self._normalize_chat_message(tenant_id, message, sender, payload) + sender_group_id = self._get_sender_info(tenant_id, sender).get('group_id') + if group_id is None or sender_group_id is None: + return False, 'Gruppen-Account ist keiner Gruppe zugeordnet' - elif message.code == 2000: - group_id = self._resolve_group_id(tenant_id, message, sender, payload) - message.receiver_id = group_id - if isinstance(payload, dict): - if group_id and not payload.get('group_id'): - payload['group_id'] = group_id - message.msg = json.dumps(payload, ensure_ascii=False) - elif group_id: - message.msg = json.dumps( - {'group_id': group_id, 'text': message.msg}, - ensure_ascii=False - ) - return self._normalize_chat_message(tenant_id, message, sender, payload) + try: + if int(group_id) != int(sender_group_id): + return False, 'Code 2000 darf nur an die eigene Gruppe gesendet werden' + except (TypeError, ValueError): + return False, 'Ungültige Gruppen-ID für Code 2000' + return True, None + return True, None + + def _prepare_message(self, tenant_id, message, sender): + """Ergänzt Chat-Nachrichten um serverseitig abgeleitete Informationen.""" + if message.code >= 1000: + payload = self._payload(message) + return self._normalize_chat_message(tenant_id, message, sender, payload) return message def _deliver(self, tenant_id, message, sender): - """Stellt eine Nachricht an alle berechtigten, verbundenen Clients zu.""" + """Stellt eine Nachricht an alle berechtigten Clients zu.""" recipients = sorted(self._get_recipients(tenant_id, message, sender)) self.log_incoming(tenant_id, message, sender, recipients=recipients) - for recipient_id in recipients: - self._send(tenant_id, recipient_id, message) + for client_id in recipients: + self._send(tenant_id, client_id, message) - def _send(self, tenant_id, account_id, message): - """Sendet eine Nachricht oder puffert sie für die letzte Sitzung.""" + def _send(self, tenant_id, client_id, message): + """Sendet eine Nachricht an einen Client oder puffert sie für ihn.""" # Erst nach erfolgreicher Token-Authentifizierung dürfen Nachrichten # an einen Client zugestellt werden. - if not self.is_authenticated(tenant_id, account_id): - self._queue_undeliverable(tenant_id, account_id, message) + if not self.is_authenticated(tenant_id, client_id): + self._queue_undeliverable(tenant_id, client_id, message) return False - if self.send_to_connection(tenant_id, account_id, message.to_json()): + if self.send_to_connection(tenant_id, client_id, message.to_json()): return True - self._queue_undeliverable(tenant_id, account_id, message) + self._queue_undeliverable(tenant_id, client_id, message) return False + def _client_ids_for_accounts(self, tenant_id, account_ids): + """Expandiert Empfänger-Accounts auf alle bekannten Client-IDs.""" + client_ids = set() + for account_id in account_ids: + client_ids.update( + self.account_clients.get((tenant_id, account_id), ()) + ) + return client_ids + def _get_recipients(self, tenant_id, message, sender): - """Bestimmt den Empfängerkreis abhängig vom Nachrichtencode.""" + """Bestimmt den Empfängerkreis abhängig vom Nachrichtencode. + + Die fachliche Empfängerermittlung erfolgt weiterhin über Rollen und + Gruppen. Am Ende werden die gefundenen Accounts auf alle ihre bekannten + Clients expandiert, damit ein Account mehrere Webviews parallel + betreiben kann. + """ db = get_db() - recipients = set() + recipient_accounts = set() code = message.code payload = self._payload(message) @@ -1257,7 +1409,7 @@ class WebSocketBroker: f'SELECT id FROM accounts WHERE tenant_id = ? AND role IN ({placeholders})', (tenant_id, *roles) ).fetchall() - recipients.update(row['id'] for row in rows) + recipient_accounts.update(row['id'] for row in rows) def add_group_account(group_id): if not group_id: @@ -1267,10 +1419,10 @@ class WebSocketBroker: WHERE group_id = ? AND tenant_id = ?''', (group_id, tenant_id) ).fetchall() - recipients.update(row['account_id'] for row in rows) + recipient_accounts.update(row['account_id'] for row in rows) if code == 99: - # Alle verbundenen Clients des Mandanten müssen die Seite neu laden. + # Alle Clients des Mandanten müssen die Seite neu laden. add_accounts(('Gast', 'Beobachter', 'Gruppe', 'Dispatcher', 'Administrator')) elif code == 100: @@ -1329,7 +1481,7 @@ class WebSocketBroker: # Heartbeat-Antworten werden nur an Dispatcher-Views weitergegeben. add_accounts(('Dispatcher',)) - return recipients + return self._client_ids_for_accounts(tenant_id, recipient_accounts) def _persist_message(self, tenant_id, message): """Speichert Nachrichten mit Code >= 1000 für die Late-Entry-Funktion.""" diff --git a/CMBNet/cmbnet/ws/heartbeat.py b/CMBNet/cmbnet/ws/heartbeat.py index ecf1ba1..f12f020 100644 --- a/CMBNet/cmbnet/ws/heartbeat.py +++ b/CMBNet/cmbnet/ws/heartbeat.py @@ -71,16 +71,16 @@ class HeartbeatManager: # Nur authentifizierte Verbindungen erhalten einen Heartbeat. for tenant_id, connections in list(broker.connections.items()): - for account_id in list(connections): - if not broker.is_authenticated(tenant_id, account_id): + for client_id in list(connections): + if not broker.is_authenticated(tenant_id, client_id): continue - broker.send_to_connection(tenant_id, account_id, msg.to_json()) + broker.send_to_connection(tenant_id, client_id, msg.to_json()) - # Abgelaufene persistierte Nachrichten und Sitzungs-Queues löschen. + # Abgelaufene persistierte Nachrichten und Client-Queues löschen. if self.app is not None: try: with self.app.app_context(): - broker.cleanup_session_queues() + broker.cleanup_client_queues() broker.cleanup_old_messages() except Exception as exc: print(f'Heartbeat cleanup error: {exc}') diff --git a/CMBNet/cmbnet/ws/protocol.py b/CMBNet/cmbnet/ws/protocol.py index 72bbb55..4bef987 100644 --- a/CMBNet/cmbnet/ws/protocol.py +++ b/CMBNet/cmbnet/ws/protocol.py @@ -6,7 +6,7 @@ from datetime import datetime class WSMessage: - def __init__(self, sender_id=None, receiver_id=None, code=0, msg="", ts=None, session_id=None): + def __init__(self, sender_id=None, receiver_id=None, code=0, msg="", ts=None, client_id=None): self.sender_id = sender_id self.receiver_id = receiver_id self.code = code @@ -14,7 +14,7 @@ class WSMessage: self.ts = ts or int(datetime.now().timestamp() * 1000) # Nur für den Code-0-Handshake. Wird nicht an andere Clients # weitergegeben und deshalb auch nicht in to_dict() serialisiert. - self.session_id = session_id + self.client_id = client_id def to_dict(self): return { @@ -36,7 +36,9 @@ class WSMessage: code=data.get('code', 0), msg=data.get('msg', ''), ts=data.get('ts'), - session_id=data.get('session_id') + # Ältere Clients senden noch session_id. Sie werden übergangsweise + # als Client-ID akzeptiert. + client_id=data.get('client_id') or data.get('session_id') ) @classmethod diff --git a/CMBNet/cmbnet/ws/routes.py b/CMBNet/cmbnet/ws/routes.py index e638011..60049dc 100644 --- a/CMBNet/cmbnet/ws/routes.py +++ b/CMBNet/cmbnet/ws/routes.py @@ -3,8 +3,8 @@ WebSocket Routes Ablauf einer Verbindung: 1. Client verbindet sich mit //ws. -2. Client sendet Code 0 mit dem zuvor über die API geholten Einmal-Token - und seiner persistenten Sitzungs-ID. +2. Client sendet Code 0 mit dem zuvor über die API geholten Einmal-Token und + seiner Client-ID. Die Client-ID wird pro Webview erzeugt. 3. Erst nach erfolgreicher Prüfung dürfen fachliche Nachrichten gesendet werden. Vorher wird die Verbindung geschlossen. """ @@ -17,9 +17,16 @@ from cmbnet.ws.protocol import WSMessage def _parse_auth_payload(value): - """Liefert (Token, Sitzungs-ID) aus dem Code-0-Payload.""" + """Liefert (Token, Client-ID) aus dem Code-0-Payload. + + Ältere Clients senden statt ``client_id`` noch ``session_id``. Der + alte Schlüssel wird übergangsweise weiter akzeptiert. + """ if isinstance(value, dict): - return value.get('token'), value.get('session_id') + return ( + value.get('token'), + value.get('client_id') or value.get('session_id') + ) if isinstance(value, str): text = value.strip() @@ -29,7 +36,10 @@ def _parse_auth_payload(value): except (TypeError, ValueError): return None, None if isinstance(data, dict): - return data.get('token'), data.get('session_id') + return ( + data.get('token'), + data.get('client_id') or data.get('session_id') + ) return text, None return None, None @@ -52,10 +62,9 @@ def ws(ws, tenant): ws.close() return - # Verbindung registrieren, aber noch nicht als authentifiziert markieren. - if not broker.register_connection(tenant_id, account_id, ws): - ws.close() - return + # Die Verbindung wird erst mit dem Code-0-Handshake registriert. Vorher + # ist die Client-ID noch nicht bekannt. + client_id = None try: while True: @@ -74,43 +83,68 @@ def ws(ws, tenant): # Die Absender-ID stammt immer aus der Session und kann vom Client # nicht gefälscht werden. msg.sender_id = account_id + if client_id: + msg._sender_client_id = client_id - # Code 0: Authentifizierung über den Einmal-Token. + # Code 0: Authentifizierung über den Einmal-Token und Registrierung + # der Client-ID. if msg.code == 0: - token, session_id = _parse_auth_payload(msg.msg) - if not session_id: - session_id = getattr(msg, 'session_id', None) - if session_id: - msg.session_id = session_id - if not token or not broker.authenticate( - tenant_id, account_id, token, session_id - ): + if client_id: broker.log_incoming( - tenant_id, msg, recipients=[], - note='Code-0-Handshake fehlgeschlagen' - ) - current_app.logger.warning( - 'WebSocket-Authentifizierung fehlgeschlagen: tenant=%s account=%s', - tenant_id, account_id + tenant_id, msg, recipients=[client_id], + note='Code-0-Handshake nach bereits erfolgreicher Authentifizierung' ) ws.close() break + + token, requested_client_id = _parse_auth_payload(msg.msg) + if not requested_client_id: + requested_client_id = getattr(msg, 'client_id', None) + client_id = broker.normalize_client_id(requested_client_id, account_id) + msg.client_id = client_id + + if not token or not broker.register_connection( + tenant_id, account_id, client_id, ws + ): + broker.log_incoming( + tenant_id, msg, recipients=[], + note='Code-0-Registrierung fehlgeschlagen' + ) + current_app.logger.warning( + 'WebSocket-Registrierung fehlgeschlagen: tenant=%s account=%s client=%s', + tenant_id, account_id, client_id + ) + ws.close() + break + + if not broker.authenticate(tenant_id, account_id, client_id, token): + broker.log_incoming( + tenant_id, msg, recipients=[client_id], + note='Code-0-Handshake fehlgeschlagen' + ) + current_app.logger.warning( + 'WebSocket-Authentifizierung fehlgeschlagen: tenant=%s account=%s client=%s', + tenant_id, account_id, client_id + ) + ws.close() + break + broker.log_incoming( - tenant_id, msg, recipients=[account_id], + tenant_id, msg, recipients=[client_id], note='Code-0-Handshake erfolgreich' ) # Bestätigt dem Client den erfolgreichen Handshake. Erst jetzt # darf er gepufferte fachliche Nachrichten senden. broker.send_to_connection( tenant_id, - account_id, + client_id, WSMessage(sender_id=0, code=0, msg='authenticated').to_json() ) continue # Fachliche Nachrichten sind erst nach erfolgreicher # Authentifizierung erlaubt. - if not broker.is_authenticated(tenant_id, account_id): + if not client_id or not broker.is_authenticated(tenant_id, client_id): broker.log_incoming( tenant_id, msg, recipients=[], note='Nachricht vor Code-0-Authentifizierung' @@ -118,9 +152,12 @@ def ws(ws, tenant): ws.close() break - broker.route_message(tenant_id, msg, apply_business=True) + broker.route_message( + tenant_id, msg, apply_business=True, client_id=client_id + ) except Exception as exc: print(f'WebSocket error: {exc}') finally: - broker.remove_connection(tenant_id, account_id, ws) + if client_id: + broker.remove_connection(tenant_id, client_id, ws) diff --git a/CMBNet/config.py b/CMBNet/config.py index ec9282b..28fd221 100644 --- a/CMBNet/config.py +++ b/CMBNet/config.py @@ -19,11 +19,18 @@ class Config: WS_GROUP_ONLINE_TIMEOUT_SECONDS = int( os.environ.get('CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS', '120') ) - # Wie lange nicht zustellbare Nachrichten pro Client-Sitzung vorgehalten - # werden, bevor sie verworfen und durch einen Code-99-Hinweis ersetzt werden. + # Wie lange nicht zustellbare Nachrichten pro Client vorgehalten werden, + # bevor sie verworfen und durch einen Code-99-Hinweis ersetzt werden. WS_QUEUE_MAX_AGE_MINUTES = int( os.environ.get('CMBNET_WS_QUEUE_MAX_AGE_MINUTES', '15') ) + # Wie lange eine nicht mehr verbundene Webview samt Queue registriert + # bleibt, bevor sie vom Broker endgültig verworfen wird. Da die Client-ID + # bei jedem Neuladen neu erzeugt wird, verhindert dieser Wert, dass alte + # Webviews unbegrenzt Nachrichten ansammeln. + WS_CLIENT_RETENTION_MINUTES = int( + os.environ.get('CMBNET_WS_CLIENT_RETENTION_MINUTES', '60') + ) LATE_ENTRY_MAX_AGE_HOURS = int(os.environ.get('CMBNET_LATE_ENTRY_MAX_AGE_HOURS', '8')) # Ausführliche Broker-Debugausgabe für eingehende Nachrichten und den # ermittelten Empfängerkreis. Kann im Betrieb über die Umgebungsvariable diff --git a/CMBNet/static/js/reload_notice.js b/CMBNet/static/js/reload_notice.js index 3ad29a1..71d335a 100644 --- a/CMBNet/static/js/reload_notice.js +++ b/CMBNet/static/js/reload_notice.js @@ -128,7 +128,9 @@ ws.send(JSON.stringify({ code: 0, msg: data.token, - session_id: window.CMBNET_CLIENT_SESSION_ID || '' + client_id: window.CMBNET_CLIENT_ID + || window.CMBNET_CLIENT_SESSION_ID + || '' })); }); diff --git a/CMBNet/static/js/sw.js b/CMBNet/static/js/sw.js index 3717fd6..0461b24 100644 --- a/CMBNet/static/js/sw.js +++ b/CMBNet/static/js/sw.js @@ -5,7 +5,7 @@ * damit er sowohl die mobilen Views als auch die statischen Assets * kontrolliert. Der Cache-Name wird pro App-Wurzel gebildet. */ -const VERSION = 'cmbnet-pwa-v8'; +const VERSION = 'cmbnet-pwa-v9'; const BASE = new URL('./', self.location).href; const SHELL_CACHE = `${VERSION}-shell`; const TILE_CACHE = `${VERSION}-tiles`; diff --git a/CMBNet/static/js/views/admin_dashboard.js b/CMBNet/static/js/views/admin_dashboard.js index 67a1571..ef5fbe2 100644 --- a/CMBNet/static/js/views/admin_dashboard.js +++ b/CMBNet/static/js/views/admin_dashboard.js @@ -14,7 +14,7 @@ async function loadBrokerStatus() { if (!data.connections || data.connections.length === 0) { const row = document.createElement('tr'); const cell = document.createElement('td'); - cell.colSpan = 4; + cell.colSpan = 5; cell.textContent = 'Keine aktiven Verbindungen'; row.appendChild(cell); body.appendChild(row); @@ -22,6 +22,9 @@ async function loadBrokerStatus() { } for (const conn of data.connections) { const row = document.createElement('tr'); + const tdClient = document.createElement('td'); + tdClient.textContent = conn.client_id || '-'; + tdClient.title = conn.client_id || ''; const tdId = document.createElement('td'); tdId.textContent = conn.account_id; const tdName = document.createElement('td'); @@ -36,13 +39,13 @@ async function loadBrokerStatus() { } else { tdGroup.textContent = '-'; } - row.append(tdId, tdName, tdRole, tdGroup); + row.append(tdClient, tdId, tdName, tdRole, tdGroup); body.appendChild(row); } } catch (error) { console.error(error); const body = document.getElementById('brokerStatusBody'); - body.innerHTML = 'Fehler beim Laden'; + body.innerHTML = 'Fehler beim Laden'; } } diff --git a/CMBNet/static/js/views/dispatcher.js b/CMBNet/static/js/views/dispatcher.js index 3c34259..3a76ba3 100644 --- a/CMBNet/static/js/views/dispatcher.js +++ b/CMBNet/static/js/views/dispatcher.js @@ -2704,7 +2704,9 @@ async function connectWebSocket() { ws.send(JSON.stringify({ code: 0, msg: token, - session_id: window.CMBNET_CLIENT_SESSION_ID || '' + client_id: window.CMBNET_CLIENT_ID + || window.CMBNET_CLIENT_SESSION_ID + || '' })); dispatcherState.authenticated = true; setConnectionStatus('Verbunden', 'connected'); @@ -2928,7 +2930,10 @@ function handleStreetUpdate(message) { if (!street && payload.name) { street = dispatcherState.streets.find(item => item.name === payload.name); } - if (!street) return; + if (!street) { + console.warn('[WS] Code 100: Straße nicht im lokalen Zustand', payload); + return; + } if (STREET_STATES.includes(payload.state)) { street.state = payload.state; @@ -2951,7 +2956,10 @@ function handleGroupStateUpdate(message) { const payload = parsePayload(message.msg) || {}; const groupId = Number(payload.group_id ?? message.receiver_id); const group = dispatcherState.groupById.get(groupId); - if (!group) return; + if (!group) { + console.warn('[WS] Code 200: Gruppe nicht im lokalen Zustand', payload); + return; + } if (GROUP_STATES.includes(payload.state)) { group.state = payload.state; @@ -2963,7 +2971,10 @@ function handleGroupPositionUpdate(message) { const payload = parsePayload(message.msg) || {}; const groupId = Number(payload.group_id ?? message.receiver_id); const group = dispatcherState.groupById.get(groupId); - if (!group) return; + if (!group) { + console.warn('[WS] Code 300: Gruppe nicht im lokalen Zustand', payload); + return; + } const lat = Number(payload.lat); const lon = Number(payload.lon); diff --git a/CMBNet/static/js/views/mobile.js b/CMBNet/static/js/views/mobile.js index 959188d..07990df 100644 --- a/CMBNet/static/js/views/mobile.js +++ b/CMBNet/static/js/views/mobile.js @@ -1154,7 +1154,9 @@ function connectWebSocket() { ws.send(JSON.stringify({ code: 0, msg: token, - session_id: window.CMBNET_CLIENT_SESSION_ID || '' + client_id: window.CMBNET_CLIENT_ID + || window.CMBNET_CLIENT_SESSION_ID + || '' })); // Fallback für ältere Server, die noch keine Code-0-Bestätigung @@ -1326,7 +1328,9 @@ function parseFlexibleTimestamp(value) { function handleWs(event) { let message; try { message = JSON.parse(event.data); } catch(e) { return; } - + + console.debug('[WS RX]', message); + if (message.code === 0) { state.authenticated = true; flushWsOutbox(); @@ -1356,6 +1360,8 @@ function handleWs(event) { state.currentPolyline.setStyle({color: STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet}); } buildStreetList(); + } else { + console.warn('[WS] Code 100: Straße nicht im lokalen Zustand', p); } } } catch(e) {} @@ -1365,12 +1371,17 @@ function handleWs(event) { const p = typeof message.msg === 'string' ? JSON.parse(message.msg) : message.msg; const gid = Number(p.group_id || message.receiver_id); const g = state.groupById.get(gid); - if (g && p.lat && p.lon) { - g.last_lat = p.lat; - g.last_lon = p.lon; + const lat = Number(p.lat); + const lon = Number(p.lon); + if (g && Number.isFinite(lat) && Number.isFinite(lon) + && p.lat !== null && p.lon !== null) { + g.last_lat = lat; + g.last_lon = lon; g.last_pos_ts = parseFlexibleTimestamp(p.ts) || Date.now(); g.last_pos_at = new Date(g.last_pos_ts).toISOString(); if (viewMode === 'mobile_dispatcher') showAllGroupPositions(); + } else if (!g) { + console.warn('[WS] Code 300: Gruppe nicht im lokalen Zustand', p); } } catch(e) {} } else if (message.code === 2000 || message.code === 1000 || message.code === 1100) { diff --git a/CMBNet/templates/admin/dashboard.html b/CMBNet/templates/admin/dashboard.html index 6dde38c..fe0249f 100644 --- a/CMBNet/templates/admin/dashboard.html +++ b/CMBNet/templates/admin/dashboard.html @@ -19,6 +19,7 @@ + @@ -26,7 +27,7 @@ - +
Client-ID Account-ID Account Rolle
Lade...
Lade...
diff --git a/CMBNet/templates/base.html b/CMBNet/templates/base.html index b6664e9..7a47c49 100644 --- a/CMBNet/templates/base.html +++ b/CMBNet/templates/base.html @@ -29,38 +29,26 @@ return clean ? base + '/' + clean : (base || '/'); }; - // Stabile ID pro Browser-Tab. Sie übersteht ein Neuladen und ordnet - // die WebSocket-Sitzung ihrer Nachrichten-Queue beim Broker zu. - (function initClientSessionId() { - const key = 'cmbnet:client-session:' + (window.CMBNET_TENANT || ''); - let sessionId = null; + // Jede Webview erhält beim Laden genau eine neue Client-ID. Sie wird + // bewusst nicht in sessionStorage gespeichert: Ein Neuladen erzeugt + // eine neue Webview und damit eine neue Broker-Verbindung. + (function initClientId() { + let clientId = null; - try { - sessionId = window.sessionStorage.getItem(key); - } catch (error) { - // sessionStorage kann in privaten Kontexten gesperrt sein. + if (window.crypto && typeof window.crypto.randomUUID === 'function') { + clientId = window.crypto.randomUUID(); + } else if (window.crypto && typeof window.crypto.getRandomValues === 'function') { + const bytes = new Uint8Array(16); + window.crypto.getRandomValues(bytes); + clientId = Array.from(bytes, value => value.toString(16).padStart(2, '0')).join(''); + } else { + clientId = 'client-' + Date.now().toString(36) + '-' + + Math.random().toString(36).slice(2, 12); } - if (!sessionId) { - if (window.crypto && typeof window.crypto.randomUUID === 'function') { - sessionId = window.crypto.randomUUID(); - } else if (window.crypto && typeof window.crypto.getRandomValues === 'function') { - const bytes = new Uint8Array(16); - window.crypto.getRandomValues(bytes); - sessionId = Array.from(bytes, value => value.toString(16).padStart(2, '0')).join(''); - } else { - sessionId = 'sess-' + Date.now().toString(36) + '-' + - Math.random().toString(36).slice(2, 12); - } - - try { - window.sessionStorage.setItem(key, sessionId); - } catch (error) { - // Dann gilt die ID nur für den aktuellen Seitenaufruf. - } - } - - window.CMBNET_CLIENT_SESSION_ID = sessionId; + window.CMBNET_CLIENT_ID = clientId; + // Übergangsweise für noch gecachte ältere Skripte. + window.CMBNET_CLIENT_SESSION_ID = clientId; })(); diff --git a/doc/Websocket und Caddy.pdf b/doc/Websocket und Caddy.pdf new file mode 100644 index 0000000..f002478 Binary files /dev/null and b/doc/Websocket und Caddy.pdf differ diff --git a/doc/broker.md b/doc/broker.md index c2d125b..fb62c01 100644 --- a/doc/broker.md +++ b/doc/broker.md @@ -1,6 +1,6 @@ # Broker und WebSocket-Protokoll -Stand: 31.10.2026 +Stand: 01.11.2026 Dieses Dokument beschreibt das aktuelle WebSocket-Protokoll, die Aufgaben und den Ablauf des Brokers sowie die Stellen, an denen die Implementierung von der @@ -22,7 +22,7 @@ WebSocket-Clients eines Mandanten. Er - ordnet Nachrichten anhand ihres Codes einem Empfängerkreis zu, - wendet fachliche Zustandsänderungen für Straßen und Gruppen an, - persistiert Chat-Nachrichten für die spätere Nachlieferung, -- puffert nicht zustellbare Nachrichten pro Client-Sitzung, +- puffert nicht zustellbare Nachrichten pro Client-ID, - überwacht die Lebenszeichen der Gruppen. Die Web-APIs liefern den Clients unabhängig vom Broker den aktuellen @@ -30,7 +30,7 @@ Initialzustand. Der Broker ist damit nicht die einzige Quelle für den Zustand, sondern verteilt Änderungen und gleicht kurzfristige Verbindungsunterbrechungen aus. -## 2. Transport, Authentifizierung und Sitzung +## 2. Transport, Authentifizierung und Client-ID ### Endpoint @@ -57,7 +57,7 @@ Nach dem Öffnen der WebSocket-Verbindung sendet der Client Code 0: { "code": 0, "msg": "", - "session_id": "" + "client_id": "" } ``` @@ -65,22 +65,29 @@ Das Token wird vorher über `GET //api/auth/ws-token` geholt. Es ist mandanten- und accountgebunden, nur einmal verwendbar und standardmäßig eine Stunde gültig. -Die `session_id` wird pro Browser-Tab in `sessionStorage` erzeugt und bleibt -über ein Neuladen der Seite erhalten. Sie ordnet die Verbindung einer -Nachrichten-Queue zu. +Die `client_id` wird in `templates/base.html` bei jedem Laden einer Webview +einmalig erzeugt. Sie wird bewusst **nicht** in `sessionStorage` gespeichert: +Ein Neuladen erzeugt eine neue Webview und damit eine neue Broker-Verbindung. +Die Client-ID ist an den Account gebunden, der den Code-0-Handshake ausführt. +Mehrere Clients desselben Accounts erhalten getrennte Verbindungen und Queues. -Der Broker akzeptiert aus Kompatibilitätsgründen auch die ältere Objektform: +Der Broker akzeptiert aus Kompatibilitätsgründen auch die ältere Objektform und +den alten Schlüssel `session_id`: ```json { "code": 0, "msg": { "token": "", - "session_id": "" + "session_id": "" } } ``` +Fehlt eine gültige Client-ID vollständig, erzeugt der Broker eine eindeutige +Ersatz-ID (`legacy--`). Ein solcher Altclient kann nach einem +Reconnect keine frühere Queue wiedererkennen. + Nach erfolgreicher Prüfung antwortet der Server mit einer Code-0-Bestätigung: ```json @@ -155,10 +162,13 @@ fachliche Empfänger weitergeleitet. Der Broker prüft: 1. Existiert das Token für Mandant und Account? 2. Ist es noch nicht verwendet? 3. Ist es nicht abgelaufen? +4. Ist die Client-ID gültig und noch keinem anderen Account zugeordnet? -Danach wird das Token als verbraucht markiert, die Sitzungs-ID normalisiert und -der Account als authentifiziert registriert. Ohne gültigen Code 0 werden -fachliche Nachrichten nicht akzeptiert; die Verbindung wird geschlossen. +Danach wird das Token als verbraucht markiert, die Client-ID normalisiert und +die Verbindung als authentifiziert registriert. Ohne gültigen Code 0 werden +fachliche Nachrichten nicht akzeptiert; die Verbindung wird geschlossen. Da die +Registrierung erst mit Code 0 erfolgt, kennt der Broker vor dem Handshake noch +keine Client-ID. ### Code 1: Heartbeat @@ -170,7 +180,7 @@ authentifizierten Verbindungen: ``` Die Heartbeat-Routine läuft in einem Daemon-Timer. Sie räumt zusätzlich -abgelaufene Chat-Nachrichten und Sitzungs-Queues auf. +abgelaufene Chat-Nachrichten und Client-Queues auf. ### Code 2: Pong / Lebenszeichen @@ -211,13 +221,14 @@ Admin- und Dispatcher-Clients als mögliche Sender; diese lösen Code 99 aktuell Queue-Verhalten: -- Ist ein Client nicht erreichbar, wird Code 99 in seiner Sitzungs-Queue +- Ist ein Client nicht erreichbar, wird Code 99 in seiner Client-Queue gespeichert. - Eine gespeicherte Code-99-Nachricht leert alle älteren Queue-Nachrichten. - Danach werden keine weiteren Nachrichten in dieser Queue gepuffert (`code99_only`). -- Beim nächsten Reconnect wird ausschließlich diese Code-99-Nachricht - zugestellt. Late Entries werden in diesem Fall unterdrückt. +- Beim nächsten Reconnect mit derselben Client-ID wird ausschließlich diese + Code-99-Nachricht zugestellt. Late Entries werden in diesem Fall + unterdrückt. - Ist die Queue wegen Überschreitung der Maximalzeit abgelaufen, erzeugt der Broker eine Code-99-Nachricht mit Hinweis auf die zu lange Unterbrechung. @@ -298,19 +309,23 @@ die Nachricht als „Von -> An“ mit Zeitstempel und Text an. ### Code 1000: Broadcast Soll-Sender: Dispatcher. Empfänger: alle Dispatcher, Beobachter und alle -Gruppen. Die aktuelle Implementierung prüft die Senderrolle nicht. +Gruppen. Der Broker akzeptiert Code 1000 nur von Accounts mit der Rolle +`Dispatcher`; andere Rollen werden mit einer Warnung und einem Debug-Eintrag +abgewiesen. ### Code 1100: Nachricht an eine Gruppe Soll-Sender: Dispatcher. Empfänger: alle Dispatcher, Beobachter und die adressierte Gruppe. Der Broker ermittelt die Gruppen-ID aus `group_id`, -`receiver_id` oder dem Absender. Die aktuelle Implementierung prüft die -Senderrolle nicht. +`receiver_id` oder dem Absender und akzeptiert Code 1100 nur von Accounts mit +der Rolle `Dispatcher`. ### Code 2000: Nachricht aus einer Gruppe Soll-Sender: Gruppen-Account. Empfänger: alle Dispatcher, Beobachter und die -eigene Gruppe. Die aktuelle Implementierung prüft die Senderrolle nicht. +eigene Gruppe. Der Broker akzeptiert Code 2000 nur von Accounts mit der Rolle +`Gruppe`. Zusätzlich muss die aufgelöste Zielgruppe die eigene Gruppe des +Absenders sein; Nachrichten an eine fremde Gruppe werden abgewiesen. ## 7. Broker-Ablauf @@ -319,19 +334,30 @@ eigene Gruppe. Die aktuelle Implementierung prüft die Senderrolle nicht. `WebSocketBroker.connections` ist ein verschachteltes Dictionary: ```text -connections[tenant_id][account_id] = { - ws, role, group_id, session_id, +connections[tenant_id][client_id] = { + ws, account_id, client_id, role, group_id, last_ping, connected_at, last_pong_at, send_lock } ``` -Pro Account wird derzeit genau eine Verbindung gespeichert. Eine neue -Verbindung desselben Accounts überschreibt die alte Registrierung. +Eine Client-ID gehört genau zu einer Webview. Ein Account kann daher mehrere +Clients parallel betreiben. Eine neue Verbindung mit derselben Client-ID ersetzt +nur diese eine Verbindung; andere Clients desselben Accounts bleiben erhalten. -`authenticated[tenant_id][account_id]` speichert den Authentifizierungsstatus. +`authenticated[tenant_id][client_id]` speichert den Authentifizierungsstatus. Ohne erfolgreichen Code-0-Handshake werden keine fachlichen Nachrichten zugestellt. +Zusätzlich hält der Broker: + +- `client_accounts[(tenant_id, client_id)] = account_id`, +- `account_clients[(tenant_id, account_id)] = {client_id, ...}`, +- `disconnected_clients[(tenant_id, client_id)] = Zeitpunkt`. + +Diese Zuordnungen bleiben nach einem Verbindungsabbruch erhalten, damit +kurzfristige Reconnects ihre Queue wiederfinden. Dauerhaft verlassene Webviews +werden nach `WS_CLIENT_RETENTION_MINUTES` (Default 60 Minuten) aufgeräumt. + ### Empfängerermittlung `_get_recipients()` entscheidet anhand des Codes und der Absenderrolle: @@ -344,33 +370,36 @@ zugestellt. - Code 2000: Dispatcher, Beobachter und die eigene Gruppe, - Code 2: nur Dispatcher. -Die Empfänger werden als Account-IDs ermittelt. Gruppen-Accounts werden über -`group_accounts` aufgelöst. +Die fachlichen Empfänger werden weiterhin als Account-IDs ermittelt. +Gruppen-Accounts werden über `group_accounts` aufgelöst. Anschließend expandiert +`_client_ids_for_accounts()` jeden Empfänger-Account auf alle seine bekannten +Client-IDs. Damit erhalten auch mehrere Tabs/Webviews desselben Accounts die +Nachricht. ### Zustellung -`_deliver()` sendet die Nachricht an jeden ermittelten Empfänger. `_send()` -prüft zuerst die Authentifizierung: +`_deliver()` sendet die Nachricht an jeden ermittelten Client. `_send()` prüft +zuerst die Authentifizierung: - authentifiziert und Verbindung vorhanden: direkter Versand, - nicht authentifiziert oder Versand fehlgeschlagen: Eintrag in die - Sitzungs-Queue, sofern eine Sitzungs-ID bekannt ist. + Client-Queue, sofern die Client-ID bekannt ist. Der direkte Versand erfolgt pro Verbindung über einen `send_lock`. Dadurch werden Heartbeat, Route-Thread und HTTP-ausgelöste Broadcasts nicht gleichzeitig in denselben Socket schreiben. -### Sitzungs-Queues +### Client-Queues Queues werden unter dem Schlüssel ```text -(tenant_id, account_id, session_id) +(tenant_id, client_id) ``` -gespeichert. Die zuletzt bekannte Session-ID wird zusätzlich in -`account_sessions` gehalten, damit Nachrichten auch ohne aktive Verbindung der -richtigen Queue zugeordnet werden können. +gespeichert. Die Account-Zuordnung liegt in `client_accounts`. Sie bleibt auch +ohne aktive Verbindung bestehen, damit weitere Nachrichten für dieselbe Webview +gepuffert werden können. Eigenschaften: @@ -381,22 +410,28 @@ Eigenschaften: Verbindungsabbruch, - abgelaufene Queues werden geleert und als „Tombstone“ für den Code-99-Hinweis behalten, +- dauerhaft getrennte Clients werden nach `WS_CLIENT_RETENTION_MINUTES` + (Default 60 Minuten) samt Queue und Zuordnung entfernt, - Queues liegen ausschließlich im Arbeitsspeicher und überleben keinen Serverneustart, - es gibt derzeit keine feste Obergrenze für die Anzahl gepufferter Nachrichten. +Da die Client-ID bei jedem Neuladen neu erzeugt wird, erbt eine neu geladene +Webview keine Nachrichten-Queue der vorherigen Seite. Nicht persistierte +Code-100/200/300-Ereignisse werden in diesem Fall über den neu geladenen +Initialzustand abgedeckt; persistierte Chat-Nachrichten kommen als Late Entries. + ### Late Entries Nach erfolgreicher Authentifizierung sendet der Broker persistierte Chat-Nachrichten der letzten acht Stunden, für die der Account berechtigt ist. -Bereits aus der Sitzungs-Queue zugestellte Nachrichten werden dabei -übersprungen. +Bereits aus der Client-Queue zugestellte Nachrichten werden dabei übersprungen. Die aktuelle Implementierung sendet Late Entries bei **jeder** erfolgreichen -Authentifizierung, also auch bei einer bereits bekannten Sitzung. Die -Soll-Beschreibung sieht eine initiale Historiennachlieferung für neue -Websessions vor. Das kann bei Reconnects zu zusätzlichen Wiederholungen führen. +Authentifizierung. Bei einem Reconnect mit derselben Client-ID können dadurch +Nachrichten erneut ankommen, die bereits live zugestellt wurden. Bei einer neu +geladenen Webview mit neuer Client-ID ist die Nachlieferung dagegen gewollt. ### Heartbeat und Gruppenpräsenz @@ -408,28 +443,29 @@ prüft alle 15 Sekunden die Gruppenpräsenz. Bei fehlendem Pong wird eine Berücksichtigt sind: -- `queue_lock` schützt `session_queues` und die Queue-Übergänge. +- `queue_lock` schützt `client_queues` und die Queue-Übergänge. - `send_lock` pro Verbindung serialisiert alle ausgehenden Frames. - Timer laufen als Daemon-Threads. - SQLite-Zugriffe erfolgen pro Thread über die Flask-App-Kontexte. Nicht vollständig abgesichert sind: -- `connections` und `authenticated` werden ohne eigenen Lock gelesen und - geschrieben. Einzelne Dictionary-Operationen sind durch den GIL atomar, - zusammengesetzte Prüfungen und Ersetzungen sind es nicht. -- Eine neue Verbindung für denselben Account ersetzt die alte Registrierung, - ohne den alten Socket aktiv zu schließen. Der alte Socket kann bis zum - Client-seitigen Schließen weiter existieren; seine Route verwendet aber den - Account-Kontext der neuen Verbindung. -- `account_sessions`, `group_last_pong` und `group_online_since` werden ohne - eigenen Lock aktualisiert. +- `connections`, `authenticated`, `client_accounts` und `account_clients` + werden ohne eigenen Lock gelesen und geschrieben. Einzelne + Dictionary-Operationen sind durch den GIL atomar, zusammengesetzte Prüfungen + und Ersetzungen sind es nicht. +- Eine neue Verbindung mit derselben Client-ID ersetzt die alte Registrierung. + Der alte Socket wird dabei aktiv geschlossen; seine Route entfernt über den + `ws`-Vergleich nicht die neue Verbindung. +- `group_last_pong` und `group_online_since` werden ohne eigenen Lock + aktualisiert. - Zwischen Auth-Prüfung und tatsächlichem Senden kann eine Verbindung ersetzt werden. Dann kann eine Nachricht an die neue Verbindung gehen oder in der Queue landen. - Der Broker ist prozesslokal. Bei mehreren WSGI-Workern hat jeder Worker eigene Verbindungen und Queues. Eine HTTP-ausgelöste Benachrichtigung kann nur die Verbindungen des Workers erreichen, der den HTTP-Request bearbeitet. + Das ist die wichtigste verbleibende Einschränkung für den Mehrclient-Betrieb. ## 9. Debugausgabe @@ -465,19 +501,19 @@ tail -f CMBNet/logs/cmbnet-ws-$(date +%F).log Jede eingehende Nachricht wird mit folgenden Feldern protokolliert: - `code` -- `sender` mit Account-ID, Name, Rolle, Gruppen-ID und Gruppenalias +- `sender` mit Account-ID, Client-ID, Name, Rolle, Gruppen-ID und Gruppenalias - `receiver_id` -- `session_id` +- `client_id` der Absender-Webview - `ts` - `msg` (bei Code 0 redigiert) -- `recipients`: ermittelte Empfänger mit Name, Rolle, Gruppe, - `connected` und `authenticated` +- `recipients`: ermittelte Clients mit Client-ID, Account-ID, Name, Rolle, + Gruppe, `connected` und `authenticated` - `note`: Grund, falls die Nachricht ignoriert oder abgelehnt wurde Beispielzeile (gekürzt): ```text -2026-10-31 13:31:47.247 [TENANT:1] WS-IN {"code": 100, "sender": {"account_id": 10, "account_name": "gruppe", "role": "Gruppe", "group_id": 20, "group_alias": "G1"}, "receiver_id": null, "session_id": null, "ts": 1793449907246, "msg": "{\"name\": \"Weg\", \"state\": \"erledigt\", \"actor\": 10, \"street_id\": 30, \"group_id\": 20}", "recipients": [{"account_id": 10, "account_name": "gruppe", "role": "Gruppe", "group_id": 20, "group_alias": "G1", "connected": true, "authenticated": true}, {"account_id": 11, "account_name": "dispatcher", "role": "Dispatcher", "group_id": null, "group_alias": null, "connected": true, "authenticated": true}], "note": null} +2026-11-01 10:03:55.247 [TENANT:1] WS-IN {"code": 100, "sender": {"account_id": 10, "account_name": "gruppe", "role": "Gruppe", "group_id": 20, "group_alias": "G1", "client_id": "group-page-1"}, "receiver_id": null, "client_id": "group-page-1", "ts": 1793449907246, "msg": "{\"name\": \"Weg\", \"state\": \"erledigt\", \"actor\": 10, \"street_id\": 30, \"group_id\": 20}", "recipients": [{"client_id": "disp-page-1", "account_id": 11, "account_name": "dispatcher", "role": "Dispatcher", "group_id": null, "group_alias": null, "connected": true, "authenticated": true}, {"client_id": "group-page-1", "account_id": 10, "account_name": "gruppe", "role": "Gruppe", "group_id": 20, "group_alias": "G1", "connected": true, "authenticated": true}], "note": null} ``` Die Debugausgabe dokumentiert den **Soll-Empfängerkreis**. Ob der einzelne @@ -486,9 +522,9 @@ Versand tatsächlich erfolgreich war, ergibt sich erst aus dem anschließenden ## 10. Abweichungen zwischen Soll-Beschreibung und aktuellem Code -Die folgenden Punkte sind bei einer Weiterentwicklung zu beachten. Sie sind -bewusst als Ist-Zustand dokumentiert und nicht alle in diesem Schritt -funktional geändert. +Die folgenden Punkte sind bei einer Weiterentwicklung zu beachten. Mit +„behoben“ markierte Punkte beschreiben den korrigierten Stand; die übrigen +Punkte sind weiterhin offen. ### 10.1 Code 2 erreicht den Admin nicht @@ -514,49 +550,39 @@ erfolgt ausschließlich serverseitig über `notify_reload()` aus HTTP-Handlern. Das Ergebnis ist für die Clients identisch, der Übertragungsweg weicht aber von der Beschreibung ab. -### 10.4 Keine Rollenprüfung bei Chat-Codes +### 10.4 Rollenprüfung bei Chat-Codes (behoben) Soll: - Code 1000 und 1100: nur Dispatcher, - Code 2000: nur Gruppen-Account. -Ist: Jeder authentifizierte Account kann Code 1000, 1100 oder 2000 senden. Die -Empfängerermittlung ist korrekt, aber die Senderrolle wird nicht geprüft. +Der Broker prüft die Senderrolle jetzt in `_validate_chat_sender()`. Bei Code +2000 wird zusätzlich kontrolliert, dass die aufgelöste Zielgruppe die eigene +Gruppe des Absenders ist. Unberechtigte Nachrichten werden vor der Persistenz +und Zustellung mit einer Warnung und einem Debug-Eintrag abgewiesen. -### 10.5 Code 2000 verliert Gruppen-ID und Empfänger-ID +### 10.5 Code-2000-Normalisierung (behoben) -In `_prepare_message()` werden Nachrichten ab Code 1000 vorzeitig an -`_normalize_chat_message()` übergeben. Die anschließenden Zweige für Code 1100 -und 2000 sind dadurch nicht erreichbar. +`_normalize_chat_message()` setzt für Code 2000 jetzt sowohl +`message.receiver_id` als auch `group_id` im normalisierten Payload. Dadurch +können Dispatcher-Ansichten die Nachricht der Gruppe zuordnen, und Late Entries +werden nach einem Reconnect wieder an die eigene Gruppe zugestellt. -Folge für Code 2000: +Weiterhin offen ist die clientseitige Anzeige: -- `message.receiver_id` bleibt `null`. -- Das normalisierte Payload enthält kein `group_id`. -- Die Live-Zustellung an die Gruppe funktioniert nur, weil - `_resolve_group_id()` als Fallback die Gruppe des Absenders verwendet. -- Die Late-Entry-Prüfung `_is_allowed_for_client()` findet bei gespeicherten - Code-2000-Nachrichten weder `group_id` noch `receiver_id` und liefert für - Gruppen-Clients `False`. Code-2000-Nachrichten werden damit nach einem - Reconnect nicht als Late Entry an die eigene Gruppe nachgeliefert. -- Der Dispatcher-Client kann die Gruppenzuordnung nicht aus dem normalisierten - Payload lesen. `handleGroupChatMessage()` in - `static/js/views/dispatcher.js` ermittelt die Gruppe aus `payload.group_id` - oder `message.receiver_id`; beide fehlen, deshalb wird die Nachricht dort - verworfen. - In der Dispatcher-Ansicht wird Code 2000 nicht als Infodialog angezeigt. - Im Beobachter-Modus (`CMBNET_VIEW_MODE === 'observer'`) wird Code 2000 vollständig ignoriert, obwohl Beobachter zum Empfängerkreis gehören. -- Der mobile Gruppen-Client zeigt die Nachricht an, weil sein Filter eine - fehlende Gruppen-ID als „eigene Gruppe“ behandelt. Die Anzeige „An“ kann - dabei jedoch leer bleiben. +- Der mobile Gruppen-Client zeigt die Nachricht an; die neue `group_id` dient + dort der Filterung, während „An“ für Code 2000 weiterhin fest „Dispatcher“ + lautet. -### 10.6 Code 1100: Alias-Präfix ist toter Code +### 10.6 Code 1100: Alias-Präfix wird nicht angewendet -Der Code-1100-Zweig in `_prepare_message()` ist wegen des vorzeitigen -`code >= 1000`-Returns nicht erreichbar. Der dort vorgesehene Alias-Präfix -(`": "`) wird daher nicht angewendet. Der Alias ist weiterhin im +Der frühere Code-1100-Zweig in `_prepare_message()` war wegen des vorzeitigen +`code >= 1000`-Returns nicht erreichbar und wurde entfernt. Ein Alias-Präfix +(`": "`) wird daher weiterhin nicht gesetzt. Der Alias ist im normalisierten `sender`-Objekt enthalten. ### 10.7 Fehlende Namen bei Code 100/200/300 @@ -578,11 +604,11 @@ sollte der Broker den Zeitstempel auch für diese Codes setzen. ### 10.9 Late Entries bei jedem Reconnect `authenticate()` ruft `send_late_entries()` bei jeder erfolgreichen -Authentifizierung auf. Bei einer bereits bekannten Sitzung werden damit +Authentifizierung auf. Bei einem Reconnect mit derselben Client-ID werden damit persistierte Chat-Nachrichten erneut gesendet, auch wenn sie vor dem Verbindungsabbruch schon live zugestellt wurden. Die Clients haben teilweise eigene Deduplizierungsschlüssel, die das abfangen; der Broker selbst -unterscheidet nicht zwischen „neue Sitzung“ und „bekannte Sitzung“. +unterscheidet nicht zwischen „bekannte Client-ID“ und „neue Client-ID“. ### 10.10 Queue-Alter und Queue-Länge @@ -591,13 +617,13 @@ Verbindungsabbruch, kann aber bei einer Queue, die erst durch eine nicht zustellbare Nachricht entsteht, etwas später liegen. Es gibt keine Obergrenze für die Anzahl oder den Speicherbedarf der gepufferten Nachrichten. -### 10.11 Nur eine Verbindung pro Account +### 10.11 Mehrere Verbindungen pro Account (behoben) -`connections[tenant_id][account_id]` enthält genau eine Verbindung. Öffnet -derselbe Account mehrere Tabs, überschreibt der neue Tab die Registrierung. -Der alte Socket wird nicht aktiv geschlossen. Die Sitzungs-Queue ist zwar pro -Tab, aber die Verbindungsverwaltung und `account_sessions` kennen nur die -zuletzt registrierte Sitzung. +`connections[tenant_id][client_id]` enthält genau eine Client-Verbindung. +Mehrere Tabs bzw. Webviews desselben Accounts besitzen unterschiedliche +Client-IDs und damit getrennte Verbindungen und Queues. Eine neue Verbindung +mit derselben Client-ID ersetzt nur diese eine Verbindung; der alte Socket wird +dabei aktiv geschlossen. ### 10.12 Prozesslokaler Broker @@ -615,12 +641,13 @@ nutzt dies intern, um nach bereits erfolgter DB-Änderung ein Code-100/200-Event zu verteilen. Ein direkter WebSocket-Frame eines Administrators wird ebenfalls akzeptiert. -### 10.14 Queues nur bei bekannter Sitzung +### 10.14 Queues nur bei bekannter Client-ID -`_queue_undeliverable()` benötigt eine bekannte Sitzungs-ID in -`account_sessions`. War ein Account in diesem Broker-Prozess noch nie -authentifiziert, wird eine nicht zustellbare Nachricht nicht gepuffert. Nach -einem Serverneustart sind alle Sitzungszuordnungen leer. +`_queue_undeliverable()` benötigt eine dem Broker bekannte Client-ID in +`client_accounts`. Vor dem Code-0-Handshake und nach einem Serverneustart sind +keine Client-Zuordnungen vorhanden; Nachrichten werden dann nicht gepuffert. +Eine neu geladene Webview erhält stattdessen den aktuellen Initialzustand und +die persistierten Late Entries. ### 10.15 Broadcasts ohne Empfänger-ID @@ -639,18 +666,16 @@ erfolgt. ## 11. Empfohlene nächste Schritte -1. Code-2000-Normalisierung korrigieren: `receiver_id` und `group_id` vor dem - Normalisieren setzen und in das gespeicherte Payload aufnehmen. Danach die - Dispatcher- und Beobachter-Anzeige für Code 2000 prüfen. -2. Rollenprüfung für Code 1000/1100/2000 ergänzen. -3. Late Entries nur für neue Sitzungen oder mit einem serverseitigen +1. Late Entries nur für neue Client-IDs oder mit einem serverseitigen „zuletzt gesehen“-Zeitpunkt senden. -4. Code 2 zusätzlich an Administratoren verteilen oder einen separaten +2. Code 2 zusätzlich an Administratoren verteilen oder einen separaten Status-Endpoint für Pong-Überfälligkeit bereitstellen. -5. Zeitstempel für Code 100/200 und Chat-Nachrichten serverseitig setzen. -6. Verbindungsverwaltung für mehrere Tabs oder explizites Schließen der alten - Verbindung absichern. -7. Queue-Länge begrenzen und Queue-Verhalten bei mehreren Workern klären. +3. Zeitstempel für Code 100/200 und Chat-Nachrichten serverseitig setzen. +4. Queue-Länge begrenzen und Queue-Verhalten bei mehreren Workern klären. +5. Code 2000 im Beobachter-Modus und als Infodialog anzeigen. +6. Den prozesslokalen Broker durch einen gemeinsamen Message-Bus oder einen + einzelnen WebSocket-Worker ersetzen, falls mehrere WSGI-Worker betrieben + werden. ## 12. Debugausgabe und Tests @@ -664,4 +689,7 @@ eine Zeile erzeugt. Damit lässt sich nachvollziehen, ob eine Nachricht - und ob der Empfänger verbunden und authentifiziert war. Für automatisierte Tests können `WS_DEBUG_MESSAGES=0` gesetzt und die -bestehenden Queue- und WebSocket-E2E-Tests verwendet werden. +bestehenden Queue- und WebSocket-E2E-Tests verwendet werden. Die Tests decken +insbesondere zwei Clients desselben Accounts, die getrennte Zustellung von +Code 100/300, Reconnect mit derselben Client-ID sowie eine neue Client-ID nach +einem Reload ab. diff --git a/doc/prompt.txt b/doc/prompt.txt index 83e246e..5ede961 100644 --- a/doc/prompt.txt +++ b/doc/prompt.txt @@ -239,3 +239,14 @@ Erläutere, an welchen Stellen die Beschreibung vom aktuellen Code-Stand abweich Bau in die Software eine Debugausgabe für die beim Broker eingehenden Nachrichten ein einschließlich einer Ausgabe, an welche Clients diese weitergeleitet werden soll. ------8<----------------- + +Aktuell verwaltet der Broker die Verbindungen anhand des Mandanten und des Accounts. +Künftig soll der Broker Verbindungen statt anhand von Accounts anhand der Client-ID verwalten. +Ziel soll sein, dass ein Account auch mehrere Clients betreiben kann. +Dazu muss der Broker selbst umgebaut werden. +Die Client-ID wird in jedem Webview einmalig nach dem Laden generiert. Deshalb muss sie auch nicht im SessionStorage gespeichert werden. +Ich sehe jetzt, dass beispielsweise Code-300 Nachrichten vom Gruppen-Client an den Broker geschickt werden, sie aktualisieren aber nicht die Karte oder sonst ein Element im User Interface. +Gleiches gilt auch für Code-100. Werden diese Nachrichten nicht über den Broker an die anderen Cleints weitergeleitet? +Oder werden sie im Client verworfen? + +------8<-----------------