from fastapi import FastAPI, HTTPException, Request, Response from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import FileResponse from pydantic import BaseModel from typing import List, Optional, Dict import asyncio import json import os import posixpath import shutil import time import uuid import db import devices as device_discovery import eta import makemkv_daten import makemkv_key import mounts as mount_verwaltung import notify import presets as preset_auswahl import rohdaten from celery_client import celery_client, start_rip from detection import CDS_DISC_OK, CDS_NO_DISC, CDS_TRAY_OPEN, drive_status from config_validation import validate_config, ConfigValidationError from cache import get as cache_get, init_cache, set as cache_set from ratelimit import check_rate_limit, get_rate_limit_remaining from prescan import PreScan # Auth (JWT/Login/API-Keys) KOMPLETT entfernt — Commander-Entscheid 24.07.2026: # Rippy läuft ausschließlich im Heimnetz, die Endpoints schützten ohnehin # nichts (kein Login-Flow im UI) und waren damit Placebo-Oberfläche. # Dokumentiert in KONZEPT.md Abschnitt 10. app = FastAPI( title="Rippy API", description="API für das automatische Ripping-System", version="1.0.0" ) @app.on_event("startup") async def startup_event(): """Initialisiere Cache + Datenbank, validiere Konfiguration, starte Disc-Wache.""" init_cache() db.init_db() try: validate_config() except ConfigValidationError as e: print(f"⚠️ Konfigurations-Warnung: {e}") # Gespeicherte Netzwerk-Speicherziele wiederherstellen — NICHT-BLOCKIEREND. # Ein zickiger/langsamer Netz-Mount (der CIFS-Schreibtest in mounten() kann im # Kernel haengen, wait_for_response) darf den API-Start NIE blockieren. Vorfall # 24.07.: ~5 min "Waiting for application startup", kein Endpoint bedient, bis der # soft-Mount per Timeout abbrach. Darum im Hintergrund: die Mounts stellen sich # her, sobald der Server antwortet, ohne die API auszubremsen. def remount(): for meldung in mount_verwaltung.alle_remounten(): db.add_log("info", "mounts", meldung) asyncio.create_task(asyncio.to_thread(remount)) asyncio.create_task(disc_watcher()) # MakeMKV-Beta-Key automatisch aktuell halten (wechselt ~monatlich, läuft zum # Monatsende ab) — sonst blockt Blu-ray-Ripping irgendwann still. Taeglicher # Forum-Abgleich; wirkt ohne Rebuild ab dem nächsten Rip. asyncio.create_task(makemkv_key.refresh_loop()) # Worker-Erreichbarkeit im Hintergrund pingen (siehe _ping_knoten) — sonst # kostet JEDER Aufruf von /capabilities eine ganze Sekunde. asyncio.create_task(_ping_schleife()) # Aus demselben Grund im Hintergrund: nachsehen, wo Rohdaten liegen. Ein # schlafendes NAS lässt os.path.isdir bis zum CIFS-Timeout hängen (hier # 10 s gemessen) — und /jobs wird alle 4 Sekunden abgefragt. asyncio.create_task(_rohdaten_schleife()) # Freigaben bewachen: Nach einem Rebuild ist die CIFS-Freigabe reproduzierbar # tot, und der zweite Anlauf hilft (Begründung bei _mount_schleife). asyncio.create_task(_mount_schleife()) # Auto-Pre-Scan-Ergebnisse je Laufwerk: das Dashboard zeigt damit sofort, # WAS im Laufwerk liegt (Titel/Jahr/Poster), ohne dass jemand klicken muss. DISC_CACHE: Dict[str, Dict] = {} def _duplikat_suchen(fingerprint: str): """Wurde eine Disc mit diesem Fingerabdruck schon erfolgreich gerippt?""" if not fingerprint: return None for job in db.list_jobs(200): if job.get("status") != "completed": continue try: meta = json.loads(job.get("meta") or "{}") except ValueError: continue if meta.get("fingerprint") == fingerprint: return { "job_id": job["id"], "title": job.get("title"), "finished_at": job["finished_at"].isoformat() if job.get("finished_at") else None, } return None async def _auto_prescan(pfad: str): """Identifiziert die eingelegte Disc im Hintergrund und cached das Ergebnis.""" if DISC_CACHE.get(pfad, {}).get("_laeuft"): return DISC_CACHE[pfad] = {"_laeuft": True, "title": "Wird erkannt…"} try: prescan = PreScan() ergebnis = await asyncio.to_thread(prescan.scan, pfad) DISC_CACHE[pfad] = ergebnis.to_dict() jahr_text = f" ({ergebnis.year})" if ( ergebnis.year and not ergebnis.title.endswith(f"({ergebnis.year})") ) else "" db.add_log( "info", "watcher", f"Disc erkannt: {ergebnis.title}{jahr_text}" + f" [{ergebnis.disc_type}, Confidence {ergebnis.confidence:.0%}] auf {pfad}", ) # Duplikat-Warnung: dieselbe Disc (Fingerabdruck) schon fertig gerippt? dup = await asyncio.to_thread(_duplikat_suchen, ergebnis.fingerprint) if dup: DISC_CACHE[pfad]["bereits_gerippt"] = dup db.add_log( "warning", "watcher", f"Diese Disc wurde bereits gerippt ({dup.get('title')}, " f"Job {dup['job_id'][:8]}…) — Dashboard zeigt den Hinweis.", ) await _auto_rip_wenn_aktiviert(pfad) except Exception as e: DISC_CACHE.pop(pfad, None) print(f"Auto-Pre-Scan {pfad}: {e}") async def _auto_rip_wenn_aktiviert(pfad: str): """Vollautomatik (Setting autoRipStart): Disc erkannt → Rip startet sofort. Commander-Wunsch 24.07.: wahlweise Popup ODER Automatik. Ziel-Ordner kommt aus den Schnellwahl-Einstellungen (Serie → seriesDir, sonst movieDir; CD → musicDir) — genau wie ein Klick im Dialog. """ einstellungen = await asyncio.to_thread(db.get_settings) if not einstellungen.get("autoRipStart"): return if await asyncio.to_thread(db.has_active_job, pfad): return disc = DISC_CACHE.get(pfad) or {} if disc.get("_laeuft"): return if disc.get("bereits_gerippt"): await asyncio.to_thread( db.add_log, "info", "api", "Automatik übersprungen: Disc wurde bereits gerippt — " 'manuell per „Rippen starten" trotzdem möglich.', ) return basis = einstellungen.get("outputDir") or MEDIA_ROOT meta = disc.get("metadata") or {} if disc.get("disc_type") == "CD": unterordner = einstellungen.get("musicDir") or "music" elif meta.get("type") == "tv": unterordner = einstellungen.get("seriesDir") or "series" else: unterordner = einstellungen.get("movieDir") or "movies" ziel = os.path.normpath(os.path.join(basis, unterordner)) if not unter_wurzel(ziel, MEDIA_ROOT): ziel = None job_id = str(uuid.uuid4()) meta_json = json.dumps({ "year": disc.get("year"), "confidence": disc.get("confidence"), **meta, }) await asyncio.to_thread( db.insert_job, job_id, pfad, None, disc.get("title"), ziel, meta_json ) await asyncio.to_thread( db.add_log, "info", "api", f'Automatik: Rip für „{disc.get("title")}" gestartet ({pfad} → {ziel})', ) start_rip(pfad, job_id, ziel) async def disc_watcher(): """Disc-Wache: pollt die Laufwerke, protokolliert Einwurf/Auswurf und stößt beim Einlegen automatisch den Pre-Scan an (Dashboard-Disc-Karte). Ersetzt den nie gebauten udev-Daemon aus dem KONZEPT: udev funktioniert im Container nicht sinnvoll (kein udevd) — ein 3-Sekunden-Poll per ioctl ist für den Heim-Use-Case gleichwertig und läuft überall. """ bekannt: Dict[str, int] = {} while True: try: for pfad in device_discovery.list_optical_devices(): try: status = await asyncio.to_thread(drive_status, pfad) except OSError: continue vorher = bekannt.get(pfad) if vorher is None: # Erststart: liegt schon eine Disc drin, direkt erkennen if status == CDS_DISC_OK: asyncio.create_task(_auto_prescan(pfad)) elif status != vorher: if status == CDS_DISC_OK: db.add_log("info", "watcher", f"Disc eingelegt: {pfad}") asyncio.create_task(_auto_prescan(pfad)) elif status in (CDS_NO_DISC, CDS_TRAY_OPEN) and vorher == CDS_DISC_OK: db.add_log("info", "watcher", f"Disc entfernt: {pfad}") DISC_CACHE.pop(pfad, None) bekannt[pfad] = status except Exception as e: print(f"Disc-Wache: {e}") await asyncio.sleep(3) # Middleware für Rate-Limiting (pro Client-IP — schützt vor Amok-Skripten, # nicht vor Angreifern; Rippy ist Heimnetz-only) @app.middleware("http") async def rate_limit_middleware(request: Request, call_next): """Rate-Limiting Middleware.""" client_ip = request.client.host # Rate Limit prüfen if not check_rate_limit(client_ip): return Response( content=json.dumps({"error": "Rate limit exceeded"}), status_code=429, media_type="application/json" ) response = await call_next(request) # Füge Rate-Limit Header hinzu remaining = get_rate_limit_remaining(client_ip) response.headers["X-RateLimit-Remaining"] = str(remaining) return response # CORS hinzufügen app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) class Job(BaseModel): id: str type: str status: str device: str startTime: str endTime: Optional[str] = None progress: int = 0 title: Optional[str] = None error: Optional[str] = None can_retry: bool = False # Rohdaten vorhanden → „Neu komprimieren" sinnvoll meta: Optional[Dict] = None # Disc-Metadaten (Poster/Jahr/Plot) — fürs Thumbnail in der Jobliste + aktivem Rip-Header # Restzeit-Schätzung (siehe eta.py). -1/"" heißt „noch keine Aussage" — # bewusst ehrlich statt einer erfundenen Minutenzahl. eta_sekunden: int = -1 eta_text: str = "" class Device(BaseModel): id: str name: str type: str path: str status: str model: Optional[str] = None serial: Optional[str] = None disc: Optional[Dict] = None # Auto-Pre-Scan-Ergebnis (Titel/Jahr/Poster) def _job_row_to_model(zeile: dict) -> Job: """DB-Zeile → UI-Form (Worker-Status 'running' heißt im UI 'processing').""" status_map = {"running": "processing"} # meta (JSON-Text) enthält u. a. poster_path — die UI baut daraus das Thumbnail. # Muss hier mit ins Job-Model, sonst schneidet FastAPIs response_model es weg # (Befund 25.07.: meta kam nie in der Jobliste an → Filmstreifen-Platzhalter). try: meta = json.loads(zeile["meta"]) if zeile.get("meta") else None except (ValueError, TypeError): meta = None return Job( id=zeile["id"], type=zeile.get("disc_type") or "unknown", status=status_map.get(zeile["status"], zeile["status"]), device=zeile.get("device") or "", startTime=zeile["created_at"].isoformat() if zeile.get("created_at") else "", endTime=zeile["finished_at"].isoformat() if zeile.get("finished_at") else None, progress=zeile.get("progress") or 0, title=zeile.get("title"), error=zeile.get("error"), meta=meta, ) @app.get("/health") async def health_check(): return {"status": "ok", "service": "api"} @app.get("/health/arbeit") async def health_arbeit(): """Läuft gerade ein Job? — die Frage VOR einem Deploy. ⚠️ Warum es das gibt (26.07.2026, selbst verursacht): Ein `docker compose up -d --build` baut den worker-Container neu und tötet damit einen laufenden Rip. Genau das ist passiert — mitten in einem Blu-ray-Rip, bei 12 %, nach 5,1 GB. Im SAVEPOINT stand die Warnung „nicht deployen, während ein Rip läuft" schon; sie half nichts, weil niemand sie las und nichts sie prüfte. Jetzt fragt `deploy.sh` hier nach und bricht ab. Ein Satz Code gegen eine verlorene Stunde. """ def sammle(): laufend = [ {"id": z["id"], "status": z["status"], "progress": z.get("progress") or 0, "titel": z.get("title") or ""} for z in db.list_jobs() if z.get("status") in ("pending", "running", "ripping", "transcoding", "canceling") ] return {"arbeit": bool(laufend), "jobs": laufend} return await asyncio.to_thread(sammle) @app.get("/health/vorraete") async def health_vorraete(): """Laufen die Hintergrund-Schleifen wirklich? (Diagnose, kein UI-Endpunkt) Zwei Endpunkte hängen an einem Vorrat, den eine Hintergrund-Schleife füllt: /capabilities am Celery-Ping, /jobs an der Rohdaten-Suche. Bleibt so ein Vorrat leer, ist am Endpunkt selbst NICHTS zu sehen — er antwortet nur dauerhaft „nichts gefunden". Genau daran ging am 26.07.2026 eine Stunde verloren. `alter_sekunden` sagt, wann die Schleife das letzte Mal durchgelaufen ist; wächst der Wert über das Intervall, läuft sie nicht mehr. """ jetzt = time.monotonic() return { "ping": { "knoten": _PING["knoten"], "alter_sekunden": None if _PING["stand"] < 0 else round(jetzt - _PING["stand"], 1), "intervall": PING_INTERVALL_SEKUNDEN, }, "rohdaten": { "jobs_im_vorrat": len(_ROHDATEN["treffer"]), "mit_treffer": sum(1 for v in _ROHDATEN["treffer"].values() if v), "alter_sekunden": None if _ROHDATEN["stand"] is None else round(jetzt - _ROHDATEN["stand"], 1), "intervall": ROHDATEN_INTERVALL_SEKUNDEN, }, "mounts": { "stand": _MOUNT_STAND, "intervall": MOUNT_WACHE_INTERVALL_SEKUNDEN, }, } @app.get("/") async def root(): return { "name": "Rippy", "version": "1.0.0", "description": "Automatisches Ripping-System für CD, DVD und Blu-ray" } def _rohdaten_suchen(job_id: str, work_dir: str) -> list: """Wo liegen die Roh-MKVs dieses Jobs? (Details in rohdaten.py) Geprüft wird mit `rohdaten.verzeichnis_da` und NICHT mit os.path.isdir: Letzteres hing am 26.07.2026 unbegrenzt im Kernel, während Rippy die CIFS-Freigabe neu einhängte — und nahm die Hintergrund-Schleife dauerhaft mit. Ausführliche Begründung dort. Bleibt trotzdem der langsame Weg (mehrere Kind-Prozesse, im schlechtesten Fall je vier Sekunden). Für die Job-Liste, die das Dashboard alle vier Sekunden abfragt, gibt es deshalb den Vorrat unten. """ return rohdaten.suche(job_id, work_dir, os.listdir, rohdaten.verzeichnis_da) # Vorrat für die Job-Liste. Dasselbe Muster wie beim Celery-Ping in # /capabilities (v3.15): Der Endpunkt wird alle 4 Sekunden vom Dashboard # abgefragt und darf NIE am Dateisystem hängen. Ein schlafendes NAS hätte das # Dashboard sonst für 10 Sekunden je Aufruf eingefroren. _ROHDATEN = {"treffer": {}, "stand": None} ROHDATEN_INTERVALL_SEKUNDEN = 30 # --- Mount-Wache ------------------------------------------------------------ # # ⚠️ Warum es die braucht (26.07.2026, DREIMAL in Folge reproduziert): Nach # `docker compose up -d --build` ist die CIFS-Freigabe tot. `mount` meldet # Rückgabewert 0, /proc/mounts zeigt genau eine korrekt aussehende Schicht, die # Erreichbarkeits-Probe antwortet direkt nach dem Mount sogar — und Sekunden # später läuft jeder Zugriff in die Zeitgrenze. Derselbe Ablauf ein zweites Mal, # ein bis zwei Minuten später, stellt sie zuverlässig her. # # ## DIE URSACHE, gemessen am 26.07.2026 # # /proc/fs/cifs/DebugData → Net namespace: 4026532653 # api-Container → net:[4026532653] ← dieselbe # worker-Container → net:[4026532540] ← andere # # Die CIFS-Verbindung lebt in der NETZ-NAMESPACE DES API-CONTAINERS — hier wird # sie eingehängt (nur dieser Container hat CAP_SYS_ADMIN). Wird der Container neu # gebaut, stirbt sein Netz-Namespace und damit der Socket. Der Mount steht danach # weiter in /proc/mounts (er ist per rshared auf den Host propagiert) und sieht # vollkommen gesund aus — aber jeder Zugriff läuft in den CIFS-Timeout. # # Deshalb passiert es nach JEDEM Deploy, deshalb sieht `mount` gesund aus, und # deshalb hilft nur ein echtes Neu-Verbinden aus dem neuen Container heraus. # # Und deshalb ist der api-Container die einzige Stelle, die die NAS-Verbindung # hält: Startet er mitten in einem Rip neu, verliert auch der Worker sein Ziel. # Das strukturell zu lösen (Mount auf dem HOST statt im Container) wäre ein # eigener Umbau und widerspräche „Speicherziele über das UI einhängen". MOUNT_WACHE_INTERVALL_SEKUNDEN = 60 # Erste Prüfung fast sofort: Genau nach einem Deploy ist die Lage kaputt, und # jede Sekunde Wartezeit ist eine Sekunde, in der Rippy sein Ziel nicht sieht. MOUNT_WACHE_ERSTE_PRUEFUNG_SEKUNDEN = 3 _MOUNT_STAND = {} async def _mount_schleife(): """Sieht nach, ob die Freigaben antworten, und verbindet sie sonst neu.""" await asyncio.sleep(MOUNT_WACHE_ERSTE_PRUEFUNG_SEKUNDEN) while True: try: await asyncio.to_thread(_mounts_nachsehen) except Exception as e: # darf nie sterben print(f"Mount-Wache fehlgeschlagen: {type(e).__name__}: {e}") await asyncio.sleep(MOUNT_WACHE_INTERVALL_SEKUNDEN) def _mounts_nachsehen() -> None: """Unerreichbare Freigaben neu verbinden — NIE während ein Job läuft. Neu verbinden heißt `umount -l`; mitten in einem Rip oder Encode wäre das ein Datenverlust. Deshalb steht die Wache still, solange irgendein Job nicht durch ist — auch bei einem wartenden, der jeden Moment anlaufen kann. """ eintraege = db.list_mounts() if not eintraege or db.hat_arbeit(): return for eintrag in eintraege: name = eintrag["name"] # Zum ERKENNEN genügt die einfache, schnelle Probe: Ein toter Mount # antwortet gar nicht, nicht nur manchmal. Die Doppelprobe steckt dort, # wo sie hingehört — in `mounten()`, direkt nach einem frischen Mount, wo # der Wettlauf mit dem lazy umount lauert. Hier kostete sie nur jede # Minute drei Sekunden Warten für nichts. erreichbar = mount_verwaltung.ist_erreichbar(name) vorher = _MOUNT_STAND.get(name) _MOUNT_STAND[name] = erreichbar if erreichbar: if vorher is False: db.add_log("success", "mounts", f"{name}: antwortet wieder") continue # Nur beim ÜBERGANG meckern, nicht jede Minute: Ist das NAS # ausgeschaltet, wäre das sonst ein Log-Wasserfall. if vorher is not False: db.add_log("warning", "mounts", f"{name}: antwortet nicht — wird neu verbunden") begonnen = time.monotonic() try: mount_verwaltung.reparieren( name, eintrag["typ"], eintrag["quelle"], eintrag.get("optionen") or "", eintrag.get("username") or "", eintrag.get("passwort") or "", ) _MOUNT_STAND[name] = True # Die DAUER mit ins Log: Sie war die entscheidende Spur, als eine # Wiederanbindung drei Minuten brauchte (ein `stat` auf dem toten # Mount). Steht sie da, muss man sie nicht erst rekonstruieren. db.add_log("success", "mounts", f"{name}: neu verbunden ({time.monotonic() - begonnen:.1f}s)") except Exception as e: db.add_log( "warning", "mounts", f"{name}: Neuverbinden fehlgeschlagen nach " f"{time.monotonic() - begonnen:.1f}s — {e}") async def _rohdaten_schleife(): """Hält den Rohdaten-Vorrat frisch. Darf nie sterben. Der Fehler wird GEMELDET, nicht verschluckt: Ein `except Exception: pass` stand hier zuerst, und als der Vorrat leer blieb, war nicht zu sehen, warum (Sitzung 26.07.2026 — eine Stunde Rätselraten für eine Zeile Log). """ while True: try: await asyncio.to_thread(_rohdaten_vorrat_auffrischen) except Exception as e: # DB/NAS weg → beim nächsten Durchlauf erneut print(f"Rohdaten-Vorrat fehlgeschlagen: {type(e).__name__}: {e}") await asyncio.sleep(ROHDATEN_INTERVALL_SEKUNDEN) def _rohdaten_vorrat_auffrischen() -> None: """Für jeden fehlgeschlagenen Job nachsehen, wo seine Rohdaten liegen. „Konnte nicht nachsehen" behält die letzte bekannte Antwort: Nach einem Container-Neustart stallt der erste Zugriff auf die CIFS-Freigabe mehrere Sekunden. Ohne diese Regel verschwände in dem Fenster der Knopf „Neu komprimieren", und der Nutzer schlösse daraus, seine 74 GB seien weg. """ work_dir = os.path.normpath((db.get_settings().get("workDir") or "").strip() or "/") alt = _ROHDATEN["treffer"] treffer = {} for zeile in db.list_jobs(): if zeile.get("status") != "failed": continue job_id = zeile["id"] ergebnis = rohdaten.suche_mit_status(job_id, work_dir, os.listdir) if not ergebnis["pfade"] and ergebnis["unklar"] and alt.get(job_id): treffer[job_id] = alt[job_id] # letzte bekannte Antwort halten else: treffer[job_id] = ergebnis["pfade"] _ROHDATEN["treffer"] = treffer _ROHDATEN["stand"] = time.monotonic() def _kann_neu_komprimieren(job: dict, work_dir: str) -> bool: """Nur wenn Rohdaten wirklich noch daliegen — der „Neu komprimieren"-Knopf an einem Job, der nie gerippt hat, war Unsinn (Befund 24.07.). ⚠️ Reparatur 26.07.2026, an der laufenden Instanz gemessen: Gesucht wurde nur im Container-Standard und unter dem AKTUELLEN `workDir`. Der Rip von Job 95afdc89 lag aber auf der NAS, weil beim Start eine Wahl NUR FÜR DIESEN RIP getroffen worden war (gibt es seit v3.15) — und die Einstellung selbst stand auf leer. Ergebnis: `can_retry` war `false`, obwohl 79,6 GB intakt dalagen. Der SAVEPOINT v3.16 behauptete „‚Neu komprimieren' genügt" — den Knopf gab es nicht. Jetzt wird an allen möglichen Orten nachgesehen. Gelesen wird aus dem Vorrat, nicht live: Diese Funktion hängt an /jobs, und das fragt das Dashboard alle 4 Sekunden. Solange der Vorrat einen Job noch nicht kennt (frischer Fehlschlag), zählt der billige lokale Ort — der liegt auf der Container-Platte und antwortet immer sofort. """ if job.get("status") != "failed": return False vorrat = _ROHDATEN["treffer"] if job["id"] in vorrat: return bool(vorrat[job["id"]]) # Nur der lokale Ort: /app/temp ist ein Docker-Volume, os.path.isdir kann # dort nicht hängen (im Gegensatz zu allem unter /app/media). return os.path.isdir(posixpath.join(rohdaten.RAW_STANDARD, job["id"])) @app.get("/jobs", response_model=List[Job]) async def get_jobs(): """Holt alle Jobs aus der Datenbank (neueste zuerst) — inkl. Restzeit. Die ETA entsteht HIER, weil hier der Fortschritt vorbeikommt: jeder Aufruf schreibt die Messreihe im Cache fort (eta.py). Im Browser zu rechnen wäre einfacher gewesen und dreifach schlechter — ein Seitenwechsel setzte die Reihe zurück, zwei Tabs zeigten verschiedene Zahlen, und für einen externen Encoder-Worker gäbe es gar keine (genau dort wollte der Commander sie). """ def sammle(): work_dir = os.path.normpath((db.get_settings().get("workDir") or "").strip() or "/") jetzt = time.monotonic() modelle = [] for z in db.list_jobs(): modell = _job_row_to_model(z) modell.can_retry = _kann_neu_komprimieren(z, work_dir) schaetzung = eta.aktualisiere_und_schaetze( z["id"], z.get("status") or "", z.get("progress") or 0, jetzt, cache_get, cache_set, ) modell.eta_sekunden = schaetzung["sekunden"] modell.eta_text = schaetzung["text"] modelle.append(modell) return modelle return await asyncio.to_thread(sammle) def _rohdaten_groesse(pfade: list) -> tuple: """(Bytes, Dateizahl) der Roh-MKVs (Details in rohdaten.py). Hier bleibt os.* stehen: Diese Funktion wird nur aufgerufen, NACHDEM `verzeichnis_da` den Pfad innerhalb von Sekunden bestätigt hat — der Mount antwortet also. Und sie läuft nur, wenn ein Mensch auf die Zahl wartet (/rohdaten, Löschen), nie in der Hintergrund-Schleife. """ return rohdaten.groesse(pfade, os.listdir, os.path.isfile, os.path.getsize) @app.get("/jobs/{job_id}/rohdaten") async def job_rohdaten(job_id: str): """Was bleibt liegen, wenn dieser Job aus der Liste fliegt? ⚠️ Der Grund für diesen Endpunkt (Vorfall 25.07.2026, v3.14): „Job aus der Liste entfernen" löscht bewusst keine Dateien — richtig, aber der Rohschnitt ist danach UNERREICHBAR, weil Job und Dateien nur über die Job-ID verbunden sind. Ein 75-GB-Rohschnitt verwaiste so unsichtbar auf der Platte: kein Eintrag zeigte mehr darauf, „Neu komprimieren" war unmöglich, und im UI war nichts davon zu sehen. Erst ein Blick per SSH brachte es zutage. Jetzt fragt das UI vor dem Entfernen hier nach und sagt die Zahl. """ job = await asyncio.to_thread(db.get_job, job_id) if not job: raise HTTPException(status_code=404, detail="Job nicht gefunden") def sammle(): work_dir = os.path.normpath((db.get_settings().get("workDir") or "").strip() or "/") pfade = _rohdaten_suchen(job_id, work_dir) bytes_gesamt, dateien = _rohdaten_groesse(pfade) return { "pfade": pfade, "dateien": dateien, "bytes": bytes_gesamt, "gb": round(bytes_gesamt / 1024**3, 1), } return await asyncio.to_thread(sammle) @app.delete("/jobs/{job_id}") async def delete_job(job_id: str, rohdaten: bool = False): """Entfernt einen erledigten Job aus der Liste. `rohdaten=true` löscht zusätzlich die Roh-MKVs. Ohne den Schalter bleiben sie liegen (Standard wie bisher) — das UI nennt vorher die Größe, damit die Entscheidung bewusst fällt und kein Rohschnitt unsichtbar verwaist. """ job = await asyncio.to_thread(db.get_job, job_id) if not job: raise HTTPException(status_code=404, detail="Job nicht gefunden") if job["status"] not in ("completed", "failed"): raise HTTPException(status_code=409, detail="Job läuft noch — erst abbrechen") geloescht_gb = 0.0 if rohdaten: def raeume(): work_dir = os.path.normpath((db.get_settings().get("workDir") or "").strip() or "/") pfade = _rohdaten_suchen(job_id, work_dir) bytes_gesamt, _ = _rohdaten_groesse(pfade) for pfad in pfade: shutil.rmtree(pfad, ignore_errors=True) return round(bytes_gesamt / 1024**3, 1) geloescht_gb = await asyncio.to_thread(raeume) await asyncio.to_thread(db.delete_job, job_id) vermerk = f" (inkl. {geloescht_gb} GB Rohdaten gelöscht)" if rohdaten else "" await asyncio.to_thread( db.add_log, "info", "api", f"Job {job_id} aus der Liste entfernt{vermerk}" ) return {"status": "deleted", "rohdaten_geloescht_gb": geloescht_gb} @app.delete("/jobs") async def delete_finished_jobs(): """Räumt ALLE erledigten Jobs (fertig + fehlgeschlagen) aus der Liste.""" anzahl = await asyncio.to_thread(db.delete_finished_jobs) await asyncio.to_thread( db.add_log, "info", "api", f"Job-Liste aufgeräumt ({anzahl} erledigte Einträge entfernt)" ) return {"deleted": anzahl} class JobCreateRequest(BaseModel): device_path: Optional[str] = None device: Optional[str] = None # Alias, so schickt es das UI title: Optional[str] = None target_dir: Optional[str] = None # Ablageziel unter /app/media (frei wählbar) series: Optional[str] = None # Serien-Flow: Ablage /Season NN season: Optional[int] = None main_feature_only: Optional[bool] = None # pro Rip; None = Setting gilt titles: Optional[List[int]] = None # exakte Titel-Auswahl (Track-Tabelle) transcode_node: Optional[str] = None # gewählter Encoder-Worker (Celery-Node) # Sprachauswahl für DIESEN Rip (ISO-639-2, z. B. ["deu","eng"]). # Leer = alles behalten. Greift bei der Kompression, nicht beim Rippen — # der Rip bleibt vollständig und verlustfrei (Begründung in # worker/ripping.build_handbrake_cmd). audio_sprachen: Optional[List[str]] = None untertitel_sprachen: Optional[List[str]] = None # Arbeitsverzeichnis NUR für diesen Rip (Commander-Wunsch 25.07.2026: # beim Start wählbar, nicht global vorgegeben). Leer = der Wert aus # Einstellungen → Verarbeitung, der auch für Vollautomatik-Rips gilt. work_dir: Optional[str] = None MEDIA_ROOT = "/app/media" def _validiere_ziel(target_dir: Optional[str]) -> Optional[str]: """Ziel muss unter /app/media liegen — Pfad-Ausbrüche (..) fliegen raus.""" if not target_dir: return None normalisiert = os.path.normpath(target_dir) if not unter_wurzel(normalisiert, MEDIA_ROOT): raise HTTPException( status_code=422, detail=f"Ziel muss unter {MEDIA_ROOT} liegen (Shares dort einhängen)", ) return normalisiert @app.post("/jobs", status_code=201) async def create_job(request: JobCreateRequest): """Legt einen Rip-Job an und schickt ihn an den Worker. Das war DIE fehlende Stelle: bis 23.07. gab es keinerlei Code-Pfad, der je einen Rip ausgelöst hat. """ device_path = request.device_path or request.device if not device_path: raise HTTPException(status_code=422, detail="device_path fehlt") if device_path not in device_discovery.list_optical_devices(): raise HTTPException(status_code=404, detail=f"Laufwerk {device_path} nicht gefunden") ziel = _validiere_ziel(request.target_dir) # Titel + Metadaten aus der Disc-Erkennung übernehmen — der Worker nutzt # sie für den Ordnernamen und die Media-Server-Aufbereitung (NFO/Poster), # das UI fürs Job-Detail-Popup. Serien-Flow und Hauptfilm-Wahl wandern # ebenfalls in die Job-Metadaten. titel = request.title meta_dict = {} disc = DISC_CACHE.get(device_path) if disc and not disc.get("_laeuft"): if not titel: titel = disc.get("title") meta_dict = { "year": disc.get("year"), "confidence": disc.get("confidence"), "fingerprint": disc.get("fingerprint"), **(disc.get("metadata") or {}), } if request.series and request.series.strip(): meta_dict["series"] = request.series.strip() meta_dict["season"] = max(1, int(request.season or 1)) if request.main_feature_only is not None: meta_dict["main_feature_only"] = request.main_feature_only if request.titles: titel_liste = sorted({int(t) for t in request.titles if int(t) >= 0})[:200] if titel_liste: meta_dict["titles"] = titel_liste if request.transcode_node: meta_dict["transcode_node"] = request.transcode_node # Sprachauswahl dieses Rips. Nur schreiben, wenn wirklich gewählt wurde — # eine leere Liste würde im Worker als „alles" gelesen, was derselbe Fall # ist, aber die Absicht verschleiert. for feld, wert in (("audio_sprachen", request.audio_sprachen), ("untertitel_sprachen", request.untertitel_sprachen)): sauber = [str(s).strip().lower() for s in (wert or []) if str(s).strip()] if sauber: meta_dict[feld] = sauber # Arbeitsverzeichnis dieses Rips. Dieselbe Pfad-Härte wie beim Ziel: muss # unter /app/media liegen, damit man nicht versehentlich 100 GB Rohdaten # irgendwohin in den Container schreibt. arbeits_dir = _validiere_ziel(request.work_dir) if arbeits_dir: meta_dict["work_dir"] = arbeits_dir meta_json = json.dumps(meta_dict) if meta_dict else None job_id = str(uuid.uuid4()) await asyncio.to_thread(db.insert_job, job_id, device_path, None, titel, ziel, meta_json) await asyncio.to_thread( db.add_log, "info", "api", f"Job {job_id} angelegt für {device_path}" + (f" → {ziel}" if ziel else ""), ) start_rip(device_path, job_id, ziel) return {"id": job_id, "status": "pending", "device": device_path, "target_dir": ziel} @app.get("/jobs/{job_id}/detail") async def get_job_detail(job_id: str): """Alles zu EINEM Job — fürs Klick-Popup auf den Titel in „Neueste Jobs": Metadaten (Poster/Jahr/Beschreibung), Ziel, Ausgabepfad, Fehler.""" job = await asyncio.to_thread(db.get_job, job_id) if not job: raise HTTPException(status_code=404, detail="Job nicht gefunden") detail = _job_row_to_model(job).dict() detail["target_dir"] = job.get("target_dir") detail["output_path"] = job.get("output_path") try: detail["meta"] = json.loads(job["meta"]) if job.get("meta") else None except ValueError: detail["meta"] = None return detail def _sicherer_dateiname(name: str) -> bool: """Pure Funktion (testbar): nur nackte Dateinamen, keine Pfad-Tricks.""" return bool(name) and "/" not in name and "\\" not in name and not name.startswith(".") def unter_wurzel(pfad: str, wurzel: str) -> bool: """Liegt `pfad` wirklich unterhalb von `wurzel` (oder IST es die Wurzel)? Pure Funktion, testbar. Ein nacktes `startswith()` genügt hier nicht: „/app/media-boese/x" beginnt mit „/app/media", liegt aber außerhalb (Befund 25.07.2026 bei der Durchsicht). Deshalb Gleichheit ODER Wurzel samt Trennzeichen. Erwartet werden normalisierte Container-Pfade mit „/". """ if not pfad or not wurzel: return False sauber = wurzel.rstrip("/") or "/" return pfad == sauber or pfad.startswith(sauber + "/") def _job_ausgabeordner(job: dict) -> str: """Validierter Ausgabeordner eines Jobs — strikt unter /app/media.""" ausgabe = os.path.normpath(job.get("output_path") or "") if not unter_wurzel(ausgabe, MEDIA_ROOT): raise HTTPException(status_code=404, detail="Job hat keinen Ausgabeordner unter /app/media") return ausgabe @app.get("/jobs/{job_id}/files") async def list_job_files(job_id: str): """Dateien eines fertigen Jobs — fürs Download-Menü im Dashboard. Vorher kam man an fertige MKVs nur per scp auf die VM. """ job = await asyncio.to_thread(db.get_job, job_id) if not job: raise HTTPException(status_code=404, detail="Job nicht gefunden") ausgabe = _job_ausgabeordner(job) def liste(): try: eintraege = sorted(os.listdir(ausgabe)) except OSError: return None dateien = [] for name in eintraege: pfad = os.path.join(ausgabe, name) if os.path.isfile(pfad): try: groesse_mb = round(os.path.getsize(pfad) / 1024**2, 1) except OSError: groesse_mb = None dateien.append({"name": name, "size_mb": groesse_mb}) return dateien dateien = await asyncio.to_thread(liste) if dateien is None: raise HTTPException( status_code=404, detail="Ausgabeordner nicht lesbar — Job noch nicht fertig oder Ziel ausgehängt?", ) return {"job_id": job_id, "output_path": ausgabe, "files": dateien} @app.get("/jobs/{job_id}/files/{dateiname}") async def download_job_file(job_id: str, dateiname: str): """Streamt EINE Datei eines Jobs zum Browser (Download-Knopf). Pfad-Validierung strikt: nackter Dateiname, realpath muss unter /app/media bleiben (kein ..-Ausbruch, kein Symlink nach draußen). """ job = await asyncio.to_thread(db.get_job, job_id) if not job: raise HTTPException(status_code=404, detail="Job nicht gefunden") ausgabe = _job_ausgabeordner(job) if not _sicherer_dateiname(dateiname): raise HTTPException(status_code=422, detail="Ungültiger Dateiname") pfad = os.path.join(ausgabe, dateiname) def pruefe(): return os.path.isfile(pfad) and unter_wurzel(os.path.realpath(pfad), MEDIA_ROOT) if not await asyncio.to_thread(pruefe): raise HTTPException(status_code=404, detail="Datei nicht gefunden") return FileResponse(pfad, filename=dateiname, media_type="application/octet-stream") @app.get("/storage-targets") async def storage_targets(): """Verfügbare Ablageziele: Verzeichnisse unter /app/media inkl. Mounts. NFS/SMB-Shares, die auf der VM unter /srv/rippy/media eingehängt werden, tauchen hier automatisch auf (rslave-Bind in docker-compose). """ def sammle(): ziele = [] try: eintraege = sorted(os.listdir(MEDIA_ROOT)) except OSError: return ziele for name in eintraege: pfad = os.path.join(MEDIA_ROOT, name) try: ist_mount = os.path.ismount(pfad) except OSError: # Toter CIFS-Mount (NAS weg) — als Ziel unbrauchbar, aber NICHT # den ganzen Endpoint sprengen (Befund 24.07.: Eintrag flog raus, # ließ sich aber nicht mehr neu anlegen). Überspringen ist ok, # die Mount-Verwaltung (/storage-mounts) zeigt ihn zum Reparieren. continue if not ist_mount and not os.path.isdir(pfad): continue try: nutzung = shutil.disk_usage(pfad) frei_gb = round(nutzung.free / 1024**3, 1) except OSError: frei_gb = None ziele.append({ "name": name, "path": pfad, "is_mount": ist_mount, "free_gb": frei_gb, }) return ziele return await asyncio.to_thread(sammle) @app.post("/devices/{name}/eject") async def eject_device(name: str): """Wirft die Disc aus. Verweigert, wenn auf dem Gerät gerade ein Job läuft.""" device_path = f"/dev/{name}" if device_path not in device_discovery.list_optical_devices(): raise HTTPException(status_code=404, detail=f"Laufwerk {device_path} nicht gefunden") if await asyncio.to_thread(db.has_active_job, device_path): raise HTTPException( status_code=409, detail="Auf diesem Laufwerk läuft gerade ein Job" ) try: await asyncio.to_thread(device_discovery.eject, device_path) except OSError as e: raise HTTPException(status_code=500, detail=f"Auswurf fehlgeschlagen: {e}") await asyncio.to_thread(db.add_log, "info", "api", f"Disc ausgeworfen: {device_path}") return {"status": "ejected", "device": device_path} @app.post("/devices/{name}/scan-tracks") async def scan_tracks_starten(name: str): """Titel-Scan der eingelegten Disc anstoßen (Track-Auswahl-Tabelle). Läuft als Worker-Task (nur der hat makemkvcon + Laufwerk); das UI pollt GET /devices/{name}/tracks. Dauert je nach Disc 20–120 s. """ device_path = f"/dev/{name}" if device_path not in device_discovery.list_optical_devices(): raise HTTPException(status_code=404, detail=f"Laufwerk {device_path} nicht gefunden") if await asyncio.to_thread(db.has_active_job, device_path): raise HTTPException(status_code=409, detail="Auf diesem Laufwerk läuft gerade ein Job") await asyncio.to_thread(db.save_settings, {"status": "running"}, f"tracks:{device_path}") celery_client.send_task("worker.tasks.scan_tracks", args=[device_path]) return {"status": "scanning"} @app.get("/devices/{name}/tracks") async def scan_tracks_ergebnis(name: str): """Ergebnis des Titel-Scans (Polling-Ziel des UI).""" device_path = f"/dev/{name}" daten = await asyncio.to_thread(db.get_settings, f"tracks:{device_path}") if not daten: return {"status": "none"} return daten @app.post("/jobs/{job_id}/retry-transcode") async def retry_transcode(job_id: str): """Stößt die Kompression eines Jobs neu an — OHNE die Disc neu zu rippen. Voraussetzung: die Rohdateien liegen noch irgendwo (bei Kompressions-Fehlschlägen bleiben sie absichtlich erhalten). ⚠️ Reparatur 26.07.2026: Das Roh-Verzeichnis wurde hier aus dem AKTUELLEN Wert von `workDir` errechnet. Wer beim Rip-Start eine andere Ablage gewählt hatte (gibt es seit v3.15), bekam damit einen Pfad, an dem nichts liegt — und der Worker brach mit „Verzeichnis erreichbar, enthält aber keine MKV-Datei" ab. Beim Job 95afdc89 lagen 79,6 GB auf der NAS, gesucht wurde in /app/temp/raw. Jetzt wird nachgesehen statt gerechnet (rohdaten.py). """ job = await asyncio.to_thread(db.get_job, job_id) if not job: raise HTTPException(status_code=404, detail="Job nicht gefunden") if job["status"] in ("running", "pending"): raise HTTPException(status_code=409, detail="Job rippt noch") einstellungen = await asyncio.to_thread(db.get_settings) work_dir = os.path.normpath((einstellungen.get("workDir") or "").strip() or "/") gefunden = await asyncio.to_thread(_rohdaten_suchen, job_id, work_dir) if not gefunden: raise HTTPException( status_code=409, detail=( "Keine Rohdaten zu diesem Job gefunden — weder unter " "/app/temp/raw noch in einem der Ablageziele. Ohne sie muss die " "Disc neu gerippt werden. (Gelöscht? Freigabe nicht eingehängt?)" ), ) raw_dir = gefunden[0] # Zielordner: der Worker schreibt das geplante Ziel beim Rip-Start nach # output_path (sprechender Name statt UUID) — alter Fallback bleibt. basis = job.get("target_dir") or f"{MEDIA_ROOT}/{job.get('disc_type') or 'bluray'}" final_dir = job.get("output_path") or f"{basis}/{job_id}" # An den (beim Rip gewählten) Encoder-Worker routen, sonst geteilte Queue try: meta = json.loads(job.get("meta") or "{}") except ValueError: meta = {} from celery_client import transcode_queue celery_client.send_task( "worker.tasks.transcode_files", args=[job_id, raw_dir, final_dir], queue=transcode_queue(meta.get("transcode_node")), ) await asyncio.to_thread(db.update_job, job_id, status="transcoding", progress=0, error=None) await asyncio.to_thread(db.add_log, "info", "api", f"Job {job_id}: Kompression neu eingereiht") return {"id": job_id, "status": "transcoding"} @app.post("/jobs/{job_id}/cancel") async def cancel_job(job_id: str): """Bittet den Worker, den Job abzubrechen (kooperativ über die DB). Der Worker prüft das Flag bei jedem Fortschritts-Update und beendet den Encoder-Prozess sauber — kein Celery-Task-ID-Tracking nötig. """ job = await asyncio.to_thread(db.get_job, job_id) if not job: raise HTTPException(status_code=404, detail="Job nicht gefunden") if job["status"] in ("completed", "failed"): raise HTTPException(status_code=409, detail="Job ist bereits beendet") await asyncio.to_thread(db.update_job, job_id, status="canceling") await asyncio.to_thread(db.add_log, "warning", "api", f"Job {job_id}: Abbruch angefordert") return {"id": job_id, "status": "canceling"} # --- Worker-Erreichbarkeit: gepingt wird im Hintergrund, nicht im Request --- # # Befund 25.07.2026 (gemessen): /capabilities brauchte **1,010 s** — und zwar # jedes Mal. Ursache ist kein Fehler, sondern das Wesen des Celery-Pings: er # sammelt Antworten bis zum Timeout und kann nicht früher aufhören, weil er # nicht weiß, wie viele Worker noch antworten wollen. Fünf UI-Stellen holen # /capabilities (Dashboard, Einstellungen, Worker-Tab, Wizard, Rip-Dialog) — # jede Seite zahlte also eine Sekunde, obwohl alle anderen Endpunkte unter # 25 ms liegen. Genau das war das „Laggen". # # Jetzt pingt ein Hintergrund-Lauf im festen Takt, und der Endpunkt liest nur # ab. Ist der Vorrat älter als PING_ALTER_MAX (Lauf noch nicht angelaufen oder # gestorben), wird EINMAL synchron gepingt und der Vorrat wieder gefüllt — # lieber eine langsame Antwort als eine falsche. _PING = {"knoten": [], "stand": -1e9} PING_INTERVALL_SEKUNDEN = 5 PING_ALTER_MAX_SEKUNDEN = 30 def _ping_jetzt() -> list: """Pingt sofort (blockiert ~1 s) und füllt den Vorrat.""" try: antworten = celery_client.control.ping(timeout=1.0) or [] knoten = [k for antwort in antworten for k in antwort.keys()] except Exception: knoten = [] _PING["knoten"] = knoten _PING["stand"] = time.monotonic() return knoten def _ping_knoten() -> list: """Erreichbare Celery-Knoten aus dem Vorrat — ohne zu warten.""" if time.monotonic() - _PING["stand"] <= PING_ALTER_MAX_SEKUNDEN: return _PING["knoten"] return _ping_jetzt() async def _ping_schleife(): """Hält den Ping-Vorrat frisch. Darf nie sterben, sonst wird jeder /capabilities-Aufruf wieder langsam.""" while True: try: await asyncio.to_thread(_ping_jetzt) except Exception: # Broker weg → beim nächsten Durchlauf erneut pass await asyncio.sleep(PING_INTERVALL_SEKUNDEN) @app.get("/capabilities") async def capabilities(): """Welche Encoder sind auf welchen Workern WIRKLICH verfügbar — inkl. Live-Erreichbarkeit (Celery-Ping + Herzschlag-Alter). Jeder Worker meldet sich selbst (caps.py, minütlich) — auch optionale Remote-GPU-Worker tauchen hier automatisch auf. """ def sammle(): zeilen = db.list_workers() ping_knoten = _ping_knoten() for zeile in zeilen: # Celery-Knotenname = @. Der Ping liefert ihn voll; # gematcht wird über den Hostname (der Docker-Worker heißt celery@…, # der WORKER_NAME steckt nur in info). Laufen MEHRERE Worker auf # demselben Host (Befund 24.07.), disambiguiert der Name-Teil — # sonst bekäme der falsche Worker den Node. `node` ist der # Routing-Ziel-Knoten für die gezielte Encoder-Wahl. hostname = (zeile.get("info") or {}).get("hostname") or zeile["name"] kandidaten = [k for k in ping_knoten if k.split("@", 1)[-1] == hostname] node = next( (k for k in kandidaten if k.split("@", 1)[0] == zeile["name"]), None ) or (kandidaten[0] if kandidaten else None) zeile["online"] = node is not None zeile["node"] = node return zeilen return {"workers": await asyncio.to_thread(sammle)} @app.get("/presets") async def preset_uebersicht(): """Welche HandBrake-Presets es WIRKLICH gibt — und welches das beste ist. Die Namen kommen von den Workern selbst (`HandBrakeCLI --preset-list`, siehe worker/caps.py), die Staffelung aus presets.py. Damit endet das Raten: vorher standen die Namen fest verdrahtet im UI, und ein Name, den das jeweilige HandBrake nicht kennt, ließ die Kompression scheitern. Commander-Anforderung 26.07.2026: „Bei den Presets soll IMMER das Beste ausgewählt werden" — die Begründung steht bei jeder Empfehlung mit dabei. """ def sammle(): return preset_auswahl.uebersicht(db.list_workers()) return await asyncio.to_thread(sammle) @app.delete("/workers/{name}") async def delete_worker(name: str): """Verwaisten Worker-Eintrag entfernen (alte Container-IDs nach Rebuilds). Ein AKTIVER Worker meldet sich binnen einer Minute einfach wieder an — löschen ist also immer gefahrlos.""" await asyncio.to_thread(db.delete_worker, name) await asyncio.to_thread(db.add_log, "info", "api", f"Worker-Eintrag '{name}' entfernt") return {"status": "deleted"} @app.get("/metadata/tv/{tv_id}/season/{season}") async def tv_season_laufzeiten(tv_id: int, season: int): """Episoden-Laufzeiten einer Staffel (TMDB) — Basis fürs Episoden-Matching des Workers (Serien-Flow).""" def hole(): prescan = PreScan() daten = prescan.tmdb.get_tv_season(tv_id, season) if not daten: return None return { "episodes": [ {"episode": e.get("episode_number"), "runtime": e.get("runtime")} for e in daten.get("episodes", []) ] } ergebnis = await asyncio.to_thread(hole) if ergebnis is None: raise HTTPException(status_code=404, detail="Staffel bei TMDB nicht gefunden") return ergebnis class MediaServerRefreshRequest(BaseModel): url: str api_key: str @app.post("/mediaserver/refresh") async def mediaserver_refresh(request: MediaServerRefreshRequest): """Bibliotheks-Scan von Jellyfin/Emby anstoßen — auch als Verbindungs-Test aus den Einstellungen (POST /Library/Refresh, Header X-Emby-Token).""" import requests as _requests url = request.url.strip().rstrip("/") if not url.startswith(("http://", "https://")): raise HTTPException(status_code=422, detail="Server-URL muss mit http(s):// beginnen") def anstossen(): return _requests.post( url + "/Library/Refresh", headers={"X-Emby-Token": request.api_key.strip()}, timeout=15, ) try: antwort = await asyncio.to_thread(anstossen) except Exception as e: raise HTTPException(status_code=400, detail=f"Server nicht erreichbar: {e}") if antwort.status_code >= 300: raise HTTPException( status_code=400, detail=f"Server antwortete mit HTTP {antwort.status_code} — API-Key prüfen " "(Jellyfin: Administration → API-Schlüssel)", ) await asyncio.to_thread(db.add_log, "info", "api", f"Bibliotheks-Refresh angestoßen ({url})") return {"status": "refreshed"} @app.get("/jobs/export") async def export_jobs(): """Job-Historie als CSV (Semikolon + BOM — öffnet sauber in deutschem Excel).""" def baue(): import csv import io puffer = io.StringIO() w = csv.writer(puffer, delimiter=";") w.writerow(["ID", "Titel", "Typ", "Status", "Fortschritt %", "Gerät", "Start", "Ende", "Ablage", "Fehler"]) for j in db.list_jobs(1000): w.writerow([ j["id"], j.get("title") or "", j.get("disc_type") or "", j.get("status") or "", j.get("progress") or 0, j.get("device") or "", j["created_at"].isoformat() if j.get("created_at") else "", j["finished_at"].isoformat() if j.get("finished_at") else "", j.get("output_path") or "", (j.get("error") or "").replace("\n", " "), ]) return puffer.getvalue() inhalt = await asyncio.to_thread(baue) return Response( content="" + inhalt, media_type="text/csv; charset=utf-8", headers={"Content-Disposition": 'attachment; filename="rippy-jobs.csv"'}, ) @app.get("/metadata/status") async def metadata_status(): """Live-Prüfung der Metadaten-Quellen — beantwortet „funktioniert mein Key?" sofort statt durch stilles Wegfallen einer Quelle.""" def pruefe(): from clients.omdb import OMDB_BASE_URL from clients.tmdb import TMDB_BASE_URL status = {} prescan = PreScan() # Bewusst am Cache VORBEI — ein alter Treffer soll keinen kaputten # Key als "ok" tarnen. /configuration ist der kleinste Auth-Aufruf. if not prescan.tmdb.api_key: status["tmdb"] = "kein_key" else: try: antwort = prescan.tmdb.session.get( f"{TMDB_BASE_URL}/configuration", params=prescan.tmdb._key_params, timeout=10, ) status["tmdb"] = "ok" if antwort.status_code == 200 else "fehler" except Exception: status["tmdb"] = "fehler" if not prescan.omdb.api_key: status["omdb"] = "kein_key" else: try: antwort = prescan.omdb.session.get( OMDB_BASE_URL, params={"apikey": prescan.omdb.api_key, "t": "Inception"}, timeout=10, ).json() status["omdb"] = "ok" if antwort.get("Response") == "True" else "fehler" except Exception: status["omdb"] = "fehler" status["jikan"] = "ok" # keyless — fällt nur bei Netzproblemen aus return status return await asyncio.to_thread(pruefe) class MountRequest(BaseModel): name: str type: str # nfs | cifs source: str # host:/export bzw. //host/share options: Optional[str] = None username: Optional[str] = None password: Optional[str] = None @app.get("/storage-mounts") async def get_storage_mounts(): """Konfigurierte Netzwerk-Speicherziele inkl. Live-Status. `mounted` = liegt ein Mount an; `reachable` = ist er auch WIRKLICH nutzbar (toter CIFS-Mount nach NAS-Ausfall: mounted=true, reachable=false → das UI bietet dann „Reparieren" statt den Eintrag verschwinden zu lassen).""" def sammle(): eintraege = db.list_mounts() ergebnis = [] for e in eintraege: gemountet = mount_verwaltung.ist_gemountet(e["name"]) ergebnis.append({ "name": e["name"], "type": e["typ"], "source": e["quelle"], "mounted": gemountet, "reachable": mount_verwaltung.ist_erreichbar(e["name"]) if gemountet else False, "has_credentials": bool(e.get("username")), }) return ergebnis return await asyncio.to_thread(sammle) @app.post("/storage-mounts", status_code=201) async def create_storage_mount(request: MountRequest): """Hängt ein NFS/SMB-Ziel ein und speichert es für den nächsten Start. Existiert der Name schon UND ist erreichbar → 409. Existiert er, ist aber TOT (NAS war weg) → wird mit den neuen Angaben frisch repariert statt stur „Name bereits vergeben" zu melden (Befund 24.07.: man saß sonst fest).""" if not mount_verwaltung.validiere_name(request.name): raise HTTPException(status_code=422, detail="Name: nur a-z, 0-9, Bindestrich (2-31 Zeichen)") if request.type not in ("nfs", "cifs"): raise HTTPException(status_code=422, detail="Typ muss nfs oder cifs sein") vorhanden = any(e["name"] == request.name for e in await asyncio.to_thread(db.list_mounts)) if vorhanden: gemountet = await asyncio.to_thread(mount_verwaltung.ist_gemountet, request.name) erreichbar = gemountet and await asyncio.to_thread(mount_verwaltung.ist_erreichbar, request.name) if erreichbar: raise HTTPException( status_code=409, detail="Name bereits vergeben und aktiv — erst entfernen, dann neu anlegen.", ) # Toter/veralteter Eintrag → reparieren (lazy abhängen + frisch mounten) aktion = mount_verwaltung.reparieren else: aktion = mount_verwaltung.mounten try: schreibbar = await asyncio.to_thread( aktion, request.name, request.type, request.source, request.options or "", request.username or "", request.password or "", ) except RuntimeError as e: raise HTTPException(status_code=400, detail=str(e)) # Bei Reparatur die (evtl. neuen) Zugangsdaten in der DB aktualisieren if vorhanden: await asyncio.to_thread(db.delete_mount, request.name) await asyncio.to_thread( db.save_mount, request.name, request.type, request.source, request.options or "", request.username or "", request.password or "", ) await asyncio.to_thread( db.add_log, "success" if schreibbar else "warning", "mounts", f"Speicherziel '{request.name}' ({request.type}) " + ("repariert" if vorhanden else "eingehängt") + f": {request.source}" + ("" if schreibbar else " — ACHTUNG: NUR LESBAR (Schreibtest fehlgeschlagen)"), ) return {"name": request.name, "mounted": True, "writable": schreibbar, "repaired": vorhanden} @app.post("/storage-mounts/{name}/repair") async def repair_storage_mount(name: str): """Toten/veralteten Mount mit den GESPEICHERTEN Zugangsdaten neu verbinden (Reparieren-Knopf im UI) — ohne dass der Nutzer alles neu eintippt.""" eintrag = next( (e for e in await asyncio.to_thread(db.list_mounts) if e["name"] == name), None ) if not eintrag: raise HTTPException(status_code=404, detail="Speicherziel nicht gefunden") try: schreibbar = await asyncio.to_thread( mount_verwaltung.reparieren, eintrag["name"], eintrag["typ"], eintrag["quelle"], eintrag.get("optionen") or "", eintrag.get("username") or "", eintrag.get("passwort") or "", ) except RuntimeError as e: raise HTTPException(status_code=400, detail=str(e)) await asyncio.to_thread( db.add_log, "success" if schreibbar else "warning", "mounts", f"Speicherziel '{name}' neu verbunden" + ("" if schreibbar else " — NUR LESBAR"), ) return {"name": name, "mounted": True, "writable": schreibbar} @app.get("/storage-mounts/shares") async def list_shares(host: str, username: str = "", password: str = ""): """SMB-Freigaben eines Rechners auflisten (PC/NAS per Klick wählen).""" try: freigaben = await asyncio.to_thread( mount_verwaltung.liste_smb_freigaben, host, username, password ) except RuntimeError as e: raise HTTPException(status_code=400, detail=str(e)) return {"host": host, "shares": freigaben} @app.delete("/storage-mounts/{name}") async def delete_storage_mount(name: str): """Hängt ein Netzwerk-Speicherziel aus und entfernt es aus der Konfiguration.""" try: await asyncio.to_thread(mount_verwaltung.aushaengen, name) except RuntimeError as e: raise HTTPException(status_code=400, detail=str(e)) await asyncio.to_thread(db.delete_mount, name) await asyncio.to_thread(db.add_log, "info", "mounts", f"Speicherziel '{name}' entfernt") return {"status": "removed"} @app.get("/browse") async def browse(path: str = MEDIA_ROOT): """Server-seitiger Ordner-Browser für die Ziel-Auswahl (nur unter /app/media).""" normalisiert = os.path.normpath(path) if not unter_wurzel(normalisiert, MEDIA_ROOT): raise HTTPException(status_code=422, detail=f"Nur Pfade unter {MEDIA_ROOT}") def liste(): try: eintraege = sorted(os.listdir(normalisiert)) except OSError: return None ordner, dateien = [], [] for name in eintraege: voll = os.path.join(normalisiert, name) if os.path.isdir(voll): ordner.append({"name": name, "path": voll}) else: # Dateien MIT anzeigen (Befund 24.07.: der Browser wirkte # „leer", weil er nur Ordner listete — die MKVs im # bluray-Ordner waren unsichtbar). try: groesse_mb = round(os.path.getsize(voll) / 1024**2, 1) except OSError: groesse_mb = None dateien.append({"name": name, "size_mb": groesse_mb}) return ordner, dateien ergebnis = await asyncio.to_thread(liste) if ergebnis is None: raise HTTPException(status_code=404, detail="Ordner nicht lesbar") ordner, dateien = ergebnis eltern = os.path.dirname(normalisiert) if normalisiert != MEDIA_ROOT else None return {"path": normalisiert, "parent": eltern, "dirs": ordner, "files": dateien} class MkdirRequest(BaseModel): path: str name: str @app.post("/browse/mkdir", status_code=201) async def browse_mkdir(request: MkdirRequest): """Neuen Ordner unter /app/media anlegen (Speicherziele-Verwaltung).""" basis = os.path.normpath(request.path) if not unter_wurzel(basis, MEDIA_ROOT): raise HTTPException(status_code=422, detail=f"Nur Pfade unter {MEDIA_ROOT}") name = request.name.strip() if not name or "/" in name or "\\" in name or name.startswith("."): raise HTTPException(status_code=422, detail="Ungültiger Ordnername") ziel = os.path.join(basis, name) try: await asyncio.to_thread(os.makedirs, ziel, exist_ok=True) except OSError as e: raise HTTPException(status_code=400, detail=f"Anlegen fehlgeschlagen: {e}") return {"path": ziel} @app.get("/system/updates") async def system_updates(): """Update-Check für die Kern-Werkzeuge (Einstellungen → System). Quellen: HandBrake über die GitHub-Release-API (releases/latest → tag_name), MakeMKV über die offizielle Download-Seite (Versionsnummer im Seitentext). Ergebnisse werden 12 h gecacht — der Check ist Komfort, kein Dauerfeuer auf fremde Server. Ein Selbst-Update gibt es bewusst NICHT: die Versionen stecken im Worker-Image, das Update ist ein Image-Rebuild (Befehl wird im UI angezeigt). """ import re as _re import requests as _requests from cache import get as cache_get, set as _cache_set def hole_neueste(): ergebnis = {"makemkv": None, "handbrake": None} cached = cache_get("updates:neueste") if cached: return cached try: antwort = _requests.get( "https://api.github.com/repos/HandBrake/HandBrake/releases/latest", timeout=15, headers={"Accept": "application/vnd.github+json"}, ) if antwort.status_code == 200: ergebnis["handbrake"] = (antwort.json().get("tag_name") or "").lstrip("v") except Exception: pass try: antwort = _requests.get("https://www.makemkv.com/download/", timeout=15) treffer = _re.search(r"MakeMKV\s+(\d+\.\d+\.\d+)", antwort.text or "") if treffer: ergebnis["makemkv"] = treffer.group(1) except Exception: pass if ergebnis["makemkv"] or ergebnis["handbrake"]: _cache_set("updates:neueste", ergebnis, expire=12 * 3600) return ergebnis def sammle(): neueste = hole_neueste() installiert = {"makemkv": None, "handbrake": None} for worker in db.list_workers(): info = worker.get("info") or {} installiert["makemkv"] = installiert["makemkv"] or info.get("makemkv") installiert["handbrake"] = installiert["handbrake"] or info.get("handbrake") return { werkzeug: { "installiert": installiert[werkzeug], "verfuegbar": neueste[werkzeug], "update": bool( installiert[werkzeug] and neueste[werkzeug] and installiert[werkzeug] != neueste[werkzeug] ), } for werkzeug in ("makemkv", "handbrake") } return await asyncio.to_thread(sammle) @app.get("/worker-setup/windows") async def worker_setup_windows(): """Windows-Installer-Skript für den nativen Transcode-Worker. Das UI (Einstellungen → Worker → Windows) zeigt den passenden Zwei-Zeilen-Aufruf — alles kommt von dieser Rippy-Instanz selbst. """ pfad = "worker_dist/install.ps1" if not os.path.isfile(pfad): raise HTTPException(status_code=404, detail="Installer nicht im Image — API neu bauen") return FileResponse(pfad, media_type="text/plain", filename="install-rippy-worker.ps1") # GET /worker-setup/windows-gui entfernt am 25.07.2026: ohne Aufrufer, seit die # .exe den .bat-Umweg ersetzt hat (v3.9 — .vbs/.bat wird als gefährlich # geflaggt, Commander-Einwand). Die Datei install-gui.ps1 selbst lebt weiter, # sie steckt in der .exe; nur diese Route war verwaist. @app.get("/worker-setup/windows-exe") async def worker_setup_windows_exe(): """Fertige Windows-Installer-.exe (Rippy-Icon, kein Konsolenfenster). Vorgebaut auf Windows (deploy/worker-windows/build-exe.ps1) — eine Windows-.exe lässt sich nicht auf Linux bauen. Generisch: die GUI fragt die Rippy-Adresse selbst ab, HandBrake + Worker-Code kommen zur Laufzeit.""" pfad = "worker_dist/RippyWorkerSetup.exe" if not os.path.isfile(pfad): raise HTTPException(status_code=404, detail="Installer-.exe nicht im Image — API neu bauen") return FileResponse( pfad, media_type="application/vnd.microsoft.portable-executable", filename="RippyWorkerSetup.exe", ) @app.get("/worker-setup/pfad-map") async def worker_setup_pfad_map(): """Was ein externer Worker für `RIPPY_PATH_MAP` eintragen muss. DER fehlende Anschluss (Befund 26.07.2026): Ein Windows-Worker bekommt von Rippy Container-Pfade (`/app/media/rippy/`). Ohne Übersetzung auf eine Freigabe sieht er sie nicht — und das Mapping setzte niemand. Externes Encoden konnte deshalb nie funktionieren, obwohl das Celery-Routing einwandfrei arbeitete (Job 95afdc89: angenommen, 182 ms später abgelehnt). Geraten wird hier nichts: Rippy hat die Freigabe selbst eingehängt und kennt ihre Quelle. Der Installer holt den Vorschlag von hier und schreibt ihn in start-tray.bat — der Nutzer muss nichts über Container-Pfade wissen. """ def sammle(): vorschlaege = mount_verwaltung.pfad_map_vorschlag(db.list_mounts()) mapping = mount_verwaltung.pfad_map_zeile(vorschlaege) if mapping: hinweis = ( "Diese Freigabe(n) hängt Rippy selbst ein — der Worker erreicht " "sie unter demselben Namen im Netzwerk. Wichtig: Arbeits" "verzeichnis UND Ablage müssen darunter liegen, sonst kann der " "Worker lesen, aber nicht schreiben (oder umgekehrt)." ) elif vorschlaege: hinweis = ( 'Es sind nur NFS-Ziele eingehängt. Windows kann NFS zwar über ' 'die Funktion „Client für NFS" einbinden, die Pfad-Schreibweise ' 'lässt sich aber nicht zuverlässig ableiten — bitte selbst ' 'eintragen, Format: /app/media/=Z:\\ (oder UNC-Pfad).' ) else: hinweis = ( "Rippy hat keine Netzwerk-Freigabe eingehängt. Ein externer " "Worker kann dann NICHTS komprimieren: Rohdaten und Ziel liegen " "auf der Platte der Rippy-Maschine, und dorthin gibt es keinen " "Netzwerk-Zugang. Abhilfe: unter Einstellungen → Speicherziele " "eine Freigabe (NAS oder PC) einhängen und sie als " "Arbeitsverzeichnis UND Ablage wählen." ) return {"mapping": mapping, "eintraege": vorschlaege, "hinweis": hinweis} return await asyncio.to_thread(sammle) @app.get("/worker-setup/paket") async def worker_setup_paket(): """Worker-Quellcode als Zip — der Windows-Installer lädt ihn von hier. Kein git, kein Docker auf der Zielmaschine nötig: die Rippy-Instanz versorgt ihre Worker selbst (Dateien liegen via Dockerfile im Image). """ def baue(): import io import zipfile if not os.path.isdir("worker_dist"): return None puffer = io.BytesIO() with zipfile.ZipFile(puffer, "w", zipfile.ZIP_DEFLATED) as z: for name in sorted(os.listdir("worker_dist")): if name.endswith(".py") and not name.startswith(("test_", "conftest")): z.write(os.path.join("worker_dist", name), name) # requirements.txt für die venv, rippy.ico für die Verknüpfung # auf dem Desktop (sonst trägt sie das Batch-Standardsymbol). elif name in ("requirements.txt", "rippy.ico"): z.write(os.path.join("worker_dist", name), name) return puffer.getvalue() inhalt = await asyncio.to_thread(baue) if not inhalt: raise HTTPException(status_code=404, detail="Worker-Paket nicht im Image — API neu bauen") return Response( content=inhalt, media_type="application/zip", headers={"Content-Disposition": 'attachment; filename="rippy-worker.zip"'}, ) @app.get("/system/info") async def system_info(): """System-Selbstauskunft (Einstellungen → System): Werkzeug-Versionen der Worker, freier Platz auf Media- und Arbeits-Volume, MakeMKV-Key-Status.""" def sammle(): info = {"api_version": app.version, "plaetze": [], "workers": db.list_workers()} for name, pfad in (("Media (/app/media)", MEDIA_ROOT), ("Arbeitsverzeichnis (/app/temp)", "/app/temp")): try: nutzung = shutil.disk_usage(pfad) info["plaetze"].append({ "name": name, "frei_gb": round(nutzung.free / 1024**3, 1), "gesamt_gb": round(nutzung.total / 1024**3, 1), }) except OSError: pass einstellungen = db.get_settings() info["makemkv_key_ui"] = bool((einstellungen.get("makemkvAppKey") or "").strip()) info["webhook_gesetzt"] = bool((einstellungen.get("notificationWebhook") or "").strip()) return info return await asyncio.to_thread(sammle) # Eigene Wurzel für die Datei-Härtung der AACS-Dumps. Bewusst NICHT die # MEDIA_ROOT-Helfer (_sicherer_dateiname/_validiere_ziel/_job_ausgabeordner): # die prüfen hart gegen /app/media und würden hier IMMER 404 liefern. # Das MakeMKV-Datenverzeichnis liegt woanders (in der API auf # /app/makemkv-data, im Worker auf /root/.MakeMKV — laut docker-compose.yml # beides dasselbe Host-Verzeichnis). MAKEMKV_DATA_ROOT = os.path.realpath(makemkv_daten.DATEN_DIR) class KeydbRequest(BaseModel): inhalt: str # voller Text der KEYDB.cfg (kein Upload — es gibt kein python-multipart) @app.get("/system/keydb") async def get_keydb_status(): """Was liegt gerade als KEYDB.cfg im MakeMKV-Datenverzeichnis? Hintergrund (Befund 25.07.2026, live auf der VM nachgemessen): Bei 4K-UHD-Discs meldet MakeMKV "The volume key is unknown for this disc" und holt den Schlüssel NICHT mehr online nach — die dokumentierten Schlüssel-Server lösen weltweit nicht mehr auf. Der einzige heute funktionierende Weg ist eine KEYDB.cfg, die der Nutzer selbst mitbringt. Rippy liefert KEINE Schlüssel mit, lädt keine herunter und verteilt keine — es stellt nur den Platz bereit und zeigt ehrlich an, was dort liegt. Fehlendes Verzeichnis oder fehlende Datei ist der NORMALFALL: dann kommt 200 mit vorhanden=false zurück, niemals 404 oder 500. """ def sammle(): return makemkv_daten.keydb_status() return await asyncio.to_thread(sammle) @app.post("/system/keydb") async def set_keydb(request: KeydbRequest): """Legt die vom Nutzer mitgebrachte KEYDB.cfg ab (atomar, ersetzt die alte). WICHTIG für die Ehrlichkeit: Die Datei wirkt erst beim NÄCHSTEN Rip — makemkvcon liest sie beim Prozessstart, ein bereits laufender Rip merkt nichts davon. Genau so steht es auch im Log-Eintrag. """ # Reine Prüfung (kein Dateisystem) — fängt den häufigsten Bedienfehler ab: # statt der KEYDB.cfg landet die HTML-Fehlerseite eines Downloads im Feld. fehler = makemkv_daten.keydb_pruefen(request.inhalt) if fehler: raise HTTPException(status_code=422, detail=fehler) def schreibe(): return makemkv_daten.keydb_schreiben(request.inhalt) try: status = await asyncio.to_thread(schreibe) except OSError as e: raise HTTPException( status_code=500, detail=( f"KEYDB.cfg konnte nicht geschrieben werden: {e}. " "Prüfe, ob das MakeMKV-Datenverzeichnis auf der VM existiert und " "beschreibbar ist (Standard: /srv/rippy/makemkv)." ), ) await asyncio.to_thread( db.add_log, "success", "makemkv-keydb", f"KEYDB.cfg abgelegt: {status['eintraege']} Zeilen mit Disc-Kennung, " f"{status['groesse_bytes']} Bytes ({status['pfad']}). " "Wirkt erst beim NÄCHSTEN Rip — MakeMKV liest die Datei beim Start.", ) return status @app.delete("/system/keydb") async def delete_keydb(): """Entfernt die KEYDB.cfg (z. B. nach einem Fehlgriff beim Einfügen). Auch hier gilt: Die Änderung wirkt erst beim NÄCHSTEN Rip. Fehlt die Datei schon, ist das kein Fehler — es kommt derselbe Zustand mit vorhanden=false. """ def loesche(): return makemkv_daten.keydb_loeschen() try: status = await asyncio.to_thread(loesche) except OSError as e: raise HTTPException( status_code=500, detail=f"KEYDB.cfg konnte nicht entfernt werden: {e}", ) await asyncio.to_thread( db.add_log, "warning", "makemkv-keydb", "KEYDB.cfg entfernt. Ab dem NÄCHSTEN Rip fehlen die selbst mitgebrachten " "Schlüssel wieder — UHD-Discs können dann erneut an " "'The volume key is unknown for this disc' scheitern.", ) return status @app.get("/system/keystore") async def get_keystore(): """Wie viele Disc-Schlüssel kennt diese Rippy-Installation? Der Schlüsselspeicher (_private_data.tar) ist MakeMKVs eigener Vorrat. Unter Windows füllt MakeMKV ihn selbst; unter Linux nie — deshalb muss er hier von Hand hereingereicht werden (Befund 25.07.2026, siehe makemkv_daten.py). Fehlt er, ist das der Normalfall: 200 mit vorhanden=false, nie 404. """ def sammle(): return makemkv_daten.schluesselspeicher_status() return await asyncio.to_thread(sammle) @app.post("/system/keystore") async def set_keystore(request: Request): """Nimmt den Schlüsselspeicher einer MakeMKV-Installation entgegen. Der Rohkörper der Anfrage IST die Datei — bewusst kein Multipart-Upload (python-multipart fehlt) und bewusst kein JSON: _private_data.tar ist binär, und Base64 würde sie nur unnötig aufblähen. Wirkt ab dem NÄCHSTEN Rip: makemkvcon liest den Speicher beim Start. """ rohdaten = await request.body() def pruefe_und_schreibe(): # Prüfung liest ein mehrere MB großes tar — gehört deshalb mit in # den Thread und nicht in die Ereignisschleife. fehler = makemkv_daten.private_data_pruefen(rohdaten) if fehler: return fehler, None return "", makemkv_daten.private_data_schreiben(rohdaten) try: fehler, status = await asyncio.to_thread(pruefe_und_schreibe) except OSError as e: raise HTTPException( status_code=500, detail=( f"Schlüsselspeicher konnte nicht geschrieben werden: {e}. " "Prüfe, ob das MakeMKV-Datenverzeichnis auf der VM existiert " "und beschreibbar ist (Standard: /srv/rippy/makemkv)." ), ) if fehler: raise HTTPException(status_code=422, detail=fehler) await asyncio.to_thread( db.add_log, "success", "makemkv-keydb", f"Schlüsselspeicher übernommen: {status['schluessel']} Disc-Schlüssel, " f"{status['groesse_bytes']} Bytes. Wirkt ab dem NÄCHSTEN Rip.", ) return status @app.get("/system/aacs-dumps") async def get_aacs_dumps(): """AACS-Dumps, die MakeMKV selbst abgelegt hat (neueste zuerst). MakeMKV schreibt sie beim gescheiterten UHD-Versuch ins Datenverzeichnis (Meldung 3332 "Saved AACS dump file as file:///root/.MakeMKV/.tgz", am 25.07.2026 so beobachtet). Rippy wertet sie nicht aus und schickt sie nirgendwohin — es zeigt nur, dass sie da sind, damit der Nutzer selbst entscheiden kann, was er damit tut. """ def liste(): return {"dumps": makemkv_daten.dumps_auflisten()} return await asyncio.to_thread(liste) @app.get("/system/aacs-dumps/{dateiname}") async def download_aacs_dump(dateiname: str): """Lädt EINEN AACS-Dump herunter. Pfad-Validierung genauso streng wie beim Job-Datei-Download: nackter Name ohne Pfadtrenner und ohne führenden Punkt (ist_aacs_dump) PLUS realpath, der das MakeMKV-Datenverzeichnis nicht verlassen darf (kein ..-Ausbruch, kein Symlink nach draußen). """ if not makemkv_daten.ist_aacs_dump(dateiname): raise HTTPException( status_code=404, detail="Kein gültiger Dump-Name — erwartet wird eine .tgz-Datei ohne Pfadangabe.", ) pfad = os.path.join(MAKEMKV_DATA_ROOT, dateiname) def pruefe(): return os.path.isfile(pfad) and unter_wurzel(os.path.realpath(pfad), MAKEMKV_DATA_ROOT) if not await asyncio.to_thread(pruefe): raise HTTPException( status_code=404, detail="Dump nicht gefunden — MakeMKV legt ihn erst beim gescheiterten UHD-Versuch an.", ) return FileResponse(pfad, filename=dateiname, media_type="application/gzip") class NotificationTestRequest(BaseModel): url: str @app.post("/notifications/test") async def notification_test(request: NotificationTestRequest): """Test-Nachricht an den Webhook — beweist die Anbindung SOFORT statt erst beim ersten Job-Ende.""" url = request.url.strip() if not url.startswith(("http://", "https://")): raise HTTPException(status_code=422, detail="Webhook-URL muss mit http(s):// beginnen") try: await asyncio.to_thread( notify.sende, url, "🔔 Rippy: Test-Benachrichtigung", "Wenn du das liest, funktioniert die Anbindung. Rippy meldet sich " "hier, sobald ein Job fertig ist oder fehlschlägt.", "info", ) except RuntimeError as e: raise HTTPException(status_code=400, detail=str(e)) await asyncio.to_thread( db.add_log, "info", "notify", f"Test-Benachrichtigung gesendet ({notify.erkenne_webhook_typ(url)})" ) return {"status": "sent", "typ": notify.erkenne_webhook_typ(url)} @app.get("/setup") async def setup_status(): """First-Run-Erkennung: wurde der Einrichtungs-Assistent abgeschlossen?""" einstellungen = await asyncio.to_thread(db.get_settings, "setup") return {"done": bool(einstellungen.get("done"))} @app.post("/setup/complete") async def setup_complete(): await asyncio.to_thread(db.save_settings, {"done": True}, "setup") await asyncio.to_thread(db.add_log, "success", "setup", "Einrichtungs-Assistent abgeschlossen") return {"done": True} @app.get("/logs") async def get_logs(limit: int = 200): """Echte Ereignisse aus der Datenbank (Watcher, API, Worker).""" zeilen = await asyncio.to_thread(db.list_logs, min(limit, 1000)) return [ { "id": str(z["id"]), "timestamp": z["ts"].isoformat() if z.get("ts") else "", "level": z.get("level") or "info", "source": z.get("source") or "system", "message": z.get("message") or "", } for z in zeilen ] @app.get("/settings") async def get_settings(): """UI-Einstellungen aus der Datenbank (leeres Objekt = Defaults im UI).""" return await asyncio.to_thread(db.get_settings) @app.post("/settings") async def save_settings(werte: Dict): """Speichert die UI-Einstellungen als JSON in der Datenbank.""" await asyncio.to_thread(db.save_settings, werte) return {"status": "saved"} @app.get("/devices", response_model=List[Device]) async def get_devices(): """Alle optischen Laufwerke mit ehrlichem Status (leer/bereit + Disc-Typ). Der alte Weg (udevadm + /dev/disc-Symlinks) lieferte im Container prinzipbedingt nichts: kein udevd, keine udev-Datenbank, kein Daemon, der Symlinks anlegt. Jetzt: /sys fürs Modell, ioctl für den Disc-Status. """ geraete = [] for pfad in device_discovery.list_optical_devices(): info = await asyncio.to_thread(device_discovery.device_info, pfad) disc = DISC_CACHE.get(pfad) if disc and not disc.get("_laeuft"): info["disc"] = disc geraete.append(Device(**info)) return geraete # GET /stream/jobs (SSE) entfernt am 25.07.2026. Der Stream war zweimal falsch: # erst ein Placebo (er sendete nur, wenn eine Liste `sse_connections` gefüllt # war, und nichts füllte sie je), dann am 23.07. funktionsfähig gemacht — aber # einen Verbraucher hat er nie bekommen. Im UI gibt es kein `EventSource`; das # Dashboard holt die Jobs mit `setInterval(loadData, 4000)`. Damit war er keine # harmlose Leiche, sondern eine Endlosschleife je Verbindung, die jeder im # Heimnetz aufmachen konnte. Wer echtes Push will, braucht BEIDE Seiten. # /metadata/lookup + /metadata/confirm entfernt (24.07., mit der # Metadaten-Seite): lookup scannte ein DUMMY-Device (/dev/dvd — existiert # nicht) und confirm schrieb in einen Cache-Key, den nie jemand las. # Die echte Korrektur läuft über /metadata/search + /metadata/override. @app.get("/metadata/search") async def metadata_search(q: str): """Manuelle Korrektur: Titel-Kandidaten aus ALLEN Quellen (TMDB/Jikan/OMDb). KONZEPT Schritt 5: „Commander bestätigt oder korrigiert manuell" — das hier ist der Korrektur-Teil, wenn die Automatik danebenliegt. """ def sammle(): prescan = PreScan() ergebnisse = [] for movie in (prescan.tmdb.search_movie(q) or [])[:4]: ergebnisse.append({ "title": movie.get("title", ""), "year": int(movie["release_date"][:4]) if movie.get("release_date") else None, "poster": f"https://image.tmdb.org/t/p/w342{movie['poster_path']}" if movie.get("poster_path") else "", "overview": (movie.get("overview") or "")[:200], "type": "movie", "source": "tmdb", "id": str(movie.get("id", "")), }) for show in (prescan.tmdb.search_tv(q) or [])[:3]: ergebnisse.append({ "title": show.get("name", ""), "year": int(show["first_air_date"][:4]) if show.get("first_air_date") else None, "poster": f"https://image.tmdb.org/t/p/w342{show['poster_path']}" if show.get("poster_path") else "", "overview": (show.get("overview") or "")[:200], "type": "tv", "source": "tmdb", "id": str(show.get("id", "")), }) ergebnisse += prescan.jikan.suche(q) ergebnisse += prescan.omdb.suche(q) # Mit Poster zuerst, Duplikate (Titel+Jahr) raus gesehen, dedup = set(), [] for e in sorted(ergebnisse, key=lambda x: 0 if x.get("poster") else 1): schluessel = ((e.get("title") or "").lower(), e.get("year")) if schluessel in gesehen: continue gesehen.add(schluessel) dedup.append(e) return dedup[:12] return await asyncio.to_thread(sammle) class MetadataOverride(BaseModel): device_path: str title: str year: Optional[int] = None poster: Optional[str] = None overview: Optional[str] = None type: Optional[str] = "movie" source: Optional[str] = None id: Optional[str] = None @app.post("/metadata/override") async def metadata_override(request: MetadataOverride): """Nutzer-Wahl für DIESE Disc merken: Karte, Jobs und Cache (30 Tage). Der Disc-Fingerabdruck (Label+Größe) macht die Korrektur wiedererkennbar — dieselbe Disc wird beim nächsten Einlegen sofort richtig angezeigt. """ if request.device_path not in device_discovery.list_optical_devices(): raise HTTPException(status_code=404, detail="Laufwerk nicht gefunden") def speichere(): from cache import set as cache_setter from cache.keys import generate_prescan_key from prescan.prescan import disc_fingerprint ergebnis = { "disc_type": (DISC_CACHE.get(request.device_path) or {}).get("disc_type", "Blu-ray"), "title": request.title, "year": request.year, "confidence": 0.99, "metadata": { "type": request.type or "movie", "id": request.id or "", "title": request.title, "year": request.year, "overview": request.overview or "", "poster_path": request.poster or "", "backdrop_path": "", "runtime": 0, "genres": [], "source": request.source or "manuell", }, "tracks": [], } abdruck = disc_fingerprint(request.device_path) cache_setter( generate_prescan_key(request.device_path, False, abdruck), ergebnis, expire=30 * 86400, ) DISC_CACHE[request.device_path] = ergebnis return ergebnis ergebnis = await asyncio.to_thread(speichere) await asyncio.to_thread( db.add_log, "success", "api", f"Metadaten manuell festgelegt: {request.title}" + (f" ({request.year})" if request.year else ""), ) return ergebnis # POST /prescan und POST /jellyfin/format entfernt am 25.07.2026 — beide waren # Überreste eines ersetzten Entwurfs, ohne einen einzigen Aufrufer: # # /prescan war der Endpunkt hinter der Metadaten-Vorschau-Seite. Die # Seite ist seit v3.4 weg (Korrektur-Popup ist der einzige # Weg), der Endpunkt blieb liegen. Der Pre-Scan selbst lebt: # der Disc-Watcher ruft PreScan direkt im Prozess auf, das # Ergebnis landet auf der Disc-Karte. Nur der HTTP-Weg # dorthin hatte keinen Nutzer. # # /jellyfin/format schrieb NFO-Dateien und lud Poster — in der API. Seit v3.2 # macht das der Worker (medien.py), und das ist die richtige # Stelle: er kennt den Ausgabeordner und ist direkt nach dem # Rip am Zug. Mit dem Endpunkt fallen nfo_generator.py und # image_downloader.py in der API weg; sonst nutzte sie nichts. # Auth-Endpoints (/token, /api-keys) entfernt — Commander-Entscheid 24.07.: # Heimnetz-only, kein Login-Flow im UI, die Endpoints waren Placebo.