nex_animation/backend/app/services/capacity.py

136 lines
6.5 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""供应商容量与限流:并发上限 + 每分钟请求数(RPM)+ 排队视图。
以数据库为唯一事实源(running 计数 + started_at 滑动窗口),
因此 API、Celery worker、调度器三方看到的限流状态一致。
"""
from __future__ import annotations
from dataclasses import asdict, dataclass
from datetime import timedelta
from sqlalchemy import case, func, select
from sqlalchemy.orm import Session
from app.config import settings
from app.constants import TaskKind
from app.models.base import now_utc
from app.models import ModelSpec, Task
# 找不到模型规格时,用任务类型推断媒体类型。资产任务默认按图像处理;
# 若使用 TTS 生成声线样本,任务行仍会带上已解析的具体模型,因此会优先命中规格表。
KIND_MEDIA_TYPE = {TaskKind.GENERATE_SHOT: "video", TaskKind.VOICEOVER: "tts",
TaskKind.ASSET: "image", TaskKind.PLATFORM_ASSET: "image"}
@dataclass
class CapacityRow:
provider: str
model: str
media_type: str
concurrency_limit: int
rpm_limit: int
running: int
starts_last_60s: int
queued: int
enabled: bool
@property
def slots(self) -> int:
return max(0, self.concurrency_limit - self.running)
@property
def rpm_headroom(self) -> int:
return max(0, self.rpm_limit - self.starts_last_60s)
def as_dict(self) -> dict:
d = asdict(self)
d.update(slots=self.slots, rpm_headroom=self.rpm_headroom,
saturated=(self.slots == 0 or self.rpm_headroom == 0))
return d
def _spec_limits(spec: ModelSpec | None) -> tuple[int, int, bool]:
if spec is None:
return settings.default_provider_concurrency, settings.default_provider_rpm, True
return int(spec.max_concurrency or 1), int(spec.requests_per_minute or 60), bool(spec.enabled)
def _task_counts(db: Session, *, window_start, project_id: int | None
) -> tuple[dict[tuple[str, str], tuple[int, int]], dict[tuple[str, str], int]]:
"""两条 GROUP BY 一次算完所有容量键的计数。
这里原本是「每个容量键发 3 条 COUNT」:注册表有 5 行 + 历史任务派生的键,
一次 /api/providers 就是 35 条 SQL、p95 逼近 160ms;而前端每个页面首屏都要
await 它,等于全站都在等这条查询。聚合口径与逐键 COUNT 完全一致:
running / starts 历史上是全库统计(不按项目过滤),只有 queued 才带项目条件,
所以必须分两条 GROUP BY,不能合并。
"""
model_col = func.coalesce(Task.model, "").label("model")
usage = db.execute(
select(Task.provider.label("provider"), model_col,
func.sum(case((Task.status == "running", 1), else_=0)).label("running"),
func.sum(case((Task.started_at >= window_start, 1), else_=0)).label("starts"))
.group_by(Task.provider, model_col)
).all()
active = {(r.provider, r.model or ""): (int(r.running or 0), int(r.starts or 0)) for r in usage}
stmt = (select(Task.provider.label("provider"), model_col, func.count(Task.id).label("queued"))
.where(Task.status == "queued").group_by(Task.provider, model_col))
if project_id:
stmt = stmt.where(Task.project_id == project_id)
queued = {(r.provider, r.model or ""): int(r.queued or 0) for r in db.execute(stmt).all()}
return active, queued
def snapshot(db: Session, *, project_id: int | None = None) -> list[CapacityRow]:
now = now_utc()
window_start = now - timedelta(minutes=1)
rows: list[CapacityRow] = []
specs = list(db.scalars(select(ModelSpec)).all())
spec_index = {(s.provider, s.model, s.media_type): s for s in specs}
# 同一个 (provider, model) 只能占一行,且媒体类型必须跟着模型规格走。
# 这里过去把任务派生出的键一律写成 "video",于是配音模型 mock/mock-tts-1 也会
# 多出一行 media_type=video 的容量记录;而 headroom() 与 /api/providers 的 load
# 都按 "provider|model" 取行,后写入的幽灵行会盖掉真正的 TTS 行,
# 结果是配音任务的并发/RPM 被悄悄换成默认的 2/30,限流面板还凭空多出一行。
media_of = {(s.provider, s.model): s.media_type for s in specs}
keys: set[tuple[str, str, str]] = {(s.provider, s.model, s.media_type) for s in specs}
for provider, model, kind in db.execute(select(Task.provider, Task.model, Task.kind)
.where(Task.provider != "").distinct()).all():
media = media_of.get((provider, model or "")) or KIND_MEDIA_TYPE.get(kind, "video")
if not (model or ""):
# 老数据里的任务可能只写了 provider:并入该供应商同媒体类型的规格行,
# 不要让它长出一行拿默认限额(2 并发 / 30 RPM)的幽灵记录。
same = [s for s in specs if s.provider == provider and s.media_type == media and s.model]
if same:
keys.add((provider, sorted(s.model for s in same)[0], media))
continue
keys.add((provider, model or "", media))
counts, queued_map = _task_counts(db, window_start=window_start, project_id=project_id)
for provider, model, media_type in sorted(keys):
spec = spec_index.get((provider, model, media_type)) or spec_index.get((provider, model, "video")) \
or spec_index.get((provider, "", media_type))
conc, rpm, enabled = _spec_limits(spec)
running, starts = counts.get((provider, model or ""), (0, 0))
rows.append(CapacityRow(provider=provider, model=model or "", media_type=media_type,
concurrency_limit=conc, rpm_limit=rpm, running=running,
starts_last_60s=starts, queued=queued_map.get((provider, model or ""), 0),
enabled=enabled))
return rows
def headroom(db: Session, provider: str, model: str | None) -> tuple[int, str]:
"""返回 (可派发数量, 阻塞原因)。"""
rows = {f"{r.provider}|{r.model}": r for r in snapshot(db)}
row = rows.get(f"{provider}|{model or ''}") or rows.get(f"{provider}|")
if row is None:
return 1, ""
if not row.enabled:
return 0, f"模型 {provider}/{row.model} 已停用"
if row.running >= row.concurrency_limit:
return 0, f"并发已满({row.running}/{row.concurrency_limit})"
if row.starts_last_60s >= row.rpm_limit:
return 0, f"已达 RPM 上限({row.starts_last_60s}/{row.rpm_limit})"
return min(row.slots, row.rpm_headroom), ""