"""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/; 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 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, 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 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._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) 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) return _method(*args, **kwargs) setattr(engine, name, routed) 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"(?]*)", "<本地路径>", 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)): self.log(text, category=category) 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()}) 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, 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 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() 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: self.stop() self.log(message, category=job.category, level="error") 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, 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) 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) 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.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_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 = "" 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, *, 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) # Activation and its new start authorization share the final # generation check/lock. Never queue a start that could outlive # a stop, logout or policy replacement during persistence. try: self._start({}, require_selection=False) except ValueError as error: message = login_message + ";策略保持停止:" + self.safe_text(str(error)) else: message = login_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): 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, *, require_selection=True): 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 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("请先在背包魔物蛋勾选要孵化的蛋,并设置优先级和孵出后的去向") if (self.engine._progression_pending() or self.engine.explore_planner.pending(self.engine.snapshot) or self.engine._breakthrough_pending): 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()