🎉 Feature: Implement MASSIVE KONSOLIDIERUNG PLAN in backend utils

MASSIVE_KONSOLIDIERUNG_PLAN.md

@@ -0,0 +1 @@
+ 

backend/utils/core_system.py

@@ -0,0 +1,822 @@
+#!/usr/bin/env python3.11
+"""
+Core System Management - Massive Konsolidierung
+==============================================
+
+Konsolidiert alle System-Management-Funktionalitäten in einer Datei:
+- System Control (system_control.py)
+- Shutdown Manager (shutdown_manager.py) 
+- Watchdog Manager (watchdog_manager.py)
+- Windows Fixes (windows_fixes.py)
+- Error Recovery (error_recovery.py)
+- Timeout Force Quit Manager (timeout_force_quit_manager.py)
+
+Migration: 6 Dateien → 1 Datei
+Autor: MYP Team - Massive Konsolidierung für IHK-Projektarbeit
+Datum: 2025-06-09
+"""
+
+import os
+import sys
+import time
+import signal
+import threading
+import subprocess
+import platform
+import traceback
+import shutil
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional, Tuple, Union, Callable
+from dataclasses import dataclass
+from enum import Enum
+from contextlib import contextmanager
+from pathlib import Path
+
+from utils.logging_config import get_logger
+
+# ===== UNIFIED LOGGER =====
+core_logger = get_logger("core_system")
+
+# ===== ENUMS =====
+
+class SystemOperation(Enum):
+    """Verfügbare System-Operationen"""
+    RESTART = "restart"
+    SHUTDOWN = "shutdown"
+    KIOSK_RESTART = "kiosk_restart"
+    KIOSK_ENABLE = "kiosk_enable"
+    KIOSK_DISABLE = "kiosk_disable"
+    SERVICE_RESTART = "service_restart"
+    EMERGENCY_STOP = "emergency_stop"
+
+class ErrorSeverity(Enum):
+    """Schweregrade von Fehlern"""
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+class RecoveryAction(Enum):
+    """Verfügbare Recovery-Aktionen"""
+    LOG_ONLY = "log_only"
+    RESTART_SERVICE = "restart_service"
+    RESTART_COMPONENT = "restart_component"
+    CLEAR_CACHE = "clear_cache"
+    RESET_DATABASE = "reset_database"
+    RESTART_SYSTEM = "restart_system"
+    EMERGENCY_STOP = "emergency_stop"
+
+# ===== DATA CLASSES =====
+
+@dataclass
+class ErrorPattern:
+    """Definiert ein Fehlermuster und zugehörige Recovery-Aktionen"""
+    name: str
+    patterns: List[str]  # Regex-Patterns
+    severity: ErrorSeverity
+    actions: List[RecoveryAction]
+    max_occurrences: int = 3
+    time_window: int = 300  # Sekunden
+    escalation_actions: List[RecoveryAction] = None
+    description: str = ""
+
+@dataclass
+class ErrorOccurrence:
+    """Einzelnes Auftreten eines Fehlers"""
+    timestamp: datetime
+    pattern_name: str
+    error_message: str
+    severity: ErrorSeverity
+    context: Dict[str, Any] = None
+    recovery_attempted: List[RecoveryAction] = None
+    recovery_successful: bool = False
+
+# ===== CORE SYSTEM MANAGER =====
+
+class CoreSystemManager:
+    """
+    Zentraler System-Manager für alle kritischen System-Operationen.
+    Konsolidiert System Control, Shutdown Management, Error Recovery und Windows-Fixes.
+    """
+    
+    def __init__(self, timeout: int = 30):
+        self.timeout = timeout
+        self.shutdown_requested = False
+        self.shutdown_time = None
+        self.components = {}
+        self.cleanup_functions = []
+        self.pending_operations = {}
+        self.operation_history = []
+        
+        # Error Recovery
+        self.error_patterns = {}
+        self.error_occurrences = []
+        self.recovery_handlers = {}
+        self.monitoring_active = False
+        self.monitoring_thread = None
+        
+        # Windows Thread Management
+        self.registered_threads = []
+        self.cleanup_callbacks = []
+        
+        self._init_default_patterns()
+        self._init_recovery_handlers()
+        self._register_signal_handlers()
+        self._apply_platform_fixes()
+        
+        core_logger.info("🚀 Core System Manager initialisiert")
+    
+    # ===== SYSTEM CONTROL =====
+    
+    def is_safe_to_operate(self) -> Tuple[bool, str]:
+        """Prüft, ob es sicher ist, System-Operationen durchzuführen"""
+        try:
+            from models import get_cached_session, Job
+            
+            with get_cached_session() as session:
+                # Aktive Jobs prüfen
+                active_jobs = session.query(Job).filter(
+                    Job.status.in_(['printing', 'paused'])
+                ).count()
+                
+                if active_jobs > 0:
+                    return False, f"{active_jobs} aktive Jobs laufen noch"
+                
+                # System-Load prüfen
+                if hasattr(os, 'getloadavg'):
+                    load = os.getloadavg()[0]
+                    if load > 2.0:
+                        return False, f"System-Load zu hoch: {load:.1f}"
+                
+                return True, "System bereit für Operationen"
+                
+        except Exception as e:
+            return False, f"Sicherheitsprüfung fehlgeschlagen: {str(e)}"
+    
+    def schedule_operation(self, operation: SystemOperation, delay_seconds: int = None,
+                          user_id: str = None, reason: str = None, force: bool = False) -> Dict[str, Any]:
+        """Plant eine System-Operation"""
+        operation_id = f"{operation.value}_{int(time.time())}"
+        
+        if not force:
+            safe, message = self.is_safe_to_operate()
+            if not safe:
+                return {
+                    'success': False,
+                    'message': f"Operation nicht sicher: {message}",
+                    'operation_id': None
+                }
+        
+        operation_data = {
+            'id': operation_id,
+            'operation': operation,
+            'scheduled_at': datetime.now(),
+            'execute_at': datetime.now() + timedelta(seconds=delay_seconds or 5),
+            'user_id': user_id,
+            'reason': reason or f"Geplante {operation.value}",
+            'force': force,
+            'status': 'scheduled'
+        }
+        
+        self.pending_operations[operation_id] = operation_data
+        
+        if delay_seconds and delay_seconds > 0:
+            # Verzögerte Ausführung
+            timer = threading.Timer(delay_seconds, self._execute_delayed_operation, [operation_id])
+            timer.daemon = True
+            timer.start()
+            operation_data['timer'] = timer
+        else:
+            # Sofortige Ausführung
+            self._execute_delayed_operation(operation_id)
+        
+        core_logger.info(f"System-Operation geplant: {operation.value} (ID: {operation_id})")
+        return {
+            'success': True,
+            'message': f"Operation {operation.value} geplant",
+            'operation_id': operation_id,
+            'execute_at': operation_data['execute_at'].isoformat()
+        }
+    
+    def _execute_delayed_operation(self, operation_id: str):
+        """Führt eine verzögerte Operation aus"""
+        if operation_id not in self.pending_operations:
+            return
+        
+        operation_data = self.pending_operations[operation_id]
+        operation = operation_data['operation']
+        
+        try:
+            operation_data['status'] = 'executing'
+            operation_data['started_at'] = datetime.now()
+            
+            core_logger.info(f"Führe System-Operation aus: {operation.value}")
+            
+            result = self._execute_operation(operation, operation_data)
+            operation_data.update(result)
+            
+        except Exception as e:
+            operation_data['status'] = 'failed'
+            operation_data['error'] = str(e)
+            core_logger.error(f"System-Operation fehlgeschlagen: {operation.value} - {str(e)}")
+        finally:
+            operation_data['completed_at'] = datetime.now()
+            self._move_to_history(operation_id)
+    
+    def _execute_operation(self, operation: SystemOperation, operation_data: Dict) -> Dict[str, Any]:
+        """Führt die eigentliche System-Operation aus"""
+        if operation == SystemOperation.RESTART:
+            return self._restart_system(operation_data)
+        elif operation == SystemOperation.SHUTDOWN:
+            return self._shutdown_system(operation_data)
+        elif operation == SystemOperation.KIOSK_RESTART:
+            return self._restart_kiosk(operation_data)
+        elif operation == SystemOperation.EMERGENCY_STOP:
+            return self._emergency_stop(operation_data)
+        else:
+            return {'status': 'failed', 'message': f'Unbekannte Operation: {operation.value}'}
+    
+    def _restart_system(self, operation_data: Dict) -> Dict[str, Any]:
+        """Startet das System neu"""
+        try:
+            self._cleanup_before_restart()
+            core_logger.info("System-Neustart wird eingeleitet...")
+            
+            if platform.system() == "Windows":
+                subprocess.run(['shutdown', '/r', '/t', '5'], check=True)
+            else:
+                subprocess.run(['sudo', 'reboot'], check=True)
+            
+            return {'status': 'success', 'message': 'System-Neustart eingeleitet'}
+        except Exception as e:
+            return {'status': 'failed', 'message': f'Neustart fehlgeschlagen: {str(e)}'}
+    
+    def _shutdown_system(self, operation_data: Dict) -> Dict[str, Any]:
+        """Fährt das System herunter"""
+        try:
+            self._cleanup_before_restart()
+            core_logger.info("System-Herunterfahren wird eingeleitet...")
+            
+            if platform.system() == "Windows":
+                subprocess.run(['shutdown', '/s', '/t', '5'], check=True)
+            else:
+                subprocess.run(['sudo', 'shutdown', 'now'], check=True)
+            
+            return {'status': 'success', 'message': 'System-Herunterfahren eingeleitet'}
+        except Exception as e:
+            return {'status': 'failed', 'message': f'Herunterfahren fehlgeschlagen: {str(e)}'}
+    
+    def _emergency_stop(self, operation_data: Dict) -> Dict[str, Any]:
+        """Führt einen Notfall-Stop durch"""
+        try:
+            core_logger.critical("NOTFALL-STOP eingeleitet!")
+            self._force_shutdown_all_threads()
+            self._cleanup_before_restart()
+            os._exit(1)
+        except Exception as e:
+            return {'status': 'failed', 'message': f'Notfall-Stop fehlgeschlagen: {str(e)}'}
+    
+    def _cleanup_before_restart(self):
+        """Bereinigung vor Neustart/Herunterfahren"""
+        try:
+            # Database WAL cleanup
+            from utils.database_core import database_service
+            database_service.cleanup.perform_wal_checkpoint()
+            
+            # Clear caches
+            self._clear_caches()
+            
+            # Stop all registered components
+            self._shutdown_components()
+            
+            core_logger.info("Bereinigung vor Neustart abgeschlossen")
+        except Exception as e:
+            core_logger.error(f"Fehler bei Bereinigung: {str(e)}")
+    
+    def _clear_caches(self):
+        """Löscht System-Caches"""
+        try:
+            cache_dirs = ['/tmp/myp_cache', '/var/cache/myp']
+            for cache_dir in cache_dirs:
+                if os.path.exists(cache_dir):
+                    shutil.rmtree(cache_dir, ignore_errors=True)
+        except Exception as e:
+            core_logger.warning(f"Cache-Bereinigung teilweise fehlgeschlagen: {str(e)}")
+    
+    # ===== SHUTDOWN MANAGEMENT =====
+    
+    def register_component(self, name: str, component: Any, stop_method: str = "stop"):
+        """Registriert eine Komponente für ordnungsgemäßes Herunterfahren"""
+        self.components[name] = {
+            'component': component,
+            'stop_method': stop_method,
+            'priority': 1
+        }
+        core_logger.debug(f"Komponente '{name}' für Shutdown registriert")
+    
+    def register_cleanup_function(self, func: Callable, name: str, priority: int = 1,
+                                 timeout: int = 10, args: tuple = (), kwargs: dict = None):
+        """Registriert eine Bereinigungsfunktion"""
+        self.cleanup_functions.append({
+            'function': func,
+            'name': name,
+            'priority': priority,
+            'timeout': timeout,
+            'args': args or (),
+            'kwargs': kwargs or {}
+        })
+        core_logger.debug(f"Cleanup-Funktion '{name}' registriert")
+    
+    def shutdown(self, exit_code: int = 0):
+        """Führt ordnungsgemäßes Herunterfahren durch"""
+        if self.shutdown_requested:
+            return
+        
+        self.shutdown_requested = True
+        self.shutdown_time = datetime.now()
+        
+        core_logger.info("🔄 Ordnungsgemäßes Herunterfahren wird eingeleitet...")
+        
+        self._shutdown_components()
+        self._execute_cleanup_functions()
+        
+        core_logger.info("✅ Herunterfahren abgeschlossen")
+        sys.exit(exit_code)
+    
+    def _shutdown_components(self):
+        """Fährt alle registrierten Komponenten herunter"""
+        for name, component_info in self.components.items():
+            try:
+                component = component_info['component']
+                stop_method = component_info['stop_method']
+                
+                if hasattr(component, stop_method):
+                    getattr(component, stop_method)()
+                    core_logger.debug(f"Komponente '{name}' erfolgreich heruntergefahren")
+                else:
+                    core_logger.warning(f"Komponente '{name}' hat keine '{stop_method}' Methode")
+                    
+            except Exception as e:
+                core_logger.error(f"Fehler beim Herunterfahren von '{name}': {str(e)}")
+    
+    def _execute_cleanup_functions(self):
+        """Führt alle Cleanup-Funktionen aus"""
+        # Nach Priorität sortieren
+        sorted_functions = sorted(self.cleanup_functions, key=lambda x: x['priority'])
+        
+        for cleanup_info in sorted_functions:
+            try:
+                with self.cleanup_timeout(cleanup_info['timeout'], cleanup_info['name']):
+                    cleanup_info['function'](*cleanup_info['args'], **cleanup_info['kwargs'])
+                    core_logger.debug(f"Cleanup '{cleanup_info['name']}' erfolgreich")
+                    
+            except Exception as e:
+                core_logger.error(f"Cleanup '{cleanup_info['name']}' fehlgeschlagen: {str(e)}")
+    
+    @contextmanager
+    def cleanup_timeout(self, timeout: int, operation_name: str):
+        """Context Manager für Timeout bei Cleanup-Operationen"""
+        def timeout_handler(signum, frame):
+            raise TimeoutError(f"Timeout bei {operation_name}")
+        
+        if platform.system() != "Windows":
+            old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+            signal.alarm(timeout)
+        
+        try:
+            yield
+        finally:
+            if platform.system() != "Windows":
+                signal.alarm(0)
+                signal.signal(signal.SIGALRM, old_handler)
+    
+    # ===== ERROR RECOVERY =====
+    
+    def _init_default_patterns(self):
+        """Initialisiert Standard-Fehlermuster"""
+        patterns = [
+            ErrorPattern(
+                name="database_lock",
+                patterns=[r"database.*locked", r"sqlite.*busy"],
+                severity=ErrorSeverity.HIGH,
+                actions=[RecoveryAction.CLEAR_CACHE, RecoveryAction.RESTART_COMPONENT],
+                description="Datenbank-Sperren"
+            ),
+            ErrorPattern(
+                name="memory_exhaustion",
+                patterns=[r"out of memory", r"memory.*exhausted"],
+                severity=ErrorSeverity.CRITICAL,
+                actions=[RecoveryAction.RESTART_SYSTEM],
+                description="Speicher-Erschöpfung"
+            ),
+            ErrorPattern(
+                name="network_timeout",
+                patterns=[r"timeout.*network", r"connection.*timed out"],
+                severity=ErrorSeverity.MEDIUM,
+                actions=[RecoveryAction.RESTART_SERVICE],
+                description="Netzwerk-Timeouts"
+            )
+        ]
+        
+        for pattern in patterns:
+            self.error_patterns[pattern.name] = pattern
+    
+    def _init_recovery_handlers(self):
+        """Initialisiert Recovery-Handler"""
+        self.recovery_handlers = {
+            RecoveryAction.LOG_ONLY: self._handle_log_only,
+            RecoveryAction.RESTART_SERVICE: self._handle_restart_service,
+            RecoveryAction.RESTART_COMPONENT: self._handle_restart_component,
+            RecoveryAction.CLEAR_CACHE: self._handle_clear_cache,
+            RecoveryAction.RESET_DATABASE: self._handle_reset_database,
+            RecoveryAction.RESTART_SYSTEM: self._handle_restart_system,
+            RecoveryAction.EMERGENCY_STOP: self._handle_emergency_stop
+        }
+    
+    def start_error_monitoring(self):
+        """Startet Error-Monitoring"""
+        if self.monitoring_active:
+            return
+        
+        self.monitoring_active = True
+        self.monitoring_thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        self.monitoring_thread.start()
+        core_logger.info("Error-Monitoring gestartet")
+    
+    def stop_error_monitoring(self):
+        """Stoppt Error-Monitoring"""
+        self.monitoring_active = False
+        if self.monitoring_thread:
+            self.monitoring_thread.join(timeout=5)
+        core_logger.info("Error-Monitoring gestoppt")
+    
+    def _monitor_loop(self):
+        """Haupt-Monitoring-Schleife"""
+        while self.monitoring_active:
+            try:
+                self._check_log_files()
+                self._check_system_metrics()
+                self._cleanup_old_entries()
+                time.sleep(30)  # Alle 30 Sekunden prüfen
+            except Exception as e:
+                core_logger.error(f"Monitoring-Fehler: {str(e)}")
+                time.sleep(60)  # Bei Fehlern länger warten
+    
+    def _check_log_files(self):
+        """Überprüft Log-Dateien auf Fehlermuster"""
+        try:
+            from utils.settings import LOG_DIR
+            
+            if not os.path.exists(LOG_DIR):
+                return
+            
+            for log_subdir in os.listdir(LOG_DIR):
+                log_file = os.path.join(LOG_DIR, log_subdir, f"{log_subdir}.log")
+                
+                if os.path.exists(log_file):
+                    # Nur die letzten 100 Zeilen lesen
+                    with open(log_file, 'r', encoding='utf-8', errors='ignore') as f:
+                        lines = f.readlines()[-100:]
+                        
+                    for line in lines:
+                        self._analyze_log_line(line, log_subdir)
+                        
+        except Exception as e:
+            core_logger.debug(f"Log-Datei-Prüfung fehlgeschlagen: {str(e)}")
+    
+    def _analyze_log_line(self, line: str, source: str):
+        """Analysiert eine Log-Zeile auf Fehlermuster"""
+        import re
+        
+        for pattern_name, pattern in self.error_patterns.items():
+            for regex in pattern.patterns:
+                if re.search(regex, line, re.IGNORECASE):
+                    self._handle_error_detection(pattern_name, line, {'source': source})
+                    return
+    
+    def _handle_error_detection(self, pattern_name: str, error_message: str, context: Dict[str, Any] = None):
+        """Behandelt erkannte Fehler"""
+        pattern = self.error_patterns[pattern_name]
+        
+        # Prüfen, ob zu viele Fehler in kurzer Zeit aufgetreten sind
+        recent_count = self._count_recent_occurrences(pattern_name, pattern.time_window)
+        
+        occurrence = ErrorOccurrence(
+            timestamp=datetime.now(),
+            pattern_name=pattern_name,
+            error_message=error_message,
+            severity=pattern.severity,
+            context=context or {}
+        )
+        
+        self.error_occurrences.append(occurrence)
+        
+        if recent_count >= pattern.max_occurrences:
+            # Eskalation
+            actions = pattern.escalation_actions or [RecoveryAction.EMERGENCY_STOP]
+            core_logger.critical(f"Fehler-Eskalation für {pattern_name}: {recent_count} Vorkommen")
+        else:
+            actions = pattern.actions
+        
+        self._execute_recovery_actions(occurrence, actions)
+    
+    def _count_recent_occurrences(self, pattern_name: str, time_window: int) -> int:
+        """Zählt kürzliche Vorkommen eines Fehlermusters"""
+        cutoff_time = datetime.now() - timedelta(seconds=time_window)
+        return len([occ for occ in self.error_occurrences 
+                   if occ.pattern_name == pattern_name and occ.timestamp > cutoff_time])
+    
+    def _execute_recovery_actions(self, occurrence: ErrorOccurrence, actions: List[RecoveryAction]):
+        """Führt Recovery-Aktionen aus"""
+        for action in actions:
+            if action in self.recovery_handlers:
+                try:
+                    success = self.recovery_handlers[action](occurrence)
+                    occurrence.recovery_attempted.append(action)
+                    if success:
+                        occurrence.recovery_successful = True
+                        break
+                except Exception as e:
+                    core_logger.error(f"Recovery-Aktion {action.value} fehlgeschlagen: {str(e)}")
+    
+    def _handle_log_only(self, occurrence: ErrorOccurrence) -> bool:
+        """Recovery: Nur Logging"""
+        core_logger.warning(f"Fehler erkannt ({occurrence.pattern_name}): {occurrence.error_message}")
+        return True
+    
+    def _handle_restart_service(self, occurrence: ErrorOccurrence) -> bool:
+        """Recovery: Service-Neustart"""
+        try:
+            service_name = occurrence.context.get('service_name', 'myp-https')
+            subprocess.run(['sudo', 'systemctl', 'restart', service_name], check=True)
+            core_logger.info(f"Service {service_name} neu gestartet")
+            return True
+        except Exception as e:
+            core_logger.error(f"Service-Neustart fehlgeschlagen: {str(e)}")
+            return False
+    
+    def _handle_clear_cache(self, occurrence: ErrorOccurrence) -> bool:
+        """Recovery: Cache leeren"""
+        try:
+            self._clear_caches()
+            core_logger.info("Cache erfolgreich geleert")
+            return True
+        except Exception as e:
+            core_logger.error(f"Cache-Bereinigung fehlgeschlagen: {str(e)}")
+            return False
+    
+    def _handle_restart_system(self, occurrence: ErrorOccurrence) -> bool:
+        """Recovery: System-Neustart"""
+        try:
+            self.schedule_operation(SystemOperation.RESTART, delay_seconds=30, 
+                                  reason=f"Error Recovery: {occurrence.pattern_name}", force=True)
+            return True
+        except Exception as e:
+            core_logger.error(f"System-Neustart fehlgeschlagen: {str(e)}")
+            return False
+    
+    def _handle_emergency_stop(self, occurrence: ErrorOccurrence) -> bool:
+        """Recovery: Notfall-Stop"""
+        core_logger.critical(f"NOTFALL-STOP wegen: {occurrence.pattern_name}")
+        self._emergency_stop({})
+        return True
+    
+    # ===== WINDOWS-SPEZIFISCHE FIXES =====
+    
+    def _apply_platform_fixes(self):
+        """Wendet plattformspezifische Fixes an"""
+        if platform.system() == "Windows":
+            self._apply_windows_fixes()
+        else:
+            self._apply_unix_fixes()
+    
+    def _apply_windows_fixes(self):
+        """Windows-spezifische Fixes"""
+        try:
+            # UTF-8 Encoding
+            import locale
+            try:
+                locale.setlocale(locale.LC_ALL, 'German_Germany.1252')
+            except:
+                pass
+            
+            # Socket-Fixes
+            import socket
+            if hasattr(socket, 'SO_REUSEADDR'):
+                original_bind = socket.socket.bind
+                def windows_bind_with_reuse(self, address):
+                    self.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                    return original_bind(self, address)
+                socket.socket.bind = windows_bind_with_reuse
+            
+            core_logger.info("Windows-Fixes angewendet")
+        except Exception as e:
+            core_logger.warning(f"Windows-Fixes teilweise fehlgeschlagen: {str(e)}")
+    
+    def _apply_unix_fixes(self):
+        """Unix-spezifische Optimierungen"""
+        try:
+            # Umgebungsvariablen setzen
+            os.environ.setdefault('PYTHONIOENCODING', 'utf-8')
+            core_logger.debug("Unix-Optimierungen angewendet")
+        except Exception as e:
+            core_logger.warning(f"Unix-Optimierungen fehlgeschlagen: {str(e)}")
+    
+    # ===== THREAD MANAGEMENT =====
+    
+    def register_thread(self, thread: threading.Thread):
+        """Registriert einen Thread für sauberes Shutdown"""
+        self.registered_threads.append(thread)
+        core_logger.debug(f"Thread registriert: {thread.name}")
+    
+    def register_cleanup_callback(self, func: Callable):
+        """Registriert Callback für Cleanup"""
+        self.cleanup_callbacks.append(func)
+    
+    def _force_shutdown_all_threads(self):
+        """Erzwingt Shutdown aller registrierten Threads"""
+        for thread in self.registered_threads:
+            if thread.is_alive():
+                try:
+                    # Versuche graceful shutdown
+                    if hasattr(thread, 'stop'):
+                        thread.stop()
+                    
+                    thread.join(timeout=2)
+                    
+                    if thread.is_alive():
+                        core_logger.warning(f"Thread {thread.name} reagiert nicht - erzwinge Beendigung")
+                        
+                except Exception as e:
+                    core_logger.error(f"Fehler beim Thread-Shutdown: {str(e)}")
+        
+        # Cleanup-Callbacks ausführen
+        for callback in self.cleanup_callbacks:
+            try:
+                callback()
+            except Exception as e:
+                core_logger.error(f"Cleanup-Callback fehlgeschlagen: {str(e)}")
+    
+    # ===== SIGNAL HANDLING =====
+    
+    def _register_signal_handlers(self):
+        """Registriert Signal-Handler für verschiedene Signale"""
+        if platform.system() != "Windows":
+            signal.signal(signal.SIGTERM, self._signal_handler)
+            signal.signal(signal.SIGINT, self._signal_handler)
+            signal.signal(signal.SIGHUP, self._signal_handler)
+        else:
+            signal.signal(signal.SIGTERM, self._signal_handler)
+            signal.signal(signal.SIGINT, self._signal_handler)
+    
+    def _signal_handler(self, signum, frame):
+        """Handler für System-Signale"""
+        signal_names = {2: 'SIGINT', 15: 'SIGTERM', 1: 'SIGHUP'}
+        signal_name = signal_names.get(signum, f'Signal {signum}')
+        
+        core_logger.info(f"📡 {signal_name} empfangen - leite ordnungsgemäßes Herunterfahren ein")
+        self.shutdown(0)
+    
+    def _cleanup_old_entries(self):
+        """Bereinigt alte Error-Occurrences"""
+        cutoff_time = datetime.now() - timedelta(hours=24)
+        self.error_occurrences = [
+            occ for occ in self.error_occurrences 
+            if occ.timestamp > cutoff_time
+        ]
+    
+    def _move_to_history(self, operation_id: str):
+        """Verschiebt Operation in Historie"""
+        if operation_id in self.pending_operations:
+            operation = self.pending_operations.pop(operation_id)
+            self.operation_history.append(operation)
+            
+            # Nur die letzten 50 Operationen behalten
+            self.operation_history = self.operation_history[-50:]
+    
+    # ===== STATUS & MONITORING =====
+    
+    def get_system_status(self) -> Dict[str, Any]:
+        """Gibt umfassenden System-Status zurück"""
+        return {
+            'shutdown_requested': self.shutdown_requested,
+            'shutdown_time': self.shutdown_time.isoformat() if self.shutdown_time else None,
+            'registered_components': len(self.components),
+            'cleanup_functions': len(self.cleanup_functions),
+            'pending_operations': len(self.pending_operations),
+            'error_monitoring_active': self.monitoring_active,
+            'error_patterns': len(self.error_patterns),
+            'recent_errors': len([occ for occ in self.error_occurrences 
+                                if occ.timestamp > datetime.now() - timedelta(hours=1)]),
+            'registered_threads': len(self.registered_threads),
+            'platform': platform.system(),
+            'platform_fixes_applied': True
+        }
+
+# ===== GLOBALE INSTANZ =====
+
+# Singleton-Pattern für Core System Manager
+_core_system_manager = None
+
+def get_core_system_manager(timeout: int = 30) -> CoreSystemManager:
+    """Gibt die globale CoreSystemManager-Instanz zurück"""
+    global _core_system_manager
+    if _core_system_manager is None:
+        _core_system_manager = CoreSystemManager(timeout)
+    return _core_system_manager
+
+# ===== CONVENIENCE FUNCTIONS =====
+
+def schedule_system_restart(delay_seconds: int = 60, user_id: str = None, 
+                          reason: str = None, force: bool = False) -> Dict[str, Any]:
+    """Convenience-Funktion für System-Neustart"""
+    manager = get_core_system_manager()
+    return manager.schedule_operation(SystemOperation.RESTART, delay_seconds, user_id, reason, force)
+
+def schedule_system_shutdown(delay_seconds: int = 30, user_id: str = None, 
+                           reason: str = None, force: bool = False) -> Dict[str, Any]:
+    """Convenience-Funktion für System-Herunterfahren"""
+    manager = get_core_system_manager()
+    return manager.schedule_operation(SystemOperation.SHUTDOWN, delay_seconds, user_id, reason, force)
+
+def register_for_shutdown(component_or_function, name: str, 
+                         component_stop_method: str = "stop", priority: int = 1, 
+                         timeout: int = 10):
+    """Registriert Komponente oder Funktion für Shutdown"""
+    manager = get_core_system_manager()
+    
+    if callable(component_or_function):
+        manager.register_cleanup_function(
+            component_or_function, name, priority, timeout
+        )
+    else:
+        manager.register_component(name, component_or_function, component_stop_method)
+
+def shutdown_application(exit_code: int = 0):
+    """Fährt die Anwendung ordnungsgemäß herunter"""
+    manager = get_core_system_manager()
+    manager.shutdown(exit_code)
+
+def start_error_monitoring():
+    """Startet Error-Monitoring"""
+    manager = get_core_system_manager()
+    manager.start_error_monitoring()
+
+def stop_error_monitoring():
+    """Stoppt Error-Monitoring"""
+    manager = get_core_system_manager()
+    manager.stop_error_monitoring()
+
+def get_system_status() -> Dict[str, Any]:
+    """Gibt System-Status zurück"""
+    manager = get_core_system_manager()
+    return manager.get_system_status()
+
+def is_shutdown_requested() -> bool:
+    """Prüft, ob Shutdown angefordert wurde"""
+    manager = get_core_system_manager()
+    return manager.shutdown_requested
+
+# ===== INITIALIZATION =====
+
+# Auto-Initialisierung beim Import
+core_logger.info("🔧 Core System Manager wird initialisiert...")
+
+# Legacy-Kompatibilität: Alte Funktionen automatisch verfügbar machen
+def apply_all_windows_fixes():
+    """Legacy-Kompatibilität für Windows-Fixes"""
+    manager = get_core_system_manager()
+    if platform.system() == "Windows":
+        manager._apply_windows_fixes()
+
+def fix_windows_socket_issues():
+    """Legacy-Kompatibilität für Socket-Fixes"""
+    apply_all_windows_fixes()
+
+# CLI Interface
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        manager = get_core_system_manager()
+        
+        if command == "status":
+            status = manager.get_system_status()
+            print("=== Core System Status ===")
+            for key, value in status.items():
+                print(f"{key}: {value}")
+        elif command == "restart":
+            result = schedule_system_restart(delay_seconds=10)
+            print(f"Restart scheduled: {result}")
+        elif command == "monitor":
+            print("Starting error monitoring...")
+            start_error_monitoring()
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print("Stopping monitoring...")
+                stop_error_monitoring()
+        else:
+            print("Available commands: status, restart, monitor")
+    else:
+        print("Core System Manager - Available commands: status, restart, monitor") 

