Hitonabi
68094f8b43
Ampel / ampel (push) Successful in 32s
- Get devices from /dev/disc/ (udev symlinks) - Also check direct devices: /dev/sr0, /dev/cdrom, /dev/dvd - Use udevadm to detect device type (cd/dvd/bluray) - Extract model and serial for better identification
433 lines
13 KiB
Python
433 lines
13 KiB
Python
from fastapi import FastAPI, HTTPException, Request, Response
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from fastapi.responses import StreamingResponse
|
|
from pydantic import BaseModel
|
|
from typing import List, Optional, Dict
|
|
from pathlib import Path
|
|
import subprocess
|
|
import asyncio
|
|
import json
|
|
|
|
from fastapi.security import OAuth2PasswordBearer
|
|
|
|
from config import settings
|
|
from config_validation import validate_config, ConfigValidationError
|
|
from cache import init_cache, set as cache_set
|
|
from auth import (
|
|
create_access_token,
|
|
create_refresh_token,
|
|
decode_token,
|
|
is_blacklisted,
|
|
add_to_blacklist,
|
|
)
|
|
from ratelimit import (
|
|
check_rate_limit,
|
|
get_rate_limit_remaining,
|
|
validate_api_key,
|
|
api_keys,
|
|
create_api_key as ratelimit_create_api_key,
|
|
delete_api_key as ratelimit_delete_api_key,
|
|
)
|
|
from prescan import PreScan
|
|
from nfo_generator import NFOGenerator
|
|
from image_downloader import ImageDownloader
|
|
|
|
app = FastAPI(
|
|
title="Rippy API",
|
|
description="API für das automatische Ripping-System",
|
|
version="1.0.0"
|
|
)
|
|
|
|
# OAuth2 Scheme
|
|
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
|
|
|
|
# SSE-Connections
|
|
sse_connections: List = []
|
|
|
|
|
|
@app.on_event("startup")
|
|
async def startup_event():
|
|
"""Initialisiere Cache beim Start und validiere Konfiguration."""
|
|
init_cache()
|
|
|
|
try:
|
|
validate_config()
|
|
except ConfigValidationError as e:
|
|
print(f"⚠️ Konfigurations-Warnung: {e}")
|
|
|
|
|
|
# Middleware für Rate-Limiting
|
|
@app.middleware("http")
|
|
async def rate_limit_middleware(request: Request, call_next):
|
|
"""Rate-Limiting Middleware."""
|
|
client_ip = request.client.host
|
|
api_key = request.headers.get("X-API-Key")
|
|
|
|
# Prüfe API Key
|
|
if api_key:
|
|
key_info = validate_api_key(api_key)
|
|
if not key_info:
|
|
raise HTTPException(status_code=401, detail="Ungültiger API Key")
|
|
|
|
# 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
|
|
|
|
class Device(BaseModel):
|
|
id: str
|
|
name: str
|
|
type: str
|
|
path: str
|
|
status: str
|
|
|
|
@app.get("/health")
|
|
async def health_check():
|
|
return {"status": "ok", "service": "api"}
|
|
|
|
|
|
@app.get("/")
|
|
async def root():
|
|
return {
|
|
"name": "Rippy",
|
|
"version": "1.0.0",
|
|
"description": "Automatisches Ripping-System für CD, DVD und Blu-ray"
|
|
}
|
|
|
|
|
|
@app.get("/jobs", response_model=List[Job])
|
|
async def get_jobs():
|
|
"""Holt alle Jobs."""
|
|
return []
|
|
|
|
|
|
@app.get("/devices", response_model=List[Device])
|
|
async def get_devices():
|
|
"""Holt alle Geräte."""
|
|
devices = []
|
|
|
|
try:
|
|
# 1. Zuerst Symlinks in /dev/disc/ prüfen
|
|
result = subprocess.run(
|
|
["ls", "-la", "/dev/disc/"],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=5
|
|
)
|
|
|
|
for line in result.stdout.strip().split('\n')[1:]:
|
|
if line and 'total' not in line:
|
|
parts = line.split()
|
|
if len(parts) >= 9:
|
|
name = parts[-1]
|
|
devices.append(Device(
|
|
id=name,
|
|
name=f"Laufwerk {name}",
|
|
type="dvd",
|
|
path=f"/dev/disc/{name}",
|
|
status="ready"
|
|
))
|
|
|
|
# 2. Direkte Geräte /dev/sr0, /dev/cdrom prüfen
|
|
import os
|
|
direct_devices = ['/dev/sr0', '/dev/cdrom', '/dev/dvd']
|
|
for device_path in direct_devices:
|
|
if os.path.exists(device_path):
|
|
# Prüfen ob es ein block device ist
|
|
import stat
|
|
mode = os.stat(device_path).st_mode
|
|
if stat.S_ISBLK(mode):
|
|
# Geräte-Info aus udevadm holen
|
|
result = subprocess.run(
|
|
["udevadm", "info", "-q", "property", "-n", device_path],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=5
|
|
)
|
|
info = {}
|
|
for line in result.stdout.strip().split('\n'):
|
|
if '=' in line:
|
|
key, value = line.split('=', 1)
|
|
info[key] = value
|
|
|
|
device_type = "dvd"
|
|
if info.get("ID_CDROM_BD") == "1":
|
|
device_type = "bluray"
|
|
elif info.get("ID_CDROM_CD") == "1":
|
|
device_type = "cd"
|
|
|
|
model = info.get("ID_MODEL", "Laufwerk")
|
|
serial = info.get("ID_SERIAL", "unknown")
|
|
|
|
devices.append(Device(
|
|
id=f"{model}_{serial}".replace(" ", "_"),
|
|
name=model,
|
|
type=device_type,
|
|
path=device_path,
|
|
status="ready",
|
|
serial=serial,
|
|
model=model
|
|
))
|
|
except Exception as e:
|
|
print(f"Fehler beim Lesen der Geräte: {e}")
|
|
pass
|
|
|
|
return devices
|
|
|
|
|
|
# SSE-Stream für Echtzeit-Updates
|
|
@app.get("/stream/jobs")
|
|
async def job_stream():
|
|
"""SSE-Stream für Job-Updates."""
|
|
async def event_generator():
|
|
while True:
|
|
if sse_connections:
|
|
# Job-Status aktualisieren
|
|
jobs = await get_jobs()
|
|
yield f"data: {json.dumps([j.dict() for j in jobs])}\n\n"
|
|
await asyncio.sleep(1)
|
|
|
|
return StreamingResponse(event_generator(), media_type="text/event-stream")
|
|
|
|
|
|
# Metadaten-Lookup Endpoints
|
|
class MetadataLookupRequest(BaseModel):
|
|
title: str
|
|
year: Optional[int] = None
|
|
disc_type: str = "dvd"
|
|
|
|
|
|
@app.post("/metadata/lookup")
|
|
async def lookup_metadata(request: MetadataLookupRequest):
|
|
"""Suche Metadaten für Disc."""
|
|
prescan = PreScan()
|
|
|
|
# Dummy device für Pre-Scan
|
|
device = "/dev/dvd" if request.disc_type in ["dvd", "bluray"] else "/dev/cdrom"
|
|
|
|
result = prescan.scan(device)
|
|
|
|
return {
|
|
"title": result.title,
|
|
"year": result.year,
|
|
"confidence": result.confidence,
|
|
"metadata": result.metadata,
|
|
"tracks": result.tracks
|
|
}
|
|
|
|
|
|
@app.post("/metadata/confirm")
|
|
async def confirm_metadata(title: str, year: Optional[int] = None, metadata: Dict = None):
|
|
"""Bestätige Metadaten."""
|
|
from cache.keys import generate_confirmed_key
|
|
# In Cache speichern
|
|
cache_key = generate_confirmed_key(title, year)
|
|
cache_set(cache_key, {"title": title, "year": year, "metadata": metadata or {}})
|
|
|
|
return {"status": "confirmed", "key": cache_key}
|
|
|
|
|
|
# Pre-Scan Endpoint
|
|
class PreScanRequest(BaseModel):
|
|
device_path: str
|
|
|
|
|
|
@app.post("/prescan")
|
|
async def run_prescan(request: PreScanRequest):
|
|
"""Führe Pre-Scan durch."""
|
|
try:
|
|
prescan = PreScan()
|
|
result = prescan.scan(request.device_path)
|
|
return result.to_dict()
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
# Jellyfin-Formatierung Endpoints
|
|
class JellyfinFormatRequest(BaseModel):
|
|
title: str
|
|
year: Optional[int]
|
|
metadata: Dict
|
|
disc_type: str
|
|
output_dir: str
|
|
|
|
|
|
@app.post("/jellyfin/format")
|
|
async def jellyfin_format(request: JellyfinFormatRequest):
|
|
"""Formatiere für Jellyfin (NFO + Images)."""
|
|
try:
|
|
nfo_gen = NFOGenerator()
|
|
img_downloader = ImageDownloader()
|
|
|
|
# Ordnerstruktur erstellen
|
|
output_path = Path(request.output_dir)
|
|
|
|
if request.disc_type in ["dvd", "bluray"]:
|
|
# Film-Formatierung
|
|
title = request.metadata.get("title", request.title)
|
|
year = request.year or request.metadata.get("year")
|
|
|
|
# movie.nfo
|
|
movie_nfo = nfo_gen.generate_movie_nfo(
|
|
title=title,
|
|
year=year or 2000,
|
|
overview=request.metadata.get("overview", ""),
|
|
rating=request.metadata.get("rating", 0),
|
|
runtime=request.metadata.get("runtime", 0),
|
|
genres=request.metadata.get("genres", []),
|
|
director=request.metadata.get("director", ""),
|
|
actors=request.metadata.get("actors", [])
|
|
)
|
|
|
|
nfo_path = output_path / "movie.nfo"
|
|
nfo_gen.save_nfo(movie_nfo, nfo_path)
|
|
|
|
# Poster und Fanart
|
|
img_downloader.download_poster(title, output_path, 500)
|
|
img_downloader.download_fanart(title, output_path, 1920)
|
|
|
|
return {
|
|
"status": "formatted",
|
|
"nfo_path": str(nfo_path),
|
|
"poster_path": str(output_path / "poster.jpg"),
|
|
"fanart_path": str(output_path / "fanart.jpg")
|
|
}
|
|
else:
|
|
# Audio-Formatierung
|
|
artist = request.metadata.get("artist", "Unknown Artist")
|
|
album = request.metadata.get("title", request.title)
|
|
# Review-Fix 22.07.: `year` war hier undefiniert (existierte nur im Film-Zweig)
|
|
year = request.year or request.metadata.get("year")
|
|
|
|
# album.nfo
|
|
album_nfo = nfo_gen.generate_album_nfo(
|
|
title=album,
|
|
artist=artist,
|
|
year=year or 2000,
|
|
genres=request.metadata.get("genres", [])
|
|
)
|
|
|
|
nfo_path = output_path / "album.nfo"
|
|
nfo_gen.save_nfo(album_nfo, nfo_path)
|
|
|
|
# Album-Cover
|
|
img_downloader.download_music_images(artist, album, output_path)
|
|
|
|
return {
|
|
"status": "formatted",
|
|
"nfo_path": str(nfo_path),
|
|
"album_cover_path": str(output_path / "album.jpg")
|
|
}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
# Auth Endpoints
|
|
class LoginRequest(BaseModel):
|
|
username: str
|
|
password: str
|
|
|
|
|
|
@app.post("/token")
|
|
async def login(request: LoginRequest):
|
|
"""Login und Token generieren."""
|
|
# Einfache Auth für MVP (in Produktion mit Datenbank); Zugangsdaten aus .env
|
|
if request.username == settings.admin_username and request.password == settings.admin_password:
|
|
access_token = create_access_token(
|
|
data={"sub": request.username, "scopes": ["admin"]}
|
|
)
|
|
refresh_token = create_refresh_token(
|
|
data={"sub": request.username}
|
|
)
|
|
return {
|
|
"access_token": access_token,
|
|
"refresh_token": refresh_token,
|
|
"token_type": "bearer"
|
|
}
|
|
raise HTTPException(status_code=401, detail="Ungültige Anmeldedaten")
|
|
|
|
|
|
@app.post("/token/refresh")
|
|
async def refresh_token(refresh_token: str):
|
|
"""Refresh Access Token."""
|
|
payload = decode_token(refresh_token)
|
|
if not payload or payload.get("type") != "refresh":
|
|
raise HTTPException(status_code=401, detail="Ungültiges Refresh Token")
|
|
|
|
access_token = create_access_token(
|
|
data={"sub": payload.get("sub"), "scopes": payload.get("scopes", [])}
|
|
)
|
|
return {"access_token": access_token, "token_type": "bearer"}
|
|
|
|
|
|
@app.post("/token/invalidate")
|
|
async def invalidate_token(token: str):
|
|
"""Invalidate Token (Logout)."""
|
|
if is_blacklisted(token):
|
|
raise HTTPException(status_code=400, detail="Token bereits invalidiert")
|
|
|
|
# Review-Fix 22.07.: vorher wurde hier NICHTS geblacklistet (Placebo-Logout)
|
|
add_to_blacklist(token)
|
|
if not is_blacklisted(token):
|
|
raise HTTPException(status_code=400, detail="Ungültiger Token")
|
|
return {"status": "invalidated"}
|
|
|
|
|
|
# API Key Endpoints
|
|
class APIKeyCreateRequest(BaseModel):
|
|
name: str
|
|
|
|
|
|
# Review-Fix 22.07.: diese Endpoints nutzten `secrets` und `api_keys`, die in
|
|
# diesem Modul NIE existierten (Crash bei jedem Aufruf) — der echte Key-Store
|
|
# lebt in ratelimit.py und wird jetzt benutzt.
|
|
@app.post("/api-keys")
|
|
async def create_api_key(request: APIKeyCreateRequest):
|
|
"""Erstelle API Key."""
|
|
# In Produktion mit Auth prüfen
|
|
return ratelimit_create_api_key(request.name)
|
|
|
|
|
|
@app.get("/api-keys")
|
|
async def list_api_keys():
|
|
"""Liste API Keys."""
|
|
return list(api_keys.values())
|
|
|
|
|
|
@app.delete("/api-keys/{key}")
|
|
async def delete_api_key(key: str):
|
|
"""Lösche API Key."""
|
|
# In Produktion mit Auth prüfen
|
|
if ratelimit_delete_api_key(key):
|
|
return {"status": "deleted"}
|
|
raise HTTPException(status_code=404, detail="API Key nicht gefunden")
|