# -*- coding: utf-8 -*- """ Backup-Zuweisungen für Satellite-Failover. Verwaltet die Zuordnung von Backup-Satellites zu Primär-Satellites für Failover-Szenarien. """ from dataclasses import dataclass, field from datetime import datetime from enum import IntEnum, auto from typing import Any, Callable, TYPE_CHECKING if TYPE_CHECKING: from trixy_core.satellite.satellite import Satellite class BackupStrategy(IntEnum): """Strategie für Backup-Auswahl.""" EXPLICIT = auto() # Explizit zugewiesene Backups SAME_ROOM = auto() # Backup im selben Raum SAME_ZONE = auto() # Backup in derselben Zone ANY_AVAILABLE = auto() # Jeder verfügbare Satellite HEALTH_BASED = auto() # Basierend auf Health-Score @dataclass class BackupAssignment: """ Zuweisung eines Backup-Satellites. Attributes: primary_id: ID des Primär-Satellites backup_id: ID des Backup-Satellites priority: Priorität (höher = bevorzugt) strategy: Verwendete Strategie created_at: Erstellungszeitpunkt last_used: Letzte Verwendung use_count: Anzahl Verwendungen """ primary_id: str backup_id: str priority: int = 0 strategy: BackupStrategy = BackupStrategy.EXPLICIT created_at: datetime = field(default_factory=datetime.now) last_used: datetime | None = None use_count: int = 0 def record_use(self) -> None: """Zeichnet eine Verwendung auf.""" self.last_used = datetime.now() self.use_count += 1 def to_dict(self) -> dict[str, Any]: """Konvertiert zu Dictionary.""" return { "primary_id": self.primary_id, "backup_id": self.backup_id, "priority": self.priority, "strategy": self.strategy.name, "created_at": self.created_at.isoformat(), "last_used": self.last_used.isoformat() if self.last_used else None, "use_count": self.use_count, } class BackupRegistry: """ Registry für Backup-Zuweisungen. Verwaltet die Zuordnung von Backup-Satellites und bietet verschiedene Strategien zur Backup-Auswahl. Example: registry = BackupRegistry() # Explizite Zuweisung registry.assign( primary_id="satellite_1", backup_id="satellite_2", priority=10 ) # Alternative Backups registry.assign("satellite_1", "satellite_3", priority=5) # Backup abrufen backup = registry.get_best_backup("satellite_1") if backup: print(f"Backup: {backup.backup_id}") # Dynamische Backups aktivieren registry.set_strategy(BackupStrategy.SAME_ROOM) """ def __init__( self, default_strategy: BackupStrategy = BackupStrategy.EXPLICIT, get_satellite: Callable[[str], "Satellite | None"] | None = None, get_all_satellites: Callable[[], list["Satellite"]] | None = None, ) -> None: """ Initialisiert die Backup-Registry. Args: default_strategy: Standard-Strategie get_satellite: Funktion zum Abrufen eines Satellites get_all_satellites: Funktion zum Abrufen aller Satellites """ self._strategy = default_strategy self._get_satellite = get_satellite self._get_all_satellites = get_all_satellites self._assignments: dict[str, list[BackupAssignment]] = {} self._health_scores: dict[str, float] = {} @property def strategy(self) -> BackupStrategy: """Aktive Strategie.""" return self._strategy def set_strategy(self, strategy: BackupStrategy) -> None: """Setzt die Strategie.""" self._strategy = strategy def assign( self, primary_id: str, backup_id: str, priority: int = 0, strategy: BackupStrategy = BackupStrategy.EXPLICIT, ) -> BackupAssignment: """ Weist einen Backup-Satellite zu. Args: primary_id: ID des Primär-Satellites backup_id: ID des Backup-Satellites priority: Priorität (höher = bevorzugt) strategy: Verwendete Strategie Returns: Die erstellte Zuweisung """ if primary_id == backup_id: raise ValueError("Primary und Backup können nicht identisch sein") assignment = BackupAssignment( primary_id=primary_id, backup_id=backup_id, priority=priority, strategy=strategy, ) if primary_id not in self._assignments: self._assignments[primary_id] = [] # Prüfe ob bereits vorhanden existing = [a for a in self._assignments[primary_id] if a.backup_id == backup_id] if existing: # Aktualisiere existierende Zuweisung existing[0].priority = priority existing[0].strategy = strategy return existing[0] self._assignments[primary_id].append(assignment) # Nach Priorität sortieren self._assignments[primary_id].sort(key=lambda a: -a.priority) return assignment def unassign(self, primary_id: str, backup_id: str | None = None) -> int: """ Entfernt Backup-Zuweisungen. Args: primary_id: ID des Primär-Satellites backup_id: Optionale spezifische Backup-ID (None = alle) Returns: Anzahl entfernter Zuweisungen """ if primary_id not in self._assignments: return 0 if backup_id is None: count = len(self._assignments[primary_id]) del self._assignments[primary_id] return count before = len(self._assignments[primary_id]) self._assignments[primary_id] = [ a for a in self._assignments[primary_id] if a.backup_id != backup_id ] return before - len(self._assignments[primary_id]) def get_backups(self, primary_id: str) -> list[BackupAssignment]: """ Gibt alle Backups für einen Primary zurück. Args: primary_id: ID des Primär-Satellites Returns: Liste der Backup-Zuweisungen (nach Priorität sortiert) """ return self._assignments.get(primary_id, []).copy() def get_best_backup( self, primary_id: str, exclude: set[str] | None = None, ) -> BackupAssignment | None: """ Gibt das beste verfügbare Backup zurück. Berücksichtigt: - Explizite Zuweisungen - Aktive Strategie - Verfügbarkeit - Health-Score Args: primary_id: ID des Primär-Satellites exclude: IDs die ausgeschlossen werden sollen Returns: Beste Backup-Zuweisung oder None """ exclude = exclude or set() exclude.add(primary_id) # Explizite Zuweisungen zuerst for assignment in self._assignments.get(primary_id, []): if assignment.backup_id in exclude: continue if self._is_backup_available(assignment.backup_id): return assignment # Fallback auf Strategie return self._find_dynamic_backup(primary_id, exclude) def _is_backup_available(self, backup_id: str) -> bool: """Prüft, ob ein Backup verfügbar ist.""" if self._get_satellite is None: return True # Annahme: verfügbar wenn nicht prüfbar backup = self._get_satellite(backup_id) return backup is not None and backup.is_connected def _find_dynamic_backup( self, primary_id: str, exclude: set[str], ) -> BackupAssignment | None: """Findet ein Backup basierend auf der aktiven Strategie.""" if self._get_satellite is None or self._get_all_satellites is None: return None primary = self._get_satellite(primary_id) candidates = self._get_all_satellites() # Filtern: verbunden und nicht ausgeschlossen candidates = [ s for s in candidates if s.is_connected and s.id not in exclude ] if not candidates: return None # Strategie anwenden if self._strategy == BackupStrategy.SAME_ROOM: if primary: candidates = [s for s in candidates if s.room_id == primary.room_id] elif self._strategy == BackupStrategy.HEALTH_BASED: # Nach Health-Score sortieren candidates = sorted( candidates, key=lambda s: self._health_scores.get(s.id, 50.0), reverse=True ) if not candidates: return None # Bestes Kandidat auswählen backup = candidates[0] return BackupAssignment( primary_id=primary_id, backup_id=backup.id, priority=0, strategy=self._strategy, ) def update_health_score(self, satellite_id: str, score: float) -> None: """ Aktualisiert den Health-Score für Strategy-basierte Auswahl. Args: satellite_id: Satellite-ID score: Health-Score (0-100) """ self._health_scores[satellite_id] = score def get_all_assignments(self) -> dict[str, list[BackupAssignment]]: """Gibt alle Zuweisungen zurück.""" return { primary: [a for a in assignments] for primary, assignments in self._assignments.items() } def get_statistics(self) -> dict[str, Any]: """Gibt Statistiken zurück.""" total_assignments = sum( len(assignments) for assignments in self._assignments.values() ) primaries_with_backup = len(self._assignments) total_uses = sum( a.use_count for assignments in self._assignments.values() for a in assignments ) return { "total_assignments": total_assignments, "primaries_with_backup": primaries_with_backup, "total_failover_uses": total_uses, "strategy": self._strategy.name, } def to_dict(self) -> dict[str, Any]: """Serialisiert die Registry.""" return { "strategy": self._strategy.name, "assignments": { primary: [a.to_dict() for a in assignments] for primary, assignments in self._assignments.items() }, } @classmethod def from_dict( cls, data: dict[str, Any], get_satellite: Callable[[str], "Satellite | None"] | None = None, get_all_satellites: Callable[[], list["Satellite"]] | None = None, ) -> "BackupRegistry": """Erstellt eine Registry aus einem Dictionary.""" strategy = BackupStrategy[data.get("strategy", "EXPLICIT")] registry = cls( default_strategy=strategy, get_satellite=get_satellite, get_all_satellites=get_all_satellites, ) for primary_id, assignments in data.get("assignments", {}).items(): for a_data in assignments: registry.assign( primary_id=a_data["primary_id"], backup_id=a_data["backup_id"], priority=a_data.get("priority", 0), strategy=BackupStrategy[a_data.get("strategy", "EXPLICIT")], ) return registry