485 lines
16 KiB
Python
485 lines
16 KiB
Python
import threading
|
|
import time
|
|
import logging
|
|
from typing import Dict, Callable, Any, List, Optional, Union
|
|
from datetime import datetime, timedelta
|
|
|
|
from PyP100 import PyP110
|
|
from sqlalchemy.orm import joinedload
|
|
|
|
from utils.logging_config import get_logger
|
|
from models import Job, Printer, get_db_session
|
|
from config.settings import TAPO_USERNAME, TAPO_PASSWORD
|
|
|
|
# Lazy logger initialization
|
|
_logger = None
|
|
|
|
def get_scheduler_logger():
|
|
"""Lazy initialization of the scheduler logger."""
|
|
global _logger
|
|
if _logger is None:
|
|
_logger = get_logger("scheduler")
|
|
return _logger
|
|
|
|
class BackgroundTaskScheduler:
|
|
"""
|
|
Ein fortschrittlicher Hintergrund-Task-Scheduler, der registrierbare Worker-Funktionen unterstützt.
|
|
Tasks können als Platzhalter registriert und später konfiguriert werden.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self._tasks: Dict[str, Dict[str, Any]] = {}
|
|
self._thread: Optional[threading.Thread] = None
|
|
self._stop_event = threading.Event()
|
|
self._running = False
|
|
self._start_time: Optional[datetime] = None
|
|
|
|
def register_task(self,
|
|
task_id: str,
|
|
func: Callable,
|
|
interval: int = 60,
|
|
args: List = None,
|
|
kwargs: Dict = None,
|
|
enabled: bool = True) -> bool:
|
|
"""
|
|
Registriert eine neue Hintergrund-Task.
|
|
|
|
Args:
|
|
task_id: Eindeutige ID für die Task
|
|
func: Die auszuführende Funktion
|
|
interval: Intervall in Sekunden zwischen den Ausführungen
|
|
args: Positionsargumente für die Funktion
|
|
kwargs: Schlüsselwortargumente für die Funktion
|
|
enabled: Ob die Task aktiviert sein soll
|
|
|
|
Returns:
|
|
bool: True wenn erfolgreich, False wenn die ID bereits existiert
|
|
"""
|
|
logger = get_scheduler_logger()
|
|
if task_id in self._tasks:
|
|
logger.error(f"Task mit ID {task_id} existiert bereits")
|
|
return False
|
|
|
|
self._tasks[task_id] = {
|
|
"func": func,
|
|
"interval": interval,
|
|
"args": args or [],
|
|
"kwargs": kwargs or {},
|
|
"enabled": enabled,
|
|
"last_run": None,
|
|
"next_run": datetime.now() if enabled else None
|
|
}
|
|
|
|
logger.info(f"Task {task_id} registriert: Intervall {interval}s, Enabled: {enabled}")
|
|
return True
|
|
|
|
def update_task(self,
|
|
task_id: str,
|
|
interval: Optional[int] = None,
|
|
args: Optional[List] = None,
|
|
kwargs: Optional[Dict] = None,
|
|
enabled: Optional[bool] = None) -> bool:
|
|
"""
|
|
Aktualisiert die Konfiguration einer bestehenden Task.
|
|
|
|
Args:
|
|
task_id: ID der zu aktualisierenden Task
|
|
interval: Neues Intervall in Sekunden
|
|
args: Neue Positionsargumente
|
|
kwargs: Neue Schlüsselwortargumente
|
|
enabled: Neuer Aktivierungsstatus
|
|
|
|
Returns:
|
|
bool: True wenn erfolgreich, False wenn die ID nicht existiert
|
|
"""
|
|
logger = get_scheduler_logger()
|
|
if task_id not in self._tasks:
|
|
logger.error(f"Task mit ID {task_id} existiert nicht")
|
|
return False
|
|
|
|
task = self._tasks[task_id]
|
|
|
|
if interval is not None:
|
|
task["interval"] = interval
|
|
|
|
if args is not None:
|
|
task["args"] = args
|
|
|
|
if kwargs is not None:
|
|
task["kwargs"] = kwargs
|
|
|
|
if enabled is not None and enabled != task["enabled"]:
|
|
task["enabled"] = enabled
|
|
if enabled:
|
|
task["next_run"] = datetime.now()
|
|
else:
|
|
task["next_run"] = None
|
|
|
|
logger.info(f"Task {task_id} aktualisiert: Intervall {task['interval']}s, Enabled: {task['enabled']}")
|
|
return True
|
|
|
|
def remove_task(self, task_id: str) -> bool:
|
|
"""
|
|
Entfernt eine Task aus dem Scheduler.
|
|
|
|
Args:
|
|
task_id: ID der zu entfernenden Task
|
|
|
|
Returns:
|
|
bool: True wenn erfolgreich, False wenn die ID nicht existiert
|
|
"""
|
|
logger = get_scheduler_logger()
|
|
if task_id not in self._tasks:
|
|
logger.error(f"Task mit ID {task_id} existiert nicht")
|
|
return False
|
|
|
|
del self._tasks[task_id]
|
|
logger.info(f"Task {task_id} entfernt")
|
|
return True
|
|
|
|
def get_task_info(self, task_id: Optional[str] = None) -> Union[Dict, List[Dict]]:
|
|
"""
|
|
Gibt Informationen zu einer Task oder allen Tasks zurück.
|
|
|
|
Args:
|
|
task_id: ID der Task oder None für alle Tasks
|
|
|
|
Returns:
|
|
Dict oder List: Task-Informationen
|
|
"""
|
|
if task_id is not None:
|
|
if task_id not in self._tasks:
|
|
return {}
|
|
|
|
task = self._tasks[task_id]
|
|
return {
|
|
"id": task_id,
|
|
"interval": task["interval"],
|
|
"enabled": task["enabled"],
|
|
"last_run": task["last_run"].isoformat() if task["last_run"] else None,
|
|
"next_run": task["next_run"].isoformat() if task["next_run"] else None
|
|
}
|
|
|
|
return [
|
|
{
|
|
"id": tid,
|
|
"interval": task["interval"],
|
|
"enabled": task["enabled"],
|
|
"last_run": task["last_run"].isoformat() if task["last_run"] else None,
|
|
"next_run": task["next_run"].isoformat() if task["next_run"] else None
|
|
}
|
|
for tid, task in self._tasks.items()
|
|
]
|
|
|
|
def get_tasks(self) -> Dict[str, Dict[str, Any]]:
|
|
"""
|
|
Gibt alle Tasks mit ihren Konfigurationen zurück.
|
|
|
|
Returns:
|
|
Dict: Dictionary mit Task-IDs als Schlüssel und Task-Konfigurationen als Werte
|
|
"""
|
|
return {
|
|
task_id: {
|
|
"interval": task["interval"],
|
|
"enabled": task["enabled"],
|
|
"last_run": task["last_run"].isoformat() if task["last_run"] else None,
|
|
"next_run": task["next_run"].isoformat() if task["next_run"] else None
|
|
}
|
|
for task_id, task in self._tasks.items()
|
|
}
|
|
|
|
def get_uptime(self) -> Optional[str]:
|
|
"""
|
|
Gibt die Laufzeit des Schedulers seit dem Start zurück.
|
|
|
|
Returns:
|
|
str: Formatierte Laufzeit oder None, wenn der Scheduler nicht läuft
|
|
"""
|
|
if not self._running or not self._start_time:
|
|
return None
|
|
|
|
uptime = datetime.now() - self._start_time
|
|
days = uptime.days
|
|
hours, remainder = divmod(uptime.seconds, 3600)
|
|
minutes, seconds = divmod(remainder, 60)
|
|
|
|
if days > 0:
|
|
return f"{days} Tage, {hours} Stunden, {minutes} Minuten"
|
|
elif hours > 0:
|
|
return f"{hours} Stunden, {minutes} Minuten"
|
|
else:
|
|
return f"{minutes} Minuten, {seconds} Sekunden"
|
|
|
|
def start(self) -> bool:
|
|
"""
|
|
Startet den Scheduler.
|
|
|
|
Returns:
|
|
bool: True wenn erfolgreich gestartet, False wenn bereits läuft
|
|
"""
|
|
logger = get_scheduler_logger()
|
|
if self._running:
|
|
logger.warning("Scheduler läuft bereits")
|
|
return False
|
|
|
|
self._stop_event.clear()
|
|
self._thread = threading.Thread(target=self._run)
|
|
self._thread.daemon = True
|
|
self._thread.start()
|
|
self._running = True
|
|
self._start_time = datetime.now()
|
|
|
|
logger.info("Scheduler gestartet")
|
|
return True
|
|
|
|
def stop(self) -> bool:
|
|
"""
|
|
Stoppt den Scheduler.
|
|
|
|
Returns:
|
|
bool: True wenn erfolgreich gestoppt, False wenn nicht läuft
|
|
"""
|
|
logger = get_scheduler_logger()
|
|
if not self._running:
|
|
logger.warning("Scheduler läuft nicht")
|
|
return False
|
|
|
|
self._stop_event.set()
|
|
if self._thread:
|
|
self._thread.join(timeout=5.0)
|
|
|
|
self._running = False
|
|
self._start_time = None
|
|
logger.info("Scheduler gestoppt")
|
|
return True
|
|
|
|
def is_running(self) -> bool:
|
|
"""
|
|
Prüft, ob der Scheduler läuft.
|
|
|
|
Returns:
|
|
bool: True wenn der Scheduler läuft, sonst False
|
|
"""
|
|
return self._running
|
|
|
|
def _run(self) -> None:
|
|
"""Hauptloop des Schedulers."""
|
|
logger = get_scheduler_logger()
|
|
logger.info("Scheduler-Thread gestartet")
|
|
|
|
while not self._stop_event.is_set():
|
|
now = datetime.now()
|
|
|
|
for task_id, task in self._tasks.items():
|
|
if not task["enabled"] or not task["next_run"]:
|
|
continue
|
|
|
|
if now >= task["next_run"]:
|
|
try:
|
|
logger.debug(f"Führe Task {task_id} aus")
|
|
task["func"](*task["args"], **task["kwargs"])
|
|
task["last_run"] = now
|
|
task["next_run"] = now + timedelta(seconds=task["interval"])
|
|
logger.debug(f"Task {task_id} erfolgreich ausgeführt, nächste Ausführung: {task['next_run']}")
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei Ausführung von Task {task_id}: {str(e)}")
|
|
# Trotzdem nächste Ausführung planen
|
|
task["next_run"] = now + timedelta(seconds=task["interval"])
|
|
|
|
# Schlafenszeit berechnen (1 Sekunde oder weniger)
|
|
time.sleep(1)
|
|
|
|
logger.info("Scheduler-Thread beendet")
|
|
|
|
|
|
def toggle_plug(printer_id: int, state: bool) -> bool:
|
|
"""
|
|
Schaltet eine Tapo-Steckdose ein oder aus.
|
|
|
|
Args:
|
|
printer_id: ID des Druckers
|
|
state: True für ein, False für aus
|
|
|
|
Returns:
|
|
bool: True wenn erfolgreich, False wenn fehlgeschlagen
|
|
"""
|
|
logger = get_logger("printers")
|
|
db_session = get_db_session()
|
|
|
|
try:
|
|
printer = db_session.query(Printer).get(printer_id)
|
|
|
|
if not printer:
|
|
logger.error(f"Drucker mit ID {printer_id} nicht gefunden")
|
|
db_session.close()
|
|
return False
|
|
|
|
# Konfiguration validieren und Fallback verwenden
|
|
plug_ip = printer.plug_ip
|
|
plug_username = printer.plug_username or TAPO_USERNAME
|
|
plug_password = printer.plug_password or TAPO_PASSWORD
|
|
|
|
if not plug_ip:
|
|
logger.error(f"Keine Steckdosen-IP für Drucker {printer.name} (ID: {printer_id}) konfiguriert")
|
|
db_session.close()
|
|
return False
|
|
|
|
if not plug_username or not plug_password:
|
|
logger.error(f"Unvollständige Tapo-Konfiguration für Drucker {printer.name} (ID: {printer_id}) - verwende globale Anmeldedaten")
|
|
|
|
# TP-Link Tapo P110 Verbindung herstellen
|
|
logger.debug(f"Verbinde zu Tapo-Steckdose {plug_ip} für Drucker {printer.name}")
|
|
p110 = PyP110.P110(plug_ip, plug_username, plug_password)
|
|
p110.handshake() # Authentifizierung
|
|
p110.login() # Login
|
|
|
|
# Steckdose ein-/ausschalten
|
|
if state:
|
|
p110.turnOn()
|
|
logger.info(f"✅ Steckdose für Drucker {printer.name} (ID: {printer_id}) eingeschaltet")
|
|
else:
|
|
p110.turnOff()
|
|
logger.info(f"✅ Steckdose für Drucker {printer.name} (ID: {printer_id}) ausgeschaltet")
|
|
|
|
db_session.close()
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"❌ Fehler beim Schalten der Steckdose für Drucker {printer_id}: {str(e)}")
|
|
db_session.close()
|
|
return False
|
|
|
|
|
|
def test_tapo_connection(ip_address: str, username: str = None, password: str = None) -> dict:
|
|
"""
|
|
Testet die Verbindung zu einer Tapo-Steckdose und gibt detaillierte Informationen zurück.
|
|
|
|
Args:
|
|
ip_address: IP-Adresse der Steckdose
|
|
username: Benutzername (optional, verwendet globale Konfiguration als Fallback)
|
|
password: Passwort (optional, verwendet globale Konfiguration als Fallback)
|
|
|
|
Returns:
|
|
dict: Testergebnis mit Status und Informationen
|
|
"""
|
|
logger = get_logger("printers")
|
|
result = {
|
|
"success": False,
|
|
"error": None,
|
|
"device_info": None,
|
|
"status": "unknown"
|
|
}
|
|
|
|
# Fallback zu globalen Anmeldedaten
|
|
if not username or not password:
|
|
username = TAPO_USERNAME
|
|
password = TAPO_PASSWORD
|
|
logger.debug(f"🔧 Verwende globale Tapo-Anmeldedaten für {ip_address}")
|
|
|
|
try:
|
|
logger.debug(f"Teste Tapo-Verbindung zu {ip_address}")
|
|
p110 = PyP110.P110(ip_address, username, password)
|
|
p110.handshake() # Authentifizierung
|
|
p110.login() # Login
|
|
|
|
# Geräteinformationen abrufen
|
|
device_info = p110.getDeviceInfo()
|
|
result["device_info"] = device_info
|
|
result["status"] = "on" if device_info.get('device_on', False) else "off"
|
|
result["success"] = True
|
|
|
|
logger.debug(f"✅ Tapo-Verbindung zu {ip_address} erfolgreich")
|
|
|
|
except Exception as e:
|
|
result["error"] = str(e)
|
|
logger.warning(f"❌ Tapo-Verbindung zu {ip_address} fehlgeschlagen: {str(e)}")
|
|
|
|
return result
|
|
|
|
|
|
def check_jobs():
|
|
"""
|
|
Überprüft alle geplanten und laufenden Jobs und schaltet Steckdosen entsprechend.
|
|
|
|
Diese Funktion wird vom Scheduler regelmäßig aufgerufen und:
|
|
1. Prüft, ob geplante Jobs gestartet werden müssen
|
|
2. Prüft, ob laufende Jobs beendet werden müssen
|
|
3. Aktualisiert den Status der Jobs
|
|
"""
|
|
logger = get_logger("jobs")
|
|
db_session = get_db_session()
|
|
|
|
try:
|
|
now = datetime.now()
|
|
|
|
# Geplante Jobs abrufen (mit 5 Minuten Puffer für vergangene Jobs)
|
|
scheduled_jobs = db_session.query(Job).options(
|
|
joinedload(Job.printer)
|
|
).filter(
|
|
Job.status == "scheduled",
|
|
Job.start_at <= now
|
|
).all()
|
|
|
|
# Laufende Jobs abrufen (mit 5 Minuten Sicherheitspuffer)
|
|
running_jobs = db_session.query(Job).options(
|
|
joinedload(Job.printer)
|
|
).filter(
|
|
Job.status == "running",
|
|
Job.end_at <= now - timedelta(minutes=5) # 5 Minuten Sicherheitspuffer
|
|
).all()
|
|
|
|
# Geplante Jobs starten
|
|
for job in scheduled_jobs:
|
|
logger.info(f"Starte geplanten Job {job.id}: {job.name} für Drucker {job.printer.name}")
|
|
|
|
# Steckdose einschalten
|
|
if toggle_plug(job.printer_id, True):
|
|
# Job als laufend markieren
|
|
job.status = "running"
|
|
job.end_at = job.start_at + timedelta(minutes=job.duration_minutes)
|
|
db_session.commit()
|
|
logger.info(f"Job {job.id} gestartet: läuft bis {job.end_at}")
|
|
else:
|
|
logger.error(f"Fehler beim Starten von Job {job.id}: Steckdose konnte nicht eingeschaltet werden")
|
|
|
|
# Beendete Jobs stoppen
|
|
for job in running_jobs:
|
|
logger.info(f"Beende laufenden Job {job.id}: {job.name} für Drucker {job.printer.name}")
|
|
|
|
# Steckdose ausschalten
|
|
if toggle_plug(job.printer_id, False):
|
|
# Job als beendet markieren
|
|
job.status = "finished"
|
|
job.actual_end_time = now
|
|
db_session.commit()
|
|
logger.info(f"Job {job.id} beendet: tatsächliche Endzeit {job.actual_end_time}")
|
|
else:
|
|
logger.error(f"Fehler beim Beenden von Job {job.id}: Steckdose konnte nicht ausgeschaltet werden")
|
|
|
|
db_session.close()
|
|
except Exception as e:
|
|
logger.error(f"Fehler im Job-Scheduler: {str(e)}")
|
|
db_session.close()
|
|
|
|
|
|
# Globaler Scheduler
|
|
scheduler = BackgroundTaskScheduler()
|
|
|
|
# Job-Überprüfungs-Task registrieren (alle 60 Sekunden)
|
|
scheduler.register_task(
|
|
task_id="check_jobs",
|
|
func=check_jobs,
|
|
interval=60,
|
|
enabled=True
|
|
)
|
|
|
|
# Alias für Kompatibilität
|
|
JobScheduler = BackgroundTaskScheduler
|
|
|
|
def get_job_scheduler() -> BackgroundTaskScheduler:
|
|
"""
|
|
Gibt den globalen Job-Scheduler zurück.
|
|
|
|
Returns:
|
|
BackgroundTaskScheduler: Der globale Scheduler
|
|
"""
|
|
return scheduler |