Umbau broekr auf client-id

This commit is contained in:
concierge committed 2026-11-01 21:59:11 +01:00
1 parent 268e150f2b
commit a95204b8d6
17 files changed
+648 -387

No files matched your search

+21 -16
View File
@@ -48,29 +48,34 @@ Clients den Header nicht selbst setzen können.
## WebSocket-Synchronisierung ## WebSocket-Synchronisierung
Jeder Browser-Tab erzeugt eine Sitzungs-ID, die in `sessionStorage` gespeichert Jede Webview erzeugt beim Laden einmalig eine Client-ID. Sie wird bewusst nicht
wird und ein Neuladen übersteht. Nicht zustellbare Nachrichten mit Code >= 100 in `sessionStorage` gespeichert: Ein Seiten-Reload erzeugt eine neue Client-ID
werden beim Broker pro `(Mandant, Account, Sitzungs-ID)` gepuffert und bei der und damit eine neue Broker-Verbindung. Nicht zustellbare Nachrichten mit
nächsten WebSocket-Verbindung mit derselben ID ausgeliefert. 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 - `CMBNET_WS_QUEUE_MAX_AGE_MINUTES` (Default `15`): Maximales Alter einer
Sitzungs-Queue. Ältere Queues werden verworfen; beim nächsten Reconnect wird Client-Queue. Ältere Queues werden verworfen; beim nächsten Reconnect mit
stattdessen eine Code-99-Nachricht mit Hinweis auf die zu lange Unterbrechung derselben Client-ID wird stattdessen eine Code-99-Nachricht mit Hinweis auf
zugestellt. 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- - `CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS` (Default `120`): Zeit ohne Code-2-
Lebenszeichen, nach der eine Gruppe von `online` auf `unterwegs` wechselt. Lebenszeichen, nach der eine Gruppe von `online` auf `unterwegs` wechselt.
- `CMBNET_WS_DEBUG_MESSAGES` (Default `1`): schreibt jede beim Broker - `CMBNET_WS_DEBUG_MESSAGES` (Default `1`): schreibt jede beim Broker
eingehende Nachricht inklusive Absender, Code und ermitteltem Empfängerkreis eingehende Nachricht inklusive Absender, Client-ID, Code und ermitteltem
nach `logs/cmbnet-ws-YYYY-MM-DD.log`. Mit `0` lässt sich die Ausgabe Empfängerkreis nach `logs/cmbnet-ws-YYYY-MM-DD.log`. Mit `0` lässt sich die
abschalten. Ausgabe abschalten.
Die Sitzungs-Queues liegen im Arbeitsspeicher des Broker-Prozesses. Sie Die Client-Queues liegen im Arbeitsspeicher des Broker-Prozesses. Sie
überstehen damit WebSocket-Unterbrechungen und Seiten-Reloads, nicht aber einen überstehen damit kurze WebSocket-Unterbrechungen, nicht aber einen
Neustart des Servers. Der mobile Client puffert zusätzlich ausgehende Seiten-Reload mit neuer Client-ID oder einen Neustart des Servers. Der mobile
fachliche Nachrichten kurzzeitig lokal und sendet sie nach erfolgreicher Client puffert zusätzlich ausgehende fachliche Nachrichten kurzzeitig im
Authentifizierung automatisch nach. Speicher und sendet sie nach erfolgreicher Authentifizierung automatisch nach.
Eine ausführliche Beschreibung des Protokolls, der Brokerlogik, der Eine ausführliche Beschreibung des Protokolls, der Brokerlogik, der
Nebenläufigkeit und der aktuellen Abweichungen steht in Nebenläufigkeit und der aktuellen Abweichungen steht in
+5 -2
View File
@@ -359,17 +359,20 @@ def broker_status(**kwargs):
"""Status aktiver WebSocket-Verbindungen""" """Status aktiver WebSocket-Verbindungen"""
connections = broker.connections.get(g.tenant_id, {}) if hasattr(broker, 'connections') else {} connections = broker.connections.get(g.tenant_id, {}) if hasattr(broker, 'connections') else {}
result = [] result = []
for account_id, conn in connections.items(): for client_id, conn in connections.items():
account = db = get_db().execute( account_id = conn.get('account_id')
account = get_db().execute(
'SELECT id, name, role FROM accounts WHERE id = ? AND tenant_id = ?', 'SELECT id, name, role FROM accounts WHERE id = ? AND tenant_id = ?',
(account_id, g.tenant_id) (account_id, g.tenant_id)
).fetchone() ).fetchone()
if not account: if not account:
continue continue
entry = { entry = {
'client_id': client_id,
'account_id': account['id'], 'account_id': account['id'],
'account_name': account['name'], 'account_name': account['name'],
'role': account['role'], 'role': account['role'],
'authenticated': broker.is_authenticated(g.tenant_id, client_id),
'group_id': None, 'group_id': None,
'group_alias': None 'group_alias': None
} }
+329 -177
View File
@@ -25,6 +25,7 @@ Wichtige Regeln aus der Spezifikation:
import json import json
import re import re
import time import time
import uuid
from datetime import datetime, timedelta, timezone from datetime import datetime, timedelta, timezone
from threading import Lock from threading import Lock
from flask import current_app from flask import current_app
@@ -35,24 +36,34 @@ from cmbnet.ws.protocol import WSMessage
class WebSocketBroker: class WebSocketBroker:
def __init__(self): def __init__(self):
# connections[tenant_id][account_id] = { # connections[tenant_id][client_id] = {
# 'ws': <WebSocket-Objekt>, # 'ws': <WebSocket-Objekt>,
# 'account_id': <zugehöriger Account>,
# 'role': <Rolle des Accounts>, # 'role': <Rolle des Accounts>,
# 'group_id': <verknüpfte Gruppe oder None>, # 'group_id': <verknüpfte Gruppe oder None>,
# } # }
# Eine Client-ID gehört genau zu einer Webview. Mehrere Clients
# desselben Accounts besitzen daher getrennte Einträge.
self.connections = {} self.connections = {}
# authenticated[tenant_id][account_id] = True # authenticated[tenant_id][client_id] = True
# Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten # Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten
# über die Verbindung senden. # über die Verbindung senden.
self.authenticated = {} self.authenticated = {}
# Nicht zustellbare Nachrichten werden pro Client-Sitzung gepuffert. # Nicht zustellbare Nachrichten werden pro Client gepuffert.
# Schlüssel: (tenant_id, account_id, session_id). # Schlüssel: (tenant_id, client_id).
self.session_queues = {} self.client_queues = {}
# Zuletzt bekannte Sitzungs-ID je Account. Sie erlaubt es, Nachrichten # client_accounts[(tenant_id, client_id)] = account_id
# auch dann der richtigen Queue zuzuordnen, wenn gerade keine # Bleibt auch nach einem Verbindungsabbruch erhalten, damit weitere
# WebSocket-Verbindung besteht. # Nachrichten für denselben Client gepuffert werden können.
self.account_sessions = {} 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() self.queue_lock = Lock()
# Zeitpunkt des letzten Code-2-Pongs je Gruppe (monotonic). # Zeitpunkt des letzten Code-2-Pongs je Gruppe (monotonic).
@@ -62,12 +73,16 @@ class WebSocketBroker:
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# Verbindungen und Authentifizierung # Verbindungen und Authentifizierung
# ------------------------------------------------------------------ # ------------------------------------------------------------------
def register_connection(self, tenant_id, account_id, ws, role=None, group_id=None): def register_connection(self, tenant_id, account_id, client_id, ws, role=None, group_id=None):
"""Registriert eine neue, noch nicht authentifizierte Verbindung. """Registriert eine neue, noch nicht authentifizierte Client-Verbindung.
Rolle und Gruppenzuordnung werden direkt mitgespeichert. Sie werden Die Verbindung wird anhand der Client-ID verwaltet. Die Account-ID wird
später für die Empfängerermittlung und für das Cleanup benötigt. 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() db = get_db()
account = db.execute( account = db.execute(
'SELECT role FROM accounts WHERE id = ? AND tenant_id = ?', 'SELECT role FROM accounts WHERE id = ? AND tenant_id = ?',
@@ -76,6 +91,13 @@ class WebSocketBroker:
if not account: if not account:
return False 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: if role is None:
role = account['role'] role = account['role']
@@ -91,24 +113,35 @@ class WebSocketBroker:
).fetchone() ).fetchone()
group_id = group['id'] if group else None group_id = group['id'] if group else None
if tenant_id not in self.connections: connections = self.connections.setdefault(tenant_id, {})
self.connections[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. # Eine neue Verbindung muss den Token-Handshake erneut durchlaufen.
# Ein eventuell noch gesetzter Auth-Status einer älteren Verbindung authenticated = self.authenticated.setdefault(tenant_id, {})
# desselben Accounts darf nicht übernommen werden. authenticated.pop(client_id, None)
authenticated = self.authenticated.get(tenant_id)
if authenticated:
authenticated.pop(account_id, None)
self.connections[tenant_id][account_id] = { connections[client_id] = {
'ws': ws, 'ws': ws,
'account_id': account_id,
'client_id': client_id,
'role': role, 'role': role,
'group_id': group_id, 'group_id': group_id,
'session_id': None,
'last_ping': datetime.now(), 'last_ping': datetime.now(),
'connected_at': time.monotonic(), 'connected_at': time.monotonic(),
'last_pong_at': None, '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. # simple-websocket schreibt Nachrichten direkt auf den Socket.
# Da Heartbeat, WebSocket-Routen und HTTP-ausgelöste Broadcasts # Da Heartbeat, WebSocket-Routen und HTTP-ausgelöste Broadcasts
# aus unterschiedlichen Threads senden können, müssen die Frames # 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". # Frames überlagern und der Browser meldet "Invalid frame header".
'send_lock': Lock() '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 return True
def send_to_connection(self, tenant_id, account_id, data): def send_to_connection(self, tenant_id, client_id, data):
"""Sendet einen Frame thread-sicher an eine registrierte Verbindung.""" """Sendet einen Frame thread-sicher an eine registrierte Client-Verbindung."""
conn = self._get_connection(tenant_id, account_id) conn = self._get_connection(tenant_id, client_id)
if not conn: if not conn:
return False return False
@@ -138,17 +175,21 @@ class WebSocketBroker:
# Schließen der Verbindung. # Schließen der Verbindung.
return False return False
def is_authenticated(self, tenant_id, account_id): def is_authenticated(self, tenant_id, client_id):
"""Prüft, ob eine Verbindung den Code-0-Handshake erfolgreich absolviert hat.""" """Prüft, ob ein Client den Code-0-Handshake erfolgreich absolviert hat."""
return self.authenticated.get(tenant_id, {}).get(account_id, False) return self.authenticated.get(tenant_id, {}).get(client_id, False)
def authenticate(self, tenant_id, account_id, token, session_id=None): def authenticate(self, tenant_id, account_id, client_id, token):
"""Authentifiziert eine Verbindung anhand des Einmal-Tokens (Code 0). """Authentifiziert eine Client-Verbindung anhand des Einmal-Tokens (Code 0).
Die Sitzungs-ID stammt vom Client und bleibt auch nach einem Neuladen Die Client-ID wird pro Webview erzeugt und ordnet die Verbindung einer
erhalten. Sie ordnet die Verbindung einer eventuell vorhandenen eventuell vorhandenen Nachrichten-Queue zu. Nach einem Neuladen der
Nachrichten-Queue zu. 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() db = get_db()
token_row = db.execute( token_row = db.execute(
'SELECT * FROM ws_tokens WHERE token = ? AND tenant_id = ? ' '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.execute('UPDATE ws_tokens SET used = 1 WHERE id = ?', (token_row['id'],))
db.commit() db.commit()
session_id = self._normalize_session_id(session_id, account_id) if conn.get('role') == 'Gruppe' and conn.get('group_id'):
conn = self._get_connection(tenant_id, account_id) # Ein frisch verbundener Gruppen-Client erhält eine
if conn: # Zwei-Minuten-Kulanz, bis der erste Code-2-Pong eintrifft.
conn['session_id'] = session_id key = (tenant_id, conn['group_id'])
if conn.get('role') == 'Gruppe' and conn.get('group_id'): self.group_online_since[key] = time.monotonic()
# 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 tenant_id not in self.authenticated: self.authenticated.setdefault(tenant_id, {})[client_id] = True
self.authenticated[tenant_id] = {} self.client_accounts[(tenant_id, client_id)] = account_id
self.authenticated[tenant_id][account_id] = True 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 # Wurde die Queue wegen Überschreitung der Maximalzeit verworfen, wird
# stattdessen ausschließlich ein Code-99-Hinweis gesendet. # stattdessen ausschließlich ein Code-99-Hinweis gesendet.
queued_messages, suppress_late_entries = self.restore_session_queue( queued_messages, suppress_late_entries = self.restore_client_queue(
tenant_id, account_id, session_id tenant_id, client_id
) )
# Nach erfolgreicher Authentifizierung dürfen die gespeicherten # Nach erfolgreicher Authentifizierung dürfen die gespeicherten
# Nachrichten der letzten 8 Stunden nachgeliefert werden. Bereits aus # 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: if not suppress_late_entries:
self.send_late_entries( self.send_late_entries(
tenant_id, tenant_id,
account_id, account_id,
client_id,
skip_messages=queued_messages skip_messages=queued_messages
) )
return True return True
def remove_connection(self, tenant_id, account_id, ws=None): def remove_connection(self, tenant_id, client_id, ws=None):
"""Entfernt eine Verbindung. """Entfernt eine Client-Verbindung.
Wenn ein Account mehrere Tabs/Verbindungen öffnet, wird nur die Die Client-ID bleibt mit ihrem Account und ihrer Queue registriert, bis
tatsächlich beendete Verbindung entfernt (ws-Vergleich), nicht die sie entweder zurückkehrt oder vom Aufräumjob verworfen wird. Dadurch
zuletzt registrierte. können kurze Unterbrechungen überbrückt werden, ohne andere Clients
desselben Accounts zu beeinflussen.
""" """
connections = self.connections.get(tenant_id) connections = self.connections.get(tenant_id)
if connections and account_id in connections: if not connections or client_id not in connections:
conn = connections[account_id] return
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]
# Ab dem Trennen beginnt die Lebenszeit der Sitzungs-Queue. conn = connections[client_id]
if session_id: if ws is not None and conn.get('ws') is not ws:
with self.queue_lock: return
self._ensure_session_queue(
tenant_id, account_id, session_id
)
def _get_connection(self, tenant_id, account_id): was_authenticated = self.is_authenticated(tenant_id, client_id)
return self.connections.get(tenant_id, {}).get(account_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): def log_incoming(self, tenant_id, message, sender=None, recipients=None, note=None):
"""Schreibt eine Debugzeile für eine beim Broker eingehende Nachricht. """Schreibt eine Debugzeile für eine beim Broker eingehende Nachricht.
@@ -260,19 +317,30 @@ class WebSocketBroker:
(message.sender_id, tenant_id) (message.sender_id, tenant_id)
).fetchone() ).fetchone()
sender_info = None sender_info = (
if sender is not None: 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 = [] recipient_rows = []
for recipient_id in sorted(set(recipients or [])): for recipient_id in sorted(set(recipients or [])):
account = db.execute( account_id = self.client_accounts.get((tenant_id, recipient_id))
'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?', account = None
(recipient_id, tenant_id) if account_id is not None:
).fetchone() account = db.execute(
'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?',
(account_id, tenant_id)
).fetchone()
if account is None: if account is None:
recipient_rows.append({ recipient_rows.append({
'account_id': recipient_id, 'client_id': recipient_id,
'account_id': account_id,
'known': False, 'known': False,
'connected': False, 'connected': False,
'authenticated': False 'authenticated': False
@@ -280,6 +348,7 @@ class WebSocketBroker:
continue continue
info = self._get_sender_info(tenant_id, account) info = self._get_sender_info(tenant_id, account)
info['client_id'] = recipient_id
info['connected'] = bool(self._get_connection(tenant_id, recipient_id)) info['connected'] = bool(self._get_connection(tenant_id, recipient_id))
info['authenticated'] = self.is_authenticated(tenant_id, recipient_id) info['authenticated'] = self.is_authenticated(tenant_id, recipient_id)
recipient_rows.append(info) recipient_rows.append(info)
@@ -297,7 +366,7 @@ class WebSocketBroker:
'code': message.code, 'code': message.code,
'sender': sender_info, 'sender': sender_info,
'receiver_id': message.receiver_id, 'receiver_id': message.receiver_id,
'session_id': getattr(message, 'session_id', None), 'client_id': sender_client_id,
'ts': message.ts, 'ts': message.ts,
'msg': payload, 'msg': payload,
'recipients': recipient_rows, 'recipients': recipient_rows,
@@ -314,21 +383,23 @@ class WebSocketBroker:
pass pass
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# Sitzungs-Queues # Client-Queues
# ------------------------------------------------------------------ # ------------------------------------------------------------------
@staticmethod @staticmethod
def _normalize_session_id(value, account_id): def normalize_client_id(value, account_id=None):
"""Validiert die vom Client gelieferte Sitzungs-ID. """Validiert die vom Webview gelieferte Client-ID.
Ältere Clients senden noch keine ID. Für sie wird eine stabile Die Client-ID wird pro Seitenaufruf neu erzeugt. Ältere Clients, die
Ersatz-ID je Account gebildet, damit auch dort die Queue funktioniert. 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() text = str(value or '').strip()
if re.fullmatch(r'[A-Za-z0-9._:-]{8,128}', text): if re.fullmatch(r'[A-Za-z0-9._:-]{8,128}', text):
return 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) minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15)
try: try:
minutes = float(minutes) minutes = float(minutes)
@@ -336,10 +407,18 @@ class WebSocketBroker:
minutes = 15 minutes = 15
return max(0.0, minutes * 60) return max(0.0, minutes * 60)
def _ensure_session_queue(self, tenant_id, account_id, session_id, now=None): def _client_retention_seconds(self):
"""Liefert die Queue einer Sitzung und legt sie bei Bedarf an.""" minutes = current_app.config.get('WS_CLIENT_RETENTION_MINUTES', 60)
key = (tenant_id, account_id, session_id) try:
queue = self.session_queues.get(key) 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: if queue is None:
queue = { queue = {
'messages': [], 'messages': [],
@@ -347,33 +426,33 @@ class WebSocketBroker:
'expired': False, 'expired': False,
'code99_only': False, 'code99_only': False,
'code99_message': None, 'code99_message': None,
'account_id': self.client_accounts.get(key),
} }
self.session_queues[key] = queue self.client_queues[key] = queue
return 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.""" """Verwirft zu alte Nachrichten und hinterlässt einen Code-99-Hinweis."""
if not queue or queue.get('code99_only') or queue.get('expired'): if not queue or queue.get('code99_only') or queue.get('expired'):
return return
now = now if now is not None else time.monotonic() 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 return
queue['messages'].clear() queue['messages'].clear()
queue['expired'] = True queue['expired'] = True
def _queue_undeliverable(self, tenant_id, account_id, message): def _queue_undeliverable(self, tenant_id, client_id, message):
"""Puffert eine nicht zustellbare Nachricht für die letzte Sitzung.""" """Puffert eine nicht zustellbare Nachricht für einen Client."""
if message.code < 100 and message.code != 99: if message.code < 100 and message.code != 99:
return return
session_id = self.account_sessions.get((tenant_id, account_id)) if (tenant_id, client_id) not in self.client_accounts:
if not session_id:
return return
with self.queue_lock: 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() now = time.monotonic()
if message.code == 99: if message.code == 99:
@@ -385,20 +464,46 @@ class WebSocketBroker:
queue['expired'] = False queue['expired'] = False
return return
self._expire_session_queue(queue, now) self._expire_client_queue(queue, now)
if queue.get('expired') or queue.get('code99_only'): if queue.get('expired') or queue.get('code99_only'):
return return
queue['messages'].append(message.to_json()) queue['messages'].append(message.to_json())
def cleanup_session_queues(self): def cleanup_client_queues(self):
"""Markiert abgelaufene Sitzungs-Queues und verwirft deren Nachrichten.""" """Räumt abgelaufene Client-Queues und verwaiste Webviews auf."""
now = time.monotonic() now = time.monotonic()
retention = self._client_retention_seconds()
with self.queue_lock: with self.queue_lock:
for queue in self.session_queues.values(): for queue in self.client_queues.values():
self._expire_session_queue(queue, now) 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) minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15)
return WSMessage( return WSMessage(
sender_id=0, sender_id=0,
@@ -410,8 +515,8 @@ class WebSocketBroker:
) )
).to_json() ).to_json()
def restore_session_queue(self, tenant_id, account_id, session_id): def restore_client_queue(self, tenant_id, client_id):
"""Liefert gepufferte Nachrichten einer wiedererkannten Sitzung aus. """Liefert gepufferte Nachrichten eines wiedererkannten Clients aus.
Rückgabe: (Menge der Roh-Nachrichten aus der Queue, Late-Entry-Sperre). Rückgabe: (Menge der Roh-Nachrichten aus der Queue, Late-Entry-Sperre).
Die Menge dient dazu, dieselben Nachrichten nicht zusätzlich als 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 war oder nur noch eine Code-99-Nachricht enthielt. In diesem Fall darf
keine zusätzliche Late-Entry-Historie mehr gesendet werden. keine zusätzliche Late-Entry-Historie mehr gesendet werden.
""" """
key = (tenant_id, account_id, session_id) key = (tenant_id, client_id)
now = time.monotonic() now = time.monotonic()
with self.queue_lock: with self.queue_lock:
queue = self.session_queues.get(key) queue = self.client_queues.get(key)
if not queue: if not queue:
return set(), False return set(), False
self._expire_session_queue(queue, now) self._expire_client_queue(queue, now)
if queue.get('code99_only'): if queue.get('code99_only'):
raw_message = queue.get('code99_message') or self._session_queue_timeout_message() raw_message = queue.get('code99_message') or self._client_queue_timeout_message()
self.session_queues.pop(key, None) self.client_queues.pop(key, None)
send_only = True send_only = True
messages = [] messages = []
elif queue.get('expired'): elif queue.get('expired'):
raw_message = self._session_queue_timeout_message() raw_message = self._client_queue_timeout_message()
self.session_queues.pop(key, None) self.client_queues.pop(key, None)
send_only = True send_only = True
messages = [] messages = []
else: else:
@@ -445,26 +550,26 @@ class WebSocketBroker:
queue['messages'] = [] queue['messages'] = []
if send_only: 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 # Verbindung ist bereits wieder weg: Queue für den nächsten
# Versuch erhalten. # Versuch erhalten.
with self.queue_lock: with self.queue_lock:
self.session_queues.setdefault(key, queue) self.client_queues.setdefault(key, queue)
return set(), True return set(), True
unsent = [] unsent = []
for index, raw_message in enumerate(messages): 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:] unsent = messages[index:]
break break
with self.queue_lock: with self.queue_lock:
current = self.session_queues.get(key) current = self.client_queues.get(key)
if current is not None: if current is not None:
if unsent: if unsent:
current['messages'] = unsent + current.get('messages', []) current['messages'] = unsent + current.get('messages', [])
if not 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 # Auch nicht zugestellte Queue-Nachrichten von den Late Entries
# ausnehmen. Sie bleiben in der Queue und werden beim nächsten # ausnehmen. Sie bleiben in der Queue und werden beim nächsten
@@ -474,11 +579,12 @@ class WebSocketBroker:
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# Late Entry # 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. """Sendet gespeicherte Nachrichten (Code >= 1000) der letzten 8 Stunden.
Es werden ausschließlich Nachrichten zugestellt, für die der Account 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. Anschließend werden abgelaufene Nachrichten gelöscht.
""" """
db = get_db() db = get_db()
@@ -491,8 +597,8 @@ class WebSocketBroker:
(tenant_id, cutoff) (tenant_id, cutoff)
).fetchall() ).fetchall()
conn = self._get_connection(tenant_id, account_id) conn = self._get_connection(tenant_id, client_id)
if not conn: if not conn or conn.get('account_id') != account_id:
return return
for msg_row in messages: for msg_row in messages:
@@ -508,7 +614,7 @@ class WebSocketBroker:
) )
if msg.to_json() in skip_messages: if msg.to_json() in skip_messages:
continue continue
self._send(tenant_id, account_id, msg) self._send(tenant_id, client_id, msg)
# Abgelaufene Nachrichten werden bei jeder Anmeldung aufgeräumt. # Abgelaufene Nachrichten werden bei jeder Anmeldung aufgeräumt.
self.cleanup_old_messages(tenant_id) self.cleanup_old_messages(tenant_id)
@@ -590,14 +696,20 @@ class WebSocketBroker:
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# Nachrichtenverarbeitung # 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. """Wertet den Code aus, persistiert ggf. und stellt die Nachricht zu.
``apply_business`` wird nur für Nachrichten verwendet, die direkt über ``apply_business`` wird nur für Nachrichten verwendet, die direkt über
die WebSocket-Route eingehen. Serverintern erzeugte Nachrichten (z. B. die WebSocket-Route eingehen. Serverintern erzeugte Nachrichten (z. B.
aus der Admin-API) haben die Datenbank bereits aktualisiert und dürfen aus der Admin-API) haben die Datenbank bereits aktualisiert und dürfen
deshalb nicht ein zweites Mal angewendet werden. 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() db = get_db()
# Absender muss zum Mandanten gehören. Die Absender-ID wird in der # 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 # an Dispatcher-Views weitergeleitet und nicht gespeichert. Gleichzeitig
# dient sie als Lebenszeichen der Gruppe. # dient sie als Lebenszeichen der Gruppe.
if code == 2: 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) self._deliver(tenant_id, message, sender)
return return
@@ -662,6 +774,22 @@ class WebSocketBroker:
) )
return 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). # Ab hier: fachliche Nachrichten (>= 100).
# Zustandsänderungen, die ein Client per WebSocket meldet, werden vor # Zustandsänderungen, die ein Client per WebSocket meldet, werden vor
# der Zustellung in der Datenbank persistiert. So sind sie auch nach # 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) message = self._prepare_message(tenant_id, message, sender)
# Ab Code 1000 werden Nachrichten für die Late-Entry-Funktion # Ab Code 1000 werden Nachrichten für die Late-Entry-Funktion
# gespeichert. Gespeichert wird die bereits aufbereitete Nachricht # gespeichert. Gespeichert wird die bereits normalisierte Nachricht.
# (bei Code 1100 inklusive Aliasname-Präfix).
if code >= 1000: if code >= 1000:
self._persist_message(tenant_id, message) self._persist_message(tenant_id, message)
@@ -709,10 +836,10 @@ class WebSocketBroker:
# ------------------------------------------------------------------ # ------------------------------------------------------------------
# Anwesenheit von Gruppen-Clients # 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.""" """Wertet ein Code-2-Lebenszeichen eines Clients aus."""
conn = self._get_connection(tenant_id, account_id) conn = self._get_connection(tenant_id, client_id) if client_id else None
if conn: if conn and conn.get('account_id') == account_id:
conn['last_pong_at'] = time.monotonic() conn['last_pong_at'] = time.monotonic()
if not sender or sender['role'] != 'Gruppe': if not sender or sender['role'] != 'Gruppe':
@@ -1177,6 +1304,17 @@ class WebSocketBroker:
except (TypeError, ValueError): except (TypeError, ValueError):
message.receiver_id = group_id message.receiver_id = group_id
normalized['group_id'] = message.receiver_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: elif message.code == 1000:
normalized['broadcast'] = True normalized['broadcast'] = True
else: else:
@@ -1186,68 +1324,82 @@ class WebSocketBroker:
message.msg = json.dumps(normalized, ensure_ascii=False) message.msg = json.dumps(normalized, ensure_ascii=False)
return message return message
def _prepare_message(self, tenant_id, message, sender): def _validate_chat_sender(self, tenant_id, message, sender):
"""Ergänzt Nachrichten um serverseitig abgeleitete Informationen.""" """Prüft Senderrolle und Gruppenzuordnung für Chat-Nachrichten."""
db = get_db()
payload = self._payload(message)
code = message.code code = message.code
role = sender['role']
if code >= 1000: if code in (1000, 1100):
return self._normalize_chat_message(tenant_id, message, sender, payload) 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_id = self._resolve_group_id(tenant_id, message, sender, payload)
group = self._fetch_group(tenant_id, group_id) sender_group_id = self._get_sender_info(tenant_id, sender).get('group_id')
message.receiver_id = group_id if group_id is None or sender_group_id is None:
if group: return False, 'Gruppen-Account ist keiner Gruppe zugeordnet'
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)
elif message.code == 2000: try:
group_id = self._resolve_group_id(tenant_id, message, sender, payload) if int(group_id) != int(sender_group_id):
message.receiver_id = group_id return False, 'Code 2000 darf nur an die eigene Gruppe gesendet werden'
if isinstance(payload, dict): except (TypeError, ValueError):
if group_id and not payload.get('group_id'): return False, 'Ungültige Gruppen-ID für Code 2000'
payload['group_id'] = group_id return True, None
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)
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 return message
def _deliver(self, tenant_id, message, sender): 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)) recipients = sorted(self._get_recipients(tenant_id, message, sender))
self.log_incoming(tenant_id, message, sender, recipients=recipients) self.log_incoming(tenant_id, message, sender, recipients=recipients)
for recipient_id in recipients: for client_id in recipients:
self._send(tenant_id, recipient_id, message) self._send(tenant_id, client_id, message)
def _send(self, tenant_id, account_id, message): def _send(self, tenant_id, client_id, message):
"""Sendet eine Nachricht oder puffert sie für die letzte Sitzung.""" """Sendet eine Nachricht an einen Client oder puffert sie für ihn."""
# Erst nach erfolgreicher Token-Authentifizierung dürfen Nachrichten # Erst nach erfolgreicher Token-Authentifizierung dürfen Nachrichten
# an einen Client zugestellt werden. # an einen Client zugestellt werden.
if not self.is_authenticated(tenant_id, account_id): if not self.is_authenticated(tenant_id, client_id):
self._queue_undeliverable(tenant_id, account_id, message) self._queue_undeliverable(tenant_id, client_id, message)
return False 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 return True
self._queue_undeliverable(tenant_id, account_id, message) self._queue_undeliverable(tenant_id, client_id, message)
return False 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): 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() db = get_db()
recipients = set() recipient_accounts = set()
code = message.code code = message.code
payload = self._payload(message) payload = self._payload(message)
@@ -1257,7 +1409,7 @@ class WebSocketBroker:
f'SELECT id FROM accounts WHERE tenant_id = ? AND role IN ({placeholders})', f'SELECT id FROM accounts WHERE tenant_id = ? AND role IN ({placeholders})',
(tenant_id, *roles) (tenant_id, *roles)
).fetchall() ).fetchall()
recipients.update(row['id'] for row in rows) recipient_accounts.update(row['id'] for row in rows)
def add_group_account(group_id): def add_group_account(group_id):
if not group_id: if not group_id:
@@ -1267,10 +1419,10 @@ class WebSocketBroker:
WHERE group_id = ? AND tenant_id = ?''', WHERE group_id = ? AND tenant_id = ?''',
(group_id, tenant_id) (group_id, tenant_id)
).fetchall() ).fetchall()
recipients.update(row['account_id'] for row in rows) recipient_accounts.update(row['account_id'] for row in rows)
if code == 99: 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')) add_accounts(('Gast', 'Beobachter', 'Gruppe', 'Dispatcher', 'Administrator'))
elif code == 100: elif code == 100:
@@ -1329,7 +1481,7 @@ class WebSocketBroker:
# Heartbeat-Antworten werden nur an Dispatcher-Views weitergegeben. # Heartbeat-Antworten werden nur an Dispatcher-Views weitergegeben.
add_accounts(('Dispatcher',)) add_accounts(('Dispatcher',))
return recipients return self._client_ids_for_accounts(tenant_id, recipient_accounts)
def _persist_message(self, tenant_id, message): def _persist_message(self, tenant_id, message):
"""Speichert Nachrichten mit Code >= 1000 für die Late-Entry-Funktion.""" """Speichert Nachrichten mit Code >= 1000 für die Late-Entry-Funktion."""
+5 -5
View File
@@ -71,16 +71,16 @@ class HeartbeatManager:
# Nur authentifizierte Verbindungen erhalten einen Heartbeat. # Nur authentifizierte Verbindungen erhalten einen Heartbeat.
for tenant_id, connections in list(broker.connections.items()): for tenant_id, connections in list(broker.connections.items()):
for account_id in list(connections): for client_id in list(connections):
if not broker.is_authenticated(tenant_id, account_id): if not broker.is_authenticated(tenant_id, client_id):
continue 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: if self.app is not None:
try: try:
with self.app.app_context(): with self.app.app_context():
broker.cleanup_session_queues() broker.cleanup_client_queues()
broker.cleanup_old_messages() broker.cleanup_old_messages()
except Exception as exc: except Exception as exc:
print(f'Heartbeat cleanup error: {exc}') print(f'Heartbeat cleanup error: {exc}')
+5 -3
View File
@@ -6,7 +6,7 @@ from datetime import datetime
class WSMessage: 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.sender_id = sender_id
self.receiver_id = receiver_id self.receiver_id = receiver_id
self.code = code self.code = code
@@ -14,7 +14,7 @@ class WSMessage:
self.ts = ts or int(datetime.now().timestamp() * 1000) self.ts = ts or int(datetime.now().timestamp() * 1000)
# Nur für den Code-0-Handshake. Wird nicht an andere Clients # Nur für den Code-0-Handshake. Wird nicht an andere Clients
# weitergegeben und deshalb auch nicht in to_dict() serialisiert. # weitergegeben und deshalb auch nicht in to_dict() serialisiert.
self.session_id = session_id self.client_id = client_id
def to_dict(self): def to_dict(self):
return { return {
@@ -36,7 +36,9 @@ class WSMessage:
code=data.get('code', 0), code=data.get('code', 0),
msg=data.get('msg', ''), msg=data.get('msg', ''),
ts=data.get('ts'), 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 @classmethod
+66 -29
View File
@@ -3,8 +3,8 @@ WebSocket Routes
Ablauf einer Verbindung: Ablauf einer Verbindung:
1. Client verbindet sich mit /<tenant>/ws. 1. Client verbindet sich mit /<tenant>/ws.
2. Client sendet Code 0 mit dem zuvor über die API geholten Einmal-Token 2. Client sendet Code 0 mit dem zuvor über die API geholten Einmal-Token und
und seiner persistenten Sitzungs-ID. seiner Client-ID. Die Client-ID wird pro Webview erzeugt.
3. Erst nach erfolgreicher Prüfung dürfen fachliche Nachrichten gesendet 3. Erst nach erfolgreicher Prüfung dürfen fachliche Nachrichten gesendet
werden. Vorher wird die Verbindung geschlossen. werden. Vorher wird die Verbindung geschlossen.
""" """
@@ -17,9 +17,16 @@ from cmbnet.ws.protocol import WSMessage
def _parse_auth_payload(value): 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): 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): if isinstance(value, str):
text = value.strip() text = value.strip()
@@ -29,7 +36,10 @@ def _parse_auth_payload(value):
except (TypeError, ValueError): except (TypeError, ValueError):
return None, None return None, None
if isinstance(data, dict): 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 text, None
return None, None return None, None
@@ -52,10 +62,9 @@ def ws(ws, tenant):
ws.close() ws.close()
return return
# Verbindung registrieren, aber noch nicht als authentifiziert markieren. # Die Verbindung wird erst mit dem Code-0-Handshake registriert. Vorher
if not broker.register_connection(tenant_id, account_id, ws): # ist die Client-ID noch nicht bekannt.
ws.close() client_id = None
return
try: try:
while True: while True:
@@ -74,43 +83,68 @@ def ws(ws, tenant):
# Die Absender-ID stammt immer aus der Session und kann vom Client # Die Absender-ID stammt immer aus der Session und kann vom Client
# nicht gefälscht werden. # nicht gefälscht werden.
msg.sender_id = account_id 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: if msg.code == 0:
token, session_id = _parse_auth_payload(msg.msg) if client_id:
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
):
broker.log_incoming( broker.log_incoming(
tenant_id, msg, recipients=[], tenant_id, msg, recipients=[client_id],
note='Code-0-Handshake fehlgeschlagen' note='Code-0-Handshake nach bereits erfolgreicher Authentifizierung'
)
current_app.logger.warning(
'WebSocket-Authentifizierung fehlgeschlagen: tenant=%s account=%s',
tenant_id, account_id
) )
ws.close() ws.close()
break 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( broker.log_incoming(
tenant_id, msg, recipients=[account_id], tenant_id, msg, recipients=[client_id],
note='Code-0-Handshake erfolgreich' note='Code-0-Handshake erfolgreich'
) )
# Bestätigt dem Client den erfolgreichen Handshake. Erst jetzt # Bestätigt dem Client den erfolgreichen Handshake. Erst jetzt
# darf er gepufferte fachliche Nachrichten senden. # darf er gepufferte fachliche Nachrichten senden.
broker.send_to_connection( broker.send_to_connection(
tenant_id, tenant_id,
account_id, client_id,
WSMessage(sender_id=0, code=0, msg='authenticated').to_json() WSMessage(sender_id=0, code=0, msg='authenticated').to_json()
) )
continue continue
# Fachliche Nachrichten sind erst nach erfolgreicher # Fachliche Nachrichten sind erst nach erfolgreicher
# Authentifizierung erlaubt. # 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( broker.log_incoming(
tenant_id, msg, recipients=[], tenant_id, msg, recipients=[],
note='Nachricht vor Code-0-Authentifizierung' note='Nachricht vor Code-0-Authentifizierung'
@@ -118,9 +152,12 @@ def ws(ws, tenant):
ws.close() ws.close()
break 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: except Exception as exc:
print(f'WebSocket error: {exc}') print(f'WebSocket error: {exc}')
finally: finally:
broker.remove_connection(tenant_id, account_id, ws) if client_id:
broker.remove_connection(tenant_id, client_id, ws)
+9 -2
View File
@@ -19,11 +19,18 @@ class Config:
WS_GROUP_ONLINE_TIMEOUT_SECONDS = int( WS_GROUP_ONLINE_TIMEOUT_SECONDS = int(
os.environ.get('CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS', '120') os.environ.get('CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS', '120')
) )
# Wie lange nicht zustellbare Nachrichten pro Client-Sitzung vorgehalten # Wie lange nicht zustellbare Nachrichten pro Client vorgehalten werden,
# werden, bevor sie verworfen und durch einen Code-99-Hinweis ersetzt werden. # bevor sie verworfen und durch einen Code-99-Hinweis ersetzt werden.
WS_QUEUE_MAX_AGE_MINUTES = int( WS_QUEUE_MAX_AGE_MINUTES = int(
os.environ.get('CMBNET_WS_QUEUE_MAX_AGE_MINUTES', '15') 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')) 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 # Ausführliche Broker-Debugausgabe für eingehende Nachrichten und den
# ermittelten Empfängerkreis. Kann im Betrieb über die Umgebungsvariable # ermittelten Empfängerkreis. Kann im Betrieb über die Umgebungsvariable
+3 -1
View File
@@ -128,7 +128,9 @@
ws.send(JSON.stringify({ ws.send(JSON.stringify({
code: 0, code: 0,
msg: data.token, msg: data.token,
session_id: window.CMBNET_CLIENT_SESSION_ID || '' client_id: window.CMBNET_CLIENT_ID
|| window.CMBNET_CLIENT_SESSION_ID
|| ''
})); }));
}); });
+1 -1
View File
@@ -5,7 +5,7 @@
* damit er sowohl die mobilen Views als auch die statischen Assets * damit er sowohl die mobilen Views als auch die statischen Assets
* kontrolliert. Der Cache-Name wird pro App-Wurzel gebildet. * 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 BASE = new URL('./', self.location).href;
const SHELL_CACHE = `${VERSION}-shell`; const SHELL_CACHE = `${VERSION}-shell`;
const TILE_CACHE = `${VERSION}-tiles`; const TILE_CACHE = `${VERSION}-tiles`;
+6 -3
View File
@@ -14,7 +14,7 @@ async function loadBrokerStatus() {
if (!data.connections || data.connections.length === 0) { if (!data.connections || data.connections.length === 0) {
const row = document.createElement('tr'); const row = document.createElement('tr');
const cell = document.createElement('td'); const cell = document.createElement('td');
cell.colSpan = 4; cell.colSpan = 5;
cell.textContent = 'Keine aktiven Verbindungen'; cell.textContent = 'Keine aktiven Verbindungen';
row.appendChild(cell); row.appendChild(cell);
body.appendChild(row); body.appendChild(row);
@@ -22,6 +22,9 @@ async function loadBrokerStatus() {
} }
for (const conn of data.connections) { for (const conn of data.connections) {
const row = document.createElement('tr'); 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'); const tdId = document.createElement('td');
tdId.textContent = conn.account_id; tdId.textContent = conn.account_id;
const tdName = document.createElement('td'); const tdName = document.createElement('td');
@@ -36,13 +39,13 @@ async function loadBrokerStatus() {
} else { } else {
tdGroup.textContent = '-'; tdGroup.textContent = '-';
} }
row.append(tdId, tdName, tdRole, tdGroup); row.append(tdClient, tdId, tdName, tdRole, tdGroup);
body.appendChild(row); body.appendChild(row);
} }
} catch (error) { } catch (error) {
console.error(error); console.error(error);
const body = document.getElementById('brokerStatusBody'); const body = document.getElementById('brokerStatusBody');
body.innerHTML = '<tr><td colspan="4">Fehler beim Laden</td></tr>'; body.innerHTML = '<tr><td colspan="5">Fehler beim Laden</td></tr>';
} }
} }
+15 -4
View File
@@ -2704,7 +2704,9 @@ async function connectWebSocket() {
ws.send(JSON.stringify({ ws.send(JSON.stringify({
code: 0, code: 0,
msg: token, msg: token,
session_id: window.CMBNET_CLIENT_SESSION_ID || '' client_id: window.CMBNET_CLIENT_ID
|| window.CMBNET_CLIENT_SESSION_ID
|| ''
})); }));
dispatcherState.authenticated = true; dispatcherState.authenticated = true;
setConnectionStatus('Verbunden', 'connected'); setConnectionStatus('Verbunden', 'connected');
@@ -2928,7 +2930,10 @@ function handleStreetUpdate(message) {
if (!street && payload.name) { if (!street && payload.name) {
street = dispatcherState.streets.find(item => item.name === 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)) { if (STREET_STATES.includes(payload.state)) {
street.state = payload.state; street.state = payload.state;
@@ -2951,7 +2956,10 @@ function handleGroupStateUpdate(message) {
const payload = parsePayload(message.msg) || {}; const payload = parsePayload(message.msg) || {};
const groupId = Number(payload.group_id ?? message.receiver_id); const groupId = Number(payload.group_id ?? message.receiver_id);
const group = dispatcherState.groupById.get(groupId); 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)) { if (GROUP_STATES.includes(payload.state)) {
group.state = payload.state; group.state = payload.state;
@@ -2963,7 +2971,10 @@ function handleGroupPositionUpdate(message) {
const payload = parsePayload(message.msg) || {}; const payload = parsePayload(message.msg) || {};
const groupId = Number(payload.group_id ?? message.receiver_id); const groupId = Number(payload.group_id ?? message.receiver_id);
const group = dispatcherState.groupById.get(groupId); 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 lat = Number(payload.lat);
const lon = Number(payload.lon); const lon = Number(payload.lon);
+15 -4
View File
@@ -1154,7 +1154,9 @@ function connectWebSocket() {
ws.send(JSON.stringify({ ws.send(JSON.stringify({
code: 0, code: 0,
msg: token, 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 // Fallback für ältere Server, die noch keine Code-0-Bestätigung
@@ -1327,6 +1329,8 @@ function handleWs(event) {
let message; let message;
try { message = JSON.parse(event.data); } catch(e) { return; } try { message = JSON.parse(event.data); } catch(e) { return; }
console.debug('[WS RX]', message);
if (message.code === 0) { if (message.code === 0) {
state.authenticated = true; state.authenticated = true;
flushWsOutbox(); flushWsOutbox();
@@ -1356,6 +1360,8 @@ function handleWs(event) {
state.currentPolyline.setStyle({color: STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet}); state.currentPolyline.setStyle({color: STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet});
} }
buildStreetList(); buildStreetList();
} else {
console.warn('[WS] Code 100: Straße nicht im lokalen Zustand', p);
} }
} }
} catch(e) {} } catch(e) {}
@@ -1365,12 +1371,17 @@ function handleWs(event) {
const p = typeof message.msg === 'string' ? JSON.parse(message.msg) : message.msg; const p = typeof message.msg === 'string' ? JSON.parse(message.msg) : message.msg;
const gid = Number(p.group_id || message.receiver_id); const gid = Number(p.group_id || message.receiver_id);
const g = state.groupById.get(gid); const g = state.groupById.get(gid);
if (g && p.lat && p.lon) { const lat = Number(p.lat);
g.last_lat = p.lat; const lon = Number(p.lon);
g.last_lon = 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_ts = parseFlexibleTimestamp(p.ts) || Date.now();
g.last_pos_at = new Date(g.last_pos_ts).toISOString(); g.last_pos_at = new Date(g.last_pos_ts).toISOString();
if (viewMode === 'mobile_dispatcher') showAllGroupPositions(); if (viewMode === 'mobile_dispatcher') showAllGroupPositions();
} else if (!g) {
console.warn('[WS] Code 300: Gruppe nicht im lokalen Zustand', p);
} }
} catch(e) {} } catch(e) {}
} else if (message.code === 2000 || message.code === 1000 || message.code === 1100) { } else if (message.code === 2000 || message.code === 1000 || message.code === 1100) {
+2 -1
View File
@@ -19,6 +19,7 @@
<table id="brokerStatusTable"> <table id="brokerStatusTable">
<thead> <thead>
<tr> <tr>
<th>Client-ID</th>
<th>Account-ID</th> <th>Account-ID</th>
<th>Account</th> <th>Account</th>
<th>Rolle</th> <th>Rolle</th>
@@ -26,7 +27,7 @@
</tr> </tr>
</thead> </thead>
<tbody id="brokerStatusBody"> <tbody id="brokerStatusBody">
<tr><td colspan="4">Lade...</td></tr> <tr><td colspan="5">Lade...</td></tr>
</tbody> </tbody>
</table> </table>
</section> </section>
+17 -29
View File
@@ -29,38 +29,26 @@
return clean ? base + '/' + clean : (base || '/'); return clean ? base + '/' + clean : (base || '/');
}; };
// Stabile ID pro Browser-Tab. Sie übersteht ein Neuladen und ordnet // Jede Webview erhält beim Laden genau eine neue Client-ID. Sie wird
// die WebSocket-Sitzung ihrer Nachrichten-Queue beim Broker zu. // bewusst nicht in sessionStorage gespeichert: Ein Neuladen erzeugt
(function initClientSessionId() { // eine neue Webview und damit eine neue Broker-Verbindung.
const key = 'cmbnet:client-session:' + (window.CMBNET_TENANT || ''); (function initClientId() {
let sessionId = null; let clientId = null;
try { if (window.crypto && typeof window.crypto.randomUUID === 'function') {
sessionId = window.sessionStorage.getItem(key); clientId = window.crypto.randomUUID();
} catch (error) { } else if (window.crypto && typeof window.crypto.getRandomValues === 'function') {
// sessionStorage kann in privaten Kontexten gesperrt sein. 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) { window.CMBNET_CLIENT_ID = clientId;
if (window.crypto && typeof window.crypto.randomUUID === 'function') { // Übergangsweise für noch gecachte ältere Skripte.
sessionId = window.crypto.randomUUID(); window.CMBNET_CLIENT_SESSION_ID = clientId;
} 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;
})(); })();
</script> </script>
<link rel="stylesheet" href="{{ url_for('static', filename='css/pico.min.css') }}"> <link rel="stylesheet" href="{{ url_for('static', filename='css/pico.min.css') }}">
Binary file not shown.
+138 -110
View File
@@ -1,6 +1,6 @@
# Broker und WebSocket-Protokoll # Broker und WebSocket-Protokoll
Stand: 31.10.2026 Stand: 01.11.2026
Dieses Dokument beschreibt das aktuelle WebSocket-Protokoll, die Aufgaben und Dieses Dokument beschreibt das aktuelle WebSocket-Protokoll, die Aufgaben und
den Ablauf des Brokers sowie die Stellen, an denen die Implementierung von der 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, - ordnet Nachrichten anhand ihres Codes einem Empfängerkreis zu,
- wendet fachliche Zustandsänderungen für Straßen und Gruppen an, - wendet fachliche Zustandsänderungen für Straßen und Gruppen an,
- persistiert Chat-Nachrichten für die spätere Nachlieferung, - 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. - überwacht die Lebenszeichen der Gruppen.
Die Web-APIs liefern den Clients unabhängig vom Broker den aktuellen 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 sondern verteilt Änderungen und gleicht kurzfristige Verbindungsunterbrechungen
aus. aus.
## 2. Transport, Authentifizierung und Sitzung ## 2. Transport, Authentifizierung und Client-ID
### Endpoint ### Endpoint
@@ -57,7 +57,7 @@ Nach dem Öffnen der WebSocket-Verbindung sendet der Client Code 0:
{ {
"code": 0, "code": 0,
"msg": "<einmaliges-token>", "msg": "<einmaliges-token>",
"session_id": "<client-sitzungs-id>" "client_id": "<client-id-der-webview>"
} }
``` ```
@@ -65,22 +65,29 @@ Das Token wird vorher über `GET /<tenant>/api/auth/ws-token` geholt. Es ist
mandanten- und accountgebunden, nur einmal verwendbar und standardmäßig eine mandanten- und accountgebunden, nur einmal verwendbar und standardmäßig eine
Stunde gültig. Stunde gültig.
Die `session_id` wird pro Browser-Tab in `sessionStorage` erzeugt und bleibt Die `client_id` wird in `templates/base.html` bei jedem Laden einer Webview
über ein Neuladen der Seite erhalten. Sie ordnet die Verbindung einer einmalig erzeugt. Sie wird bewusst **nicht** in `sessionStorage` gespeichert:
Nachrichten-Queue zu. 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 ```json
{ {
"code": 0, "code": 0,
"msg": { "msg": {
"token": "<token>", "token": "<token>",
"session_id": "<client-sitzungs-id>" "session_id": "<alte-sitzungs-id>"
} }
} }
``` ```
Fehlt eine gültige Client-ID vollständig, erzeugt der Broker eine eindeutige
Ersatz-ID (`legacy-<account>-<zufall>`). 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: Nach erfolgreicher Prüfung antwortet der Server mit einer Code-0-Bestätigung:
```json ```json
@@ -155,10 +162,13 @@ fachliche Empfänger weitergeleitet. Der Broker prüft:
1. Existiert das Token für Mandant und Account? 1. Existiert das Token für Mandant und Account?
2. Ist es noch nicht verwendet? 2. Ist es noch nicht verwendet?
3. Ist es nicht abgelaufen? 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 Danach wird das Token als verbraucht markiert, die Client-ID normalisiert und
der Account als authentifiziert registriert. Ohne gültigen Code 0 werden die Verbindung als authentifiziert registriert. Ohne gültigen Code 0 werden
fachliche Nachrichten nicht akzeptiert; die Verbindung wird geschlossen. 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 ### Code 1: Heartbeat
@@ -170,7 +180,7 @@ authentifizierten Verbindungen:
``` ```
Die Heartbeat-Routine läuft in einem Daemon-Timer. Sie räumt zusätzlich 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 ### Code 2: Pong / Lebenszeichen
@@ -211,13 +221,14 @@ Admin- und Dispatcher-Clients als mögliche Sender; diese lösen Code 99 aktuell
Queue-Verhalten: 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. gespeichert.
- Eine gespeicherte Code-99-Nachricht leert alle älteren Queue-Nachrichten. - Eine gespeicherte Code-99-Nachricht leert alle älteren Queue-Nachrichten.
- Danach werden keine weiteren Nachrichten in dieser Queue gepuffert - Danach werden keine weiteren Nachrichten in dieser Queue gepuffert
(`code99_only`). (`code99_only`).
- Beim nächsten Reconnect wird ausschließlich diese Code-99-Nachricht - Beim nächsten Reconnect mit derselben Client-ID wird ausschließlich diese
zugestellt. Late Entries werden in diesem Fall unterdrückt. Code-99-Nachricht zugestellt. Late Entries werden in diesem Fall
unterdrückt.
- Ist die Queue wegen Überschreitung der Maximalzeit abgelaufen, erzeugt der - Ist die Queue wegen Überschreitung der Maximalzeit abgelaufen, erzeugt der
Broker eine Code-99-Nachricht mit Hinweis auf die zu lange Unterbrechung. 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 ### Code 1000: Broadcast
Soll-Sender: Dispatcher. Empfänger: alle Dispatcher, Beobachter und alle 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 ### Code 1100: Nachricht an eine Gruppe
Soll-Sender: Dispatcher. Empfänger: alle Dispatcher, Beobachter und die Soll-Sender: Dispatcher. Empfänger: alle Dispatcher, Beobachter und die
adressierte Gruppe. Der Broker ermittelt die Gruppen-ID aus `group_id`, adressierte Gruppe. Der Broker ermittelt die Gruppen-ID aus `group_id`,
`receiver_id` oder dem Absender. Die aktuelle Implementierung prüft die `receiver_id` oder dem Absender und akzeptiert Code 1100 nur von Accounts mit
Senderrolle nicht. der Rolle `Dispatcher`.
### Code 2000: Nachricht aus einer Gruppe ### Code 2000: Nachricht aus einer Gruppe
Soll-Sender: Gruppen-Account. Empfänger: alle Dispatcher, Beobachter und die 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 ## 7. Broker-Ablauf
@@ -319,19 +334,30 @@ eigene Gruppe. Die aktuelle Implementierung prüft die Senderrolle nicht.
`WebSocketBroker.connections` ist ein verschachteltes Dictionary: `WebSocketBroker.connections` ist ein verschachteltes Dictionary:
```text ```text
connections[tenant_id][account_id] = { connections[tenant_id][client_id] = {
ws, role, group_id, session_id, ws, account_id, client_id, role, group_id,
last_ping, connected_at, last_pong_at, send_lock last_ping, connected_at, last_pong_at, send_lock
} }
``` ```
Pro Account wird derzeit genau eine Verbindung gespeichert. Eine neue Eine Client-ID gehört genau zu einer Webview. Ein Account kann daher mehrere
Verbindung desselben Accounts überschreibt die alte Registrierung. 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 Ohne erfolgreichen Code-0-Handshake werden keine fachlichen Nachrichten
zugestellt. 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 ### Empfängerermittlung
`_get_recipients()` entscheidet anhand des Codes und der Absenderrolle: `_get_recipients()` entscheidet anhand des Codes und der Absenderrolle:
@@ -344,33 +370,36 @@ zugestellt.
- Code 2000: Dispatcher, Beobachter und die eigene Gruppe, - Code 2000: Dispatcher, Beobachter und die eigene Gruppe,
- Code 2: nur Dispatcher. - Code 2: nur Dispatcher.
Die Empfänger werden als Account-IDs ermittelt. Gruppen-Accounts werden über Die fachlichen Empfänger werden weiterhin als Account-IDs ermittelt.
`group_accounts` aufgelöst. 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 ### Zustellung
`_deliver()` sendet die Nachricht an jeden ermittelten Empfänger. `_send()` `_deliver()` sendet die Nachricht an jeden ermittelten Client. `_send()` prüft
prüft zuerst die Authentifizierung: zuerst die Authentifizierung:
- authentifiziert und Verbindung vorhanden: direkter Versand, - authentifiziert und Verbindung vorhanden: direkter Versand,
- nicht authentifiziert oder Versand fehlgeschlagen: Eintrag in die - 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 Der direkte Versand erfolgt pro Verbindung über einen `send_lock`. Dadurch
werden Heartbeat, Route-Thread und HTTP-ausgelöste Broadcasts nicht gleichzeitig werden Heartbeat, Route-Thread und HTTP-ausgelöste Broadcasts nicht gleichzeitig
in denselben Socket schreiben. in denselben Socket schreiben.
### Sitzungs-Queues ### Client-Queues
Queues werden unter dem Schlüssel Queues werden unter dem Schlüssel
```text ```text
(tenant_id, account_id, session_id) (tenant_id, client_id)
``` ```
gespeichert. Die zuletzt bekannte Session-ID wird zusätzlich in gespeichert. Die Account-Zuordnung liegt in `client_accounts`. Sie bleibt auch
`account_sessions` gehalten, damit Nachrichten auch ohne aktive Verbindung der ohne aktive Verbindung bestehen, damit weitere Nachrichten für dieselbe Webview
richtigen Queue zugeordnet werden können. gepuffert werden können.
Eigenschaften: Eigenschaften:
@@ -381,22 +410,28 @@ Eigenschaften:
Verbindungsabbruch, Verbindungsabbruch,
- abgelaufene Queues werden geleert und als „Tombstone“ für den - abgelaufene Queues werden geleert und als „Tombstone“ für den
Code-99-Hinweis behalten, 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 - Queues liegen ausschließlich im Arbeitsspeicher und überleben keinen
Serverneustart, Serverneustart,
- es gibt derzeit keine feste Obergrenze für die Anzahl gepufferter - es gibt derzeit keine feste Obergrenze für die Anzahl gepufferter
Nachrichten. 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 ### Late Entries
Nach erfolgreicher Authentifizierung sendet der Broker persistierte Nach erfolgreicher Authentifizierung sendet der Broker persistierte
Chat-Nachrichten der letzten acht Stunden, für die der Account berechtigt ist. Chat-Nachrichten der letzten acht Stunden, für die der Account berechtigt ist.
Bereits aus der Sitzungs-Queue zugestellte Nachrichten werden dabei Bereits aus der Client-Queue zugestellte Nachrichten werden dabei übersprungen.
übersprungen.
Die aktuelle Implementierung sendet Late Entries bei **jeder** erfolgreichen Die aktuelle Implementierung sendet Late Entries bei **jeder** erfolgreichen
Authentifizierung, also auch bei einer bereits bekannten Sitzung. Die Authentifizierung. Bei einem Reconnect mit derselben Client-ID können dadurch
Soll-Beschreibung sieht eine initiale Historiennachlieferung für neue Nachrichten erneut ankommen, die bereits live zugestellt wurden. Bei einer neu
Websessions vor. Das kann bei Reconnects zu zusätzlichen Wiederholungen führen. geladenen Webview mit neuer Client-ID ist die Nachlieferung dagegen gewollt.
### Heartbeat und Gruppenpräsenz ### Heartbeat und Gruppenpräsenz
@@ -408,28 +443,29 @@ prüft alle 15 Sekunden die Gruppenpräsenz. Bei fehlendem Pong wird eine
Berücksichtigt sind: 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. - `send_lock` pro Verbindung serialisiert alle ausgehenden Frames.
- Timer laufen als Daemon-Threads. - Timer laufen als Daemon-Threads.
- SQLite-Zugriffe erfolgen pro Thread über die Flask-App-Kontexte. - SQLite-Zugriffe erfolgen pro Thread über die Flask-App-Kontexte.
Nicht vollständig abgesichert sind: Nicht vollständig abgesichert sind:
- `connections` und `authenticated` werden ohne eigenen Lock gelesen und - `connections`, `authenticated`, `client_accounts` und `account_clients`
geschrieben. Einzelne Dictionary-Operationen sind durch den GIL atomar, werden ohne eigenen Lock gelesen und geschrieben. Einzelne
zusammengesetzte Prüfungen und Ersetzungen sind es nicht. Dictionary-Operationen sind durch den GIL atomar, zusammengesetzte Prüfungen
- Eine neue Verbindung für denselben Account ersetzt die alte Registrierung, und Ersetzungen sind es nicht.
ohne den alten Socket aktiv zu schließen. Der alte Socket kann bis zum - Eine neue Verbindung mit derselben Client-ID ersetzt die alte Registrierung.
Client-seitigen Schließen weiter existieren; seine Route verwendet aber den Der alte Socket wird dabei aktiv geschlossen; seine Route entfernt über den
Account-Kontext der neuen Verbindung. `ws`-Vergleich nicht die neue Verbindung.
- `account_sessions`, `group_last_pong` und `group_online_since` werden ohne - `group_last_pong` und `group_online_since` werden ohne eigenen Lock
eigenen Lock aktualisiert. aktualisiert.
- Zwischen Auth-Prüfung und tatsächlichem Senden kann eine Verbindung ersetzt - 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 werden. Dann kann eine Nachricht an die neue Verbindung gehen oder in der
Queue landen. Queue landen.
- Der Broker ist prozesslokal. Bei mehreren WSGI-Workern hat jeder Worker - Der Broker ist prozesslokal. Bei mehreren WSGI-Workern hat jeder Worker
eigene Verbindungen und Queues. Eine HTTP-ausgelöste Benachrichtigung kann eigene Verbindungen und Queues. Eine HTTP-ausgelöste Benachrichtigung kann
nur die Verbindungen des Workers erreichen, der den HTTP-Request bearbeitet. 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 ## 9. Debugausgabe
@@ -465,19 +501,19 @@ tail -f CMBNet/logs/cmbnet-ws-$(date +%F).log
Jede eingehende Nachricht wird mit folgenden Feldern protokolliert: Jede eingehende Nachricht wird mit folgenden Feldern protokolliert:
- `code` - `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` - `receiver_id`
- `session_id` - `client_id` der Absender-Webview
- `ts` - `ts`
- `msg` (bei Code 0 redigiert) - `msg` (bei Code 0 redigiert)
- `recipients`: ermittelte Empfänger mit Name, Rolle, Gruppe, - `recipients`: ermittelte Clients mit Client-ID, Account-ID, Name, Rolle,
`connected` und `authenticated` Gruppe, `connected` und `authenticated`
- `note`: Grund, falls die Nachricht ignoriert oder abgelehnt wurde - `note`: Grund, falls die Nachricht ignoriert oder abgelehnt wurde
Beispielzeile (gekürzt): Beispielzeile (gekürzt):
```text ```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 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 ## 10. Abweichungen zwischen Soll-Beschreibung und aktuellem Code
Die folgenden Punkte sind bei einer Weiterentwicklung zu beachten. Sie sind Die folgenden Punkte sind bei einer Weiterentwicklung zu beachten. Mit
bewusst als Ist-Zustand dokumentiert und nicht alle in diesem Schritt „behoben“ markierte Punkte beschreiben den korrigierten Stand; die übrigen
funktional geändert. Punkte sind weiterhin offen.
### 10.1 Code 2 erreicht den Admin nicht ### 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 Das Ergebnis ist für die Clients identisch, der Übertragungsweg weicht aber von
der Beschreibung ab. der Beschreibung ab.
### 10.4 Keine Rollenprüfung bei Chat-Codes ### 10.4 Rollenprüfung bei Chat-Codes (behoben)
Soll: Soll:
- Code 1000 und 1100: nur Dispatcher, - Code 1000 und 1100: nur Dispatcher,
- Code 2000: nur Gruppen-Account. - Code 2000: nur Gruppen-Account.
Ist: Jeder authentifizierte Account kann Code 1000, 1100 oder 2000 senden. Die Der Broker prüft die Senderrolle jetzt in `_validate_chat_sender()`. Bei Code
Empfängerermittlung ist korrekt, aber die Senderrolle wird nicht geprüft. 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()` setzt für Code 2000 jetzt sowohl
`_normalize_chat_message()` übergeben. Die anschließenden Zweige für Code 1100 `message.receiver_id` als auch `group_id` im normalisierten Payload. Dadurch
und 2000 sind dadurch nicht erreichbar. 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. - In der Dispatcher-Ansicht wird Code 2000 nicht als Infodialog angezeigt.
- Im Beobachter-Modus (`CMBNET_VIEW_MODE === 'observer'`) wird Code 2000 - Im Beobachter-Modus (`CMBNET_VIEW_MODE === 'observer'`) wird Code 2000
vollständig ignoriert, obwohl Beobachter zum Empfängerkreis gehören. vollständig ignoriert, obwohl Beobachter zum Empfängerkreis gehören.
- Der mobile Gruppen-Client zeigt die Nachricht an, weil sein Filter eine - Der mobile Gruppen-Client zeigt die Nachricht an; die neue `group_id` dient
fehlende Gruppen-ID als „eigene Gruppe“ behandelt. Die Anzeige „An“ kann dort der Filterung, während „An“ für Code 2000 weiterhin fest „Dispatcher“
dabei jedoch leer bleiben. 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 Der frühere Code-1100-Zweig in `_prepare_message()` war wegen des vorzeitigen
`code >= 1000`-Returns nicht erreichbar. Der dort vorgesehene Alias-Präfix `code >= 1000`-Returns nicht erreichbar und wurde entfernt. Ein Alias-Präfix
(`"<Alias>: "`) wird daher nicht angewendet. Der Alias ist weiterhin im (`"<Alias>: "`) wird daher weiterhin nicht gesetzt. Der Alias ist im
normalisierten `sender`-Objekt enthalten. normalisierten `sender`-Objekt enthalten.
### 10.7 Fehlende Namen bei Code 100/200/300 ### 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 ### 10.9 Late Entries bei jedem Reconnect
`authenticate()` ruft `send_late_entries()` bei jeder erfolgreichen `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 persistierte Chat-Nachrichten erneut gesendet, auch wenn sie vor dem
Verbindungsabbruch schon live zugestellt wurden. Die Clients haben teilweise Verbindungsabbruch schon live zugestellt wurden. Die Clients haben teilweise
eigene Deduplizierungsschlüssel, die das abfangen; der Broker selbst 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 ### 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 zustellbare Nachricht entsteht, etwas später liegen. Es gibt keine Obergrenze
für die Anzahl oder den Speicherbedarf der gepufferten Nachrichten. 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 `connections[tenant_id][client_id]` enthält genau eine Client-Verbindung.
derselbe Account mehrere Tabs, überschreibt der neue Tab die Registrierung. Mehrere Tabs bzw. Webviews desselben Accounts besitzen unterschiedliche
Der alte Socket wird nicht aktiv geschlossen. Die Sitzungs-Queue ist zwar pro Client-IDs und damit getrennte Verbindungen und Queues. Eine neue Verbindung
Tab, aber die Verbindungsverwaltung und `account_sessions` kennen nur die mit derselben Client-ID ersetzt nur diese eine Verbindung; der alte Socket wird
zuletzt registrierte Sitzung. dabei aktiv geschlossen.
### 10.12 Prozesslokaler Broker ### 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 zu verteilen. Ein direkter WebSocket-Frame eines Administrators wird ebenfalls
akzeptiert. 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 `_queue_undeliverable()` benötigt eine dem Broker bekannte Client-ID in
`account_sessions`. War ein Account in diesem Broker-Prozess noch nie `client_accounts`. Vor dem Code-0-Handshake und nach einem Serverneustart sind
authentifiziert, wird eine nicht zustellbare Nachricht nicht gepuffert. Nach keine Client-Zuordnungen vorhanden; Nachrichten werden dann nicht gepuffert.
einem Serverneustart sind alle Sitzungszuordnungen leer. Eine neu geladene Webview erhält stattdessen den aktuellen Initialzustand und
die persistierten Late Entries.
### 10.15 Broadcasts ohne Empfänger-ID ### 10.15 Broadcasts ohne Empfänger-ID
@@ -639,18 +666,16 @@ erfolgt.
## 11. Empfohlene nächste Schritte ## 11. Empfohlene nächste Schritte
1. Code-2000-Normalisierung korrigieren: `receiver_id` und `group_id` vor dem 1. Late Entries nur für neue Client-IDs oder mit einem serverseitigen
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
„zuletzt gesehen“-Zeitpunkt senden. „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. Status-Endpoint für Pong-Überfälligkeit bereitstellen.
5. Zeitstempel für Code 100/200 und Chat-Nachrichten serverseitig setzen. 3. Zeitstempel für Code 100/200 und Chat-Nachrichten serverseitig setzen.
6. Verbindungsverwaltung für mehrere Tabs oder explizites Schließen der alten 4. Queue-Länge begrenzen und Queue-Verhalten bei mehreren Workern klären.
Verbindung absichern. 5. Code 2000 im Beobachter-Modus und als Infodialog anzeigen.
7. Queue-Länge begrenzen und Queue-Verhalten bei mehreren Workern klären. 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 ## 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. - und ob der Empfänger verbunden und authentifiziert war.
Für automatisierte Tests können `WS_DEBUG_MESSAGES=0` gesetzt und die 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.
+11
View File
@@ -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. 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<----------------- ------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<-----------------