rebuild(runtime): govern market operations and job truth
This commit is contained in:
leefer
@@ -0,0 +1,3 @@
|
||||
from backend.features.operations.service import OperationsService
|
||||
|
||||
__all__ = ["OperationsService"]
|
||||
@@ -0,0 +1,96 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Annotated
|
||||
|
||||
from fastapi import APIRouter, Path, Query, Request
|
||||
|
||||
from backend.data.gateway import MarketDataUnavailable
|
||||
from backend.data.providers.base import ProviderError
|
||||
from backend.features.accounts.auth import (
|
||||
AdminPrincipal,
|
||||
AdminWritePrincipal,
|
||||
AuthenticatedPrincipal,
|
||||
)
|
||||
from backend.features.market.events import MarketEventError
|
||||
from backend.features.operations.schemas import (
|
||||
BackfillInput,
|
||||
EventRevisionInput,
|
||||
JobRunResponse,
|
||||
OperationResult,
|
||||
RuntimeStatusResponse,
|
||||
)
|
||||
from backend.features.operations.service import OperationsError
|
||||
from backend.http.errors import AppError
|
||||
|
||||
router = APIRouter(tags=["operations"])
|
||||
|
||||
|
||||
@router.get("/operations/status", response_model=RuntimeStatusResponse)
|
||||
def public_status(request: Request, _principal: AuthenticatedPrincipal) -> dict:
|
||||
return request.app.state.container.operations.public_status()
|
||||
|
||||
|
||||
@router.get("/admin/operations/jobs", response_model=list[JobRunResponse])
|
||||
def jobs(request: Request, _principal: AdminPrincipal) -> list[dict]:
|
||||
return request.app.state.container.operations.jobs()
|
||||
|
||||
|
||||
@router.post("/admin/operations/backfill", response_model=OperationResult)
|
||||
def backfill(
|
||||
payload: BackfillInput, request: Request, _principal: AdminWritePrincipal
|
||||
) -> dict:
|
||||
try:
|
||||
return request.app.state.container.operations.backfill(
|
||||
payload.start_date.isoformat(), payload.end_date.isoformat()
|
||||
)
|
||||
except OperationsError as exc:
|
||||
raise AppError("invalid_operation", str(exc), 400) from exc
|
||||
|
||||
|
||||
@router.post("/admin/operations/events/supplement", response_model=OperationResult)
|
||||
def supplement_events(
|
||||
request: Request,
|
||||
_principal: AdminWritePrincipal,
|
||||
trade_date: Annotated[str, Query(alias="date")],
|
||||
) -> dict:
|
||||
try:
|
||||
return request.app.state.container.operations.supplement_events(trade_date)
|
||||
except (OperationsError, MarketEventError) as exc:
|
||||
raise AppError("invalid_operation", str(exc), 400) from exc
|
||||
except (MarketDataUnavailable, ProviderError) as exc:
|
||||
raise AppError("event_service_unavailable", str(exc), 503) from exc
|
||||
|
||||
|
||||
@router.put(
|
||||
"/admin/operations/events/{trade_date}/{identifier}",
|
||||
response_model=OperationResult,
|
||||
)
|
||||
def revise_event(
|
||||
payload: EventRevisionInput,
|
||||
request: Request,
|
||||
principal: AdminWritePrincipal,
|
||||
trade_date: Annotated[str, Path()],
|
||||
identifier: Annotated[str, Path(min_length=1, max_length=20)],
|
||||
) -> dict:
|
||||
try:
|
||||
return request.app.state.container.operations.revise_event(
|
||||
principal.user.id,
|
||||
trade_date=trade_date,
|
||||
identifier=identifier,
|
||||
**payload.model_dump(),
|
||||
)
|
||||
except (OperationsError, MarketEventError) as exc:
|
||||
raise AppError("invalid_event_revision", str(exc), 400) from exc
|
||||
|
||||
|
||||
@router.get(
|
||||
"/admin/operations/events/{trade_date}/{identifier}/history",
|
||||
response_model=list[OperationResult],
|
||||
)
|
||||
def event_history(
|
||||
request: Request,
|
||||
_principal: AdminPrincipal,
|
||||
trade_date: Annotated[str, Path()],
|
||||
identifier: Annotated[str, Path(min_length=1, max_length=20)],
|
||||
) -> list[dict]:
|
||||
return request.app.state.container.operations.event_history(trade_date, identifier)
|
||||
@@ -0,0 +1,49 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import date
|
||||
from typing import Any, Literal
|
||||
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
|
||||
class BackfillInput(BaseModel):
|
||||
start_date: date
|
||||
end_date: date
|
||||
|
||||
|
||||
class EventRevisionInput(BaseModel):
|
||||
event_type: Literal["limit_up", "broken", "limit_down"]
|
||||
reason: str = Field(min_length=1, max_length=200)
|
||||
first_time: str = Field(default="", max_length=5)
|
||||
last_time: str = Field(default="", max_length=5)
|
||||
open_times: int | None = Field(default=None, ge=0)
|
||||
|
||||
|
||||
class OperationResult(BaseModel):
|
||||
model_config = {"extra": "allow"}
|
||||
|
||||
|
||||
class JobRunResponse(BaseModel):
|
||||
id: int
|
||||
kind: str
|
||||
run_key: str
|
||||
requested_date: str
|
||||
trigger: str
|
||||
status: Literal["running", "completed", "failed"]
|
||||
attempt: int
|
||||
started_at: str
|
||||
finished_at: str | None
|
||||
duration_ms: int | None
|
||||
coverage: float | None
|
||||
source_set: list[str]
|
||||
output_version: str
|
||||
payload: dict[str, Any]
|
||||
error_code: str
|
||||
error_message: str
|
||||
|
||||
|
||||
class RuntimeStatusResponse(BaseModel):
|
||||
state: Literal["idle", "running", "ready", "degraded"]
|
||||
message: str
|
||||
trade_date: str | None = None
|
||||
observed_at: str | None = None
|
||||
@@ -0,0 +1,312 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import date, datetime, time
|
||||
from typing import Any
|
||||
from uuid import uuid4
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
from backend.data.repository import MarketRepository
|
||||
from backend.database.connection import Database
|
||||
from backend.features.market.events import MarketEventService
|
||||
from backend.features.market.service import MarketService
|
||||
from backend.features.screener.service import ScreenerService
|
||||
from backend.jobs.service import JobAlreadyRunning, JobService
|
||||
|
||||
SHANGHAI = ZoneInfo("Asia/Shanghai")
|
||||
|
||||
|
||||
class OperationsError(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class OperationsService:
|
||||
def __init__(
|
||||
self,
|
||||
database: Database,
|
||||
market_repository: MarketRepository,
|
||||
market: MarketService,
|
||||
events: MarketEventService,
|
||||
screener: ScreenerService,
|
||||
jobs: JobService,
|
||||
) -> None:
|
||||
self._database = database
|
||||
self._market_repository = market_repository
|
||||
self._market = market
|
||||
self._events = events
|
||||
self._screener = screener
|
||||
self._jobs = jobs
|
||||
|
||||
def refresh(
|
||||
self,
|
||||
requested_date: str | None = None,
|
||||
*,
|
||||
trigger: str = "administrator",
|
||||
realtime: bool = False,
|
||||
now: datetime | None = None,
|
||||
run_key: str | None = None,
|
||||
) -> dict[str, Any]:
|
||||
clock = now or datetime.now(SHANGHAI)
|
||||
target = _date(requested_date or clock.date().isoformat())
|
||||
key = run_key or f"{target}:{trigger}:{uuid4().hex}"
|
||||
try:
|
||||
return self._jobs.execute(
|
||||
kind="market.refresh",
|
||||
run_key=key,
|
||||
requested_date=target,
|
||||
trigger=trigger,
|
||||
operation=lambda: (
|
||||
self._market.sync_realtime(target, clock)
|
||||
if realtime
|
||||
else self._market.sync_snapshot(target)
|
||||
),
|
||||
stale_after_seconds=120,
|
||||
)
|
||||
except JobAlreadyRunning as exc:
|
||||
raise OperationsError("行情刷新任务正在运行") from exc
|
||||
|
||||
def backfill(self, start_date: str, end_date: str) -> dict[str, Any]:
|
||||
start, end = _date(start_date), _date(end_date)
|
||||
if start > end:
|
||||
raise OperationsError("开始日期不能晚于结束日期")
|
||||
with self._database.read() as connection:
|
||||
dates = self._market_repository.open_dates_between(connection, start, end)
|
||||
if not dates:
|
||||
raise OperationsError("所选范围没有交易日")
|
||||
if len(dates) > 15:
|
||||
raise OperationsError("单次最多回补15个交易日")
|
||||
|
||||
def operation() -> dict[str, Any]:
|
||||
rows = []
|
||||
for target in dates:
|
||||
rows.append(
|
||||
self.refresh(
|
||||
target,
|
||||
trigger="historical-backfill",
|
||||
run_key=f"{target}:archive-v1",
|
||||
)
|
||||
)
|
||||
return {
|
||||
"start_date": start,
|
||||
"end_date": end,
|
||||
"dates": list(dates),
|
||||
"completed": len(rows),
|
||||
"coverage": min(
|
||||
(float(row.get("coverage") or 0) for row in rows), default=0
|
||||
),
|
||||
"source_set": ["tushare", "local"],
|
||||
"output_version": "historical-backfill-v1",
|
||||
}
|
||||
|
||||
try:
|
||||
return self._jobs.execute(
|
||||
kind="market.backfill",
|
||||
run_key=f"{start}:{end}",
|
||||
requested_date=end,
|
||||
trigger="administrator",
|
||||
operation=operation,
|
||||
stale_after_seconds=15 * 60,
|
||||
)
|
||||
except JobAlreadyRunning as exc:
|
||||
raise OperationsError("历史回补任务正在运行") from exc
|
||||
|
||||
def supplement_events(
|
||||
self,
|
||||
trade_date: str,
|
||||
*,
|
||||
trigger: str = "administrator",
|
||||
run_key: str | None = None,
|
||||
) -> dict[str, Any]:
|
||||
target = _date(trade_date)
|
||||
try:
|
||||
return self._jobs.execute(
|
||||
kind="market.event-supplement",
|
||||
run_key=run_key or f"{target}:event-v1:{uuid4().hex}",
|
||||
requested_date=target,
|
||||
trigger=trigger,
|
||||
operation=lambda: self._events.supplement(target),
|
||||
stale_after_seconds=120,
|
||||
)
|
||||
except JobAlreadyRunning as exc:
|
||||
raise OperationsError("事件补充任务正在运行") from exc
|
||||
|
||||
def revise_event(self, user_id: int, **payload: Any) -> dict[str, Any]:
|
||||
return self._events.revise(user_id=user_id, **payload)
|
||||
|
||||
def event_history(self, trade_date: str, identifier: str) -> list[dict[str, Any]]:
|
||||
return self._events.history(trade_date, identifier)
|
||||
|
||||
def jobs(self) -> list[dict[str, Any]]:
|
||||
return self._jobs.latest()
|
||||
|
||||
def public_status(self) -> dict[str, Any]:
|
||||
latest = self._jobs.latest_for_kind("market.refresh")
|
||||
with self._database.read() as connection:
|
||||
snapshot = self._market_repository.latest_summary(
|
||||
connection, datetime.now(SHANGHAI).date().isoformat()
|
||||
)
|
||||
if latest and latest["status"] == "running":
|
||||
return {"state": "running", "message": "正在更新行情数据"}
|
||||
if snapshot is None:
|
||||
message = "等待管理员首次同步真实行情"
|
||||
if latest and latest["status"] == "failed":
|
||||
message = "最近行情更新失败，等待重新同步"
|
||||
return {"state": "degraded", "message": message}
|
||||
trade_date = str(snapshot["trade_date"])
|
||||
observed_at = str(snapshot["observed_at"])
|
||||
if latest and latest["status"] == "failed":
|
||||
message = "最近更新失败，继续使用最后成功行情"
|
||||
state = "degraded"
|
||||
elif str(snapshot["state"]) == "realtime":
|
||||
message = f"实时行情更新于 {observed_at[11:19]}"
|
||||
state = "ready"
|
||||
else:
|
||||
message = f"{trade_date} 收盘数据已就绪"
|
||||
state = "ready"
|
||||
return {
|
||||
"state": state,
|
||||
"message": message,
|
||||
"trade_date": trade_date,
|
||||
"observed_at": observed_at,
|
||||
}
|
||||
|
||||
def tick(self, now: datetime | None = None) -> None:
|
||||
clock = now or datetime.now(SHANGHAI)
|
||||
target = clock.date().isoformat()
|
||||
local_time = clock.time().replace(tzinfo=None)
|
||||
in_market = time(9, 15) <= local_time < time(11, 35) or time(
|
||||
12, 55
|
||||
) <= local_time < time(15, 5)
|
||||
is_open = self._is_open(target)
|
||||
if (
|
||||
in_market
|
||||
and is_open
|
||||
and self._jobs.ready_for_schedule(
|
||||
"market.refresh",
|
||||
now=clock,
|
||||
completed_after_seconds=8,
|
||||
failed_after_seconds=60,
|
||||
)
|
||||
):
|
||||
bucket = int(clock.timestamp() // 8)
|
||||
self._attempt(
|
||||
lambda: self.refresh(
|
||||
target,
|
||||
trigger="realtime-poll",
|
||||
realtime=True,
|
||||
now=clock,
|
||||
run_key=f"{target}:realtime:{bucket}",
|
||||
)
|
||||
)
|
||||
if (
|
||||
time(9, 15) <= local_time < time(9, 30)
|
||||
and is_open
|
||||
and self._jobs.ready_for_schedule(
|
||||
"auction.collect",
|
||||
now=clock,
|
||||
completed_after_seconds=8,
|
||||
failed_after_seconds=60,
|
||||
)
|
||||
):
|
||||
bucket = int(clock.timestamp() // 8)
|
||||
self._attempt(
|
||||
lambda: self._jobs.execute(
|
||||
kind="auction.collect",
|
||||
run_key=f"{target}:{bucket}",
|
||||
requested_date=target,
|
||||
trigger="auction-poll",
|
||||
operation=lambda: self._auction_result(target, clock),
|
||||
stale_after_seconds=60,
|
||||
)
|
||||
)
|
||||
if local_time >= time(15, 10) and is_open:
|
||||
final = self._jobs.latest_success("market.refresh", target)
|
||||
if not final or final["payload"].get("output_version") != "market-summary-v1":
|
||||
if self._jobs.ready_for_schedule(
|
||||
"market.refresh",
|
||||
now=clock,
|
||||
completed_after_seconds=0,
|
||||
failed_after_seconds=300,
|
||||
):
|
||||
retry_bucket = int(clock.timestamp() // 300)
|
||||
self._attempt(
|
||||
lambda: self.refresh(
|
||||
target,
|
||||
trigger="after-close",
|
||||
run_key=f"{target}:final:{retry_bucket}",
|
||||
)
|
||||
)
|
||||
return
|
||||
self._after_close(target, clock)
|
||||
|
||||
def _after_close(self, target: str, clock: datetime) -> None:
|
||||
if (
|
||||
not self._jobs.latest_success("market.event-supplement", target)
|
||||
and self._jobs.ready_for_schedule(
|
||||
"market.event-supplement",
|
||||
now=clock,
|
||||
completed_after_seconds=300,
|
||||
failed_after_seconds=300,
|
||||
)
|
||||
):
|
||||
self._attempt(
|
||||
lambda: self.supplement_events(
|
||||
target, trigger="after-close", run_key=f"{target}:event-v1"
|
||||
)
|
||||
)
|
||||
if (
|
||||
not self._jobs.latest_success("screener.after-close", target)
|
||||
and self._jobs.ready_for_schedule(
|
||||
"screener.after-close",
|
||||
now=clock,
|
||||
completed_after_seconds=300,
|
||||
failed_after_seconds=300,
|
||||
)
|
||||
):
|
||||
self._attempt(
|
||||
lambda: self._jobs.execute(
|
||||
kind="screener.after-close",
|
||||
run_key=f"{target}:catalog-v1",
|
||||
requested_date=target,
|
||||
trigger="after-close",
|
||||
operation=self._screener_result,
|
||||
stale_after_seconds=15 * 60,
|
||||
)
|
||||
)
|
||||
|
||||
def _auction_result(self, target: str, clock: datetime) -> dict[str, Any]:
|
||||
result = self._market.sync_insight("auction", target, 0)
|
||||
return {
|
||||
"trade_date": result.get("trade_date") or target,
|
||||
"coverage": result.get("coverage"),
|
||||
"phase": result.get("phase"),
|
||||
"observed_at": result.get("observed_at") or clock.isoformat(timespec="seconds"),
|
||||
"source_set": ["ifind", "tushare", "local"],
|
||||
"output_version": "auction-snapshot-v1",
|
||||
}
|
||||
|
||||
def _screener_result(self) -> dict[str, Any]:
|
||||
result = self._screener.run_after_close() or {}
|
||||
return {
|
||||
**result,
|
||||
"coverage": result.get("coverage"),
|
||||
"source_set": ["tushare", "local"],
|
||||
"output_version": "screener-runs-v1",
|
||||
}
|
||||
|
||||
def _is_open(self, target: str) -> bool:
|
||||
with self._database.read() as connection:
|
||||
return target in self._market_repository.open_dates(connection, target, 1)
|
||||
|
||||
@staticmethod
|
||||
def _attempt(operation) -> None:
|
||||
try:
|
||||
operation()
|
||||
except Exception:
|
||||
return
|
||||
|
||||
|
||||
def _date(value: str) -> str:
|
||||
try:
|
||||
return date.fromisoformat(value).isoformat()
|
||||
except ValueError as exc:
|
||||
raise OperationsError("日期格式无效") from exc
|
||||
Reference in New Issue
Block a user