Umbau broekr auf client-id

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

No files matched your search

+329 -177
View File
@@ -25,6 +25,7 @@ Wichtige Regeln aus der Spezifikation:
import json
import re
import time
import uuid
from datetime import datetime, timedelta, timezone
from threading import Lock
from flask import current_app
@@ -35,24 +36,34 @@ from cmbnet.ws.protocol import WSMessage
class WebSocketBroker:
def __init__(self):
# connections[tenant_id][account_id] = {
# connections[tenant_id][client_id] = {
# 'ws': <WebSocket-Objekt>,
# 'account_id': <zugehöriger Account>,
# 'role': <Rolle des Accounts>,
# 'group_id': <verknüpfte Gruppe oder None>,
# }
# Eine Client-ID gehört genau zu einer Webview. Mehrere Clients
# desselben Accounts besitzen daher getrennte Einträge.
self.connections = {}
# authenticated[tenant_id][account_id] = True
# authenticated[tenant_id][client_id] = True
# Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten
# über die Verbindung senden.
self.authenticated = {}
# Nicht zustellbare Nachrichten werden pro Client-Sitzung gepuffert.
# Schlüssel: (tenant_id, account_id, session_id).
self.session_queues = {}
# Zuletzt bekannte Sitzungs-ID je Account. Sie erlaubt es, Nachrichten
# auch dann der richtigen Queue zuzuordnen, wenn gerade keine
# WebSocket-Verbindung besteht.
self.account_sessions = {}
# Nicht zustellbare Nachrichten werden pro Client gepuffert.
# Schlüssel: (tenant_id, client_id).
self.client_queues = {}
# client_accounts[(tenant_id, client_id)] = account_id
# Bleibt auch nach einem Verbindungsabbruch erhalten, damit weitere
# Nachrichten für denselben Client gepuffert werden können.
self.client_accounts = {}
# account_clients[(tenant_id, account_id)] = {client_id, ...}
# Wird für die Empfängerermittlung benötigt: Ein Account kann mehrere
# Clients gleichzeitig betreiben.
self.account_clients = {}
# disconnected_clients[(tenant_id, client_id)] = monotonic Zeitpunkt.
# Dient dem Aufräumen dauerhaft verlassener Webviews.
self.disconnected_clients = {}
self.queue_lock = Lock()
# Zeitpunkt des letzten Code-2-Pongs je Gruppe (monotonic).
@@ -62,12 +73,16 @@ class WebSocketBroker:
# ------------------------------------------------------------------
# Verbindungen und Authentifizierung
# ------------------------------------------------------------------
def register_connection(self, tenant_id, account_id, ws, role=None, group_id=None):
"""Registriert eine neue, noch nicht authentifizierte Verbindung.
def register_connection(self, tenant_id, account_id, client_id, ws, role=None, group_id=None):
"""Registriert eine neue, noch nicht authentifizierte Client-Verbindung.
Rolle und Gruppenzuordnung werden direkt mitgespeichert. Sie werden
später für die Empfängerermittlung und für das Cleanup benötigt.
Die Verbindung wird anhand der Client-ID verwaltet. Die Account-ID wird
mitgeführt, damit Empfänger weiterhin über Rollen und Gruppen ermittelt
werden können und ein Account mehrere Clients parallel betreiben kann.
"""
if not client_id:
return False
db = get_db()
account = db.execute(
'SELECT role FROM accounts WHERE id = ? AND tenant_id = ?',
@@ -76,6 +91,13 @@ class WebSocketBroker:
if not account:
return False
# Eine Client-ID ist an den Account gebunden, der sie im Handshake
# verwendet hat. Ein Wechsel des Accounts unter derselben ID wäre ein
# Hinweis auf eine falsche bzw. manipulierte Zuordnung.
existing_account = self.client_accounts.get((tenant_id, client_id))
if existing_account is not None and existing_account != account_id:
return False
if role is None:
role = account['role']
@@ -91,24 +113,35 @@ class WebSocketBroker:
).fetchone()
group_id = group['id'] if group else None
if tenant_id not in self.connections:
self.connections[tenant_id] = {}
connections = self.connections.setdefault(tenant_id, {})
# Eine neue Verbindung mit derselben Client-ID ersetzt eine eventuell
# noch registrierte alte Verbindung (z. B. nach einem schnellen
# Reconnect).
existing = connections.get(client_id)
if existing and existing.get('ws') is not ws:
try:
existing['ws'].close()
except Exception:
pass
# Eine neue Verbindung muss den Token-Handshake erneut durchlaufen.
# Ein eventuell noch gesetzter Auth-Status einer älteren Verbindung
# desselben Accounts darf nicht übernommen werden.
authenticated = self.authenticated.get(tenant_id)
if authenticated:
authenticated.pop(account_id, None)
authenticated = self.authenticated.setdefault(tenant_id, {})
authenticated.pop(client_id, None)
self.connections[tenant_id][account_id] = {
connections[client_id] = {
'ws': ws,
'account_id': account_id,
'client_id': client_id,
'role': role,
'group_id': group_id,
'session_id': None,
'last_ping': datetime.now(),
'connected_at': time.monotonic(),
'last_pong_at': None,
# Ob diese Client-ID bereits vor diesem Handshake bekannt war.
# Nur dann bleibt ihre Queue auch bei einem fehlgeschlagenen
# erneuten Handshake erhalten.
'known_client': existing_account is not None,
# simple-websocket schreibt Nachrichten direkt auf den Socket.
# Da Heartbeat, WebSocket-Routen und HTTP-ausgelöste Broadcasts
# aus unterschiedlichen Threads senden können, müssen die Frames
@@ -116,11 +149,15 @@ class WebSocketBroker:
# Frames überlagern und der Browser meldet "Invalid frame header".
'send_lock': Lock()
}
self.client_accounts[(tenant_id, client_id)] = account_id
self.account_clients.setdefault((tenant_id, account_id), set()).add(client_id)
self.disconnected_clients.pop((tenant_id, client_id), None)
return True
def send_to_connection(self, tenant_id, account_id, data):
"""Sendet einen Frame thread-sicher an eine registrierte Verbindung."""
conn = self._get_connection(tenant_id, account_id)
def send_to_connection(self, tenant_id, client_id, data):
"""Sendet einen Frame thread-sicher an eine registrierte Client-Verbindung."""
conn = self._get_connection(tenant_id, client_id)
if not conn:
return False
@@ -138,17 +175,21 @@ class WebSocketBroker:
# Schließen der Verbindung.
return False
def is_authenticated(self, tenant_id, account_id):
"""Prüft, ob eine Verbindung den Code-0-Handshake erfolgreich absolviert hat."""
return self.authenticated.get(tenant_id, {}).get(account_id, False)
def is_authenticated(self, tenant_id, client_id):
"""Prüft, ob ein Client den Code-0-Handshake erfolgreich absolviert hat."""
return self.authenticated.get(tenant_id, {}).get(client_id, False)
def authenticate(self, tenant_id, account_id, token, session_id=None):
"""Authentifiziert eine Verbindung anhand des Einmal-Tokens (Code 0).
def authenticate(self, tenant_id, account_id, client_id, token):
"""Authentifiziert eine Client-Verbindung anhand des Einmal-Tokens (Code 0).
Die Sitzungs-ID stammt vom Client und bleibt auch nach einem Neuladen
erhalten. Sie ordnet die Verbindung einer eventuell vorhandenen
Nachrichten-Queue zu.
Die Client-ID wird pro Webview erzeugt und ordnet die Verbindung einer
eventuell vorhandenen Nachrichten-Queue zu. Nach einem Neuladen der
Seite entsteht eine neue Client-ID und damit bewusst eine neue Sitzung.
"""
conn = self._get_connection(tenant_id, client_id)
if not conn or conn.get('account_id') != account_id:
return False
db = get_db()
token_row = db.execute(
'SELECT * FROM ws_tokens WHERE token = ? AND tenant_id = ? '
@@ -176,67 +217,83 @@ class WebSocketBroker:
db.execute('UPDATE ws_tokens SET used = 1 WHERE id = ?', (token_row['id'],))
db.commit()
session_id = self._normalize_session_id(session_id, account_id)
conn = self._get_connection(tenant_id, account_id)
if conn:
conn['session_id'] = session_id
if conn.get('role') == 'Gruppe' and conn.get('group_id'):
# Ein frisch verbundener Gruppen-Client erhält eine
# Zwei-Minuten-Kulanz, bis der erste Code-2-Pong eintrifft.
key = (tenant_id, conn['group_id'])
self.group_online_since[key] = time.monotonic()
self.account_sessions[(tenant_id, account_id)] = session_id
if 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."""