Files
live-hub-py/web/backend/services/account_sync_runner.py
T

394 lines
12 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""账号内部同步队列执行器。"""
from __future__ import annotations
from collections.abc import Callable
from concurrent.futures import as_completed
from datetime import UTC, datetime
from typing import Any
from sqlalchemy.orm import Session
from ..database import WorkerSessionLocal
from ..models import Account, AccountWorkItem
from .account_exchange_sync_service import sync_exchange_records
from .account_sync_service import (
DOMAIN_ELITE,
DOMAIN_ESPORTS,
DOMAIN_EXCHANGE_RECORDS,
DOMAIN_GOLD,
DOMAIN_POINTS,
DOMAIN_ROLE,
DOMAIN_STOREHOME,
sync_storehome_snapshot,
)
from .account_work_queue import (
claim_account_work,
complete_account_work,
fail_account_work,
)
from .douyu_account_probe import (
config_mapping,
persist_probe_result,
probe_account,
)
from .douyu_activity_query import activity_client
from .douyu_read_gateway import StorehomeSnapshot, fetch_storehome_snapshot
from .douyu_service import ensure_douyu_config
from .task_runtime import TaskLane, available_slots, submit
WORK_STOREHOME_SYNC = DOMAIN_STOREHOME + "_sync"
WORK_POINTS_SYNC = DOMAIN_POINTS + "_sync"
WORK_GOLD_SYNC = DOMAIN_GOLD + "_sync"
WORK_ROLE_SYNC = DOMAIN_ROLE + "_sync"
WORK_ELITE_SYNC = DOMAIN_ELITE + "_sync"
WORK_ESPORTS_SYNC = DOMAIN_ESPORTS + "_sync"
WORK_EXCHANGE_RECORDS_SYNC = DOMAIN_EXCHANGE_RECORDS + "_sync"
ACCOUNT_SYNC_WORK_TYPES = (
WORK_STOREHOME_SYNC,
WORK_POINTS_SYNC,
WORK_GOLD_SYNC,
WORK_ROLE_SYNC,
WORK_ELITE_SYNC,
WORK_ESPORTS_SYNC,
WORK_EXCHANGE_RECORDS_SYNC,
)
def _execute_storehome_sync(
db: Session,
*,
account: Account,
item: AccountWorkItem,
client_factory: Callable[[str], Any],
snapshot_fetcher: Callable[..., StorehomeSnapshot],
) -> dict[str, Any]:
if not account.cookie:
raise RuntimeError("账号没有可用 CK,不能同步商品能力")
if account.ck_check_status in {"invalid", "manual"}:
raise RuntimeError(f"账号 CK 状态为 {account.ck_check_status},暂不能同步商品能力")
config = ensure_douyu_config(db)
manual_id = str(getattr(config, "manual_id", "") or "")
rid = str(getattr(config, "rid", "") or "")
if not manual_id:
raise RuntimeError("未配置精英宝典 manualID")
client = client_factory(account.cookie)
snapshot = snapshot_fetcher(
client,
manual_id=manual_id,
rid=rid,
)
result = sync_storehome_snapshot(
db,
account,
snapshot,
source="account_work.storehome_sync",
)
return {
"ok": True,
"work_id": int(item.id),
"account_id": int(account.id),
"item_count": result.item_count,
"changed_count": result.changed_count,
}
def _profile_probe_kwargs(
work_type: str,
config: Any,
) -> dict[str, Any]:
base = {
"with_elite": False,
"with_esports": False,
"with_storehome": False,
"with_eligibility": False,
"with_limited_goods": False,
"with_gold": False,
"with_goods": False,
"with_elite_role": False,
"include_esports": False,
"include_peace": False,
"use_cache": False,
}
if work_type == WORK_POINTS_SYNC:
return {**base, "with_eligibility": True}
if work_type == WORK_GOLD_SYNC:
return {**base, "with_gold": True}
if work_type == WORK_ROLE_SYNC:
return {
**base,
"with_elite_role": True,
"include_esports": True,
"include_peace": bool(getattr(config, "peace_enabled", False)),
}
if work_type == WORK_ELITE_SYNC:
return {**base, "with_elite": True}
if work_type == WORK_ESPORTS_SYNC:
return {**base, "with_esports": True}
raise RuntimeError(f"不支持的账号资料同步类型: {work_type}")
def _profile_domain_succeeded(work_type: str, probe: dict[str, Any]) -> bool:
if work_type == WORK_POINTS_SYNC:
eligibility = probe.get("eligibility") or {}
return bool(
eligibility.get("points") is not None
and isinstance(eligibility.get("points_response"), dict)
and eligibility["points_response"]
)
if work_type == WORK_GOLD_SYNC:
return (probe.get("gold") or {}).get("status") == "ok"
if work_type == WORK_ROLE_SYNC:
roles = probe.get("roles") or {}
return any(
(role or {}).get("status") in {"bound", "pending", "unbound"}
for role in roles.values()
if isinstance(role, dict)
)
if work_type == WORK_ELITE_SYNC:
return (probe.get("elite") or {}).get("status") == "ok"
if work_type == WORK_ESPORTS_SYNC:
return (probe.get("esports") or {}).get("status") == "ok"
return False
def _execute_profile_sync(
db: Session,
*,
account: Account,
item: AccountWorkItem,
client_factory: Callable[[str], Any],
probe_fetcher: Callable[..., dict[str, Any]],
) -> dict[str, Any]:
if not account.cookie:
raise RuntimeError("账号没有可用 CK,不能同步账号资料")
if account.ck_check_status in {"invalid", "manual"}:
raise RuntimeError(f"账号 CK 状态为 {account.ck_check_status},暂不能同步")
config = ensure_douyu_config(db)
client = client_factory(account.cookie)
probe = probe_fetcher(
account,
config,
client=client,
**_profile_probe_kwargs(item.work_type, config),
)
errors = probe.get("errors") or {}
domain_error = {
WORK_POINTS_SYNC: "points",
WORK_GOLD_SYNC: "gold",
WORK_ROLE_SYNC: "elite_role",
WORK_ELITE_SYNC: "elite",
WORK_ESPORTS_SYNC: "esports",
}.get(item.work_type, "")
if domain_error and domain_error in errors:
raise RuntimeError(str(errors[domain_error]))
if not _profile_domain_succeeded(item.work_type, probe):
detail = ";".join(str(value) for value in errors.values())
raise RuntimeError(detail or f"{item.work_type} 未返回可落库结果")
persist_probe_result(
db,
account,
probe,
source=f"account_work.{item.work_type}",
record_event=False,
update_session=False,
)
return {
"ok": True,
"work_id": int(item.id),
"account_id": int(account.id),
"work_type": item.work_type,
"errors": sorted(errors),
}
def _execute_exchange_records_sync(
db: Session,
*,
account: Account,
item: AccountWorkItem,
client_factory: Callable[[str], Any],
) -> dict[str, Any]:
if not account.cookie:
raise RuntimeError("账号没有可用 CK,不能同步兑换记录")
if account.ck_check_status in {"invalid", "manual"}:
raise RuntimeError(
f"账号 CK 状态为 {account.ck_check_status},暂不能同步兑换记录"
)
config = ensure_douyu_config(db)
result = sync_exchange_records(
db,
account,
client_factory(account.cookie),
config_mapping(config),
source=f"account_work.{item.work_type}",
)
return {
"ok": True,
"work_id": int(item.id),
"account_id": int(account.id),
"work_type": item.work_type,
**result,
}
def execute_account_work_item(
work_id: int,
*,
session_factory: Callable[[], Session] = WorkerSessionLocal,
client_factory: Callable[[str], Any] = activity_client,
snapshot_fetcher: Callable[..., StorehomeSnapshot] = fetch_storehome_snapshot,
probe_fetcher: Callable[..., dict[str, Any]] = probe_account,
) -> dict[str, Any]:
"""在一个短事务中执行单条账号维护工作。"""
session = session_factory()
item: AccountWorkItem | None = None
try:
item = session.get(AccountWorkItem, int(work_id))
if item is None or item.status != "running":
return {"ok": False, "work_id": int(work_id), "skipped": True}
account = session.get(Account, int(item.account_id))
if account is None:
raise RuntimeError("工作项对应账号不存在")
if item.work_type == WORK_STOREHOME_SYNC:
result = _execute_storehome_sync(
session,
account=account,
item=item,
client_factory=client_factory,
snapshot_fetcher=snapshot_fetcher,
)
elif item.work_type == WORK_EXCHANGE_RECORDS_SYNC:
result = _execute_exchange_records_sync(
session,
account=account,
item=item,
client_factory=client_factory,
)
elif item.work_type in ACCOUNT_SYNC_WORK_TYPES:
result = _execute_profile_sync(
session,
account=account,
item=item,
client_factory=client_factory,
probe_fetcher=probe_fetcher,
)
else:
raise RuntimeError(f"不支持的工作类型: {item.work_type}")
complete_account_work(session, item)
session.commit()
return result
except Exception as exc: # noqa: BLE001 - 单工作项失败必须收敛到队列状态
if not session.is_active:
session.rollback()
item = session.get(AccountWorkItem, int(work_id))
if item is not None:
fail_account_work(
session,
item,
error=exc,
retry_after_seconds=15 * 60,
)
session.commit()
return {
"ok": False,
"work_id": int(work_id),
"error": f"{type(exc).__name__}: {exc}"[:500],
}
finally:
session.close()
def run_account_sync_queue(
db: Session,
*,
batch_size: int = 20,
now: datetime | None = None,
session_factory: Callable[[], Session] = WorkerSessionLocal,
client_factory: Callable[[str], Any] = activity_client,
snapshot_fetcher: Callable[..., StorehomeSnapshot] = fetch_storehome_snapshot,
probe_fetcher: Callable[..., dict[str, Any]] = probe_account,
) -> dict[str, Any]:
"""领取少量到期工作并通过独立账号同步槽执行。"""
moment = now or datetime.now(UTC)
capacity = available_slots(TaskLane.ACCOUNT_SYNC)
if capacity <= 0:
return {
"scanned": 0,
"success": 0,
"failed": 0,
"message": "账号同步槽已满,本轮跳过",
}
limit = max(1, min(int(batch_size), capacity))
items = claim_account_work(
db,
work_types=ACCOUNT_SYNC_WORK_TYPES,
limit=limit,
now=moment,
)
db.commit()
if not items:
return {
"scanned": 0,
"success": 0,
"failed": 0,
"message": "暂无到期的账号同步工作",
}
futures = {}
for item in items:
work_id = int(item.id)
future = submit(
TaskLane.ACCOUNT_SYNC,
execute_account_work_item,
work_id,
session_factory=session_factory,
client_factory=client_factory,
snapshot_fetcher=snapshot_fetcher,
probe_fetcher=probe_fetcher,
)
if future is not None:
futures[future] = work_id
success = 0
failed = 0
skipped = 0
for future in as_completed(futures):
try:
result = future.result()
except Exception: # noqa: BLE001 - worker 异常已由执行函数收敛,这里只计数
failed += 1
continue
if result.get("ok"):
success += 1
elif result.get("skipped"):
skipped += 1
else:
failed += 1
return {
"scanned": len(futures),
"success": success,
"failed": failed,
"skipped": skipped,
"message": (
f"账号同步完成 {success} 条"
+ (f",失败 {failed} 条" if failed else "")
+ (f",跳过 {skipped} 条" if skipped else "")
),
}
__all__ = [
"ACCOUNT_SYNC_WORK_TYPES",
"WORK_ELITE_SYNC",
"WORK_ESPORTS_SYNC",
"WORK_EXCHANGE_RECORDS_SYNC",
"WORK_GOLD_SYNC",
"WORK_POINTS_SYNC",
"WORK_ROLE_SYNC",
"WORK_STOREHOME_SYNC",
"execute_account_work_item",
"run_account_sync_queue",
]