"""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) 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) 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), '') if text: return f'{name}: {text}' return name 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 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 ) 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'] return result def _send_batch(self, messaging, tokens, data, android, webpush): batch_result = { 'sent': 0, 'failed': 0, 'sent_tokens': [], 'invalid_tokens': [], 'errors': [], } message = messaging.MulticastMessage( tokens=tokens, data=data, android=android, webpush=webpush, ) try: response = messaging.send_each_for_multicast(message) 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 ) 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 ) 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()