222 lines
7.8 KiB
Python
Executable File
222 lines
7.8 KiB
Python
Executable File
"""
|
|
StemEngine — FastAPI application entry point.
|
|
Mounts API routers and optionally serves legacy static WebUI when explicitly enabled.
|
|
"""
|
|
import json
|
|
import logging
|
|
import logging.config
|
|
import os
|
|
import warnings
|
|
from contextlib import asynccontextmanager
|
|
from pathlib import Path
|
|
from urllib.parse import urlparse
|
|
|
|
# Suppress FutureWarnings from third-party libraries that use deprecated
|
|
# PyTorch APIs (torch.cuda.amp.autocast, torch.backends.cuda.sdp_kernel).
|
|
# These are upstream issues in rotary_embedding_torch and similar packages;
|
|
# the warnings are harmless and clutter the logs.
|
|
warnings.filterwarnings(
|
|
"ignore",
|
|
message=r".*torch\.cuda\.amp\.autocast.*",
|
|
category=FutureWarning,
|
|
)
|
|
warnings.filterwarnings(
|
|
"ignore",
|
|
message=r".*torch\.backends\.cuda\.sdp_kernel.*",
|
|
category=FutureWarning,
|
|
)
|
|
|
|
from fastapi import FastAPI
|
|
|
|
# Load logging config from the discrete YAML file next to this package.
|
|
# Edit backend/logging.yaml to change log levels without touching code.
|
|
_log_cfg = Path(__file__).parent / "logging.yaml"
|
|
if _log_cfg.exists():
|
|
import yaml
|
|
with open(_log_cfg) as _f:
|
|
logging.config.dictConfig(yaml.safe_load(_f))
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from fastapi.middleware.gzip import GZipMiddleware
|
|
from fastapi.staticfiles import StaticFiles
|
|
from fastapi.responses import FileResponse
|
|
|
|
from . import job_manager as jm
|
|
from .routers import separate, transcribe, abc_convert, pipeline, jobs, lrc, subsonic, projects, models, lyric_transcribe, system, settings, karaoke_sek, pixabay, room, local_library, gloss
|
|
from .config import SUBSONIC_CONFIG_PATH
|
|
from .app_settings import settings as app_settings
|
|
from .db import init_db
|
|
from .services.local_library_service import seed_music_library_path_from_env
|
|
from .services.gloss_service import initialize_gloss_runtime
|
|
|
|
_log = logging.getLogger(__name__)
|
|
|
|
|
|
def _build_frame_src_csp() -> str:
|
|
"""Build a narrow CSP policy for iframe sources.
|
|
|
|
The policy is intentionally scoped to `frame-src` to avoid changing other
|
|
fetch directives during this rollout.
|
|
"""
|
|
sources = ["'self'"]
|
|
raw = (os.environ.get("MUON_IFRAME_URL") or "").strip()
|
|
if raw:
|
|
parsed = urlparse(raw)
|
|
if parsed.scheme in {"http", "https"} and parsed.netloc:
|
|
origin = f"{parsed.scheme}://{parsed.netloc}"
|
|
if origin not in sources:
|
|
sources.append(origin)
|
|
return f"frame-src {' '.join(sources)}"
|
|
|
|
|
|
def _purge_legacy_subsonic_config() -> None:
|
|
"""Delete subsonic.json if it is in the legacy plaintext format.
|
|
|
|
Encrypted configs (_enc=True) are kept. Any file that lacks the _enc
|
|
flag stored the password in cleartext and must be removed so it is never
|
|
served again.
|
|
"""
|
|
if not SUBSONIC_CONFIG_PATH.exists():
|
|
return
|
|
try:
|
|
stored = json.loads(SUBSONIC_CONFIG_PATH.read_text())
|
|
except Exception:
|
|
stored = {}
|
|
if not stored.get('_enc'):
|
|
SUBSONIC_CONFIG_PATH.unlink()
|
|
_log.warning(
|
|
"Deleted legacy plaintext Subsonic config at %s — "
|
|
"re-enter credentials via the Settings UI.",
|
|
SUBSONIC_CONFIG_PATH,
|
|
)
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app):
|
|
init_db(_log)
|
|
try:
|
|
result = jm.prune_old_non_project_jobs(force=True)
|
|
if result.get("deleted", 0) > 0:
|
|
_log.info(
|
|
"Startup retention prune deleted %d old non-project jobs",
|
|
result["deleted"],
|
|
)
|
|
except Exception:
|
|
_log.exception("Startup retention prune failed")
|
|
_purge_legacy_subsonic_config()
|
|
if seed_music_library_path_from_env():
|
|
_log.info(
|
|
"Startup: seeded music_library_path from MUSIC_LIBRARY_PATH env var into settings.json"
|
|
)
|
|
try:
|
|
initialize_gloss_runtime()
|
|
except Exception:
|
|
_log.exception("Startup gloss runtime initialization failed")
|
|
for issue in app_settings.validate_startup():
|
|
_log.warning("Startup check: %s", issue)
|
|
yield
|
|
|
|
|
|
def _include_routers(app: FastAPI) -> None:
|
|
app.include_router(jobs.router)
|
|
app.include_router(separate.router)
|
|
app.include_router(transcribe.router)
|
|
app.include_router(abc_convert.router)
|
|
app.include_router(pipeline.router)
|
|
app.include_router(lrc.router)
|
|
app.include_router(subsonic.router)
|
|
app.include_router(projects.router)
|
|
app.include_router(gloss.router)
|
|
app.include_router(models.router)
|
|
app.include_router(lyric_transcribe.router)
|
|
app.include_router(system.router)
|
|
app.include_router(settings.router)
|
|
app.include_router(local_library.router)
|
|
app.include_router(karaoke_sek.router)
|
|
app.include_router(pixabay.router)
|
|
app.include_router(room.router)
|
|
|
|
|
|
def _mount_static(app: FastAPI) -> None:
|
|
# Legacy behavior (backend-served frontend) is opt-in only.
|
|
# Default runtime is API-only with separate WebUI/SingUI services.
|
|
if os.environ.get("BACKEND_SERVE_LEGACY_WEBUI", "false").lower() != "true":
|
|
return
|
|
|
|
# Serve built React frontend from /app/backend/static
|
|
# Mount order matters: API routes always win over static assets.
|
|
_static_dir = Path(__file__).parent / "static"
|
|
_assets_dir = _static_dir / "assets"
|
|
|
|
if not _static_dir.exists():
|
|
return
|
|
|
|
if _assets_dir.exists():
|
|
app.mount("/assets", StaticFiles(directory=str(_assets_dir)), name="assets")
|
|
|
|
@app.get("/", include_in_schema=False)
|
|
async def root():
|
|
return FileResponse(str(_static_dir / "index.html"))
|
|
|
|
@app.get("/{full_path:path}", include_in_schema=False)
|
|
async def spa_fallback(full_path: str):
|
|
"""Serve index.html for all non-API routes to support SPA client-side routing."""
|
|
candidate = _static_dir / full_path
|
|
if candidate.is_file():
|
|
return FileResponse(str(candidate))
|
|
return FileResponse(str(_static_dir / "index.html"))
|
|
|
|
|
|
def create_app() -> FastAPI:
|
|
app = FastAPI(title="StemEngine", version="1.0.0", lifespan=lifespan)
|
|
frame_src_csp = _build_frame_src_csp()
|
|
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=app_settings.cors_origins_resolved,
|
|
allow_origin_regex=app_settings.cors_origin_regex_resolved,
|
|
allow_methods=["*"],
|
|
allow_headers=["*"],
|
|
)
|
|
app.add_middleware(GZipMiddleware, minimum_size=1024, compresslevel=6)
|
|
|
|
@app.middleware("http")
|
|
async def _allow_private_network_access(request, call_next):
|
|
"""Add Access-Control-Allow-Private-Network for Chromium PNA preflights.
|
|
|
|
Browsers may block requests from secure/public origins to private/Tailscale
|
|
addresses unless this response header is present when requested.
|
|
"""
|
|
response = await call_next(request)
|
|
if request.headers.get("access-control-request-private-network", "").lower() == "true":
|
|
response.headers["access-control-allow-private-network"] = "true"
|
|
return response
|
|
|
|
@app.middleware("http")
|
|
async def _static_cache_control(request, call_next):
|
|
response = await call_next(request)
|
|
if request.method not in {"GET", "HEAD"}:
|
|
return response
|
|
|
|
path = request.url.path
|
|
if response.status_code == 200 and path.startswith('/assets/'):
|
|
response.headers.setdefault('Cache-Control', 'public, max-age=31536000, immutable')
|
|
return response
|
|
|
|
if path in {'/sw.js', '/manifest.webmanifest'}:
|
|
response.headers.setdefault('Cache-Control', 'no-cache')
|
|
return response
|
|
|
|
content_type = response.headers.get('content-type', '')
|
|
if 'text/html' in content_type:
|
|
response.headers.setdefault('Cache-Control', 'no-cache')
|
|
response.headers.setdefault('Content-Security-Policy', frame_src_csp)
|
|
|
|
return response
|
|
|
|
_include_routers(app)
|
|
_mount_static(app)
|
|
return app
|
|
|
|
|
|
app = create_app()
|