From 654567caa32cbdae500ccccb9995545705d5a66b Mon Sep 17 00:00:00 2001 From: AttilaNet Date: Wed, 11 Nov 2026 11:05:49 +0800 Subject: [PATCH] fix: preserve background connection state and durable disconnect logs --- analysis/WEB_CONNECTION_FIX.md | 24 + ranch_assistant/api.py | 24 +- ranch_assistant/engine.py | 2 +- ranch_web/README.md | 10 + ranch_web/activity.py | 242 ++++++++++ ranch_web/app.py | 4 +- ranch_web/scheduler.py | 20 + ranch_web/service.py | 204 +++++++- ranch_web/static/app.js | 129 ++++- .../tests/browser/test_connection_browser.py | 249 ++++++++++ .../tests/browser/test_workbench_browser.py | 9 +- ranch_web/tests/test_activity.py | 301 ++++++++++++ ranch_web/tests/test_api.py | 10 + ranch_web/tests/test_connection_state.py | 442 ++++++++++++++++++ 14 files changed, 1622 insertions(+), 48 deletions(-) create mode 100644 analysis/WEB_CONNECTION_FIX.md create mode 100644 ranch_web/activity.py create mode 100644 ranch_web/tests/browser/test_connection_browser.py create mode 100644 ranch_web/tests/test_activity.py create mode 100644 ranch_web/tests/test_connection_state.py diff --git a/analysis/WEB_CONNECTION_FIX.md b/analysis/WEB_CONNECTION_FIX.md new file mode 100644 index 0000000..98880c4 --- /dev/null +++ b/analysis/WEB_CONNECTION_FIX.md @@ -0,0 +1,24 @@ +# Web 后台监控与断线状态修复 + +版本:`2.0.0.dev1`,保留原有工作台布局。 + +## 问题与证据 + +后台账号队列和调度线程独立于浏览器。关闭页面、管理登录退出或过期,不会调用游戏账号退出或停止服务端策略。离线测试直接启动调度器,在没有任何浏览器请求时验证了心跳和状态读取。 + +原实现存在两处可复现问题:每个成功的本地任务都会清除账号错误,包括空闲 tick 和缓存视图;连接状态仅根据客户端对象和旧快照是否存在判断,无法反映游戏会话失效。只读生产诊断中,所检查的两个账号最近保留的请求均成功,没有证据证明本次用户反馈必然由 token 过期引起。服务重启后不会自动连接游戏,这一既有行为也需要明确解释。 + +## 修复行为 + +- 状态区分在线、临时故障重试、会话失效、未连接,公开最后成功通信时间和下一次重试时间。页面轮询不构成游戏通信成功,旧数据明确标注为缓存。 +- 游戏 `408` 明确暂停游戏请求并停止策略,保留加密会话和未决操作记录,等待用户恢复有效会话或重新登录。 +- 网络故障、HTTP `408/429/5xx` 和游戏 `997` 使用上限 60 秒的退避,依次等待 5、10、20、40、60 秒。恢复探测只读取角色,不重放操作;恢复后策略保持停止。 +- 普通业务拒绝停止本轮策略,但不误判为会话失效。恢复会话的候选客户端失败时,不破坏原连接;同协议请求序号保持高水位,不复用已发送序号。 +- 普通运行日志按账号限量持久化,调试详情维持原有缓存限制。日志编号包括调试事件并在重启后保持递增。日志存储失败保留内存提示,不改变已经发出的游戏请求结论。 +- 服务重启、主动退出游戏后明确说明需要手动恢复。恢复会话、导入配置和重启均不会自动开启策略。 + +## 验证范围 + +离线验证使用临时工作区、假游戏传输和本地浏览器服务,覆盖真实账号队列及调度代码。生产验收仅进行管理登录、只读工作台访问和健康检查,不代用户登录游戏或执行策略。 + +本次完成 Web 后端 245 项回归:244 通过,1 项因 Windows 符号链接权限跳过,无失败;浏览器 31 项全部通过。独立审核的四组故障重放均通过,涵盖同协议请求计数不回退、无客户端时不承诺虚假的自动重试、存储恢复后的日志编号以及日志故障不影响游戏请求原始结论。 diff --git a/ranch_assistant/api.py b/ranch_assistant/api.py index 4c2d11d..663729a 100644 --- a/ranch_assistant/api.py +++ b/ranch_assistant/api.py @@ -38,7 +38,17 @@ def decode(raw, key): class ApiError(RuntimeError): - pass + def __init__(self, message, *, code=None): + super().__init__(message) + self.code = code + + +class SessionExpiredError(ApiError): + """The game explicitly rejected its saved session (resCode 408).""" + + +class TemporaryApiError(ApiError): + """Transport/server failure with an unknown outcome; never replay writes.""" def server_id(server): @@ -177,20 +187,22 @@ class Client: headers=dict(result.headers), elapsed_ms=round((time.monotonic() - started) * 1000), body_preview=result.content[:4000].decode("utf-8", errors="replace"), bytes_received=len(result.content), decoded=False) if result.status_code != 200: - raise ApiError(f"HTTP {result.status_code},响应无法解码,请查看调试窗口") + error_type = TemporaryApiError if result.status_code in (408, 429) or result.status_code >= 500 else ApiError + raise error_type(f"HTTP {result.status_code},响应无法解码,请查看调试窗口") raise if self.trace: self.trace.emit("response", operation, request_id=identifier, url=url, http_status=result.status_code, headers=dict(result.headers), elapsed_ms=round((time.monotonic() - started) * 1000), body=response, decoded=True) if result.status_code != 200: - raise ApiError(f"HTTP {result.status_code},请求已停止") + error_type = TemporaryApiError if result.status_code in (408, 429) or result.status_code >= 500 else ApiError + raise error_type(f"HTTP {result.status_code},请求已停止") if not isinstance(response, dict): raise ApiError("游戏接口响应不是 JSON 对象,请查看调试窗口") code = response.get("resCode") if code not in (0, "0"): if str(code) == "408": - raise ApiError("会话已失效,请重新登录或导入有效会话") - raise ApiError(f"游戏接口返回 {code},已停止本轮操作") + raise SessionExpiredError("会话已失效,请手动恢复会话或重新登录", code=408) + raise ApiError(f"游戏接口返回 {code},已停止本轮操作", code=code) except ApiError as error: if self.trace: self.trace.emit("error", operation, request_id=identifier, url=url, message=str(error)) @@ -198,7 +210,7 @@ class Client: except requests.RequestException as error: if self.trace: self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error)) - raise ApiError("网络请求未确认完成;已停止执行,请刷新状态后再启动") from error + raise TemporaryApiError("网络请求未确认完成;已停止执行,请刷新状态后再启动") from error except (ValueError, TypeError) as error: if self.trace: self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error)) diff --git a/ranch_assistant/engine.py b/ranch_assistant/engine.py index 0f7631b..83683ff 100644 --- a/ranch_assistant/engine.py +++ b/ranch_assistant/engine.py @@ -990,8 +990,8 @@ class Engine: def keep_alive(self): if self.demo: return "离线演示无需心跳" - self.last_heartbeat = time.monotonic() self.client.call("heartBeatService/keepAlive") + self.last_heartbeat = time.monotonic() return "会话心跳已更新" @single_flight diff --git a/ranch_web/README.md b/ranch_web/README.md index 02f90d2..1ace661 100644 --- a/ranch_web/README.md +++ b/ranch_web/README.md @@ -32,6 +32,14 @@ py -3 -m venv .venv-web 健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。重启、恢复会话或导入策略后仍需手动开启运行。 +### 后台运行与断线处理 + +关闭网页或退出 Web 管理登录不会停止服务器上的账号监控和已开启策略。账号监控和策略执行由服务端管理;“停止”策略后仍保留状态监控,退出游戏账号或停止服务后结束监控。 + +账号状态区分游戏在线、临时故障重试、游戏登录过期和未连接,显示最后成功通信时间及具体原因。临时网络故障采用退避后的只读状态检查;无法确认的操作保留核对记录,不自动重复提交。游戏会话失效后停止策略和游戏轮询,需在登录页重新登录或恢复有效会话;成功恢复后仍需手动开启策略。 + +服务重启会保留配置与加密会话,但不会自动连接游戏或恢复策略。登录页与运行日志会提示需要恢复会话。普通运行日志在各账号目录中限量持久保存,服务重启后仍可查看;调试请求详情仅在当前进程中按原有上限缓存。页面展示旧角色数据时会标注缓存状态,不把页面刷新视作游戏连接成功。 + ## Linux Python 与环境变量 ```sh @@ -69,6 +77,8 @@ Web 检查固定官方 GitHub Releases 的稳定 `v2.x.y`,跳过桌面 1.x、 ## 离线验证 +本次后台连接与日志修复:Web 后端 **245 项中 244 通过、1 项因 Windows 符号链接权限跳过**,浏览器 **31 项全部通过**;独立故障重放四组通过。行为与证据边界见 [连接修复说明](../analysis/WEB_CONNECTION_FIX.md)。现有后端命令追加 `ranch_web.tests.test_base_path ranch_web.tests.test_activity ranch_web.tests.test_connection_state`,浏览器命令追加 `ranch_web.tests.browser.test_base_path_browser ranch_web.tests.browser.test_connection_browser.ConnectionBrowserTests` 可覆盖本次回归。 + 独立管理登录页调整后的完整非浏览器后端验证为 **193项:192通过、1跳过(Windows符号链接权限),0失败/错误,用时26.994秒**。以下命令显式列出全部10个后端模块,避免发现并混入浏览器测试: ```console diff --git a/ranch_web/activity.py b/ranch_web/activity.py new file mode 100644 index 0000000..f95b67c --- /dev/null +++ b/ranch_web/activity.py @@ -0,0 +1,242 @@ +"""Bounded account-local activity persistence; standard library only. + +Use one ActivityLog per profile_root (one writer, thread safe):: + + activity = ActivityLog(profile_root / "activity.json") + logs.extend(activity.load()) + cursor = activity.sequence + entry = activity.append({"message": safe_text(message), "debug": False}) + +Only allowlisted short fields are retained. The caller MUST apply safe_text to +messages before append; this module cannot know account-specific secret values. +Debug messages are never persisted. A tiny .seq sidecar reserves sequence blocks +BEFORE publishing any entry, including debug. Restart skips unused reservations, +so ids strictly increase across restarts but can have gaps. Both load() and +sequence are idempotent reads; no timer, idle writes, flush or close is needed. +Storage failures raise ActivityLogError with a path-free message. +""" +from __future__ import annotations + +from collections import deque +from collections.abc import Mapping +from datetime import datetime, timezone +import json +import os +from pathlib import Path +import tempfile +import threading + + +MAX_ENTRIES = 2000 +MAX_MESSAGE_CHARS = 2048 +MAX_BYTES = 2 * 1024 * 1024 +_MAX_SEQUENCE = (1 << 53) - 1 # Browser cursors must remain exact integers. +_LEVELS = frozenset({"debug", "info", "warning", "error", "critical"}) + + +class ActivityLogError(RuntimeError): + """Persistence failed; public error text contains no filesystem paths.""" + + +def _encode(value): + return json.dumps(value, ensure_ascii=False, allow_nan=False, + separators=(",", ":")).encode("utf-8") + + +def _sequence(value): + return value if type(value) is int and 0 <= value <= _MAX_SEQUENCE else 0 + + +class ActivityLog: + """Atomic snapshots capped by both count and serialized bytes. + + Construction does no IO. load() lazily restores nondebug entries and the + reserved high-water mark; append() and sequence also load on first use. + append() returns a NEW canonical dict with id == seq; caller ids are ignored. + load() returns independent copies of nondebug entries, oldest first. + + Default file cap is 1 MiB, hard cap 2 MiB, each message <= 2048 characters. + The .seq file is < 64 bytes and rewritten at most once per 256 appends in a + running instance. Only real nondebug appends rewrite the bounded snapshot. + """ + + def __init__(self, path, max_entries=MAX_ENTRIES, *, + max_bytes=1024 * 1024, sequence_block_size=256): + if type(max_entries) is not int or not 1 <= max_entries <= MAX_ENTRIES: + raise ValueError("max_entries must be between 1 and 2000") + if type(max_bytes) is not int or not 16384 <= max_bytes <= MAX_BYTES: + raise ValueError("max_bytes must be between 16384 and 2097152") + if type(sequence_block_size) is not int or not 1 <= sequence_block_size <= 65536: + raise ValueError("sequence_block_size must be between 1 and 65536") + self._path = Path(path) + self._sequence_path = self._path.with_name(self._path.name + ".seq") + self._max_entries = max_entries + self._max_bytes = max_bytes + self._block_size = sequence_block_size + self._lock = threading.RLock() + self._loaded = False + self._sequence = self._reserved = 0 + self._entries = deque() # (canonical dict, cached serialized bytes) + + @property + def sequence(self): + """Last emitted seq, or the restored reservation ceiling after restart.""" + with self._lock: + self._load() + return self._sequence + + def load(self): + """Restore once, without modifying either file; return nondebug copies.""" + with self._lock: + self._load() + return [dict(entry) for entry, _ in self._entries] + + def append(self, entry, *, after_sequence=0): + """Append caller-sanitized fields and return {time,message,debug,level,id,seq}. + + No seq is returned until its high-water mark is durable. If writing + fails the event is not published and the in-memory cursor is unchanged. + Unknown fields (tokens, headers, request bodies, paths, etc.) are dropped. + after_sequence includes ids published by the caller during memory-only + fallback; reserve above that cursor before publishing a recovered event. + """ + if not isinstance(entry, Mapping) or not isinstance(entry.get("message"), str): + raise ValueError("Activity entry requires a sanitized string message") + if "debug" in entry and type(entry["debug"]) is not bool: + raise ValueError("Activity debug flag must be a boolean") + if type(after_sequence) is not int or not 0 <= after_sequence <= _MAX_SEQUENCE: + raise ValueError("Activity cursor must be a nonnegative safe integer") + clean = self._clean(entry) + with self._lock: + self._load() + next_sequence = max(self._sequence, after_sequence) + 1 + if next_sequence > _MAX_SEQUENCE: + raise ActivityLogError("Activity sequence exhausted") + if next_sequence > self._reserved: + reserved = min(_MAX_SEQUENCE, next_sequence + self._block_size - 1) + self._write(self._sequence_path, _encode({"schema": 1, "sequence": reserved})) + self._reserved = reserved + clean["id"] = clean["seq"] = next_sequence + if not clean["debug"]: + entries = deque(self._entries) + entries.append((clean, _encode(clean))) + self._trim(entries, self._reserved) + self._write(self._path, self._snapshot(entries, self._reserved)) + self._entries = entries + self._sequence = next_sequence + return dict(clean) + + def log(self, message, *, debug=False): + """Convenience helper for an already safe_text-sanitized message; int id.""" + return self.append({"message": message, "debug": debug})["id"] + + @staticmethod + def _clean(entry): + level = entry.get("level", "info") + level = level.lower() if isinstance(level, str) else "info" + level = {"trace": "debug", "warn": "warning"}.get(level, level) + debug = entry.get("debug", False) is True or level == "debug" + level = "debug" if debug else level if level in _LEVELS else "info" + stamp = entry.get("time") + try: + if not isinstance(stamp, str) or len(stamp) > 64: + raise ValueError + datetime.fromisoformat(stamp) + except ValueError: + stamp = datetime.now(timezone.utc).isoformat(timespec="milliseconds") + message = entry["message"][:MAX_MESSAGE_CHARS].replace("\r", " ").replace("\n", " ") + message = message.encode("utf-8", errors="replace").decode("utf-8") + return {"time": stamp, "message": message, "debug": debug, "level": level} + + def _load(self): + if self._loaded: + return + record = self._read(self._path, MAX_BYTES) + watermark = self._read(self._sequence_path, 1024) + high = _sequence(watermark.get("sequence")) if watermark.get("schema") == 1 else 0 + entries = {} + if record.get("schema") == 1: + high = max(high, _sequence(record.get("sequence"))) + rows = record.get("entries", []) + if isinstance(rows, list): + for row in rows: + if not isinstance(row, dict): + continue + seq = _sequence(row.get("seq")) + high = max(high, seq) + if not seq or not isinstance(row.get("message"), str): + continue + if "debug" in row and type(row["debug"]) is not bool: + continue + clean = self._clean(row) + if clean["debug"]: + continue + clean["id"] = clean["seq"] = seq + entries[seq] = (clean, _encode(clean)) + self._entries = deque(entries[seq] for seq in sorted(entries)[-self._max_entries:]) + self._trim(self._entries, high) + self._sequence = self._reserved = high + self._loaded = True + + @staticmethod + def _prefix(sequence): + return b'{"schema":1,"sequence":' + str(sequence).encode("ascii") + b',"entries":[' + + def _trim(self, entries, sequence): + size = len(self._prefix(sequence)) + 2 + sum(len(raw) for _, raw in entries) + max(0, len(entries) - 1) + while entries and (len(entries) > self._max_entries or size > self._max_bytes): + _, raw = entries.popleft() + size -= len(raw) + (1 if entries else 0) + + def _snapshot(self, entries, sequence): + return self._prefix(sequence) + b",".join(raw for _, raw in entries) + b"]}" + + @staticmethod + def _check_path(path): + for candidate in (path, *path.parents): + if candidate.is_symlink() or getattr(candidate, "is_junction", lambda: False)(): + raise ActivityLogError("Activity storage must not use linked paths") + + def _read(self, path, limit): + try: + self._check_path(path) + with path.open("rb") as stream: + data = stream.read(limit + 1) + if len(data) > limit: + return {} + value = json.loads(data) + return value if isinstance(value, dict) else {} + except FileNotFoundError: + return {} + except (ValueError, UnicodeError, RecursionError): + return {} + except OSError: + raise ActivityLogError("Unable to read activity storage") from None + + def _write(self, path, data): + temporary = None + try: + self._check_path(path) + path.parent.mkdir(parents=True, exist_ok=True) + descriptor, name = tempfile.mkstemp(prefix=".activity-", suffix=".tmp", dir=path.parent) + temporary = Path(name) + with os.fdopen(descriptor, "wb") as stream: + os.chmod(temporary, 0o600) + stream.write(data) + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, path) + if os.name != "nt": + directory = os.open(path.parent, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0)) + try: + os.fsync(directory) + finally: + os.close(directory) + except OSError: + raise ActivityLogError("Unable to save activity storage") from None + finally: + if temporary is not None: + try: + temporary.unlink(missing_ok=True) + except OSError: + pass diff --git a/ranch_web/app.py b/ranch_web/app.py index 891a4f5..e017656 100644 --- a/ranch_web/app.py +++ b/ranch_web/app.py @@ -576,8 +576,10 @@ def create_app(data_dir=None, manager=None, config=None, updates=None) -> FastAP def public_summary(value): if not isinstance(value, dict): raise HTTPException(500, "账号状态返回格式不正确") - result = {field: value.get(field) for field in ("id", "label", "connected", "demo", "running", "busy", "revision", "error")} + result = {field: value.get(field) for field in ("id", "label", "connected", "demo", "running", "busy", "revision", "error", + "connection_state", "connection_message", "last_game_success_at", "next_retry_at")} result["error"] = public_error(result["error"]) + result["connection_message"] = public_error(result["connection_message"]) player = value.get("player") result["player"] = {field: player.get(field) for field in ("name", "level", "exp", "next_exp", "money", "ke", "ti")} if isinstance(player, dict) else None return public(result) diff --git a/ranch_web/scheduler.py b/ranch_web/scheduler.py index bbb8e74..0c0933b 100644 --- a/ranch_web/scheduler.py +++ b/ranch_web/scheduler.py @@ -19,6 +19,24 @@ class AccountSchedule: self.next_fast = {kind: math.inf for kind in FAST_KINDS} self.monitoring = False self.last_maintenance_error = {} + self.game_paused = False + self.retry_deadline = None + self.retry_attempt = 0 + + def game_failed(self, *, retry=False): + self.game_paused = True + self.stop() + self.retry_deadline = None + if retry: + self.retry_attempt += 1 + delay = min(5 * 2 ** min(self.retry_attempt - 1, 4), 60) + self.retry_deadline = self.clock() + delay + return delay + + def game_resumed(self): + self.game_paused = False + self.retry_deadline = None + self.retry_attempt = 0 def monitor(self, enabled=True): self.monitoring = bool(enabled) @@ -69,6 +87,8 @@ class AccountSchedule: def due(self, engine, config, running): now = self.clock() + if self.game_paused: + return "retry" if self.retry_deadline is not None and now >= self.retry_deadline else None def allowed(kind): return now - self.last_maintenance_error.get(kind, -math.inf) >= 30 diff --git a/ranch_web/service.py b/ranch_web/service.py index 78ef7b6..e0e83da 100644 --- a/ranch_web/service.py +++ b/ranch_web/service.py @@ -35,20 +35,23 @@ from __future__ import annotations from collections import OrderedDict, deque from copy import copy, deepcopy from dataclasses import asdict, dataclass -from datetime import datetime, timezone +from datetime import datetime, timedelta, timezone import json import math import re import threading import uuid -from ranch_assistant.api import Client, Session, server_entries +import requests + +from ranch_assistant.api import ApiError, Client, Session, SessionExpiredError, TemporaryApiError, server_entries from ranch_assistant.battles import CancelledBeforeDispatch from ranch_assistant.debug import TraceLog, sensitive from ranch_assistant.engine import Engine from ranch_assistant.login import PasswordLogin from ranch_assistant.model import Catalog +from .activity import ActivityLog, ActivityLogError from .policies import apply_config, default_config, validate_config from .scheduler import AccountSchedule, FAST_KINDS, Scheduler from .store import WebStore, session_identity @@ -143,10 +146,19 @@ class AccountWorker: self._secrets = set() self._pending = deque() self._jobs = OrderedDict() - self._logs = deque(maxlen=2000) + self._activity = ActivityLog(self.profile_root / "activity.json", max_entries=2000) + self._activity_warning = False + try: + self._logs = deque(self._activity.load(), maxlen=2000) + self._log_sequence = self._activity.sequence + except ActivityLogError: + self._activity_warning = True + self._log_sequence = 1 + self._logs = deque([{"id": 1, "seq": 1, "debug": False, "level": "warning", + "time": datetime.now(timezone.utc).isoformat(timespec="milliseconds"), + "message": "首次读取运行日志失败,当前日志暂存内存;后续日志将重试保存"}], maxlen=2000) self._debug_entries = OrderedDict() self._debug_bytes = 0 - self._log_sequence = 0 self._views = OrderedDict() self._view_jobs = {} self._view_epoch = 0 @@ -166,12 +178,21 @@ class AccountWorker: 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.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) @@ -240,8 +261,27 @@ class AccountWorker: 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 + try: + if self._activity_warning: + # Confirm an actual durable write before declaring recovery; + # debug appends within a reserved block alone need no IO. + recovered = self._activity.append({"time": entry["time"], "debug": False, "level": "info", + "message": "运行日志持久化已恢复;降级期间的日志仅保留在内存"}, after_sequence=self._log_sequence) + self._logs.append(recovered) + self._log_sequence = recovered["seq"] + self._activity_warning = False + entry = self._activity.append(entry, after_sequence=self._log_sequence) + except ActivityLogError: + # Keep retrying the same writer on later events. Logging must + # never replace a dispatched game's result or original error. + if not self._activity_warning: + self._activity_warning = True + self._log_sequence += 1 + self._logs.append({"id": self._log_sequence, "seq": self._log_sequence, + "time": entry["time"], "debug": False, "level": "warning", + "message": "运行日志无法持久保存,当前日志仅保留在内存;请检查 Web 数据目录"}) + entry["id"] = entry["seq"] = self._log_sequence + 1 + self._log_sequence = entry["seq"] self._logs.append(entry) return entry["id"] @@ -275,9 +315,73 @@ class AccountWorker: 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), + 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}) + "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}) + + def _require_game(self): + if self.connection_state != "online" and not (self._retry_probe and self.connection_state == "retrying"): + raise ValueError(self.connection_message) + + def _game_failed(self, error, client): + # Candidate login/restore clients may fail while the previous role is + # still healthy. Only that client's verified activation replaces it. + if client is not self.engine.client or isinstance(error, CancelledBeforeDispatch): + return + if self._last_game_error is error: + return + cause = error.__cause__ + code = str(error.code) if isinstance(error, ApiError) and error.code is not None else None + temporary = (isinstance(error, (TemporaryApiError, requests.RequestException)) + or isinstance(cause, requests.RequestException) or code == "997") + expired = isinstance(error, SessionExpiredError) or code == "408" + if not (temporary or isinstance(error, ApiError)): + return + self._last_game_error = error + self._game_failure_sequence += 1 + self.stop() + if code is not None and not (temporary or expired): + # A decoded business rejection proves neither disconnection nor + # expiry. Keep monitoring, but never retry its rejected write. + self.error = self._last_game_error_message = self.safe_text(str(error)) + self.log(self.error) + return + self.engine.heartbeat_enabled = False + delay = self.schedule.game_failed(retry=temporary and not expired and client is not None) + with self.lock: + self.next_retry_at = None + if expired: + self.connection_state = "expired" + message = "游戏会话已失效(408);策略已停止,游戏请求已暂停,请手动恢复会话或重新登录" + elif temporary and client is not None: + self.connection_state = "retrying" + reason = "游戏网络请求超时" if isinstance(error, requests.Timeout) or isinstance(cause, requests.Timeout) else "游戏网络暂时不可用" + message = f"{reason};策略已停止,{delay} 秒后只读重试,未确认记录保留" + self.next_retry_at = (datetime.now(timezone.utc) + timedelta(seconds=delay)).isoformat(timespec="milliseconds") + elif temporary: + self.connection_state = "offline" + message = "游戏网络请求未确认完成;会话尚未恢复,请手动再次恢复会话或重新登录,策略保持停止" + else: + self.connection_state = "offline" + message = "游戏请求失败,已停止策略和游戏请求,请手动恢复会话:" + str(error) + self.error = self.connection_message = self.safe_text(message) + self._last_game_error_message = self.error + self.log(self.connection_message) + + def _game_succeeded(self): + 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 = "" + self.schedule.game_resumed() + self.engine.heartbeat_enabled = True + if previous != "online": + self.log("游戏连接已确认;策略保持停止") def status(self): with self.lock: @@ -386,18 +490,23 @@ class AccountWorker: self._active = self._execution = job job.status = "running" final_status, final_error, public_result = "succeeded", "", None + failure_sequence = self._game_failure_sequence try: result = self._execute(job) public_result = self.public_json(result) - with self.lock: - self.error = "" + 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: - message = self.safe_text(str(error)) or type(error).__name__ + 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: - self.error = message + 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) @@ -443,6 +552,8 @@ class AccountWorker: self.config, self.revision = self._load_config(self.state_root) self.active_identity = saved self.engine = self._engine() + self.connection_message = "服务已启动或重启;已保留保存的会话,请手动恢复会话或重新登录,策略保持停止" + self.log(self.connection_message) if self.demo: self.result(*self.engine.poll()) self.schedule.monitor(True) @@ -462,8 +573,9 @@ class AccountWorker: 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("尚未连接游戏角色,请先登录并选择区服或恢复会话") + 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 @@ -573,6 +685,17 @@ class AccountWorker: 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 @@ -616,11 +739,13 @@ class AccountWorker: 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 = "" @@ -634,13 +759,42 @@ class AccountWorker: def guarded_call(*args, **kwargs): self.check_intent() + # This precedes Client.call's wire payload construction. A + # saved candidate can lag the still-online client's counters. + self._share_session_counters(client.session) + active = client is self.engine.client + if active: + self._require_game() # A repaired directory may be retried. Client.persist_session # sets this before Trace.begin blocks an unsafe dispatch. self._session_write_error = "" - return original(*args, **kwargs) + 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): @@ -659,6 +813,18 @@ class AccountWorker: 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: @@ -729,6 +895,7 @@ class AccountWorker: self.manager._release_identity(self, previous_identity) if old_client is not None and old_client is not client: old_client.close() + self._game_succeeded() return {"connected": True, "running": False, "has_saved_password": self._has_saved_password} def _login(self, payload): @@ -843,6 +1010,11 @@ class AccountWorker: 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} @@ -856,6 +1028,8 @@ class AccountWorker: def _start(self, payload): self.check_intent() + if not self.demo: + self._require_game() if self.engine.snapshot is None or not (self.demo or self.engine.client): raise ValueError("请先登录并选择区服或打开离线演示") value = validate_config(self.config) diff --git a/ranch_web/static/app.js b/ranch_web/static/app.js index fc01b4c..1b33ad0 100644 --- a/ranch_web/static/app.js +++ b/ranch_web/static/app.js @@ -4,20 +4,77 @@ import {el, $, $$, clone, getPath, setPath, pathKey, textValue, number, chinaTim import {PageView, PAGES} from './pages.js'; import {notice, dialog, confirm, filePicker, fileBase64} from './ui.js'; -const state = {accounts:new Map(),active:null,schema:null,meta:null,ready:false,polling:false,seq:0,redirecting:false}; +const state = {accounts:new Map(),active:null,schema:null,meta:null,ready:false,polling:false,seq:0,redirecting:false,webStatusError:null,statusMessage:'连接中'}; const current = () => state.accounts.get(state.active); const currentPage = () => { const account=current(); return account?.pages.get(account.page); }; const terminal = new Set(['succeeded','failed','cancelled']); const jobLabels = {queued:'排队中',running:'执行中',succeeded:'已完成',failed:'失败',cancelled:'已取消'}; const operationLabels = {login:'登录',enter_server:'进入区服',restore_session:'恢复会话',refresh:'刷新 / 预览',start:'开启策略',stop:'停止策略',set_config:'保存配置',import_config:'导入策略',import_yields:'导入收益',claim_daily:'领取每日奖励',quote_expansion:'读取扩建费用',expand:'扩建',sell:'派遣',feed:'喂养',lock:'锁定',unlock:'解锁'}; +const connectionLabels = {online:'已登录',retrying:'正在重试',expired:'登录已过期',offline:'游戏离线'}; +const gameRefreshOperations = new Set(['start','refresh','refresh_maps','refresh_tasks']); + +function connectionState(summary) { + if(summary?.demo)return 'online'; + return Object.hasOwn(connectionLabels,summary?.connection_state)?summary.connection_state:summary?.connected?'online':'offline'; +} + +function gameAvailable(account) { return Boolean(account && !state.webStatusError && !account.transportErrors.has('status') && connectionState(account.summary)==='online'); } + +function connectionReason(summary) { + return summary?.connection_message || summary?.error || {retrying:'游戏请求暂时失败,等待重试。',expired:'游戏登录状态已失效,请在登录页重新登录或恢复会话。',offline:'尚未连接游戏,请在登录页登录或恢复已保存会话。'}[connectionState(summary)] || ''; +} + +function connectionDetails(account) { + if(!account)return ''; + const summary=account.summary,kind=connectionState(summary),parts=[]; + if(state.webStatusError)parts.push(state.webStatusError); + if(kind!=='online')parts.push(connectionReason(summary)); + if(kind==='retrying'){ + const value=summary.next_retry_at; + const retryAt=typeof value==='number'?(value<1e12?value*1000:value):Date.parse(value); + if(value!=null && Number.isFinite(retryAt)){ + const seconds=Math.max(0,Math.ceil((retryAt-Date.now())/1000)); + parts.push(seconds?`${seconds} 秒后重试(${chinaTime(value,{date:true})},北京时间)`:'等待重试结果'); + }else parts.push('等待重试安排'); + } + if(!gameAvailable(account))parts.push(summary.last_game_success_at!=null?`显示缓存数据;最后成功通信:${chinaTime(summary.last_game_success_at,{date:true})}(北京时间)`:'显示已保存数据(缓存);尚无成功通信记录。'); + return parts.join(';'); +} + +function transportMessages(account=current()) { return [...(account?.transportErrors.values() || [])]; } + +function renderStatus() { + const message=[connectionDetails(current()),...transportMessages()].filter(Boolean).join(';') || state.statusMessage; + const node=$('#status-text');if(node.textContent!==message)node.textContent=message;node.title=message; +} + +function transportError(account,key,label,failure) { + if(failure && failure.status!==401)account.transportErrors.set(key,`${label}读取失败:${failure.message || String(failure)} 正在重试。`); + else account.transportErrors.delete(key); + renderSummary(); +} + +function connectionError(account) { return Object.assign(new Error(connectionDetails(account) || '请等待游戏连接恢复后再操作。'),{connection:true}); } + +function renderPageConnection(page) { + if(!page.connectionStatus){ + page.connectionStatus=el('p',{class:'page-summary','data-connection-status':'',hidden:true}); + page.header.after(page.connectionStatus); + } + const stale=!gameAvailable(page.account),message=connectionDetails(page.account); + page.connectionStatus.hidden=!stale;page.connectionStatus.textContent=message; + if(stale){page.loading.dataset.loading='false';page.loading.textContent=page.data?'已载入缓存':'缓存中暂无数据';clearTimeout(page.loadTimer);} + else if(page.loading.textContent.includes('缓存')){page.loading.textContent=page.data?'已载入':'正在读取…';page.loading.dataset.loading=String(!page.data);} + $$('button[data-operation]',page.actionsHost).filter(button=>gameRefreshOperations.has(button.dataset.operation)).forEach(button=>button.disabled=stale); +} function makeAccount(summary) { return {id:summary.id,summary,config:null,revision:null,edits:new Map(),pages:new Map(),page:'login',jobs:new Map(),savePromise:null,saveError:null, - logs:{entries:[],next:0,debug:false,loading:false},loadingConfig:false}; + logs:{entries:[],next:0,debug:false,loading:false},loadingConfig:false,transportErrors:new Map()}; } -function setStatus(message) { $('#status-text').textContent=message; $('#status-text').title=message; } -function error(error) { if(state.redirecting)return;notice(error.message || String(error),true); setStatus(error.message || String(error)); } +function setStatus(message) { state.statusMessage=message;renderStatus(); } +function error(error) { if(state.redirecting)return;if(error.connection){renderSummary();return;}notice(error.message || String(error),true);setStatus(error.message || String(error)); } function renderAccountTabs() { const root=$('#account-tabs'); @@ -28,11 +85,11 @@ function renderAccountTabs() { button=el('button',{type:'button',class:'account-tab',role:'tab','data-account':account.id,onClick:()=>selectAccount(account.id)},el('span',{class:'account-dot'}),el('span',{class:'account-label'})); root.append(button); } - const summary=account.summary, selected=state.active===account.id; + const summary=account.summary,selected=state.active===account.id,kind=connectionState(summary); $('.account-label',button).textContent=summary.label || summary.player?.name || '账号'; - $('.account-dot',button).className=`account-dot${summary.error?' error':summary.running?' running':''}`; + $('.account-dot',button).className=`account-dot${summary.error || kind!=='online'?' error':summary.running?' running':''}`; button.setAttribute('aria-selected',String(selected));button.tabIndex=selected?0:-1; - button.title=`${summary.label || '账号'}${summary.demo?' · 离线演示':''}${summary.running?' · 策略运行中':''}${summary.error?' · '+summary.error:''}`; + button.title=[summary.label || '账号',summary.demo?'离线演示':connectionLabels[kind],summary.running?'策略运行中':'',kind==='online'?summary.error:connectionReason(summary)].filter(Boolean).join(' · '); }); } @@ -45,22 +102,27 @@ function syncSaveStatus(account=current()) { function renderSummary() { const account=current(),summary=account?.summary,player=summary?.player || {}; - const connected=summary?.connected,demo=summary?.demo; - $('#connection').textContent=demo?'离线演示':connected?'已登录':'未登录'; - $('#connection').className=`connection${demo?' demo':connected?' online':''}`; + const kind=connectionState(summary),connected=gameAvailable(account),demo=summary?.demo,details=connectionDetails(account); + $('#connection').textContent=state.webStatusError || account?.transportErrors.has('status')?'Web 状态重试中':demo?'离线演示':connectionLabels[kind]; + $('#connection').className=`connection${connected?(demo?' demo':' online'):kind==='retrying'?' demo':''}`; + $('#connection').title=details || (demo?'当前为离线演示,不连接游戏服务器。':summary?.connection_message || '游戏连接正常'); $('#player-name').textContent=player.name || '—';$('#player-name').title=player.name || ''; for (const [id,key] of [['player-level','level'],['player-money','money'],['player-ke','ke'],['player-ti','ti']]) $('#'+id).textContent=number(player[key]); $('#player-exp').textContent=player.exp==null?'—':`${number(player.exp)} / ${number(player.next_exp)}`; $('#experience-progress').max=Math.max(1,Number(player.next_exp)||1);$('#experience-progress').value=Number(player.exp)||0; - const run=$('#strategy-toggle');run.textContent=summary?.running?'停止':'开启';run.classList.toggle('running',Boolean(summary?.running));run.disabled=!account || !account.config || !connected && !demo; + const run=$('#strategy-toggle');run.textContent=summary?.running?'停止':'开启';run.classList.toggle('running',Boolean(summary?.running));run.disabled=!account || !summary?.running && (!account.config || !connected); run.setAttribute('aria-pressed',String(Boolean(summary?.running))); - run.title=summary?.running?'停止自动执行已勾选功能;取消尚未发送的请求':'开启后自动执行各页面已勾选功能'; + run.title=summary?.running?'停止自动执行已勾选功能;取消尚未发送的请求':!connected?details:'开启后自动执行各页面已勾选功能'; + $('[data-command="start"]').disabled=!account?.config || !connected; + $('[data-command="start-all"]').disabled=![...state.accounts.values()].some(gameAvailable); if (account?.config && document.activeElement!==$('#refresh-interval')) $('#refresh-interval').value=String(account.config.interval); $('#refresh-interval').disabled=!account?.config; - $('#refresh').disabled=!account; + $('#refresh').disabled=!connected;$('#refresh').title=connected?'读取游戏状态并预览策略':details; const task=account?[...account.jobs.values()].at(-1)?.job:null; $('#job-status').textContent=task?`${operationLabels[task.operation] || task.operation} · ${jobLabels[task.status]}`:summary?.busy?'后台任务执行中':''; - $('#data-summary').textContent=summary?.error || (demo?'当前为离线演示,不连接游戏服务器。':connected?'角色状态自动刷新;配置功能后开启策略。':'请在登录页输入账号密码,或恢复已保存会话。'); + const message=[details || summary?.error || (demo?'当前为离线演示,不连接游戏服务器。':connected?'角色状态自动刷新;配置功能后开启策略。':'请在登录页输入账号密码,或恢复已保存会话。'),...transportMessages(account)].filter(Boolean).join(';'); + $('#data-summary').textContent=message;$('#data-summary').title=message; + account?.pages.forEach(renderPageConnection);renderStatus(); syncSaveStatus(account); } @@ -164,30 +226,35 @@ async function pollJob(account,record) { if(record.polling)return;record.polling=true; try { const job=await api.job(account.id,record.job.id);record.job=job; + account.transportErrors.delete(`job:${job.id}`); if(terminal.has(job.status)){ account.jobs.delete(job.id); if(job.status==='succeeded')record.resolve(job.result); else record.reject(new Error(job.error || '任务已取消')); } - }catch(failure){if([400,401,403,404].includes(failure.status)){account.jobs.delete(record.job.id);record.reject(failure);}} + }catch(failure){if([400,401,403,404].includes(failure.status)){account.transportErrors.delete(`job:${record.job.id}`);account.jobs.delete(record.job.id);record.reject(failure);}else transportError(account,`job:${record.job.id}`,'任务状态',failure);} finally{record.polling=false;renderSummary();} } async function perform(account,operation,payload={},options={}) { if(!account)throw new Error('请先新增或选择一个账号。'); + if(gameRefreshOperations.has(operation) && !gameAvailable(account))throw connectionError(account); if(operation==='start'){ const invalid=account.pages.get(account.page)?.root.querySelector(':invalid'); if(invalid){invalid.reportValidity();throw new Error('请先完成当前输入,再开启策略。');} } if(operation!=='stop')await flushConfig(account); + if(gameRefreshOperations.has(operation) && !gameAvailable(account))throw connectionError(account); const job=await api.action(account.id,operation,payload); - setStatus(`${operationLabels[operation] || '操作'}:${jobLabels[job.status] || '已提交'}`); + setStatus(`${operationLabels[operation] || '操作'}:${gameRefreshOperations.has(operation)&&job.status==='succeeded'?'等待确认游戏状态':jobLabels[job.status] || '已提交'}`); const result=await trackJob(account,job); if(!state.accounts.has(account.id))return result; if(result?.config){account.config=clone(result.config);account.revision=result.revision;} if(['enter_server','restore_session','logout','forget_login','import_config','import_yields'].includes(operation))await refreshConfig(account); - account.summary=await api.status(account.id); + try{account.summary=await api.status(account.id);account.transportErrors.delete('status');} + catch(failure){transportError(account,'status','Web 账号状态',failure);failure.connection=true;throw failure;} renderAccountTabs();renderSummary(); + if((gameRefreshOperations.has(operation)||['enter_server','restore_session'].includes(operation)) && !gameAvailable(account)){setStatus('工作台状态已更新');throw connectionError(account);} const page=options.page || account.pages.get(account.page);if(page)await loadPage(page,true); if(operation==='login'&&result)account.pages.get('login')?.login?.update(result); if(operation==='enter_server'||operation==='restore_session')notice('已读取角色。策略保持关闭,请配置功能后开启。'); @@ -206,14 +273,16 @@ function getPage(account,key) { } async function loadPage(page,force=false) { + if(!force && !gameAvailable(page.account) && (page.key!=='login'||state.webStatusError||page.account.transportErrors.has('status'))){clearTimeout(page.loadTimer);renderPageConnection(page);return;} if(page.fetching){if(force)page.reload=true;return;} page.fetching=true;const generation=page.generation || 0; try { const response=await api.view(page.account.id,page.key,page.query); if(generation!==(page.generation||0))return; page.clearError();page.render(response.data,response.loading);page.lastLoad=Date.now(); - if(response.loading){clearTimeout(page.loadTimer);page.loadTimer=setTimeout(()=>loadPage(page),650);} - }catch(failure){page.showError(failure.message);} + transportError(page.account,`view:${page.key}`,'页面数据',null);renderPageConnection(page); + if(response.loading && gameAvailable(page.account)){clearTimeout(page.loadTimer);page.loadTimer=setTimeout(()=>loadPage(page),650);} + }catch(failure){if(generation===(page.generation||0)){page.showError(failure.message);transportError(page.account,`view:${page.key}`,'页面数据',failure);}} finally{page.fetching=false;if(page.reload){page.reload=false;loadPage(page);}} } @@ -310,7 +379,13 @@ async function command(name,account=current()) { if(name==='debug'){account.logs.debug=!account.logs.debug;account.logs.entries=[];account.logs.next=0;account.logs.generation=(account.logs.generation || 0)+1;$('#debug-log').checked=account.logs.debug;setLogVisible(true);renderLogs(true);await fetchLogs(account);return;} if(name==='save'){await flushConfig(account);notice('策略已保存。');return;} if(name==='stop'||name==='start')return await perform(account,name); - if(name==='start-all'||name==='stop-all'){await Promise.all([...state.accounts.values()].map(item=>perform(item,name==='start-all'?'start':'stop')));return;} + if(name==='start-all'||name==='stop-all'){ + const accounts=[...state.accounts.values()],eligible=name==='start-all'?accounts.filter(gameAvailable):accounts; + if(!eligible.length)throw connectionError(account); + await Promise.all(eligible.map(item=>perform(item,name==='start-all'?'start':'stop'))); + if(eligible.lengthentry.id==null||!seen.has(entry.id)));account.logs.next=response.next; if(account.id===state.active)renderLogs(); if(account.logs.entries.length>1200){account.logs.entries=account.logs.entries.slice(-600);if(account.id===state.active)renderLogs(true);} - }catch(failure){if(failure.status!==401)setStatus(failure.message);}finally{account.logs.loading=false;} + transportError(account,'logs','日志',null); + }catch(failure){if(generation===(account.logs.generation || 0))transportError(account,'logs','日志',failure);}finally{account.logs.loading=false;} } async function showDebugEntry(account,entry) { @@ -455,11 +531,14 @@ function showNoAccounts() { } async function syncAccounts() { - const response=await api.accounts(),summaries=Array.isArray(response)?response:response.accounts || []; + let response; + try{response=await api.accounts();state.webStatusError=null;} + catch(failure){if(failure.status!==401){state.webStatusError=`Web 状态读取失败:${failure.message || String(failure)} 正在重试。`;renderAccountTabs();renderSummary();}throw failure;} + const summaries=Array.isArray(response)?response:response.accounts || []; const ids=new Set(summaries.map(summary=>summary.id)); for(const [id,account]of state.accounts)if(!ids.has(id)){account.pages.forEach(page=>{clearTimeout(page.loadTimer);page.root.remove();});state.accounts.delete(id);} summaries.forEach(summary=>{ - const account=state.accounts.get(summary.id);if(account){account.summary=summary;if(account.config&&account.revision!==summary.revision&&!account.edits.size&&!account.savePromise)refreshConfig(account).catch(error);} + const account=state.accounts.get(summary.id);if(account){account.summary=summary;account.transportErrors.delete('status');if(account.config&&account.revision!==summary.revision&&!account.edits.size&&!account.savePromise)refreshConfig(account).catch(error);} else state.accounts.set(summary.id,makeAccount(summary)); }); renderAccountTabs();renderSummary(); @@ -467,9 +546,11 @@ async function syncAccounts() { } async function tick() { + if(state.ready)renderSummary(); if(!state.ready||state.polling)return;state.polling=true; try{ - const account=current();await Promise.allSettled([syncAccounts(),...([...state.accounts.values()].flatMap(item=>[...item.jobs.values()].map(job=>pollJob(item,job))))]); + await Promise.allSettled([syncAccounts(),...([...state.accounts.values()].flatMap(item=>[...item.jobs.values()].map(job=>pollJob(item,job))))]); + const account=current(); if(state.ready&&account&&state.accounts.has(account.id)){fetchLogs(account);const page=account.pages.get(account.page);if(page&&Date.now()-(page.lastLoad||0)>4000)loadPage(page);} }finally{state.polling=false;} } diff --git a/ranch_web/tests/browser/test_connection_browser.py b/ranch_web/tests/browser/test_connection_browser.py new file mode 100644 index 0000000..e49a565 --- /dev/null +++ b/ranch_web/tests/browser/test_connection_browser.py @@ -0,0 +1,249 @@ +"""Offline browser regressions for game and Web connection feedback. + +All accounts are disposable demos. Game status/action responses are synthetic; +Python HTTP and browser requests outside this test's loopback server are blocked. +""" +from __future__ import annotations + +import copy +import unittest +from unittest.mock import patch + +from . import test_workbench_browser as fixtures + +if fixtures.AVAILABLE: + from playwright.sync_api import expect + + +@unittest.skipUnless(fixtures.AVAILABLE, "Python Playwright and a system Chromium browser are required") +class ConnectionBrowserTests(unittest.TestCase): + setUpClass = classmethod(fixtures.WorkbenchBrowserTests.setUpClass.__func__) + tearDownClass = classmethod(fixtures.WorkbenchBrowserTests.tearDownClass.__func__) + tearDown = fixtures.WorkbenchBrowserTests.tearDown + await_job = fixtures.WorkbenchBrowserTests.await_job + open = fixtures.WorkbenchBrowserTests.open + go = fixtures.WorkbenchBrowserTests.go + fulfill = staticmethod(fixtures.WorkbenchBrowserTests.fulfill) + + def setUp(self): + guard = patch("requests.sessions.Session.request", side_effect=AssertionError("Live HTTP is forbidden")) + guard.start() + self.addCleanup(guard.stop) + fixtures.WorkbenchBrowserTests.setUp(self) + self.external_requests = [] + + def local_only(route): + if route.request.url.startswith(self.base + "/"): + route.continue_() + else: + self.external_requests.append(route.request.url) + route.abort() + + self.context.route("**/*", local_only) + self.summary = copy.deepcopy(self.manager.status(self.first)) + self.summary.update(demo=False, connected=True, running=False, error="", connection_state="online", + connection_message="游戏连接正常", last_game_success_at="2026-11-11T00:00:00Z", next_retry_at=None) + self.calls = {"accounts": 0, "logs": 0, "views": 0} + self.fail_accounts = False + self.fail_logs = False + + def accounts(route): + self.calls["accounts"] += 1 + if self.fail_accounts: + route.abort("connectionrefused") + else: + self.fulfill(route, [self.summary, self.manager.status(self.second)]) + + def logs(route): + self.calls["logs"] += 1 + if self.fail_logs: + route.abort("connectionrefused") + else: + self.fulfill(route, {"entries": [], "next": 0}) + + self.page.route("**/api/accounts", accounts) + self.page.route(f"**/api/accounts/{self.first}/status", lambda route: self.fulfill(route, self.summary)) + self.page.route(f"**/api/accounts/{self.first}/logs?*", logs) + self.page.on("request", lambda request: self.calls.__setitem__("views", self.calls["views"] + 1) + if f"/api/accounts/{self.first}/views/" in request.url else None) + + def test_expired_cached_snapshot_stops_view_polling_and_recovers(self): + self.open() + panel = self.go("ranch") + expect(panel.locator("tbody tr").first).to_be_visible() + row_count = panel.locator("tbody tr").count() + self.summary.update(connection_state="expired", connection_message="登录凭据已失效,请重新登录。") + expect(self.page.locator("#connection")).to_have_text("登录已过期") + expect(self.page.locator("#data-summary")).to_contain_text(self.summary["connection_message"]) + expect(panel.locator(".page-loading")).to_contain_text("缓存") + expect(panel.locator("[data-connection-status]")).to_contain_text("2026/11/11") + expect(self.page.locator("#strategy-toggle")).to_be_disabled() + expect(self.page.locator("#refresh")).to_be_disabled() + expect(self.page.locator('[data-command="start"]')).to_be_disabled() + count = dict(self.calls) + self.page.wait_for_timeout(5200) + self.assertEqual(self.calls["views"], count["views"]) + self.assertGreater(self.calls["accounts"], count["accounts"]) + self.assertGreater(self.calls["logs"], count["logs"]) + self.assertEqual(panel.locator("tbody tr").count(), row_count) + self.assertTrue(panel.locator("input[data-config-path]").first.is_enabled()) + self.summary.update(connection_state="online", connection_message="游戏连接正常", error="", last_game_success_at="2026-11-11T00:01:00Z") + expect(self.page.locator("#connection")).to_have_text("已登录") + expect(self.page.locator("#strategy-toggle")).to_be_enabled() + expect(panel.locator("[data-connection-status]")).to_be_hidden() + expect(self.page.locator("#data-summary")).not_to_contain_text("凭据已失效") + expect(self.page.locator("#status-text")).not_to_contain_text("凭据已失效") + expect(panel.locator(".page-loading")).not_to_contain_text("缓存") + self.assertEqual(self.page.locator("#page-tabs [role=tab]").count(), 15) + self.assertEqual(self.external_requests, []) + self.assertEqual(self.errors, []) + + def test_retry_countdown_offline_reason_and_login_metadata(self): + self.open() + self.summary.update(connection_state="retrying", connection_message="游戏请求暂时失败(网络连接中断),即将重试。") + self.summary["next_retry_at"] = self.page.evaluate("new Date(Date.now()+30000).toISOString()") + expect(self.page.locator("#connection")).to_have_text("正在重试") + panel = self.go("bag") + expect(panel.locator("[data-connection-status]")).to_contain_text(self.summary["connection_message"]) + expect(self.page.locator("#data-summary")).to_contain_text("秒后重试") + first = self.page.locator("#data-summary").inner_text() + self.page.wait_for_timeout(2100) + self.assertNotEqual(first, self.page.locator("#data-summary").inner_text()) + self.summary.update(connection_state="offline", connection_message="尚未连接游戏,请在登录页恢复会话。", next_retry_at=None) + expect(self.page.locator("#connection")).to_have_text("游戏离线") + expect(self.page.locator("#data-summary")).to_contain_text("尚未连接游戏") + expect(self.page.locator("#data-summary")).not_to_contain_text("过期") + expect(self.page.locator("#data-summary")).not_to_contain_text("秒后重试") + login_calls = [] + self.page.on("request", lambda request: login_calls.append(request.url) if "/views/login?" in request.url else None) + login = self.go("login") + expect(login.get_by_role("button", name="恢复选中会话(无需重新输密码)")).to_be_visible() + before = len(login_calls) + self.page.wait_for_timeout(5200) + self.assertGreater(len(login_calls), before, "Disconnected login metadata must continue refreshing") + self.assertEqual(self.external_requests, []) + self.assertEqual(self.errors, []) + + def test_web_status_and_log_failures_clear_only_the_recovered_channel(self): + self.open() + self.go("ranch") + self.fail_accounts = True + expect(self.page.locator("#data-summary")).to_contain_text("Web 状态读取失败") + expect(self.page.locator("#strategy-toggle")).to_be_disabled() + expect(self.page.locator("#connection")).not_to_have_text("已登录") + count = dict(self.calls) + self.page.wait_for_timeout(5100) + self.assertGreater(self.calls["accounts"], count["accounts"]) + self.assertGreater(self.calls["logs"], count["logs"]) + self.assertEqual(self.calls["views"], count["views"]) + self.fail_logs = True + expect(self.page.locator("#data-summary")).to_contain_text("日志读取失败") + self.fail_accounts = False + expect(self.page.locator("#data-summary")).not_to_contain_text("Web 状态读取失败") + expect(self.page.locator("#data-summary")).to_contain_text("日志读取失败") + self.fail_logs = False + expect(self.page.locator("#data-summary")).not_to_contain_text("日志读取失败") + expect(self.page.locator("#status-text")).not_to_contain_text("读取失败") + expect(self.page.locator("#strategy-toggle")).to_be_enabled() + self.assertEqual(self.external_requests, []) + + def test_successful_refresh_job_with_disconnected_summary_never_reports_success(self): + self.open() + def refresh(route): + self.summary.update(connection_state="retrying", connection_message="游戏请求超时,稍后重试。", next_retry_at=None) + self.fulfill(route, {"id": "fixture-refresh", "status": "succeeded", "operation": "refresh", "result": {"message": "刷新成功"}}) + self.page.route(f"**/api/accounts/{self.first}/actions/refresh", refresh) + self.page.locator("#refresh").click() + expect(self.page.locator("#connection")).to_have_text("正在重试") + expect(self.page.locator("#status-text")).to_contain_text("游戏请求超时") + expect(self.page.locator("#status-text")).not_to_contain_text("刷新成功") + expect(self.page.locator("#status-text")).not_to_contain_text("刷新 / 预览已完成") + expect(self.page.locator("#notice")).not_to_have_text("刷新成功") + self.assertEqual(self.external_requests, []) + + def test_closing_page_never_stops_or_logs_out_account(self): + self.summary["running"] = True + self.open() + writes = [] + self.page.on("request", lambda request: writes.append(request.url) if request.method in ("POST", "PUT", "DELETE") else None) + self.page.goto("about:blank") + self.page.close() + self.assertEqual(writes, []) + self.assertEqual(self.external_requests, []) + + def test_disconnected_loading_response_is_cached_and_config_remains_editable(self): + self.open() + self.summary.update(connection_state="offline", connection_message="Web 服务已重启,请手动恢复会话。", last_game_success_at=None) + expect(self.page.locator("#connection")).to_have_text("游戏离线") + response = {"loading": True, "data": {"page": "bag", "summary": "已保存的背包", "filters": [], "columns": [], "rows": [], + "form": [{"path": ["policy", "collect"], "label": "收取魔物", "type": "checkbox"}], "actions": []}} + view_calls, actions = [], [] + self.page.route(f"**/api/accounts/{self.first}/views/bag?*", lambda route: (view_calls.append(route.request.url), self.fulfill(route, response))) + self.page.on("request", lambda request: actions.append(request.url) if "/actions/" in request.url else None) + panel = self.go("bag") + expect(panel.locator("[data-connection-status]")).to_contain_text("Web 服务已重启") + expect(panel.locator(".page-loading")).to_contain_text("缓存") + self.page.locator('[data-command="start"]').dispatch_event("click") + self.page.locator("#refresh").dispatch_event("click") + self.page.wait_for_timeout(1800) + self.assertEqual(len(view_calls), 1, "Disconnected loading=true must not create a 650ms reload chain") + self.assertEqual(actions, [], "Disconnected starts and refreshes must be guarded beyond button disabled state") + control = panel.locator("input[data-config-path]").first + expect(control).to_be_enabled() + control.set_checked(not control.is_checked()) + expect(self.page.locator("#save-status")).to_have_text("策略已自动保存") + self.page.wait_for_timeout(800) + self.assertEqual(self.manager.get_config(self.first)["config"]["policy"]["collect"], control.is_checked()) + self.assertEqual(actions, []) + self.assertEqual(self.external_requests, []) + self.assertEqual(self.errors, []) + + def test_job_transport_failure_retries_and_clears_on_job_recovery(self): + self.open() + fail_job = True + job_calls = [] + self.page.route(f"**/api/accounts/{self.first}/actions/refresh", lambda route: self.fulfill(route, + {"id": "fixture-job", "status": "queued", "operation": "refresh"})) + def job(route): + job_calls.append(route.request.url) + if fail_job: + route.abort("connectionrefused") + else: + self.fulfill(route, {"id": "fixture-job", "status": "succeeded", "operation": "refresh", "result": {}}) + self.page.route(f"**/api/accounts/{self.first}/jobs/fixture-job", job) + self.page.locator("#refresh").click() + expect(self.page.locator("#data-summary")).to_contain_text("任务状态读取失败") + self.page.wait_for_timeout(1200) + self.assertGreater(len(job_calls), 1) + expect(self.page.locator("#data-summary")).to_contain_text("任务状态读取失败") + fail_job = False + expect(self.page.locator("#data-summary")).not_to_contain_text("任务状态读取失败") + expect(self.page.locator("#status-text")).not_to_contain_text("任务状态读取失败") + self.assertEqual(self.external_requests, []) + + def test_view_failure_survives_successful_logs_and_clears_on_view_recovery(self): + self.open() + fail_view = True + response = {"loading": False, "data": {"page": "bag", "summary": "已恢复页面数据", "form": [], "filters": [], "actions": [], "columns": [], "rows": []}} + def view(route): + if fail_view: + route.abort("connectionrefused") + else: + self.fulfill(route, response) + self.page.route(f"**/api/accounts/{self.first}/views/bag?*", view) + self.page.locator('.page-tab[data-page="bag"]').click() + panel = self.page.locator('.page-panel[data-page="bag"]:not([hidden])') + expect(panel.locator(".page-error")).to_be_visible() + expect(self.page.locator("#data-summary")).to_contain_text("页面数据读取失败") + self.page.wait_for_timeout(1200) + expect(self.page.locator("#data-summary")).to_contain_text("页面数据读取失败") + fail_view = False + panel.get_by_role("button", name="重新读取").click() + expect(panel.locator(".page-error")).to_be_hidden() + expect(self.page.locator("#data-summary")).not_to_contain_text("页面数据读取失败") + expect(self.page.locator("#status-text")).not_to_contain_text("页面数据读取失败") + self.assertEqual(self.external_requests, []) + + +if __name__ == "__main__": + unittest.main() diff --git a/ranch_web/tests/browser/test_workbench_browser.py b/ranch_web/tests/browser/test_workbench_browser.py index 59ca027..030783b 100644 --- a/ranch_web/tests/browser/test_workbench_browser.py +++ b/ranch_web/tests/browser/test_workbench_browser.py @@ -283,10 +283,17 @@ class WorkbenchBrowserTests(unittest.TestCase): def test_fake_login_uses_servers_without_persisting_password(self): payloads = [] + login_result = {"servers": [{"id": 7, "name": "测试区", "role_name": "测试角色"}], "has_saved_password": True} def route_login(route): payloads.append(route.request.post_data_json) - self.fulfill(route, {"id": "fake_login", "status": "succeeded", "operation": "login", "result": {"servers": [{"id": 7, "name": "测试区", "role_name": "测试角色"}], "has_saved_password": True}, "error": None}) + self.fulfill(route, {"id": "fake_login", "status": "succeeded", "operation": "login", "result": login_result, "error": None}) + def route_login_view(route): + response = route.fetch().json() + if payloads and response.get("data"): + response["data"]["login"] = login_result + self.fulfill(route, response) self.page.route(f"**/api/accounts/{self.first}/actions/login", route_login) + self.page.route(f"**/api/accounts/{self.first}/views/login?*", route_login_view) self.open() panel = self.go("login") panel.get_by_label("游戏账号", exact=True).fill("offline-test") diff --git a/ranch_web/tests/test_activity.py b/ranch_web/tests/test_activity.py new file mode 100644 index 0000000..0a49e61 --- /dev/null +++ b/ranch_web/tests/test_activity.py @@ -0,0 +1,301 @@ +"""Standalone activity tests: disposable files, stdlib, no service/game imports.""" +from concurrent.futures import ThreadPoolExecutor +import json +import os +from pathlib import Path +import stat +import tempfile +import unittest +from unittest.mock import patch + +from ranch_web.activity import ActivityLog, ActivityLogError, MAX_MESSAGE_CHARS + + +class ActivityTests(unittest.TestCase): + def setUp(self): + self.root = Path(self.enterContext(tempfile.TemporaryDirectory(prefix="activity-test-"))) + self.path = self.root / "profiles" / "account-a" / "activity.json" + self.watermark = self.path.with_name(self.path.name + ".seq") + + def log(self, **kwargs): + return ActivityLog(self.path, **kwargs) + + def append(self, log, message="safe lifecycle event", **kwargs): + return log.append({"message": message, **kwargs}) + + def test_creation_load_sequence_and_repeated_idle_reads_never_write(self): + with patch("ranch_web.activity.os.replace") as replace, patch("ranch_web.activity.os.fsync") as fsync: + log = self.log() + for _ in range(100): + self.assertEqual(log.load(), []) + self.assertEqual(log.sequence, 0) + replace.assert_not_called() + fsync.assert_not_called() + self.assertFalse(self.path.parent.exists()) + + def test_account_isolation_and_persistence(self): + log = self.log() + first = self.append(log, "account A operation", level="warning") + other_path = self.root / "profiles" / "account-b" / "activity.json" + other = ActivityLog(other_path) + self.assertEqual(other.load(), []) + self.assertEqual(other.sequence, 0) + second = self.append(other, "account B start") + self.assertEqual((first["seq"], second["seq"]), (1, 1)) + self.assertEqual(ActivityLog(self.path).load(), [first]) + self.assertEqual(ActivityLog(other_path).load(), [second]) + self.assertEqual(first["level"], "warning") + + def test_debug_only_tail_restart_startup_exceeds_browser_cursor(self): + log = self.log(sequence_block_size=8) + persisted = self.append(log, "persisted operation") + # More than one reservation block, with no final nondebug flush. + for number in range(23): + tail = self.append(log, "transient trace " + str(number), debug=True) + browser_cursor = log.sequence + self.assertEqual(browser_cursor, tail["seq"]) + self.assertGreater(browser_cursor, persisted["seq"]) + self.assertNotIn(b"transient trace", self.path.read_bytes()) + restored = self.log(sequence_block_size=8) + self.assertEqual(restored.load(), [persisted]) + # This becomes worker._log_sequence and therefore manager.logs().next. + self.assertGreaterEqual(restored.sequence, browser_cursor) + startup = self.append(restored, "startup") + self.assertGreater(startup["seq"], browser_cursor) + page = {"entries": [e for e in restored.load() if e["seq"] > browser_cursor], + "next": restored.sequence} + self.assertEqual(page, {"entries": [startup], "next": startup["seq"]}) + following = self.append(restored, "following event") + self.assertEqual(following["seq"], startup["seq"] + 1) + + def test_entirely_debug_run_survives_restart_without_snapshot(self): + log = self.log(sequence_block_size=8) + for _ in range(19): + self.append(log, "never persist this trace", debug=True) + cursor = log.sequence + self.assertFalse(self.path.exists()) + self.assertTrue(self.watermark.exists()) + restarted = self.log(sequence_block_size=8) + self.assertEqual(restarted.load(), []) + self.assertGreater(self.append(restarted, "startup")["seq"], cursor) + + def test_caller_fallback_cursor_is_reserved_before_resuming_debug_events(self): + log = self.log() + self.append(log) + recovered = log.append({"message": "debug after recovery", "debug": True}, after_sequence=1000) + self.assertEqual(recovered["seq"], 1001) + self.assertGreaterEqual(json.loads(self.watermark.read_bytes())["sequence"], recovered["seq"]) + self.assertGreater(self.append(self.log(), "startup")["seq"], recovered["seq"]) + + def test_failed_caller_cursor_reservation_can_retry_without_reusing_ids(self): + log = self.log() + self.append(log) + with patch.object(log, "_write", side_effect=ActivityLogError("Unable to save activity storage")): + with self.assertRaises(ActivityLogError): + log.append({"message": "not published", "debug": True}, after_sequence=1000) + self.assertEqual(log.sequence, 1) + self.assertEqual(log.append({"message": "recovery"}, after_sequence=1001)["seq"], 1002) + + def test_invalid_caller_cursor_is_rejected(self): + for cursor in (True, -1, None, 1.0, 1 << 53): + with self.subTest(cursor=cursor), self.assertRaises(ValueError): + self.log().append({"message": "invalid cursor"}, after_sequence=cursor) + + def test_debug_cost_is_small_watermark_per_block_no_snapshot_rewrite(self): + log = self.log(sequence_block_size=8) + self.append(log) + snapshot = self.path.read_bytes() + with patch("ranch_web.activity.os.replace", wraps=os.replace) as replace: + for _ in range(31): + self.append(log, "debug private detail", debug=True) + self.assertEqual(replace.call_count, 3) + self.assertTrue(all(Path(call.args[1]) == self.watermark for call in replace.call_args_list)) + self.assertEqual(self.path.read_bytes(), snapshot) + self.assertLess(self.watermark.stat().st_size, 64) + self.assertNotIn(b"private detail", self.watermark.read_bytes()) + + def test_max_entries_and_highwater_survive_eviction(self): + log = self.log(max_entries=3, sequence_block_size=8) + entries = [self.append(log, str(n)) for n in range(12)] + self.assertEqual(log.load(), entries[-3:]) + restarted = self.log(max_entries=2, sequence_block_size=8) + self.assertEqual(restarted.load(), entries[-2:]) + self.assertGreater(self.append(restarted)["seq"], entries[-1]["seq"]) + + def test_hard_2000_entry_bound(self): + # Construct a valid oversized snapshot to test bounded recovery without + # manufacturing 2001 synchronous fsync operations in this unit suite. + self.path.parent.mkdir(parents=True) + rows = [{"seq": seq, "message": "short"} for seq in range(1, 2006)] + self.path.write_text(json.dumps({"schema": 1, "sequence": 2005, "entries": rows}), encoding="utf-8") + log = self.log() + self.assertEqual(len(log.load()), 2000) + last = self.append(log, "last") + rows = json.loads(self.path.read_bytes())["entries"] + self.assertEqual(len(rows), 2000) + self.assertEqual(rows[0]["seq"], 7) + self.assertEqual(rows[-1], last) + + def test_unicode_message_and_total_encoded_byte_limits(self): + log = self.log(max_bytes=16384) + for _ in range(12): + last = self.append(log, "操作\n" * 16000) + self.assertEqual(len(last["message"]), MAX_MESSAGE_CHARS) + self.assertNotIn("\n", last["message"]) + self.assertLessEqual(self.path.stat().st_size, 16384) + self.assertLess(len(log.load()), 12) + self.assertEqual(self.log(max_bytes=16384).load(), log.load()) + self.assertEqual(log.load()[-1], last) + + def test_caller_redaction_and_whitelist_exclude_credentials_payloads_paths(self): + secret, password, local_path = "synthetic-token-value", "synthetic-password", str(self.root) + + def safe_text(value): + for sensitive in (secret, password, local_path): + value = value.replace(sensitive, "") + return value + + entry = {"message": safe_text("operation " + secret + " " + password + " " + local_path), + "token": secret, "password": password, "path": local_path, + "headers": {"Authorization": secret}, "request": {"body": password}, + "response": {"raw": secret}, "seq": 90000, "id": 90000} + log = self.log() + saved = log.append(entry) + self.assertEqual(set(saved), {"time", "message", "debug", "level", "id", "seq"}) + self.assertEqual(saved["seq"], 1) + for filename in (self.path, self.watermark): + raw = filename.read_text(encoding="utf-8") + for sensitive in (secret, password, local_path, '"headers"', '"request"', '"response"'): + self.assertNotIn(sensitive, raw) + + def test_output_copies_and_helper_integer_id(self): + log = self.log() + entry = self.append(log, "original") + entry["message"] = "mutated" + snapshot = log.load() + snapshot[0]["message"] = "also mutated" + self.assertEqual(log.load()[0]["message"], "original") + identifier = log.log("second") + self.assertIs(type(identifier), int) + self.assertEqual(identifier, log.sequence) + self.assertEqual(identifier, log.load()[-1]["id"]) + + def test_corrupt_snapshot_preserves_debug_cursor_via_watermark(self): + log = self.log(sequence_block_size=8) + self.append(log) + for _ in range(20): + self.append(log, debug=True) + old_cursor = log.sequence + for damaged in (b"{broken", b"\xff\xfe", b"[]", b"null", b'{"schema":99}'): + with self.subTest(damaged=damaged): + self.path.write_bytes(damaged) + restored = self.log(sequence_block_size=8) + self.assertEqual(restored.load(), []) + self.assertGreater(self.append(restored, "recovered")["seq"], old_cursor) + + def test_corrupt_rows_and_metadata_are_tolerated_and_scrubbed(self): + self.path.parent.mkdir(parents=True) + rows = [None, 17, {"seq": True, "message": "bad"}, {"seq": -1, "message": "bad"}, + {"seq": 5, "message": "five", "token": "discard-me"}, + {"seq": 4, "message": "four", "debug": False}, + {"seq": 6, "message": "debug", "debug": True}, + {"seq": 7, "message": "wrong flag", "debug": "false"}, + {"seq": 8, "message": []}, {"seq": 9, "message": "nine"}] + self.path.write_text(json.dumps({"schema": 1, "sequence": 20, "entries": rows}), encoding="utf-8") + self.watermark.write_text("broken", encoding="utf-8") + log = self.log() + self.assertEqual([entry["seq"] for entry in log.load()], [4, 5, 9]) + self.assertEqual(log.sequence, 20) + self.assertEqual(self.append(log)["seq"], 21) + self.assertNotIn(b"discard-me", self.path.read_bytes()) + + def test_oversized_or_deeply_nested_corrupt_files_are_tolerated(self): + self.path.parent.mkdir(parents=True) + for damaged in (b" " * (2 * 1024 * 1024 + 1), b"[" * 2000 + b"]" * 2000): + self.path.write_bytes(damaged) + self.assertEqual(self.log().load(), []) + self.assertEqual(self.append(self.log())["seq"], 1) + + def test_atomic_replace_failure_keeps_old_snapshot_and_hides_path(self): + log = self.log() + first = self.append(log) + old = self.path.read_bytes() + with patch("ranch_web.activity.os.replace", side_effect=OSError("PRIVATE " + str(self.path))): + with self.assertRaises(ActivityLogError) as raised: + self.append(log, "not published") + self.assertNotIn(str(self.root), str(raised.exception)) + self.assertTrue(raised.exception.__suppress_context__) + self.assertEqual(self.path.read_bytes(), old) + self.assertEqual(log.sequence, first["seq"]) + self.assertEqual(log.load(), [first]) + self.assertEqual(list(self.path.parent.glob("*.tmp")), []) + self.assertEqual(self.append(log, "retry")["seq"], first["seq"] + 1) + + def test_reservation_failure_does_not_publish_debug_sequence(self): + log = self.log() + with patch("ranch_web.activity.os.fsync", side_effect=OSError("PRIVATE " + str(self.path))): + with self.assertRaisesRegex(ActivityLogError, "Unable to save activity storage"): + self.append(log, debug=True) + self.assertEqual(log.sequence, 0) + self.assertFalse(self.path.exists()) + self.assertFalse(self.watermark.exists()) + self.assertEqual(list(self.path.parent.glob("*.tmp")), []) + + def test_atomic_temp_permissions_and_replacement(self): + real_replace = os.replace + destinations = [] + + def inspect_replace(source, destination): + source, destination = Path(source), Path(destination) + self.assertEqual(source.parent, destination.parent) + json.loads(source.read_bytes()) # Always a complete JSON document. + if os.name != "nt": + self.assertEqual(stat.S_IMODE(source.stat().st_mode), 0o600) + destinations.append(destination) + return real_replace(source, destination) + + with patch("ranch_web.activity.os.replace", side_effect=inspect_replace), \ + patch("ranch_web.activity.os.chmod", wraps=os.chmod) as chmod: + self.append(self.log()) + self.assertEqual(destinations, [self.watermark, self.path]) + self.assertEqual([call.args[1] for call in chmod.call_args_list], [0o600, 0o600]) + if os.name != "nt": + for path in (self.path, self.watermark): + self.assertEqual(stat.S_IMODE(path.stat().st_mode), 0o600) + + def test_trace_level_is_not_persisted_even_without_debug_flag(self): + log = self.log() + entry = self.append(log, "transient", level="trace") + self.assertTrue(entry["debug"]) + self.assertEqual(entry["level"], "debug") + self.assertEqual(log.load(), []) + self.assertFalse(self.path.exists()) + + def test_thread_safe_unique_sequences(self): + log = self.log(sequence_block_size=8) + with ThreadPoolExecutor(max_workers=8) as pool: + entries = list(pool.map(lambda _: self.append(log, debug=True), range(160))) + self.assertEqual(sorted(entry["seq"] for entry in entries), list(range(1, 161))) + self.assertEqual(log.sequence, 160) + self.assertGreater(self.append(self.log())["seq"], 160) + + def test_validation_has_path_free_messages(self): + for options in ({"max_entries": 0}, {"max_entries": 2001}, {"max_entries": True}, + {"max_bytes": 1}, {"max_bytes": 2097153}, {"sequence_block_size": 0}): + with self.subTest(options=options), self.assertRaises(ValueError): + self.log(**options) + for entry in (None, {}, {"message": self.path}, {"message": "safe", "debug": "false"}): + with self.subTest(entry=entry), self.assertRaises(ValueError) as raised: + self.log().append(entry) + self.assertNotIn(str(self.root), str(raised.exception)) + + def test_unreadable_storage_error_hides_path(self): + with patch("pathlib.Path.open", side_effect=PermissionError("PRIVATE " + str(self.path))): + with self.assertRaises(ActivityLogError) as raised: + self.log().load() + self.assertEqual(str(raised.exception), "Unable to read activity storage") + self.assertTrue(raised.exception.__suppress_context__) + + +if __name__ == "__main__": + unittest.main() diff --git a/ranch_web/tests/test_api.py b/ranch_web/tests/test_api.py index fbcaa21..1e63138 100644 --- a/ranch_web/tests/test_api.py +++ b/ranch_web/tests/test_api.py @@ -185,6 +185,16 @@ class ApiTests(unittest.TestCase): self.assertEqual(self.client.delete(f"/api/accounts/{response.json()['id']}").status_code, 204) self.assertEqual(self.client.get(f"/api/accounts/{response.json()['id']}/status").status_code, 404) + def test_connection_metadata_survives_summary_dto(self): + metadata = {"connection_state": "retrying", "connection_message": "网络请求超时;策略已停止,正在只读重试", + "last_game_success_at": "2026-11-11T02:05:36.000+00:00", "next_retry_at": "2026-11-11T02:05:41.000+00:00"} + self.manager.accounts[self.account_id].update(metadata) + for url in (self.url + "/status", "/api/accounts"): + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + summary = response.json()[0] if url == "/api/accounts" else response.json() + self.assertEqual({key: summary[key] for key in metadata}, metadata) + def test_game_login_is_queued_and_credentials_stay_server_side(self): response = self.client.post(self.url + "/actions/login", json={"account": "fake-account", "password": "GAME_PASSWORD", "remember": True}) self.assertEqual(response.status_code, 202) diff --git a/ranch_web/tests/test_connection_state.py b/ranch_web/tests/test_connection_state.py new file mode 100644 index 0000000..6e4f7a8 --- /dev/null +++ b/ranch_web/tests/test_connection_state.py @@ -0,0 +1,442 @@ +"""Connection regressions through real workers and an entirely offline transport.""" +from copy import deepcopy +from types import SimpleNamespace +import threading +import unittest +from unittest.mock import patch + +import requests + +from ranch_assistant.api import ApiError, encode +from ranch_web.activity import ActivityLogError +from ranch_web.service import WebManager +from ranch_web.scheduler import Scheduler +from ranch_web.tests import test_service as fixtures + + +class ConnectionStateTests(unittest.TestCase): + setUp = fixtures.ServiceTests.setUp + account = fixtures.ServiceTests.account + idle = fixtures.ServiceTests.idle + job = fixtures.ServiceTests.job + login = fixtures.ServiceTests.login + enable = fixtures.ServiceTests.enable + + def connected(self, *, running=False): + identifier = self.account(False) + self.login(identifier) + worker = self.manager._worker(identifier) + self.now = 1000.0 + worker.schedule.clock = lambda: self.now + if running: + self.enable(identifier) + self.job(identifier, self.manager.submit(identifier, "start")) + return identifier, worker + + def tick(self, identifier, worker, *, status="succeeded"): + return self.job(identifier, worker.enqueue("__tick"), status=status) + + def expiry(self, worker): + return SimpleNamespace(status_code=200, headers={}, + content=encode({"resCode": 408}, worker.engine.client.session.key)) + + def test_expired_state_survives_idle_view_config_and_blocks_game_requests(self): + identifier, worker = self.connected(running=True) + original_client, original_snapshot = worker.engine.client, worker.engine.snapshot + with patch.object(original_client.http, "post", return_value=self.expiry(worker)) as post: + worker.engine.last_heartbeat = 0 + self.tick(identifier, worker, status="failed") + state = self.manager.status(identifier) + self.assertEqual(state.get("connection_state"), "expired") + self.assertIn("失效", state["connection_message"]) + self.assertFalse(state["connected"]) + self.assertFalse(state["running"]) + reason = state["error"] + for _ in range(3): + self.now += 600 + self.tick(identifier, worker) + view = self.manager.view(identifier, "bag") + self.job(identifier, {"id": view["job_id"]}) + config = self.manager.get_config(identifier) + config["config"]["interval"] = 60 + self.job(identifier, self.manager.set_config(identifier, config["config"])["job"]) + self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed") + self.job(identifier, self.manager.submit(identifier, "start"), status="failed") + self.assertEqual(post.call_count, 1) + self.assertEqual(self.manager.status(identifier)["error"], reason) + self.assertEqual(self.manager.status(identifier)["connection_state"], "expired") + self.assertIs(worker.engine.client, original_client) + self.assertIs(worker.engine.snapshot, original_snapshot) + self.assertIsNotNone(worker.securestore.load(worker.active_identity)) + self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity})) + self.assertEqual(self.manager.status(identifier)["connection_state"], "online") + self.assertFalse(self.manager.status(identifier)["running"]) + + def test_timeout_retries_only_snapshot_and_keeps_uncertain_write_evidence(self): + identifier, worker = self.connected(running=True) + journal = worker.engine.battle_journal + pending = journal.begin(worker.engine.snapshot, {"kind": "battle", "description": "未确认的战斗", + "path": "stageService/stageStart", "payload": {}, "stage_id": "0101", "difficulty": "1"}) + journal.update(pending, "unknown", message="未确认的战斗写请求") + evidence = journal.path + before = evidence.read_bytes() + client = worker.engine.client + + def write(runtime, operation, payload): + runtime.engine.client.call("monsterService/monsterLock", {"monsterId": 1}) + + with patch("ranch_web.actions.execute_action", side_effect=write): + with patch.object(client.http, "post", side_effect=requests.ReadTimeout("synthetic timeout")) as post: + self.job(identifier, self.manager.submit(identifier, "lock"), status="failed") + self.assertEqual(post.call_count, 1) + state = self.manager.status(identifier) + self.assertEqual(state.get("connection_state"), "retrying") + self.assertNotIn("失效", state["connection_message"]) + self.assertFalse(state["running"]) + self.assertIsNotNone(state["next_retry_at"]) + calls = len(fixtures.FakeClient.calls) + self.tick(identifier, worker) + self.assertEqual(len(fixtures.FakeClient.calls), calls) + self.now += 61 + self.tick(identifier, worker) + paths = [url.rsplit("/", 2)[-2:] for _, url, _ in fixtures.FakeClient.calls[calls:]] + self.assertEqual(paths, [["masterService", "masterQueryDetail"]]) + self.assertEqual(self.manager.status(identifier)["connection_state"], "online") + self.assertEqual(self.manager.status(identifier)["error"], "") + self.assertIsNone(self.manager.status(identifier)["next_retry_at"]) + self.assertIsNotNone(self.manager.status(identifier)["last_game_success_at"]) + self.assertFalse(worker.running) + self.assertEqual(journal.pending(worker.engine.snapshot)["attempt_id"], pending["attempt_id"]) + self.assertEqual(evidence.read_bytes(), before) + # Continue through the ordinary monitor/reconcile path after recovery. + # The existing Engine barrier must still prevent the unknown write. + worker.engine.last_heartbeat = self.now + worker.schedule.next_poll = 0 + self.now += 121 + self.tick(identifier, worker) + paths = [url.rsplit("/", 2)[-2:] for _, url, _ in fixtures.FakeClient.calls[calls:]] + self.assertEqual(paths, [["masterService", "masterQueryDetail"]] * 2) + self.assertEqual(journal.pending(worker.engine.snapshot)["attempt_id"], pending["attempt_id"]) + self.assertEqual(journal.pending(worker.engine.snapshot)["phase"], "unknown") + self.assertFalse(worker.running) + + def test_business_rejection_keeps_connection_and_idle_does_not_clear_error(self): + identifier, worker = self.connected(running=True) + client = worker.engine.client + response = SimpleNamespace(status_code=200, headers={}, + content=encode({"resCode": 403}, client.session.key)) + with patch.object(client.http, "post", return_value=response): + self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed") + state = self.manager.status(identifier) + self.assertEqual(state["connection_state"], "online") + self.assertTrue(state["connected"]) + self.assertFalse(state["running"]) + self.assertFalse(worker.schedule.game_paused) + self.assertTrue(worker.schedule.monitoring) + reason = state["error"] + self.assertIn("403", reason) + worker.engine.last_heartbeat = self.now + worker.schedule.next_poll = float("inf") + with patch.object(worker.engine, "master_sync_due", return_value=False), patch.object(worker.engine, "growth_sync_due", return_value=False): + self.tick(identifier, worker) + view = self.manager.view(identifier, "bag") + self.job(identifier, {"id": view["job_id"]}) + self.assertEqual(self.manager.status(identifier)["error"], reason) + + def test_997_is_retrying_without_expiry_and_backoff_is_bounded(self): + identifier, worker = self.connected() + response = SimpleNamespace(status_code=200, headers={}, + content=encode({"resCode": 997}, worker.engine.client.session.key)) + with patch.object(worker.engine.client.http, "post", return_value=response) as post: + self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed") + for delay in (5, 10, 20, 40, 60, 60): + self.assertEqual(worker.schedule.retry_deadline - self.now, delay) + state = self.manager.status(identifier) + self.assertEqual(state["connection_state"], "retrying") + self.assertNotIn("失效", state["connection_message"]) + calls = post.call_count + self.tick(identifier, worker) + self.assertEqual(post.call_count, calls) + self.now += delay + self.tick(identifier, worker, status="failed") + self.assertEqual(post.call_count, calls + 1) + + def test_swallowed_expiry_still_stops_strategy_and_marks_job_failed(self): + identifier, worker = self.connected(running=True) + + def swallowed(runtime, operation, payload): + try: + runtime.engine.client.call("monsterService/monsterLock") + except ApiError: + return {"message": "Engine caught the error"} + + with patch("ranch_web.actions.execute_action", side_effect=swallowed): + with patch.object(worker.engine.client.http, "post", return_value=self.expiry(worker)): + result = self.job(identifier, self.manager.submit(identifier, "lock"), status="failed") + self.assertIn("失效", result["error"]) + self.assertEqual(self.manager.status(identifier)["connection_state"], "expired") + self.assertFalse(worker.running) + + def test_scheduler_runs_fake_heartbeat_and_poll_without_any_browser_requests(self): + identifier, worker = self.connected() + heartbeat, poll = threading.Event(), threading.Event() + original = worker.engine.client.http.post + + def post(url, *args, **kwargs): + result = original(url, *args, **kwargs) + if url.endswith("heartBeatService/keepAlive"): + heartbeat.set() + if url.endswith("masterService/masterQueryDetail"): + poll.set() + return result + + worker.engine.last_heartbeat = 0 + worker.schedule.next_poll = 0 + with patch.object(worker.engine.client.http, "post", side_effect=post): + scheduler = Scheduler(self.manager._worker_list, interval=.01) + try: + self.assertTrue(heartbeat.wait(3), "No heartbeat without browser polling") + self.assertTrue(poll.wait(3), "No game poll without browser polling") + finally: + scheduler.close() + self.idle(identifier) + self.assertFalse(worker.running) + + def test_idle_local_success_does_not_clear_game_error(self): + identifier, worker = self.connected() + with patch.object(worker.engine.client.http, "post", side_effect=requests.Timeout("offline")): + self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed") + reason = self.manager.status(identifier)["error"] + self.assertTrue(reason) + self.tick(identifier, worker) + view = self.manager.view(identifier, "bag") + self.job(identifier, {"id": view["job_id"]}) + self.job(identifier, self.manager.submit(identifier, "refresh", {"page": "statistics"})) + self.assertEqual(self.manager.status(identifier)["error"], reason) + self.assertFalse(self.manager.status(identifier)["connected"]) + + def test_failed_restore_candidate_does_not_poison_online_client(self): + identifier, worker = self.connected() + client = worker.engine.client + original = deepcopy(self.manager.status(identifier)) + response = self.expiry(worker) + with patch.object(fixtures.FakeClient, "_post", return_value=response): + self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}), status="failed") + self.assertIs(worker.engine.client, client) + self.assertFalse(client.closed) + state = self.manager.status(identifier) + self.assertEqual(state.get("connection_state"), "online") + self.assertEqual(state["last_game_success_at"], original["last_game_success_at"]) + self.assertEqual(state["connection_message"], original["connection_message"]) + self.assertTrue(state["connected"]) + + def test_failed_same_protocol_restore_preserves_counter_high_water_before_wire_and_finally(self): + identifier, worker = self.connected() + for active_reqid, active_reqsid in ((400, 900), (500, 1200)): + with self.subTest(active_reqid=active_reqid): + client = worker.engine.client + saved = deepcopy(client.session) + saved.reqid, saved.reqsid = 400, 900 + worker.securestore.save(saved, "离线高水位回归") + client.session.reqid, client.session.reqsid = active_reqid, active_reqsid + wire = [] + + def post(url, data, **kwargs): + wire.append(fixtures.decode(data, client.session.key)) + return self.expiry(worker) + + with patch.object(fixtures.FakeClient, "_post", side_effect=post): + self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}), status="failed") + self.assertEqual((wire[0]["reqid"], wire[0]["reqsid"]), (active_reqid, active_reqsid)) + persisted = worker.securestore.load(worker.active_identity) + self.assertEqual((persisted.reqid, persisted.reqsid), (active_reqid + 1, active_reqsid + 1)) + self.assertEqual((client.session.reqid, client.session.reqsid), (persisted.reqid, persisted.reqsid)) + client.call("heartBeatService/keepAlive") + payload = fixtures.FakeClient.calls[-1][2] + self.assertEqual((payload["reqid"], payload["reqsid"]), (active_reqid + 1, active_reqsid + 1)) + + def test_counter_merge_requires_exact_protocol_session(self): + identifier, worker = self.connected() + current = worker.engine.client.session + current.reqid, current.reqsid = 500, 900 + changes = {"token": "different", "key": "different", "server_url": "https://other.invalid/", + "account_id": "different", "server_id": 9, "role_id": 999, "channel": "other", "platform": "other"} + for field, value in changes.items(): + candidate = deepcopy(current) + candidate.reqid, candidate.reqsid = 800, 1800 + setattr(candidate, field, value) + worker._share_session_counters(candidate) + self.assertEqual((current.reqid, current.reqsid), (500, 900), field) + self.assertEqual((candidate.reqid, candidate.reqsid), (800, 1800), field) + + def test_first_restore_timeout_without_client_requires_manual_restore(self): + identifier, worker = self.connected() + identity = worker.active_identity + self.manager.close() + self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin) + self.addCleanup(self.manager.close) + self.idle(identifier) + worker = self.manager._worker(identifier) + with patch.object(fixtures.FakeClient, "_post", side_effect=requests.ReadTimeout("offline")) as post: + self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}), status="failed") + for _ in range(3): + self.tick(identifier, worker) + self.assertEqual(post.call_count, 1) + state = self.manager.status(identifier) + self.assertEqual(state["connection_state"], "offline") + self.assertIn("手动", state["connection_message"]) + self.assertIsNone(state["next_retry_at"]) + self.assertIsNone(worker.schedule.retry_deadline) + self.assertIsNone(worker.engine.client) + + def test_activity_restart_cursor_survives_debug_only_tail_and_records_reason(self): + identifier, worker = self.connected() + worker.log("可持久保存的运行事件") + worker.log("不持久保存的调试内容", debug=True) + old_cursor = self.manager.logs(identifier, debug=True)["next"] + self.manager.close() + self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin) + self.addCleanup(self.manager.close) + self.idle(identifier) + logs = self.manager.logs(identifier, after=old_cursor) + self.assertGreater(logs["next"], old_cursor) + self.assertTrue(any("重启" in row["message"] and "恢复" in row["message"] for row in logs["entries"])) + all_logs = self.manager.logs(identifier, debug=True)["entries"] + self.assertTrue(any("可持久保存的运行事件" == row["message"] for row in all_logs)) + self.assertFalse(any("不持久保存的调试内容" == row["message"] for row in all_logs)) + + def test_activity_write_failure_keeps_memory_logs_and_original_game_outcome(self): + identifier, worker = self.connected() + with patch.object(worker._activity, "append", side_effect=ActivityLogError("Unable to save activity storage")): + with patch.object(worker.engine.client.http, "post", return_value=self.expiry(worker)): + result = self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed") + self.assertIn("失效", result["error"]) + self.assertEqual(self.manager.status(identifier)["connection_state"], "expired") + logs = self.manager.logs(identifier, debug=True)["entries"] + self.assertTrue(any("日志无法持久保存" in entry["message"] for entry in logs)) + self.assertEqual(len({entry["seq"] for entry in logs}), len(logs)) + + def test_activity_idle_tick_and_view_do_not_write_log_storage(self): + identifier, worker = self.connected() + worker.engine.last_heartbeat = self.now + worker.schedule.next_poll = float("inf") + with patch.object(worker.engine, "master_sync_due", return_value=False), patch.object(worker.engine, "growth_sync_due", return_value=False): + with patch.object(worker._activity, "append", wraps=worker._activity.append) as append: + self.tick(identifier, worker) + view = self.manager.view(identifier, "bag") + self.job(identifier, {"id": view["job_id"]}) + append.assert_not_called() + + def test_activity_failure_does_not_turn_successful_game_read_into_failure(self): + identifier, worker = self.connected() + with patch.object(worker._activity, "append", side_effect=ActivityLogError("Unable to save activity storage")): + self.job(identifier, self.manager.submit(identifier, "refresh")) + self.assertEqual(self.manager.status(identifier)["connection_state"], "online") + self.assertEqual(self.manager.status(identifier)["error"], "") + self.assertTrue(any("日志无法持久保存" in entry["message"] for entry in self.manager.logs(identifier)["entries"])) + + def test_activity_recovers_after_long_memory_fallback_without_reusing_cursor(self): + identifier, worker = self.connected() + activity = worker._activity + with patch.object(activity, "_write", side_effect=ActivityLogError("Unable to save activity storage")): + worker.log("临时无法保存的运行事件") + for _ in range(300): + worker.log("磁盘只读期间的调试事件", debug=True) + memory_cursor = self.manager.logs(identifier, debug=True)["next"] + for _ in range(300): + worker.log("磁盘恢复后的调试事件", debug=True) + self.assertIs(worker._activity, activity) + logs = self.manager.logs(identifier, debug=True) + old_cursor = logs["next"] + self.assertGreater(old_cursor, memory_cursor) + self.assertEqual(len({entry["seq"] for entry in logs["entries"]}), len(logs["entries"])) + self.assertEqual(sum("日志无法持久保存" in entry["message"] for entry in logs["entries"]), 1) + self.assertEqual(sum("日志持久化已恢复" in entry["message"] for entry in logs["entries"]), 1) + self.manager.close() + self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin) + self.addCleanup(self.manager.close) + self.idle(identifier) + after_restart = self.manager.logs(identifier, after=old_cursor) + self.assertTrue(after_restart["entries"]) + self.assertTrue(all(entry["seq"] > old_cursor for entry in after_restart["entries"])) + + def test_activity_initial_load_failure_retries_on_later_events(self): + self.manager.close() + with patch("ranch_web.service.ActivityLog.load", side_effect=ActivityLogError("Unable to read activity storage")), \ + patch("ranch_web.activity.ActivityLog._read", side_effect=ActivityLogError("Unable to read activity storage")): + self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin) + self.addCleanup(self.manager.close) + identifier = self.account(False) + worker = self.manager._worker(identifier) + self.assertTrue(any("首次读取运行日志失败" in entry["message"] for entry in self.manager.logs(identifier)["entries"])) + before = self.manager.logs(identifier)["next"] + identifier = worker.log("日志存储重新可用") + self.assertGreater(identifier, before) + self.assertIsNotNone(worker._activity) + self.assertTrue(any("日志持久化已恢复" in entry["message"] for entry in worker._activity.load())) + + def test_activity_initial_load_failure_then_immediate_recovery_has_ordered_messages(self): + self.manager.close() + with patch("ranch_web.service.ActivityLog.load", side_effect=ActivityLogError("Unable to read activity storage")): + self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin) + self.addCleanup(self.manager.close) + identifier = self.account(False) + messages = [entry["message"] for entry in self.manager.logs(identifier)["entries"]] + self.assertIn("首次读取运行日志失败", messages[0]) + self.assertIn("日志持久化已恢复", messages[1]) + self.assertEqual(messages[2], "账号工作区已载入") + self.assertFalse(any("无法持久保存" in message for message in messages[1:])) + + def test_restart_and_explicit_logout_require_manual_restore(self): + identifier, worker = self.connected() + self.manager.close() + calls = len(fixtures.FakeClient.calls) + self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin) + self.addCleanup(self.manager.close) + self.idle(identifier) + worker = self.manager._worker(identifier) + state = self.manager.status(identifier) + self.assertEqual(state.get("connection_state"), "offline") + self.assertIn("重启", state["connection_message"]) + self.assertIn("恢复", state["connection_message"]) + self.assertFalse(state["running"]) + self.assertEqual(len(fixtures.FakeClient.calls), calls) + self.tick(identifier, worker) + self.assertEqual(len(fixtures.FakeClient.calls), calls) + self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity})) + self.job(identifier, self.manager.submit(identifier, "logout")) + calls = len(fixtures.FakeClient.calls) + self.now += 10000 + self.tick(identifier, worker) + state = self.manager.status(identifier) + self.assertEqual(state["connection_state"], "offline") + self.assertIn("退出", state["connection_message"]) + self.assertFalse(state["running"]) + self.assertEqual(len(fixtures.FakeClient.calls), calls) + + +class ErrorClassificationTests(unittest.TestCase): + def test_failed_heartbeat_does_not_advance_its_success_clock(self): + def fail(*args): + raise ApiError("offline") + + engine = fixtures.Engine(fixtures.Catalog(), SimpleNamespace(call=fail)) + engine.last_heartbeat = 123 + with self.assertRaises(ApiError): + engine.keep_alive() + self.assertEqual(engine.last_heartbeat, 123) + + def test_wire_expiry_and_transport_timeout_have_distinct_types(self): + client = fixtures.FakeClient(fixtures.Session("https://offline.invalid/game/", "synthetic-token")) + self.addCleanup(client.close) + response = SimpleNamespace(status_code=200, headers={}, content=encode({"resCode": 408}, client.session.key)) + with patch.object(client.http, "post", return_value=response): + with self.assertRaises(ApiError) as expired: + client.call("masterService/masterQueryDetail") + with patch.object(client.http, "post", side_effect=requests.Timeout("offline")) as post: + with self.assertRaises(ApiError) as temporary: + client.call("monsterService/monsterLock") + self.assertEqual(post.call_count, 1) + self.assertEqual(getattr(expired.exception, "code", None), 408) + self.assertNotEqual(type(expired.exception), type(temporary.exception)) + self.assertIsInstance(temporary.exception.__cause__, requests.Timeout)