Broker unterstützt jetzt mehrere WSGI Worker
This commit is contained in:
1 parent
1e2a58e563
commit
f5b0c9509c
13 files changed
+1246
-321
No files matched your search
+25
-5
@@ -70,12 +70,32 @@ Die Zeitfenster lassen sich über Umgebungsvariablen konfigurieren:
|
|||||||
eingehende Nachricht inklusive Absender, Client-ID, Code und ermitteltem
|
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
|
Empfängerkreis nach `logs/cmbnet-ws-YYYY-MM-DD.log`. Mit `0` lässt sich die
|
||||||
Ausgabe abschalten.
|
Ausgabe abschalten.
|
||||||
|
- `CMBNET_WS_BUS_POLL_INTERVAL` (Default `0.5`): Intervall in Sekunden, in dem
|
||||||
|
jeder Worker die gemeinsame Queue für seine lokal verbundenen Clients prüft.
|
||||||
|
- `CMBNET_WS_EPHEMERAL_TTL_SECONDS` (Default `30`): Lebensdauer kurzlebiger
|
||||||
|
Code-2-Zustellaufträge.
|
||||||
|
- `CMBNET_WS_WORKER_ID`: optionale feste Worker-ID; muss je Worker-Prozess
|
||||||
|
eindeutig sein. Standardmäßig wird `<hostname>:<pid>` verwendet.
|
||||||
|
|
||||||
Die Client-Queues liegen im Arbeitsspeicher des Broker-Prozesses. Sie
|
Die Client-Queues und Sequenznummern liegen in der gemeinsamen SQLite-Datenbank
|
||||||
überstehen damit kurze WebSocket-Unterbrechungen, nicht aber einen
|
(`ws_clients`, `ws_client_queue`). Dadurch überstehen sie einen Worker-Neustart
|
||||||
Seiten-Reload mit neuer Client-ID oder einen Neustart des Servers. Der mobile
|
und einen Reconnect auf einem anderen WSGI-Worker. Jeder Worker betreibt eine
|
||||||
Client puffert zusätzlich ausgehende fachliche Nachrichten kurzzeitig im
|
eigene Zustellschleife und liefert nur an seine lokal verbundenen Clients aus.
|
||||||
Speicher und sendet sie nach erfolgreicher Authentifizierung automatisch nach.
|
Die Latenz für workerübergreifende Nachrichten ergibt sich aus
|
||||||
|
`CMBNET_WS_BUS_POLL_INTERVAL` (Default `0.5` Sekunden). Der mobile Client
|
||||||
|
puffert zusätzlich ausgehende fachliche Nachrichten kurzzeitig im Speicher und
|
||||||
|
sendet sie nach erfolgreicher Authentifizierung automatisch nach.
|
||||||
|
|
||||||
|
Für den Betrieb mit mehreren Workern muss Gunicorn ohne `preload_app` laufen,
|
||||||
|
damit Heartbeat und Zustellschleife in jedem Worker-Prozess starten:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
gunicorn --worker-class gevent --workers 4 --bind 127.0.0.1:5000 wsgi:app
|
||||||
|
```
|
||||||
|
|
||||||
|
SQLite läuft dabei im WAL-Modus mit einem `busy_timeout`. Bei sehr vielen
|
||||||
|
Clients oder hoher Schreiblast sollte statt SQLite ein Redis- oder
|
||||||
|
PostgreSQL-Bus verwendet werden.
|
||||||
|
|
||||||
Eine ausführliche Beschreibung des Protokolls, der Brokerlogik, der
|
Eine ausführliche Beschreibung des Protokolls, der Brokerlogik, der
|
||||||
Nebenläufigkeit und der aktuellen Abweichungen steht in
|
Nebenläufigkeit und der aktuellen Abweichungen steht in
|
||||||
|
|||||||
@@ -157,6 +157,12 @@ def create_app(config_name=None):
|
|||||||
# WebSocket Routes laden
|
# WebSocket Routes laden
|
||||||
from cmbnet.ws import routes
|
from cmbnet.ws import routes
|
||||||
|
|
||||||
|
# Optionale feste Worker-ID aus der Konfiguration übernehmen. Der Broker
|
||||||
|
# liest sonst CMBNET_WS_WORKER_ID bzw. bildet <hostname>:<pid>.
|
||||||
|
from cmbnet.ws import broker as ws_broker
|
||||||
|
if app.config.get('WS_WORKER_ID'):
|
||||||
|
ws_broker.worker_id = app.config['WS_WORKER_ID']
|
||||||
|
|
||||||
# Heartbeat starten (Code 1 jede Minute, Aufräumen alter Nachrichten)
|
# Heartbeat starten (Code 1 jede Minute, Aufräumen alter Nachrichten)
|
||||||
from cmbnet.ws.heartbeat import heartbeat_manager
|
from cmbnet.ws.heartbeat import heartbeat_manager
|
||||||
heartbeat_manager.start(
|
heartbeat_manager.start(
|
||||||
@@ -164,6 +170,16 @@ def create_app(config_name=None):
|
|||||||
interval=app.config.get('WS_HEARTBEAT_INTERVAL', 60)
|
interval=app.config.get('WS_HEARTBEAT_INTERVAL', 60)
|
||||||
)
|
)
|
||||||
|
|
||||||
|
# Worker-lokale Schleife für die gemeinsame Zustell-Queue. Jeder
|
||||||
|
# Gunicorn-/WSGI-Worker muss eine eigene Instanz starten. Bei
|
||||||
|
# ``preload_app=True`` würde sie im Master starten und in den Workern
|
||||||
|
# fehlen; deshalb ist der Betrieb ohne Preload erforderlich.
|
||||||
|
from cmbnet.ws.delivery import delivery_worker
|
||||||
|
delivery_worker.start(
|
||||||
|
app,
|
||||||
|
interval=app.config.get('WS_BUS_POLL_INTERVAL', 0.5)
|
||||||
|
)
|
||||||
|
|
||||||
# Favicon explizit bedienen, damit /favicon.ico nicht als Tenant-Pfad
|
# Favicon explizit bedienen, damit /favicon.ico nicht als Tenant-Pfad
|
||||||
# interpretiert wird.
|
# interpretiert wird.
|
||||||
@app.route('/favicon.ico')
|
@app.route('/favicon.ico')
|
||||||
|
|||||||
+17
-31
@@ -356,38 +356,24 @@ def import_streets(**kwargs):
|
|||||||
@admin_api_bp.route('/broker/status')
|
@admin_api_bp.route('/broker/status')
|
||||||
@role_required('Administrator')
|
@role_required('Administrator')
|
||||||
def broker_status(**kwargs):
|
def broker_status(**kwargs):
|
||||||
"""Status aktiver WebSocket-Verbindungen"""
|
"""Status aktiver WebSocket-Verbindungen aller Worker.
|
||||||
connections = broker.connections.get(g.tenant_id, {}) if hasattr(broker, 'connections') else {}
|
|
||||||
|
Die Verbindungsliste liegt in der gemeinsamen Tabelle ``ws_clients``.
|
||||||
|
Dadurch zeigt das Dashboard auch Clients, die an einem anderen
|
||||||
|
WSGI-Worker hängen.
|
||||||
|
"""
|
||||||
|
connections = broker.describe_connections(g.tenant_id)
|
||||||
result = []
|
result = []
|
||||||
for client_id, conn in connections.items():
|
for conn in connections:
|
||||||
account_id = conn.get('account_id')
|
result.append({
|
||||||
account = get_db().execute(
|
'client_id': conn['client_id'],
|
||||||
'SELECT id, name, role FROM accounts WHERE id = ? AND tenant_id = ?',
|
'account_id': conn['account_id'],
|
||||||
(account_id, g.tenant_id)
|
'account_name': conn['account_name'],
|
||||||
).fetchone()
|
'role': conn['role'],
|
||||||
if not account:
|
'authenticated': bool(conn['authenticated']),
|
||||||
continue
|
'group_id': conn['group_id'],
|
||||||
entry = {
|
'group_alias': conn['group_alias']
|
||||||
'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
|
|
||||||
}
|
|
||||||
if account['role'] == 'Gruppe':
|
|
||||||
group = get_db().execute(
|
|
||||||
'''SELECT g.id, g.aliasname 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'], g.tenant_id)
|
|
||||||
).fetchone()
|
|
||||||
if group:
|
|
||||||
entry['group_id'] = group['id']
|
|
||||||
entry['group_alias'] = group['aliasname']
|
|
||||||
result.append(entry)
|
|
||||||
return jsonify({'connections': result})
|
return jsonify({'connections': result})
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -11,8 +11,16 @@ def get_db():
|
|||||||
db_path = current_app.config['DATABASE_PATH']
|
db_path = current_app.config['DATABASE_PATH']
|
||||||
# Stelle sicher, dass das instance Verzeichnis existiert
|
# Stelle sicher, dass das instance Verzeichnis existiert
|
||||||
Path(db_path).parent.mkdir(parents=True, exist_ok=True)
|
Path(db_path).parent.mkdir(parents=True, exist_ok=True)
|
||||||
g.db = sqlite3.connect(db_path)
|
g.db = sqlite3.connect(db_path, timeout=30)
|
||||||
g.db.row_factory = sqlite3.Row
|
g.db.row_factory = sqlite3.Row
|
||||||
|
# Mehrere WSGI-Worker schreiben gleichzeitig in dieselbe SQLite-Datei.
|
||||||
|
# busy_timeout zuerst setzen, damit auch das Umschalten auf WAL bei
|
||||||
|
# parallelen Verbindungen warten kann statt sofort zu scheitern.
|
||||||
|
# WAL erlaubt parallele Leser und reduziert die Blockierzeit bei
|
||||||
|
# Schreibern.
|
||||||
|
g.db.execute('PRAGMA busy_timeout = 30000')
|
||||||
|
g.db.execute('PRAGMA journal_mode = WAL')
|
||||||
|
g.db.execute('PRAGMA synchronous = NORMAL')
|
||||||
return g.db
|
return g.db
|
||||||
|
|
||||||
|
|
||||||
@@ -23,6 +31,65 @@ def close_db(e=None):
|
|||||||
db.close()
|
db.close()
|
||||||
|
|
||||||
|
|
||||||
|
def ensure_ws_schema(db):
|
||||||
|
"""Legt die Tabellen für den prozessübergreifenden Broker-Zustand an."""
|
||||||
|
db.executescript('''
|
||||||
|
CREATE TABLE IF NOT EXISTS ws_clients (
|
||||||
|
tenant_id INTEGER NOT NULL,
|
||||||
|
client_id TEXT NOT NULL,
|
||||||
|
account_id INTEGER NOT NULL,
|
||||||
|
last_seq INTEGER NOT NULL DEFAULT 0,
|
||||||
|
worker_id TEXT,
|
||||||
|
authenticated INTEGER NOT NULL DEFAULT 0,
|
||||||
|
connected_at REAL,
|
||||||
|
disconnected_at REAL,
|
||||||
|
queue_started_at REAL,
|
||||||
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||||
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||||
|
PRIMARY KEY (tenant_id, client_id),
|
||||||
|
FOREIGN KEY (tenant_id) REFERENCES tenants(id),
|
||||||
|
FOREIGN KEY (account_id) REFERENCES accounts(id)
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE TABLE IF NOT EXISTS ws_client_queue (
|
||||||
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||||
|
tenant_id INTEGER NOT NULL,
|
||||||
|
client_id TEXT NOT NULL,
|
||||||
|
code INTEGER NOT NULL,
|
||||||
|
payload TEXT NOT NULL,
|
||||||
|
code99_only INTEGER NOT NULL DEFAULT 0,
|
||||||
|
created_at REAL NOT NULL,
|
||||||
|
expires_at REAL,
|
||||||
|
FOREIGN KEY (tenant_id) REFERENCES tenants(id)
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE TABLE IF NOT EXISTS ws_group_presence (
|
||||||
|
tenant_id INTEGER NOT NULL,
|
||||||
|
group_id INTEGER NOT NULL,
|
||||||
|
last_pong_at REAL,
|
||||||
|
online_since REAL,
|
||||||
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||||
|
PRIMARY KEY (tenant_id, group_id),
|
||||||
|
FOREIGN KEY (tenant_id) REFERENCES tenants(id),
|
||||||
|
FOREIGN KEY (group_id) REFERENCES groups(id)
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE TABLE IF NOT EXISTS cache_state (
|
||||||
|
key TEXT PRIMARY KEY,
|
||||||
|
revision INTEGER NOT NULL DEFAULT 0,
|
||||||
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||||
|
);
|
||||||
|
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_ws_clients_account
|
||||||
|
ON ws_clients(tenant_id, account_id);
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_ws_client_queue_client
|
||||||
|
ON ws_client_queue(tenant_id, client_id, id);
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_ws_client_queue_expires
|
||||||
|
ON ws_client_queue(expires_at);
|
||||||
|
''')
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
def ensure_schema():
|
def ensure_schema():
|
||||||
"""Ergänzt bestehende Datenbanken um das Gruppen-Account-Zuordnungsmodell.
|
"""Ergänzt bestehende Datenbanken um das Gruppen-Account-Zuordnungsmodell.
|
||||||
|
|
||||||
@@ -32,6 +99,7 @@ def ensure_schema():
|
|||||||
und die alte Spalte durch einen Tabellen-Neubau entfernt.
|
und die alte Spalte durch einen Tabellen-Neubau entfernt.
|
||||||
"""
|
"""
|
||||||
db = get_db()
|
db = get_db()
|
||||||
|
ensure_ws_schema(db)
|
||||||
groups_table = db.execute(
|
groups_table = db.execute(
|
||||||
"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'groups'"
|
"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'groups'"
|
||||||
).fetchone()
|
).fetchone()
|
||||||
|
|||||||
@@ -10,10 +10,61 @@ from cmbnet.db import get_db
|
|||||||
class GroupsService:
|
class GroupsService:
|
||||||
# In-Memory Cache: groups_cache[tenant_id][group_id] = group_dict
|
# In-Memory Cache: groups_cache[tenant_id][group_id] = group_dict
|
||||||
_cache = {}
|
_cache = {}
|
||||||
|
# Gemeinsame Cache-Revision je Mandant. Sie liegt in der Tabelle
|
||||||
|
# ``cache_state`` und wird bei jeder schreibenden Änderung erhöht. Dadurch
|
||||||
|
# verwirft jeder Worker seinen lokalen Cache, sobald ein anderer Worker
|
||||||
|
# Gruppen- oder Zuordnungsdaten geändert hat.
|
||||||
|
_cache_revision = {}
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def _revision_key(cls, tenant_id):
|
||||||
|
return f'groups:{tenant_id}'
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def _current_revision(cls, tenant_id):
|
||||||
|
db = get_db()
|
||||||
|
key = cls._revision_key(tenant_id)
|
||||||
|
row = db.execute(
|
||||||
|
'SELECT revision FROM cache_state WHERE key = ?', (key,)
|
||||||
|
).fetchone()
|
||||||
|
if row is None:
|
||||||
|
db.execute(
|
||||||
|
'INSERT OR IGNORE INTO cache_state (key, revision) VALUES (?, 0)',
|
||||||
|
(key,)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
return 0
|
||||||
|
return int(row['revision'] or 0)
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def _bump_revision(cls, tenant_id):
|
||||||
|
"""Erhöht die gemeinsame Revision und gibt den neuen Wert zurück."""
|
||||||
|
db = get_db()
|
||||||
|
key = cls._revision_key(tenant_id)
|
||||||
|
db.execute(
|
||||||
|
'INSERT OR IGNORE INTO cache_state (key, revision) VALUES (?, 0)',
|
||||||
|
(key,)
|
||||||
|
)
|
||||||
|
db.execute(
|
||||||
|
'UPDATE cache_state SET revision = revision + 1, '
|
||||||
|
'updated_at = CURRENT_TIMESTAMP WHERE key = ?',
|
||||||
|
(key,)
|
||||||
|
)
|
||||||
|
row = db.execute(
|
||||||
|
'SELECT revision FROM cache_state WHERE key = ?', (key,)
|
||||||
|
).fetchone()
|
||||||
|
db.commit()
|
||||||
|
return int(row['revision'] or 0)
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def load_from_db(cls, tenant_id):
|
def load_from_db(cls, tenant_id):
|
||||||
"""Lädt alle Gruppen eines Mandanten aus der Datenbank in den Cache"""
|
"""Lädt alle Gruppen eines Mandanten aus der Datenbank in den Cache"""
|
||||||
|
# Revision vor dem Lesen der Daten ermitteln. Schreibt ein anderer
|
||||||
|
# Worker währenddessen, bleibt die gespeicherte Revision älter als die
|
||||||
|
# gemeinsame Revision und der Cache wird beim nächsten Zugriff erneut
|
||||||
|
# geladen. Die umgekehrte Reihenfolge könnte dagegen veraltete Daten
|
||||||
|
# dauerhaft mit einer aktuellen Revision verknüpfen.
|
||||||
|
revision = cls._current_revision(tenant_id)
|
||||||
groups = GroupModel.get_all_by_tenant(tenant_id)
|
groups = GroupModel.get_all_by_tenant(tenant_id)
|
||||||
memberships = GroupModel.get_account_ids_by_group(tenant_id)
|
memberships = GroupModel.get_account_ids_by_group(tenant_id)
|
||||||
# Vollständig neu aufbauen, damit gelöschte Gruppen nicht im Cache
|
# Vollständig neu aufbauen, damit gelöschte Gruppen nicht im Cache
|
||||||
@@ -33,32 +84,47 @@ class GroupsService:
|
|||||||
'created_at': group['created_at'],
|
'created_at': group['created_at'],
|
||||||
'updated_at': group['updated_at']
|
'updated_at': group['updated_at']
|
||||||
}
|
}
|
||||||
|
cls._cache_revision[tenant_id] = revision
|
||||||
return cls._cache[tenant_id]
|
return cls._cache[tenant_id]
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def get_all(cls, tenant_id, force_reload=False):
|
def get_all(cls, tenant_id, force_reload=False):
|
||||||
"""Gibt alle Gruppen für einen Mandanten zurück (aus Cache)"""
|
"""Gibt alle Gruppen für einen Mandanten zurück (aus Cache)"""
|
||||||
if force_reload or tenant_id not in cls._cache or not cls._cache[tenant_id]:
|
revision = cls._current_revision(tenant_id)
|
||||||
|
if (
|
||||||
|
force_reload
|
||||||
|
or tenant_id not in cls._cache
|
||||||
|
or not cls._cache[tenant_id]
|
||||||
|
or cls._cache_revision.get(tenant_id) != revision
|
||||||
|
):
|
||||||
cls.load_from_db(tenant_id)
|
cls.load_from_db(tenant_id)
|
||||||
return cls._cache.get(tenant_id, {})
|
return cls._cache.get(tenant_id, {})
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def get_by_id(cls, tenant_id, group_id):
|
def get_by_id(cls, tenant_id, group_id):
|
||||||
"""Gibt eine spezifische Gruppe aus dem Cache zurück"""
|
"""Gibt eine spezifische Gruppe aus dem Cache zurück"""
|
||||||
if tenant_id not in cls._cache or not cls._cache[tenant_id]:
|
revision = cls._current_revision(tenant_id)
|
||||||
|
if (
|
||||||
|
tenant_id not in cls._cache
|
||||||
|
or not cls._cache[tenant_id]
|
||||||
|
or cls._cache_revision.get(tenant_id) != revision
|
||||||
|
):
|
||||||
cls.load_from_db(tenant_id)
|
cls.load_from_db(tenant_id)
|
||||||
return cls._cache.get(tenant_id, {}).get(group_id)
|
return cls._cache.get(tenant_id, {}).get(group_id)
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def invalidate(cls, tenant_id):
|
def invalidate(cls, tenant_id):
|
||||||
"""Invalidiert den Cache für einen Mandanten (erzwingt Neuladen)"""
|
"""Invalidiert den Cache für einen Mandanten (erzwingt Neuladen)."""
|
||||||
if tenant_id in cls._cache:
|
if tenant_id in cls._cache:
|
||||||
cls._cache[tenant_id] = {}
|
cls._cache[tenant_id] = {}
|
||||||
|
cls._cache_revision.pop(tenant_id, None)
|
||||||
|
cls._bump_revision(tenant_id)
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def invalidate_all(cls):
|
def invalidate_all(cls):
|
||||||
"""Invalidiert den gesamten Cache"""
|
"""Invalidiert den gesamten Cache."""
|
||||||
cls._cache = {}
|
cls._cache = {}
|
||||||
|
cls._cache_revision = {}
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def is_account_linked(cls, account_id, group_id, tenant_id):
|
def is_account_linked(cls, account_id, group_id, tenant_id):
|
||||||
@@ -87,14 +153,20 @@ class GroupsService:
|
|||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def update_cache_entry(cls, tenant_id, group_id, data):
|
def update_cache_entry(cls, tenant_id, group_id, data):
|
||||||
"""Aktualisiert einen Eintrag im Cache.
|
"""Aktualisiert einen Eintrag im Cache und invalidiert andere Worker.
|
||||||
|
|
||||||
Der Cache wird vor dem Aktualisieren vollständig geladen, damit ein
|
Der Cache wird vor dem Aktualisieren vollständig geladen, damit ein
|
||||||
gezieltes Update (z. B. nach Code 200/300) keinen Teil-Cache erzeugt,
|
gezieltes Update (z. B. nach Code 200/300) keinen Teil-Cache erzeugt,
|
||||||
der anschließend beim Initialload unvollständige Gruppendaten liefert.
|
der anschließend beim Initialload unvollständige Gruppendaten liefert.
|
||||||
|
Anschließend wird die gemeinsame Revision erhöht, damit andere Worker
|
||||||
|
ihre lokalen Caches verwerfen. Der lokale Cache wird bewusst nicht auf
|
||||||
|
die neue Revision gesetzt: Beim nächsten Zugriff wird er neu geladen
|
||||||
|
und kann so keine Änderungen verpassen, die ein anderer Worker zwischen
|
||||||
|
dem Laden und dem Erhöhen der Revision geschrieben hat.
|
||||||
"""
|
"""
|
||||||
if tenant_id not in cls._cache or not cls._cache[tenant_id]:
|
cls.get_all(tenant_id)
|
||||||
cls.load_from_db(tenant_id)
|
|
||||||
if group_id not in cls._cache[tenant_id]:
|
if group_id not in cls._cache[tenant_id]:
|
||||||
cls._cache[tenant_id][group_id] = {}
|
cls._cache[tenant_id][group_id] = {}
|
||||||
cls._cache[tenant_id][group_id].update(data)
|
cls._cache[tenant_id][group_id].update(data)
|
||||||
|
cls._bump_revision(tenant_id)
|
||||||
|
cls._cache_revision.pop(tenant_id, None)
|
||||||
+223
-206
@@ -23,14 +23,17 @@ Wichtige Regeln aus der Spezifikation:
|
|||||||
Zeitfenster wieder zurück auf "unterwegs".
|
Zeitfenster wieder zurück auf "unterwegs".
|
||||||
"""
|
"""
|
||||||
import json
|
import json
|
||||||
|
import os
|
||||||
import re
|
import re
|
||||||
|
import socket
|
||||||
import time
|
import time
|
||||||
import uuid
|
import uuid
|
||||||
from datetime import datetime, timedelta, timezone
|
from datetime import datetime, timedelta, timezone
|
||||||
from threading import Lock
|
from threading import Event, Lock
|
||||||
from flask import current_app
|
from flask import current_app
|
||||||
from cmbnet.db import get_db
|
from cmbnet.db import get_db
|
||||||
from cmbnet.services.groups_service import GroupsService
|
from cmbnet.services.groups_service import GroupsService
|
||||||
|
from cmbnet.ws import store
|
||||||
from cmbnet.ws.protocol import WSMessage
|
from cmbnet.ws.protocol import WSMessage
|
||||||
|
|
||||||
|
|
||||||
@@ -43,41 +46,35 @@ class WebSocketBroker:
|
|||||||
# 'group_id': <verknüpfte Gruppe oder None>,
|
# 'group_id': <verknüpfte Gruppe oder None>,
|
||||||
# }
|
# }
|
||||||
# Eine Client-ID gehört genau zu einer Webview. Mehrere Clients
|
# Eine Client-ID gehört genau zu einer Webview. Mehrere Clients
|
||||||
# desselben Accounts besitzen daher getrennte Einträge.
|
# desselben Accounts besitzen daher getrennte Einträge. Dieses Dict
|
||||||
|
# enthält bewusst nur die Verbindungen des aktuellen Worker-Prozesses.
|
||||||
self.connections = {}
|
self.connections = {}
|
||||||
# authenticated[tenant_id][client_id] = True
|
# authenticated[tenant_id][client_id] = True
|
||||||
# Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten
|
# Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten
|
||||||
# über die Verbindung senden.
|
# über die Verbindung senden. Auch dieser Status ist prozesslokal.
|
||||||
self.authenticated = {}
|
self.authenticated = {}
|
||||||
|
|
||||||
# Nicht zustellbare Nachrichten werden pro Client gepuffert.
|
# Gemeinsamer Zustand liegt in SQLite (siehe cmbnet/ws/store.py):
|
||||||
# Schlüssel: (tenant_id, client_id).
|
# ws_clients, ws_client_queue und ws_group_presence. Dadurch finden
|
||||||
self.client_queues = {}
|
# Reconnects auf einem anderen Worker ihre Queue und Sequenznummer.
|
||||||
# client_accounts[(tenant_id, client_id)] = account_id
|
self.worker_id = os.environ.get('CMBNET_WS_WORKER_ID') or ''
|
||||||
# Bleibt auch nach einem Verbindungsabbruch erhalten, damit weitere
|
if not self.worker_id:
|
||||||
# Nachrichten für denselben Client gepuffert werden können.
|
self.worker_id = f'{socket.gethostname()}:{os.getpid()}'
|
||||||
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()
|
|
||||||
|
|
||||||
# Sequenznummern werden pro Client-ID vergeben und bleiben über einen
|
# Sequenznummern werden pro Client-ID vergeben. Der lokale Cache wird
|
||||||
# WebSocket-Reconnect derselben Webview hinweg erhalten. Dadurch kann
|
# beim Registrieren aus der Datenbank geladen; nach jedem erfolgreichen
|
||||||
# der Client nach einem Reconnect erkennen, ob ihm Frames fehlen.
|
# Versand wird die gemeinsame Zählung fortgeschrieben.
|
||||||
# client_sequences[(tenant_id, client_id)] = zuletzt zugestellte Sequenz
|
|
||||||
self.client_sequences = {}
|
self.client_sequences = {}
|
||||||
# Ein Lock pro Client-ID serialisiert Sequenzvergabe und Sendevorgang
|
# Ein Lock pro Client-ID serialisiert Sequenzvergabe und Sendevorgang
|
||||||
# auch dann, wenn die Verbindung während eines Reconnects ersetzt wird.
|
# auch dann, wenn die Verbindung während eines Reconnects ersetzt wird.
|
||||||
self.client_sequence_locks = {}
|
self.client_sequence_locks = {}
|
||||||
|
# Serialisiert das Ausliefern der gemeinsamen Queue pro Client, damit
|
||||||
# Zeitpunkt des letzten Code-2-Pongs je Gruppe (monotonic).
|
# Authentifizierung und Polling-Schleife nicht parallel dieselben
|
||||||
self.group_last_pong = {}
|
# Aufträge versenden.
|
||||||
self.group_online_since = {}
|
self.client_delivery_locks = {}
|
||||||
|
# Weckt die lokale Polling-Schleife nach einer neu eingestellten
|
||||||
|
# Nachricht. Workerübergreifend übernimmt das reguläre Polling.
|
||||||
|
self.delivery_wakeup = Event()
|
||||||
|
|
||||||
# ------------------------------------------------------------------
|
# ------------------------------------------------------------------
|
||||||
# Verbindungen und Authentifizierung
|
# Verbindungen und Authentifizierung
|
||||||
@@ -102,10 +99,15 @@ class WebSocketBroker:
|
|||||||
|
|
||||||
# Eine Client-ID ist an den Account gebunden, der sie im Handshake
|
# Eine Client-ID ist an den Account gebunden, der sie im Handshake
|
||||||
# verwendet hat. Ein Wechsel des Accounts unter derselben ID wäre ein
|
# verwendet hat. Ein Wechsel des Accounts unter derselben ID wäre ein
|
||||||
# Hinweis auf eine falsche bzw. manipulierte Zuordnung.
|
# Hinweis auf eine falsche bzw. manipulierte Zuordnung. Die Zuordnung
|
||||||
existing_account = self.client_accounts.get((tenant_id, client_id))
|
# liegt prozessübergreifend in ws_clients.
|
||||||
|
existing_account = store.get_client_account(tenant_id, client_id)
|
||||||
if existing_account is not None and existing_account != account_id:
|
if existing_account is not None and existing_account != account_id:
|
||||||
return False
|
return False
|
||||||
|
if not store.ensure_client(
|
||||||
|
tenant_id, client_id, account_id, worker_id=self.worker_id
|
||||||
|
):
|
||||||
|
return False
|
||||||
|
|
||||||
if role is None:
|
if role is None:
|
||||||
role = account['role']
|
role = account['role']
|
||||||
@@ -123,6 +125,7 @@ class WebSocketBroker:
|
|||||||
group_id = group['id'] if group else None
|
group_id = group['id'] if group else None
|
||||||
|
|
||||||
connections = self.connections.setdefault(tenant_id, {})
|
connections = self.connections.setdefault(tenant_id, {})
|
||||||
|
key = (tenant_id, client_id)
|
||||||
|
|
||||||
# Eine neue Verbindung mit derselben Client-ID ersetzt eine eventuell
|
# Eine neue Verbindung mit derselben Client-ID ersetzt eine eventuell
|
||||||
# noch registrierte alte Verbindung (z. B. nach einem schnellen
|
# noch registrierte alte Verbindung (z. B. nach einem schnellen
|
||||||
@@ -148,9 +151,9 @@ class WebSocketBroker:
|
|||||||
'connected_at': time.monotonic(),
|
'connected_at': time.monotonic(),
|
||||||
'last_pong_at': None,
|
'last_pong_at': None,
|
||||||
# Zuletzt an diese Client-ID zugestellte Sequenznummer. Die
|
# Zuletzt an diese Client-ID zugestellte Sequenznummer. Die
|
||||||
# maßgebliche Zählung liegt in self.client_sequences, damit sie
|
# maßgebliche Zählung liegt in ws_clients und überlebt damit einen
|
||||||
# einen Reconnect überlebt.
|
# Worker-Wechsel.
|
||||||
'seq': self.client_sequences.get((tenant_id, client_id), 0),
|
'seq': store.get_last_seq(tenant_id, client_id),
|
||||||
# Ob diese Client-ID bereits vor diesem Handshake bekannt war.
|
# Ob diese Client-ID bereits vor diesem Handshake bekannt war.
|
||||||
# Nur dann bleibt ihre Queue auch bei einem fehlgeschlagenen
|
# Nur dann bleibt ihre Queue auch bei einem fehlgeschlagenen
|
||||||
# erneuten Handshake erhalten.
|
# erneuten Handshake erhalten.
|
||||||
@@ -163,9 +166,8 @@ class WebSocketBroker:
|
|||||||
'send_lock': Lock()
|
'send_lock': Lock()
|
||||||
}
|
}
|
||||||
|
|
||||||
self.client_accounts[(tenant_id, client_id)] = account_id
|
self.client_sequences[key] = store.get_last_seq(tenant_id, client_id)
|
||||||
self.account_clients.setdefault((tenant_id, account_id), set()).add(client_id)
|
self.client_delivery_locks.setdefault(key, Lock())
|
||||||
self.disconnected_clients.pop((tenant_id, client_id), None)
|
|
||||||
return True
|
return True
|
||||||
|
|
||||||
def send_to_connection(self, tenant_id, client_id, data):
|
def send_to_connection(self, tenant_id, client_id, data):
|
||||||
@@ -191,7 +193,7 @@ class WebSocketBroker:
|
|||||||
|
|
||||||
last_seq = self.client_sequences.get(key)
|
last_seq = self.client_sequences.get(key)
|
||||||
if last_seq is None:
|
if last_seq is None:
|
||||||
last_seq = int(conn.get('seq') or 0)
|
last_seq = store.get_last_seq(tenant_id, client_id)
|
||||||
next_seq = last_seq + 1
|
next_seq = last_seq + 1
|
||||||
payload['seq'] = next_seq
|
payload['seq'] = next_seq
|
||||||
framed = json.dumps(payload, ensure_ascii=False)
|
framed = json.dumps(payload, ensure_ascii=False)
|
||||||
@@ -205,6 +207,12 @@ class WebSocketBroker:
|
|||||||
|
|
||||||
self.client_sequences[key] = next_seq
|
self.client_sequences[key] = next_seq
|
||||||
conn['seq'] = next_seq
|
conn['seq'] = next_seq
|
||||||
|
# Die Sequenz wird erst nach erfolgreichem Senden persistiert,
|
||||||
|
# damit ein fehlgeschlagener Versand keine Lücke erzeugt.
|
||||||
|
store.set_last_seq(
|
||||||
|
tenant_id, client_id, next_seq,
|
||||||
|
account_id=conn.get('account_id')
|
||||||
|
)
|
||||||
return True
|
return True
|
||||||
except Exception:
|
except Exception:
|
||||||
# Eine fehlerhafte Verbindung darf den Versand an andere Clients
|
# Eine fehlerhafte Verbindung darf den Versand an andere Clients
|
||||||
@@ -216,6 +224,10 @@ class WebSocketBroker:
|
|||||||
"""Prüft, ob ein Client den Code-0-Handshake erfolgreich absolviert hat."""
|
"""Prüft, ob ein Client den Code-0-Handshake erfolgreich absolviert hat."""
|
||||||
return self.authenticated.get(tenant_id, {}).get(client_id, False)
|
return self.authenticated.get(tenant_id, {}).get(client_id, False)
|
||||||
|
|
||||||
|
def describe_connections(self, tenant_id):
|
||||||
|
"""Liefert alle verbundenen Clients des Mandanten aus der gemeinsamen DB."""
|
||||||
|
return store.describe_connections(tenant_id)
|
||||||
|
|
||||||
def authenticate(self, tenant_id, account_id, client_id, token):
|
def authenticate(self, tenant_id, account_id, client_id, token):
|
||||||
"""Authentifiziert eine Client-Verbindung anhand des Einmal-Tokens (Code 0).
|
"""Authentifiziert eine Client-Verbindung anhand des Einmal-Tokens (Code 0).
|
||||||
|
|
||||||
@@ -257,13 +269,15 @@ class WebSocketBroker:
|
|||||||
if conn.get('role') == 'Gruppe' and conn.get('group_id'):
|
if conn.get('role') == 'Gruppe' and conn.get('group_id'):
|
||||||
# Ein frisch verbundener Gruppen-Client erhält eine
|
# Ein frisch verbundener Gruppen-Client erhält eine
|
||||||
# Zwei-Minuten-Kulanz, bis der erste Code-2-Pong eintrifft.
|
# Zwei-Minuten-Kulanz, bis der erste Code-2-Pong eintrifft.
|
||||||
key = (tenant_id, conn['group_id'])
|
store.set_group_online_since(tenant_id, conn['group_id'])
|
||||||
self.group_online_since[key] = time.monotonic()
|
|
||||||
|
|
||||||
self.authenticated.setdefault(tenant_id, {})[client_id] = True
|
self.authenticated.setdefault(tenant_id, {})[client_id] = True
|
||||||
self.client_accounts[(tenant_id, client_id)] = account_id
|
store.mark_authenticated(
|
||||||
self.account_clients.setdefault((tenant_id, account_id), set()).add(client_id)
|
tenant_id, client_id, True, worker_id=self.worker_id
|
||||||
self.disconnected_clients.pop((tenant_id, client_id), None)
|
)
|
||||||
|
self.client_sequences[(tenant_id, client_id)] = store.get_last_seq(
|
||||||
|
tenant_id, client_id
|
||||||
|
)
|
||||||
|
|
||||||
# Zuerst die für diesen Client gepufferten Nachrichten ausliefern.
|
# Zuerst die für diesen Client gepufferten Nachrichten ausliefern.
|
||||||
# Wurde die Queue wegen Überschreitung der Maximalzeit verworfen, wird
|
# Wurde die Queue wegen Überschreitung der Maximalzeit verworfen, wird
|
||||||
@@ -313,23 +327,26 @@ class WebSocketBroker:
|
|||||||
if not authenticated:
|
if not authenticated:
|
||||||
self.authenticated.pop(tenant_id, None)
|
self.authenticated.pop(tenant_id, None)
|
||||||
|
|
||||||
|
key = (tenant_id, client_id)
|
||||||
|
self.client_sequences.pop(key, None)
|
||||||
|
self.client_sequence_locks.pop(key, None)
|
||||||
|
|
||||||
if not was_authenticated and not was_known_client:
|
if not was_authenticated and not was_known_client:
|
||||||
# Ein nie erfolgreich authentifizierter neuer Client hinterlässt
|
# Ein nie erfolgreich authentifizierter neuer Client hinterlässt
|
||||||
# keine Zuordnung, Queue oder Empfängerregistrierung.
|
# keine Zuordnung, Queue oder Empfängerregistrierung.
|
||||||
account_id = self.client_accounts.pop((tenant_id, client_id), None)
|
store.delete_client(
|
||||||
self.client_queues.pop((tenant_id, client_id), None)
|
tenant_id, client_id, worker_id=self.worker_id
|
||||||
self.disconnected_clients.pop((tenant_id, client_id), None)
|
)
|
||||||
self.client_sequences.pop((tenant_id, client_id), None)
|
self.client_delivery_locks.pop(key, None)
|
||||||
self.client_sequence_locks.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
|
return
|
||||||
|
|
||||||
self.disconnected_clients[(tenant_id, client_id)] = time.monotonic()
|
# Die Client-ID bleibt samt Queue bekannt. Ein Reconnect kann auf
|
||||||
|
# einem beliebigen Worker landen und findet den Zustand dort wieder.
|
||||||
|
# Das Delivery-Lock bleibt bestehen, damit eine laufende Zustellung
|
||||||
|
# nicht mit einer neuen Verbindung derselben Client-ID kollidiert.
|
||||||
|
store.mark_disconnected(
|
||||||
|
tenant_id, client_id, worker_id=self.worker_id
|
||||||
|
)
|
||||||
|
|
||||||
def _get_connection(self, tenant_id, client_id):
|
def _get_connection(self, tenant_id, client_id):
|
||||||
return self.connections.get(tenant_id, {}).get(client_id)
|
return self.connections.get(tenant_id, {}).get(client_id)
|
||||||
@@ -369,7 +386,8 @@ class WebSocketBroker:
|
|||||||
|
|
||||||
recipient_rows = []
|
recipient_rows = []
|
||||||
for recipient_id in sorted(set(recipients or [])):
|
for recipient_id in sorted(set(recipients or [])):
|
||||||
account_id = self.client_accounts.get((tenant_id, recipient_id))
|
client_row = store.get_client(tenant_id, recipient_id)
|
||||||
|
account_id = client_row['account_id'] if client_row else None
|
||||||
account = None
|
account = None
|
||||||
if account_id is not None:
|
if account_id is not None:
|
||||||
account = db.execute(
|
account = db.execute(
|
||||||
@@ -388,8 +406,12 @@ class WebSocketBroker:
|
|||||||
|
|
||||||
info = self._get_sender_info(tenant_id, account)
|
info = self._get_sender_info(tenant_id, account)
|
||||||
info['client_id'] = recipient_id
|
info['client_id'] = recipient_id
|
||||||
info['connected'] = bool(self._get_connection(tenant_id, recipient_id))
|
info['connected'] = bool(
|
||||||
info['authenticated'] = self.is_authenticated(tenant_id, recipient_id)
|
client_row and client_row['disconnected_at'] is None
|
||||||
|
)
|
||||||
|
info['authenticated'] = bool(
|
||||||
|
client_row and client_row['authenticated']
|
||||||
|
)
|
||||||
recipient_rows.append(info)
|
recipient_rows.append(info)
|
||||||
|
|
||||||
payload = message.msg
|
payload = message.msg
|
||||||
@@ -454,95 +476,62 @@ class WebSocketBroker:
|
|||||||
minutes = 60
|
minutes = 60
|
||||||
return max(self._client_queue_max_age_seconds(), minutes * 60)
|
return max(self._client_queue_max_age_seconds(), minutes * 60)
|
||||||
|
|
||||||
def _ensure_client_queue(self, tenant_id, client_id, now=None):
|
def _ephemeral_ttl_seconds(self):
|
||||||
"""Liefert die Queue eines Clients und legt sie bei Bedarf an."""
|
try:
|
||||||
key = (tenant_id, client_id)
|
return max(1.0, float(current_app.config.get(
|
||||||
queue = self.client_queues.get(key)
|
'WS_EPHEMERAL_TTL_SECONDS', 30
|
||||||
if queue is None:
|
)))
|
||||||
queue = {
|
except (TypeError, ValueError):
|
||||||
'messages': [],
|
return 30.0
|
||||||
'created_at': now if now is not None else time.monotonic(),
|
|
||||||
'expired': False,
|
|
||||||
'code99_only': False,
|
|
||||||
'code99_message': None,
|
|
||||||
'account_id': self.client_accounts.get(key),
|
|
||||||
}
|
|
||||||
self.client_queues[key] = queue
|
|
||||||
return queue
|
|
||||||
|
|
||||||
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._client_queue_max_age_seconds():
|
|
||||||
return
|
|
||||||
|
|
||||||
queue['messages'].clear()
|
|
||||||
queue['expired'] = True
|
|
||||||
|
|
||||||
def _queue_undeliverable(self, tenant_id, client_id, message):
|
def _queue_undeliverable(self, tenant_id, client_id, message):
|
||||||
"""Puffert eine nicht zustellbare Nachricht für einen Client."""
|
"""Puffert eine nicht zustellbare Nachricht für einen Client.
|
||||||
if message.code < 100 and message.code != 99:
|
|
||||||
return
|
|
||||||
|
|
||||||
if (tenant_id, client_id) not in self.client_accounts:
|
Bei Code 2 handelt es sich um ein kurzlebiges Lebenszeichen. Es wird
|
||||||
return
|
nur für aktuell verbundene Clients gepuffert, damit ein späterer
|
||||||
|
Reconnect kein veraltetes Pong erhält.
|
||||||
|
"""
|
||||||
|
if message.code == 2:
|
||||||
|
if not store.client_is_connected(tenant_id, client_id):
|
||||||
|
return False
|
||||||
|
elif message.code < 100 and message.code != 99:
|
||||||
|
return False
|
||||||
|
|
||||||
with self.queue_lock:
|
if not store.client_exists(tenant_id, client_id):
|
||||||
queue = self._ensure_client_queue(tenant_id, client_id)
|
return False
|
||||||
now = time.monotonic()
|
|
||||||
|
|
||||||
if message.code == 99:
|
queued = store.enqueue_message(
|
||||||
# Eine nicht zustellbare Reload-Aufforderung verdrängt alle
|
tenant_id,
|
||||||
# älteren Nachrichten. Danach wird nichts weiter gepuffert.
|
client_id,
|
||||||
queue['messages'].clear()
|
message.code,
|
||||||
queue['code99_only'] = True
|
message.to_json(),
|
||||||
queue['code99_message'] = message.to_json()
|
self._client_queue_max_age_seconds(),
|
||||||
queue['expired'] = False
|
timeout_payload=self._client_queue_timeout_message(),
|
||||||
return
|
ephemeral_seconds=(
|
||||||
|
self._ephemeral_ttl_seconds() if message.code == 2 else None
|
||||||
self._expire_client_queue(queue, now)
|
)
|
||||||
if queue.get('expired') or queue.get('code99_only'):
|
)
|
||||||
return
|
if queued:
|
||||||
|
self.delivery_wakeup.set()
|
||||||
queue['messages'].append(message.to_json())
|
return queued
|
||||||
|
|
||||||
def cleanup_client_queues(self):
|
def cleanup_client_queues(self):
|
||||||
"""Räumt abgelaufene Client-Queues und verwaiste Webviews auf."""
|
"""Räumt abgelaufene Queues und verwaiste Clients in der DB auf."""
|
||||||
now = time.monotonic()
|
store.purge_expired_queue_rows()
|
||||||
retention = self._client_retention_seconds()
|
store.expire_queues(
|
||||||
with self.queue_lock:
|
self._client_queue_max_age_seconds(),
|
||||||
for queue in self.client_queues.values():
|
self._client_queue_timeout_message()
|
||||||
self._expire_client_queue(queue, now)
|
)
|
||||||
|
store.cleanup_clients(self._client_retention_seconds())
|
||||||
|
|
||||||
for key, disconnected_at in list(self.disconnected_clients.items()):
|
# Lokale Caches für inzwischen entfernte Clients bereinigen.
|
||||||
tenant_id, client_id = key
|
for key in list(self.client_sequences):
|
||||||
if self._get_connection(tenant_id, client_id):
|
if not store.client_exists(*key):
|
||||||
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)
|
|
||||||
self.client_sequences.pop(key, None)
|
self.client_sequences.pop(key, None)
|
||||||
self.client_sequence_locks.pop(key, None)
|
self.client_sequence_locks.pop(key, None)
|
||||||
if account_id is not None:
|
for key in list(self.client_delivery_locks):
|
||||||
clients = self.account_clients.get((tenant_id, account_id))
|
if not store.client_exists(*key):
|
||||||
if clients is not None:
|
self.client_delivery_locks.pop(key, None)
|
||||||
clients.discard(client_id)
|
|
||||||
if not clients:
|
|
||||||
self.account_clients.pop((tenant_id, account_id), None)
|
|
||||||
|
|
||||||
def _client_queue_timeout_message(self):
|
def _client_queue_timeout_message(self):
|
||||||
minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15)
|
minutes = current_app.config.get('WS_QUEUE_MAX_AGE_MINUTES', 15)
|
||||||
@@ -556,8 +545,13 @@ class WebSocketBroker:
|
|||||||
)
|
)
|
||||||
).to_json()
|
).to_json()
|
||||||
|
|
||||||
|
def _client_delivery_lock(self, tenant_id, client_id):
|
||||||
|
return self.client_delivery_locks.setdefault(
|
||||||
|
(tenant_id, client_id), Lock()
|
||||||
|
)
|
||||||
|
|
||||||
def restore_client_queue(self, tenant_id, client_id):
|
def restore_client_queue(self, tenant_id, client_id):
|
||||||
"""Liefert gepufferte Nachrichten eines wiedererkannten Clients aus.
|
"""Liefert persistierte Nachrichten eines wiedererkannten Clients aus.
|
||||||
|
|
||||||
Rückgabe: (Menge der Roh-Nachrichten aus der Queue, Late-Entry-Sperre).
|
Rückgabe: (Menge der Roh-Nachrichten aus der Queue, Late-Entry-Sperre).
|
||||||
Die Menge dient dazu, dieselben Nachrichten nicht zusätzlich als
|
Die Menge dient dazu, dieselben Nachrichten nicht zusätzlich als
|
||||||
@@ -565,57 +559,66 @@ class WebSocketBroker:
|
|||||||
war oder nur noch eine Code-99-Nachricht enthielt. In diesem Fall darf
|
war oder nur noch eine Code-99-Nachricht enthielt. In diesem Fall darf
|
||||||
keine zusätzliche Late-Entry-Historie mehr gesendet werden.
|
keine zusätzliche Late-Entry-Historie mehr gesendet werden.
|
||||||
"""
|
"""
|
||||||
key = (tenant_id, client_id)
|
with self._client_delivery_lock(tenant_id, client_id):
|
||||||
now = time.monotonic()
|
rows = store.fetch_queue(tenant_id, client_id)
|
||||||
|
if not rows:
|
||||||
with self.queue_lock:
|
|
||||||
queue = self.client_queues.get(key)
|
|
||||||
if not queue:
|
|
||||||
return set(), False
|
return set(), False
|
||||||
self._expire_client_queue(queue, now)
|
|
||||||
|
|
||||||
if queue.get('code99_only'):
|
started_at = store.get_queue_started_at(tenant_id, client_id)
|
||||||
raw_message = queue.get('code99_message') or self._client_queue_timeout_message()
|
max_age = self._client_queue_max_age_seconds()
|
||||||
self.client_queues.pop(key, None)
|
if started_at is not None and store.now() - started_at >= max_age:
|
||||||
send_only = True
|
store.replace_queue_with_timeout(
|
||||||
messages = []
|
tenant_id, client_id, self._client_queue_timeout_message()
|
||||||
elif queue.get('expired'):
|
)
|
||||||
raw_message = self._client_queue_timeout_message()
|
rows = store.fetch_queue(tenant_id, client_id)
|
||||||
self.client_queues.pop(key, None)
|
suppress_late_entries = True
|
||||||
send_only = True
|
|
||||||
messages = []
|
|
||||||
else:
|
else:
|
||||||
raw_message = None
|
suppress_late_entries = any(
|
||||||
send_only = False
|
row['code99_only'] for row in rows
|
||||||
messages = list(queue.get('messages', []))
|
)
|
||||||
queue['messages'] = []
|
|
||||||
|
|
||||||
if send_only:
|
raw_messages = set()
|
||||||
if raw_message and not self.send_to_connection(tenant_id, client_id, raw_message):
|
for row in rows:
|
||||||
# Verbindung ist bereits wieder weg: Queue für den nächsten
|
raw_message = row['payload']
|
||||||
# Versuch erhalten.
|
|
||||||
with self.queue_lock:
|
|
||||||
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, client_id, raw_message):
|
if not self.send_to_connection(tenant_id, client_id, raw_message):
|
||||||
unsent = messages[index:]
|
# Verbindung ist bereits wieder weg. Noch nicht
|
||||||
|
# zugestellte Aufträge bleiben in der Queue.
|
||||||
break
|
break
|
||||||
|
if not row['code99_only']:
|
||||||
|
raw_messages.add(raw_message)
|
||||||
|
store.delete_queue_row(row['id'])
|
||||||
|
|
||||||
with self.queue_lock:
|
return raw_messages, suppress_late_entries
|
||||||
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.client_queues.pop(key, None)
|
|
||||||
|
|
||||||
# Auch nicht zugestellte Queue-Nachrichten von den Late Entries
|
def drain_client_queue(self, tenant_id, client_id):
|
||||||
# ausnehmen. Sie bleiben in der Queue und werden beim nächsten
|
"""Stellt die gemeinsame Queue eines lokal verbundenen Clients zu."""
|
||||||
# Reconnect erneut versucht, statt doppelt gepuffert zu werden.
|
self.restore_client_queue(tenant_id, client_id)
|
||||||
return set(messages), False
|
|
||||||
|
def drain_local_clients(self):
|
||||||
|
"""Zustellrunde für alle lokal verbundenen, authentifizierten Clients."""
|
||||||
|
local_clients = set()
|
||||||
|
for tenant_id, connections in list(self.connections.items()):
|
||||||
|
for client_id in list(connections):
|
||||||
|
if self.is_authenticated(tenant_id, client_id):
|
||||||
|
local_clients.add((tenant_id, client_id))
|
||||||
|
|
||||||
|
if not local_clients:
|
||||||
|
return
|
||||||
|
|
||||||
|
# Nur Clients mit tatsächlich wartenden Aufträgen öffnen eine
|
||||||
|
# Transaktion. Das hält die Polling-Schleife bei vielen verbundenen
|
||||||
|
# Clients günstig.
|
||||||
|
for tenant_id, client_id in store.clients_with_queue(local_clients):
|
||||||
|
try:
|
||||||
|
self.drain_client_queue(tenant_id, client_id)
|
||||||
|
except Exception as exc:
|
||||||
|
try:
|
||||||
|
current_app.logger.warning(
|
||||||
|
'WS-Queue-Zustellung fehlgeschlagen: tenant=%s client=%s error=%s',
|
||||||
|
tenant_id, client_id, exc
|
||||||
|
)
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
|
||||||
# ------------------------------------------------------------------
|
# ------------------------------------------------------------------
|
||||||
# Late Entry
|
# Late Entry
|
||||||
@@ -881,7 +884,7 @@ class WebSocketBroker:
|
|||||||
"""Wertet ein Code-2-Lebenszeichen eines Clients aus."""
|
"""Wertet ein Code-2-Lebenszeichen eines Clients aus."""
|
||||||
conn = self._get_connection(tenant_id, client_id) if client_id else None
|
conn = self._get_connection(tenant_id, client_id) if client_id else None
|
||||||
if conn and conn.get('account_id') == account_id:
|
if conn and conn.get('account_id') == account_id:
|
||||||
conn['last_pong_at'] = time.monotonic()
|
conn['last_pong_at'] = time.time()
|
||||||
|
|
||||||
if not sender or sender['role'] != 'Gruppe':
|
if not sender or sender['role'] != 'Gruppe':
|
||||||
return
|
return
|
||||||
@@ -897,9 +900,8 @@ class WebSocketBroker:
|
|||||||
if not group:
|
if not group:
|
||||||
return
|
return
|
||||||
|
|
||||||
now = time.monotonic()
|
|
||||||
group_id = group['id']
|
group_id = group['id']
|
||||||
self.group_last_pong[(tenant_id, group_id)] = now
|
store.record_group_pong(tenant_id, group_id)
|
||||||
|
|
||||||
if group['state'] == 'unterwegs':
|
if group['state'] == 'unterwegs':
|
||||||
self._set_group_state_internal(
|
self._set_group_state_internal(
|
||||||
@@ -917,11 +919,16 @@ class WebSocketBroker:
|
|||||||
return False
|
return False
|
||||||
|
|
||||||
old_state = group['state']
|
old_state = group['state']
|
||||||
db.execute(
|
# Der Vergleich im UPDATE verhindert, dass zwei Worker denselben
|
||||||
|
# automatischen Statuswechsel gleichzeitig in die Historie schreiben.
|
||||||
|
cursor = db.execute(
|
||||||
'UPDATE groups SET state = ?, updated_at = CURRENT_TIMESTAMP '
|
'UPDATE groups SET state = ?, updated_at = CURRENT_TIMESTAMP '
|
||||||
'WHERE id = ? AND tenant_id = ?',
|
'WHERE id = ? AND tenant_id = ? AND state = ?',
|
||||||
(new_state, group_id, tenant_id)
|
(new_state, group_id, tenant_id, old_state)
|
||||||
)
|
)
|
||||||
|
if cursor.rowcount == 0:
|
||||||
|
db.rollback()
|
||||||
|
return False
|
||||||
db.execute(
|
db.execute(
|
||||||
'''INSERT INTO group_state_history
|
'''INSERT INTO group_state_history
|
||||||
(tenant_id, group_id, from_state, to_state, last_lat, last_lon,
|
(tenant_id, group_id, from_state, to_state, last_lat, last_lon,
|
||||||
@@ -937,7 +944,7 @@ class WebSocketBroker:
|
|||||||
)
|
)
|
||||||
|
|
||||||
if new_state == 'online':
|
if new_state == 'online':
|
||||||
self.group_online_since[(tenant_id, group_id)] = time.monotonic()
|
store.set_group_online_since(tenant_id, group_id)
|
||||||
|
|
||||||
message = WSMessage(
|
message = WSMessage(
|
||||||
sender_id=actor_account_id or 0,
|
sender_id=actor_account_id or 0,
|
||||||
@@ -972,20 +979,24 @@ class WebSocketBroker:
|
|||||||
except (TypeError, ValueError):
|
except (TypeError, ValueError):
|
||||||
timeout = 120.0
|
timeout = 120.0
|
||||||
|
|
||||||
now = time.monotonic()
|
current = store.now()
|
||||||
for row in rows:
|
for row in rows:
|
||||||
key = (row['tenant_id'], row['id'])
|
presence = store.get_group_presence(row['tenant_id'], row['id'])
|
||||||
reference = self.group_last_pong.get(key)
|
last_pong = presence['last_pong_at'] if presence else None
|
||||||
online_since = self.group_online_since.get(key)
|
online_since = presence['online_since'] if presence else None
|
||||||
|
reference = last_pong
|
||||||
if online_since is not None:
|
if online_since is not None:
|
||||||
reference = max(reference, online_since) if reference else online_since
|
reference = (
|
||||||
|
max(reference, online_since)
|
||||||
|
if reference is not None else online_since
|
||||||
|
)
|
||||||
if reference is None:
|
if reference is None:
|
||||||
# Zustand war bereits vor dem Start des Trackings "online".
|
# Zustand war bereits vor dem Start des Trackings "online".
|
||||||
# Ab jetzt läuft die Kulanzfrist.
|
# Ab jetzt läuft die Kulanzfrist.
|
||||||
self.group_online_since[key] = now
|
store.set_group_online_since(row['tenant_id'], row['id'], current)
|
||||||
continue
|
continue
|
||||||
|
|
||||||
if now - reference > timeout:
|
if current - reference > timeout:
|
||||||
self._set_group_state_internal(
|
self._set_group_state_internal(
|
||||||
row['tenant_id'], row['id'], 'unterwegs'
|
row['tenant_id'], row['id'], 'unterwegs'
|
||||||
)
|
)
|
||||||
@@ -1158,7 +1169,7 @@ class WebSocketBroker:
|
|||||||
db.commit()
|
db.commit()
|
||||||
GroupsService.update_cache_entry(tenant_id, group_id, {'state': new_state})
|
GroupsService.update_cache_entry(tenant_id, group_id, {'state': new_state})
|
||||||
if new_state == 'online':
|
if new_state == 'online':
|
||||||
self.group_online_since[(tenant_id, group_id)] = time.monotonic()
|
store.set_group_online_since(tenant_id, group_id)
|
||||||
self._log_business(tenant_id, sender['id'], 'group.state_change', 'group',
|
self._log_business(tenant_id, sender['id'], 'group.state_change', 'group',
|
||||||
group_id, {'from': group['state'], 'to': new_state})
|
group_id, {'from': group['state'], 'to': new_state})
|
||||||
|
|
||||||
@@ -1402,20 +1413,27 @@ class WebSocketBroker:
|
|||||||
return message
|
return message
|
||||||
|
|
||||||
def _deliver(self, tenant_id, message, sender):
|
def _deliver(self, tenant_id, message, sender):
|
||||||
"""Stellt eine Nachricht an alle berechtigten Clients zu."""
|
"""Stellt eine Nachricht an alle berechtigten Clients zu.
|
||||||
|
|
||||||
|
Lokal verbundene Clients erhalten den Frame direkt. Für alle anderen
|
||||||
|
Clients wird ein persistenter Auftrag in der gemeinsamen Queue
|
||||||
|
angelegt. Jeder Worker pollt diese Queue für seine eigenen Clients.
|
||||||
|
"""
|
||||||
recipients = sorted(self._get_recipients(tenant_id, message, sender))
|
recipients = sorted(self._get_recipients(tenant_id, message, sender))
|
||||||
self.log_incoming(tenant_id, message, sender, recipients=recipients)
|
self.log_incoming(tenant_id, message, sender, recipients=recipients)
|
||||||
for client_id in recipients:
|
for client_id in recipients:
|
||||||
self._send(tenant_id, client_id, message)
|
self._send(tenant_id, client_id, message)
|
||||||
|
self.delivery_wakeup.set()
|
||||||
|
|
||||||
def _send(self, tenant_id, client_id, message):
|
def _send(self, tenant_id, client_id, message):
|
||||||
"""Sendet eine Nachricht an einen Client oder puffert sie für ihn."""
|
"""Sendet eine Nachricht an einen Client oder puffert sie für ihn."""
|
||||||
# Erst nach erfolgreicher Token-Authentifizierung dürfen Nachrichten
|
conn = self._get_connection(tenant_id, client_id)
|
||||||
# an einen Client zugestellt werden.
|
authenticated = self.is_authenticated(tenant_id, client_id)
|
||||||
if not self.is_authenticated(tenant_id, client_id):
|
|
||||||
self._queue_undeliverable(tenant_id, client_id, message)
|
|
||||||
return False
|
|
||||||
|
|
||||||
|
# Ein lokal verbundener Client ohne wartende Queue wird direkt
|
||||||
|
# bedient. Existiert bereits eine Queue, wird auch diese Nachricht
|
||||||
|
# eingereiht, damit die Reihenfolge erhalten bleibt.
|
||||||
|
if conn and authenticated and not store.client_has_queue(tenant_id, client_id):
|
||||||
if self.send_to_connection(tenant_id, client_id, message.to_json()):
|
if self.send_to_connection(tenant_id, client_id, message.to_json()):
|
||||||
return True
|
return True
|
||||||
|
|
||||||
@@ -1423,13 +1441,12 @@ class WebSocketBroker:
|
|||||||
return False
|
return False
|
||||||
|
|
||||||
def _client_ids_for_accounts(self, tenant_id, account_ids):
|
def _client_ids_for_accounts(self, tenant_id, account_ids):
|
||||||
"""Expandiert Empfänger-Accounts auf alle bekannten Client-IDs."""
|
"""Expandiert Empfänger-Accounts auf alle bekannten Client-IDs.
|
||||||
client_ids = set()
|
|
||||||
for account_id in account_ids:
|
Die Zuordnung liegt in ws_clients und umfasst damit auch Clients, die
|
||||||
client_ids.update(
|
an anderen Workern verbunden oder momentan getrennt sind.
|
||||||
self.account_clients.get((tenant_id, account_id), ())
|
"""
|
||||||
)
|
return store.client_ids_for_accounts(tenant_id, account_ids)
|
||||||
return client_ids
|
|
||||||
|
|
||||||
def _get_recipients(self, tenant_id, message, sender):
|
def _get_recipients(self, tenant_id, message, sender):
|
||||||
"""Bestimmt den Empfängerkreis abhängig vom Nachrichtencode.
|
"""Bestimmt den Empfängerkreis abhängig vom Nachrichtencode.
|
||||||
|
|||||||
@@ -0,0 +1,75 @@
|
|||||||
|
"""Worker-lokale Zustellschleife für die gemeinsame WebSocket-Queue.
|
||||||
|
|
||||||
|
Jeder WSGI-Worker besitzt eigene WebSocket-Objekte. Die persistente Queue in
|
||||||
|
``ws_client_queue`` ist dagegen gemeinsam. Diese Schleife prüft regelmäßig, ob
|
||||||
|
für die lokal verbundenen Clients Aufträge eingegangen sind, und stellt sie
|
||||||
|
über den lokalen Broker zu.
|
||||||
|
"""
|
||||||
|
import threading
|
||||||
|
|
||||||
|
from cmbnet.ws import broker
|
||||||
|
|
||||||
|
|
||||||
|
class DeliveryWorker:
|
||||||
|
def __init__(self, interval=0.5):
|
||||||
|
self.interval = interval
|
||||||
|
self.app = None
|
||||||
|
self.running = False
|
||||||
|
self._thread = None
|
||||||
|
self._stop = threading.Event()
|
||||||
|
|
||||||
|
def start(self, app=None, interval=None):
|
||||||
|
if app is not None:
|
||||||
|
self.app = app
|
||||||
|
if interval is not None:
|
||||||
|
self.interval = interval
|
||||||
|
if self.running:
|
||||||
|
return
|
||||||
|
if self.app is None:
|
||||||
|
return
|
||||||
|
|
||||||
|
self.running = True
|
||||||
|
self._stop.clear()
|
||||||
|
self._thread = threading.Thread(
|
||||||
|
target=self._run,
|
||||||
|
name='cmbnet-ws-delivery',
|
||||||
|
daemon=True
|
||||||
|
)
|
||||||
|
self._thread.start()
|
||||||
|
|
||||||
|
def stop(self):
|
||||||
|
self.running = False
|
||||||
|
self._stop.set()
|
||||||
|
broker.delivery_wakeup.set()
|
||||||
|
# Der Thread ist ein Daemon. Ein Join mit Timeout verhindert, dass
|
||||||
|
# ein laufender Datenbankzugriff den Shutdown blockiert.
|
||||||
|
if self._thread is not None:
|
||||||
|
self._thread.join(timeout=2.0)
|
||||||
|
self._thread = None
|
||||||
|
|
||||||
|
def wake(self):
|
||||||
|
broker.delivery_wakeup.set()
|
||||||
|
|
||||||
|
def _run(self):
|
||||||
|
# Ein App-Kontext für die gesamte Lebensdauer der Schleife hält die
|
||||||
|
# SQLite-Verbindung dieses Threads offen. Bei einem Polling-Intervall
|
||||||
|
# von 0,5 s wäre ein Verbindungsaufbau pro Runde unnötig teuer.
|
||||||
|
with self.app.app_context():
|
||||||
|
while not self._stop.is_set() and self.running:
|
||||||
|
try:
|
||||||
|
broker.drain_local_clients()
|
||||||
|
except Exception as exc:
|
||||||
|
try:
|
||||||
|
self.app.logger.warning(
|
||||||
|
'WS-Zustellschleife fehlgeschlagen: %s', exc
|
||||||
|
)
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
|
||||||
|
# Neue lokale Nachrichten wecken die Schleife sofort. Für
|
||||||
|
# Nachrichten aus anderen Workern greift der reguläre Timeout.
|
||||||
|
broker.delivery_wakeup.wait(self.interval)
|
||||||
|
broker.delivery_wakeup.clear()
|
||||||
|
|
||||||
|
|
||||||
|
delivery_worker = DeliveryWorker()
|
||||||
@@ -69,17 +69,24 @@ class HeartbeatManager:
|
|||||||
|
|
||||||
msg = WSMessage(sender_id=0, code=1, msg='ping')
|
msg = WSMessage(sender_id=0, code=1, msg='ping')
|
||||||
|
|
||||||
# Nur authentifizierte Verbindungen erhalten einen Heartbeat.
|
if self.app is not None:
|
||||||
|
try:
|
||||||
|
# Auch der Versand braucht einen App-Kontext: Die
|
||||||
|
# Sequenznummern liegen inzwischen in der gemeinsamen
|
||||||
|
# SQLite-Datenbank und werden beim Senden fortgeschrieben.
|
||||||
|
with self.app.app_context():
|
||||||
|
# Nur authentifizierte Verbindungen erhalten einen
|
||||||
|
# Heartbeat.
|
||||||
for tenant_id, connections in list(broker.connections.items()):
|
for tenant_id, connections in list(broker.connections.items()):
|
||||||
for client_id in list(connections):
|
for client_id in list(connections):
|
||||||
if not broker.is_authenticated(tenant_id, client_id):
|
if not broker.is_authenticated(tenant_id, client_id):
|
||||||
continue
|
continue
|
||||||
broker.send_to_connection(tenant_id, client_id, msg.to_json())
|
broker.send_to_connection(
|
||||||
|
tenant_id, client_id, msg.to_json()
|
||||||
|
)
|
||||||
|
|
||||||
# Abgelaufene persistierte Nachrichten und Client-Queues löschen.
|
# Abgelaufene persistierte Nachrichten und Client-Queues
|
||||||
if self.app is not None:
|
# löschen.
|
||||||
try:
|
|
||||||
with self.app.app_context():
|
|
||||||
broker.cleanup_client_queues()
|
broker.cleanup_client_queues()
|
||||||
broker.cleanup_old_messages()
|
broker.cleanup_old_messages()
|
||||||
except Exception as exc:
|
except Exception as exc:
|
||||||
|
|||||||
@@ -0,0 +1,535 @@
|
|||||||
|
"""Prozessübergreifender Zustand des WebSocket-Brokers.
|
||||||
|
|
||||||
|
Der Broker hält weiterhin nur die WebSocket-Objekte im eigenen Prozess.
|
||||||
|
Alles, was ein Reconnect auf einem anderen WSGI-Worker wiederfinden muss,
|
||||||
|
liegt in SQLite:
|
||||||
|
|
||||||
|
- ``ws_clients``: bekannte Client-IDs, Account, letzte Sequenznummer und
|
||||||
|
Verbindungsstatus,
|
||||||
|
- ``ws_client_queue``: persistente Zustellaufträge pro Client,
|
||||||
|
- ``ws_group_presence``: gemeinsame Pong-Zeitpunkte der Gruppen.
|
||||||
|
|
||||||
|
Die Tabellen werden über ``ensure_schema()`` angelegt. Die Funktionen hier
|
||||||
|
erwarten einen aktiven Flask-App-Kontext, weil sie ``get_db()`` verwenden.
|
||||||
|
"""
|
||||||
|
import time
|
||||||
|
|
||||||
|
from cmbnet.db import get_db
|
||||||
|
|
||||||
|
# Kleine Hilfsfunktion, damit alle Zeitstempel dieselbe Basis haben.
|
||||||
|
def now():
|
||||||
|
return time.time()
|
||||||
|
|
||||||
|
|
||||||
|
# ----------------------------------------------------------------------
|
||||||
|
# Clients
|
||||||
|
# ----------------------------------------------------------------------
|
||||||
|
def get_client(tenant_id, client_id):
|
||||||
|
"""Liefert die Zeile eines bekannten Clients oder ``None``."""
|
||||||
|
return get_db().execute(
|
||||||
|
'SELECT * FROM ws_clients WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
).fetchone()
|
||||||
|
|
||||||
|
|
||||||
|
def get_client_account(tenant_id, client_id):
|
||||||
|
"""Liefert die Account-ID, die zu einer Client-ID gehört."""
|
||||||
|
row = get_client(tenant_id, client_id)
|
||||||
|
return row['account_id'] if row else None
|
||||||
|
|
||||||
|
|
||||||
|
def client_exists(tenant_id, client_id):
|
||||||
|
return get_client(tenant_id, client_id) is not None
|
||||||
|
|
||||||
|
|
||||||
|
def client_is_connected(tenant_id, client_id):
|
||||||
|
row = get_client(tenant_id, client_id)
|
||||||
|
return bool(row and row['disconnected_at'] is None)
|
||||||
|
|
||||||
|
|
||||||
|
def ensure_client(tenant_id, client_id, account_id, worker_id=None):
|
||||||
|
"""Registriert eine Client-ID bzw. aktualisiert ihren Verbindungsstatus.
|
||||||
|
|
||||||
|
Gibt ``False`` zurück, wenn die Client-ID bereits einem anderen Account
|
||||||
|
gehört. Ein solcher Wechsel wäre ein Hinweis auf eine manipulierte
|
||||||
|
Zuordnung und wird vom Broker abgelehnt.
|
||||||
|
"""
|
||||||
|
db = get_db()
|
||||||
|
row = get_client(tenant_id, client_id)
|
||||||
|
current = now()
|
||||||
|
|
||||||
|
if row is not None:
|
||||||
|
if row['account_id'] != account_id:
|
||||||
|
return False
|
||||||
|
db.execute(
|
||||||
|
'UPDATE ws_clients SET worker_id = ?, connected_at = ?, '
|
||||||
|
'disconnected_at = NULL, authenticated = 0 '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(worker_id, current, tenant_id, client_id)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
return True
|
||||||
|
|
||||||
|
db.execute(
|
||||||
|
'INSERT INTO ws_clients '
|
||||||
|
'(tenant_id, client_id, account_id, worker_id, connected_at, '
|
||||||
|
' authenticated, last_seq) '
|
||||||
|
'VALUES (?, ?, ?, ?, ?, 0, 0)',
|
||||||
|
(tenant_id, client_id, account_id, worker_id, current)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
|
def mark_authenticated(tenant_id, client_id, authenticated=True, worker_id=None):
|
||||||
|
db = get_db()
|
||||||
|
if worker_id is None:
|
||||||
|
db.execute(
|
||||||
|
'UPDATE ws_clients SET authenticated = ? '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(1 if authenticated else 0, tenant_id, client_id)
|
||||||
|
)
|
||||||
|
else:
|
||||||
|
# Nur der Worker, dem die Client-ID aktuell zugeordnet ist, darf den
|
||||||
|
# Authentifizierungsstatus setzen. So überschreibt ein verspäteter
|
||||||
|
# Handshake eines alten Workers keinen Reconnect auf einem anderen
|
||||||
|
# Worker.
|
||||||
|
db.execute(
|
||||||
|
'UPDATE ws_clients SET authenticated = ? '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ? '
|
||||||
|
'AND (worker_id IS NULL OR worker_id = ?)',
|
||||||
|
(1 if authenticated else 0, tenant_id, client_id, worker_id)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def mark_disconnected(tenant_id, client_id, worker_id=None):
|
||||||
|
"""Markiert eine Client-ID als getrennt, ohne ihre Queue zu löschen.
|
||||||
|
|
||||||
|
Mit ``worker_id`` wird nur die Zuordnung dieses Workers getrennt. Hat
|
||||||
|
inzwischen ein anderer Worker dieselbe Client-ID übernommen, bleibt dessen
|
||||||
|
Verbindungsstatus unberührt.
|
||||||
|
"""
|
||||||
|
db = get_db()
|
||||||
|
if worker_id is None:
|
||||||
|
db.execute(
|
||||||
|
'UPDATE ws_clients SET worker_id = NULL, disconnected_at = ?, '
|
||||||
|
'authenticated = 0 WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(now(), tenant_id, client_id)
|
||||||
|
)
|
||||||
|
else:
|
||||||
|
db.execute(
|
||||||
|
'UPDATE ws_clients SET worker_id = NULL, disconnected_at = ?, '
|
||||||
|
'authenticated = 0 WHERE tenant_id = ? AND client_id = ? '
|
||||||
|
'AND (worker_id IS NULL OR worker_id = ?)',
|
||||||
|
(now(), tenant_id, client_id, worker_id)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def delete_client(tenant_id, client_id, worker_id=None):
|
||||||
|
"""Entfernt eine Client-ID samt Queue und Sequenzzustand.
|
||||||
|
|
||||||
|
Mit ``worker_id`` wird nur gelöscht, solange die Client-ID noch diesem
|
||||||
|
Worker gehört. Das verhindert, dass ein scheidender Worker einen
|
||||||
|
zwischenzeitlichen Reconnect auf einem anderen Worker entfernt.
|
||||||
|
"""
|
||||||
|
db = get_db()
|
||||||
|
if worker_id is None:
|
||||||
|
cursor = db.execute(
|
||||||
|
'DELETE FROM ws_clients WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
)
|
||||||
|
else:
|
||||||
|
cursor = db.execute(
|
||||||
|
'DELETE FROM ws_clients WHERE tenant_id = ? AND client_id = ? '
|
||||||
|
'AND (worker_id IS NULL OR worker_id = ?)',
|
||||||
|
(tenant_id, client_id, worker_id)
|
||||||
|
)
|
||||||
|
if cursor.rowcount:
|
||||||
|
db.execute(
|
||||||
|
'DELETE FROM ws_client_queue WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def get_last_seq(tenant_id, client_id):
|
||||||
|
row = get_client(tenant_id, client_id)
|
||||||
|
return int(row['last_seq'] or 0) if row else 0
|
||||||
|
|
||||||
|
|
||||||
|
def set_last_seq(tenant_id, client_id, seq, account_id=None):
|
||||||
|
db = get_db()
|
||||||
|
cursor = db.execute(
|
||||||
|
'UPDATE ws_clients SET last_seq = ? WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(seq, tenant_id, client_id)
|
||||||
|
)
|
||||||
|
if cursor.rowcount:
|
||||||
|
db.commit()
|
||||||
|
return
|
||||||
|
# Die Client-Zeile kann durch einen Cleanup verschwunden sein. In diesem
|
||||||
|
# Fall wird sie mit der bekannten Account-ID neu angelegt, damit der
|
||||||
|
# Sequenzstand nicht verloren geht.
|
||||||
|
if account_id is not None:
|
||||||
|
db.execute(
|
||||||
|
'INSERT OR IGNORE INTO ws_clients '
|
||||||
|
'(tenant_id, client_id, account_id, last_seq) VALUES (?, ?, ?, ?)',
|
||||||
|
(tenant_id, client_id, account_id, seq)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def client_ids_for_accounts(tenant_id, account_ids):
|
||||||
|
"""Expandiert Empfänger-Accounts auf alle bekannten Client-IDs.
|
||||||
|
|
||||||
|
Anders als früher werden auch Clients berücksichtigt, die an einem
|
||||||
|
anderen Worker verbunden oder momentan getrennt sind. Nur so können
|
||||||
|
Nachrichten für einen Reconnect auf einem beliebigen Worker gepuffert
|
||||||
|
werden.
|
||||||
|
"""
|
||||||
|
account_ids = list(dict.fromkeys(account_ids))
|
||||||
|
if not account_ids:
|
||||||
|
return set()
|
||||||
|
|
||||||
|
db = get_db()
|
||||||
|
result = set()
|
||||||
|
chunk_size = 400
|
||||||
|
for start in range(0, len(account_ids), chunk_size):
|
||||||
|
chunk = account_ids[start:start + chunk_size]
|
||||||
|
placeholders = ','.join('?' for _ in chunk)
|
||||||
|
rows = db.execute(
|
||||||
|
f'SELECT client_id FROM ws_clients '
|
||||||
|
f'WHERE tenant_id = ? AND account_id IN ({placeholders})',
|
||||||
|
(tenant_id, *chunk)
|
||||||
|
).fetchall()
|
||||||
|
result.update(row['client_id'] for row in rows)
|
||||||
|
return result
|
||||||
|
|
||||||
|
|
||||||
|
def describe_connections(tenant_id):
|
||||||
|
"""Liefert alle aktuell verbundenen Clients inklusive Account und Gruppe."""
|
||||||
|
rows = get_db().execute(
|
||||||
|
'''SELECT c.client_id, c.account_id, c.authenticated,
|
||||||
|
a.name AS account_name, a.role,
|
||||||
|
g.id AS group_id, g.aliasname AS group_alias
|
||||||
|
FROM ws_clients c
|
||||||
|
JOIN accounts a
|
||||||
|
ON a.id = c.account_id AND a.tenant_id = c.tenant_id
|
||||||
|
LEFT JOIN group_accounts ga
|
||||||
|
ON ga.tenant_id = c.tenant_id AND ga.account_id = c.account_id
|
||||||
|
LEFT JOIN groups g
|
||||||
|
ON g.id = ga.group_id AND g.tenant_id = c.tenant_id
|
||||||
|
WHERE c.tenant_id = ? AND c.disconnected_at IS NULL
|
||||||
|
ORDER BY c.client_id''',
|
||||||
|
(tenant_id,)
|
||||||
|
).fetchall()
|
||||||
|
return [dict(row) for row in rows]
|
||||||
|
|
||||||
|
|
||||||
|
# ----------------------------------------------------------------------
|
||||||
|
# Client-Queues
|
||||||
|
# ----------------------------------------------------------------------
|
||||||
|
def get_queue_started_at(tenant_id, client_id):
|
||||||
|
row = get_client(tenant_id, client_id)
|
||||||
|
return row['queue_started_at'] if row else None
|
||||||
|
|
||||||
|
|
||||||
|
def _set_queue_started_at(db, tenant_id, client_id, started_at):
|
||||||
|
db.execute(
|
||||||
|
'UPDATE ws_clients SET queue_started_at = ? '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(started_at, tenant_id, client_id)
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def client_has_queue(tenant_id, client_id):
|
||||||
|
"""Prüft, ob für einen Client noch zustellbare Aufträge warten."""
|
||||||
|
row = get_db().execute(
|
||||||
|
'SELECT 1 FROM ws_client_queue '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ? '
|
||||||
|
'AND (expires_at IS NULL OR expires_at > ?) LIMIT 1',
|
||||||
|
(tenant_id, client_id, now())
|
||||||
|
).fetchone()
|
||||||
|
return row is not None
|
||||||
|
|
||||||
|
|
||||||
|
def enqueue_message(tenant_id, client_id, code, payload, max_age_seconds,
|
||||||
|
timeout_payload=None, ephemeral_seconds=None):
|
||||||
|
"""Legt einen Zustellauftrag für einen Client an.
|
||||||
|
|
||||||
|
``max_age_seconds`` steuert die Lebensdauer einer normalen Queue.
|
||||||
|
``timeout_payload`` wird als Code-99-Tombstone eingesetzt, wenn die Queue
|
||||||
|
zu alt ist oder eine Code-99-Nachricht alle älteren Aufträge verdrängt.
|
||||||
|
``ephemeral_seconds`` gilt für Code 2: Der Auftrag verfällt schnell und
|
||||||
|
wird nicht für getrennte Clients vorgehalten.
|
||||||
|
"""
|
||||||
|
db = get_db()
|
||||||
|
current = now()
|
||||||
|
row = db.execute(
|
||||||
|
'SELECT queue_started_at FROM ws_clients '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
).fetchone()
|
||||||
|
if row is None:
|
||||||
|
# Unbekannte Client-IDs werden nicht gepuffert. Der Broker legt die
|
||||||
|
# Zeile beim Code-0-Handshake an.
|
||||||
|
return False
|
||||||
|
|
||||||
|
started_at = row['queue_started_at']
|
||||||
|
if started_at is None:
|
||||||
|
started_at = current
|
||||||
|
|
||||||
|
# Eine Code-99-Nachricht verdrängt alle älteren Aufträge und blockiert
|
||||||
|
# weitere Nachrichten, bis sie zugestellt wurde.
|
||||||
|
if code != 99:
|
||||||
|
tombstone = db.execute(
|
||||||
|
'SELECT 1 FROM ws_client_queue '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ? AND code99_only = 1 LIMIT 1',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
).fetchone()
|
||||||
|
if tombstone:
|
||||||
|
return False
|
||||||
|
|
||||||
|
# Abgelaufene Queue: Inhalt verwerfen und einen Code-99-Hinweis hinterlassen.
|
||||||
|
if current - started_at >= max_age_seconds:
|
||||||
|
db.execute(
|
||||||
|
'DELETE FROM ws_client_queue WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
)
|
||||||
|
if timeout_payload is not None:
|
||||||
|
db.execute(
|
||||||
|
'INSERT INTO ws_client_queue '
|
||||||
|
'(tenant_id, client_id, code, payload, code99_only, created_at) '
|
||||||
|
'VALUES (?, ?, 99, ?, 1, ?)',
|
||||||
|
(tenant_id, client_id, timeout_payload, current)
|
||||||
|
)
|
||||||
|
_set_queue_started_at(db, tenant_id, client_id, current)
|
||||||
|
else:
|
||||||
|
_set_queue_started_at(db, tenant_id, client_id, None)
|
||||||
|
db.commit()
|
||||||
|
return True
|
||||||
|
|
||||||
|
if code == 99:
|
||||||
|
db.execute(
|
||||||
|
'DELETE FROM ws_client_queue WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
)
|
||||||
|
db.execute(
|
||||||
|
'INSERT INTO ws_client_queue '
|
||||||
|
'(tenant_id, client_id, code, payload, code99_only, created_at) '
|
||||||
|
'VALUES (?, ?, 99, ?, 1, ?)',
|
||||||
|
(tenant_id, client_id, payload, current)
|
||||||
|
)
|
||||||
|
_set_queue_started_at(db, tenant_id, client_id, current)
|
||||||
|
db.commit()
|
||||||
|
return True
|
||||||
|
|
||||||
|
expires_at = None
|
||||||
|
if ephemeral_seconds is not None:
|
||||||
|
expires_at = current + ephemeral_seconds
|
||||||
|
|
||||||
|
db.execute(
|
||||||
|
'INSERT INTO ws_client_queue '
|
||||||
|
'(tenant_id, client_id, code, payload, code99_only, created_at, expires_at) '
|
||||||
|
'VALUES (?, ?, ?, ?, 0, ?, ?)',
|
||||||
|
(tenant_id, client_id, code, payload, current, expires_at)
|
||||||
|
)
|
||||||
|
_set_queue_started_at(db, tenant_id, client_id, started_at)
|
||||||
|
db.commit()
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
|
def fetch_queue(tenant_id, client_id):
|
||||||
|
"""Liefert alle noch gültigen Aufträge eines Clients in Reihenfolge."""
|
||||||
|
return get_db().execute(
|
||||||
|
'SELECT * FROM ws_client_queue '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ? '
|
||||||
|
'AND (expires_at IS NULL OR expires_at > ?) '
|
||||||
|
'ORDER BY id ASC',
|
||||||
|
(tenant_id, client_id, now())
|
||||||
|
).fetchall()
|
||||||
|
|
||||||
|
|
||||||
|
def clients_with_queue(pairs):
|
||||||
|
"""Liefert diejenigen ``(tenant_id, client_id)``, die Aufträge haben."""
|
||||||
|
if not pairs:
|
||||||
|
return set()
|
||||||
|
|
||||||
|
db = get_db()
|
||||||
|
by_tenant = {}
|
||||||
|
for tenant_id, client_id in pairs:
|
||||||
|
by_tenant.setdefault(tenant_id, set()).add(client_id)
|
||||||
|
|
||||||
|
result = set()
|
||||||
|
chunk_size = 400
|
||||||
|
for tenant_id, client_ids in by_tenant.items():
|
||||||
|
ids = list(client_ids)
|
||||||
|
for start in range(0, len(ids), chunk_size):
|
||||||
|
chunk = ids[start:start + chunk_size]
|
||||||
|
placeholders = ','.join('?' for _ in chunk)
|
||||||
|
rows = db.execute(
|
||||||
|
f'SELECT DISTINCT client_id FROM ws_client_queue '
|
||||||
|
f'WHERE tenant_id = ? AND client_id IN ({placeholders}) '
|
||||||
|
f'AND (expires_at IS NULL OR expires_at > ?)',
|
||||||
|
(tenant_id, *chunk, now())
|
||||||
|
).fetchall()
|
||||||
|
result.update((tenant_id, row['client_id']) for row in rows)
|
||||||
|
return result
|
||||||
|
|
||||||
|
|
||||||
|
def delete_queue_row(row_id):
|
||||||
|
"""Löscht einen zugestellten Auftrag und räumt den Queue-Start auf."""
|
||||||
|
db = get_db()
|
||||||
|
row = db.execute(
|
||||||
|
'SELECT tenant_id, client_id FROM ws_client_queue WHERE id = ?',
|
||||||
|
(row_id,)
|
||||||
|
).fetchone()
|
||||||
|
if row is None:
|
||||||
|
return
|
||||||
|
db.execute('DELETE FROM ws_client_queue WHERE id = ?', (row_id,))
|
||||||
|
remaining = db.execute(
|
||||||
|
'SELECT 1 FROM ws_client_queue '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ? '
|
||||||
|
'AND (expires_at IS NULL OR expires_at > ?) LIMIT 1',
|
||||||
|
(row['tenant_id'], row['client_id'], now())
|
||||||
|
).fetchone()
|
||||||
|
if remaining is None:
|
||||||
|
_set_queue_started_at(db, row['tenant_id'], row['client_id'], None)
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def replace_queue_with_timeout(tenant_id, client_id, payload):
|
||||||
|
"""Ersetzt eine abgelaufene Queue durch einen Code-99-Hinweis."""
|
||||||
|
db = get_db()
|
||||||
|
current = now()
|
||||||
|
db.execute(
|
||||||
|
'DELETE FROM ws_client_queue WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
)
|
||||||
|
db.execute(
|
||||||
|
'INSERT INTO ws_client_queue '
|
||||||
|
'(tenant_id, client_id, code, payload, code99_only, created_at) '
|
||||||
|
'VALUES (?, ?, 99, ?, 1, ?)',
|
||||||
|
(tenant_id, client_id, payload, current)
|
||||||
|
)
|
||||||
|
_set_queue_started_at(db, tenant_id, client_id, current)
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def expire_queues(max_age_seconds, timeout_payload):
|
||||||
|
"""Wandelt zu alte Queues in Code-99-Tombstones um.
|
||||||
|
|
||||||
|
Die Funktion ist idempotent und kann von jedem Worker regelmäßig
|
||||||
|
aufgerufen werden. Nach dem ersten Lauf ist ``queue_started_at``
|
||||||
|
aktualisiert, sodass weitere Worker die Queue nicht erneut umwandeln.
|
||||||
|
"""
|
||||||
|
db = get_db()
|
||||||
|
cutoff = now() - max_age_seconds
|
||||||
|
rows = db.execute(
|
||||||
|
'SELECT tenant_id, client_id FROM ws_clients '
|
||||||
|
'WHERE queue_started_at IS NOT NULL AND queue_started_at <= ?',
|
||||||
|
(cutoff,)
|
||||||
|
).fetchall()
|
||||||
|
|
||||||
|
current = now()
|
||||||
|
for row in rows:
|
||||||
|
tenant_id = row['tenant_id']
|
||||||
|
client_id = row['client_id']
|
||||||
|
db.execute(
|
||||||
|
'DELETE FROM ws_client_queue WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
)
|
||||||
|
db.execute(
|
||||||
|
'INSERT INTO ws_client_queue '
|
||||||
|
'(tenant_id, client_id, code, payload, code99_only, created_at) '
|
||||||
|
'VALUES (?, ?, 99, ?, 1, ?)',
|
||||||
|
(tenant_id, client_id, timeout_payload, current)
|
||||||
|
)
|
||||||
|
_set_queue_started_at(db, tenant_id, client_id, current)
|
||||||
|
if rows:
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def cleanup_clients(retention_seconds):
|
||||||
|
"""Entfernt dauerhaft getrennte Clients ohne zustellbare Restnachrichten."""
|
||||||
|
db = get_db()
|
||||||
|
cutoff = now() - retention_seconds
|
||||||
|
rows = db.execute(
|
||||||
|
'SELECT tenant_id, client_id FROM ws_clients '
|
||||||
|
'WHERE disconnected_at IS NOT NULL AND disconnected_at < ?',
|
||||||
|
(cutoff,)
|
||||||
|
).fetchall()
|
||||||
|
|
||||||
|
for row in rows:
|
||||||
|
tenant_id = row['tenant_id']
|
||||||
|
client_id = row['client_id']
|
||||||
|
pending = db.execute(
|
||||||
|
'SELECT 1 FROM ws_client_queue '
|
||||||
|
'WHERE tenant_id = ? AND client_id = ? AND code99_only = 0 '
|
||||||
|
'AND (expires_at IS NULL OR expires_at > ?) LIMIT 1',
|
||||||
|
(tenant_id, client_id, now())
|
||||||
|
).fetchone()
|
||||||
|
if pending is not None:
|
||||||
|
# Noch zustellbare Nachrichten halten den Client am Leben.
|
||||||
|
continue
|
||||||
|
db.execute(
|
||||||
|
'DELETE FROM ws_client_queue WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
)
|
||||||
|
db.execute(
|
||||||
|
'DELETE FROM ws_clients WHERE tenant_id = ? AND client_id = ?',
|
||||||
|
(tenant_id, client_id)
|
||||||
|
)
|
||||||
|
if rows:
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def purge_expired_queue_rows():
|
||||||
|
"""Löscht abgelaufene ephemere Aufträge (z. B. Code 2)."""
|
||||||
|
db = get_db()
|
||||||
|
db.execute(
|
||||||
|
'DELETE FROM ws_client_queue WHERE expires_at IS NOT NULL AND expires_at <= ?',
|
||||||
|
(now(),)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
# ----------------------------------------------------------------------
|
||||||
|
# Gruppenpräsenz
|
||||||
|
# ----------------------------------------------------------------------
|
||||||
|
def get_group_presence(tenant_id, group_id):
|
||||||
|
return get_db().execute(
|
||||||
|
'SELECT * FROM ws_group_presence WHERE tenant_id = ? AND group_id = ?',
|
||||||
|
(tenant_id, group_id)
|
||||||
|
).fetchone()
|
||||||
|
|
||||||
|
|
||||||
|
def record_group_pong(tenant_id, group_id, timestamp=None):
|
||||||
|
db = get_db()
|
||||||
|
current = timestamp if timestamp is not None else now()
|
||||||
|
db.execute(
|
||||||
|
'INSERT OR IGNORE INTO ws_group_presence (tenant_id, group_id) VALUES (?, ?)',
|
||||||
|
(tenant_id, group_id)
|
||||||
|
)
|
||||||
|
db.execute(
|
||||||
|
'UPDATE ws_group_presence SET last_pong_at = ?, updated_at = CURRENT_TIMESTAMP '
|
||||||
|
'WHERE tenant_id = ? AND group_id = ?',
|
||||||
|
(current, tenant_id, group_id)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
|
|
||||||
|
|
||||||
|
def set_group_online_since(tenant_id, group_id, timestamp=None):
|
||||||
|
db = get_db()
|
||||||
|
current = timestamp if timestamp is not None else now()
|
||||||
|
db.execute(
|
||||||
|
'INSERT OR IGNORE INTO ws_group_presence (tenant_id, group_id) VALUES (?, ?)',
|
||||||
|
(tenant_id, group_id)
|
||||||
|
)
|
||||||
|
db.execute(
|
||||||
|
'UPDATE ws_group_presence SET online_since = ?, updated_at = CURRENT_TIMESTAMP '
|
||||||
|
'WHERE tenant_id = ? AND group_id = ?',
|
||||||
|
(current, tenant_id, group_id)
|
||||||
|
)
|
||||||
|
db.commit()
|
||||||
@@ -31,6 +31,20 @@ class Config:
|
|||||||
WS_CLIENT_RETENTION_MINUTES = int(
|
WS_CLIENT_RETENTION_MINUTES = int(
|
||||||
os.environ.get('CMBNET_WS_CLIENT_RETENTION_MINUTES', '60')
|
os.environ.get('CMBNET_WS_CLIENT_RETENTION_MINUTES', '60')
|
||||||
)
|
)
|
||||||
|
# Intervall, in dem jeder Worker die gemeinsame Zustell-Queue nach
|
||||||
|
# Nachrichten für seine lokal verbundenen Clients prüft. Kleine Werte
|
||||||
|
# senken die Latenz, erzeugen aber mehr Datenbankzugriffe.
|
||||||
|
WS_BUS_POLL_INTERVAL = float(
|
||||||
|
os.environ.get('CMBNET_WS_BUS_POLL_INTERVAL', '0.5')
|
||||||
|
)
|
||||||
|
# Kurzlebige Zustellaufträge (Code 2) verfallen nach dieser Zeit, damit
|
||||||
|
# sie nicht bei einem späteren Reconnect zugestellt werden.
|
||||||
|
WS_EPHEMERAL_TTL_SECONDS = int(
|
||||||
|
os.environ.get('CMBNET_WS_EPHEMERAL_TTL_SECONDS', '30')
|
||||||
|
)
|
||||||
|
# Optionale feste Worker-ID. Standardmäßig setzt der Broker
|
||||||
|
# ``<hostname>:<pid>`` ein.
|
||||||
|
WS_WORKER_ID = os.environ.get('CMBNET_WS_WORKER_ID', '')
|
||||||
LATE_ENTRY_MAX_AGE_HOURS = int(os.environ.get('CMBNET_LATE_ENTRY_MAX_AGE_HOURS', '8'))
|
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
|
# Ausführliche Broker-Debugausgabe für eingehende Nachrichten und den
|
||||||
# ermittelten Empfängerkreis. Kann im Betrieb über die Umgebungsvariable
|
# ermittelten Empfängerkreis. Kann im Betrieb über die Umgebungsvariable
|
||||||
|
|||||||
@@ -126,6 +126,61 @@ CREATE TABLE IF NOT EXISTS ws_tokens (
|
|||||||
FOREIGN KEY (account_id) REFERENCES accounts(id)
|
FOREIGN KEY (account_id) REFERENCES accounts(id)
|
||||||
);
|
);
|
||||||
|
|
||||||
|
-- Prozessübergreifender WebSocket-Zustand
|
||||||
|
-- Bekannte Client-IDs, Account-Zuordnung, letzte Sequenznummer und
|
||||||
|
-- Verbindungsstatus. Die Tabelle überlebt Reconnects auf anderen Workern.
|
||||||
|
CREATE TABLE IF NOT EXISTS ws_clients (
|
||||||
|
tenant_id INTEGER NOT NULL,
|
||||||
|
client_id TEXT NOT NULL,
|
||||||
|
account_id INTEGER NOT NULL,
|
||||||
|
last_seq INTEGER NOT NULL DEFAULT 0,
|
||||||
|
worker_id TEXT,
|
||||||
|
authenticated INTEGER NOT NULL DEFAULT 0,
|
||||||
|
connected_at REAL,
|
||||||
|
disconnected_at REAL,
|
||||||
|
queue_started_at REAL,
|
||||||
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||||
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||||
|
PRIMARY KEY (tenant_id, client_id),
|
||||||
|
FOREIGN KEY (tenant_id) REFERENCES tenants(id),
|
||||||
|
FOREIGN KEY (account_id) REFERENCES accounts(id)
|
||||||
|
);
|
||||||
|
|
||||||
|
-- Persistente Zustellaufträge pro Client. Jeder Worker liefert nur die
|
||||||
|
-- Aufträge seiner eigenen, lokal verbundenen Clients aus.
|
||||||
|
CREATE TABLE IF NOT EXISTS ws_client_queue (
|
||||||
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||||
|
tenant_id INTEGER NOT NULL,
|
||||||
|
client_id TEXT NOT NULL,
|
||||||
|
code INTEGER NOT NULL,
|
||||||
|
payload TEXT NOT NULL,
|
||||||
|
code99_only INTEGER NOT NULL DEFAULT 0,
|
||||||
|
created_at REAL NOT NULL,
|
||||||
|
expires_at REAL,
|
||||||
|
FOREIGN KEY (tenant_id) REFERENCES tenants(id)
|
||||||
|
);
|
||||||
|
|
||||||
|
-- Gemeinsame Gruppenpräsenz. last_pong_at und online_since werden von allen
|
||||||
|
-- Workern gelesen und geschrieben.
|
||||||
|
CREATE TABLE IF NOT EXISTS ws_group_presence (
|
||||||
|
tenant_id INTEGER NOT NULL,
|
||||||
|
group_id INTEGER NOT NULL,
|
||||||
|
last_pong_at REAL,
|
||||||
|
online_since REAL,
|
||||||
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||||
|
PRIMARY KEY (tenant_id, group_id),
|
||||||
|
FOREIGN KEY (tenant_id) REFERENCES tenants(id),
|
||||||
|
FOREIGN KEY (group_id) REFERENCES groups(id)
|
||||||
|
);
|
||||||
|
|
||||||
|
-- Workerübergreifende Cache-Revisionen. Jeder Worker vergleicht die Revision
|
||||||
|
-- seines In-Memory-Caches mit diesem Wert und lädt bei Abweichung neu.
|
||||||
|
CREATE TABLE IF NOT EXISTS cache_state (
|
||||||
|
key TEXT PRIMARY KEY,
|
||||||
|
revision INTEGER NOT NULL DEFAULT 0,
|
||||||
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||||
|
);
|
||||||
|
|
||||||
-- Persistierte WebSocket Nachrichten für Code >= 1000
|
-- Persistierte WebSocket Nachrichten für Code >= 1000
|
||||||
CREATE TABLE IF NOT EXISTS ws_messages_store (
|
CREATE TABLE IF NOT EXISTS ws_messages_store (
|
||||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||||
@@ -164,3 +219,9 @@ CREATE INDEX IF NOT EXISTS idx_street_house_numbers_lookup
|
|||||||
ON street_house_numbers(tenant_id, street_name, house_number);
|
ON street_house_numbers(tenant_id, street_name, house_number);
|
||||||
CREATE INDEX IF NOT EXISTS idx_ws_tokens_token ON ws_tokens(token);
|
CREATE INDEX IF NOT EXISTS idx_ws_tokens_token ON ws_tokens(token);
|
||||||
CREATE INDEX IF NOT EXISTS idx_ws_messages_ts ON ws_messages_store(ts);
|
CREATE INDEX IF NOT EXISTS idx_ws_messages_ts ON ws_messages_store(ts);
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_ws_clients_account
|
||||||
|
ON ws_clients(tenant_id, account_id);
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_ws_client_queue_client
|
||||||
|
ON ws_client_queue(tenant_id, client_id, id);
|
||||||
|
CREATE INDEX IF NOT EXISTS idx_ws_client_queue_expires
|
||||||
|
ON ws_client_queue(expires_at);
|
||||||
@@ -3,3 +3,7 @@ Werkzeug>=3.0.0
|
|||||||
flask-sock>=0.7.0
|
flask-sock>=0.7.0
|
||||||
simple-websocket>=1.0.0
|
simple-websocket>=1.0.0
|
||||||
python-dateutil>=2.9.0
|
python-dateutil>=2.9.0
|
||||||
|
packaging>=26.3
|
||||||
|
gevent>=26.9.0
|
||||||
|
greenlet>=3.5.6
|
||||||
|
gunicorn>=26.2.0
|
||||||
+115
-65
@@ -15,8 +15,9 @@ Die zentrale Implementierung liegt in:
|
|||||||
|
|
||||||
## 1. Grundidee
|
## 1. Grundidee
|
||||||
|
|
||||||
Der Broker ist eine prozesslokale Vermittlungsinstanz zwischen allen aktiven
|
Der Broker ist eine Vermittlungsinstanz zwischen allen aktiven WebSocket-Clients
|
||||||
WebSocket-Clients eines Mandanten. Er
|
eines Mandanten. Die Socket-Objekte sind prozesslokal, der Client-Zustand und
|
||||||
|
die Zustell-Queue liegen gemeinsam in SQLite. Er
|
||||||
|
|
||||||
- verwaltet die WebSocket-Verbindungen und deren Authentifizierungsstatus,
|
- verwaltet die WebSocket-Verbindungen und deren Authentifizierungsstatus,
|
||||||
- ordnet Nachrichten anhand ihres Codes einem Empfängerkreis zu,
|
- ordnet Nachrichten anhand ihres Codes einem Empfängerkreis zu,
|
||||||
@@ -140,9 +141,11 @@ Zählung ab 1.
|
|||||||
|
|
||||||
Clients merken sich die zuletzt empfangene Sequenznummer. Trifft nach einem
|
Clients merken sich die zuletzt empfangene Sequenznummer. Trifft nach einem
|
||||||
Reconnect eine andere Nummer als `zuletzt + 1` ein, zeigt der Client einen
|
Reconnect eine andere Nummer als `zuletzt + 1` ein, zeigt der Client einen
|
||||||
Code-99-ähnlichen Neulade-Dialog an. Die Sequenzzählung liegt bewusst nur im
|
Code-99-ähnlichen Neulade-Dialog an. Die Sequenzzählung liegt in
|
||||||
Broker-Prozess und nicht in der Datenbank; nach einem Broker-Neustart beginnt
|
`ws_clients.last_seq` und bleibt damit auch bei einem Worker-Wechsel oder
|
||||||
sie neu und löst bei bereits geöffneten Clients den Neulade-Hinweis aus.
|
Neustart eines Workers erhalten. Nach einem vollständigen Verlust der
|
||||||
|
Datenbank beginnt sie neu und löst bei bereits geöffneten Clients den
|
||||||
|
Neulade-Hinweis aus.
|
||||||
|
|
||||||
`sender_id` und `receiver_id` werden nicht in jedem Fall mit lesbaren Namen
|
`sender_id` und `receiver_id` werden nicht in jedem Fall mit lesbaren Namen
|
||||||
ergänzt. Chat-Nachrichten enthalten zusätzlich ein `sender`-Objekt mit
|
ergänzt. Chat-Nachrichten enthalten zusätzlich ein `sender`-Objekt mit
|
||||||
@@ -384,7 +387,8 @@ Absenders sein; Nachrichten an eine fremde Gruppe werden abgewiesen.
|
|||||||
|
|
||||||
### Verbindungsverwaltung
|
### Verbindungsverwaltung
|
||||||
|
|
||||||
`WebSocketBroker.connections` ist ein verschachteltes Dictionary:
|
`WebSocketBroker.connections` ist ein prozesslokales, verschachteltes
|
||||||
|
Dictionary:
|
||||||
|
|
||||||
```text
|
```text
|
||||||
connections[tenant_id][client_id] = {
|
connections[tenant_id][client_id] = {
|
||||||
@@ -393,28 +397,35 @@ connections[tenant_id][client_id] = {
|
|||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
Eine Client-ID gehört genau zu einer Webview. Ein Account kann daher mehrere
|
Es enthält nur die WebSocket-Objekte des aktuellen Workers. Eine Client-ID
|
||||||
Clients parallel betreiben. Eine neue Verbindung mit derselben Client-ID ersetzt
|
gehört genau zu einer Webview. Ein Account kann daher mehrere Clients parallel
|
||||||
nur diese eine Verbindung; andere Clients desselben Accounts bleiben erhalten.
|
betreiben. Eine neue Verbindung mit derselben Client-ID ersetzt nur diese eine
|
||||||
Die zuletzt zugestellte Sequenznummer wird zusätzlich in
|
Verbindung; andere Clients desselben Accounts bleiben erhalten.
|
||||||
`client_sequences[(tenant_id, client_id)]` geführt, damit sie einen Reconnect
|
|
||||||
überlebt. `client_sequence_locks[(tenant_id, client_id)]` serialisiert
|
|
||||||
Sequenzvergabe und Versand pro Client.
|
|
||||||
|
|
||||||
`authenticated[tenant_id][client_id]` speichert den Authentifizierungsstatus.
|
Der workerübergreifende Zustand liegt in SQLite:
|
||||||
Ohne erfolgreichen Code-0-Handshake werden keine fachlichen Nachrichten
|
|
||||||
zugestellt.
|
|
||||||
|
|
||||||
Zusätzlich hält der Broker:
|
- `ws_clients[(tenant_id, client_id)]`: Account-ID, letzte Sequenznummer,
|
||||||
|
Verbindungsstatus, Worker-ID und Queue-Startzeit,
|
||||||
|
- `ws_client_queue`: persistente Zustellaufträge pro Client,
|
||||||
|
- `ws_group_presence[(tenant_id, group_id)]`: gemeinsame Pong-Zeitpunkte,
|
||||||
|
- `cache_state`: gemeinsame Cache-Revision je Mandant. Gruppen- und
|
||||||
|
Zuordnungsänderungen erhöhen die Revision; jeder Worker verwirft daraufhin
|
||||||
|
seinen lokalen `GroupsService`-Cache und lädt ihn neu.
|
||||||
|
|
||||||
- `client_accounts[(tenant_id, client_id)] = account_id`,
|
Die Sequenznummer wird nach jedem erfolgreichen Versand in `ws_clients`
|
||||||
- `account_clients[(tenant_id, account_id)] = {client_id, ...}`,
|
fortgeschrieben. Ein Reconnect auf einem anderen Worker setzt die Zählung dort
|
||||||
- `disconnected_clients[(tenant_id, client_id)] = Zeitpunkt`,
|
fort. `client_sequence_locks[(tenant_id, client_id)]` serialisiert
|
||||||
- `client_sequences[(tenant_id, client_id)] = letzte Sequenznummer`.
|
Sequenzvergabe und Versand innerhalb eines Workers.
|
||||||
|
|
||||||
Diese Zuordnungen bleiben nach einem Verbindungsabbruch erhalten, damit
|
`authenticated[tenant_id][client_id]` speichert den Authentifizierungsstatus
|
||||||
kurzfristige Reconnects ihre Queue wiederfinden. Dauerhaft verlassene Webviews
|
des aktuellen Workers. Zusätzlich wird er in `ws_clients.authenticated`
|
||||||
werden nach `WS_CLIENT_RETENTION_MINUTES` (Default 60 Minuten) aufgeräumt.
|
gespiegelt, damit der Admin-Status alle Worker sieht. Ohne erfolgreichen
|
||||||
|
Code-0-Handshake werden keine fachlichen Nachrichten zugestellt.
|
||||||
|
|
||||||
|
Die Client-Zuordnungen bleiben nach einem Verbindungsabbruch in der Datenbank
|
||||||
|
erhalten, damit kurzfristige Reconnects ihre Queue wiederfinden. Dauerhaft
|
||||||
|
verlassene Webviews werden nach `WS_CLIENT_RETENTION_MINUTES` (Default 60
|
||||||
|
Minuten) aufgeräumt.
|
||||||
|
|
||||||
### Empfängerermittlung
|
### Empfängerermittlung
|
||||||
|
|
||||||
@@ -437,18 +448,25 @@ Nachricht.
|
|||||||
### Zustellung
|
### Zustellung
|
||||||
|
|
||||||
`_deliver()` sendet die Nachricht an jeden ermittelten Client. `_send()` prüft
|
`_deliver()` sendet die Nachricht an jeden ermittelten Client. `_send()` prüft
|
||||||
zuerst die Authentifizierung:
|
zuerst, ob der Client lokal verbunden und authentifiziert ist:
|
||||||
|
|
||||||
- authentifiziert und Verbindung vorhanden: direkter Versand,
|
- lokal verbunden, authentifiziert und ohne wartende Queue: direkter Versand,
|
||||||
- nicht authentifiziert oder Versand fehlgeschlagen: Eintrag in die
|
- sonst: Eintrag in die gemeinsame Queue `ws_client_queue`.
|
||||||
Client-Queue, sofern die Client-ID bekannt ist.
|
|
||||||
|
Jeder Worker betreibt eine Zustellschleife (`cmbnet/ws/delivery.py`), die die
|
||||||
|
gemeinsame Queue regelmäßig nach Aufträgen für seine lokal verbundenen Clients
|
||||||
|
durchsucht. Dadurch erreicht eine HTTP-ausgelöste Benachrichtigung auch
|
||||||
|
WebSockets, die an einem anderen WSGI-Worker hängen. Die Latenz entspricht
|
||||||
|
`WS_BUS_POLL_INTERVAL` (Default 0,5 s); lokal eingestellte Nachrichten wecken
|
||||||
|
die Schleife zusätzlich sofort.
|
||||||
|
|
||||||
Der direkte Versand erfolgt pro Verbindung über einen `send_lock`. Dadurch
|
Der direkte Versand erfolgt pro Verbindung über einen `send_lock`. Dadurch
|
||||||
werden Heartbeat, Route-Thread und HTTP-ausgelöste Broadcasts nicht gleichzeitig
|
werden Heartbeat, Route-Thread und HTTP-ausgelöste Broadcasts nicht gleichzeitig
|
||||||
in denselben Socket schreiben. Zusätzlich serialisiert ein pro Client-ID
|
in denselben Socket schreiben. Zusätzlich serialisiert ein pro Client-ID
|
||||||
geführtes `sequence_lock` die Sequenzvergabe und den Sendevorgang. Erst nach
|
geführtes `sequence_lock` die Sequenzvergabe und den Sendevorgang. Erst nach
|
||||||
erfolgreichem `send()` wird die Sequenznummer fortgeschrieben; schlägt der
|
erfolgreichem `send()` wird die Sequenznummer in `ws_clients` fortgeschrieben;
|
||||||
Versand fehl, bleibt sie unverändert und die Nachricht wird gepuffert.
|
schlägt der Versand fehl, bleibt sie unverändert und die Nachricht wird
|
||||||
|
gepuffert.
|
||||||
|
|
||||||
### Client-Queues
|
### Client-Queues
|
||||||
|
|
||||||
@@ -458,14 +476,18 @@ Queues werden unter dem Schlüssel
|
|||||||
(tenant_id, client_id)
|
(tenant_id, client_id)
|
||||||
```
|
```
|
||||||
|
|
||||||
gespeichert. Die Account-Zuordnung liegt in `client_accounts`. Sie bleibt auch
|
in der Tabelle `ws_client_queue` gespeichert. Die Account-Zuordnung liegt in
|
||||||
ohne aktive Verbindung bestehen, damit weitere Nachrichten für dieselbe Webview
|
`ws_clients`. Sie bleibt auch ohne aktive Verbindung bestehen, damit weitere
|
||||||
gepuffert werden können.
|
Nachrichten für dieselbe Webview gepuffert werden können. Da die Queue
|
||||||
|
prozessübergreifend ist, findet ein Reconnect auf einem beliebigen Worker seine
|
||||||
|
Aufträge wieder.
|
||||||
|
|
||||||
Eigenschaften:
|
Eigenschaften:
|
||||||
|
|
||||||
- gepuffert werden Code 99 und alle Codes ab 100,
|
- gepuffert werden Code 99 und alle Codes ab 100,
|
||||||
- Code 2 und Codes unter 100 werden nicht gepuffert,
|
- Code 2 wird nur für aktuell verbundene Clients kurzlebig gepuffert
|
||||||
|
(`WS_EPHEMERAL_TTL_SECONDS`, Default 30 s) und danach verworfen,
|
||||||
|
- Codes unter 100 werden nicht gepuffert,
|
||||||
- das maximale Alter beträgt `WS_QUEUE_MAX_AGE_MINUTES` (Default 15 Minuten),
|
- das maximale Alter beträgt `WS_QUEUE_MAX_AGE_MINUTES` (Default 15 Minuten),
|
||||||
- die Altersmessung beginnt mit dem Anlegen der Queue, im Regelfall beim
|
- die Altersmessung beginnt mit dem Anlegen der Queue, im Regelfall beim
|
||||||
Verbindungsabbruch,
|
Verbindungsabbruch,
|
||||||
@@ -473,8 +495,8 @@ Eigenschaften:
|
|||||||
Code-99-Hinweis behalten,
|
Code-99-Hinweis behalten,
|
||||||
- dauerhaft getrennte Clients werden nach `WS_CLIENT_RETENTION_MINUTES`
|
- dauerhaft getrennte Clients werden nach `WS_CLIENT_RETENTION_MINUTES`
|
||||||
(Default 60 Minuten) samt Queue und Zuordnung entfernt,
|
(Default 60 Minuten) samt Queue und Zuordnung entfernt,
|
||||||
- Queues liegen ausschließlich im Arbeitsspeicher und überleben keinen
|
- Queues überleben einen Worker-Neustart und einen Reconnect auf einem anderen
|
||||||
Serverneustart,
|
Worker,
|
||||||
- es gibt derzeit keine feste Obergrenze für die Anzahl gepufferter
|
- es gibt derzeit keine feste Obergrenze für die Anzahl gepufferter
|
||||||
Nachrichten.
|
Nachrichten.
|
||||||
|
|
||||||
@@ -496,37 +518,45 @@ geladenen Webview mit neuer Client-ID ist die Nachlieferung dagegen gewollt.
|
|||||||
|
|
||||||
### Heartbeat und Gruppenpräsenz
|
### Heartbeat und Gruppenpräsenz
|
||||||
|
|
||||||
Der `HeartbeatManager` startet beim Anlegen der Flask-App. Er sendet Code 1 und
|
Der `HeartbeatManager` startet beim Anlegen der Flask-App in jedem Worker. Er
|
||||||
prüft alle 15 Sekunden die Gruppenpräsenz. Bei fehlendem Pong wird eine
|
sendet Code 1 an die lokal verbundenen Clients und prüft alle 15 Sekunden die
|
||||||
`online`-Gruppe nach dem konfigurierten Timeout auf `unterwegs` gesetzt.
|
Gruppenpräsenz. Die Pong-Zeitpunkte liegen in `ws_group_presence`, damit ein
|
||||||
|
Worker eine Gruppe nicht zurücksetzt, obwohl ein anderer Worker gerade Pongs
|
||||||
|
empfängt. Bei fehlendem Pong wird eine `online`-Gruppe nach dem konfigurierten
|
||||||
|
Timeout auf `unterwegs` gesetzt.
|
||||||
|
|
||||||
## 8. Nebenläufigkeit
|
## 8. Nebenläufigkeit
|
||||||
|
|
||||||
Berücksichtigt sind:
|
Berücksichtigt sind:
|
||||||
|
|
||||||
- `queue_lock` schützt `client_queues` und die Queue-Übergänge.
|
|
||||||
- `send_lock` pro Verbindung serialisiert alle ausgehenden Frames.
|
- `send_lock` pro Verbindung serialisiert alle ausgehenden Frames.
|
||||||
- Timer laufen als Daemon-Threads.
|
- `client_sequence_locks` und `client_delivery_locks` serialisieren
|
||||||
|
Sequenzvergabe, Queue-Zustellung und Reconnect innerhalb eines Workers.
|
||||||
|
- Die gemeinsame Queue liegt in SQLite. Schreibende Zugriffe werden durch
|
||||||
|
SQLite serialisiert; WAL und `busy_timeout` reduzieren die Blockierzeit.
|
||||||
|
- Timer und die Zustellschleife laufen als Daemon-Threads.
|
||||||
- SQLite-Zugriffe erfolgen pro Thread über die Flask-App-Kontexte.
|
- SQLite-Zugriffe erfolgen pro Thread über die Flask-App-Kontexte.
|
||||||
|
- Jeder Worker besitzt eine eigene `DeliveryWorker`-Schleife. Nach einer lokal
|
||||||
|
eingestellten Nachricht wird sie über ein Event sofort geweckt; Nachrichten
|
||||||
|
aus anderen Workern werden über das Polling-Intervall übernommen.
|
||||||
|
|
||||||
Nicht vollständig abgesichert sind:
|
Nicht vollständig abgesichert sind:
|
||||||
|
|
||||||
- `connections`, `authenticated`, `client_accounts` und `account_clients`
|
- `connections` und `authenticated` werden ohne eigenen Lock gelesen und
|
||||||
werden ohne eigenen Lock gelesen und geschrieben. Einzelne
|
geschrieben. Einzelne Dictionary-Operationen sind durch den GIL atomar,
|
||||||
Dictionary-Operationen sind durch den GIL atomar, zusammengesetzte Prüfungen
|
zusammengesetzte Prüfungen und Ersetzungen sind es nicht.
|
||||||
und Ersetzungen sind es nicht.
|
|
||||||
- Eine neue Verbindung mit derselben Client-ID ersetzt die alte Registrierung.
|
- Eine neue Verbindung mit derselben Client-ID ersetzt die alte Registrierung.
|
||||||
Der alte Socket wird dabei aktiv geschlossen; seine Route entfernt über den
|
Der alte Socket wird dabei aktiv geschlossen; seine Route entfernt über den
|
||||||
`ws`-Vergleich nicht die neue Verbindung.
|
`ws`-Vergleich nicht die neue Verbindung.
|
||||||
- `group_last_pong` und `group_online_since` werden ohne eigenen Lock
|
|
||||||
aktualisiert.
|
|
||||||
- Zwischen Auth-Prüfung und tatsächlichem Senden kann eine Verbindung ersetzt
|
- Zwischen Auth-Prüfung und tatsächlichem Senden kann eine Verbindung ersetzt
|
||||||
werden. Dann kann eine Nachricht an die neue Verbindung gehen oder in der
|
werden. Dann kann eine Nachricht an die neue Verbindung gehen oder in der
|
||||||
Queue landen.
|
Queue landen.
|
||||||
- Der Broker ist prozesslokal. Bei mehreren WSGI-Workern hat jeder Worker
|
- Die Zustellung ist at-least-once. Bei einem Absturz zwischen erfolgreichem
|
||||||
eigene Verbindungen und Queues. Eine HTTP-ausgelöste Benachrichtigung kann
|
Senden und dem Löschen des Queue-Eintrags kann eine Nachricht nach einem
|
||||||
nur die Verbindungen des Workers erreichen, der den HTTP-Request bearbeitet.
|
Reconnect erneut zugestellt werden.
|
||||||
Das ist die wichtigste verbleibende Einschränkung für den Mehrclient-Betrieb.
|
- Bei sehr vielen Clients oder sehr häufigen Code-300-Nachrichten kann SQLite
|
||||||
|
zum Flaschenhals werden. Dann ist ein Wechsel auf Redis oder PostgreSQL als
|
||||||
|
gemeinsamer Bus sinnvoll.
|
||||||
|
|
||||||
## 9. Debugausgabe
|
## 9. Debugausgabe
|
||||||
|
|
||||||
@@ -686,13 +716,33 @@ Client-IDs und damit getrennte Verbindungen und Queues. Eine neue Verbindung
|
|||||||
mit derselben Client-ID ersetzt nur diese eine Verbindung; der alte Socket wird
|
mit derselben Client-ID ersetzt nur diese eine Verbindung; der alte Socket wird
|
||||||
dabei aktiv geschlossen.
|
dabei aktiv geschlossen.
|
||||||
|
|
||||||
### 10.12 Prozesslokaler Broker
|
### 10.12 Mehrere WSGI-Worker (behoben)
|
||||||
|
|
||||||
Der Broker ist ein Singleton im Python-Prozess. Bei mehreren WSGI-Workern sind
|
WebSocket-Objekte bleiben prozesslokal, weil ein Socket nur von dem Worker
|
||||||
Verbindungen, Queues und Gruppenpräsenz nicht prozessübergreifend. Die
|
bedient werden kann, der ihn geöffnet hat. Der Zustand ist jedoch
|
||||||
HTTP-API eines Workers kann keine WebSocket-Verbindung eines anderen Workers
|
prozessübergreifend:
|
||||||
direkt bedienen. Für einen zuverlässigen Betrieb ist entweder ein Worker
|
|
||||||
erforderlich oder ein externer Broker/Message-Bus.
|
- `ws_clients` enthält Client-Zuordnung, Sequenznummer und Verbindungsstatus,
|
||||||
|
- `ws_client_queue` enthält persistente Zustellaufträge,
|
||||||
|
- `ws_group_presence` enthält die gemeinsamen Pong-Zeitpunkte,
|
||||||
|
- `cache_state` enthält die gemeinsame Gruppen-Cache-Revision,
|
||||||
|
- jeder Worker pollt die Queue für seine lokal verbundenen Clients.
|
||||||
|
|
||||||
|
Eine HTTP-ausgelöste Benachrichtigung wird damit an Clients aller Worker
|
||||||
|
zugestellt. Voraussetzung ist, dass jeder Worker seine eigene
|
||||||
|
`DeliveryWorker`-Schleife startet. Bei Gunicorn darf `preload_app` nicht
|
||||||
|
verwendet werden, weil die Schleife sonst im Master statt in den Workern
|
||||||
|
startet. Die Zustellung ist at-least-once; Duplikate sind bei einem Absturz
|
||||||
|
zwischen Senden und Quittieren möglich.
|
||||||
|
|
||||||
|
Wird ein Worker-Prozess hart beendet (z. B. `SIGKILL`), läuft sein
|
||||||
|
`remove_connection()` nicht mehr. Seine Clients bleiben dann in `ws_clients`
|
||||||
|
als verbunden markiert und können weiter Queue-Einträge ansammeln. Ein
|
||||||
|
Reconnect derselben Client-ID korrigiert den Eintrag; ein regulärer
|
||||||
|
Gunicorn-Reload schließt die Verbindungen und räumt sie über den
|
||||||
|
`finally`-Zweig der WebSocket-Route auf. Für harte Abstürze ist ein
|
||||||
|
Worker-Liveness-Check (eigene Heartbeat-Tabelle) ein möglicher nächster
|
||||||
|
Schritt.
|
||||||
|
|
||||||
### 10.13 Administrator als Sender fachlicher Änderungen
|
### 10.13 Administrator als Sender fachlicher Änderungen
|
||||||
|
|
||||||
@@ -705,10 +755,11 @@ akzeptiert.
|
|||||||
### 10.14 Queues nur bei bekannter Client-ID
|
### 10.14 Queues nur bei bekannter Client-ID
|
||||||
|
|
||||||
`_queue_undeliverable()` benötigt eine dem Broker bekannte Client-ID in
|
`_queue_undeliverable()` benötigt eine dem Broker bekannte Client-ID in
|
||||||
`client_accounts`. Vor dem Code-0-Handshake und nach einem Serverneustart sind
|
`ws_clients`. Vor dem Code-0-Handshake ist sie noch nicht vorhanden; Nachrichten
|
||||||
keine Client-Zuordnungen vorhanden; Nachrichten werden dann nicht gepuffert.
|
werden dann nicht gepuffert. Nach einem Serverneustart bleiben die Zuordnungen
|
||||||
Eine neu geladene Webview erhält stattdessen den aktuellen Initialzustand und
|
dagegen in der Datenbank erhalten. Eine neu geladene Webview mit neuer Client-ID
|
||||||
die persistierten Late Entries.
|
erhält keinen alten Puffer, sondern den aktuellen Initialzustand und die
|
||||||
|
persistierten Late Entries.
|
||||||
|
|
||||||
### 10.15 Broadcasts ohne Empfänger-ID
|
### 10.15 Broadcasts ohne Empfänger-ID
|
||||||
|
|
||||||
@@ -732,11 +783,10 @@ erfolgt.
|
|||||||
2. Code 2 zusätzlich an Administratoren verteilen oder einen separaten
|
2. Code 2 zusätzlich an Administratoren verteilen oder einen separaten
|
||||||
Status-Endpoint für Pong-Überfälligkeit bereitstellen.
|
Status-Endpoint für Pong-Überfälligkeit bereitstellen.
|
||||||
3. Zeitstempel für Code 100/200 und Chat-Nachrichten serverseitig setzen.
|
3. Zeitstempel für Code 100/200 und Chat-Nachrichten serverseitig setzen.
|
||||||
4. Queue-Länge begrenzen und Queue-Verhalten bei mehreren Workern klären.
|
4. Queue-Länge begrenzen und die Schreiblast der DB-Outbox beobachten.
|
||||||
5. Code 2000 im Beobachter-Modus und als Infodialog anzeigen.
|
5. Code 2000 im Beobachter-Modus und als Infodialog anzeigen.
|
||||||
6. Den prozesslokalen Broker durch einen gemeinsamen Message-Bus oder einen
|
6. Bei Bedarf Redis oder PostgreSQL als schnelleren gemeinsamen Bus einsetzen,
|
||||||
einzelnen WebSocket-Worker ersetzen, falls mehrere WSGI-Worker betrieben
|
falls das SQLite-Polling bei vielen Clients nicht mehr ausreicht.
|
||||||
werden.
|
|
||||||
|
|
||||||
## 12. Debugausgabe und Tests
|
## 12. Debugausgabe und Tests
|
||||||
|
|
||||||
|
|||||||
Reference in new issue
Block a user