Umbau broekr auf client-id
This commit is contained in:
1 parent
268e150f2b
commit
a95204b8d6
17 files changed
+649
-388
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
|
||||
@@ -1326,7 +1328,9 @@ function parseFlexibleTimestamp(value) {
|
||||
function handleWs(event) {
|
||||
let message;
|
||||
try { message = JSON.parse(event.data); } catch(e) { return; }
|
||||
|
||||
|
||||
console.debug('[WS RX]', message);
|
||||
|
||||
if (message.code === 0) {
|
||||
state.authenticated = true;
|
||||
flushWsOutbox();
|
||||
@@ -1356,6 +1360,8 @@ function handleWs(event) {
|
||||
state.currentPolyline.setStyle({color: STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet});
|
||||
}
|
||||
buildStreetList();
|
||||
} else {
|
||||
console.warn('[WS] Code 100: Straße nicht im lokalen Zustand', p);
|
||||
}
|
||||
}
|
||||
} catch(e) {}
|
||||
@@ -1365,12 +1371,17 @@ function handleWs(event) {
|
||||
const p = typeof message.msg === 'string' ? JSON.parse(message.msg) : message.msg;
|
||||
const gid = Number(p.group_id || message.receiver_id);
|
||||
const g = state.groupById.get(gid);
|
||||
if (g && p.lat && p.lon) {
|
||||
g.last_lat = p.lat;
|
||||
g.last_lon = p.lon;
|
||||
const lat = Number(p.lat);
|
||||
const lon = Number(p.lon);
|
||||
if (g && Number.isFinite(lat) && Number.isFinite(lon)
|
||||
&& p.lat !== null && p.lon !== null) {
|
||||
g.last_lat = lat;
|
||||
g.last_lon = lon;
|
||||
g.last_pos_ts = parseFlexibleTimestamp(p.ts) || Date.now();
|
||||
g.last_pos_at = new Date(g.last_pos_ts).toISOString();
|
||||
if (viewMode === 'mobile_dispatcher') showAllGroupPositions();
|
||||
} else if (!g) {
|
||||
console.warn('[WS] Code 300: Gruppe nicht im lokalen Zustand', p);
|
||||
}
|
||||
} catch(e) {}
|
||||
} else if (message.code === 2000 || message.code === 1000 || message.code === 1100) {
|
||||
|
||||
@@ -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') }}">
|
||||
|
||||
Reference in new issue
Block a user