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