1876 lines
98 KiB
Python
1876 lines
98 KiB
Python
"""Serial account runtime for the Web workspace (no GUI imports).
|
||
|
||
Worker contract for actions/views owners:
|
||
engine: ranch_assistant.engine.Engine; config: validated complete dict.
|
||
catalog: account-local Catalog (overrides must not leak to other accounts).
|
||
profile_root: stable profiles/<account id>; state_root/state: current role root.
|
||
securestore/session_store: Web encrypted store scoped to this account.
|
||
trace: redacting TraceLog-compatible recorder; log(message, *, debug=False).
|
||
save_config(config=None): validate/apply/save on this worker's thread.
|
||
replace_config(config): alias for save_config, returns {config, revision}.
|
||
stop(): immediate cancellation; start is serialized through manager.submit.
|
||
login_view(): public {servers, saved_sessions, has_saved_password, account}.
|
||
result(snapshot, plans, message): consume an Engine triple, public message only.
|
||
login view DTO exposes metadata at data.login and the same top-level fields.
|
||
|
||
Lazy network debug: manager.logs(account_id, debug=True) returns summary entries
|
||
with id and details_available; manager.debug_entry(account_id, entry_id) returns
|
||
one {id, details} redacted trace envelope (including body/headers). Suggested REST
|
||
GET /api/accounts/{id}/logs/{entry_id}, using manager.log_detail as an alias.
|
||
No credentials or local paths are exposed.
|
||
|
||
execute_action(worker, operation, payload) runs only on the account thread.
|
||
Its return must be public JSON; no Session, Client, Snapshot, raw response or path.
|
||
GET views are cached and asynchronously rebuilt on that same thread.
|
||
set_config returns {config, revision, pending, job_id, job}; pending=True means
|
||
the revision/config are still the applied ones. Poll job_id for the new revision.
|
||
|
||
Dependency injection: engine_factory(catalog, client=None, budget_path=None)
|
||
has Engine's constructor convention; login_factory(catalog, device, trace=...)
|
||
has PasswordLogin's constructor convention. For offline restoration a fake
|
||
login factory may provide client_factory(session, trace=...) as an attribute.
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
from collections import OrderedDict, deque
|
||
from copy import copy, deepcopy
|
||
from dataclasses import asdict, dataclass
|
||
from datetime import datetime, timedelta, timezone
|
||
from functools import wraps
|
||
import json
|
||
import math
|
||
import re
|
||
import threading
|
||
import uuid
|
||
|
||
import requests
|
||
|
||
from ranch_assistant.api import ApiError, Client, Session, SessionExpiredError, TemporaryApiError, server_entries
|
||
from ranch_assistant.battles import CancelledBeforeDispatch
|
||
from ranch_assistant.debug import TraceLog, sensitive
|
||
from ranch_assistant.engine import Engine
|
||
from ranch_assistant.login import PasswordLogin
|
||
from ranch_assistant.model import Catalog, seconds
|
||
|
||
from .activity import ActivityLog, ActivityLogError
|
||
from .log_categories import endpoint_category, legacy_category, normalize_category, note_hints, operation_category, route_message
|
||
from .policies import apply_config, default_config, validate_config
|
||
from .scheduler import AccountSchedule, FAST_KINDS, Scheduler
|
||
from .store import WebStore, _unlinked, atomic_json, session_identity
|
||
|
||
|
||
PAGES = frozenset("login incubator bag ranch daily hatching mainline battles gifts commissions exploration maps statistics plans yields".split())
|
||
READ_ACTIONS = frozenset({"refresh", "refresh_maps", "refresh_tasks", "export_config", "quote_expansion"})
|
||
STOP_ACTIONS = frozenset({"lock", "unlock", "sell", "feed", "expand", "claim_daily", "import_config"})
|
||
LOCAL_ACTIONS = frozenset({"import_config", "export_config", "import_yields"})
|
||
LIFECYCLE = frozenset({"login", "enter_server", "restore_session", "logout", "forget_login", "start", "stop"})
|
||
SECRET_FIELDS = frozenset({"key", "reqid", "reqsid", "requestid", "authorization", "cookie", "setcookie", "protected",
|
||
"raw", "snapshot", "rawsnapshot", "accountid", "serverurl", "gameserveraddress", "centerurl", "deviceid",
|
||
"profileroot", "stateroot", "budgetpath", "filepath", "headers", "body", "request", "response"})
|
||
|
||
|
||
class RevisionConflict(ValueError):
|
||
"""The browser edited a different applied configuration revision."""
|
||
|
||
|
||
class AutoReloginBlocked(ValueError):
|
||
"""Password login has no verified local credentials/target to use."""
|
||
|
||
|
||
def _private_field(field):
|
||
normalized = str(field).lower().replace("_", "").replace("-", "")
|
||
return normalized in SECRET_FIELDS or sensitive(field)
|
||
|
||
|
||
def _trace_secret(field):
|
||
normalized = str(field).lower().replace("_", "").replace("-", "")
|
||
return sensitive(field) or normalized in {"reqid", "reqsid", "protected"}
|
||
|
||
|
||
@dataclass
|
||
class _Job:
|
||
id: str
|
||
operation: str
|
||
payload: dict
|
||
generation: int
|
||
consuming: bool = False
|
||
status: str = "queued"
|
||
result: object = None
|
||
error: str = ""
|
||
internal: bool = False
|
||
workspace: str = ""
|
||
category: str = "general"
|
||
due_kind: str | None = None
|
||
commission_failure: str = ""
|
||
|
||
def public(self):
|
||
operation = {"__config": "set_config", "__view": "view"}.get(self.operation, self.operation)
|
||
return {"id": self.id, "status": self.status, "operation": operation,
|
||
"result": deepcopy(self.result), "error": self.error}
|
||
|
||
|
||
class WebTrace(TraceLog):
|
||
"""Keep useful private network evidence; expose only short event summaries."""
|
||
|
||
def __init__(self, worker):
|
||
self.worker = worker
|
||
super().__init__(worker.profile_root, on_event=worker._trace_event)
|
||
self.events = deque(maxlen=32)
|
||
|
||
def remember(self, value):
|
||
self.worker.remember(value)
|
||
super().remember(value)
|
||
|
||
def redact(self, value):
|
||
if isinstance(value, dict):
|
||
return {field: "<隐藏>" if _trace_secret(field) else self.redact(item) for field, item in value.items()}
|
||
if isinstance(value, (tuple, list)):
|
||
return [self.redact(item) for item in value]
|
||
return self.worker.safe_text(value) if isinstance(value, str) else value
|
||
|
||
def begin(self, operation, **details):
|
||
self.worker.check_intent(check_persistence=True)
|
||
return super().begin(operation, **details)
|
||
|
||
def emit(self, kind, operation, **details):
|
||
result = super().emit(kind, operation, **details)
|
||
try:
|
||
self.path.chmod(0o600)
|
||
except OSError:
|
||
pass
|
||
return result
|
||
|
||
|
||
class AccountWorker:
|
||
def __init__(self, manager, record):
|
||
self.manager, self.id, self.label = manager, record["id"], record["label"]
|
||
self.demo = record["demo"]
|
||
self.profile_root = manager.store.profile(self.id)
|
||
self.securestore = self.session_store = manager.store.secure(self.id)
|
||
self.catalog = copy(manager.catalog)
|
||
self.catalog.overrides = {}
|
||
self.lock = threading.RLock()
|
||
self.condition = threading.Condition(self.lock)
|
||
self._secret_lock = threading.RLock()
|
||
self._secrets = set()
|
||
self._pending = deque()
|
||
self._jobs = OrderedDict()
|
||
self._activity = ActivityLog(self.profile_root / "activity.json", max_entries=2000)
|
||
self._activity_warning = False
|
||
try:
|
||
self._logs = deque(self._activity.load(), maxlen=2000)
|
||
self._log_sequence = self._activity.sequence
|
||
except ActivityLogError:
|
||
self._activity_warning = True
|
||
self._log_sequence = 1
|
||
self._logs = deque([{"id": 1, "seq": 1, "debug": False, "level": "warning", "category": "general",
|
||
"time": datetime.now(timezone.utc).isoformat(timespec="milliseconds"),
|
||
"message": "首次读取运行日志失败,当前日志暂存内存;后续日志将重试保存"}], maxlen=2000)
|
||
self._debug_entries = OrderedDict()
|
||
self._debug_bytes = 0
|
||
self._views = OrderedDict()
|
||
self._view_jobs = {}
|
||
self._view_epoch = 0
|
||
self._generation = 0
|
||
self._running = False
|
||
self._intent_error = ""
|
||
self._legacy_pending = {}
|
||
self._run_intents = self._load_run_intents()
|
||
self._execution_retry_deadline = None
|
||
self._execution_retry_at = None
|
||
self._execution_retry_attempt = 0
|
||
self._execution_error = ""
|
||
self._execution_block = ""
|
||
self._closing = False
|
||
self._active = None
|
||
self._execution = None
|
||
self._tick_queued = False
|
||
self._closed = threading.Event()
|
||
self._login_pending = None
|
||
self._servers = []
|
||
self._saved_sessions = []
|
||
self._saved_account = ""
|
||
self._has_saved_password = False
|
||
self._last_persisted_session = None
|
||
self._restore_factory = getattr(manager.login_factory, "client_factory", Client)
|
||
self.active_identity = None
|
||
self.error = ""
|
||
self.connection_state = "offline"
|
||
self.connection_message = "离线演示" if self.demo else "尚未连接游戏,请登录并选择区服或手动恢复会话"
|
||
self.last_game_success_at = None
|
||
self.next_retry_at = None
|
||
self._retry_probe = False
|
||
self._last_game_error = None
|
||
self._game_failure_sequence = 0
|
||
self.schedule = AccountSchedule()
|
||
self._auto_relogin_suspended = False
|
||
self._auto_relogin_pending_config = None
|
||
self._auto_relogin_inflight = False
|
||
self._auto_relogin_target = None
|
||
self._auto_relogin_account = ""
|
||
self._auto_relogin_error = ""
|
||
self._auto_relogin_blocked = False
|
||
# Reuse the account's existing disconnected settings for login
|
||
# preferences. Role policies remain in their own role directories.
|
||
self._login_settings_root = manager.store.role_root(self.id)
|
||
self.state_root = self.state = manager.store.role_root(self.id, demo=self.demo)
|
||
self.config, self.revision = self._load_config(self.state_root)
|
||
self.trace = WebTrace(self)
|
||
self.engine = self._engine()
|
||
self._summary = self._make_summary()
|
||
if self._activity_warning:
|
||
self.log("账号工作区已载入")
|
||
self.thread = threading.Thread(target=self._run, name="ranch-web-" + self.id[:8], daemon=True)
|
||
self.thread.start()
|
||
self.enqueue("__initialize", {}, internal=True)
|
||
|
||
def _load_config(self, folder):
|
||
record = self.manager.store.load_config(folder)
|
||
value, revision = (validate_config(record["config"]), record["revision"]) if record else (default_config(), 0)
|
||
if folder != self._login_settings_root:
|
||
login = self.manager.store.load_config(self._login_settings_root)
|
||
if login:
|
||
value["auto_relogin"] = validate_config(login["config"])["auto_relogin"]
|
||
# A saved role is durable keep-login authorization. Old releases used
|
||
# enabled=False as their default; it was never an explicit account clear.
|
||
if re.fullmatch(r"[a-f0-9]{64}", folder.name):
|
||
value["auto_relogin"]["enabled"] = True
|
||
return value, revision
|
||
|
||
def _load_run_intents(self):
|
||
try:
|
||
path = _unlinked(self.profile_root / "run_intent.json")
|
||
if not path.exists():
|
||
return {}
|
||
value = json.loads(path.read_text(encoding="utf-8"))
|
||
if (not isinstance(value, dict) or value.get("schema") != 1
|
||
or not isinstance(value.get("roles"), dict)
|
||
or any(not isinstance(scope, str) or not re.fullmatch(r"[a-f0-9]{64}|demo|disconnected", scope)
|
||
or type(requested) is not bool for scope, requested in value["roles"].items())):
|
||
raise ValueError("invalid run intent")
|
||
pending = value.get("legacy_pending", {})
|
||
if (not isinstance(pending, dict) or any(not re.fullmatch(r"[a-f0-9]{64}", scope)
|
||
or not isinstance(record, dict) or record.get("kind") not in {"gift", "hatch", "feed"}
|
||
or not isinstance(record.get("evidence"), dict) for scope, record in pending.items())):
|
||
raise ValueError("invalid pending evidence")
|
||
self._legacy_pending = pending
|
||
return value["roles"]
|
||
except (OSError, ValueError, TypeError):
|
||
self._intent_error = "运行意愿记录无法读取;已保留原文件,请检查 Web 数据目录后重试"
|
||
return {}
|
||
|
||
@property
|
||
def strategy_requested(self):
|
||
# Missing records migrate to enabled. Transient running=False from an
|
||
# old process is not evidence that the user pressed Stop.
|
||
if self.demo:
|
||
return self._run_intents.get("demo", False)
|
||
return self._run_intents.get(self._workspace(), self._run_intents.get("disconnected", True))
|
||
|
||
def _set_strategy_requested(self, requested):
|
||
"""Only the explicit manager Stop and Start paths may call this."""
|
||
with self.lock:
|
||
if requested:
|
||
# The Start may have waited behind persistence while a later
|
||
# synchronous Stop revoked its generation.
|
||
self.check_intent()
|
||
if self._intent_error:
|
||
raise OSError(self._intent_error)
|
||
self._run_intents[self._workspace()] = bool(requested)
|
||
self._save_run_intents()
|
||
|
||
def _save_run_intents(self):
|
||
try:
|
||
atomic_json(self.profile_root / "run_intent.json", {"schema": 1, "roles": self._run_intents,
|
||
"legacy_pending": self._legacy_pending})
|
||
except (OSError, ValueError):
|
||
self._intent_error = "运行意愿或待核对记录无法持久保存;请检查 Web 数据目录"
|
||
raise OSError(self._intent_error) from None
|
||
|
||
def _legacy_write(self, path, payload):
|
||
"""Fence only three legacy writes lacking Engine's durable journals."""
|
||
if path not in {"monsterService/monsterSendGift", "stackService/stackAddMonster", "monsterService/monsterIntensify"}:
|
||
return None
|
||
if not self.active_identity or self.engine.snapshot is None:
|
||
return None
|
||
if self.active_identity in self._legacy_pending:
|
||
raise ValueError("上次赠礼、装填或喂养请求待核对,禁止自动重发")
|
||
payload = payload or {}
|
||
if path == "monsterService/monsterSendGift":
|
||
mid = int(payload["monsterId"])
|
||
evidence = {"monster": mid, "gift_time": seconds(self.engine.snapshot.monsters[mid].get("giftTime"))}
|
||
kind = "gift"
|
||
elif path == "stackService/stackAddMonster":
|
||
stacks = {int(row["id"]): int(row.get("monsterId") or 0) for row in self.engine.snapshot.raw.get("stacks", [])}
|
||
evidence = {str(egg["stackId"]): stacks[int(egg["stackId"])] for egg in payload["eggs"]}
|
||
kind = "hatch"
|
||
elif path == "monsterService/monsterIntensify" and payload.get("foods"):
|
||
evidence = {"foods": list(payload["foods"])}
|
||
kind = "feed"
|
||
else:
|
||
return None
|
||
with self.lock:
|
||
self._legacy_pending[self.active_identity] = {"kind": kind, "evidence": evidence}
|
||
self._save_run_intents() # A failure here prevents sending the write.
|
||
return self.active_identity
|
||
|
||
def _reconcile_legacy_write(self, snapshot, identity):
|
||
# Raw server snapshots precede Engine's local optimistic gift/growth
|
||
# overlays. An unchanged read, heartbeat or elapsed time is not proof.
|
||
with self.lock:
|
||
record = self._legacy_pending.get(identity)
|
||
if not record:
|
||
return
|
||
evidence, kind = record["evidence"], record["kind"]
|
||
if kind == "gift":
|
||
mon = snapshot.monsters.get(int(evidence["monster"]))
|
||
confirmed = mon is None or seconds(mon.get("giftTime")) > seconds(evidence["gift_time"])
|
||
elif kind == "feed":
|
||
confirmed = all(int(mid) not in snapshot.monsters for mid in evidence["foods"])
|
||
else:
|
||
stacks = {str(row["id"]): int(row.get("monsterId") or 0) for row in snapshot.raw.get("stacks", [])}
|
||
confirmed = bool(evidence) and all(stacks.get(slot, 0) > 0 and stacks[slot] != previous
|
||
for slot, previous in evidence.items())
|
||
if confirmed:
|
||
self._legacy_pending.pop(identity)
|
||
self._save_run_intents()
|
||
|
||
def _pending_battle_recovery(self):
|
||
classify = getattr(self.engine, "pending_battle_recovery", None)
|
||
if callable(classify):
|
||
status = classify()
|
||
return status if isinstance(status, dict) else {}
|
||
# Compatibility for older Engine test doubles without the public API.
|
||
if self.engine.snapshot is not None:
|
||
record = self.engine.battle_journal.pending(self.engine.snapshot)
|
||
if record:
|
||
if self.engine.battles.resumable_task_clock(record) is True:
|
||
return {"resumable": True, "message": "战果已保存;等待结算时间及对应策略启用后续交"}
|
||
return {}
|
||
|
||
def _pending_execution_reason(self):
|
||
suffix = ";禁止自动重发,请在游戏内核对结果"
|
||
if self.active_identity in self._legacy_pending:
|
||
kind = self._legacy_pending[self.active_identity]["kind"]
|
||
return {"gift": "赠礼", "hatch": "装填", "feed": "喂养"}[kind] + "请求结果待核对" + suffix
|
||
if self.engine.snapshot is None:
|
||
return ""
|
||
if self.engine._progression_pending():
|
||
sweep = self.engine.sweeper.state.get("pending")
|
||
if sweep:
|
||
return f"扫荡(关卡 {sweep.get('stage', '')}):{sweep.get('phase') or '请求结果待核对'}" + suffix
|
||
recovery = self._pending_battle_recovery()
|
||
if recovery.get("state") == "blocked_policy":
|
||
return recovery.get("message") or "等待启用本次战斗的来源策略后恢复"
|
||
if recovery.get("resumable") is not True:
|
||
record = self.engine.battle_journal.pending(self.engine.snapshot) or {}
|
||
label = record.get("description") or ("战斗" if record.get("stage_id") else "任务")
|
||
if record.get("stage_id"):
|
||
label += f"(关卡 {record['stage_id']},难度 {record.get('difficulty') or 1})"
|
||
detail = record.get("message") or "请求结果待核对"
|
||
if record.get("execution_status") == "timed_out" or record.get("terminal_reason") == "worker_wall_clock_limit":
|
||
detail = "本地战斗计算超时"
|
||
if (not record.get("battle_data") and not record.get("settlement_dispatched")
|
||
and not record.get("settlement_confirmed")
|
||
and record.get("path") in ("", "battleService/battleStart", "stageService/stageStart")):
|
||
detail += ",尚未提交结算"
|
||
return label + ":" + detail + suffix
|
||
explore = self.engine.explore_planner.pending(self.engine.snapshot)
|
||
if explore:
|
||
label = "探险出发" if explore.get("kind") == "explore_start" else "探险领奖"
|
||
return f"{label}(队伍 {explore.get('team_id', '')}):{explore.get('message') or '请求结果待核对'}" + suffix
|
||
if self.engine._breakthrough_pending:
|
||
record = self.engine._breakthrough_pending
|
||
label = "潜能提升" if record.get("kind") == "potential" else "突破"
|
||
return label + ":" + (record.get("message") or "请求结果待核对") + suffix
|
||
return ""
|
||
|
||
def _refresh_execution(self):
|
||
"""Rearm desired execution, never grant writes to a read-only callback."""
|
||
with self.lock:
|
||
self._execution_block = self._intent_error or self._pending_execution_reason()
|
||
ready = self.demo or self.connection_state == "online" and self.engine.client is not None
|
||
if ready and self.engine.snapshot is not None and not self.schedule.monitoring:
|
||
self.schedule.monitor(True)
|
||
if self._execution_retry_deadline is not None and self.schedule.clock() >= self._execution_retry_deadline:
|
||
self._execution_retry_deadline = self._execution_retry_at = None
|
||
self._running = bool(self.strategy_requested and ready and self.engine.snapshot is not None
|
||
and not self._execution_block and self._execution_retry_deadline is None
|
||
and not self._closing and not self.manager._closing and not getattr(self, "_session_write_error", ""))
|
||
if not self._running:
|
||
self.engine.auto = False
|
||
self.schedule.stop()
|
||
return self._running
|
||
|
||
def _strategy_status(self):
|
||
requested = self.strategy_requested
|
||
if not requested:
|
||
state, message = "stopped", "已按用户选择停止策略;离线后仍按配置间隔重登,点击开始可恢复策略"
|
||
elif self._execution_block:
|
||
state, message = "blocked", self._execution_block
|
||
elif self._execution_retry_deadline is not None:
|
||
state, message = "recovering", self._execution_error + ";等待退避后自动恢复已勾选策略"
|
||
elif self.connection_state == "retrying":
|
||
state, message = "recovering", self.connection_message
|
||
elif not self._running:
|
||
state, message = "offline", self.connection_message
|
||
elif (recovery := self._pending_battle_recovery()).get("resumable") is True:
|
||
state = "recovering"
|
||
message = recovery.get("message") or "等待对应策略允许恢复"
|
||
else:
|
||
state, message = "running", "已勾选的策略将自动执行"
|
||
return {"strategy_requested": requested, "manual_stop": not requested,
|
||
"strategy_state": state, "strategy_message": self.safe_text(message),
|
||
"strategy_retry_at": self._execution_retry_at or (self.next_retry_at if requested else None)}
|
||
|
||
def _execution_failed(self, error):
|
||
self.stop()
|
||
if self._pending_execution_reason():
|
||
return
|
||
self._execution_retry_attempt += 1
|
||
delay = min(5 * 2 ** min(self._execution_retry_attempt - 1, 4), 60)
|
||
self._execution_retry_deadline = self.schedule.clock() + delay
|
||
self._execution_retry_at = (datetime.now(timezone.utc) + timedelta(seconds=delay)).isoformat(timespec="milliseconds")
|
||
self._execution_error = self.safe_text(str(error)) or type(error).__name__
|
||
|
||
def _engine(self, client=None, *, state_root=None, config=None):
|
||
state_root = self.state_root if state_root is None else state_root
|
||
config = self.config if config is None else config
|
||
engine = self.manager.engine_factory(self.catalog, client, state_root / "purchase_budget.json")
|
||
apply_config(engine, config)
|
||
engine.auto = False
|
||
engine.heartbeat_enabled = bool(client)
|
||
self._route_engine_tasks(engine)
|
||
return engine
|
||
|
||
def _attribute_task(self, category):
|
||
# Only the serial account thread owns execution context. HTTP readers,
|
||
# stop requests and other accounts cannot inherit an in-flight task.
|
||
job = self._execution
|
||
if job is not None and threading.current_thread() is getattr(self, "thread", None):
|
||
job.category = normalize_category(category)
|
||
|
||
def _task_category(self):
|
||
if self._execution is not None and threading.current_thread() is getattr(self, "thread", None):
|
||
return self._execution.category
|
||
return "general"
|
||
|
||
def _dispatch_category(self, operation):
|
||
active = self._task_category()
|
||
category = endpoint_category(operation, active=active)
|
||
path = "/".join(str(operation).split("?", 1)[0].split("/")[-2:])
|
||
job = self._execution
|
||
if (job is not None and threading.current_thread() is getattr(self, "thread", None)
|
||
and job.operation == "__tick" and job.due_kind == "poll"
|
||
and active in {"general", "hatching"}
|
||
and path in {"monsterService/monsterSell", "monsterService/monsterIntensify", "stackService/stackTransferMonster"}):
|
||
return "hatching"
|
||
return category
|
||
|
||
def _route_engine_tasks(self, engine):
|
||
# Observe existing action boundaries on this worker's engine instance.
|
||
# Retain context through return/exception until _run publishes the job;
|
||
# generic local story results and pre-dispatch errors have no endpoint.
|
||
sources = {"_run_progression_intent": "mainline", "_execute_legacy_task": "commissions",
|
||
"_run_map_challenge": "maps", "_execute_explore": "exploration",
|
||
"_execute_breakthrough": "ranch", "claim_daily_entry": "daily"}
|
||
for name, category in sources.items():
|
||
method = getattr(engine, name, None)
|
||
if not callable(method):
|
||
continue
|
||
|
||
@wraps(method)
|
||
def routed(*args, _method=method, _name=name, _category=category, **kwargs):
|
||
category = _category
|
||
if _name == "_run_progression_intent":
|
||
try:
|
||
intent = args[0] if args else kwargs.get("intent")
|
||
if intent is None:
|
||
intent = next((item for item in engine._progression_intents
|
||
if not (item.get("block_reason") if isinstance(item, dict) else getattr(item, "block_reason", ""))), None)
|
||
if engine._is_commission(intent):
|
||
category = "commissions"
|
||
except CancelledBeforeDispatch:
|
||
raise
|
||
except Exception:
|
||
# Attribution must not prevent an otherwise valid action.
|
||
category = "general"
|
||
self._attribute_task(category)
|
||
try:
|
||
return _method(*args, **kwargs)
|
||
except CancelledBeforeDispatch:
|
||
raise
|
||
except Exception:
|
||
if category == "commissions":
|
||
# Enrich the existing error entry, preserving the original
|
||
# exception and its one-time reporting on the worker.
|
||
try:
|
||
source = args[0] if args else kwargs.get("intent", kwargs.get("action"))
|
||
if source is None and _name == "_run_progression_intent":
|
||
source = intent
|
||
self._commission_failure_context(engine, source)
|
||
except Exception:
|
||
pass
|
||
raise
|
||
|
||
setattr(engine, name, routed)
|
||
|
||
def _commission_failure_context(self, engine, source):
|
||
if self._execution is None or threading.current_thread() is not getattr(self, "thread", None):
|
||
return
|
||
field = lambda key, default=None: source.get(key, default) if isinstance(source, dict) else getattr(source, key, default)
|
||
payload = field("payload") or {}
|
||
type_id = field("source_task_type_id") or field("task_type_id") or payload.get("taskTypeId")
|
||
info = engine._commission_info(type_id)
|
||
name = info.get("name") or type_id or "名称未记录"
|
||
reward = (info.get("reward") or {}).get("ke")
|
||
expected = f"标注{reward}氪金" if type(reward) in (int, float) else "标注氪金未记录"
|
||
path = field("path", "") or ""
|
||
kind = field("kind", "")
|
||
action = "接取" if path.endswith("taskLoopReceive") or kind in {"quest_accept", "progression_loop_accept"} else (
|
||
"领奖" if path.endswith("taskComplete") or kind in {"quest_complete", "progression_complete"} else "推进")
|
||
self._execution.commission_failure = f"委托「{name}」({expected}){action}异常,结果待核对"
|
||
|
||
def remember(self, value):
|
||
with self._secret_lock:
|
||
if isinstance(value, dict):
|
||
for field, item in value.items():
|
||
if sensitive(field) and isinstance(item, str) and item:
|
||
self._secrets.add(str(item))
|
||
if isinstance(item, (dict, tuple, list)):
|
||
self.remember(item)
|
||
elif isinstance(value, (tuple, list)):
|
||
for item in value:
|
||
self.remember(item)
|
||
|
||
def safe_text(self, value):
|
||
value = str(value)
|
||
with self._secret_lock:
|
||
for secret in sorted(self._secrets, key=len, reverse=True):
|
||
value = value.replace(secret, "<隐藏>")
|
||
for path in (self.manager.store.root, self.profile_root):
|
||
value = value.replace(str(path), "<本地目录>").replace(path.as_posix(), "<本地目录>")
|
||
value = re.sub(r"(?i)(password|passwd|pwd|[\w]*token|reqsid|reqid|authorization|cookie|\bkey)\s*['\"]?\s*[:=]\s*['\"]?[^\s,;\"'}]+", r"\1=<隐藏>", value)
|
||
value = re.sub(r"[A-Za-z]:[\\/][^\r\n\"<>]*", "<本地路径>", value)
|
||
value = re.sub(r"(?<![\w:])/((?:data|home|tmp|var|mnt|app|opt|Users)/[^\s\"<>]*)", "<本地路径>", value)
|
||
return value[:16000]
|
||
|
||
def public_json(self, value, *, _columns=False):
|
||
if value is None or type(value) in (bool, int):
|
||
return value
|
||
if type(value) is float:
|
||
return value if math.isfinite(value) else None
|
||
if isinstance(value, str):
|
||
return self.safe_text(value)
|
||
if isinstance(value, (tuple, list)):
|
||
return [self.public_json(item, _columns=_columns) for item in value]
|
||
if type(value) is dict:
|
||
result = {}
|
||
for field, item in value.items():
|
||
if not isinstance(field, str):
|
||
raise ValueError("操作返回的公开数据字段名必须为字符串")
|
||
# `key` in a column descriptor is the documented view schema.
|
||
if _private_field(field) and not (field == "key" and _columns):
|
||
continue
|
||
if field == "path" and not (isinstance(item, list) and all(isinstance(part, (str, int)) for part in item)):
|
||
continue
|
||
result[field] = self.public_json(item, _columns=field in {"columns", "filters", "pages", "tabs", "form"})
|
||
return result
|
||
raise ValueError("操作返回了不支持的公开数据类型")
|
||
|
||
def log(self, message, *, debug=False, category=None, level="info"):
|
||
message = self.safe_text(message)
|
||
level = level if isinstance(level, str) and level in {"info", "warning", "error", "critical", "debug"} else "info"
|
||
debug = bool(debug or level == "debug")
|
||
if category is None:
|
||
category = self._task_category()
|
||
if category == "general":
|
||
category = legacy_category(message)
|
||
entry = {"time": datetime.now(timezone.utc).isoformat(timespec="milliseconds"),
|
||
"message": message, "category": normalize_category(category),
|
||
"debug": debug, "level": "debug" if debug else level}
|
||
with self.lock:
|
||
try:
|
||
if self._activity_warning:
|
||
# Confirm an actual durable write before declaring recovery;
|
||
# debug appends within a reserved block alone need no IO.
|
||
recovered = self._activity.append({"time": entry["time"], "debug": False, "level": "info", "category": "general",
|
||
"message": "运行日志持久化已恢复;降级期间的日志仅保留在内存"}, after_sequence=self._log_sequence)
|
||
self._logs.append(recovered)
|
||
self._log_sequence = recovered["seq"]
|
||
self._activity_warning = False
|
||
entry = self._activity.append(entry, after_sequence=self._log_sequence)
|
||
except ActivityLogError:
|
||
# Keep retrying the same writer on later events. Logging must
|
||
# never replace a dispatched game's result or original error.
|
||
if not self._activity_warning:
|
||
self._activity_warning = True
|
||
self._log_sequence += 1
|
||
self._logs.append({"id": self._log_sequence, "seq": self._log_sequence,
|
||
"time": entry["time"], "debug": False, "level": "warning", "category": "general",
|
||
"message": "运行日志无法持久保存,当前日志仅保留在内存;请检查 Web 数据目录"})
|
||
entry["id"] = entry["seq"] = self._log_sequence + 1
|
||
self._log_sequence = entry["seq"]
|
||
self._logs.append(entry)
|
||
return entry["id"]
|
||
|
||
def _log_message(self, message):
|
||
sources = []
|
||
for name, category in (("planner", "hatching"), ("hatch_planner", "hatching"),
|
||
("gift_planner", "gifts"), ("breakthrough_planner", "ranch")):
|
||
notes = getattr(getattr(self.engine, name, None), "notes", ())
|
||
sources.append((category, [self.safe_text(note) for note in notes[:512]]))
|
||
for category, text in route_message(self.safe_text(message), context=self._task_category(), hints=note_hints(sources)):
|
||
level = "info"
|
||
if category == "commissions":
|
||
if "战斗失败" in text:
|
||
level = "error"
|
||
elif any(marker in text for marker in ("结果未知", "未确认", "待确认", "等待核对", "奖励未记录")):
|
||
level = "warning"
|
||
self.log(text, category=category, level=level)
|
||
|
||
def _trace_event(self, event):
|
||
fields = [event.get("operation", "网络"), event.get("kind", "")]
|
||
if "http_status" in event:
|
||
fields.append("HTTP " + str(event["http_status"]))
|
||
if "elapsed_ms" in event:
|
||
fields.append(str(event["elapsed_ms"]) + "ms")
|
||
if event.get("message"):
|
||
fields.append(str(event["message"]))
|
||
source = self._dispatch_category(event.get("operation", ""))
|
||
if source == "general":
|
||
source = self._dispatch_category(event.get("url", ""))
|
||
if event.get("kind") == "request" and source != "general":
|
||
self._attribute_task(source)
|
||
category = self._task_category()
|
||
if category == "general":
|
||
category = source
|
||
identifier = self.log(";".join(fields), debug=True, category=category)
|
||
serialized = json.dumps(event, ensure_ascii=False, allow_nan=False).encode("utf-8")
|
||
if len(serialized) > 1024 * 1024:
|
||
event = {"kind": event.get("kind"), "operation": event.get("operation"),
|
||
"message": "单条网络详情超过 1 MiB,详情未保留", "truncated": True, "bytes": len(serialized)}
|
||
serialized = json.dumps(event, ensure_ascii=False).encode("utf-8")
|
||
with self.lock:
|
||
self._debug_entries[identifier] = (deepcopy(event), len(serialized))
|
||
self._debug_bytes += len(serialized)
|
||
while len(self._debug_entries) > 64 or self._debug_bytes > 8 * 1024 * 1024:
|
||
_, (_, size) = self._debug_entries.popitem(last=False)
|
||
self._debug_bytes -= size
|
||
|
||
def _make_summary(self):
|
||
player = {"name": "", "level": 0, "exp": 0, "next_exp": None, "money": 0, "ke": 0, "ti": 0}
|
||
snapshot = self.engine.snapshot
|
||
if snapshot is not None:
|
||
master = snapshot.raw.get("master", {})
|
||
for field in ("level", "exp", "money", "ke", "ti"):
|
||
player[field] = master.get(field, 0)
|
||
player["name"] = master.get("roleName") or master.get("masterName") or master.get("name", "")
|
||
player["next_exp"] = self.catalog.data.get("farm_level", {}).get(str(int(master.get("level") or 1) + 1))
|
||
return self.public_json({"id": self.id, "label": self.label, "connected": self.connection_state == "online",
|
||
"demo": self.demo, "running": self._running, "busy": False, "player": player,
|
||
"revision": self.revision, "error": self.error, "connection_state": self.connection_state,
|
||
"connection_message": self.connection_message, "last_game_success_at": self.last_game_success_at,
|
||
"next_retry_at": self.next_retry_at, "auto_relogin_status": self._auto_relogin_status(), **self._strategy_status()})
|
||
|
||
def _auto_relogin_status(self):
|
||
with self.lock:
|
||
preference = (self._auto_relogin_pending_config[1] if self._auto_relogin_pending_config
|
||
else self.config["auto_relogin"])
|
||
state, message, next_at = "idle", "自动重登已开启;等待游戏连接掉线", None
|
||
if not preference["enabled"]:
|
||
state, message = "disabled", "自动重登已关闭"
|
||
elif self._auto_relogin_suspended:
|
||
state, message = "suspended", "已暂停本次自动重登;手动登录或恢复成功后重新参与掉线监测"
|
||
elif self._auto_relogin_pending_config:
|
||
state, message = "suspended", "正在保存自动重登设置,旧登录计划已取消"
|
||
elif self.demo:
|
||
message = "离线演示不执行自动重登"
|
||
elif self._auto_relogin_inflight:
|
||
state, message = "authenticating", "正在使用服务器保存的密码重新登录原区服、原角色;激活成功后将尝试开启已勾选的策略"
|
||
elif not self.active_identity or self.schedule.disconnected_at is not None and not self._auto_relogin_target:
|
||
state, message = "blocked", "没有可确认的原区服和角色会话,请先手动登录并选择区服"
|
||
elif self.schedule.disconnected_at is not None:
|
||
if not self._has_saved_password:
|
||
state, message = "blocked", "未在服务器保存密码,无法自动重登;请手动登录并勾选记住密码"
|
||
elif self._auto_relogin_account != self._saved_account:
|
||
state, message = "blocked", "保存密码的账号与掉线角色所属账号不匹配,请手动登录确认"
|
||
elif self._auto_relogin_blocked:
|
||
state, message = "blocked", self._auto_relogin_error
|
||
else:
|
||
deadline = self.schedule.auto_relogin_deadline(self.config)
|
||
if deadline is not None:
|
||
next_at = datetime.fromtimestamp(self.schedule.disconnected_wall_at
|
||
+ deadline - self.schedule.disconnected_at, timezone.utc).isoformat(timespec="milliseconds")
|
||
state = "failed" if self._auto_relogin_error else "waiting"
|
||
message = (self._auto_relogin_error + ";将按配置分钟间隔再次尝试" if self._auto_relogin_error
|
||
else f"游戏已掉线,从首次掉线起等待 {preference['delay_minutes']} 分钟后重新登录原区服、原角色")
|
||
return {"state": state, "message": self.safe_text(message), "next_attempt_at": next_at}
|
||
|
||
def _mark_disconnected(self, session, identity):
|
||
if not self._auto_relogin_suspended and self.schedule.disconnected_at is None:
|
||
self.schedule.disconnected()
|
||
self._auto_relogin_target = identity
|
||
self._auto_relogin_account = session.account_name.strip()
|
||
self._auto_relogin_error = ""
|
||
self._auto_relogin_blocked = False
|
||
|
||
def suspend_auto_relogin(self):
|
||
# Called synchronously at submit/close, before any queued lifecycle job.
|
||
with self.lock:
|
||
self._auto_relogin_suspended = True
|
||
self.schedule.clear_disconnection()
|
||
self._auto_relogin_target = None
|
||
self._auto_relogin_account = ""
|
||
self._auto_relogin_error = ""
|
||
self._auto_relogin_blocked = False
|
||
|
||
def _require_game(self):
|
||
if self.connection_state != "online" and not (self._retry_probe and self.connection_state == "retrying"):
|
||
raise ValueError(self.connection_message)
|
||
|
||
def _game_failed(self, error, client):
|
||
# Candidate login/restore clients may fail while the previous role is
|
||
# still healthy. Only that client's verified activation replaces it.
|
||
if client is not self.engine.client or isinstance(error, CancelledBeforeDispatch):
|
||
return
|
||
if self._last_game_error is error:
|
||
return
|
||
cause = error.__cause__
|
||
code = str(error.code) if isinstance(error, ApiError) and error.code is not None else None
|
||
temporary = (isinstance(error, (TemporaryApiError, requests.RequestException))
|
||
or isinstance(cause, requests.RequestException) or code == "997")
|
||
expired = isinstance(error, SessionExpiredError) or code == "408"
|
||
if not (temporary or isinstance(error, ApiError)):
|
||
return
|
||
self._last_game_error = error
|
||
self._game_failure_sequence += 1
|
||
self.stop()
|
||
if code is not None and not (temporary or expired):
|
||
# A decoded business rejection proves neither disconnection nor
|
||
# expiry. Keep monitoring, but never retry its rejected write.
|
||
self.error = self._last_game_error_message = self.safe_text(str(error))
|
||
self._execution_failed(error)
|
||
self.log(self.error, level="error")
|
||
return
|
||
self.engine.heartbeat_enabled = False
|
||
if client is not None:
|
||
self._mark_disconnected(client.session, self.active_identity)
|
||
delay = self.schedule.game_failed(retry=temporary and not expired and client is not None)
|
||
with self.lock:
|
||
self.next_retry_at = None
|
||
if expired:
|
||
self.connection_state = "expired"
|
||
message = "游戏会话已失效(408);游戏请求已暂停,将按配置间隔重新登录,策略运行意愿已保留"
|
||
elif temporary and client is not None:
|
||
self.connection_state = "retrying"
|
||
reason = "游戏网络请求超时" if isinstance(error, requests.Timeout) or isinstance(cause, requests.Timeout) else "游戏网络暂时不可用"
|
||
message = f"{reason};{delay} 秒后只读重试,连接恢复后自动继续已勾选策略,未确认记录保留"
|
||
self.next_retry_at = (datetime.now(timezone.utc) + timedelta(seconds=delay)).isoformat(timespec="milliseconds")
|
||
elif temporary:
|
||
self.connection_state = "offline"
|
||
message = "游戏网络请求未确认完成;会话尚未恢复,请手动再次恢复会话或重新登录,策略保持停止"
|
||
else:
|
||
self.connection_state = "offline"
|
||
message = "游戏请求失败,已停止策略和游戏请求,请手动恢复会话:" + str(error)
|
||
self.error = self.connection_message = self.safe_text(message)
|
||
self._last_game_error_message = self.error
|
||
self.log(self.connection_message, category="login", level="error")
|
||
|
||
def _game_succeeded(self, *, activated=False):
|
||
previous = self.connection_state
|
||
with self.lock:
|
||
self.connection_state = "online"
|
||
self.connection_message = "游戏连接正常"
|
||
self.last_game_success_at = datetime.now(timezone.utc).isoformat(timespec="milliseconds")
|
||
self.next_retry_at = None
|
||
self.error = ""
|
||
if activated:
|
||
self._auto_relogin_suspended = False
|
||
self._auto_relogin_target = None
|
||
self._auto_relogin_account = ""
|
||
self._auto_relogin_error = ""
|
||
self._auto_relogin_blocked = False
|
||
self.schedule.game_resumed()
|
||
self.engine.heartbeat_enabled = True
|
||
self._refresh_execution()
|
||
if previous != "online" and not activated:
|
||
self.log("游戏连接已确认;" + ("已勾选的策略继续运行" if self.running else "策略保持停止"), category="login")
|
||
|
||
def status(self):
|
||
with self.lock:
|
||
result = deepcopy(self._summary)
|
||
result.update(running=self._running, busy=bool(self._active or self._pending))
|
||
result["auto_relogin_status"] = self._auto_relogin_status()
|
||
result.update(self._strategy_status())
|
||
return result
|
||
|
||
@property
|
||
def running(self):
|
||
with self.lock:
|
||
return self._running
|
||
|
||
def login_view(self):
|
||
with self.lock:
|
||
return deepcopy({"servers": self._servers, "saved_sessions": self._saved_sessions,
|
||
"has_saved_password": self._has_saved_password, "account": self._saved_account})
|
||
|
||
def _refresh_login_metadata(self):
|
||
remember, account, password = self.securestore.load_credentials()
|
||
self.remember({"password": password})
|
||
entries = self.public_json(self.securestore.entries())
|
||
with self.lock:
|
||
self._saved_sessions = entries
|
||
self._saved_account = account if remember else ""
|
||
self._has_saved_password = bool(remember and password)
|
||
|
||
def check_intent(self, *, check_persistence=False):
|
||
with self.lock:
|
||
job = self._execution
|
||
if job and job.consuming and (self._closing or self.manager._closing or job.generation != self._generation):
|
||
raise CancelledBeforeDispatch()
|
||
if check_persistence and getattr(self, "_session_write_error", ""):
|
||
raise OSError(self._session_write_error)
|
||
|
||
def stop(self, *, keep_running=False):
|
||
"""Never wait on the Engine operation lock or the account queue."""
|
||
with self.condition:
|
||
previous_generation = self._generation
|
||
self._generation += 1
|
||
# Desktop actions stop automation just before their own confirmed
|
||
# manual request. Preserve only that already-current manual intent;
|
||
# an HTTP stop from another thread must still cancel it immediately.
|
||
current = self._execution
|
||
if (threading.current_thread() is self.thread and current and current.generation == previous_generation
|
||
and current.operation in STOP_ACTIONS | {"quote_expansion", "reset_map_pending"}):
|
||
current.generation = self._generation
|
||
if not keep_running:
|
||
self._running = False
|
||
self.engine.auto = False
|
||
self.engine.cancel_progression()
|
||
self.schedule.stop()
|
||
for job in self._pending:
|
||
if job.consuming:
|
||
job.status = "cancelled"
|
||
job.error = "操作尚未开始,已取消"
|
||
job.payload = {}
|
||
self.condition.notify_all()
|
||
|
||
def enqueue(self, operation, payload=None, *, consuming=False, internal=False):
|
||
with self.condition:
|
||
if self._closing:
|
||
raise RuntimeError("账号正在关闭")
|
||
if len(self._pending) >= 256:
|
||
raise RuntimeError("账号待处理操作过多,请等待当前任务完成")
|
||
job = _Job(uuid.uuid4().hex, operation, deepcopy(payload or {}), self._generation,
|
||
consuming=consuming, internal=internal, workspace=self._workspace())
|
||
self._jobs[job.id] = job
|
||
self._pending.append(job)
|
||
for identifier in list(self._jobs):
|
||
if len(self._jobs) <= 256:
|
||
break
|
||
if self._jobs[identifier].status in {"succeeded", "failed", "cancelled"}:
|
||
self._jobs.pop(identifier)
|
||
self.condition.notify()
|
||
return job.public()
|
||
|
||
def job(self, identifier):
|
||
with self.lock:
|
||
if identifier not in self._jobs or self._jobs[identifier].internal and self._jobs[identifier].operation != "__view":
|
||
raise KeyError("任务不存在")
|
||
return self._jobs[identifier].public()
|
||
|
||
def request_tick(self):
|
||
with self.condition:
|
||
if self._closing or self._active or self._pending or self._tick_queued:
|
||
return
|
||
self._tick_queued = True
|
||
self.enqueue("__tick", internal=True)
|
||
|
||
def _run(self):
|
||
try:
|
||
while True:
|
||
with self.condition:
|
||
self.condition.wait_for(lambda: self._pending or self._closing)
|
||
if self._closing and not self._pending:
|
||
break
|
||
job = self._pending.popleft()
|
||
view_key = tuple(job.payload["key"]) if job.operation == "__view" and "key" in job.payload else None
|
||
if job.operation == "__tick":
|
||
self._tick_queued = False
|
||
if job.status == "cancelled":
|
||
continue
|
||
if job.consuming and job.generation != self._generation:
|
||
job.status, job.error, job.payload = "cancelled", "操作尚未开始,已取消", {}
|
||
continue
|
||
self._active = self._execution = job
|
||
job.category = operation_category(job.operation, job.payload)
|
||
job.status = "running"
|
||
final_status, final_error, public_result = "succeeded", "", None
|
||
failure_sequence = self._game_failure_sequence
|
||
try:
|
||
result = self._execute(job)
|
||
public_result = self.public_json(result)
|
||
if failure_sequence != self._game_failure_sequence:
|
||
final_status, final_error = "failed", self._last_game_error_message
|
||
except CancelledBeforeDispatch:
|
||
final_status, final_error = "cancelled", "未发送的操作已取消;已发请求保留核对记录"
|
||
except Exception as error:
|
||
if self.engine.client is None and job.operation in {"enter_server", "restore_session"}:
|
||
self._game_failed(error, None)
|
||
message = self.error if self._last_game_error is error else self.safe_text(str(error)) or type(error).__name__
|
||
final_status, final_error = "failed", message
|
||
with self.lock:
|
||
if self.connection_state not in {"expired", "retrying"} and not (
|
||
self.engine.client is not None and job.operation in {"login", "enter_server", "restore_session"}):
|
||
self.error = message
|
||
if (job.consuming and job.operation != "start"
|
||
and failure_sequence == self._game_failure_sequence):
|
||
self._execution_failed(error)
|
||
self.log((job.commission_failure + ";" if job.commission_failure else "") + message, category=job.category, level="error")
|
||
finally:
|
||
job.payload = {}
|
||
try:
|
||
self._persist_session()
|
||
self._refresh_execution()
|
||
summary = self._make_summary()
|
||
except Exception as error:
|
||
self.stop()
|
||
self.error = self.safe_text(str(error))
|
||
summary = dict(self._summary, error=self.error, running=False)
|
||
if final_status == "succeeded":
|
||
final_status, final_error = "failed", self.error
|
||
self.log(self.error, category=job.category, level="error")
|
||
with self.condition:
|
||
if self._auto_relogin_pending_config and self._auto_relogin_pending_config[0] == job.id:
|
||
self._auto_relogin_pending_config = None
|
||
self._summary = summary
|
||
# A terminal job means its counters and status are both
|
||
# visible. Publish them atomically for HTTP polling.
|
||
job.result, job.status, job.error = public_result, final_status, final_error
|
||
if view_key is not None and self._view_jobs.get(view_key) == job.id:
|
||
# This index only deduplicates in-flight builds;
|
||
# completed jobs remain pollable in bounded _jobs.
|
||
self._view_jobs.pop(view_key, None)
|
||
self._active = self._execution = None
|
||
self.condition.notify_all()
|
||
finally:
|
||
try:
|
||
self._release_clients()
|
||
finally:
|
||
self.manager._release_identity(self)
|
||
self._closed.set()
|
||
|
||
def _execute(self, job):
|
||
operation, payload = job.operation, job.payload
|
||
if operation == "__initialize":
|
||
self._refresh_login_metadata()
|
||
saved = self.securestore.active()
|
||
if saved is not None and not self.demo:
|
||
# Restore settings without issuing an unsolicited game request.
|
||
session = self.securestore.load(saved)
|
||
self.state_root = self.state = self.manager.store.role_root(self.id, saved)
|
||
self.config, self.revision = self._load_config(self.state_root)
|
||
self.active_identity = saved
|
||
self.engine = self._engine()
|
||
self.connection_message = "服务已启动或重启;已保留会话与策略运行意愿,将等待配置分钟后重新登录原区服、原角色"
|
||
# Opt-in only: retain the known startup offline origin even
|
||
# while disabled, so enabling later can reuse that timestamp.
|
||
self._mark_disconnected(session, saved)
|
||
if self.config["auto_relogin"]["enabled"]:
|
||
self.connection_message = "服务已启动或重启;将等待配置分钟后使用保存的密码重新登录原区服、原角色"
|
||
self.log(self.connection_message, category="login")
|
||
if self.demo:
|
||
self.result(*self.engine.poll())
|
||
self.schedule.monitor(True)
|
||
self.schedule.poll_finished(self.config)
|
||
return None
|
||
if operation == "__tick":
|
||
return self._tick(job)
|
||
if operation == "__view":
|
||
if job.workspace != self._workspace():
|
||
return {"message": "角色已切换,原页面请求已失效"}
|
||
return self._build_view(payload)
|
||
if operation == "__config":
|
||
if job.workspace != self._workspace():
|
||
raise RevisionConflict("账号角色已切换,原角色的策略修改未应用;请刷新后重试")
|
||
return self.save_config(payload["config"], revision=payload.get("revision"))
|
||
if operation in LIFECYCLE:
|
||
return getattr(self, "_" + operation)(payload)
|
||
if job.workspace != self._workspace():
|
||
raise RevisionConflict("账号角色已切换,原角色的操作未执行;请刷新后重试")
|
||
local = operation in LOCAL_ACTIONS or operation == "refresh" and payload.get("page") in {"statistics", "yields", "plans"}
|
||
if not self.demo and not local:
|
||
self._require_game()
|
||
from .actions import execute_action
|
||
# A manual refresh previews state while the chosen execution switch stays on.
|
||
self.engine.auto = False
|
||
result = execute_action(self, operation, payload)
|
||
if isinstance(result, tuple) and len(result) == 3:
|
||
result = self.result(*result)
|
||
self._invalidate_views()
|
||
return result
|
||
|
||
def _workspace(self):
|
||
return self.active_identity or ("demo" if self.demo else "disconnected")
|
||
|
||
def _invalidate_views(self, *, clear=False):
|
||
with self.lock:
|
||
self._view_epoch += 1
|
||
if clear:
|
||
self._views.clear()
|
||
self._view_jobs.clear()
|
||
self._web_expansion_quotes = {}
|
||
|
||
def result(self, snapshot, plans, message):
|
||
"""Actions may consume an Engine triple without exposing its internals."""
|
||
self.engine.snapshot = snapshot
|
||
if message:
|
||
self._log_message(message)
|
||
self._invalidate_views()
|
||
self.schedule.arm(self.engine, self.config, self._running, plans)
|
||
return {"message": self.safe_text(message)}
|
||
|
||
def save_config(self, config=None, *, revision=None):
|
||
if threading.current_thread() is not self.thread:
|
||
raise RuntimeError("策略保存必须在账号队列中执行")
|
||
if revision is not None and revision != self.revision:
|
||
raise RevisionConflict("策略已在其他页面更新,请刷新后重试")
|
||
source = deepcopy(self.config if config is None else config)
|
||
if self._execution and self._execution.operation == "import_config":
|
||
# Legacy portable documents contain strategy rules, not local
|
||
# login authorization. Never erase or enable this preference.
|
||
source["auto_relogin"] = deepcopy(self.config["auto_relogin"])
|
||
value = validate_config(source)
|
||
if self.active_identity and not self.demo:
|
||
value["auto_relogin"]["enabled"] = True
|
||
new_revision = self.revision + 1
|
||
self.manager.store.save_config(self.state_root, value, new_revision)
|
||
if self.state_root != self._login_settings_root:
|
||
login = self.manager.store.load_config(self._login_settings_root)
|
||
local = validate_config(login["config"]) if login else default_config()
|
||
local["auto_relogin"] = deepcopy(value["auto_relogin"])
|
||
self.manager.store.save_config(self._login_settings_root, local, new_revision)
|
||
apply_config(self.engine, value)
|
||
with self.lock:
|
||
self.config, self.revision = value, new_revision
|
||
# A policy job never clears cancellation or resurrects a stopped start.
|
||
if not (self._running and not self._closing and self._execution
|
||
and self._execution.generation == self._generation):
|
||
self.engine.auto = False
|
||
self.schedule.poll_finished(value)
|
||
self.schedule.arm(self.engine, value, self._running, self.engine.plans() if self.engine.snapshot else ())
|
||
self._invalidate_views()
|
||
return {"config": deepcopy(value), "revision": new_revision}
|
||
|
||
replace_config = save_config
|
||
|
||
def view(self, page, query=None):
|
||
if page not in PAGES:
|
||
raise ValueError("未知页面")
|
||
if query is not None and not isinstance(query, dict):
|
||
raise ValueError("页面筛选条件必须是对象")
|
||
query = deepcopy(query or {})
|
||
signature = json.dumps(query, ensure_ascii=False, sort_keys=True, allow_nan=False)
|
||
if len(signature) > 16384:
|
||
raise ValueError("页面筛选条件过长")
|
||
key = (page, signature)
|
||
with self.condition:
|
||
cached = self._views.get(key)
|
||
job_id = self._view_jobs.get(key)
|
||
pending = bool(job_id and self._jobs.get(job_id) and self._jobs[job_id].status in {"queued", "running"})
|
||
if not pending and (cached is None or cached["epoch"] != self._view_epoch):
|
||
job = self.enqueue("__view", {"page": page, "query": query, "key": list(key)}, internal=True)
|
||
self._view_jobs[key] = job_id = job["id"]
|
||
pending = True
|
||
if cached:
|
||
self._views.move_to_end(key)
|
||
return {"data": deepcopy(cached["data"]) if cached else None, "loading": pending,
|
||
"job_id": job_id, "revision": cached["revision"] if cached else self.revision}
|
||
|
||
def _build_view(self, payload):
|
||
from .views import build_view
|
||
data = build_view(self.engine, payload["page"], self.config, payload["query"])
|
||
if payload["page"] == "login":
|
||
metadata = self.login_view()
|
||
data.update(deepcopy(metadata))
|
||
data["login"] = metadata
|
||
data["rows"] = [{"id": str(server["id"]), **server} for server in metadata["servers"]]
|
||
if not self.demo and not self.engine.client:
|
||
data["summary"] = "请登录并选择区服,或恢复已保存的角色;策略保持停止"
|
||
data = self.public_json(data)
|
||
key = tuple(payload["key"])
|
||
with self.lock:
|
||
self._views[key] = {"data": data, "revision": self.revision, "epoch": self._view_epoch}
|
||
self._views.move_to_end(key)
|
||
while len(self._views) > 32:
|
||
self._views.popitem(last=False)
|
||
return {"page": payload["page"], "revision": self.revision}
|
||
|
||
def _set_auto(self, desired):
|
||
with self.lock:
|
||
job = self._execution
|
||
active = bool(desired and self._running and not self._closing and job and job.generation == self._generation)
|
||
self.engine.auto = active
|
||
if active:
|
||
job.consuming = True
|
||
return active
|
||
|
||
def _tick(self, job):
|
||
self._refresh_execution()
|
||
kind = self.schedule.due(self.engine, self.config, self._running)
|
||
job.due_kind, job.category = kind, operation_category(kind)
|
||
if kind is None:
|
||
return None
|
||
if kind == "auto_relogin":
|
||
with self.lock:
|
||
if self._auto_relogin_status()["state"] not in {"waiting", "failed"}:
|
||
# A blocked password login must not starve existing
|
||
# read-only timeout probes that could restore the client.
|
||
kind = self.schedule.due(self.engine, dict(self.config, auto_relogin={"enabled": False}), self._running)
|
||
else:
|
||
# Automation is already stopped on disconnect. This tick
|
||
# still consumes authentication intent and must be revocable.
|
||
job.consuming = True
|
||
self.check_intent()
|
||
self._running = self.engine.auto = False
|
||
self.schedule.stop()
|
||
if kind == "auto_relogin":
|
||
return self._auto_relogin()
|
||
if kind is None:
|
||
return None
|
||
job.due_kind, job.category = kind, operation_category(kind)
|
||
if not self.demo and self.engine.client is None:
|
||
return None
|
||
auto = False
|
||
try:
|
||
if kind == "retry":
|
||
# A raw role read cannot replay writes or reconcile pending
|
||
# battle records. Engine.poll() can perform both side effects.
|
||
self._retry_probe = True
|
||
try:
|
||
self.engine.snapshot = self.engine.client.snapshot()
|
||
finally:
|
||
self._retry_probe = False
|
||
self._refresh_execution()
|
||
self.schedule.poll_finished(self.config)
|
||
self._invalidate_views()
|
||
return {"kind": kind}
|
||
if kind in FAST_KINDS:
|
||
if not self._set_auto(True):
|
||
return None
|
||
self.schedule.next_fast[kind] = math.inf
|
||
auto = True
|
||
value = self.engine.poll_automation(kind)
|
||
elif kind in ("poll", "reconcile"):
|
||
recovering = self._pending_battle_recovery().get("resumable") is True
|
||
with self.lock:
|
||
# Recover only the original entry, with general automation
|
||
# disabled. Stop/config changes still revoke this job.
|
||
auto = self._set_auto(self._running and kind == "poll" and not recovering)
|
||
resume_pending = bool(recovering and self._running and self.strategy_requested
|
||
and not self._closing and not self.manager._closing and job.generation == self._generation)
|
||
if resume_pending:
|
||
job.consuming = True
|
||
self.check_intent()
|
||
if callable(getattr(self.engine, "pending_battle_recovery", None)):
|
||
value = self.engine.poll(defer_hatch=True, resume_pending=resume_pending)
|
||
else:
|
||
# Older Engine doubles use auto to authorize saved results.
|
||
if resume_pending:
|
||
auto = self._set_auto(True)
|
||
value = self.engine.poll(defer_hatch=True)
|
||
self.schedule.poll_finished(self.config)
|
||
else:
|
||
self._set_auto(False)
|
||
method = {"heartbeat": self.engine.keep_alive, "master_sync": self.engine.sync_master,
|
||
"growth_sync": self.engine.sync_growth}[kind]
|
||
value = method()
|
||
if isinstance(value, tuple) and len(value) == 3:
|
||
self.result(*value)
|
||
with self.lock:
|
||
# Config replacement revokes the old intent with auto=False
|
||
# while preserving the user's running switch. Only a pause
|
||
# by the current Engine generation turns that switch off.
|
||
if auto and job.generation == self._generation and not self.engine.auto:
|
||
if self._pending_execution_reason():
|
||
# A pending barrier pauses execution, not user intent
|
||
# or the generation of other queued local edits.
|
||
self._refresh_execution()
|
||
else:
|
||
self._execution_failed(ValueError(value[2] or "策略暂不可用"))
|
||
elif auto and job.generation == self._generation:
|
||
self._execution_retry_attempt = 0
|
||
self._execution_error = ""
|
||
self.schedule.arm(self.engine, self.config, self._running, value[1], completed=kind)
|
||
elif isinstance(value, str):
|
||
self._log_message(value)
|
||
return {"kind": kind}
|
||
except Exception:
|
||
self.schedule.maintenance_failed(kind)
|
||
if kind == "poll":
|
||
self.schedule.poll_finished(self.config)
|
||
raise
|
||
|
||
def _password_login_flow(self):
|
||
flow = self.manager.login_factory(self.catalog, self.securestore.device(), trace=self.trace)
|
||
# Preserve the factory's existing constructor convention. The real
|
||
# SDK flow checks this optional guard at its own HTTP send boundary.
|
||
if isinstance(flow, PasswordLogin):
|
||
flow.cancel_guard = self.check_intent
|
||
return flow
|
||
|
||
def _auto_relogin(self):
|
||
client = None
|
||
self._auto_relogin_inflight = True
|
||
try:
|
||
self.check_intent()
|
||
identity = self._auto_relogin_target
|
||
if not identity or identity != self.active_identity:
|
||
raise AutoReloginBlocked("无法确认掉线前的原区服和角色,请手动登录确认")
|
||
try:
|
||
target = self.securestore.load(identity)
|
||
except (OSError, ValueError, KeyError):
|
||
raise AutoReloginBlocked("掉线前保存的角色会话不存在或无法读取,请手动登录确认") from None
|
||
if not target.account_id or not target.account_name or not target.server_id or not target.role_id:
|
||
raise AutoReloginBlocked("保存的会话缺少可确认的账号、原区服或角色,请手动登录确认")
|
||
saved, account, password = self.securestore.load_credentials()
|
||
self.remember({"password": password})
|
||
if not saved or not account or not password:
|
||
raise AutoReloginBlocked("未在服务器保存密码,无法自动重登;请手动登录并勾选记住密码")
|
||
if account.strip() != target.account_name.strip():
|
||
raise AutoReloginBlocked("保存密码的账号与掉线角色所属账号不匹配,请手动登录确认")
|
||
self.manager._claim_identity(self, identity)
|
||
self.check_intent()
|
||
self._session_write_error = ""
|
||
client, response, context = self._password_login_flow().authenticate(account, password)
|
||
self.check_intent()
|
||
# account_name is the input username; account_id is the SDK uid.
|
||
# Neither can substitute for the other when choosing the target.
|
||
if (client.session.account_name.strip() != target.account_name.strip()
|
||
or str(context.get("uid", "")) != target.account_id
|
||
or client.session.account_id != target.account_id
|
||
or client.session.channel != target.channel
|
||
or client.session.platform != target.platform
|
||
or context.get("channel") != target.channel):
|
||
raise ValueError("密码登录返回的账号与原角色会话不匹配,已拒绝进入区服")
|
||
servers = server_entries(response, target.platform)
|
||
server = next((row for row in servers if row["id"] == target.server_id), None)
|
||
if server is None:
|
||
raise ValueError("官方登录列表中没有掉线前的原区服,已拒绝切换其他区服")
|
||
roles = [row for row in response.get("masterInfos") or [] if isinstance(row, dict)
|
||
and str(row.get("serverId")) == str(target.server_id)]
|
||
if not roles or {str(row.get("id")) for row in roles} != {str(target.role_id)}:
|
||
raise ValueError("官方登录列表中无法确认原区服的原角色,已拒绝进入或创建其他角色")
|
||
self._bind_client(client)
|
||
self.check_intent()
|
||
client.enter_server(context["center_url"], server, context["uid"], self.catalog,
|
||
context["channel"], target.platform, context["device_id"])
|
||
self.check_intent()
|
||
if client.session.server_id != target.server_id or client.session.account_id != target.account_id:
|
||
raise ValueError("进入区服返回的账号或区服与掉线前不匹配,已停止自动重登")
|
||
# Client.snapshot must reject a different character before saving
|
||
# it; enter_server normally resets role_id to zero for manual use.
|
||
client.session.role_id = target.role_id
|
||
snapshot = client.snapshot()
|
||
self.check_intent()
|
||
if session_identity(client.session) != identity or int(snapshot.raw.get("master", {}).get("id") or 0) != target.role_id:
|
||
raise ValueError("进服后的角色与掉线前不匹配,已停止自动重登")
|
||
result = self._activate_client(client, snapshot, login_message="自动重登成功,已恢复原区服和原角色")
|
||
client = None # The worker now owns this client.
|
||
return result
|
||
except Exception as error:
|
||
with self.lock:
|
||
# One cancellation path handles both a guard exception and a
|
||
# revoked SDK call that eventually returns a transport error.
|
||
try:
|
||
self.check_intent()
|
||
if isinstance(error, CancelledBeforeDispatch):
|
||
raise error
|
||
except CancelledBeforeDispatch:
|
||
preference = (self._auto_relogin_pending_config[1] if self._auto_relogin_pending_config
|
||
else self.config["auto_relogin"])
|
||
if (not self._auto_relogin_suspended and preference["enabled"]
|
||
and self.schedule.disconnected_at is not None):
|
||
self.schedule.auto_relogin_failed()
|
||
self._auto_relogin_error = "自动重登已被新的操作取消"
|
||
raise
|
||
self.schedule.auto_relogin_failed()
|
||
self._auto_relogin_blocked = isinstance(error, AutoReloginBlocked)
|
||
self._auto_relogin_error = "自动重登未完成:" + self.safe_text(str(error))
|
||
self.log(self._auto_relogin_error, category="login", level="error")
|
||
return {"connected": False, "running": False, "message": self._auto_relogin_error}
|
||
finally:
|
||
self._auto_relogin_inflight = False
|
||
if client is not None:
|
||
client.close()
|
||
|
||
def _bind_client(self, client):
|
||
if not isinstance(client.session, Session):
|
||
raise ValueError("登录客户端未提供受支持的会话")
|
||
self.remember(asdict(client.session))
|
||
self._share_session_counters(client.session)
|
||
client.trace = self.trace
|
||
self._session_write_error = ""
|
||
|
||
def persist(current):
|
||
try:
|
||
self._share_session_counters(current)
|
||
self.securestore.save(current, self._session_label(current))
|
||
self._last_persisted_session = self._session_stamp(current)
|
||
self._session_write_error = ""
|
||
except Exception:
|
||
self._session_write_error = "会话请求序号无法持久保存,已阻止后续请求;请检查 Web 数据目录"
|
||
raise OSError(self._session_write_error) from None
|
||
|
||
client.on_session_change = persist
|
||
if getattr(client, "_ranch_web_owner", None) is not self and hasattr(client, "call"):
|
||
original = client.call
|
||
|
||
def guarded_call(*args, **kwargs):
|
||
self.check_intent()
|
||
path = args[0] if args else kwargs.get("path", "")
|
||
category = self._dispatch_category(path)
|
||
if category != "general":
|
||
self._attribute_task(category)
|
||
# This precedes Client.call's wire payload construction. A
|
||
# saved candidate can lag the still-online client's counters.
|
||
self._share_session_counters(client.session)
|
||
active = client is self.engine.client
|
||
if active:
|
||
self._require_game()
|
||
# A repaired directory may be retried. Client.persist_session
|
||
# sets this before Trace.begin blocks an unsafe dispatch.
|
||
self._session_write_error = ""
|
||
legacy = self._legacy_write(path, args[1] if len(args) > 1 else kwargs.get("payload")) if active else None
|
||
try:
|
||
response = original(*args, **kwargs)
|
||
except Exception as error:
|
||
if legacy is not None and (isinstance(error, CancelledBeforeDispatch)
|
||
or isinstance(error, ApiError) and error.code is not None):
|
||
# A decoded rejection did not apply the write; it needs
|
||
# bounded backoff and fresh planning, not uncertainty.
|
||
with self.lock:
|
||
self._legacy_pending.pop(legacy, None)
|
||
self._save_run_intents()
|
||
self._game_failed(error, client)
|
||
raise
|
||
if legacy is not None and path == "monsterService/monsterSendGift":
|
||
try:
|
||
feel, gifted_at = float(response["feel"]), seconds(response["giftDate"])
|
||
before = self._legacy_pending[legacy]["evidence"]["gift_time"]
|
||
confirmed = math.isfinite(feel) and feel >= 0 and math.isfinite(gifted_at) and gifted_at > before
|
||
except (KeyError, TypeError, ValueError):
|
||
confirmed = False
|
||
if confirmed:
|
||
# The same authoritative response used by GiftPlanner's
|
||
# cooldown is sufficient even if role reads lag behind.
|
||
with self.lock:
|
||
self._legacy_pending.pop(legacy, None)
|
||
self._save_run_intents()
|
||
path = args[0] if args else kwargs.get("path")
|
||
if active and path == "heartBeatService/keepAlive":
|
||
self._game_succeeded()
|
||
return response
|
||
|
||
client.call = guarded_call
|
||
client._ranch_web_owner = self
|
||
original_snapshot = client.snapshot
|
||
|
||
def guarded_snapshot(*args, **kwargs):
|
||
if client is self.engine.client:
|
||
self._require_game()
|
||
try:
|
||
snapshot = original_snapshot(*args, **kwargs)
|
||
except Exception as error:
|
||
self._game_failed(error, client)
|
||
raise
|
||
self._reconcile_legacy_write(snapshot, session_identity(client.session))
|
||
if client is self.engine.client:
|
||
self._game_succeeded()
|
||
return snapshot
|
||
|
||
client.snapshot = guarded_snapshot
|
||
http = getattr(client, "http", None)
|
||
if http is not None:
|
||
def guarded_transport(method):
|
||
def dispatch(*args, **kwargs):
|
||
# Client.call encodes before entering post; requests then
|
||
# prepares its request before entering send. Check at both
|
||
# boundaries without holding a lock across transport I/O.
|
||
self.check_intent(check_persistence=True)
|
||
return method(*args, **kwargs)
|
||
dispatch._ranch_web_owner = self
|
||
return dispatch
|
||
|
||
for name in ("post", "send"):
|
||
method = getattr(http, name, None)
|
||
if callable(method) and getattr(method, "_ranch_web_owner", None) is not self:
|
||
setattr(http, name, guarded_transport(method))
|
||
return client
|
||
|
||
def _share_session_counters(self, session):
|
||
client = self.engine.client
|
||
if client is None or client.session is session:
|
||
return
|
||
current = client.session
|
||
protocol = ("token", "key", "server_url", "account_id", "server_id", "role_id", "channel", "platform")
|
||
if all(getattr(session, field) == getattr(current, field) for field in protocol):
|
||
for field in ("reqid", "reqsid"):
|
||
high = max(getattr(session, field), getattr(current, field))
|
||
setattr(session, field, high)
|
||
setattr(current, field, high)
|
||
|
||
def _session_label(self, session):
|
||
role = ""
|
||
if self.engine.client is not None and self.engine.client.session is session and self.engine.snapshot:
|
||
role = self.engine.snapshot.raw.get("master", {}).get("roleName", "")
|
||
return " / ".join(str(part) for part in (self.label or session.account_name or "游戏账号", "区服 " + str(session.server_id), role) if part)
|
||
|
||
def _persist_session(self):
|
||
client = self.engine.client
|
||
if client is not None and self._session_stamp(client.session) != self._last_persisted_session:
|
||
self.securestore.save(client.session, self._session_label(client.session))
|
||
self._last_persisted_session = self._session_stamp(client.session)
|
||
|
||
@staticmethod
|
||
def _session_stamp(session):
|
||
return tuple(getattr(session, field) for field in Session.__dataclass_fields__)
|
||
|
||
def _activate_client(self, client, snapshot, *, login_message="登录成功"):
|
||
self.check_intent()
|
||
session = client.session
|
||
role_id = int(snapshot.raw.get("master", {}).get("id") or 0)
|
||
if not session.role_id or role_id != session.role_id:
|
||
raise ValueError("会话返回了其他角色,已停止;请重新登录并选择区服")
|
||
identity = session_identity(session)
|
||
previous_identity = self.active_identity
|
||
self.manager._claim_identity(self, identity)
|
||
old_client = self.engine.client
|
||
old_engine, old_config, old_revision, old_root, old_demo = self.engine, self.config, self.revision, self.state_root, self.demo
|
||
mode_saved = False
|
||
try:
|
||
state = self.manager.store.role_root(self.id, identity)
|
||
value, revision = self._load_config(state)
|
||
revision = max(self.revision, revision) + 1
|
||
engine = self._engine(client, state_root=state, config=value)
|
||
engine.snapshot = snapshot
|
||
self.manager.store.save_config(state, value, revision)
|
||
label = " / ".join(str(part) for part in (self.label or session.account_name or "游戏账号",
|
||
"区服 " + str(session.server_id), snapshot.raw["master"].get("roleName") or snapshot.raw["master"].get("masterName", "")) if part)
|
||
self.securestore.save(session, label)
|
||
self.securestore.set_active(identity)
|
||
self._refresh_login_metadata()
|
||
self.manager._set_demo(self, False)
|
||
mode_saved = True
|
||
with self.lock:
|
||
self.check_intent()
|
||
self.state_root = self.state = state
|
||
self.config, self.revision = value, revision
|
||
self.engine, self.active_identity, self.demo = engine, identity, False
|
||
self._running = False
|
||
self.schedule.monitor(True)
|
||
self.schedule.poll_finished(self.config)
|
||
self._game_succeeded(activated=True)
|
||
self._invalidate_views(clear=True)
|
||
# A verified connection never changes durable user intent or
|
||
# grants writes to this authentication/read-only operation.
|
||
self._refresh_execution()
|
||
message = login_message + ";" + self._strategy_status()["strategy_message"]
|
||
result = {"connected": True, "running": self._running,
|
||
"has_saved_password": self._has_saved_password, "message": message}
|
||
self.log(message, category="login")
|
||
except Exception:
|
||
with self.lock:
|
||
self.engine, self.active_identity, self.demo = old_engine, previous_identity, old_demo
|
||
self.state_root = self.state = old_root
|
||
self.config, self.revision = old_config, old_revision
|
||
self.catalog.overrides = deepcopy(old_config.get("overrides", {}))
|
||
try:
|
||
self.securestore.set_active(previous_identity)
|
||
if mode_saved:
|
||
self.manager._set_demo(self, old_demo)
|
||
except (OSError, ValueError):
|
||
self.log("登录未完成,原连接保留;保存的会话仍可手动恢复", category="login")
|
||
if identity != previous_identity:
|
||
self.manager._release_identity(self, identity)
|
||
raise
|
||
if previous_identity and previous_identity != identity:
|
||
self.manager._release_identity(self, previous_identity)
|
||
if old_client is not None and old_client is not client:
|
||
old_client.close()
|
||
return result
|
||
|
||
def _login(self, payload):
|
||
self.check_intent()
|
||
self._session_write_error = ""
|
||
account, password = payload.get("account", ""), payload.get("password", "")
|
||
remember = payload.get("remember", False)
|
||
if not isinstance(account, str) or not isinstance(password, str) or type(remember) is not bool:
|
||
raise ValueError("账号密码和记住密码选项格式错误")
|
||
saved, saved_account, saved_password = self.securestore.load_credentials()
|
||
if not password and saved and (not account.strip() or account.strip() == saved_account):
|
||
account, password = saved_account, saved_password
|
||
account = account.strip()
|
||
if not account or not password:
|
||
raise ValueError("请填写账号和密码")
|
||
self.remember({"password": password})
|
||
if self._login_pending is not None and self._login_pending[0] is not self.engine.client:
|
||
self._login_pending[0].close()
|
||
self._login_pending = None
|
||
with self.lock:
|
||
self._servers = []
|
||
self.schedule.monitor(False)
|
||
self.securestore.save_credentials(account, password, remember)
|
||
self._refresh_login_metadata()
|
||
flow = self._password_login_flow()
|
||
client, response, context = flow.authenticate(account, password)
|
||
try:
|
||
self.check_intent()
|
||
self._bind_client(client)
|
||
self.remember(response)
|
||
roles = {}
|
||
for row in response.get("masterInfos") or []:
|
||
if isinstance(row, dict) and row.get("serverId") is not None:
|
||
roles[str(row["serverId"])] = row
|
||
public = []
|
||
for row in server_entries(response):
|
||
role = roles.get(str(row["id"]), {})
|
||
public.append({"id": row["id"], "name": row["serverName"],
|
||
"role_name": role.get("masterName") or role.get("roleName") or row.get("masterName") or row.get("roleName") or "无已有角色"})
|
||
self._login_pending = (client, response, context)
|
||
with self.lock:
|
||
self.check_intent()
|
||
self._servers = self.public_json(public)
|
||
self._invalidate_views()
|
||
return {"servers": deepcopy(self._servers), "has_saved_password": self._has_saved_password}
|
||
except Exception:
|
||
client.close()
|
||
raise
|
||
|
||
def _enter_server(self, payload):
|
||
if self._login_pending is None:
|
||
raise ValueError("请先完成账号密码登录并获取区服列表")
|
||
identifier = payload.get("server_id")
|
||
if type(identifier) is not int and not (isinstance(identifier, str) and identifier.isascii() and identifier.isdigit()):
|
||
raise ValueError("请选择有效的区服编号")
|
||
client, response, context = self._login_pending
|
||
server = next((row for row in server_entries(response) if row["id"] == int(identifier)), None)
|
||
if server is None:
|
||
raise ValueError("所选区服不在本次官方登录返回的列表中")
|
||
self.check_intent()
|
||
try:
|
||
client.enter_server(context["center_url"], server, context["uid"], self.catalog,
|
||
context["channel"], "ANDROID", context["device_id"])
|
||
self.check_intent()
|
||
result = self._activate_client(client, client.snapshot())
|
||
self._login_pending = None
|
||
return result
|
||
except Exception:
|
||
client.close()
|
||
self._login_pending = None
|
||
raise
|
||
|
||
def _restore_session(self, payload):
|
||
session = self.securestore.load(payload.get("session_id"))
|
||
identity = session_identity(session)
|
||
self.manager._claim_identity(self, identity)
|
||
client = None
|
||
try:
|
||
client = self._bind_client(self._restore_factory(session, trace=self.trace))
|
||
self.check_intent()
|
||
return self._activate_client(client, client.snapshot())
|
||
except Exception:
|
||
if client is not None:
|
||
client.close()
|
||
if identity != self.active_identity:
|
||
self.manager._release_identity(self, identity)
|
||
raise
|
||
|
||
def _release_clients(self):
|
||
clients = [self.engine.client]
|
||
if self._login_pending is not None:
|
||
clients.append(self._login_pending[0])
|
||
self._login_pending = None
|
||
try:
|
||
self._persist_session()
|
||
finally:
|
||
seen = set()
|
||
for client in clients:
|
||
if client is not None and id(client) not in seen:
|
||
seen.add(id(client))
|
||
client.close()
|
||
|
||
def _logout(self, payload):
|
||
identity = self.active_identity
|
||
session = (self.engine.client.session if self.engine.client is not None else
|
||
self.securestore.load(identity) if identity else None)
|
||
self._release_clients()
|
||
self.engine = self._engine()
|
||
with self.lock:
|
||
self._servers = []
|
||
self.schedule.monitor(False)
|
||
self.schedule.game_failed()
|
||
if session is not None:
|
||
self._mark_disconnected(session, identity)
|
||
self.connection_state = "offline"
|
||
self.connection_message = "已退出当前游戏连接;会话、密码与策略运行意愿已保留,将按配置间隔重新登录"
|
||
self.next_retry_at = None
|
||
self.error = ""
|
||
self._refresh_login_metadata()
|
||
self._invalidate_views(clear=True)
|
||
return {"connected": False, "running": False}
|
||
|
||
def _forget_login(self, payload):
|
||
self._logout(payload)
|
||
self.securestore.forget()
|
||
self.manager._release_identity(self)
|
||
self.active_identity = None
|
||
self.state_root = self.state = self.manager.store.role_root(self.id, demo=self.demo)
|
||
config, revision = self._load_config(self.state_root)
|
||
self.config, self.revision = config, max(self.revision, revision) + 1
|
||
self.engine = self._engine()
|
||
self.connection_message = "已清空保存的登录,不再自动重登;请重新登录并选择区服"
|
||
self._refresh_login_metadata()
|
||
self._invalidate_views()
|
||
return {"connected": False, "running": False, "has_saved_password": False}
|
||
|
||
def _start(self, payload, *, require_selection=True):
|
||
self.check_intent()
|
||
self._set_strategy_requested(True)
|
||
if not self.demo:
|
||
self._require_game()
|
||
if self.engine.snapshot is None or not (self.demo or self.engine.client):
|
||
raise ValueError("请先登录并选择区服或打开离线演示")
|
||
value = validate_config(self.config)
|
||
policy = value["policy"]
|
||
other = any(value[section]["enabled"] for section in ("quest_policy", "daily_policy", "sweep_policy", "explore_policy", "progression_policy"))
|
||
other = other or bool(policy["breakthrough_targets"]) or policy["gift_enabled"]
|
||
ranch = policy["enabled"] and any(policy[field] for field in ("buy", "fill", "dispatch", "collect", "feed"))
|
||
if require_selection and not ranch and not other:
|
||
raise ValueError("请先勾选至少一项功能,并启用对应策略")
|
||
if require_selection and ranch and not other and not any(rule["enabled"] for rule in policy["egg_rules"].values()):
|
||
raise ValueError("请先在背包魔物蛋勾选要孵化的蛋,并设置优先级和孵出后的去向")
|
||
reason = self._pending_execution_reason()
|
||
if reason:
|
||
raise ValueError(reason)
|
||
with self.lock:
|
||
self.check_intent()
|
||
self._execution_retry_deadline = self._execution_retry_at = None
|
||
self._execution_retry_attempt = 0
|
||
self._execution_error = ""
|
||
self._refresh_execution()
|
||
self.engine.heartbeat_enabled = True
|
||
self.schedule.monitor(True)
|
||
self._invalidate_views()
|
||
return {"running": self._running, **self._strategy_status()}
|
||
|
||
def _stop(self, payload):
|
||
# submit('stop') already made cancellation effective synchronously.
|
||
return {"running": False}
|
||
|
||
def close(self, timeout=30):
|
||
with self.condition:
|
||
self.suspend_auto_relogin()
|
||
self.stop()
|
||
self._closing = True
|
||
for job in self._pending:
|
||
job.status, job.error, job.payload = "cancelled", "账号正在关闭,操作已取消", {}
|
||
self._pending.clear()
|
||
self._view_jobs.clear()
|
||
self.condition.notify_all()
|
||
if threading.current_thread() is not self.thread:
|
||
if not self._closed.wait(timeout):
|
||
raise RuntimeError("账号仍在等待已发送的请求结束;工作区保留,未删除任何文件")
|
||
|
||
|
||
class WebManager:
|
||
def __init__(self, root, *, start_scheduler=True, catalog=None, engine_factory=None, login_factory=None):
|
||
self.lock = threading.RLock()
|
||
self.catalog = catalog or Catalog()
|
||
self.engine_factory = engine_factory or Engine
|
||
self.login_factory = login_factory or PasswordLogin
|
||
self.store = WebStore(root)
|
||
self._workers = {}
|
||
self._identities = {}
|
||
self._records = []
|
||
self._closing = False
|
||
self.scheduler = None
|
||
try:
|
||
self._records = self.store.accounts()
|
||
for record in self._records:
|
||
self._workers[record["id"]] = AccountWorker(self, record)
|
||
if start_scheduler:
|
||
self.scheduler = Scheduler(self._worker_list)
|
||
except Exception:
|
||
self.close()
|
||
raise
|
||
|
||
def _worker_list(self):
|
||
with self.lock:
|
||
return list(self._workers.values())
|
||
|
||
def _worker(self, identifier):
|
||
with self.lock:
|
||
if not isinstance(identifier, str) or identifier not in self._workers:
|
||
raise KeyError("账号不存在")
|
||
return self._workers[identifier]
|
||
|
||
def _claim_identity(self, worker, identity):
|
||
with self.lock:
|
||
owner = self._identities.get(identity)
|
||
if owner is not None and owner != worker.id:
|
||
raise ValueError("该账号、区服和角色已在另一个页签连接,请切换到对应页签")
|
||
if self._closing:
|
||
raise CancelledBeforeDispatch()
|
||
self._identities[identity] = worker.id
|
||
|
||
def _release_identity(self, worker, identity=None):
|
||
with self.lock:
|
||
for current, owner in list(self._identities.items()):
|
||
if owner == worker.id and (identity is None or current == identity):
|
||
self._identities.pop(current, None)
|
||
|
||
def _set_demo(self, worker, demo):
|
||
with self.lock:
|
||
records = [dict(row, demo=bool(demo)) if row["id"] == worker.id else dict(row) for row in self._records]
|
||
self.store.save_accounts(records)
|
||
self._records = records
|
||
|
||
def list_accounts(self):
|
||
return [worker.status() for worker in self._worker_list()]
|
||
|
||
def create_account(self, label="", demo=True):
|
||
if not isinstance(label, str) or len(label) > 200 or type(demo) is not bool:
|
||
raise ValueError("账号名称或演示模式格式错误")
|
||
worker = None
|
||
try:
|
||
with self.lock:
|
||
if self._closing:
|
||
raise RuntimeError("Web 服务正在关闭")
|
||
if len(self._workers) >= 32:
|
||
raise ValueError("本工作台最多支持32个账号页签")
|
||
record = {"id": uuid.uuid4().hex, "label": label.strip() or "账号 " + str(len(self._records) + 1), "demo": demo}
|
||
worker = AccountWorker(self, record)
|
||
records = [*self._records, record]
|
||
self.store.save_accounts(records)
|
||
self._records = records
|
||
self._workers[record["id"]] = worker
|
||
return worker.status()
|
||
except Exception:
|
||
if worker is not None:
|
||
# Worker shutdown releases identity under manager.lock.
|
||
# Never join it while holding that same lock.
|
||
worker.close()
|
||
raise
|
||
|
||
def remove_account(self, identifier):
|
||
worker = self._worker(identifier)
|
||
worker.close()
|
||
# No deletion until the worker has persisted counters and released clients.
|
||
self.store.remove_profile(identifier)
|
||
with self.lock:
|
||
self._records = [row for row in self._records if row["id"] != identifier]
|
||
self.store.save_accounts(self._records)
|
||
self._workers.pop(identifier, None)
|
||
|
||
def status(self, identifier):
|
||
return self._worker(identifier).status()
|
||
|
||
def get_config(self, identifier):
|
||
worker = self._worker(identifier)
|
||
with worker.lock:
|
||
return {"config": deepcopy(worker.config), "revision": worker.revision}
|
||
|
||
def set_config(self, identifier, config, revision=None):
|
||
value = validate_config(config)
|
||
worker = self._worker(identifier)
|
||
if revision is not None and (type(revision) is not int or revision < 0):
|
||
raise ValueError("策略修订编号必须为非负整数")
|
||
with worker.condition:
|
||
if revision is not None and revision != worker.revision:
|
||
raise RevisionConflict("策略已在其他页面更新,请刷新后重试")
|
||
changed = any(value.get(section) != worker.config.get(section) for section in
|
||
("policy", "quest_policy", "daily_policy", "sweep_policy", "explore_policy", "progression_policy", "overrides", "auto_relogin"))
|
||
login_changed = value["auto_relogin"] != worker.config["auto_relogin"]
|
||
if changed:
|
||
worker.stop(keep_running=True)
|
||
job = worker.enqueue("__config", {"config": value, "revision": revision})
|
||
if login_changed:
|
||
worker._auto_relogin_pending_config = (job["id"], deepcopy(value["auto_relogin"]))
|
||
return {"config": deepcopy(worker.config), "revision": worker.revision,
|
||
"pending": True, "job_id": job["id"], "job": job}
|
||
|
||
def view(self, identifier, page, query=None):
|
||
return self._worker(identifier).view(page, query)
|
||
|
||
def submit(self, identifier, operation, payload=None):
|
||
if not isinstance(operation, str) or not re.fullmatch(r"[a-z][a-z_]{0,63}", operation):
|
||
raise ValueError("无效的操作名称")
|
||
if payload is not None and not isinstance(payload, dict):
|
||
raise ValueError("操作参数必须是对象")
|
||
worker = self._worker(identifier)
|
||
with worker.condition:
|
||
if operation == "stop":
|
||
worker.stop()
|
||
worker._set_strategy_requested(False)
|
||
# Stop is complete before returning; it never waits behind a model.
|
||
job = _Job(uuid.uuid4().hex, operation, {}, worker._generation, status="succeeded",
|
||
result={"running": False, **worker._strategy_status()})
|
||
worker._jobs[job.id] = job
|
||
return job.public()
|
||
if operation in STOP_ACTIONS or operation in {"login", "enter_server", "restore_session", "logout", "forget_login"}:
|
||
if operation == "forget_login":
|
||
worker.suspend_auto_relogin()
|
||
worker.stop()
|
||
consuming = operation not in READ_ACTIONS and operation not in LOCAL_ACTIONS and operation not in {"logout", "forget_login"}
|
||
return worker.enqueue(operation, payload, consuming=consuming)
|
||
|
||
def job(self, identifier, job_id):
|
||
return self._worker(identifier).job(job_id)
|
||
|
||
def logs(self, identifier, after=0, debug=False):
|
||
if type(after) is not int or after < 0:
|
||
raise ValueError("日志游标必须为非负整数")
|
||
worker = self._worker(identifier)
|
||
with worker.lock:
|
||
entries = [deepcopy(entry) for entry in worker._logs if entry["seq"] > after and (debug or not entry["debug"])]
|
||
for entry in entries:
|
||
entry["message"] = worker.safe_text(entry["message"])
|
||
entry["details_available"] = bool(debug and entry["id"] in worker._debug_entries)
|
||
return {"entries": entries, "next": worker._log_sequence}
|
||
|
||
def debug_entry(self, identifier, entry_id):
|
||
try:
|
||
numeric = int(entry_id)
|
||
except (ValueError, TypeError):
|
||
raise ValueError("无效的调试日志编号") from None
|
||
worker = self._worker(identifier)
|
||
with worker.lock:
|
||
if numeric not in worker._debug_entries:
|
||
raise KeyError("该条网络详情已过期,请在调试日志中选择仍可用的条目")
|
||
details = worker.trace.redact(deepcopy(worker._debug_entries[numeric][0]))
|
||
return {"id": numeric, "details": details}
|
||
|
||
log_detail = debug_entry
|
||
|
||
def close(self):
|
||
with self.lock:
|
||
self._closing = True
|
||
workers = list(self._workers.values())
|
||
if self.scheduler is not None:
|
||
self.scheduler.close()
|
||
# Cancel every account first, then await each; one slow account cannot
|
||
# postpone cancellation of another account's simulation.
|
||
for worker in workers:
|
||
worker.stop()
|
||
failures = []
|
||
for worker in workers:
|
||
try:
|
||
worker.close()
|
||
except RuntimeError as error:
|
||
failures.append(error)
|
||
if failures:
|
||
raise failures[0]
|
||
self.store.close()
|