bug fix shutdown/reconnect WS resultiert in offline für FCM

This commit is contained in:
concierge committed 2026-11-09 09:15:34 +01:00
1 parent c51ef02f88
commit b5f928bf76
11 files changed
+331 -11

No files matched your search

+68
View File
@@ -122,6 +122,10 @@ class WebSocketBroker:
):
return False
# Der Worker ist offensichtlich aktiv; sein Lebenszeichen verhindert,
# dass andere Worker seine Clients fälschlich als verwaist markieren.
store.touch_worker(self.worker_id)
# Für Gruppen-Accounts die zugehörige Gruppe ermitteln. Ein Account der
# Rolle "Gruppe" ist höchstens einer Gruppe zugeordnet.
if group_id is None and role == 'Gruppe':
@@ -161,6 +165,11 @@ class WebSocketBroker:
'last_ping': datetime.now(),
'connected_at': time.monotonic(),
'last_pong_at': None,
# Zeitpunkt des letzten beliebigen Lebenszeichens. Wird beim
# Handshake gesetzt und bei jeder eingehenden Nachricht
# aktualisiert, damit auch Clients ohne Pong nicht fälschlich
# als tot gelten.
'last_seen_at': time.time(),
# Zuletzt an diese Client-ID zugestellte Sequenznummer. Die
# maßgebliche Zählung liegt in ws_clients und überlebt damit einen
# Worker-Wechsel.
@@ -283,6 +292,8 @@ class WebSocketBroker:
store.set_group_online_since(tenant_id, conn['group_id'])
self.authenticated.setdefault(tenant_id, {})[client_id] = True
conn['last_seen_at'] = time.time()
conn['last_pong_at'] = conn['last_seen_at']
store.mark_authenticated(
tenant_id, client_id, True, worker_id=self.worker_id
)
@@ -359,6 +370,60 @@ class WebSocketBroker:
tenant_id, client_id, worker_id=self.worker_id
)
def check_client_liveness(self, timeout_seconds):
"""Trennt authentifizierte Verbindungen ohne Lebenszeichen.
Ein sauber geschlossener WebSocket wird bereits in der WS-Route
erkannt. Mobile Geräte verlieren die Verbindung beim Schlafenlegen
jedoch oft ohne FIN/RST; der Server sieht dann scheinbar eine offene
Verbindung und markiert den Client nie als getrennt. Diese Prüfung
schließt solche halb offenen Verbindungen nach ``timeout_seconds``
und macht sie damit für FCM-Aufwachsignale sichtbar.
Rückgabe: Anzahl der getrennten Verbindungen.
"""
try:
timeout_seconds = float(timeout_seconds)
except (TypeError, ValueError):
timeout_seconds = 0
if timeout_seconds <= 0:
return 0
now = time.time()
disconnected = 0
for tenant_id, connections in list(self.connections.items()):
for client_id, conn in list(connections.items()):
if not self.is_authenticated(tenant_id, client_id):
continue
last_seen = conn.get('last_seen_at') or conn.get('last_pong_at')
if last_seen is None:
# Sehr alte Verbindungsobjekte haben noch keinen
# Zeitstempel; sie erhalten eine Gnadenfrist.
conn['last_seen_at'] = now
continue
if now - last_seen <= timeout_seconds:
continue
ws = conn.get('ws')
try:
if ws is not None:
ws.close()
except Exception:
pass
self.remove_connection(tenant_id, client_id, ws)
disconnected += 1
try:
current_app.logger.info(
'WebSocket-Verbindung ohne Lebenszeichen getrennt: '
'tenant=%s client=%s last_seen=%.0fs',
tenant_id, client_id, now - last_seen
)
except Exception:
pass
return disconnected
def _get_connection(self, tenant_id, client_id):
return self.connections.get(tenant_id, {}).get(client_id)
@@ -835,6 +900,9 @@ class WebSocketBroker:
"""
if client_id:
message._sender_client_id = client_id
conn = self._get_connection(tenant_id, client_id)
if conn is not None:
conn['last_seen_at'] = time.time()
db = get_db()
+20 -1
View File
@@ -9,7 +9,7 @@ Zusätzlich räumt die Routine abgelaufene Late-Entry-Nachrichten auf, damit die
Tabelle ws_messages_store nicht unbegrenzt wächst.
"""
from threading import Timer
from cmbnet.ws import broker
from cmbnet.ws import broker, store
from cmbnet.ws.protocol import WSMessage
@@ -75,6 +75,17 @@ class HeartbeatManager:
# Sequenznummern liegen inzwischen in der gemeinsamen
# SQLite-Datenbank und werden beim Senden fortgeschrieben.
with self.app.app_context():
# Eigenes Lebenszeichen aktualisieren, bevor verwaiste
# Clients anderer Worker erkannt werden.
timeout = self.app.config.get(
'WS_CLIENT_OFFLINE_TIMEOUT_SECONDS',
max(180, int(self.interval) * 3)
)
store.touch_worker(broker.worker_id)
store.mark_orphan_clients_disconnected(
store.now() - max(1, int(timeout))
)
# Nur authentifizierte Verbindungen erhalten einen
# Heartbeat.
for tenant_id, connections in list(broker.connections.items()):
@@ -85,6 +96,14 @@ class HeartbeatManager:
tenant_id, client_id, msg.to_json()
)
# Halb offene Verbindungen erkennen. Ein mobiles Gerät
# verliert beim Schlafenlegen oft die Verbindung, ohne
# dass der Server ein FIN/RST erhält. Ohne diese Prüfung
# bliebe der Client dauerhaft als "verbunden" markiert
# und würde nie über FCM geweckt.
broker.check_client_liveness(timeout)
store.cleanup_worker_registry(max(600, int(timeout) * 4))
# Abgelaufene persistierte Nachrichten und Client-Queues
# löschen.
broker.cleanup_client_queues()
+111 -2
View File
@@ -294,6 +294,61 @@ def get_push_token(tenant_id, client_id):
).fetchone()
def touch_worker(worker_id, timestamp=None):
"""Aktualisiert das Lebenszeichen eines WSGI-Workers."""
if not worker_id:
return
current = now() if timestamp is None else timestamp
db = get_db()
db.execute(
'''INSERT INTO ws_workers (worker_id, started_at, heartbeat_at)
VALUES (?, ?, ?)
ON CONFLICT(worker_id) DO UPDATE SET
heartbeat_at = excluded.heartbeat_at''',
(worker_id, current, current)
)
db.commit()
def mark_orphan_clients_disconnected(active_since):
"""Markiert Clients von nicht mehr lebenden Workern als getrennt.
Nach einem Neustart bleiben in ``ws_clients`` Einträge mit
``disconnected_at IS NULL`` zurück, obwohl die zugehörige Verbindung nur
im Speicher des alten Prozesses existierte. Ohne diese Bereinigung würden
solche Clients nie als Wake-Kandidaten erscheinen. Clients eines Workers,
dessen Heartbeat noch innerhalb von ``active_since`` liegt, bleiben
unberührt.
"""
db = get_db()
cursor = db.execute(
'''UPDATE ws_clients
SET worker_id = NULL, disconnected_at = ?, authenticated = 0
WHERE disconnected_at IS NULL
AND (
worker_id IS NULL
OR NOT EXISTS (
SELECT 1 FROM ws_workers w
WHERE w.worker_id = ws_clients.worker_id
AND w.heartbeat_at >= ?
)
)''',
(now(), active_since)
)
db.commit()
return cursor.rowcount
def cleanup_worker_registry(max_age_seconds):
"""Entfernt Lebenszeichen-Einträge beendeter Worker."""
db = get_db()
db.execute(
'DELETE FROM ws_workers WHERE heartbeat_at < ?',
(now() - max_age_seconds,)
)
db.commit()
def mark_push_token_invalid(token):
"""Markiert ein von FCM abgelehntes Token als ungültig."""
db = get_db()
@@ -323,7 +378,7 @@ def _offline_mobile_wake_query(tenant_id, disconnected_before,
LIMIT 1
)
WHERE c.tenant_id = ?
AND c.client_type IN ('group_view', 'dispatcher_mobile')
AND p.client_type IN ('group_view', 'dispatcher_mobile')
AND c.disconnected_at IS NOT NULL
AND c.disconnected_at <= ?'''
]
@@ -423,8 +478,47 @@ def claim_offline_mobile_wakes(tenant_id, disconnected_before,
raise
def mobile_push_stats(tenant_id):
"""Liefert Diagnosezahlen für den manuellen FCM-Wake.
``valid_tokens`` zählt registrierte, nicht von FCM abgelehnte Tokens
mobiler Webviews. ``connected`` zählt die davon aktuell als verbunden
geltenden Clients. Damit lässt sich in der Oberfläche unterscheiden, ob
die Registrierung oder die Offline-Erkennung das Problem ist.
"""
db = get_db()
valid_tokens = db.execute(
'''SELECT COUNT(*) FROM ws_push_tokens
WHERE tenant_id = ? AND invalid = 0
AND client_type IN ('group_view', 'dispatcher_mobile')''',
(tenant_id,)
).fetchone()[0]
connected = db.execute(
'''SELECT COUNT(DISTINCT c.client_id)
FROM ws_clients c
JOIN ws_push_tokens p
ON p.tenant_id = c.tenant_id
AND p.client_id = c.client_id
AND p.invalid = 0
WHERE c.tenant_id = ?
AND p.client_type IN ('group_view', 'dispatcher_mobile')
AND c.disconnected_at IS NULL''',
(tenant_id,)
).fetchone()[0]
return {
'valid_tokens': int(valid_tokens or 0),
'connected': int(connected or 0),
}
def cleanup_orphan_push_tokens(max_age_seconds):
"""Entfernt ungültige sowie verwaiste, lange nicht aktualisierte Tokens."""
"""Entfernt ungültige sowie veraltete, nicht mehr verbundene Tokens.
Tokens von aktuell verbundenen Clients bleiben erhalten, auch wenn die
Registrierung länger zurückliegt. Getrennte Tokens werden erst nach der
(bewusst großzügigen) Aufbewahrungsfrist entfernt, damit auch über Nacht
schlafende Mobilgeräte noch geweckt werden können.
"""
db = get_db()
cutoff = now() - max_age_seconds
db.execute(
@@ -437,6 +531,7 @@ def cleanup_orphan_push_tokens(max_age_seconds):
SELECT 1 FROM ws_clients c
WHERE c.tenant_id = ws_push_tokens.tenant_id
AND c.client_id = ws_push_tokens.client_id
AND c.disconnected_at IS NULL
)''',
(cutoff,)
)
@@ -713,6 +808,20 @@ def cleanup_clients(retention_seconds):
'DELETE FROM ws_client_queue WHERE tenant_id = ? AND client_id = ?',
(tenant_id, client_id)
)
# Ein gültiges FCM-Token hält den Client-Eintrag am Leben. Sonst
# würden schlafende Mobilgeräte schon nach der kurzen
# Client-Aufbewahrung samt Token verschwinden und könnten nie wieder
# geweckt werden. Das Token selbst wird über
# ``cleanup_orphan_push_tokens`` mit eigener Frist aufgeräumt.
has_push_token = db.execute(
'SELECT 1 FROM ws_push_tokens '
'WHERE tenant_id = ? AND client_id = ? AND invalid = 0 LIMIT 1',
(tenant_id, client_id)
).fetchone()
if has_push_token is not None:
continue
db.execute(
'DELETE FROM ws_push_tokens WHERE tenant_id = ? AND client_id = ?',
(tenant_id, client_id)