Projektarbeit-MYP/backend/utils/backup_manager.py

"""
Backup Manager - Wrapper für DatabaseBackupManager
Kompatibilitäts-Wrapper für die vollständige Backup-Implementierung in database_utils.py
"""

from utils.logging_config import get_logger
from utils.database_utils import DatabaseBackupManager

backup_logger = get_logger("backup")

class BackupManager:
    """
    Kompatibilitäts-Wrapper für DatabaseBackupManager.
    Stellt die ursprüngliche API bereit, nutzt aber die vollständige Implementierung.
    """
    
    def __init__(self):
        """Initialisiert den BackupManager mit vollständiger Funktionalität."""
        try:
            self._db_backup_manager = DatabaseBackupManager()
            self.enabled = True
            backup_logger.info("BackupManager erfolgreich initialisiert mit vollständiger Funktionalität")
        except Exception as e:
            backup_logger.error(f"Fehler bei BackupManager-Initialisierung: {e}")
            self._db_backup_manager = None
            self.enabled = False
    
    def create_backup(self, backup_type="manual"):
        """
        Erstellt ein Backup der Datenbank.
        
        Args:
            backup_type (str): Typ des Backups (manual, automatic, emergency)
            
        Returns:
            dict: Ergebnis der Backup-Operation mit success/error Status
        """
        if not self.enabled or not self._db_backup_manager:
            backup_logger.warning("BackupManager nicht verfügbar - Backup-Erstellung fehlgeschlagen")
            return {
                "success": False, 
                "message": "Backup-System nicht verfügbar",
                "error": "BackupManager nicht initialisiert"
            }
        
        try:
            backup_logger.info(f"Starte Backup-Erstellung: {backup_type}")
            
            # Nutze die vollständige DatabaseBackupManager-Implementation
            backup_path = self._db_backup_manager.create_backup(compress=True)
            
            backup_logger.info(f"Backup erfolgreich erstellt: {backup_path}")
            return {
                "success": True,
                "message": f"Backup erfolgreich erstellt: {backup_type}",
                "backup_path": backup_path,
                "backup_type": backup_type
            }
            
        except Exception as e:
            backup_logger.error(f"Fehler bei Backup-Erstellung ({backup_type}): {str(e)}")
            return {
                "success": False,
                "message": f"Backup-Erstellung fehlgeschlagen: {str(e)}",
                "error": str(e),
                "backup_type": backup_type
            }
    
    def restore_backup(self, backup_path):
        """
        Stellt ein Backup wieder her.
        
        Args:
            backup_path (str): Pfad zur Backup-Datei
            
        Returns:
            dict: Ergebnis der Restore-Operation
        """
        if not self.enabled or not self._db_backup_manager:
            backup_logger.warning("BackupManager nicht verfügbar - Restore fehlgeschlagen")
            return {
                "success": False,
                "message": "Backup-System nicht verfügbar",
                "error": "BackupManager nicht initialisiert"
            }
        
        try:
            backup_logger.info(f"Starte Backup-Wiederherstellung: {backup_path}")
            
            # Nutze die vollständige DatabaseBackupManager-Implementation
            success = self._db_backup_manager.restore_backup(backup_path)
            
            if success:
                backup_logger.info(f"Backup erfolgreich wiederhergestellt: {backup_path}")
                return {
                    "success": True,
                    "message": f"Backup erfolgreich wiederhergestellt",
                    "backup_path": backup_path
                }
            else:
                backup_logger.error(f"Backup-Wiederherstellung fehlgeschlagen: {backup_path}")
                return {
                    "success": False,
                    "message": "Backup-Wiederherstellung fehlgeschlagen",
                    "backup_path": backup_path
                }
                
        except Exception as e:
            backup_logger.error(f"Fehler bei Backup-Wiederherstellung ({backup_path}): {str(e)}")
            return {
                "success": False,
                "message": f"Restore fehlgeschlagen: {str(e)}",
                "error": str(e),
                "backup_path": backup_path
            }
    
    def get_backup_list(self):
        """
        Holt eine Liste aller verfügbaren Backups.
        
        Returns:
            dict: Liste der verfügbaren Backups
        """
        if not self.enabled or not self._db_backup_manager:
            return {
                "success": False,
                "message": "Backup-System nicht verfügbar",
                "backups": []
            }
        
        try:
            backups = self._db_backup_manager.list_backups()
            return {
                "success": True,
                "message": f"{len(backups)} Backups gefunden",
                "backups": backups
            }
        except Exception as e:
            backup_logger.error(f"Fehler beim Abrufen der Backup-Liste: {str(e)}")
            return {
                "success": False,
                "message": f"Fehler beim Abrufen der Backups: {str(e)}",
                "backups": []
            }
    
    def cleanup_old_backups(self, keep_count=10):
        """
        Räumt alte Backups auf und behält nur die neuesten.
        
        Args:
            keep_count (int): Anzahl der zu behaltenden Backups
            
        Returns:
            dict: Ergebnis der Cleanup-Operation
        """
        if not self.enabled or not self._db_backup_manager:
            return {
                "success": False,
                "message": "Backup-System nicht verfügbar"
            }
        
        try:
            removed_count = self._db_backup_manager.cleanup_old_backups(keep_count)
            backup_logger.info(f"Backup-Cleanup abgeschlossen: {removed_count} alte Backups entfernt")
            return {
                "success": True,
                "message": f"{removed_count} alte Backups entfernt",
                "removed_count": removed_count,
                "kept_count": keep_count
            }
        except Exception as e:
            backup_logger.error(f"Fehler beim Backup-Cleanup: {str(e)}")
            return {
                "success": False,
                "message": f"Cleanup fehlgeschlagen: {str(e)}",
                "error": str(e)
            }