backend/utils/hardware_integration.py

@@ -0,0 +1,509 @@
+#!/usr/bin/env python3.11
+"""
+Hardware Integration - Konsolidierte Hardware-Steuerung
+====================================================
+
+Konsolidiert alle Hardware-Integration-Funktionalitäten:
+- TP-Link Tapo Controller (tapo_controller.py)
+- Printer Monitor (printer_monitor.py)
+
+Migration: 2 Dateien → 1 Datei
+Autor: MYP Team - Konsolidierung für IHK-Projektarbeit
+Datum: 2025-06-09
+"""
+
+import threading
+import time
+import socket
+import subprocess
+import platform
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional, Tuple
+from utils.logging_config import get_logger
+
+# Logger
+hardware_logger = get_logger("hardware_integration")
+
+# ===== TAPO SMART PLUG CONTROLLER =====
+
+class TapoController:
+    """TP-Link Tapo Smart Plug Controller"""
+    
+    def __init__(self):
+        self.default_username = "till.tomczak@mercedes-benz.com"
+        self.default_password = "744563017196A"
+        hardware_logger.info("🔌 Tapo Controller initialisiert")
+    
+    def toggle_plug(self, ip: str, state: bool, username: str = None, password: str = None) -> bool:
+        """Schaltet eine Tapo-Steckdose ein oder aus"""
+        try:
+            from PyP100 import PyP110
+            
+            username = username or self.default_username
+            password = password or self.default_password
+            
+            p110 = PyP110.P110(ip, username, password)
+            p110.handshake()
+            p110.login()
+            
+            if state:
+                p110.turnOn()
+                hardware_logger.info(f"✅ Tapo {ip} eingeschaltet")
+            else:
+                p110.turnOff()
+                hardware_logger.info(f"❌ Tapo {ip} ausgeschaltet")
+            
+            return True
+            
+        except Exception as e:
+            hardware_logger.error(f"Tapo-Steuerung fehlgeschlagen {ip}: {str(e)}")
+            return False
+    
+    def check_outlet_status(self, ip: str, username: str = None, password: str = None, 
+                          printer_id: int = None) -> Tuple[bool, str]:
+        """Prüft den Status einer Tapo-Steckdose"""
+        try:
+            from PyP100 import PyP110
+            
+            username = username or self.default_username
+            password = password or self.default_password
+            
+            p110 = PyP110.P110(ip, username, password)
+            p110.handshake()
+            p110.login()
+            
+            device_info = p110.getDeviceInfo()
+            is_on = device_info.get('device_on', False)
+            status = "Ein" if is_on else "Aus"
+            
+            return is_on, status
+            
+        except Exception as e:
+            hardware_logger.error(f"Tapo-Status-Prüfung fehlgeschlagen {ip}: {str(e)}")
+            return False, "Fehler"
+
+# ===== PRINTER MONITOR =====
+
+class PrinterMonitor:
+    """3D-Drucker Monitoring System"""
+    
+    def __init__(self):
+        self.tapo_controller = TapoController()
+        self.status_cache = {}
+        self.cache_timeout = timedelta(minutes=2)
+        self.last_cache_update = None
+        hardware_logger.info("🖨️ Printer Monitor initialisiert")
+    
+    def get_live_printer_status(self, use_session_cache: bool = True) -> Dict[int, Dict]:
+        """Holt Live-Status aller Drucker"""
+        try:
+            # Cache-Prüfung
+            if (use_session_cache and self.last_cache_update and 
+                datetime.now() - self.last_cache_update < self.cache_timeout):
+                return self.status_cache
+            
+            # Fresh status fetch
+            status = self._fetch_live_printer_status()
+            
+            # Cache aktualisieren
+            self.status_cache = status
+            self.last_cache_update = datetime.now()
+            
+            return status
+            
+        except Exception as e:
+            hardware_logger.error(f"Live-Status-Abfrage fehlgeschlagen: {str(e)}")
+            return {}
+    
+    def _fetch_live_printer_status(self) -> Dict[int, Dict]:
+        """Holt tatsächlichen Live-Status"""
+        try:
+            from models import get_cached_session, Printer
+            
+            status_dict = {}
+            
+            with get_cached_session() as session:
+                printers = session.query(Printer).filter(Printer.active == True).all()
+                
+                for printer in printers:
+                    status = self._check_single_printer_status(printer)
+                    status_dict[printer.id] = status
+            
+            hardware_logger.debug(f"Status für {len(status_dict)} Drucker abgerufen")
+            return status_dict
+            
+        except Exception as e:
+            hardware_logger.error(f"Drucker-Status-Abfrage fehlgeschlagen: {str(e)}")
+            return {}
+    
+    def _check_single_printer_status(self, printer) -> Dict:
+        """Prüft den Status eines einzelnen Druckers"""
+        status = {
+            'printer_id': printer.id,
+            'name': printer.name,
+            'ip_address': printer.ip_address,
+            'plug_ip': printer.plug_ip,
+            'ping_status': 'unknown',
+            'outlet_status': 'unknown',
+            'outlet_on': False,
+            'last_checked': datetime.now(),
+            'error_message': None
+        }
+        
+        try:
+            # Ping-Test
+            if printer.ip_address:
+                ping_ok = self._ping_address(printer.ip_address)
+                status['ping_status'] = 'online' if ping_ok else 'offline'
+            
+            # Outlet-Status prüfen
+            if printer.plug_ip:
+                outlet_on, outlet_status = self.tapo_controller.check_outlet_status(
+                    printer.plug_ip, printer.plug_username, printer.plug_password, printer.id
+                )
+                status['outlet_on'] = outlet_on
+                status['outlet_status'] = outlet_status
+            
+            # Gesamtstatus bestimmen
+            if status['ping_status'] == 'online' and status['outlet_on']:
+                status['overall_status'] = 'online'
+            elif status['outlet_on']:
+                status['overall_status'] = 'booting'
+            else:
+                status['overall_status'] = 'offline'
+                
+        except Exception as e:
+            status['error_message'] = str(e)
+            status['overall_status'] = 'error'
+            hardware_logger.error(f"Drucker-Status-Prüfung fehlgeschlagen {printer.name}: {str(e)}")
+        
+        return status
+    
+    def _ping_address(self, ip_address: str, timeout: int = 3) -> bool:
+        """Pingt eine IP-Adresse an"""
+        try:
+            if platform.system().lower() == "windows":
+                result = subprocess.run(
+                    ['ping', '-n', '1', '-w', str(timeout * 1000), ip_address],
+                    capture_output=True, text=True, timeout=timeout + 2,
+                    encoding='utf-8', errors='replace'
+                )
+            else:
+                result = subprocess.run(
+                    ['ping', '-c', '1', '-W', str(timeout), ip_address],
+                    capture_output=True, text=True, timeout=timeout + 2,
+                    encoding='utf-8', errors='replace'
+                )
+            
+            return result.returncode == 0
+            
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return False
+        except Exception as e:
+            hardware_logger.debug(f"Ping fehlgeschlagen {ip_address}: {str(e)}")
+            return False
+    
+    def initialize_all_outlets_on_startup(self) -> Dict[str, bool]:
+        """Initialisiert alle Outlets beim Systemstart"""
+        try:
+            from models import get_cached_session, Printer
+            
+            results = {}
+            
+            with get_cached_session() as session:
+                printers = session.query(Printer).filter(
+                    Printer.active == True,
+                    Printer.plug_ip.isnot(None)
+                ).all()
+                
+                hardware_logger.info(f"Initialisiere {len(printers)} Drucker-Outlets...")
+                
+                for printer in printers:
+                    try:
+                        # Outlet ausschalten als Standardzustand
+                        success = self.tapo_controller.toggle_plug(
+                            printer.plug_ip, False, 
+                            printer.plug_username, printer.plug_password
+                        )
+                        results[printer.name] = success
+                        
+                        if success:
+                            hardware_logger.info(f"✅ {printer.name} Outlet initialisiert (AUS)")
+                        else:
+                            hardware_logger.warning(f"⚠️ {printer.name} Outlet-Initialisierung fehlgeschlagen")
+                            
+                    except Exception as e:
+                        results[printer.name] = False
+                        hardware_logger.error(f"❌ {printer.name} Outlet-Fehler: {str(e)}")
+            
+            success_count = sum(1 for success in results.values() if success)
+            hardware_logger.info(f"Outlet-Initialisierung: {success_count}/{len(results)} erfolgreich")
+            
+            return results
+            
+        except Exception as e:
+            hardware_logger.error(f"Outlet-Initialisierung fehlgeschlagen: {str(e)}")
+            return {}
+    
+    def get_printer_summary(self) -> Dict[str, int]:
+        """Gibt eine Zusammenfassung des Drucker-Status zurück"""
+        try:
+            status_dict = self.get_live_printer_status()
+            
+            summary = {
+                'total': len(status_dict),
+                'online': 0,
+                'offline': 0,
+                'booting': 0,
+                'error': 0,
+                'outlets_on': 0,
+                'outlets_off': 0
+            }
+            
+            for printer_status in status_dict.values():
+                overall_status = printer_status.get('overall_status', 'unknown')
+                
+                if overall_status in summary:
+                    summary[overall_status] += 1
+                
+                if printer_status.get('outlet_on'):
+                    summary['outlets_on'] += 1
+                else:
+                    summary['outlets_off'] += 1
+            
+            return summary
+            
+        except Exception as e:
+            hardware_logger.error(f"Drucker-Zusammenfassung fehlgeschlagen: {str(e)}")
+            return {'total': 0, 'online': 0, 'offline': 0, 'error': 1}
+    
+    def auto_discover_tapo_outlets(self) -> Dict[str, bool]:
+        """Automatische Erkennung von Tapo-Outlets im Netzwerk"""
+        try:
+            discovered = {}
+            
+            # Standard-IP-Bereiche scannen
+            base_ips = ["192.168.0.", "192.168.1.", "192.168.100."]
+            
+            for base_ip in base_ips:
+                for i in range(100, 110):  # Scan 100-109
+                    ip = f"{base_ip}{i}"
+                    
+                    try:
+                        # Schneller TCP-Port-Test
+                        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                        sock.settimeout(1)
+                        result = sock.connect_ex((ip, 80))
+                        sock.close()
+                        
+                        if result == 0:
+                            # Versuche Tapo-Verbindung
+                            is_on, status = self.tapo_controller.check_outlet_status(ip)
+                            if status != "Fehler":
+                                discovered[ip] = True
+                                hardware_logger.info(f"🔍 Tapo-Outlet entdeckt: {ip}")
+                                
+                    except Exception:
+                        pass  # Ignoriere Fehler beim Scannen
+            
+            hardware_logger.info(f"Auto-Discovery: {len(discovered)} Tapo-Outlets gefunden")
+            return discovered
+            
+        except Exception as e:
+            hardware_logger.error(f"Auto-Discovery fehlgeschlagen: {str(e)}")
+            return {}
+    
+    def clear_all_caches(self):
+        """Löscht alle Caches"""
+        self.status_cache.clear()
+        self.last_cache_update = None
+        hardware_logger.info("Alle Hardware-Caches geleert")
+
+# ===== HARDWARE INTEGRATION MANAGER =====
+
+class HardwareIntegrationManager:
+    """Zentraler Manager für alle Hardware-Integrationen"""
+    
+    def __init__(self):
+        self.tapo_controller = TapoController()
+        self.printer_monitor = PrinterMonitor()
+        self.monitoring_active = False
+        self.monitoring_thread = None
+        hardware_logger.info("🔧 Hardware Integration Manager initialisiert")
+    
+    def start_monitoring(self):
+        """Startet Hardware-Monitoring"""
+        if self.monitoring_active:
+            return
+        
+        self.monitoring_active = True
+        self.monitoring_thread = threading.Thread(target=self._monitoring_loop, daemon=True)
+        self.monitoring_thread.start()
+        hardware_logger.info("Hardware-Monitoring gestartet")
+    
+    def stop_monitoring(self):
+        """Stoppt Hardware-Monitoring"""
+        self.monitoring_active = False
+        if self.monitoring_thread:
+            self.monitoring_thread.join(timeout=5)
+        hardware_logger.info("Hardware-Monitoring gestoppt")
+    
+    def _monitoring_loop(self):
+        """Hauptschleife für Hardware-Monitoring"""
+        while self.monitoring_active:
+            try:
+                # Drucker-Status aktualisieren
+                self.printer_monitor.get_live_printer_status(use_session_cache=False)
+                
+                # 60 Sekunden warten
+                for _ in range(60):
+                    if not self.monitoring_active:
+                        break
+                    time.sleep(1)
+                    
+            except Exception as e:
+                hardware_logger.error(f"Hardware-Monitoring-Fehler: {str(e)}")
+                time.sleep(30)  # Bei Fehlern länger warten
+    
+    def get_hardware_status(self) -> Dict[str, Any]:
+        """Gibt umfassenden Hardware-Status zurück"""
+        try:
+            printer_summary = self.printer_monitor.get_printer_summary()
+            
+            return {
+                'timestamp': datetime.now().isoformat(),
+                'monitoring_active': self.monitoring_active,
+                'printer_summary': printer_summary,
+                'tapo_controller_active': True,
+                'cache_status': {
+                    'last_update': self.printer_monitor.last_cache_update.isoformat() 
+                                  if self.printer_monitor.last_cache_update else None,
+                    'cached_printers': len(self.printer_monitor.status_cache)
+                }
+            }
+            
+        except Exception as e:
+            hardware_logger.error(f"Hardware-Status-Abfrage fehlgeschlagen: {str(e)}")
+            return {'error': str(e), 'timestamp': datetime.now().isoformat()}
+    
+    def initialize_system(self) -> Dict[str, Any]:
+        """Initialisiert das gesamte Hardware-System"""
+        results = {
+            'outlet_initialization': {},
+            'auto_discovery': {},
+            'monitoring_started': False
+        }
+        
+        try:
+            # Outlets initialisieren
+            results['outlet_initialization'] = self.printer_monitor.initialize_all_outlets_on_startup()
+            
+            # Auto-Discovery
+            results['auto_discovery'] = self.printer_monitor.auto_discover_tapo_outlets()
+            
+            # Monitoring starten
+            self.start_monitoring()
+            results['monitoring_started'] = True
+            
+            hardware_logger.info("Hardware-System erfolgreich initialisiert")
+            
+        except Exception as e:
+            hardware_logger.error(f"Hardware-System-Initialisierung fehlgeschlagen: {str(e)}")
+            results['error'] = str(e)
+        
+        return results
+
+# ===== GLOBALE INSTANZ =====
+
+# Singleton für Hardware Integration Manager
+_hardware_manager = None
+
+def get_hardware_manager() -> HardwareIntegrationManager:
+    """Gibt die globale Hardware-Manager-Instanz zurück"""
+    global _hardware_manager
+    if _hardware_manager is None:
+        _hardware_manager = HardwareIntegrationManager()
+    return _hardware_manager
+
+# ===== CONVENIENCE FUNCTIONS =====
+
+def toggle_plug(ip: str, state: bool, username: str = None, password: str = None) -> bool:
+    """Convenience-Funktion für Tapo-Steuerung"""
+    manager = get_hardware_manager()
+    return manager.tapo_controller.toggle_plug(ip, state, username, password)
+
+def get_printer_status(printer_id: int = None) -> Dict:
+    """Convenience-Funktion für Drucker-Status"""
+    manager = get_hardware_manager()
+    all_status = manager.printer_monitor.get_live_printer_status()
+    
+    if printer_id:
+        return all_status.get(printer_id, {})
+    return all_status
+
+def get_hardware_summary() -> Dict[str, Any]:
+    """Convenience-Funktion für Hardware-Zusammenfassung"""
+    manager = get_hardware_manager()
+    return manager.get_hardware_status()
+
+def initialize_hardware_system() -> Dict[str, Any]:
+    """Convenience-Funktion für Hardware-Initialisierung"""
+    manager = get_hardware_manager()
+    return manager.initialize_system()
+
+# Legacy-Kompatibilität
+def check_outlet_status(ip: str, username: str = None, password: str = None, 
+                       printer_id: int = None) -> Tuple[bool, str]:
+    """Legacy-Kompatibilität für Outlet-Status"""
+    manager = get_hardware_manager()
+    return manager.tapo_controller.check_outlet_status(ip, username, password, printer_id)
+
+def auto_discover_tapo_outlets() -> Dict[str, bool]:
+    """Legacy-Kompatibilität für Auto-Discovery"""
+    manager = get_hardware_manager()
+    return manager.printer_monitor.auto_discover_tapo_outlets()
+
+def initialize_all_outlets() -> Dict[str, bool]:
+    """Legacy-Kompatibilität für Outlet-Initialisierung"""
+    manager = get_hardware_manager()
+    return manager.printer_monitor.initialize_all_outlets_on_startup()
+
+# CLI Interface
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        manager = get_hardware_manager()
+        
+        if command == "status":
+            status = manager.get_hardware_status()
+            print("=== Hardware Status ===")
+            for key, value in status.items():
+                print(f"{key}: {value}")
+                
+        elif command == "discover":
+            print("Starte Auto-Discovery...")
+            discovered = manager.printer_monitor.auto_discover_tapo_outlets()
+            print(f"Gefundene Outlets: {discovered}")
+            
+        elif command == "init":
+            print("Initialisiere Hardware-System...")
+            results = manager.initialize_system()
+            print(f"Initialisierung: {results}")
+            
+        elif command == "monitor":
+            print("Starte Hardware-Monitoring...")
+            manager.start_monitoring()
+            try:
+                while True:
+                    time.sleep(10)
+                    status = manager.get_hardware_status()
+                    print(f"Status: {status['printer_summary']}")
+            except KeyboardInterrupt:
+                print("Stoppe Monitoring...")
+                manager.stop_monitoring()
+        else:
+            print("Available commands: status, discover, init, monitor")
+    else:
+        print("Hardware Integration Manager - Available commands: status, discover, init, monitor") 

