WebSocket stabiler gemacht mit Puffern beim Broker

This commit is contained in:
concierge committed 2026-10-31 09:01:44 +01:00
1 parent 12523ddd0a
commit c793e8b16d
10 files changed
+533 -37

No files matched your search

+386 -20
View File
@@ -15,10 +15,18 @@ Wichtige Regeln aus der Spezifikation:
damit sie bei einer späteren Anmeldung als "Late Entry" nachgeliefert werden
können. Nachrichten, die älter als LATE_ENTRY_MAX_AGE_HOURS (Default 8h) sind,
werden gelöscht.
- Nicht zustellbare Nachrichten ab Code 100 werden pro Client-Sitzung gepuffert.
Eine zu alte Queue wird verworfen; beim nächsten Reconnect wird dann Code 99
mit einem Hinweis auf die zu lange Unterbrechung gesendet.
- Code 2 dient zugleich als Lebenszeichen einer Gruppe. Gruppen wechseln bei
einem Pong von "unterwegs" auf "online" und ohne Pong nach dem konfigurierten
Zeitfenster wieder zurück auf "unterwegs".
"""
import json
import re
import time
from datetime import datetime, timedelta, timezone
from threading import Lock
from flask import current_app
from cmbnet.db import get_db
from cmbnet.services.groups_service import GroupsService
@@ -38,6 +46,19 @@ class WebSocketBroker:
# ü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 = {}
self.queue_lock = Lock()
# Zeitpunkt des letzten Code-2-Pongs je Gruppe (monotonic).
self.group_last_pong = {}
self.group_online_since = {}
# ------------------------------------------------------------------
# Verbindungen und Authentifizierung
# ------------------------------------------------------------------
@@ -84,16 +105,50 @@ class WebSocketBroker:
'ws': ws,
'role': role,
'group_id': group_id,
'last_ping': datetime.now()
'session_id': None,
'last_ping': datetime.now(),
'connected_at': time.monotonic(),
'last_pong_at': 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
# pro Verbindung serialisiert werden. Sonst können sich zwei
# Frames überlagern und der Browser meldet "Invalid frame header".
'send_lock': Lock()
}
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)
if not conn:
return False
try:
lock = conn.get('send_lock')
if lock is None:
lock = Lock()
conn['send_lock'] = lock
with lock:
conn['ws'].send(data)
return True
except Exception:
# Eine fehlerhafte Verbindung darf den Versand an andere Clients
# nicht verhindern. Das Aufräumen übernimmt die Route beim
# 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 authenticate(self, tenant_id, account_id, token):
"""Authentifiziert eine Verbindung anhand des Einmal-Tokens (Code 0)."""
def authenticate(self, tenant_id, account_id, token, session_id=None):
"""Authentifiziert eine 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.
"""
db = get_db()
token_row = db.execute(
'SELECT * FROM ws_tokens WHERE token = ? AND tenant_id = ? '
@@ -121,13 +176,37 @@ 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 tenant_id not in self.authenticated:
self.authenticated[tenant_id] = {}
self.authenticated[tenant_id][account_id] = True
# Zuerst die für diese Sitzung 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
)
# Nach erfolgreicher Authentifizierung dürfen die gespeicherten
# Nachrichten der letzten 8 Stunden nachgeliefert werden.
self.send_late_entries(tenant_id, account_id)
# Nachrichten der letzten 8 Stunden nachgeliefert werden. Bereits aus
# der Sitzungs-Queue zugestellte Nachrichten werden dabei ausgelassen.
if not suppress_late_entries:
self.send_late_entries(
tenant_id,
account_id,
skip_messages=queued_messages
)
return True
def remove_connection(self, tenant_id, account_id, ws=None):
@@ -139,7 +218,9 @@ class WebSocketBroker:
"""
connections = self.connections.get(tenant_id)
if connections and account_id in connections:
if ws is None or connections[account_id].get('ws') is ws:
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.
@@ -147,13 +228,178 @@ class WebSocketBroker:
if authenticated and account_id in authenticated:
del authenticated[account_id]
# 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
)
def _get_connection(self, tenant_id, account_id):
return self.connections.get(tenant_id, {}).get(account_id)
# ------------------------------------------------------------------
# Sitzungs-Queues
# ------------------------------------------------------------------
@staticmethod
def _normalize_session_id(value, account_id):
"""Validiert die vom Client gelieferte Sitzungs-ID.
Ältere Clients senden noch keine ID. Für sie wird eine stabile
Ersatz-ID je Account gebildet, damit auch dort die Queue funktioniert.
"""
text = str(value or '').strip()
if re.fullmatch(r'[A-Za-z0-9._:-]{8,128}', text):
return text
return f'legacy-{account_id}'
def _session_queue_max_age_seconds(self):
minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15)
try:
minutes = float(minutes)
except (TypeError, ValueError):
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)
if queue is None:
queue = {
'messages': [],
'created_at': now if now is not None else time.monotonic(),
'expired': False,
'code99_only': False,
'code99_message': None,
}
self.session_queues[key] = queue
return queue
def _expire_session_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():
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."""
if message.code < 100 and message.code != 99:
return
session_id = self.account_sessions.get((tenant_id, account_id))
if not session_id:
return
with self.queue_lock:
queue = self._ensure_session_queue(tenant_id, account_id, session_id)
now = time.monotonic()
if message.code == 99:
# Eine nicht zustellbare Reload-Aufforderung verdrängt alle
# älteren Nachrichten. Danach wird nichts weiter gepuffert.
queue['messages'].clear()
queue['code99_only'] = True
queue['code99_message'] = message.to_json()
queue['expired'] = False
return
self._expire_session_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."""
now = time.monotonic()
with self.queue_lock:
for queue in self.session_queues.values():
self._expire_session_queue(queue, now)
def _session_queue_timeout_message(self):
minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15)
return WSMessage(
sender_id=0,
code=99,
msg=(
'Die WebSocket-Verbindung war zu lange unterbrochen '
f'(mehr als {minutes} Minuten). Bitte lade die Seite neu, '
'um den aktuellen Stand zu erhalten.'
)
).to_json()
def restore_session_queue(self, tenant_id, account_id, session_id):
"""Liefert gepufferte Nachrichten einer wiedererkannten Sitzung aus.
Rückgabe: (Menge der Roh-Nachrichten aus der Queue, Late-Entry-Sperre).
Die Menge dient dazu, dieselben Nachrichten nicht zusätzlich als
Late Entry zu senden. Die Sperre ist gesetzt, wenn die Queue abgelaufen
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)
now = time.monotonic()
with self.queue_lock:
queue = self.session_queues.get(key)
if not queue:
return set(), False
self._expire_session_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)
send_only = True
messages = []
elif queue.get('expired'):
raw_message = self._session_queue_timeout_message()
self.session_queues.pop(key, None)
send_only = True
messages = []
else:
raw_message = None
send_only = False
messages = list(queue.get('messages', []))
queue['messages'] = []
if send_only:
if raw_message and not self.send_to_connection(tenant_id, account_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)
return set(), True
unsent = []
for index, raw_message in enumerate(messages):
if not self.send_to_connection(tenant_id, account_id, raw_message):
unsent = messages[index:]
break
with self.queue_lock:
current = self.session_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)
# Auch nicht zugestellte Queue-Nachrichten von den Late Entries
# ausnehmen. Sie bleiben in der Queue und werden beim nächsten
# Reconnect erneut versucht, statt doppelt gepuffert zu werden.
return set(messages), False
# ------------------------------------------------------------------
# Late Entry
# ------------------------------------------------------------------
def send_late_entries(self, tenant_id, account_id):
def send_late_entries(self, tenant_id, account_id, skip_messages=None):
"""Sendet gespeicherte Nachrichten (Code >= 1000) der letzten 8 Stunden.
Es werden ausschließlich Nachrichten zugestellt, für die der Account
@@ -162,6 +408,7 @@ class WebSocketBroker:
"""
db = get_db()
cutoff = self._late_entry_cutoff()
skip_messages = skip_messages or set()
messages = db.execute(
'SELECT * FROM ws_messages_store WHERE tenant_id = ? AND ts >= ? '
@@ -184,6 +431,8 @@ class WebSocketBroker:
msg=msg_row['msg'],
ts=msg_row['ts']
)
if msg.to_json() in skip_messages:
continue
self._send(tenant_id, account_id, msg)
# Abgelaufene Nachrichten werden bei jeder Anmeldung aufgeräumt.
@@ -299,8 +548,10 @@ class WebSocketBroker:
return
# Code 2 ist die Antwort eines Clients auf den Heartbeat. Sie wird nur
# an Dispatcher-Views weitergeleitet und nicht gespeichert.
# 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._deliver(tenant_id, message, sender)
return
@@ -352,6 +603,122 @@ class WebSocketBroker:
return self._apply_group_position_change(tenant_id, message, sender, payload)
return False
# ------------------------------------------------------------------
# Anwesenheit von Gruppen-Clients
# ------------------------------------------------------------------
def _record_client_pong(self, tenant_id, account_id, sender):
"""Wertet ein Code-2-Lebenszeichen eines Clients aus."""
conn = self._get_connection(tenant_id, account_id)
if conn:
conn['last_pong_at'] = time.monotonic()
if not sender or sender['role'] != 'Gruppe':
return
db = get_db()
group = db.execute(
'''SELECT g.id, g.state FROM groups g
JOIN group_accounts ga
ON ga.group_id = g.id AND ga.tenant_id = g.tenant_id
WHERE ga.account_id = ? AND g.tenant_id = ?''',
(account_id, tenant_id)
).fetchone()
if not group:
return
now = time.monotonic()
group_id = group['id']
self.group_last_pong[(tenant_id, group_id)] = now
if group['state'] == 'unterwegs':
self._set_group_state_internal(
tenant_id, group_id, 'online', actor_account_id=account_id
)
def _set_group_state_internal(self, tenant_id, group_id, new_state, actor_account_id=None):
"""Setzt einen automatisch abgeleiteten Gruppenstatus und informiert Clients."""
db = get_db()
group = db.execute(
'SELECT * FROM groups WHERE id = ? AND tenant_id = ?',
(group_id, tenant_id)
).fetchone()
if not group or group['state'] == new_state:
return False
old_state = group['state']
db.execute(
'UPDATE groups SET state = ?, updated_at = CURRENT_TIMESTAMP '
'WHERE id = ? AND tenant_id = ?',
(new_state, group_id, tenant_id)
)
db.execute(
'''INSERT INTO group_state_history
(tenant_id, group_id, from_state, to_state, last_lat, last_lon,
last_pos_at, actor_account_id)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)''',
(tenant_id, group_id, old_state, new_state,
group['last_lat'], group['last_lon'], group['last_pos_at'],
actor_account_id)
)
db.commit()
GroupsService.update_cache_entry(
tenant_id, group_id, {'state': new_state}
)
if new_state == 'online':
self.group_online_since[(tenant_id, group_id)] = time.monotonic()
message = WSMessage(
sender_id=actor_account_id or 0,
code=200,
msg=json.dumps({
'group_id': group_id,
'state': new_state,
'actor': actor_account_id,
'automatic': True
}, ensure_ascii=False)
)
self._deliver(tenant_id, message, None)
return True
def check_group_presence_timeouts(self, tenant_id=None):
"""Setzt Online-Gruppen ohne Code-2-Pong auf "unterwegs" zurück."""
db = get_db()
if tenant_id is None:
rows = db.execute(
"SELECT id, tenant_id FROM groups WHERE state = 'online'"
).fetchall()
else:
rows = db.execute(
"SELECT id, tenant_id FROM groups "
"WHERE state = 'online' AND tenant_id = ?",
(tenant_id,)
).fetchall()
timeout = current_app.config.get('WS_GROUP_ONLINE_TIMEOUT_SECONDS', 120)
try:
timeout = float(timeout)
except (TypeError, ValueError):
timeout = 120.0
now = time.monotonic()
for row in rows:
key = (row['tenant_id'], row['id'])
reference = self.group_last_pong.get(key)
online_since = self.group_online_since.get(key)
if online_since is not None:
reference = max(reference, online_since) if reference else online_since
if reference is None:
# Zustand war bereits vor dem Start des Trackings "online".
# Ab jetzt läuft die Kulanzfrist.
self.group_online_since[key] = now
continue
if now - reference > timeout:
self._set_group_state_internal(
row['tenant_id'], row['id'], 'unterwegs'
)
def _apply_street_change(self, tenant_id, message, sender, payload):
"""Wendet einen Straßen-State-Wechsel aus einer Code-100-Nachricht an."""
if sender['role'] not in ('Dispatcher', 'Administrator'):
@@ -492,6 +859,8 @@ class WebSocketBroker:
)
db.commit()
GroupsService.update_cache_entry(tenant_id, group_id, {'state': new_state})
if new_state == 'online':
self.group_online_since[(tenant_id, group_id)] = time.monotonic()
self._log_business(tenant_id, sender['id'], 'group.state_change', 'group',
group_id, {'from': group['state'], 'to': new_state})
@@ -730,21 +1099,18 @@ class WebSocketBroker:
self._send(tenant_id, recipient_id, message)
def _send(self, tenant_id, account_id, message):
"""Sendet eine Nachricht, falls für den Account eine Verbindung besteht."""
"""Sendet eine Nachricht oder puffert sie für die letzte Sitzung."""
# Erst nach erfolgreicher Token-Authentifizierung dürfen Nachrichten
# an einen Client zugestellt werden.
if not self.is_authenticated(tenant_id, account_id):
return
conn = self._get_connection(tenant_id, account_id)
if not conn:
return
try:
conn['ws'].send(message.to_json())
except Exception:
# Eine fehlerhafte Verbindung darf den Versand an andere Clients
# nicht verhindern. Das Aufräumen übernimmt die Route beim
# Schließen der Verbindung.
pass
self._queue_undeliverable(tenant_id, account_id, message)
return False
if self.send_to_connection(tenant_id, account_id, message.to_json()):
return True
self._queue_undeliverable(tenant_id, account_id, message)
return False
def _get_recipients(self, tenant_id, message, sender):
"""Bestimmt den Empfängerkreis abhängig vom Nachrichtencode."""