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
+633 -372

No files matched your search

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