backend/utils/shutdown_manager.py

@@ -1,442 +0,0 @@
-#!/usr/bin/env python3
-"""
-Zentraler Shutdown-Manager für robuste Anwendungsbeendigung
-Koordiniert alle Cleanup-Operationen mit Timeouts und Fehlerbehandlung
-"""
-
-import os
-import sys
-import signal
-import threading
-import time
-import atexit
-from typing import List, Callable, Dict, Any, Optional
-from datetime import datetime
-from contextlib import contextmanager
-import logging
-
-# Logging-Setup mit Fallback
-try:
-    from utils.logging_config import get_logger
-    shutdown_logger = get_logger("shutdown_manager")
-except ImportError:
-    logging.basicConfig(level=logging.INFO)
-    shutdown_logger = logging.getLogger("shutdown_manager")
-
-
-class ShutdownManager:
-    """
-    Zentraler Manager für ordnungsgemäße Anwendungsbeendigung.
-    Koordiniert alle Cleanup-Operationen mit Timeouts und Prioritäten.
-    """
-    
-    def __init__(self, timeout: int = 30):
-        self.timeout = timeout
-        self.is_shutting_down = False
-        self.shutdown_started = None
-        self.cleanup_functions: List[Dict[str, Any]] = []
-        self.components: Dict[str, Any] = {}
-        self._lock = threading.Lock()
-        self._signal_handlers_registered = False
-        
-        # Shutdown-Ereignis für Thread-Koordination
-        self.shutdown_event = threading.Event()
-        
-        # Registriere grundlegende Signal-Handler
-        self._register_signal_handlers()
-        
-        shutdown_logger.info("🔧 Shutdown-Manager initialisiert")
-    
-    def _register_signal_handlers(self):
-        """Registriert plattformspezifische Signal-Handler"""
-        if self._signal_handlers_registered:
-            return
-            
-        try:
-            if os.name == 'nt':  # Windows
-                signal.signal(signal.SIGINT, self._signal_handler)
-                signal.signal(signal.SIGTERM, self._signal_handler)
-                if hasattr(signal, 'SIGBREAK'):
-                    signal.signal(signal.SIGBREAK, self._signal_handler)
-            else:  # Unix/Linux
-                signal.signal(signal.SIGINT, self._signal_handler)
-                signal.signal(signal.SIGTERM, self._signal_handler)
-                signal.signal(signal.SIGHUP, self._signal_handler)
-            
-            self._signal_handlers_registered = True
-            shutdown_logger.debug("✅ Signal-Handler registriert")
-            
-        except Exception as e:
-            shutdown_logger.warning(f"⚠️ Signal-Handler konnten nicht registriert werden: {e}")
-    
-    def _signal_handler(self, signum, frame):
-        """Zentraler Signal-Handler für ordnungsgemäße Beendigung"""
-        if not self.is_shutting_down:
-            shutdown_logger.warning(f"🛑 Signal {signum} empfangen - starte koordiniertes Shutdown")
-            self.shutdown()
-    
-    def register_component(self, name: str, component: Any, stop_method: str = "stop"):
-        """
-        Registriert eine Komponente für ordnungsgemäße Beendigung
-        
-        Args:
-            name: Name der Komponente
-            component: Komponenten-Objekt
-            stop_method: Name der Stopp-Methode (Standard: "stop")
-        """
-        with self._lock:
-            self.components[name] = {
-                'component': component,
-                'stop_method': stop_method,
-                'priority': 1  # Standard-Priorität
-            }
-            shutdown_logger.debug(f"📝 Komponente '{name}' registriert")
-    
-    def register_cleanup_function(self, 
-                                func: Callable, 
-                                name: str, 
-                                priority: int = 1,
-                                timeout: int = 10,
-                                args: tuple = (),
-                                kwargs: dict = None):
-        """
-        Registriert eine Cleanup-Funktion
-        
-        Args:
-            func: Cleanup-Funktion
-            name: Beschreibender Name
-            priority: Priorität (1=hoch, 3=niedrig)
-            timeout: Timeout in Sekunden
-            args: Funktions-Argumente
-            kwargs: Funktions-Keyword-Argumente
-        """
-        if kwargs is None:
-            kwargs = {}
-            
-        cleanup_item = {
-            'function': func,
-            'name': name,
-            'priority': priority,
-            'timeout': timeout,
-            'args': args,
-            'kwargs': kwargs
-        }
-        
-        with self._lock:
-            self.cleanup_functions.append(cleanup_item)
-            # Nach Priorität sortieren (1 = höchste Priorität zuerst)
-            self.cleanup_functions.sort(key=lambda x: x['priority'])
-            
-        shutdown_logger.debug(f"📝 Cleanup-Funktion '{name}' registriert (Priorität: {priority})")
-    
-    def register_queue_manager(self, queue_manager_module):
-        """Registriert den Queue Manager für ordnungsgemäße Beendigung"""
-        try:
-            stop_func = getattr(queue_manager_module, 'stop_queue_manager', None)
-            if stop_func:
-                self.register_cleanup_function(
-                    func=stop_func,
-                    name="Queue Manager",
-                    priority=1,  # Hohe Priorität
-                    timeout=15
-                )
-                shutdown_logger.debug("✅ Queue Manager registriert")
-            else:
-                shutdown_logger.warning("⚠️ Queue Manager stop_queue_manager Funktion nicht gefunden")
-        except Exception as e:
-            shutdown_logger.error(f"❌ Fehler beim Registrieren des Queue Managers: {e}")
-    
-    def register_scheduler(self, scheduler, scheduler_enabled: bool = True):
-        """Registriert den Job-Scheduler für ordnungsgemäße Beendigung"""
-        if not scheduler_enabled or not scheduler:
-            shutdown_logger.debug("Scheduler nicht registriert (deaktiviert oder nicht vorhanden)")
-            return
-            
-        def stop_scheduler():
-            try:
-                if hasattr(scheduler, 'shutdown'):
-                    shutdown_logger.info("🔄 Beende Scheduler mit shutdown()...")
-                    scheduler.shutdown(wait=True)
-                elif hasattr(scheduler, 'stop'):
-                    shutdown_logger.info("🔄 Beende Scheduler mit stop()...")
-                    scheduler.stop()
-                else:
-                    shutdown_logger.warning("⚠️ Scheduler hat keine bekannte Stop-Methode")
-                    
-                shutdown_logger.info("✅ Scheduler erfolgreich gestoppt")
-            except Exception as e:
-                shutdown_logger.error(f"❌ Fehler beim Stoppen des Schedulers: {e}")
-        
-        self.register_cleanup_function(
-            func=stop_scheduler,
-            name="Job Scheduler",
-            priority=1,  # Hohe Priorität
-            timeout=10
-        )
-    
-    def register_database_cleanup(self):
-        """Registriert Datenbank-Cleanup mit robuster Fehlerbehandlung"""
-        def safe_database_cleanup():
-            try:
-                shutdown_logger.info("💾 Führe sicheres Datenbank-Cleanup durch...")
-                
-                # Versuche den neuen DatabaseCleanupManager zu verwenden
-                try:
-                    from utils.database_cleanup import safe_database_cleanup
-                    
-                    result = safe_database_cleanup(force_mode_switch=False)  # Kein riskantes Mode-Switching
-                    
-                    if result.get("success", False):
-                        shutdown_logger.info(f"✅ Datenbank-Cleanup erfolgreich: {', '.join(result.get('operations', []))}")
-                    else:
-                        shutdown_logger.warning(f"⚠️ Datenbank-Cleanup mit Problemen: {', '.join(result.get('errors', []))}")
-                        
-                except ImportError:
-                    shutdown_logger.info("Fallback: Verwende einfaches WAL-Checkpoint...")
-                    
-                    # Einfacher Fallback nur mit WAL-Checkpoint
-                    try:
-                        from models import create_optimized_engine
-                        from sqlalchemy import text
-                        
-                        engine = create_optimized_engine()
-                        
-                        with engine.connect() as conn:
-                            result = conn.execute(text("PRAGMA wal_checkpoint(PASSIVE)")).fetchone()
-                            if result and result[1] > 0:
-                                shutdown_logger.info(f"WAL-Checkpoint: {result[1]} Seiten übertragen")
-                            conn.commit()
-                        
-                        engine.dispose()
-                        shutdown_logger.info("✅ Einfaches Datenbank-Cleanup abgeschlossen")
-                        
-                    except Exception as db_error:
-                        shutdown_logger.error(f"❌ Fehler beim einfachen Datenbank-Cleanup: {db_error}")
-                
-            except Exception as cleanup_error:
-                shutdown_logger.error(f"❌ Fehler beim Datenbank-Cleanup: {cleanup_error}")
-        
-        self.register_cleanup_function(
-            func=safe_database_cleanup,
-            name="Datenbank Cleanup",
-            priority=3,  # Niedrige Priorität (am Ende)
-            timeout=20
-        )
-    
-    def register_windows_thread_manager(self):
-        """Registriert Windows Thread Manager falls verfügbar"""
-        try:
-            if os.name == 'nt':
-                from utils.windows_fixes import get_windows_thread_manager
-                
-                thread_manager = get_windows_thread_manager()
-                if thread_manager:
-                    self.register_cleanup_function(
-                        func=thread_manager.shutdown_all,
-                        name="Windows Thread Manager",
-                        priority=2,
-                        timeout=15
-                    )
-                    shutdown_logger.debug("✅ Windows Thread Manager registriert")
-        except Exception as e:
-            shutdown_logger.debug(f"Windows Thread Manager nicht verfügbar: {e}")
-    
-    @contextmanager
-    def cleanup_timeout(self, timeout: int, operation_name: str):
-        """Context Manager für Timeout-überwachte Operationen"""
-        start_time = time.time()
-        success = False
-        
-        try:
-            yield
-            success = True
-        except Exception as e:
-            elapsed = time.time() - start_time
-            shutdown_logger.error(f"❌ Fehler bei {operation_name} nach {elapsed:.1f}s: {e}")
-            raise
-        finally:
-            elapsed = time.time() - start_time
-            if success:
-                shutdown_logger.debug(f"✅ {operation_name} abgeschlossen in {elapsed:.1f}s")
-            elif elapsed >= timeout:
-                shutdown_logger.warning(f"⏱️ {operation_name} Timeout nach {elapsed:.1f}s")
-    
-    def shutdown(self, exit_code: int = 0):
-        """
-        Führt koordiniertes Shutdown aller registrierten Komponenten durch
-        
-        Args:
-            exit_code: Exit-Code für sys.exit()
-        """
-        if self.is_shutting_down:
-            shutdown_logger.debug("Shutdown bereits in Bearbeitung")
-            return
-        
-        with self._lock:
-            if self.is_shutting_down:
-                return
-                
-            self.is_shutting_down = True
-            self.shutdown_started = datetime.now()
-            
-        shutdown_logger.info("🔄 Starte koordiniertes System-Shutdown...")
-        self.shutdown_event.set()
-        
-        total_start = time.time()
-        
-        try:
-            # 1. Komponenten stoppen (nach Priorität)
-            self._shutdown_components()
-            
-            # 2. Cleanup-Funktionen ausführen (nach Priorität)
-            self._execute_cleanup_functions()
-            
-            total_elapsed = time.time() - total_start
-            shutdown_logger.info(f"✅ Koordiniertes Shutdown abgeschlossen in {total_elapsed:.1f}s")
-            
-        except Exception as e:
-            shutdown_logger.error(f"❌ Fehler beim koordinierten Shutdown: {e}")
-        finally:
-            shutdown_logger.info("🏁 System wird beendet...")
-            sys.exit(exit_code)
-    
-    def _shutdown_components(self):
-        """Stoppt alle registrierten Komponenten"""
-        if not self.components:
-            return
-            
-        shutdown_logger.info(f"🔄 Stoppe {len(self.components)} registrierte Komponenten...")
-        
-        for name, config in self.components.items():
-            try:
-                component = config['component']
-                stop_method = config['stop_method']
-                
-                if hasattr(component, stop_method):
-                    with self.cleanup_timeout(10, f"Komponente {name}"):
-                        method = getattr(component, stop_method)
-                        method()
-                        shutdown_logger.debug(f"✅ Komponente '{name}' gestoppt")
-                else:
-                    shutdown_logger.warning(f"⚠️ Komponente '{name}' hat keine '{stop_method}' Methode")
-                    
-            except Exception as e:
-                shutdown_logger.error(f"❌ Fehler beim Stoppen der Komponente '{name}': {e}")
-    
-    def _execute_cleanup_functions(self):
-        """Führt alle registrierten Cleanup-Funktionen aus"""
-        if not self.cleanup_functions:
-            return
-            
-        shutdown_logger.info(f"🧹 Führe {len(self.cleanup_functions)} Cleanup-Funktionen aus...")
-        
-        for cleanup_item in self.cleanup_functions:
-            try:
-                func = cleanup_item['function']
-                name = cleanup_item['name']
-                timeout = cleanup_item['timeout']
-                args = cleanup_item['args']
-                kwargs = cleanup_item['kwargs']
-                
-                shutdown_logger.debug(f"🔄 Führe Cleanup aus: {name}")
-                
-                with self.cleanup_timeout(timeout, f"Cleanup {name}"):
-                    func(*args, **kwargs)
-                    shutdown_logger.debug(f"✅ Cleanup '{name}' abgeschlossen")
-                    
-            except Exception as e:
-                shutdown_logger.error(f"❌ Fehler bei Cleanup '{cleanup_item['name']}': {e}")
-                # Weiter mit nächstem Cleanup
-                continue
-    
-    def is_shutdown_requested(self) -> bool:
-        """Prüft ob Shutdown angefordert wurde"""
-        return self.shutdown_event.is_set()
-    
-    def get_shutdown_time(self) -> Optional[datetime]:
-        """Gibt den Zeitpunkt des Shutdown-Starts zurück"""
-        return self.shutdown_started
-    
-    def force_shutdown(self, exit_code: int = 1):
-        """Erzwingt sofortiges Shutdown ohne Cleanup"""
-        shutdown_logger.warning("🚨 Erzwinge sofortiges Shutdown ohne Cleanup!")
-        sys.exit(exit_code)
-
-
-# Globaler Shutdown-Manager
-_shutdown_manager: Optional[ShutdownManager] = None
-_manager_lock = threading.Lock()
-
-
-def get_shutdown_manager(timeout: int = 30) -> ShutdownManager:
-    """
-    Singleton-Pattern für globalen Shutdown-Manager
-    
-    Args:
-        timeout: Gesamttimeout für Shutdown-Operationen
-        
-    Returns:
-        ShutdownManager: Globaler Shutdown-Manager
-    """
-    global _shutdown_manager
-    
-    with _manager_lock:
-        if _shutdown_manager is None:
-            _shutdown_manager = ShutdownManager(timeout=timeout)
-            
-            # Registriere atexit-Handler als Fallback
-            atexit.register(_shutdown_manager.shutdown)
-            
-        return _shutdown_manager
-
-
-def register_for_shutdown(component_or_function, 
-                         name: str,
-                         component_stop_method: str = "stop",
-                         priority: int = 1,
-                         timeout: int = 10):
-    """
-    Vereinfachte Registrierung für Shutdown
-    
-    Args:
-        component_or_function: Komponente mit Stop-Methode oder Cleanup-Funktion
-        name: Beschreibender Name
-        component_stop_method: Name der Stop-Methode für Komponenten
-        priority: Priorität (1=hoch, 3=niedrig)
-        timeout: Timeout in Sekunden
-    """
-    manager = get_shutdown_manager()
-    
-    if callable(component_or_function):
-        # Es ist eine Funktion
-        manager.register_cleanup_function(
-            func=component_or_function,
-            name=name,
-            priority=priority,
-            timeout=timeout
-        )
-    else:
-        # Es ist eine Komponente
-        manager.register_component(
-            name=name,
-            component=component_or_function,
-            stop_method=component_stop_method
-        )
-
-
-def shutdown_application(exit_code: int = 0):
-    """
-    Startet koordiniertes Shutdown der Anwendung
-    
-    Args:
-        exit_code: Exit-Code für sys.exit()
-    """
-    manager = get_shutdown_manager()
-    manager.shutdown(exit_code)
-
-
-def is_shutdown_requested() -> bool:
-    """Prüft ob Shutdown angefordert wurde"""
-    if _shutdown_manager:
-        return _shutdown_manager.is_shutdown_requested()
-    return False 

