bug fix shutdown/reconnect WS resultiert in offline für FCM
This commit is contained in:
1 parent
c51ef02f88
commit
b5f928bf76
11 files changed
+331
-11
No files matched your search
@@ -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()
|
||||
|
||||
|
||||
@@ -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
@@ -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)
|
||||
|
||||
Reference in new issue
Block a user