| from __future__ import annotations |
|
|
| import asyncio |
| from contextlib import asynccontextmanager |
| from html import escape |
| from mimetypes import guess_type |
| from pathlib import Path |
| import re |
| from threading import Event, Thread, active_count |
| import time |
|
|
| from fastapi import FastAPI, HTTPException, Request |
| from fastapi.middleware.cors import CORSMiddleware |
| from fastapi.responses import FileResponse, HTMLResponse, Response |
| from starlette.middleware.gzip import GZipMiddleware |
|
|
| from api import accounts, ai, chat_room, checkin, image_tasks, openui, product_visual, register, shop, skills, system, third_party_images |
| from api.errors import install_exception_handlers |
| from api.support import resolve_web_asset, start_limited_account_watcher |
| from services.backup_service import backup_service |
| from services.config import config |
| from services.event_loop_watchdog import start_loop_wedge_guard |
| from services.pool_pricing_service import pool_pricing_service |
| from services.share_evidence_service import share_evidence_service |
| from services.thread_pool import apply_thread_pool_tokens |
| from services.skill_service import skill_service |
| from services.sqlite_mirror_service import sqlite_mirror_service |
|
|
| STATIC_CACHE_CONTROL = "public, max-age=31536000, immutable" |
| ASSET_CACHE_CONTROL = "public, max-age=86400" |
| HTML_CACHE_CONTROL = "no-cache" |
| COMPRESSIBLE_SUFFIXES = {".css", ".html", ".js", ".json", ".map", ".svg", ".txt", ".xml"} |
| TITLE_RE = re.compile(r"<title>.*?</title>", re.IGNORECASE | re.DOTALL) |
| ICON_LINK_RE = re.compile(r"<link\b[^>]*\brel=[\"'][^\"']*(?:icon|apple-touch-icon)[^\"']*[\"'][^>]*>", re.IGNORECASE) |
|
|
|
|
| def _start_image_cleanup() -> Thread: |
| def worker() -> None: |
| started_at = time.monotonic() |
| try: |
| removed = config.cleanup_old_images() |
| elapsed = time.monotonic() - started_at |
| print(f"[image-cleanup] removed {removed} expired images in {elapsed:.2f}s") |
| except Exception as exc: |
| elapsed = time.monotonic() - started_at |
| print(f"[image-cleanup] failed after {elapsed:.2f}s: {exc}") |
|
|
| thread = Thread(target=worker, name="image-cleanup", daemon=True) |
| thread.start() |
| return thread |
|
|
|
|
| def _start_bundled_skill_sync() -> Thread: |
| """Synchronize bundled Skills without blocking HTTP startup. |
| |
| On Hugging Face the Skills directory can live on a Storage Bucket mount. |
| Copying a large bundle to that network filesystem may take minutes on the |
| first deployment, so doing it before ``yield`` makes the whole Space appear |
| stuck even though database recovery has already completed. |
| """ |
|
|
| def worker() -> None: |
| started_at = time.monotonic() |
| print("[skills] bundled Skill synchronization started in background") |
| try: |
| bundled_skills = skill_service.sync_bundled_skills() |
| elapsed = time.monotonic() - started_at |
| print( |
| f"[skills] synchronized {len(bundled_skills)} bundled Skills " |
| f"in {elapsed:.2f}s" |
| ) |
| except Exception as exc: |
| elapsed = time.monotonic() - started_at |
| print(f"[skills] bundled Skill synchronization failed after {elapsed:.2f}s: {exc}") |
|
|
| thread = Thread(target=worker, name="bundled-skill-sync", daemon=True) |
| thread.start() |
| return thread |
|
|
|
|
| def _web_cache_headers(full_path: str, asset: Path) -> dict[str, str]: |
| clean_path = full_path.strip("/") |
| suffix = asset.suffix.lower() |
| headers: dict[str, str] = {} |
| if clean_path.startswith("_next/static/"): |
| headers["Cache-Control"] = STATIC_CACHE_CONTROL |
| elif suffix in {".html", ".txt"}: |
| headers["Cache-Control"] = HTML_CACHE_CONTROL |
| else: |
| headers["Cache-Control"] = ASSET_CACHE_CONTROL |
| return headers |
|
|
|
|
| def _select_web_asset(request: Request, full_path: str, asset: Path) -> tuple[Path, dict[str, str], str | None]: |
| headers = _web_cache_headers(full_path, asset) |
| media_type = guess_type(str(asset))[0] |
| accept_encoding = str(request.headers.get("accept-encoding") or "").lower() |
| gzip_asset = asset.with_name(f"{asset.name}.gz") |
| is_compressible = asset.suffix.lower() in COMPRESSIBLE_SUFFIXES |
| if is_compressible: |
| headers = dict(headers) |
| headers["Vary"] = "Accept-Encoding" |
| if "gzip" in accept_encoding and is_compressible and gzip_asset.is_file(): |
| headers = dict(headers) |
| headers["Content-Encoding"] = "gzip" |
| return gzip_asset, headers, media_type |
| return asset, headers, media_type |
|
|
|
|
| def _is_api_like_path(full_path: str) -> bool: |
| clean_path = full_path.strip("/") |
| return clean_path.startswith(("api/", "auth/", "v1/")) |
|
|
|
|
| def _guess_icon_type(href: str) -> str: |
| clean_href = href.split("?", 1)[0].split("#", 1)[0].lower() |
| if clean_href.endswith(".svg"): |
| return "image/svg+xml" |
| if clean_href.endswith((".jpg", ".jpeg")): |
| return "image/jpeg" |
| if clean_href.endswith(".webp"): |
| return "image/webp" |
| if clean_href.endswith(".ico"): |
| return "image/x-icon" |
| return "image/png" |
|
|
|
|
| def _inject_branding_head(html_text: str) -> str: |
| branding = config.get_branding() |
| title = escape(str(branding.get("site_title") or "ACM 号池管理"), quote=False) |
| raw_icon_href = str(branding.get("site_logo_url") or "/favicon.ico") |
| icon_href = escape(raw_icon_href, quote=True) |
| icon_type = escape(_guess_icon_type(raw_icon_href), quote=True) |
| icon_markup = ( |
| f'<link rel="icon" href="{icon_href}" type="{icon_type}" data-branding-icon="favicon">' |
| f'<link rel="apple-touch-icon" href="{icon_href}" data-branding-icon="apple-touch-icon">' |
| ) |
| next_html = TITLE_RE.sub(f"<title>{title}</title>", html_text, count=1) |
| if next_html == html_text and "</head>" in next_html: |
| next_html = next_html.replace("</head>", f"<title>{title}</title></head>", 1) |
| next_html = ICON_LINK_RE.sub("", next_html) |
| if "</head>" in next_html: |
| next_html = next_html.replace("</head>", f"{icon_markup}</head>", 1) |
| return next_html |
|
|
|
|
| def _web_response(full_path: str, request: Request, asset: Path) -> Response: |
| if asset.suffix.lower() == ".html": |
| html_text = asset.read_text(encoding="utf-8") |
| return HTMLResponse( |
| _inject_branding_head(html_text), |
| headers=_web_cache_headers(full_path, asset), |
| ) |
| selected_asset, headers, media_type = _select_web_asset(request, full_path, asset) |
| return FileResponse(selected_asset, headers=headers, media_type=media_type) |
|
|
|
|
| def create_app() -> FastAPI: |
| app_version = config.app_version |
|
|
| async def _loop_lag_watchdog() -> None: |
| """把事件循环的真实卡顿写进日志。 |
| |
| ⚠️ 排查「整站无响应」时，容器日志一切正常（后台线程照跑）却测不出来到底卡在哪， |
| 就是因为没有任何关于事件循环本身的观测。这个探针每 20 秒量一次 sleep 漂移： |
| 漂移 = 循环线程被同步调用/GIL 抢占的实际时长。 |
| """ |
| from utils.log import logger as _logger |
|
|
| while True: |
| started = time.perf_counter() |
| await asyncio.sleep(20) |
| lag_ms = round((time.perf_counter() - started - 20) * 1000) |
| if lag_ms >= 800: |
| _logger.warning({ |
| "event": "event_loop_lag", |
| "lag_ms": lag_ms, |
| "threads": active_count(), |
| }) |
|
|
| @asynccontextmanager |
| async def lifespan(_: FastAPI): |
| |
| |
| |
| tokens = apply_thread_pool_tokens() |
| print(f"[thread-pool] worker thread capacity set to {tokens}") |
| stop_event = Event() |
| thread = start_limited_account_watcher(stop_event) |
| backup_service.start() |
| sqlite_mirror_service.start() |
| pool_pricing_service.start() |
| share_evidence_service.start() |
| image_tasks.image_task_service.start_image_persistence() |
| _start_bundled_skill_sync() |
| _start_image_cleanup() |
| watchdog = asyncio.create_task(_loop_lag_watchdog()) |
| wedge_guard = start_loop_wedge_guard(asyncio.get_running_loop(), stop_event) |
| try: |
| yield |
| finally: |
| watchdog.cancel() |
| stop_event.set() |
| wedge_guard.join(timeout=1) |
| thread.join(timeout=1) |
| image_tasks.image_task_service.stop_image_persistence() |
| backup_service.stop() |
| sqlite_mirror_service.stop() |
| pool_pricing_service.stop() |
| share_evidence_service.stop() |
| from services.deferred_json_mapping import flush_deferred_mappings |
|
|
| await asyncio.to_thread(flush_deferred_mappings, 2.0) |
|
|
| app = FastAPI(title="CHATSAM", version=app_version, lifespan=lifespan) |
| install_exception_handlers(app) |
| app.add_middleware(GZipMiddleware, minimum_size=1024, compresslevel=1) |
| app.add_middleware( |
| CORSMiddleware, |
| allow_origins=["*"], |
| allow_credentials=False, |
| allow_methods=["*"], |
| allow_headers=["*"], |
| ) |
| app.include_router(ai.create_router()) |
| app.include_router(accounts.create_router()) |
| app.include_router(checkin.create_router()) |
| app.include_router(chat_room.create_router()) |
| app.include_router(image_tasks.create_router()) |
| app.include_router(openui.create_router()) |
| app.include_router(product_visual.create_router()) |
| app.include_router(register.create_router()) |
| app.include_router(shop.create_router()) |
| app.include_router(skills.create_router()) |
| app.include_router(third_party_images.create_router()) |
| app.include_router(system.create_router(app_version)) |
|
|
| @app.get("/{full_path:path}", include_in_schema=False) |
| async def serve_web(full_path: str, request: Request): |
| asset = resolve_web_asset(full_path) |
| if asset is not None: |
| return _web_response(full_path, request, asset) |
| if full_path.strip("/").startswith("_next/"): |
| raise HTTPException(status_code=404, detail="Not Found") |
| fallback = resolve_web_asset("") |
| if fallback is None: |
| raise HTTPException(status_code=404, detail="Not Found") |
| return _web_response("", request, fallback) |
|
|
| @app.head("/{full_path:path}", include_in_schema=False) |
| async def serve_web_head(full_path: str, request: Request): |
| if _is_api_like_path(full_path): |
| raise HTTPException(status_code=405, detail="Method Not Allowed") |
| asset = resolve_web_asset(full_path) |
| if asset is not None: |
| selected_asset, headers, media_type = _select_web_asset(request, full_path, asset) |
| return FileResponse(selected_asset, headers=headers, media_type=media_type) |
| if full_path.strip("/").startswith("_next/"): |
| raise HTTPException(status_code=404, detail="Not Found") |
| fallback = resolve_web_asset("") |
| if fallback is None: |
| raise HTTPException(status_code=404, detail="Not Found") |
| selected_asset, headers, media_type = _select_web_asset(request, "", fallback) |
| return FileResponse(selected_asset, headers=headers, media_type=media_type) |
|
|
| return app |
|
|
