opencode ergebnis V0.1

This commit is contained in:
concierge committed 2026-10-23 00:05:06 +02:00
1 parent 61d86a3d83
commit 7e498ebc3f
71 files changed
+28982 -46

No files matched your search

+4
View File
@@ -0,0 +1,4 @@
from .broker import WebSocketBroker
from .protocol import WSMessage
broker = WebSocketBroker()
+754
View File
@@ -0,0 +1,754 @@
"""
WebSocket Broker - Kernkomponente für Realtime-Kommunikation
Der Broker nimmt Nachrichten aus WebSocket-Verbindungen (und aus HTTP-Handlern)
entgegen, wertet den Code aus, bestimmt den erlaubten Empfängerkreis und stellt
die Nachricht zu.
Wichtige Regeln aus der Spezifikation:
- Code < 100: rein interne Nachrichten (z. B. Authentifizierung, Heartbeat).
- Code 100/200/300: State- bzw. Positionsänderungen an Dispatcher, Beobachter
und die jeweils betroffene Gruppe.
- Code 1000/1100/2000: Chat-/Broadcast-Nachrichten. Diese werden persistiert,
damit sie bei einer späteren Anmeldung als "Late Entry" nachgeliefert werden
können. Nachrichten, die älter als LATE_ENTRY_MAX_AGE_HOURS (Default 8h) sind,
werden gelöscht.
"""
import json
import time
from datetime import datetime, timedelta, timezone
from flask import current_app
from cmbnet.db import get_db
from cmbnet.services.groups_service import GroupsService
from cmbnet.ws.protocol import WSMessage
class WebSocketBroker:
def __init__(self):
# connections[tenant_id][account_id] = {
# 'ws': <WebSocket-Objekt>,
# 'role': <Rolle des Accounts>,
# 'group_id': <verknüpfte Gruppe oder None>,
# }
self.connections = {}
# authenticated[tenant_id][account_id] = True
# Erst nach erfolgreichem Code-0-Handshake darf ein Client Nachrichten
# über die Verbindung senden.
self.authenticated = {}
# ------------------------------------------------------------------
# Verbindungen und Authentifizierung
# ------------------------------------------------------------------
def register_connection(self, tenant_id, account_id, ws, role=None, group_id=None):
"""Registriert eine neue, noch nicht authentifizierte Verbindung.
Rolle und Gruppenzuordnung werden direkt mitgespeichert. Sie werden
später für die Empfängerermittlung und für das Cleanup benötigt.
"""
db = get_db()
account = db.execute(
'SELECT role FROM accounts WHERE id = ? AND tenant_id = ?',
(account_id, tenant_id)
).fetchone()
if not account:
return False
if role is None:
role = account['role']
# Für Gruppen-Accounts die zugehörige Gruppe ermitteln. Ein Account der
# Rolle "Gruppe" ist genau einer Gruppe zugeordnet.
if group_id is None and role == 'Gruppe':
group = db.execute(
'SELECT id FROM groups WHERE account_id = ? AND tenant_id = ?',
(account_id, tenant_id)
).fetchone()
group_id = group['id'] if group else None
if tenant_id not in self.connections:
self.connections[tenant_id] = {}
# Eine neue Verbindung muss den Token-Handshake erneut durchlaufen.
# Ein eventuell noch gesetzter Auth-Status einer älteren Verbindung
# desselben Accounts darf nicht übernommen werden.
authenticated = self.authenticated.get(tenant_id)
if authenticated:
authenticated.pop(account_id, None)
self.connections[tenant_id][account_id] = {
'ws': ws,
'role': role,
'group_id': group_id,
'last_ping': datetime.now()
}
return True
def is_authenticated(self, tenant_id, account_id):
"""Prüft, ob eine Verbindung den Code-0-Handshake erfolgreich absolviert hat."""
return self.authenticated.get(tenant_id, {}).get(account_id, False)
def authenticate(self, tenant_id, account_id, token):
"""Authentifiziert eine Verbindung anhand des Einmal-Tokens (Code 0)."""
db = get_db()
token_row = db.execute(
'SELECT * FROM ws_tokens WHERE token = ? AND tenant_id = ? '
'AND account_id = ? AND used = 0',
(token, tenant_id, account_id)
).fetchone()
if not token_row:
return False
# Ablaufzeit prüfen (Tokens sind nur kurzzeitig gültig).
if token_row['expires_at']:
try:
expires = datetime.fromisoformat(token_row['expires_at'].replace('Z', '+00:00'))
# SQLite liefert naive Zeitstempel; ein Vergleich mit einer
# zeitzonenbehafteten Zeit wäre nicht möglich.
if expires.tzinfo is not None:
expires = expires.astimezone().replace(tzinfo=None)
if expires < datetime.now():
return False
except ValueError:
return False
# Token darf nur einmal verwendet werden.
db.execute('UPDATE ws_tokens SET used = 1 WHERE id = ?', (token_row['id'],))
db.commit()
if tenant_id not in self.authenticated:
self.authenticated[tenant_id] = {}
self.authenticated[tenant_id][account_id] = True
# Nach erfolgreicher Authentifizierung dürfen die gespeicherten
# Nachrichten der letzten 8 Stunden nachgeliefert werden.
self.send_late_entries(tenant_id, account_id)
return True
def remove_connection(self, tenant_id, account_id, ws=None):
"""Entfernt eine Verbindung.
Wenn ein Account mehrere Tabs/Verbindungen öffnet, wird nur die
tatsächlich beendete Verbindung entfernt (ws-Vergleich), nicht die
zuletzt registrierte.
"""
connections = self.connections.get(tenant_id)
if connections and account_id in connections:
if ws is None or connections[account_id].get('ws') is ws:
del connections[account_id]
# Nur wenn die tatsächlich beendete Verbindung die aktuelle
# war, darf auch der Authentifizierungsstatus entfernt werden.
authenticated = self.authenticated.get(tenant_id)
if authenticated and account_id in authenticated:
del authenticated[account_id]
def _get_connection(self, tenant_id, account_id):
return self.connections.get(tenant_id, {}).get(account_id)
# ------------------------------------------------------------------
# Late Entry
# ------------------------------------------------------------------
def send_late_entries(self, tenant_id, account_id):
"""Sendet gespeicherte Nachrichten (Code >= 1000) der letzten 8 Stunden.
Es werden ausschließlich Nachrichten zugestellt, für die der Account
laut Protokoll berechtigt ist. Die Zustellung erfolgt chronologisch.
Anschließend werden abgelaufene Nachrichten gelöscht.
"""
db = get_db()
cutoff = self._late_entry_cutoff()
messages = db.execute(
'SELECT * FROM ws_messages_store WHERE tenant_id = ? AND ts >= ? '
'ORDER BY ts ASC, id ASC',
(tenant_id, cutoff)
).fetchall()
conn = self._get_connection(tenant_id, account_id)
if not conn:
return
for msg_row in messages:
if not self._is_allowed_for_client(tenant_id, account_id, msg_row):
continue
msg = WSMessage(
sender_id=msg_row['sender_id'],
receiver_id=msg_row['receiver_id'],
code=msg_row['code'],
msg=msg_row['msg'],
ts=msg_row['ts']
)
self._send(tenant_id, account_id, msg)
# Abgelaufene Nachrichten werden bei jeder Anmeldung aufgeräumt.
self.cleanup_old_messages(tenant_id)
def _late_entry_cutoff(self):
"""Zeitstempel (ms), ab dem gespeicherte Nachrichten noch zustellbar sind."""
max_age_hours = current_app.config.get('LATE_ENTRY_MAX_AGE_HOURS', 8)
return int((datetime.now() - timedelta(hours=max_age_hours)).timestamp() * 1000)
def cleanup_old_messages(self, tenant_id=None):
"""Löscht persistierte Nachrichten, die älter als die Late-Entry-Frist sind."""
db = get_db()
cutoff = self._late_entry_cutoff()
if tenant_id is None:
db.execute('DELETE FROM ws_messages_store WHERE ts < ?', (cutoff,))
else:
db.execute(
'DELETE FROM ws_messages_store WHERE tenant_id = ? AND ts < ?',
(tenant_id, cutoff)
)
db.commit()
def _is_allowed_for_client(self, tenant_id, account_id, msg_row):
"""Prüft, ob eine persistierte Nachricht für diesen Client bestimmt ist."""
db = get_db()
account = db.execute(
'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?',
(account_id, tenant_id)
).fetchone()
if not account:
return False
role = account['role']
code = msg_row['code']
# Code 1000: Broadcast an Dispatcher, Beobachter und alle Gruppen.
if code == 1000:
return role in ('Dispatcher', 'Beobachter', 'Gruppe')
# Code 1100: Dispatcher, Beobachter und die angesprochene Gruppe.
if code == 1100:
if role in ('Dispatcher', 'Beobachter'):
return True
if role == 'Gruppe':
group = db.execute(
'SELECT id FROM groups WHERE account_id = ? AND tenant_id = ?',
(account_id, tenant_id)
).fetchone()
return bool(group and msg_row['receiver_id'] == group['id'])
return False
# Code 2000: nur Dispatcher und Beobachter.
if code == 2000:
return role in ('Dispatcher', 'Beobachter')
return False
# ------------------------------------------------------------------
# Nachrichtenverarbeitung
# ------------------------------------------------------------------
def route_message(self, tenant_id, message, apply_business=False):
"""Wertet den Code aus, persistiert ggf. und stellt die Nachricht zu.
``apply_business`` wird nur für Nachrichten verwendet, die direkt über
die WebSocket-Route eingehen. Serverintern erzeugte Nachrichten (z. B.
aus der Admin-API) haben die Datenbank bereits aktualisiert und dürfen
deshalb nicht ein zweites Mal angewendet werden.
"""
db = get_db()
# Absender muss zum Mandanten gehören. Die Absender-ID wird in der
# WebSocket-Route aus der Session gesetzt und kann nicht gefälscht
# werden.
sender = db.execute(
'SELECT * FROM accounts WHERE id = ? AND tenant_id = ?',
(message.sender_id, tenant_id)
).fetchone()
if not sender:
return
code = message.code
# Code 0 wird ausschließlich in der WebSocket-Route (Handshake)
# verarbeitet und niemals weitergeleitet.
if code <= 0:
return
# Code 1 sendet ausschließlich der Server (Heartbeat-Routine).
# Nachrichten dieses Typs von Clients werden ignoriert.
if code == 1:
return
# Code 2 ist die Antwort eines Clients auf den Heartbeat. Sie wird nur
# an Dispatcher-Views weitergeleitet und nicht gespeichert.
if code == 2:
self._deliver(tenant_id, message, sender)
return
# Sonstige interne Codes (< 100) werden nicht an die Oberfläche gegeben.
if code < 100:
return
# Ab hier: fachliche Nachrichten (>= 100).
# Zustandsänderungen, die ein Client per WebSocket meldet, werden vor
# der Zustellung in der Datenbank persistiert. So sind sie auch nach
# einem Neuladen der Seite wieder sichtbar.
if apply_business and code in (100, 200, 300):
if not self._apply_business_change(tenant_id, message, sender):
return
message = self._prepare_message(tenant_id, message, sender)
# Ab Code 1000 werden Nachrichten für die Late-Entry-Funktion
# gespeichert. Gespeichert wird die bereits aufbereitete Nachricht
# (bei Code 1100 inklusive Aliasname-Präfix).
if code >= 1000:
self._persist_message(tenant_id, message)
self._deliver(tenant_id, message, sender)
def _apply_business_change(self, tenant_id, message, sender):
"""Persistiert Code 100/200/300 aus einer WebSocket-Nachricht.
Gibt ``False`` zurück, wenn die Nachricht ungültig oder für den
Absender nicht erlaubt ist. In diesem Fall wird sie nicht zugestellt.
"""
payload = self._payload(message)
if not isinstance(payload, dict):
return False
if message.code == 100:
return self._apply_street_change(tenant_id, message, sender, payload)
if message.code == 200:
return self._apply_group_state_change(tenant_id, message, sender, payload)
if message.code == 300:
return self._apply_group_position_change(tenant_id, message, sender, payload)
return False
def _apply_street_change(self, tenant_id, message, sender, payload):
"""Wendet einen Straßen-State-Wechsel aus einer Code-100-Nachricht an."""
if sender['role'] not in ('Dispatcher', 'Administrator'):
return False
db = get_db()
street = None
street_id = payload.get('street_id')
if street_id is not None:
try:
street_id = int(street_id)
except (TypeError, ValueError):
return False
street = db.execute(
'SELECT * FROM streets WHERE id = ? AND tenant_id = ?',
(street_id, tenant_id)
).fetchone()
if not street and payload.get('name'):
street = db.execute(
'SELECT * FROM streets WHERE name = ? AND tenant_id = ?',
(str(payload['name']), tenant_id)
).fetchone()
if not street:
return False
new_state = payload.get('state')
if new_state not in ('unbearbeitet', 'zugewiesen', 'erledigt'):
return False
if 'group_id' in payload:
group_id = payload['group_id']
if group_id in ('', None):
group_id = None
else:
try:
group_id = int(group_id)
except (TypeError, ValueError):
return False
else:
group_id = street['group_id']
# Unbearbeitet bedeutet immer "keine Gruppe". Für "zugewiesen" ist
# dagegen eine gültige Gruppe erforderlich.
if new_state == 'unbearbeitet':
group_id = None
elif new_state == 'zugewiesen' and group_id is None:
return False
if group_id is not None:
group = db.execute(
'SELECT id FROM groups WHERE id = ? AND tenant_id = ?',
(group_id, tenant_id)
).fetchone()
if not group:
return False
old_state = street['state']
old_group_id = street['group_id']
changed = old_state != new_state or old_group_id != group_id
if changed:
db.execute(
'UPDATE streets SET state = ?, group_id = ?, updated_at = CURRENT_TIMESTAMP '
'WHERE id = ? AND tenant_id = ?',
(new_state, group_id, street['id'], tenant_id)
)
db.execute(
'''INSERT INTO street_state_history
(tenant_id, street_id, from_state, to_state, group_id, actor_account_id, reason)
VALUES (?, ?, ?, ?, ?, ?, ?)''',
(tenant_id, street['id'], old_state, new_state,
group_id, sender['id'], 'ws_code_100')
)
db.commit()
self._log_business(tenant_id, sender['id'], 'street.state_change', 'street',
street['id'], {'from': old_state, 'to': new_state,
'group_id': group_id})
# Für die Empfängerermittlung muss die alte Gruppe bekannt bleiben:
# Bei einem Gruppenwechsel erhält sowohl die alte als auch die neue
# Gruppe die Code-100-Nachricht.
message._old_group_id = old_group_id
message.msg = json.dumps({
'name': street['name'],
'state': new_state,
'actor': sender['id'],
'street_id': street['id'],
'group_id': group_id
}, ensure_ascii=False)
return True
def _apply_group_state_change(self, tenant_id, message, sender, payload):
"""Wendet einen Gruppen-State-Wechsel aus einer Code-200-Nachricht an."""
if sender['role'] not in ('Dispatcher', 'Administrator', 'Gruppe'):
return False
group_id = self._resolve_group_id(tenant_id, message, sender, payload)
if not group_id:
return False
db = get_db()
group = db.execute(
'SELECT * FROM groups WHERE id = ? AND tenant_id = ?',
(group_id, tenant_id)
).fetchone()
if not group:
return False
# Ein Gruppen-Account darf nur den Zustand seiner eigenen Gruppe ändern.
if sender['role'] == 'Gruppe' and group['account_id'] != sender['id']:
return False
new_state = payload.get('state')
if new_state not in ('offen', 'unterwegs', 'online', 'pausierend', 'fertig'):
return False
if new_state != group['state']:
db.execute(
'UPDATE groups SET state = ?, updated_at = CURRENT_TIMESTAMP '
'WHERE id = ? AND tenant_id = ?',
(new_state, group_id, tenant_id)
)
db.execute(
'''INSERT INTO group_state_history
(tenant_id, group_id, from_state, to_state, last_lat, last_lon,
last_pos_at, actor_account_id)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)''',
(tenant_id, group_id, group['state'], new_state,
group['last_lat'], group['last_lon'], group['last_pos_at'], sender['id'])
)
db.commit()
GroupsService.update_cache_entry(tenant_id, group_id, {'state': new_state})
self._log_business(tenant_id, sender['id'], 'group.state_change', 'group',
group_id, {'from': group['state'], 'to': new_state})
message.receiver_id = group_id
message.msg = json.dumps({
'group_id': group_id,
'state': new_state,
'actor': sender['id']
}, ensure_ascii=False)
return True
def _apply_group_position_change(self, tenant_id, message, sender, payload):
"""Wendet eine Positionsänderung aus einer Code-300-Nachricht an."""
if sender['role'] not in ('Dispatcher', 'Administrator', 'Gruppe'):
return False
group_id = self._resolve_group_id(tenant_id, message, sender, payload)
if not group_id:
return False
db = get_db()
group = db.execute(
'SELECT * FROM groups WHERE id = ? AND tenant_id = ?',
(group_id, tenant_id)
).fetchone()
if not group:
return False
if sender['role'] == 'Gruppe' and group['account_id'] != sender['id']:
return False
try:
lat = float(payload.get('lat'))
lon = float(payload.get('lon'))
except (TypeError, ValueError):
return False
if not (-90 <= lat <= 90 and -180 <= lon <= 180):
return False
# Der Server setzt den Zeitstempel, damit die Progressbar nicht durch
# manipulierbare Client-Zeitangaben verfälscht wird.
pos_at = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')
ts_ms = int(time.time() * 1000)
db.execute(
'UPDATE groups SET last_lat = ?, last_lon = ?, last_pos_at = ?, '
'updated_at = CURRENT_TIMESTAMP WHERE id = ? AND tenant_id = ?',
(lat, lon, pos_at, group_id, tenant_id)
)
db.execute(
'''INSERT INTO group_state_history
(tenant_id, group_id, from_state, to_state, last_lat, last_lon,
last_pos_at, actor_account_id)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)''',
(tenant_id, group_id, group['state'], group['state'],
lat, lon, pos_at, sender['id'])
)
db.commit()
GroupsService.update_cache_entry(tenant_id, group_id, {
'last_lat': lat,
'last_lon': lon,
'last_pos_at': pos_at
})
self._log_business(tenant_id, sender['id'], 'group.position_change', 'group',
group_id, {'lat': lat, 'lon': lon})
message.receiver_id = group_id
# Auch der Nachrichten-Zeitstempel wird serverseitig gesetzt, damit
# die Progressbar nicht von einer manipulierten Client-Uhr abhängt.
message.ts = ts_ms
message.msg = json.dumps({
'group_id': group_id,
'lat': lat,
'lon': lon,
'ts': ts_ms,
'actor': sender['id']
}, ensure_ascii=False)
return True
@staticmethod
def _log_business(tenant_id, actor_id, action, entity_type, entity_id, details):
"""Schreibt eine per WebSocket ausgelöste Änderung ins Transaktionslog."""
try:
db = get_db()
db.execute(
'INSERT INTO transaction_log '
'(tenant_id, actor_account_id, action, entity_type, entity_id, details) '
'VALUES (?, ?, ?, ?, ?, ?)',
(tenant_id, actor_id, action, entity_type, entity_id,
json.dumps(details, ensure_ascii=False))
)
db.commit()
from cmbnet.core.logging import write_transaction_log
actor = db.execute(
'SELECT name FROM accounts WHERE id = ? AND tenant_id = ?',
(actor_id, tenant_id)
).fetchone()
write_transaction_log(tenant_id, actor_id, actor['name'] if actor else None,
action, entity_type, entity_id, details)
except Exception as exc:
print(f'Transaction log error: {exc}')
def _prepare_message(self, tenant_id, message, sender):
"""Ergänzt Nachrichten um serverseitig abgeleitete Informationen."""
db = get_db()
payload = self._payload(message)
if message.code == 1100:
# Empfänger ist eine spezielle Gruppe. Die Gruppen-ID wird aus dem
# Payload oder dem receiver_id-Feld gelesen.
group_id = self._resolve_group_id(tenant_id, message, sender, payload)
group = self._fetch_group(tenant_id, group_id)
message.receiver_id = group_id
# Spezifikation: Dem Freitext wird der Aliasname der Gruppe
# vorangestellt. Ein bereits vorhandenes Präfix wird nicht doppelt
# gesetzt.
if group:
alias = group['aliasname'] or str(group['id'])
prefix = f'{alias}: '
text = message.msg if isinstance(message.msg, str) else json.dumps(message.msg)
if not text.startswith(prefix):
message.msg = prefix + text
elif message.code == 2000:
# Spezifikation: Inhalt ist JSON mit Gruppen-ID und Freitext.
group_id = self._resolve_group_id(tenant_id, message, sender, payload)
message.receiver_id = group_id
if isinstance(payload, dict):
if group_id and not payload.get('group_id'):
payload['group_id'] = group_id
message.msg = json.dumps(payload, ensure_ascii=False)
elif group_id:
message.msg = json.dumps(
{'group_id': group_id, 'text': message.msg},
ensure_ascii=False
)
return message
def _deliver(self, tenant_id, message, sender):
"""Stellt eine Nachricht an alle berechtigten, verbundenen Clients zu."""
for recipient_id in self._get_recipients(tenant_id, message, sender):
self._send(tenant_id, recipient_id, message)
def _send(self, tenant_id, account_id, message):
"""Sendet eine Nachricht, falls für den Account eine Verbindung besteht."""
# Erst nach erfolgreicher Token-Authentifizierung dürfen Nachrichten
# an einen Client zugestellt werden.
if not self.is_authenticated(tenant_id, account_id):
return
conn = self._get_connection(tenant_id, account_id)
if not conn:
return
try:
conn['ws'].send(message.to_json())
except Exception:
# Eine fehlerhafte Verbindung darf den Versand an andere Clients
# nicht verhindern. Das Aufräumen übernimmt die Route beim
# Schließen der Verbindung.
pass
def _get_recipients(self, tenant_id, message, sender):
"""Bestimmt den Empfängerkreis abhängig vom Nachrichtencode."""
db = get_db()
recipients = set()
code = message.code
payload = self._payload(message)
def add_accounts(roles):
placeholders = ','.join('?' for _ in roles)
rows = db.execute(
f'SELECT id FROM accounts WHERE tenant_id = ? AND role IN ({placeholders})',
(tenant_id, *roles)
).fetchall()
recipients.update(row['id'] for row in rows)
def add_group_account(group_id):
if not group_id:
return
group = db.execute(
'SELECT account_id FROM groups WHERE id = ? AND tenant_id = ?',
(group_id, tenant_id)
).fetchone()
if group and group['account_id']:
recipients.add(group['account_id'])
if code == 100:
# Dispatcher, Gast, Beobachter + die mit der Straße verknüpfte
# Gruppe. Bei einem Gruppenwechsel werden sowohl die alte als auch
# die neue Gruppe benachrichtigt.
add_accounts(('Dispatcher', 'Beobachter', 'Gast'))
group_ids = set()
group_id = payload.get('group_id') if isinstance(payload, dict) else None
if group_id not in (None, ''):
group_ids.add(group_id)
old_group_id = getattr(message, '_old_group_id', None)
if old_group_id is not None:
group_ids.add(old_group_id)
street_id = payload.get('street_id') if isinstance(payload, dict) else None
# Das Payload stammt aus dem vertrauenswürdigen Server-Code. Nur
# wenn keine Gruppen-ID enthalten ist, wird die Straße aus der
# Datenbank gelesen.
if street_id and not (isinstance(payload, dict) and 'group_id' in payload):
street = db.execute(
'SELECT group_id FROM streets WHERE id = ? AND tenant_id = ?',
(street_id, tenant_id)
).fetchone()
if street and street['group_id'] is not None:
group_ids.add(street['group_id'])
for group_id in group_ids:
add_group_account(group_id)
elif code in (200, 300):
# Dispatcher, Beobachter + die betroffene Gruppe.
add_accounts(('Dispatcher', 'Beobachter'))
group_id = self._resolve_group_id(tenant_id, message, sender, payload)
add_group_account(group_id)
elif code == 1000:
# Broadcast an Dispatcher, Beobachter und alle Gruppen.
add_accounts(('Dispatcher', 'Beobachter', 'Gruppe'))
elif code == 1100:
# Dispatcher, Beobachter + die spezielle Gruppe.
add_accounts(('Dispatcher', 'Beobachter'))
add_group_account(message.receiver_id)
elif code == 2000:
# Eine Gruppe sendet an Dispatcher und Beobachter.
add_accounts(('Dispatcher', 'Beobachter'))
elif code == 2:
# Heartbeat-Antworten werden nur an Dispatcher-Views weitergegeben.
add_accounts(('Dispatcher',))
return recipients
def _persist_message(self, tenant_id, message):
"""Speichert Nachrichten mit Code >= 1000 für die Late-Entry-Funktion."""
db = get_db()
db.execute(
'INSERT INTO ws_messages_store '
'(tenant_id, sender_id, receiver_id, code, ts, msg) '
'VALUES (?, ?, ?, ?, ?, ?)',
(tenant_id, message.sender_id, message.receiver_id,
message.code, message.ts, message.msg)
)
db.commit()
# ------------------------------------------------------------------
# Hilfsfunktionen
# ------------------------------------------------------------------
@staticmethod
def _payload(message):
"""Liefert den JSON-Payload einer Nachricht oder None."""
if isinstance(message.msg, dict):
return message.msg
if not isinstance(message.msg, str):
return None
try:
data = json.loads(message.msg)
return data if isinstance(data, dict) else None
except (ValueError, TypeError):
return None
def _resolve_group_id(self, tenant_id, message, sender, payload):
"""Ermittelt die betroffene Gruppen-ID aus Payload, receiver_id oder Absender."""
group_id = payload.get('group_id') if isinstance(payload, dict) else None
if group_id is None:
group_id = message.receiver_id
if group_id is None and sender is not None and message.code in (200, 300, 2000):
# Bei Gruppen-Nachrichten ist der Absender die Gruppe selbst.
group = get_db().execute(
'SELECT id FROM groups WHERE account_id = ? AND tenant_id = ?',
(sender['id'], tenant_id)
).fetchone()
group_id = group['id'] if group else None
if group_id is not None:
try:
group_id = int(group_id)
except (TypeError, ValueError):
group_id = None
return group_id
@staticmethod
def _fetch_group(tenant_id, group_id):
"""Lädt eine Gruppe mandantenspezifisch."""
if not group_id:
return None
return get_db().execute(
'SELECT id, aliasname FROM groups WHERE id = ? AND tenant_id = ?',
(group_id, tenant_id)
).fetchone()
+77
View File
@@ -0,0 +1,77 @@
"""
Heartbeat-Routine für WebSocket-Verbindungen
Der Server sendet jede Minute eine Nachricht mit Code 1 an alle
authentifizierten Clients. Die Clients antworten mit Code 2; diese Antwort
wird vom Broker ausschließlich an Dispatcher-Views weitergeleitet.
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.protocol import WSMessage
class HeartbeatManager:
def __init__(self, interval=60):
self.interval = interval
self.running = False
self.app = None
self._timer = None
def start(self, app=None, interval=None):
"""Startet die zyklische Heartbeat-Routine."""
# Die App-Referenz wird benötigt, um im Hintergrund-Thread einen
# Flask-App-Kontext für Datenbankzugriffe öffnen zu können.
if app is not None:
self.app = app
if interval is not None:
self.interval = interval
if self.running:
return
self.running = True
self._send_heartbeat()
def stop(self):
"""Stoppt die Heartbeat-Routine."""
self.running = False
if self._timer is not None:
self._timer.cancel()
self._timer = None
def _send_heartbeat(self):
if not self.running:
return
msg = WSMessage(sender_id=0, code=1, msg='ping')
# Nur authentifizierte Verbindungen erhalten einen Heartbeat.
for tenant_id, connections in list(broker.connections.items()):
for account_id, conn_info in list(connections.items()):
if not broker.is_authenticated(tenant_id, account_id):
continue
try:
conn_info['ws'].send(msg.to_json())
except Exception:
# Defekte Verbindungen werden beim Schließen durch die
# WebSocket-Route entfernt.
pass
# Abgelaufene persistierte Nachrichten löschen.
if self.app is not None:
try:
with self.app.app_context():
broker.cleanup_old_messages()
except Exception as exc:
print(f'Heartbeat cleanup error: {exc}')
# Nächsten Heartbeat planen. Der Timer läuft als Daemon, damit er den
# Prozess beim Beenden nicht blockiert.
self._timer = Timer(self.interval, self._send_heartbeat)
self._timer.daemon = True
self._timer.start()
heartbeat_manager = HeartbeatManager()
+44
View File
@@ -0,0 +1,44 @@
"""
WebSocket Protokoll Definition
"""
import json
from datetime import datetime
class WSMessage:
def __init__(self, sender_id=None, receiver_id=None, code=0, msg="", ts=None):
self.sender_id = sender_id
self.receiver_id = receiver_id
self.code = code
self.msg = msg
self.ts = ts or int(datetime.now().timestamp() * 1000)
def to_dict(self):
return {
'sender_id': self.sender_id,
'receiver_id': self.receiver_id,
'code': self.code,
'ts': self.ts,
'msg': self.msg
}
def to_json(self):
return json.dumps(self.to_dict())
@classmethod
def from_dict(cls, data):
return cls(
sender_id=data.get('sender_id'),
receiver_id=data.get('receiver_id'),
code=data.get('code', 0),
msg=data.get('msg', ''),
ts=data.get('ts')
)
@classmethod
def from_json(cls, json_str):
try:
data = json.loads(json_str)
return cls.from_dict(data)
except:
return None
+70
View File
@@ -0,0 +1,70 @@
"""
WebSocket Routes
Ablauf einer Verbindung:
1. Client verbindet sich mit /<tenant>/ws.
2. Client sendet Code 0 mit dem zuvor über die API geholten Einmal-Token.
3. Erst nach erfolgreicher Prüfung dürfen fachliche Nachrichten gesendet
werden. Vorher wird die Verbindung geschlossen.
"""
from flask import session
from cmbnet.extensions import sock
from cmbnet.ws import broker
from cmbnet.ws.protocol import WSMessage
@sock.route('/<tenant>/ws')
def ws(ws, tenant):
"""WebSocket Endpoint"""
from cmbnet.db import get_db
db = get_db()
tenant_row = db.execute('SELECT * FROM tenants WHERE code = ?', (tenant,)).fetchone()
if not tenant_row:
ws.close()
return
tenant_id = tenant_row['id']
account_id = session.get('account_id')
if not account_id:
ws.close()
return
# Verbindung registrieren, aber noch nicht als authentifiziert markieren.
if not broker.register_connection(tenant_id, account_id, ws):
ws.close()
return
try:
while True:
data = ws.receive()
if data is None:
break
msg = WSMessage.from_json(data)
if not msg:
continue
# Die Absender-ID stammt immer aus der Session und kann vom Client
# nicht gefälscht werden.
msg.sender_id = account_id
# Code 0: Authentifizierung über den Einmal-Token.
if msg.code == 0:
if not broker.authenticate(tenant_id, account_id, msg.msg):
ws.close()
break
continue
# Fachliche Nachrichten sind erst nach erfolgreicher
# Authentifizierung erlaubt.
if not broker.is_authenticated(tenant_id, account_id):
ws.close()
break
broker.route_message(tenant_id, msg, apply_business=True)
except Exception as exc:
print(f'WebSocket error: {exc}')
finally:
broker.remove_connection(tenant_id, account_id, ws)