Umbau broekr auf client-id
This commit is contained in:
1 parent
268e150f2b
commit
a95204b8d6
17 files changed
+648
-387
No files matched your search
+21
-16
@@ -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
|
||||||
|
|||||||
@@ -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
@@ -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."""
|
||||||
|
|||||||
@@ -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}')
|
||||||
|
|||||||
@@ -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
@@ -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
@@ -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
|
||||||
|
|||||||
@@ -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
|
||||||
|
|| ''
|
||||||
}));
|
}));
|
||||||
});
|
});
|
||||||
|
|
||||||
|
|||||||
@@ -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`;
|
||||||
|
|||||||
@@ -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>';
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -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);
|
||||||
|
|||||||
@@ -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) {
|
||||||
|
|||||||
@@ -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
@@ -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
@@ -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.
|
||||||
@@ -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<-----------------
|
||||||
Reference in new issue
Block a user