Files
Sternsinger/CMBNet/cmbnet/ws/store.py
T

776 lines
27 KiB
Python

"""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,
client_type=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.
``client_type`` wird bei jedem Reconnect aktualisiert. ``None`` lässt
einen bereits bekannten Typ unverändert, damit ältere Clients ohne
Typangabe ihre FCM-Berechtigung nicht verlieren.
"""
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, '
'client_type = COALESCE(?, client_type) '
'WHERE tenant_id = ? AND client_id = ?',
(worker_id, current, client_type, tenant_id, client_id)
)
db.commit()
return True
db.execute(
'INSERT INTO ws_clients '
'(tenant_id, client_id, account_id, client_type, worker_id, '
' connected_at, authenticated, last_seq) '
'VALUES (?, ?, ?, ?, ?, ?, 0, 0)',
(tenant_id, client_id, account_id, client_type, 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 set_client_wake_sent(tenant_id, client_id, reason=None, timestamp=None):
"""Vermerkt ein erfolgreich abgesetztes FCM-Aufwachsignal."""
db = get_db()
db.execute(
'UPDATE ws_clients SET last_wake_at = ?, last_wake_reason = ? '
'WHERE tenant_id = ? AND client_id = ?',
(timestamp if timestamp is not None else now(), reason, tenant_id, client_id)
)
db.commit()
def upsert_push_token(tenant_id, client_id, account_id, token, client_type,
platform=None, auto_position=False):
"""Speichert bzw. aktualisiert ein FCM-Token.
Das Token ist projektweit eindeutig. Meldet sich derselbe Browser nach
einem Neuladen mit einer neuen Client-ID an, wird der bestehende Eintrag
verschoben, statt ein zweites Token anzulegen. Ältere Tokens derselben
Client-ID werden entfernt, damit nach einer Token-Rotation keine doppelten
Wake-Signale entstehen.
"""
db = get_db()
current = now()
db.execute(
'DELETE FROM ws_push_tokens '
'WHERE tenant_id = ? AND client_id = ? AND token <> ?',
(tenant_id, client_id, token)
)
db.execute(
'''INSERT INTO ws_push_tokens
(tenant_id, client_id, account_id, token, client_type,
platform, auto_position, invalid, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
ON CONFLICT(token) DO UPDATE SET
tenant_id = excluded.tenant_id,
client_id = excluded.client_id,
account_id = excluded.account_id,
client_type = excluded.client_type,
platform = excluded.platform,
auto_position = excluded.auto_position,
invalid = 0,
updated_at = excluded.updated_at''',
(tenant_id, client_id, account_id, token, client_type,
platform, 1 if auto_position else 0, current, current)
)
db.commit()
def delete_push_token(tenant_id, token=None, client_id=None, account_id=None):
"""Entfernt ein FCM-Token gezielt über Token oder Client-ID."""
clauses = ['tenant_id = ?']
params = [tenant_id]
if token:
clauses.append('token = ?')
params.append(token)
if client_id:
clauses.append('client_id = ?')
params.append(client_id)
if account_id is not None:
clauses.append('account_id = ?')
params.append(account_id)
if len(clauses) == 1:
return
db = get_db()
db.execute(
f'DELETE FROM ws_push_tokens WHERE {" AND ".join(clauses)}',
tuple(params)
)
db.commit()
def get_push_token(tenant_id, client_id):
"""Liefert das zuletzt aktualisierte, gültige Token eines Clients."""
return get_db().execute(
'''SELECT * FROM ws_push_tokens
WHERE tenant_id = ? AND client_id = ? AND invalid = 0
ORDER BY updated_at DESC, id DESC LIMIT 1''',
(tenant_id, client_id)
).fetchone()
def mark_push_token_invalid(token):
"""Markiert ein von FCM abgelehntes Token als ungültig."""
db = get_db()
db.execute(
'UPDATE ws_push_tokens SET invalid = 1, updated_at = ? WHERE token = ?',
(now(), token)
)
db.commit()
def _offline_mobile_wake_query(tenant_id, disconnected_before,
re_wake_before=None, group_id=None,
auto_position_only=False, client_id=None,
limit=500):
sql = [
'''SELECT c.tenant_id, c.client_id, c.account_id, c.client_type,
c.disconnected_at, c.last_wake_at, c.last_wake_reason,
p.token, p.platform, p.auto_position
FROM ws_clients c
JOIN ws_push_tokens p
ON p.id = (
SELECT p2.id FROM ws_push_tokens p2
WHERE p2.tenant_id = c.tenant_id
AND p2.client_id = c.client_id
AND p2.invalid = 0
ORDER BY p2.updated_at DESC, p2.id DESC
LIMIT 1
)
WHERE c.tenant_id = ?
AND c.client_type IN ('group_view', 'dispatcher_mobile')
AND c.disconnected_at IS NOT NULL
AND c.disconnected_at <= ?'''
]
params = [tenant_id, disconnected_before]
if client_id is not None:
sql.append('AND c.client_id = ?')
params.append(client_id)
if re_wake_before is not None:
sql.append(
'AND (c.last_wake_at IS NULL OR c.last_wake_at <= ?)'
)
params.append(re_wake_before)
if auto_position_only:
sql.append("AND (c.client_type = 'dispatcher_mobile' OR p.auto_position = 1)")
if group_id is not None:
sql.append(
'''AND EXISTS (
SELECT 1 FROM group_accounts ga
WHERE ga.tenant_id = c.tenant_id
AND ga.account_id = c.account_id
AND ga.group_id = ?
)'''
)
params.append(group_id)
sql.append('ORDER BY c.disconnected_at ASC LIMIT ?')
params.append(max(1, int(limit)))
return ' '.join(sql), tuple(params)
def offline_mobile_wake_candidates(tenant_id, disconnected_before,
re_wake_before=None, group_id=None,
auto_position_only=False, client_id=None,
limit=500):
"""Liefert offline mobile Clients mit gültigem FCM-Token.
``disconnected_before`` ist der Spätzeitpunkt, zu dem die Trennung
eingetreten sein muss (für den regulären Offline-Timeout).
``re_wake_before`` verhindert zu häufige Wiederholungen; ``None`` hebt
die Sperre auf (manueller Aufruf).
``auto_position_only`` berücksichtigt nur Gruppen-Views, bei denen die
automatische Positionsübertragung aktiviert ist.
"""
sql, params = _offline_mobile_wake_query(
tenant_id,
disconnected_before,
re_wake_before=re_wake_before,
group_id=group_id,
auto_position_only=auto_position_only,
client_id=client_id,
limit=limit,
)
return get_db().execute(sql, params).fetchall()
def claim_offline_mobile_wakes(tenant_id, disconnected_before,
re_wake_before=None, group_id=None,
auto_position_only=False, client_id=None,
reason='offline', limit=500):
"""Reserviert fällige Wake-Kandidaten prozessübergreifend.
Mehrere WSGI-Worker dürfen nicht dasselbe FCM-Signal senden. Deshalb
werden die Kandidaten in einer ``BEGIN IMMEDIATE``-Transaktion gelesen
und ihr ``last_wake_at`` sofort gesetzt. Der tatsächliche FCM-Versand
erfolgt erst nach dem Commit.
"""
db = get_db()
if db.in_transaction:
db.commit()
db.execute('BEGIN IMMEDIATE')
try:
sql, params = _offline_mobile_wake_query(
tenant_id,
disconnected_before,
re_wake_before=re_wake_before,
group_id=group_id,
auto_position_only=auto_position_only,
client_id=client_id,
limit=limit,
)
rows = db.execute(sql, params).fetchall()
current = now()
for row in rows:
db.execute(
'UPDATE ws_clients SET last_wake_at = ?, last_wake_reason = ? '
'WHERE tenant_id = ? AND client_id = ?',
(current, reason, tenant_id, row['client_id'])
)
db.commit()
return rows
except Exception:
db.rollback()
raise
def cleanup_orphan_push_tokens(max_age_seconds):
"""Entfernt ungültige sowie verwaiste, lange nicht aktualisierte Tokens."""
db = get_db()
cutoff = now() - max_age_seconds
db.execute(
'DELETE FROM ws_push_tokens WHERE invalid = 1'
)
db.execute(
'''DELETE FROM ws_push_tokens
WHERE updated_at < ?
AND NOT EXISTS (
SELECT 1 FROM ws_clients c
WHERE c.tenant_id = ws_push_tokens.tenant_id
AND c.client_id = ws_push_tokens.client_id
)''',
(cutoff,)
)
db.commit()
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_push_tokens 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()