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
+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."""
|
||||
|
||||
Reference in new issue
Block a user