385 lines
13 KiB
Python
385 lines
13 KiB
Python
"""FCM-Signaldienst für mobile PWA-Clients.
|
|
|
|
FCM transportiert ausschließlich ein Aufwachsignal. Die fachlichen Inhalte
|
|
bleiben in der persistenten WebSocket-Queue des Brokers. Das Modul kapselt
|
|
die optionale ``firebase-admin``-Abhängigkeit, damit die Anwendung auch ohne
|
|
Firebase-Konfiguration vollständig startet.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import threading
|
|
from datetime import timedelta
|
|
from pathlib import Path
|
|
|
|
from flask import current_app, url_for
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _config_bool(value):
|
|
if isinstance(value, bool):
|
|
return value
|
|
return str(value or '').strip().lower() in ('1', 'true', 'yes', 'on')
|
|
|
|
|
|
def fcm_enabled(config=None):
|
|
"""Gibt zurück, ob FCM in der aktuellen Konfiguration aktiviert ist."""
|
|
config = config or current_app.config
|
|
return _config_bool(config.get('FCM_ENABLED', False))
|
|
|
|
|
|
def _web_config(config):
|
|
"""Baut die öffentliche Firebase-Webkonfiguration.
|
|
|
|
Diese Werte sind bewusst öffentlich. Sie dürfen nicht mit dem
|
|
Service-Account-Schlüssel verwechselt werden.
|
|
"""
|
|
project_id = str(config.get('FCM_WEB_PROJECT_ID')
|
|
or config.get('FCM_PROJECT_ID') or '').strip()
|
|
return {
|
|
'apiKey': str(config.get('FCM_WEB_API_KEY', '')).strip(),
|
|
'authDomain': str(
|
|
config.get('FCM_WEB_AUTH_DOMAIN')
|
|
or (f'{project_id}.firebaseapp.com' if project_id else '')
|
|
).strip(),
|
|
'projectId': project_id,
|
|
'storageBucket': str(
|
|
config.get('FCM_WEB_STORAGE_BUCKET')
|
|
or (f'{project_id}.appspot.com' if project_id else '')
|
|
).strip(),
|
|
'messagingSenderId': str(
|
|
config.get('FCM_WEB_MESSAGING_SENDER_ID', '')
|
|
).strip(),
|
|
'appId': str(config.get('FCM_WEB_APP_ID', '')).strip(),
|
|
}
|
|
|
|
|
|
def public_fcm_config(config=None):
|
|
"""Liefert die für Browser und Service Worker bestimmte Konfiguration.
|
|
|
|
Der Service Worker benötigt nur die öffentlichen Firebase-Webdaten. Der
|
|
Service-Account-Schlüssel bleibt ausschließlich auf dem Server.
|
|
"""
|
|
config = config or current_app.config
|
|
firebase_config = _web_config(config)
|
|
vapid_key = str(config.get('FCM_VAPID_KEY', '')).strip()
|
|
required_web = (
|
|
firebase_config['apiKey'],
|
|
firebase_config['projectId'],
|
|
firebase_config['messagingSenderId'],
|
|
firebase_config['appId'],
|
|
vapid_key,
|
|
)
|
|
enabled = fcm_enabled(config) and all(required_web)
|
|
|
|
try:
|
|
icon_url = url_for('static', filename='img/icon-192.png')
|
|
wake_url = url_for('wake')
|
|
except Exception:
|
|
# Die Funktion kann auch außerhalb eines Request-Kontexts aufgerufen
|
|
# werden (z. B. in Tests). Dann bleiben die Pfade relativ.
|
|
icon_url = '/static/img/icon-192.png'
|
|
wake_url = '/wake'
|
|
|
|
return {
|
|
'enabled': bool(enabled),
|
|
'sdkVersion': str(config.get('FCM_WEB_SDK_VERSION', '10.14.1')),
|
|
'vapidKey': vapid_key,
|
|
'firebase': firebase_config,
|
|
'title': str(config.get('DISPLAY_TITLE', '20*C+M+B+27')),
|
|
'icon': icon_url,
|
|
'wakeUrl': wake_url,
|
|
'notificationTag': 'cmbnet-wake',
|
|
}
|
|
|
|
|
|
class FcmService:
|
|
"""Kapselt Initialisierung und Versand von FCM-Signalen."""
|
|
|
|
def __init__(self):
|
|
self._lock = threading.Lock()
|
|
self._app = None
|
|
self._initialized = False
|
|
self._error = None
|
|
|
|
def _server_config(self):
|
|
config = current_app.config
|
|
if not fcm_enabled(config):
|
|
return None, 'FCM ist deaktiviert.'
|
|
if not (config.get('FCM_SERVICE_ACCOUNT_FILE')
|
|
or config.get('FCM_SERVICE_ACCOUNT_JSON')):
|
|
return None, 'FCM-Service-Account ist nicht konfiguriert.'
|
|
return config, None
|
|
|
|
def server_ready(self):
|
|
"""Prüft, ob der Server FCM grundsätzlich senden könnte."""
|
|
_config, error = self._server_config()
|
|
return error is None
|
|
|
|
def server_status(self):
|
|
"""Prüft die tatsächliche Sendefähigkeit inklusive firebase-admin.
|
|
|
|
``server_ready`` prüft nur die Konfiguration. Für eine verständliche
|
|
Fehlermeldung im Wake-Endpunkt muss auch die Initialisierung von
|
|
``firebase-admin`` berücksichtigt werden (fehlendes Paket, ungültiger
|
|
Service-Account usw.).
|
|
"""
|
|
_config, error = self._server_config()
|
|
if error:
|
|
return {'ready': False, 'error': error}
|
|
app, error = self._ensure_app()
|
|
return {'ready': app is not None, 'error': error}
|
|
|
|
def _ensure_app(self):
|
|
"""Initialisiert firebase-admin genau einmal pro Workerprozess."""
|
|
config, error = self._server_config()
|
|
if error:
|
|
return None, error
|
|
if self._initialized:
|
|
return self._app, self._error
|
|
|
|
with self._lock:
|
|
if self._initialized:
|
|
return self._app, self._error
|
|
self._initialized = True
|
|
try:
|
|
import firebase_admin
|
|
from firebase_admin import credentials
|
|
except ImportError:
|
|
self._error = (
|
|
'firebase-admin ist nicht installiert. '
|
|
'Bitte requirements.txt installieren.'
|
|
)
|
|
logger.warning(self._error)
|
|
self._log_debug({'event': 'init-error', 'error': self._error})
|
|
return None, self._error
|
|
|
|
try:
|
|
try:
|
|
self._app = firebase_admin.get_app('cmbnet')
|
|
except ValueError:
|
|
credential = self._load_credential(credentials, config)
|
|
options = {}
|
|
project_id = str(
|
|
config.get('FCM_PROJECT_ID') or ''
|
|
).strip()
|
|
if project_id:
|
|
options['projectId'] = project_id
|
|
self._app = firebase_admin.initialize_app(
|
|
credential, options, name='cmbnet'
|
|
)
|
|
except Exception as exc:
|
|
self._error = f'FCM-Initialisierung fehlgeschlagen: {exc}'
|
|
logger.exception(self._error)
|
|
self._log_debug({'event': 'init-error', 'error': self._error})
|
|
return None, self._error
|
|
|
|
return self._app, None
|
|
|
|
@staticmethod
|
|
def _load_credential(credentials, config):
|
|
inline = config.get('FCM_SERVICE_ACCOUNT_JSON')
|
|
if inline:
|
|
data = json.loads(inline)
|
|
return credentials.Certificate(data)
|
|
|
|
path = Path(str(config.get('FCM_SERVICE_ACCOUNT_FILE', ''))).expanduser()
|
|
if not path.is_absolute():
|
|
path = Path(current_app.root_path).parent / path
|
|
if not path.is_file():
|
|
raise FileNotFoundError(f'Service-Account-Datei fehlt: {path}')
|
|
return credentials.Certificate(str(path))
|
|
|
|
@staticmethod
|
|
def _token_fingerprint(token):
|
|
"""Verkürzter, stabiler Token-Fingerabdruck für Logs (kein Klartext)."""
|
|
if not token:
|
|
return '-'
|
|
return hashlib.sha256(str(token).encode('utf-8')).hexdigest()[:12]
|
|
|
|
@staticmethod
|
|
def _describe_send_error(token, exception):
|
|
"""Formatiert einen FCM-Fehler und entfernt das Token aus dem Text."""
|
|
name = type(exception).__name__ if exception is not None else 'UnknownError'
|
|
text = str(exception or '').strip()
|
|
if token:
|
|
text = text.replace(str(token), '<token>')
|
|
if text:
|
|
return f'{name}: {text}'
|
|
return name
|
|
|
|
@staticmethod
|
|
def _log_debug(payload):
|
|
"""Schreibt eine FCM-Diagnosezeile in das separate FCM-Log."""
|
|
tenant_id = None
|
|
try:
|
|
from flask import g
|
|
tenant_id = getattr(g, 'tenant_id', None)
|
|
except Exception:
|
|
pass
|
|
try:
|
|
from cmbnet.core.logging import write_fcm_debug_log
|
|
write_fcm_debug_log(payload, tenant_id=tenant_id)
|
|
except Exception:
|
|
# Diagnose darf den Versand nie beeinflussen.
|
|
pass
|
|
|
|
def send_wake(self, tokens, reason='wake'):
|
|
"""Sendet ein reines Daten-Signal an die angegebenen FCM-Tokens.
|
|
|
|
Rückgabe enthält Zähler und die von FCM als ungültig gemeldeten
|
|
Tokens. Es werden keine Chat- oder Positionsdaten übertragen.
|
|
"""
|
|
tokens = [str(token).strip() for token in tokens if token]
|
|
tokens = list(dict.fromkeys(tokens))
|
|
result = {
|
|
'configured': False,
|
|
'requested': len(tokens),
|
|
'sent': 0,
|
|
'failed': 0,
|
|
'sent_tokens': [],
|
|
'invalid_tokens': [],
|
|
'errors': [],
|
|
}
|
|
if not tokens:
|
|
return result
|
|
|
|
app, error = self._ensure_app()
|
|
if error or app is None:
|
|
result['error'] = error
|
|
self._log_debug({
|
|
'event': 'wake',
|
|
'reason': reason,
|
|
'requested': len(tokens),
|
|
'sent': 0,
|
|
'failed': 0,
|
|
'error': error,
|
|
})
|
|
return result
|
|
|
|
result['configured'] = True
|
|
config = current_app.config
|
|
ttl_seconds = max(
|
|
60, int(config.get('FCM_SIGNAL_TTL_SECONDS', 600))
|
|
)
|
|
|
|
from firebase_admin import messaging
|
|
|
|
data = {
|
|
'type': 'cmbnet-wake',
|
|
'reason': str(reason or 'wake'),
|
|
}
|
|
android = messaging.AndroidConfig(
|
|
priority='high',
|
|
ttl=timedelta(seconds=ttl_seconds),
|
|
)
|
|
webpush = messaging.WebpushConfig(
|
|
headers={
|
|
'Urgency': 'high',
|
|
'TTL': str(ttl_seconds),
|
|
}
|
|
)
|
|
|
|
for start in range(0, len(tokens), 500):
|
|
batch = tokens[start:start + 500]
|
|
batch_result = self._send_batch(
|
|
messaging, batch, data, android, webpush, app=app
|
|
)
|
|
result['sent'] += batch_result['sent']
|
|
result['failed'] += batch_result['failed']
|
|
result['sent_tokens'].extend(batch_result['sent_tokens'])
|
|
result['invalid_tokens'].extend(batch_result['invalid_tokens'])
|
|
result['errors'].extend(batch_result['errors'])
|
|
if batch_result.get('error'):
|
|
result['error'] = batch_result['error']
|
|
|
|
self._log_debug({
|
|
'event': 'wake',
|
|
'reason': reason,
|
|
'requested': len(tokens),
|
|
'sent': result['sent'],
|
|
'failed': result['failed'],
|
|
'errors': result['errors'][:5],
|
|
'error': result.get('error'),
|
|
})
|
|
return result
|
|
|
|
def _send_batch(self, messaging, tokens, data, android, webpush, app=None):
|
|
batch_result = {
|
|
'sent': 0,
|
|
'failed': 0,
|
|
'sent_tokens': [],
|
|
'invalid_tokens': [],
|
|
'errors': [],
|
|
}
|
|
message = messaging.MulticastMessage(
|
|
tokens=tokens,
|
|
data=data,
|
|
android=android,
|
|
webpush=webpush,
|
|
)
|
|
try:
|
|
# Der Dienst initialisiert bewusst eine benannte App ("cmbnet"),
|
|
# damit er sich nicht mit einer eventuell vorhandenen
|
|
# Standard-App anderer Module vermischt. Die messaging-Funktionen
|
|
# verwenden ohne ``app`` jedoch immer die Standard-App und würden
|
|
# deshalb mit "The default Firebase app does not exist" scheitern.
|
|
response = messaging.send_each_for_multicast(message, app=app)
|
|
responses = list(response.responses)
|
|
except Exception as exc:
|
|
details = self._describe_send_error(None, exc)
|
|
logger.warning(
|
|
'FCM-Batchversand fehlgeschlagen (%s Empfänger): %s',
|
|
len(tokens), details
|
|
)
|
|
self._log_debug({
|
|
'event': 'batch-error',
|
|
'recipients': len(tokens),
|
|
'error': details,
|
|
})
|
|
batch_result['failed'] += len(tokens)
|
|
batch_result['error'] = details
|
|
batch_result['errors'].append({
|
|
'fingerprint': '-',
|
|
'error': details,
|
|
})
|
|
return batch_result
|
|
|
|
for token, send_response in zip(tokens, responses):
|
|
if send_response.success:
|
|
batch_result['sent'] += 1
|
|
batch_result['sent_tokens'].append(token)
|
|
continue
|
|
batch_result['failed'] += 1
|
|
exception = send_response.exception
|
|
details = self._describe_send_error(token, exception)
|
|
fingerprint = self._token_fingerprint(token)
|
|
logger.warning(
|
|
'FCM-Signal abgelehnt: token=%s error=%s',
|
|
fingerprint, details
|
|
)
|
|
self._log_debug({
|
|
'event': 'rejected',
|
|
'token': fingerprint,
|
|
'error': details,
|
|
})
|
|
batch_result['errors'].append({
|
|
'fingerprint': fingerprint,
|
|
'error': details,
|
|
})
|
|
text = str(exception or '').upper()
|
|
if (
|
|
isinstance(exception, messaging.UnregisteredError)
|
|
or 'UNREGISTERED' in text
|
|
or 'INVALID_ARGUMENT' in text
|
|
or 'SENDER_ID_MISMATCH' in text
|
|
):
|
|
batch_result['invalid_tokens'].append(token)
|
|
return batch_result
|
|
|
|
|
|
fcm_service = FcmService()
|