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
@@ -125,7 +125,12 @@ Die Zeitfenster lassen sich über Umgebungsvariablen konfigurieren:
|
||||
die zu lange Unterbrechung zugestellt.
|
||||
- `CMBNET_WS_CLIENT_RETENTION_MINUTES` (Default `60`): Wie lange eine nicht mehr
|
||||
verbundene Webview samt Queue registriert bleibt, bevor der Broker sie
|
||||
endgültig aufräumt.
|
||||
endgültig aufräumt. Clients mit gültigem FCM-Token bleiben länger erhalten.
|
||||
- `CMBNET_WS_CLIENT_OFFLINE_TIMEOUT_SECONDS` (Default `180`): Zeit ohne
|
||||
Lebenszeichen (Pong oder beliebige eingehende WebSocket-Nachricht), nach der
|
||||
der Server eine halb offene Verbindung schließt und den Client als getrennt
|
||||
markiert. Erst dadurch werden schlafende Mobilgeräte zuverlässig als
|
||||
„offline“ erkannt.
|
||||
- `CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS` (Default `120`): Zeit ohne Code-2-
|
||||
Lebenszeichen, nach der eine Gruppe von `online` auf `unterwegs` wechselt.
|
||||
- `CMBNET_WS_DEBUG_MESSAGES` (Default `1`): schreibt jede beim Broker
|
||||
|
||||
@@ -115,6 +115,7 @@ def wake_mobile_clients(**kwargs):
|
||||
return jsonify({'ok': False, 'error': 'Ungültige Gruppen-ID.'}), 400
|
||||
|
||||
current = store.now()
|
||||
stats = store.mobile_push_stats(g.tenant_id)
|
||||
cooldown = max(0, int(current_app.config.get(
|
||||
'FCM_MANUAL_WAKE_COOLDOWN_SECONDS', 15
|
||||
)))
|
||||
@@ -140,11 +141,21 @@ def wake_mobile_clients(**kwargs):
|
||||
for token in invalid_tokens:
|
||||
store.mark_push_token_invalid(token)
|
||||
|
||||
current_app.logger.info(
|
||||
'FCM-Wake manuell: tenant=%s group=%s tokens=%s verbunden=%s '
|
||||
'candidates=%s sent=%s failed=%s',
|
||||
g.tenant_id, group_id, stats['valid_tokens'], stats['connected'],
|
||||
len(candidates), int(result.get('sent') or 0),
|
||||
int(result.get('failed') or 0)
|
||||
)
|
||||
|
||||
return jsonify({
|
||||
'ok': True,
|
||||
'configured': bool(result.get('configured')),
|
||||
'candidates': len(candidates),
|
||||
'sent': int(result.get('sent') or 0),
|
||||
'failed': int(result.get('failed') or 0),
|
||||
'valid_tokens': stats['valid_tokens'],
|
||||
'connected': stats['connected'],
|
||||
'error': result.get('error'),
|
||||
})
|
||||
@@ -99,6 +99,12 @@ def ensure_ws_schema(db):
|
||||
FOREIGN KEY (group_id) REFERENCES groups(id)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS ws_workers (
|
||||
worker_id TEXT PRIMARY KEY,
|
||||
started_at REAL NOT NULL,
|
||||
heartbeat_at REAL NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS cache_state (
|
||||
key TEXT PRIMARY KEY,
|
||||
revision INTEGER NOT NULL DEFAULT 0,
|
||||
|
||||
@@ -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)
|
||||
|
||||
+11
-1
@@ -19,6 +19,13 @@ class Config:
|
||||
WS_GROUP_ONLINE_TIMEOUT_SECONDS = int(
|
||||
os.environ.get('CMBNET_WS_GROUP_ONLINE_TIMEOUT_SECONDS', '120')
|
||||
)
|
||||
# Wartezeit ohne Lebenszeichen, nach der eine WebSocket-Verbindung als
|
||||
# verloren gilt. Der Server sendet jede ``WS_HEARTBEAT_INTERVAL`` Sekunde
|
||||
# einen Ping; der Timeout muss deutlich darüber liegen, damit ein
|
||||
# einzelner ausgefallener Pong die Verbindung nicht sofort trennt.
|
||||
WS_CLIENT_OFFLINE_TIMEOUT_SECONDS = int(
|
||||
os.environ.get('CMBNET_WS_CLIENT_OFFLINE_TIMEOUT_SECONDS', '180')
|
||||
)
|
||||
# Wie lange nicht zustellbare Nachrichten pro Client vorgehalten werden,
|
||||
# bevor sie verworfen und durch einen Code-99-Hinweis ersetzt werden.
|
||||
WS_QUEUE_MAX_AGE_MINUTES = int(
|
||||
@@ -114,8 +121,11 @@ class Config:
|
||||
FCM_WAKE_POLL_INTERVAL_SECONDS = float(os.environ.get(
|
||||
'CMBNET_FCM_WAKE_POLL_INTERVAL_SECONDS', '30'
|
||||
))
|
||||
# FCM-Tokens bleiben auch für länger schlafende Geräte erhalten. Sie
|
||||
# werden erst entfernt, wenn sie von FCM abgelehnt wurden oder das Gerät
|
||||
# über diesen Zeitraum weder verbunden noch neu registriert war.
|
||||
FCM_PUSH_TOKEN_RETENTION_MINUTES = int(os.environ.get(
|
||||
'CMBNET_FCM_PUSH_TOKEN_RETENTION_MINUTES', '1440'
|
||||
'CMBNET_FCM_PUSH_TOKEN_RETENTION_MINUTES', '43200'
|
||||
))
|
||||
# Ausführliche Broker-Debugausgabe für eingehende Nachrichten und den
|
||||
# ermittelten Empfängerkreis. Kann im Betrieb über die Umgebungsvariable
|
||||
|
||||
@@ -18,7 +18,8 @@ Sie sind kein Anwendungsinhalt.
|
||||
|
||||
| Komponente | Aufgabe |
|
||||
| --- | --- |
|
||||
| `cmbnet/ws/broker.py` | Erkennt nicht zustellbare Nachrichten und fordert ein Wake-Signal an. |
|
||||
| `cmbnet/ws/broker.py` | Erkennt nicht zustellbare Nachrichten, trennt Verbindungen ohne Lebenszeichen und fordert ein Wake-Signal an. |
|
||||
| `cmbnet/ws/heartbeat.py` | Sendet Code-1-Pings und prüft, ob Clients noch antworten. |
|
||||
| `cmbnet/ws/push.py` | Periodischer Worker für den Offline-Timeout. |
|
||||
| `cmbnet/services/fcm_service.py` | Firebase-Admin-Initialisierung und FCM-Versand. |
|
||||
| `cmbnet/api/push.py` | Token-Registrierung, Abmeldung und manueller Wake-Button. |
|
||||
@@ -60,6 +61,33 @@ Sobald eine Nachricht mit Code `>= 99` für einen getrennten mobilen Client
|
||||
eingereiht wird, versucht der Broker ein FCM-Signal. Mehrere Nachrichten
|
||||
innerhalb des Queue-Cooldowns lösen nur ein Signal aus.
|
||||
|
||||
### Offline-Erkennung
|
||||
|
||||
Ein Client gilt nur dann als offline, wenn der Broker seine WebSocket-
|
||||
Verbindung als beendet markiert hat (`ws_clients.disconnected_at`). Dafür gibt
|
||||
es drei Wege:
|
||||
|
||||
1. Ein sauber geschlossener Socket wird in der WS-Route unmittelbar erkannt.
|
||||
2. Die mobile View schließt ihren Socket beim Wechsel in den Hintergrund
|
||||
(`visibilitychange`) bzw. beim Verlassen der Seite (`pagehide`). Damit ist
|
||||
sie sofort offline, ohne auf einen Timeout warten zu müssen. Beim
|
||||
Sichtbarwerden verbindet sie sich neu und frischt ihr FCM-Token auf.
|
||||
3. Halb offene Verbindungen, bei denen das Gerät einschläft, ohne FIN/RST zu
|
||||
senden, werden vom Heartbeat nach
|
||||
`CMBNET_WS_CLIENT_OFFLINE_TIMEOUT_SECONDS` (Default 180) ohne Lebenszeichen
|
||||
geschlossen. Als Lebenszeichen zählt ein Code-2-Pong oder jede andere
|
||||
eingehende WebSocket-Nachricht des Clients.
|
||||
4. Jeder WSGI-Worker hinterlässt ein Lebenszeichen in `ws_workers`. Clients
|
||||
eines nicht mehr laufenden Workers – etwa nach einem Neustart – werden
|
||||
automatisch als getrennt markiert. Das verhindert dauerhaft „verbundene“
|
||||
Karteileichen in der Datenbank.
|
||||
|
||||
Ohne Schritt 3 und 4 blieben schlafende Geräte bzw. Clients aus einem alten
|
||||
Prozess dauerhaft als „verbunden“ markiert und würden nie als Wake-Kandidaten
|
||||
erscheinen. `ws_clients`-Einträge mit gültigem FCM-Token werden beim normalen
|
||||
Client-Aufräumen nicht entfernt; das Token hat eine eigene, großzügigere
|
||||
Aufbewahrungsfrist.
|
||||
|
||||
### Offline-Timeout
|
||||
|
||||
Ein periodischer Worker prüft getrennte Clients. Nach
|
||||
@@ -96,6 +124,11 @@ Desktop-Dispatcher erhalten keine FCM-Behandlung.
|
||||
- `client_type`: Client-Typ für das FCM-Routing
|
||||
- `last_wake_at`, `last_wake_reason`: Drosselung und Nachvollziehbarkeit
|
||||
|
||||
Neue Tabelle `ws_workers`:
|
||||
|
||||
- Lebenszeichen je WSGI-Worker (`started_at`, `heartbeat_at`)
|
||||
- dient der Erkennung verwaister Clients nach einem Worker-Neustart
|
||||
|
||||
Neue Tabelle `ws_push_tokens`:
|
||||
|
||||
- ein FCM-Token ist projektweit eindeutig
|
||||
@@ -105,8 +138,9 @@ Neue Tabelle `ws_push_tokens`:
|
||||
|
||||
Die Registrierung wird bei einem Reload mit neuer Client-ID auf die neue
|
||||
Client-ID verschoben. Nach einer Token-Rotation wird das alte Token derselben
|
||||
Webview entfernt. Verwaiste Tokens werden zusammen mit den Client-Queues
|
||||
aufgeräumt.
|
||||
Webview entfernt. Verwaiste Tokens werden mit einer eigenen Frist aufgeräumt;
|
||||
der zugehörige `ws_clients`-Eintrag bleibt so lange erhalten. Die
|
||||
Client-Queues werden weiterhin nach der kürzeren Queue-Frist bereinigt.
|
||||
|
||||
## Mehrere Worker
|
||||
|
||||
@@ -140,7 +174,8 @@ inaktiv:
|
||||
| `CMBNET_FCM_MANUAL_WAKE_COOLDOWN_SECONDS` | `15` | Cooldown für den Button |
|
||||
| `CMBNET_FCM_SIGNAL_TTL_SECONDS` | `600` | FCM-TTL |
|
||||
| `CMBNET_FCM_WAKE_POLL_INTERVAL_SECONDS` | `30` | Prüfintervall des Workers |
|
||||
| `CMBNET_FCM_PUSH_TOKEN_RETENTION_MINUTES` | `1440` | Aufbewahrung verwaister Tokens |
|
||||
| `CMBNET_FCM_PUSH_TOKEN_RETENTION_MINUTES` | `43200` | Aufbewahrung nicht verbundener Tokens (30 Tage) |
|
||||
| `CMBNET_WS_CLIENT_OFFLINE_TIMEOUT_SECONDS` | `180` | Zeit ohne Lebenszeichen bis zur Offline-Markierung |
|
||||
|
||||
## Beschränkungen und Konsequenzen bei PWAs
|
||||
|
||||
|
||||
@@ -214,6 +214,15 @@ CREATE TABLE IF NOT EXISTS ws_group_presence (
|
||||
FOREIGN KEY (group_id) REFERENCES groups(id)
|
||||
);
|
||||
|
||||
-- Lebenszeichen der WSGI-Worker. Clients eines Workers, dessen Heartbeat
|
||||
-- länger als der Offline-Timeout zurückliegt (z. B. nach einem Neustart),
|
||||
-- werden als getrennt markiert und können über FCM geweckt werden.
|
||||
CREATE TABLE IF NOT EXISTS ws_workers (
|
||||
worker_id TEXT PRIMARY KEY,
|
||||
started_at REAL NOT NULL,
|
||||
heartbeat_at REAL NOT NULL
|
||||
);
|
||||
|
||||
-- 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 (
|
||||
|
||||
@@ -3656,7 +3656,12 @@ async function wakeMobileClients() {
|
||||
if (sent > 0) {
|
||||
setStreetSearchStatus(`${sent} mobile Clients geweckt.`);
|
||||
} else {
|
||||
setStreetSearchStatus('Keine offline mobilen Clients mit Push-Token gefunden.');
|
||||
const tokens = Number(result.valid_tokens) || 0;
|
||||
const connected = Number(result.connected) || 0;
|
||||
setStreetSearchStatus(
|
||||
'Keine offline mobilen Clients mit Push-Token gefunden '
|
||||
+ `(registriert: ${tokens}, verbunden: ${connected}).`
|
||||
);
|
||||
}
|
||||
setTimeout(() => setStreetSearchStatus(''), 5000);
|
||||
} catch (error) {
|
||||
|
||||
@@ -156,6 +156,38 @@ async function initMobile() {
|
||||
}
|
||||
if (state.ws) state.ws.close();
|
||||
});
|
||||
|
||||
// ``pagehide`` wird auf mobilen Browsern zuverlässiger ausgelöst als
|
||||
// ``beforeunload``, wenn die PWA verlassen oder eingefroren wird.
|
||||
window.addEventListener('pagehide', () => {
|
||||
if (state.ws) state.ws.close();
|
||||
});
|
||||
|
||||
document.addEventListener('visibilitychange', () => {
|
||||
if (document.hidden) {
|
||||
// Im Hintergrund kann die View nicht bedient werden und mobile
|
||||
// Browser frieren die Verbindung ohnehin ein. Das saubere
|
||||
// Schließen markiert den Client sofort als offline, sodass der
|
||||
// manuelle Wake-Button ihn über FCM erreichen kann.
|
||||
if (state.reconnectTimer) {
|
||||
clearTimeout(state.reconnectTimer);
|
||||
state.reconnectTimer = null;
|
||||
}
|
||||
if (state.ws) {
|
||||
const ws = state.ws;
|
||||
state.ws = null;
|
||||
state.authenticated = false;
|
||||
try { ws.close(); } catch (error) {}
|
||||
}
|
||||
setMobileWsStatus('getrennt', 'disconnected');
|
||||
return;
|
||||
}
|
||||
|
||||
// Beim Zurückkehren sofort wieder verbinden und die Token-
|
||||
// Registrierung auffrischen (verhindert veraltete Tokens).
|
||||
syncPushRegistration();
|
||||
connectWebSocket();
|
||||
});
|
||||
}
|
||||
|
||||
function fetchJson(url, options={}) {
|
||||
@@ -629,7 +661,12 @@ async function wakeMobileClientsFromUi() {
|
||||
if (sent > 0) {
|
||||
showMobileToast(`${sent} mobile Clients geweckt.`);
|
||||
} else {
|
||||
showMobileToast('Keine offline mobilen Clients mit Push-Token gefunden.');
|
||||
const tokens = Number(result.valid_tokens) || 0;
|
||||
const connected = Number(result.connected) || 0;
|
||||
showMobileToast(
|
||||
'Keine offline mobilen Clients mit Push-Token gefunden '
|
||||
+ `(registriert: ${tokens}, verbunden: ${connected}).`
|
||||
);
|
||||
}
|
||||
} catch (error) {
|
||||
showMobileToast(`Wecken fehlgeschlagen: ${error.message}`, true);
|
||||
@@ -1748,6 +1785,9 @@ function setMobileWsStatus(label, status) {
|
||||
}
|
||||
|
||||
function scheduleMobileReconnect() {
|
||||
// Im Hintergrund nicht in einer Reconnect-Schleife hängen bleiben. Die
|
||||
// Verbindung wird beim nächsten Sichtbarwerden wieder aufgebaut.
|
||||
if (document.hidden) return;
|
||||
if (state.reconnectTimer) return;
|
||||
state.reconnectTimer = setTimeout(() => {
|
||||
state.reconnectTimer = null;
|
||||
@@ -2132,6 +2172,9 @@ function handleWs(event) {
|
||||
setMobileWsStatus('verbunden', 'connected');
|
||||
flushWsOutbox();
|
||||
resolveWsAuthentication();
|
||||
// Token-Aktualität erhalten, damit die FCM-Aufbewahrung auch bei
|
||||
// lange laufenden PWAs nicht abläuft.
|
||||
syncPushRegistration();
|
||||
} else if (message.code === 1) {
|
||||
setMobileWsStatus('verbunden', 'connected');
|
||||
if (state.ws && state.ws.readyState === WebSocket.OPEN) {
|
||||
|
||||
Reference in new issue
Block a user