1466 lines
74 KiB
Python
1466 lines
74 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
|
||
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
|
||
|
||
from .activity import ActivityLog, ActivityLogError
|
||
from .policies import apply_config, default_config, validate_config
|
||
from .scheduler import AccountSchedule, FAST_KINDS, Scheduler
|
||
from .store import WebStore, 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 = ""
|
||
|
||
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",
|
||
"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._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"]
|
||
return value, revision
|
||
|
||
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)
|
||
return engine
|
||
|
||
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):
|
||
entry = {"time": datetime.now(timezone.utc).isoformat(timespec="milliseconds"),
|
||
"message": self.safe_text(message), "debug": bool(debug), "level": "debug" if debug else "info"}
|
||
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",
|
||
"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",
|
||
"message": "运行日志无法持久保存,当前日志仅保留在内存;请检查 Web 数据目录"})
|
||
entry["id"] = entry["seq"] = self._log_sequence + 1
|
||
self._log_sequence = entry["seq"]
|
||
self._logs.append(entry)
|
||
return entry["id"]
|
||
|
||
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"]))
|
||
identifier = self.log(";".join(fields), debug=True)
|
||
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()})
|
||
|
||
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.log(self.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)
|
||
|
||
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
|
||
if previous != "online":
|
||
self.log("游戏连接已确认;策略保持停止")
|
||
|
||
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()
|
||
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.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:
|
||
self.stop()
|
||
self.log(message)
|
||
finally:
|
||
job.payload = {}
|
||
try:
|
||
self._persist_session()
|
||
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)
|
||
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)
|
||
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)
|
||
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)
|
||
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.
|
||
self.engine.auto = bool(self._running and not self._closing and self._execution
|
||
and self._execution.generation == self._generation)
|
||
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):
|
||
kind = self.schedule.due(self.engine, self.config, self._running)
|
||
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
|
||
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.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 == "poll":
|
||
auto = self._set_auto(self._running)
|
||
value = self.engine.poll(defer_hatch=True)
|
||
self.schedule.poll_finished(self.config)
|
||
elif kind == "reconcile":
|
||
self._set_auto(False)
|
||
# Engine's durable pending barriers reconcile before planning.
|
||
# A check never silently replays an uncertain write.
|
||
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:
|
||
self.stop()
|
||
self.schedule.arm(self.engine, self.config, self._running, value[1], completed=kind)
|
||
elif isinstance(value, str):
|
||
self.log(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)
|
||
client = None # The worker now owns this client.
|
||
self.log("自动重登成功,已恢复原区服和原角色的监控;策略保持停止")
|
||
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)
|
||
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()
|
||
# 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 = ""
|
||
try:
|
||
response = original(*args, **kwargs)
|
||
except Exception as error:
|
||
self._game_failed(error, client)
|
||
raise
|
||
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
|
||
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):
|
||
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)
|
||
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("登录未完成,原连接保留;保存的会话仍可手动恢复")
|
||
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 {"connected": True, "running": False, "has_saved_password": self._has_saved_password}
|
||
|
||
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):
|
||
self._release_clients()
|
||
self.manager._release_identity(self)
|
||
self.active_identity = None
|
||
self.securestore.set_active(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()
|
||
with self.lock:
|
||
self._servers = []
|
||
self.schedule.monitor(False)
|
||
self.schedule.game_failed()
|
||
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._refresh_login_metadata()
|
||
self._invalidate_views()
|
||
return {"connected": False, "running": False, "has_saved_password": False}
|
||
|
||
def _start(self, payload):
|
||
self.check_intent()
|
||
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 not ranch and not other:
|
||
raise ValueError("请先勾选至少一项功能,并启用对应策略")
|
||
if ranch and not other and not any(rule["enabled"] for rule in policy["egg_rules"].values()):
|
||
raise ValueError("请先在背包魔物蛋勾选要孵化的蛋,并设置优先级和孵出后的去向")
|
||
with self.lock:
|
||
self.check_intent()
|
||
self._running = self.engine.auto = True
|
||
self.engine.heartbeat_enabled = True
|
||
self.schedule.monitor(True)
|
||
self._invalidate_views()
|
||
return {"running": True}
|
||
|
||
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()
|
||
# 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._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 in {"login", "enter_server", "restore_session", "logout", "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()
|