1078 lines
51 KiB
Python
1078 lines
51 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, timezone
|
||
import json
|
||
import math
|
||
import re
|
||
import threading
|
||
import uuid
|
||
|
||
from ranch_assistant.api import Client, Session, 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 .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."""
|
||
|
||
|
||
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._logs = deque(maxlen=2000)
|
||
self._debug_entries = OrderedDict()
|
||
self._debug_bytes = 0
|
||
self._log_sequence = 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.schedule = AccountSchedule()
|
||
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()
|
||
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)
|
||
return (validate_config(record["config"]), record["revision"]) if record else (default_config(), 0)
|
||
|
||
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:
|
||
self._log_sequence += 1
|
||
entry["id"] = entry["seq"] = self._log_sequence
|
||
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": bool(self.engine.client and snapshot),
|
||
"demo": self.demo, "running": self._running, "busy": False, "player": player,
|
||
"revision": self.revision, "error": self.error})
|
||
|
||
def status(self):
|
||
with self.lock:
|
||
result = deepcopy(self._summary)
|
||
result.update(running=self._running, busy=bool(self._active or self._pending))
|
||
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 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
|
||
try:
|
||
result = self._execute(job)
|
||
public_result = self.public_json(result)
|
||
with self.lock:
|
||
self.error = ""
|
||
except CancelledBeforeDispatch:
|
||
final_status, final_error = "cancelled", "未发送的操作已取消;已发请求保留核对记录"
|
||
except Exception as error:
|
||
message = self.safe_text(str(error)) or type(error).__name__
|
||
final_status, final_error = "failed", message
|
||
with self.lock:
|
||
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:
|
||
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.
|
||
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()
|
||
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("账号角色已切换,原角色的操作未执行;请刷新后重试")
|
||
if not self.demo and not self.engine.client and operation not in LOCAL_ACTIONS:
|
||
raise ValueError("尚未连接游戏角色,请先登录并选择区服或恢复会话")
|
||
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("策略已在其他页面更新,请刷新后重试")
|
||
value = validate_config(self.config if config is None else config)
|
||
new_revision = self.revision + 1
|
||
self.manager.store.save_config(self.state_root, value, 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):
|
||
if not self.demo and self.engine.client is None:
|
||
return None
|
||
kind = self.schedule.due(self.engine, self.config, self._running)
|
||
if kind is None:
|
||
return None
|
||
auto = False
|
||
try:
|
||
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 _bind_client(self, client):
|
||
if not isinstance(client.session, Session):
|
||
raise ValueError("登录客户端未提供受支持的会话")
|
||
self.remember(asdict(client.session))
|
||
client.trace = self.trace
|
||
self._session_write_error = ""
|
||
|
||
def persist(current):
|
||
try:
|
||
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()
|
||
# A repaired directory may be retried. Client.persist_session
|
||
# sets this before Trace.begin blocks an unsafe dispatch.
|
||
self._session_write_error = ""
|
||
return original(*args, **kwargs)
|
||
|
||
client.call = guarded_call
|
||
client._ranch_web_owner = self
|
||
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 _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._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.manager.login_factory(self.catalog, self.securestore.device(), trace=self.trace)
|
||
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._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 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):
|
||
self.stop()
|
||
with self.condition:
|
||
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"))
|
||
if changed:
|
||
worker.stop(keep_running=True)
|
||
job = worker.enqueue("__config", {"config": value, "revision": revision})
|
||
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"}:
|
||
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()
|