Files
myrzx_bot/ranch_web/service.py
T

1078 lines
51 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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()