backend/utils/system_control.py

@@ -1,658 +0,0 @@
-#!/usr/bin/env python3
-"""
-Robuste System-Control-Funktionen für wartungsfreien Produktionsbetrieb
-Bietet sichere Restart-, Shutdown- und Kiosk-Verwaltungsfunktionen
-"""
-
-import os
-import sys
-import subprocess
-import time
-import signal
-import psutil
-import threading
-from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Tuple, Any
-from pathlib import Path
-import logging
-import json
-from contextlib import contextmanager
-from enum import Enum
-
-# Logging-Setup
-try:
-    from utils.logging_config import get_logger
-    system_logger = get_logger("system_control")
-except ImportError:
-    logging.basicConfig(level=logging.INFO)
-    system_logger = logging.getLogger("system_control")
-
-
-class SystemOperation(Enum):
-    """Verfügbare System-Operationen"""
-    RESTART = "restart"
-    SHUTDOWN = "shutdown"
-    KIOSK_RESTART = "kiosk_restart"
-    KIOSK_ENABLE = "kiosk_enable"
-    KIOSK_DISABLE = "kiosk_disable"
-    SERVICE_RESTART = "service_restart"
-    EMERGENCY_STOP = "emergency_stop"
-
-
-class SystemControlManager:
-    """
-    Zentraler Manager für alle System-Control-Operationen.
-    Bietet sichere und robuste Funktionen für wartungsfreien Betrieb.
-    """
-    
-    def __init__(self):
-        self.is_windows = os.name == 'nt'
-        self.pending_operations: Dict[str, Dict] = {}
-        self.operation_history: List[Dict] = []
-        self.lock = threading.Lock()
-        
-        # Konfiguration
-        self.config = {
-            "restart_delay": 60,  # Sekunden
-            "shutdown_delay": 30,  # Sekunden
-            "kiosk_restart_delay": 10,  # Sekunden
-            "max_operation_history": 100,
-            "safety_checks": True,
-            "require_confirmation": True
-        }
-        
-        # Service-Namen für verschiedene Plattformen
-        self.services = {
-            "https": "myp-https.service",
-            "kiosk": "myp-kiosk.service",
-            "watchdog": "kiosk-watchdog.service"
-        }
-        
-        system_logger.info("🔧 System-Control-Manager initialisiert")
-    
-    def is_safe_to_operate(self) -> Tuple[bool, str]:
-        """
-        Prüft ob System-Operationen sicher ausgeführt werden können.
-        
-        Returns:
-            Tuple[bool, str]: (is_safe, reason)
-        """
-        try:
-            # Prüfe Systemlast
-            load_avg = psutil.getloadavg()[0] if hasattr(psutil, 'getloadavg') else 0
-            if load_avg > 2.0:
-                return False, f"Hohe Systemlast: {load_avg:.2f}"
-            
-            # Prüfe verfügbaren Speicher
-            memory = psutil.virtual_memory()
-            if memory.percent > 90:
-                return False, f"Wenig verfügbarer Speicher: {memory.percent:.1f}% belegt"
-            
-            # Prüfe aktive Drucker-Jobs
-            try:
-                from models import get_db_session, Job
-                db_session = get_db_session()
-                active_jobs = db_session.query(Job).filter(
-                    Job.status.in_(["printing", "queued", "preparing"])
-                ).count()
-                db_session.close()
-                
-                if active_jobs > 0:
-                    return False, f"Aktive Druckjobs: {active_jobs}"
-            except Exception as e:
-                system_logger.warning(f"Job-Prüfung fehlgeschlagen: {e}")
-            
-            # Prüfe kritische Prozesse
-            critical_processes = ["chromium", "firefox", "python"]
-            for proc in psutil.process_iter(['pid', 'name', 'cpu_percent']):
-                try:
-                    if any(crit in proc.info['name'].lower() for crit in critical_processes):
-                        if proc.info['cpu_percent'] > 80:
-                            return False, f"Kritischer Prozess unter hoher Last: {proc.info['name']}"
-                except (psutil.NoSuchProcess, psutil.AccessDenied):
-                    continue
-            
-            return True, "System ist sicher für Operationen"
-            
-        except Exception as e:
-            system_logger.error(f"Fehler bei Sicherheitsprüfung: {e}")
-            return False, f"Sicherheitsprüfung fehlgeschlagen: {e}"
-    
-    def schedule_operation(self, 
-                          operation: SystemOperation, 
-                          delay_seconds: int = None,
-                          user_id: str = None,
-                          reason: str = None,
-                          force: bool = False) -> Dict[str, Any]:
-        """
-        Plant eine System-Operation mit Verzögerung.
-        
-        Args:
-            operation: Art der Operation
-            delay_seconds: Verzögerung in Sekunden (None = Standard)
-            user_id: ID des anfragenden Benutzers
-            reason: Grund für die Operation
-            force: Sicherheitsprüfungen überspringen
-            
-        Returns:
-            Dict mit Operation-Details
-        """
-        with self.lock:
-            # Sicherheitsprüfung (außer bei Force)
-            if not force and self.config["safety_checks"]:
-                is_safe, safety_reason = self.is_safe_to_operate()
-                if not is_safe:
-                    return {
-                        "success": False,
-                        "error": f"Operation abgelehnt: {safety_reason}",
-                        "safety_check": False
-                    }
-            
-            # Standard-Verzögerung setzen
-            if delay_seconds is None:
-                delay_seconds = {
-                    SystemOperation.RESTART: self.config["restart_delay"],
-                    SystemOperation.SHUTDOWN: self.config["shutdown_delay"],
-                    SystemOperation.KIOSK_RESTART: self.config["kiosk_restart_delay"],
-                    SystemOperation.KIOSK_ENABLE: 5,
-                    SystemOperation.KIOSK_DISABLE: 5,
-                    SystemOperation.SERVICE_RESTART: 10,
-                    SystemOperation.EMERGENCY_STOP: 0
-                }.get(operation, 30)
-            
-            # Operations-ID generieren
-            operation_id = f"{operation.value}_{int(time.time())}"
-            scheduled_time = datetime.now() + timedelta(seconds=delay_seconds)
-            
-            # Operation speichern
-            operation_data = {
-                "id": operation_id,
-                "operation": operation.value,
-                "scheduled_time": scheduled_time,
-                "delay_seconds": delay_seconds,
-                "user_id": user_id,
-                "reason": reason or "Keine Begründung angegeben",
-                "force": force,
-                "created_at": datetime.now(),
-                "status": "scheduled"
-            }
-            
-            self.pending_operations[operation_id] = operation_data
-            
-            # Operation in separatem Thread ausführen
-            thread = threading.Thread(
-                target=self._execute_delayed_operation,
-                args=(operation_id,),
-                daemon=True
-            )
-            thread.start()
-            
-            system_logger.info(f"🕐 Operation geplant: {operation.value} in {delay_seconds}s")
-            
-            return {
-                "success": True,
-                "operation_id": operation_id,
-                "scheduled_time": scheduled_time.isoformat(),
-                "delay_seconds": delay_seconds,
-                "message": f"Operation '{operation.value}' geplant für {scheduled_time.strftime('%H:%M:%S')}"
-            }
-    
-    def _execute_delayed_operation(self, operation_id: str):
-        """
-        Führt geplante Operation nach Verzögerung aus.
-        
-        Args:
-            operation_id: ID der auszuführenden Operation
-        """
-        try:
-            operation_data = self.pending_operations.get(operation_id)
-            if not operation_data:
-                return
-            
-            # Warten bis zur geplanten Zeit
-            scheduled_time = operation_data["scheduled_time"]
-            wait_time = (scheduled_time - datetime.now()).total_seconds()
-            
-            if wait_time > 0:
-                time.sleep(wait_time)
-            
-            # Status aktualisieren
-            operation_data["status"] = "executing"
-            operation_data["executed_at"] = datetime.now()
-            
-            # Operation ausführen
-            operation = SystemOperation(operation_data["operation"])
-            result = self._execute_operation(operation, operation_data)
-            
-            # Ergebnis speichern
-            operation_data["result"] = result
-            operation_data["status"] = "completed" if result.get("success") else "failed"
-            operation_data["completed_at"] = datetime.now()
-            
-            # In Historie verschieben
-            self._move_to_history(operation_id)
-            
-        except Exception as e:
-            system_logger.error(f"Fehler bei verzögerter Operation {operation_id}: {e}")
-            if operation_id in self.pending_operations:
-                self.pending_operations[operation_id]["status"] = "error"
-                self.pending_operations[operation_id]["error"] = str(e)
-                self._move_to_history(operation_id)
-    
-    def _execute_operation(self, operation: SystemOperation, operation_data: Dict) -> Dict[str, Any]:
-        """
-        Führt die eigentliche System-Operation aus.
-        
-        Args:
-            operation: Art der Operation
-            operation_data: Operation-Daten
-            
-        Returns:
-            Dict mit Ergebnis
-        """
-        try:
-            system_logger.info(f"▶️ Führe Operation aus: {operation.value}")
-            
-            if operation == SystemOperation.RESTART:
-                return self._restart_system(operation_data)
-            elif operation == SystemOperation.SHUTDOWN:
-                return self._shutdown_system(operation_data)
-            elif operation == SystemOperation.KIOSK_RESTART:
-                return self._restart_kiosk(operation_data)
-            elif operation == SystemOperation.KIOSK_ENABLE:
-                return self._enable_kiosk(operation_data)
-            elif operation == SystemOperation.KIOSK_DISABLE:
-                return self._disable_kiosk(operation_data)
-            elif operation == SystemOperation.SERVICE_RESTART:
-                return self._restart_services(operation_data)
-            elif operation == SystemOperation.EMERGENCY_STOP:
-                return self._emergency_stop(operation_data)
-            else:
-                return {"success": False, "error": f"Unbekannte Operation: {operation.value}"}
-                
-        except Exception as e:
-            system_logger.error(f"Fehler bei Operation {operation.value}: {e}")
-            return {"success": False, "error": str(e)}
-    
-    def _restart_system(self, operation_data: Dict) -> Dict[str, Any]:
-        """Startet das System neu."""
-        try:
-            system_logger.warning("🔄 System-Neustart wird ausgeführt...")
-            
-            # Cleanup vor Neustart
-            self._cleanup_before_restart()
-            
-            # System-Neustart je nach Plattform
-            if self.is_windows:
-                subprocess.run(["shutdown", "/r", "/t", "0"], check=True)
-            else:
-                subprocess.run(["sudo", "systemctl", "reboot"], check=True)
-            
-            return {"success": True, "message": "System-Neustart initiiert"}
-            
-        except subprocess.CalledProcessError as e:
-            return {"success": False, "error": f"Neustart fehlgeschlagen: {e}"}
-        except Exception as e:
-            return {"success": False, "error": f"Unerwarteter Fehler: {e}"}
-    
-    def _shutdown_system(self, operation_data: Dict) -> Dict[str, Any]:
-        """Fährt das System herunter."""
-        try:
-            system_logger.warning("🛑 System-Shutdown wird ausgeführt...")
-            
-            # Cleanup vor Shutdown
-            self._cleanup_before_restart()
-            
-            # System-Shutdown je nach Plattform
-            if self.is_windows:
-                subprocess.run(["shutdown", "/s", "/t", "0"], check=True)
-            else:
-                subprocess.run(["sudo", "systemctl", "poweroff"], check=True)
-            
-            return {"success": True, "message": "System-Shutdown initiiert"}
-            
-        except subprocess.CalledProcessError as e:
-            return {"success": False, "error": f"Shutdown fehlgeschlagen: {e}"}
-        except Exception as e:
-            return {"success": False, "error": f"Unerwarteter Fehler: {e}"}
-    
-    def _restart_kiosk(self, operation_data: Dict) -> Dict[str, Any]:
-        """Startet nur den Kiosk-Modus neu."""
-        try:
-            system_logger.info("🖥️ Kiosk-Neustart wird ausgeführt...")
-            
-            success_count = 0
-            errors = []
-            
-            # Kiosk-Service neustarten
-            try:
-                subprocess.run(["sudo", "systemctl", "restart", self.services["kiosk"]], 
-                             check=True, timeout=30)
-                success_count += 1
-                system_logger.info("✅ Kiosk-Service neugestartet")
-            except Exception as e:
-                errors.append(f"Kiosk-Service: {e}")
-            
-            # Watchdog-Service neustarten (falls vorhanden)
-            try:
-                subprocess.run(["sudo", "systemctl", "restart", self.services["watchdog"]], 
-                             check=True, timeout=30)
-                success_count += 1
-                system_logger.info("✅ Watchdog-Service neugestartet")
-            except Exception as e:
-                errors.append(f"Watchdog-Service: {e}")
-            
-            # X11-Session neustarten
-            try:
-                subprocess.run(["sudo", "systemctl", "restart", "getty@tty1.service"], 
-                             check=True, timeout=30)
-                success_count += 1
-                system_logger.info("✅ X11-Session neugestartet")
-            except Exception as e:
-                errors.append(f"X11-Session: {e}")
-            
-            if success_count > 0:
-                return {
-                    "success": True, 
-                    "message": f"Kiosk neugestartet ({success_count} Services)",
-                    "errors": errors if errors else None
-                }
-            else:
-                return {
-                    "success": False,
-                    "error": "Alle Kiosk-Neustarts fehlgeschlagen",
-                    "details": errors
-                }
-                
-        except Exception as e:
-            return {"success": False, "error": f"Kiosk-Neustart fehlgeschlagen: {e}"}
-    
-    def _enable_kiosk(self, operation_data: Dict) -> Dict[str, Any]:
-        """Aktiviert den Kiosk-Modus."""
-        try:
-            system_logger.info("🖥️ Kiosk-Modus wird aktiviert...")
-            
-            # Kiosk-Service aktivieren und starten
-            subprocess.run(["sudo", "systemctl", "enable", self.services["kiosk"]], 
-                         check=True, timeout=30)
-            subprocess.run(["sudo", "systemctl", "start", self.services["kiosk"]], 
-                         check=True, timeout=30)
-            
-            # Watchdog aktivieren
-            try:
-                subprocess.run(["sudo", "systemctl", "enable", self.services["watchdog"]], 
-                             check=True, timeout=30)
-                subprocess.run(["sudo", "systemctl", "start", self.services["watchdog"]], 
-                             check=True, timeout=30)
-            except Exception as e:
-                system_logger.warning(f"Watchdog-Aktivierung fehlgeschlagen: {e}")
-            
-            return {"success": True, "message": "Kiosk-Modus aktiviert"}
-            
-        except subprocess.CalledProcessError as e:
-            return {"success": False, "error": f"Kiosk-Aktivierung fehlgeschlagen: {e}"}
-        except Exception as e:
-            return {"success": False, "error": f"Unerwarteter Fehler: {e}"}
-    
-    def _disable_kiosk(self, operation_data: Dict) -> Dict[str, Any]:
-        """Deaktiviert den Kiosk-Modus."""
-        try:
-            system_logger.info("🖥️ Kiosk-Modus wird deaktiviert...")
-            
-            # Kiosk-Service stoppen und deaktivieren
-            subprocess.run(["sudo", "systemctl", "stop", self.services["kiosk"]], 
-                         check=True, timeout=30)
-            subprocess.run(["sudo", "systemctl", "disable", self.services["kiosk"]], 
-                         check=True, timeout=30)
-            
-            # Watchdog stoppen
-            try:
-                subprocess.run(["sudo", "systemctl", "stop", self.services["watchdog"]], 
-                             check=True, timeout=30)
-                subprocess.run(["sudo", "systemctl", "disable", self.services["watchdog"]], 
-                             check=True, timeout=30)
-            except Exception as e:
-                system_logger.warning(f"Watchdog-Deaktivierung fehlgeschlagen: {e}")
-            
-            return {"success": True, "message": "Kiosk-Modus deaktiviert"}
-            
-        except subprocess.CalledProcessError as e:
-            return {"success": False, "error": f"Kiosk-Deaktivierung fehlgeschlagen: {e}"}
-        except Exception as e:
-            return {"success": False, "error": f"Unerwarteter Fehler: {e}"}
-    
-    def _restart_services(self, operation_data: Dict) -> Dict[str, Any]:
-        """Startet wichtige Services neu."""
-        try:
-            system_logger.info("🔄 Services werden neugestartet...")
-            
-            success_count = 0
-            errors = []
-            
-            # HTTPS-Service neustarten
-            try:
-                subprocess.run(["sudo", "systemctl", "restart", self.services["https"]], 
-                             check=True, timeout=60)
-                success_count += 1
-                system_logger.info("✅ HTTPS-Service neugestartet")
-            except Exception as e:
-                errors.append(f"HTTPS-Service: {e}")
-            
-            # NetworkManager neustarten (falls nötig)
-            try:
-                subprocess.run(["sudo", "systemctl", "restart", "NetworkManager"], 
-                             check=True, timeout=30)
-                success_count += 1
-                system_logger.info("✅ NetworkManager neugestartet")
-            except Exception as e:
-                errors.append(f"NetworkManager: {e}")
-            
-            if success_count > 0:
-                return {
-                    "success": True,
-                    "message": f"Services neugestartet ({success_count})",
-                    "errors": errors if errors else None
-                }
-            else:
-                return {
-                    "success": False,
-                    "error": "Alle Service-Neustarts fehlgeschlagen",
-                    "details": errors
-                }
-                
-        except Exception as e:
-            return {"success": False, "error": f"Service-Neustart fehlgeschlagen: {e}"}
-    
-    def _emergency_stop(self, operation_data: Dict) -> Dict[str, Any]:
-        """Notfall-Stopp aller Services."""
-        try:
-            system_logger.warning("🚨 Notfall-Stopp wird ausgeführt...")
-            
-            # Flask-App stoppen
-            try:
-                os.kill(os.getpid(), signal.SIGTERM)
-            except Exception as e:
-                system_logger.error(f"Flask-Stopp fehlgeschlagen: {e}")
-            
-            return {"success": True, "message": "Notfall-Stopp initiiert"}
-            
-        except Exception as e:
-            return {"success": False, "error": f"Notfall-Stopp fehlgeschlagen: {e}"}
-    
-    def _cleanup_before_restart(self):
-        """Führt Cleanup-Operationen vor Neustart/Shutdown aus."""
-        try:
-            system_logger.info("🧹 Cleanup vor Neustart/Shutdown...")
-            
-            # Shutdown-Manager verwenden falls verfügbar
-            try:
-                from utils.shutdown_manager import get_shutdown_manager
-                shutdown_manager = get_shutdown_manager()
-                shutdown_manager.shutdown(exit_code=0)
-            except ImportError:
-                system_logger.warning("Shutdown-Manager nicht verfügbar")
-            
-            # Datenbank-Cleanup
-            try:
-                from utils.database_cleanup import safe_database_cleanup
-                safe_database_cleanup(force_mode_switch=False)
-            except ImportError:
-                system_logger.warning("Database-Cleanup nicht verfügbar")
-            
-            # Cache leeren
-            self._clear_caches()
-            
-        except Exception as e:
-            system_logger.error(f"Cleanup fehlgeschlagen: {e}")
-    
-    def _clear_caches(self):
-        """Leert alle Caches."""
-        try:
-            # User-Cache leeren
-            from app import clear_user_cache, clear_printer_status_cache
-            clear_user_cache()
-            clear_printer_status_cache()
-            
-            # System-Cache leeren
-            if not self.is_windows:
-                subprocess.run(["sudo", "sync"], timeout=10)
-                subprocess.run(["sudo", "echo", "3", ">", "/proc/sys/vm/drop_caches"], 
-                             shell=True, timeout=10)
-                
-        except Exception as e:
-            system_logger.warning(f"Cache-Clearing fehlgeschlagen: {e}")
-    
-    def _move_to_history(self, operation_id: str):
-        """Verschiebt abgeschlossene Operation in Historie."""
-        with self.lock:
-            if operation_id in self.pending_operations:
-                operation_data = self.pending_operations.pop(operation_id)
-                self.operation_history.append(operation_data)
-                
-                # Historie begrenzen
-                if len(self.operation_history) > self.config["max_operation_history"]:
-                    self.operation_history = self.operation_history[-self.config["max_operation_history"]:]
-    
-    def cancel_operation(self, operation_id: str) -> Dict[str, Any]:
-        """
-        Bricht geplante Operation ab.
-        
-        Args:
-            operation_id: ID der abzubrechenden Operation
-            
-        Returns:
-            Dict mit Ergebnis
-        """
-        with self.lock:
-            if operation_id not in self.pending_operations:
-                return {"success": False, "error": "Operation nicht gefunden"}
-            
-            operation_data = self.pending_operations[operation_id]
-            if operation_data["status"] == "executing":
-                return {"success": False, "error": "Operation bereits in Ausführung"}
-            
-            operation_data["status"] = "cancelled"
-            operation_data["cancelled_at"] = datetime.now()
-            self._move_to_history(operation_id)
-            
-            system_logger.info(f"❌ Operation abgebrochen: {operation_id}")
-            
-            return {"success": True, "message": "Operation erfolgreich abgebrochen"}
-    
-    def get_pending_operations(self) -> List[Dict]:
-        """Gibt alle geplanten Operationen zurück."""
-        with self.lock:
-            return list(self.pending_operations.values())
-    
-    def get_operation_history(self, limit: int = 20) -> List[Dict]:
-        """Gibt Operation-Historie zurück."""
-        with self.lock:
-            return self.operation_history[-limit:] if limit else self.operation_history
-    
-    def get_system_status(self) -> Dict[str, Any]:
-        """Gibt aktuellen System-Status zurück."""
-        try:
-            # Service-Status prüfen
-            service_status = {}
-            for name, service in self.services.items():
-                try:
-                    result = subprocess.run(
-                        ["sudo", "systemctl", "is-active", service],
-                        capture_output=True, text=True, timeout=10
-                    )
-                    service_status[name] = result.stdout.strip()
-                except Exception as e:
-                    service_status[name] = f"error: {e}"
-            
-            # System-Metriken
-            memory = psutil.virtual_memory()
-            disk = psutil.disk_usage('/')
-            
-            # Aktive Operations
-            pending_ops = len(self.pending_operations)
-            
-            return {
-                "success": True,
-                "timestamp": datetime.now().isoformat(),
-                "services": service_status,
-                "system_metrics": {
-                    "memory_percent": memory.percent,
-                    "memory_available_gb": memory.available / (1024**3),
-                    "disk_percent": disk.percent,
-                    "disk_free_gb": disk.free / (1024**3),
-                    "load_average": psutil.getloadavg()[0] if hasattr(psutil, 'getloadavg') else 0
-                },
-                "operations": {
-                    "pending": pending_ops,
-                    "history_count": len(self.operation_history)
-                },
-                "is_safe": self.is_safe_to_operate()[0]
-            }
-            
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-
-# Globaler System-Control-Manager
-_system_control_manager: Optional[SystemControlManager] = None
-_control_lock = threading.Lock()
-
-
-def get_system_control_manager() -> SystemControlManager:
-    """
-    Singleton-Pattern für globalen System-Control-Manager.
-    
-    Returns:
-        SystemControlManager: Globaler System-Control-Manager
-    """
-    global _system_control_manager
-    
-    with _control_lock:
-        if _system_control_manager is None:
-            _system_control_manager = SystemControlManager()
-        return _system_control_manager
-
-
-# Convenience-Funktionen
-def schedule_system_restart(delay_seconds: int = 60, user_id: str = None, reason: str = None, force: bool = False) -> Dict[str, Any]:
-    """Plant System-Neustart."""
-    manager = get_system_control_manager()
-    return manager.schedule_operation(SystemOperation.RESTART, delay_seconds, user_id, reason, force)
-
-
-def schedule_system_shutdown(delay_seconds: int = 30, user_id: str = None, reason: str = None, force: bool = False) -> Dict[str, Any]:
-    """Plant System-Shutdown."""
-    manager = get_system_control_manager()
-    return manager.schedule_operation(SystemOperation.SHUTDOWN, delay_seconds, user_id, reason, force)
-
-
-def restart_kiosk(delay_seconds: int = 10, user_id: str = None, reason: str = None) -> Dict[str, Any]:
-    """Plant Kiosk-Neustart."""
-    manager = get_system_control_manager()
-    return manager.schedule_operation(SystemOperation.KIOSK_RESTART, delay_seconds, user_id, reason)
-
-
-def get_system_status() -> Dict[str, Any]:
-    """Gibt System-Status zurück."""
-    manager = get_system_control_manager()
-    return manager.get_system_status()