from __future__ import annotations
import asyncio
from pathlib import Path
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse, HTMLResponse
from fastapi.staticfiles import StaticFiles
from sakura_cloud.api.middleware import security_headers_middleware, trace_logging_middleware
from sakura_cloud.api.v1.router import api_router
from sakura_cloud.core.config import settings
from sakura_cloud.core.logging import configure_logging, logger
from sakura_cloud.db.session import SessionLocal
from sakura_cloud.services.migrations import upgrade_database_to_head
from sakura_cloud.services.reminders import run_daily_reminder_digest
from sakura_cloud.services.storage import cleanup_stale_uploads
def _admin_frontend_dist() -> Path:
base_dir = Path(__file__).resolve().parent
candidates = [
base_dir.parent / "sakura_admin_web" / "dist",
base_dir / "sakura_admin_web" / "dist",
]
for candidate in candidates:
if (candidate / "index.html").is_file():
return candidate
return candidates[0]
def _cloud_public_dir() -> Path:
return Path(__file__).resolve().parent / "public"
def _online_search_page() -> HTMLResponse:
return HTMLResponse(
"""
Sakura Cloud 在线搜索
""",
headers={
"Content-Security-Policy": (
"default-src 'self'; base-uri 'self'; object-src 'none'; "
"frame-ancestors 'none'; img-src 'self' data: blob: https: http:; "
"style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; "
"connect-src 'self'"
)
},
)
def _admin_placeholder() -> HTMLResponse:
return HTMLResponse(
"""
Sakura Cloud Admin
Sakura Cloud Admin
Frontend not built. Run: cd sakura_admin_web && npm run build
"""
)
def _spa_index(frontend_dist: Path) -> FileResponse | HTMLResponse:
index_path = frontend_dist / "index.html"
if index_path.is_file():
return FileResponse(index_path)
return _admin_placeholder()
async def cleanup_uploads_loop() -> None:
while True:
await asyncio.sleep(3600)
db = SessionLocal()
try:
cleanup_stale_uploads(db)
except Exception:
logger.exception("Cleanup stale uploads failed")
finally:
db.close()
async def reminder_digest_loop() -> None:
while True:
await asyncio.sleep(300)
db = SessionLocal()
try:
run_daily_reminder_digest(db)
except Exception:
logger.exception("Reminder digest loop failed")
finally:
db.close()
def create_app() -> FastAPI:
configure_logging()
app = FastAPI(
title=settings.app_name,
version=settings.app_version,
openapi_url=f"{settings.api_prefix}/openapi.json",
)
app.add_middleware(
CORSMiddleware,
allow_origins=settings.cors_origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.middleware("http")(security_headers_middleware)
app.middleware("http")(trace_logging_middleware)
app.include_router(api_router, prefix=settings.api_prefix)
frontend_dist = _admin_frontend_dist()
public_dir = _cloud_public_dir()
assets_dir = frontend_dist / "assets"
if settings.admin_frontend_enabled and assets_dir.is_dir():
app.mount("/assets", StaticFiles(directory=assets_dir), name="admin_assets")
sources_dir = public_dir / "sources"
if sources_dir.is_dir():
app.mount("/sources", StaticFiles(directory=sources_dir), name="source_json")
@app.get("/online-search", response_model=None)
def online_search_console() -> HTMLResponse:
return _online_search_page()
@app.get("/search", response_model=None)
def search_console() -> HTMLResponse:
return _online_search_page()
@app.get("/admin", response_model=None)
def admin_console() -> FileResponse | HTMLResponse:
if not settings.admin_frontend_enabled:
return HTMLResponse("Admin console disabled
", status_code=404)
return _spa_index(frontend_dist)
@app.get("/{full_path:path}", include_in_schema=False, response_model=None)
def spa_fallback(full_path: str) -> FileResponse | HTMLResponse:
api_prefix = settings.api_prefix.strip("/")
if full_path == api_prefix or full_path.startswith(api_prefix + "/"):
raise HTTPException(status_code=404, detail="API route not found")
if not settings.admin_frontend_enabled:
raise HTTPException(status_code=404, detail="Frontend disabled")
return _spa_index(frontend_dist)
@app.on_event("startup")
async def _start_background_tasks() -> None:
if settings.auto_migrate_on_startup:
logger.info("Auto migration enabled, upgrading database to head")
upgrade_database_to_head()
else:
logger.info("Auto migration disabled, skipping database upgrade on startup")
db = SessionLocal()
try:
cleanup_stale_uploads(db)
try:
run_daily_reminder_digest(db)
except Exception:
logger.exception("Initial reminder digest failed during startup")
finally:
db.close()
logger.info("Startup tasks completed")
asyncio.create_task(cleanup_uploads_loop())
asyncio.create_task(reminder_digest_loop())
return app
app = create_app()