fix: preserve background connection state and durable disconnect logs

This commit is contained in:
AttilaNet
2026-11-11 11:05:49 +08:00
parent e26d37e9c5
commit 654567caa3
14 changed files with 1622 additions and 48 deletions
+24
View File
@@ -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 项全部通过。独立审核的四组故障重放均通过,涵盖同协议请求计数不回退、无客户端时不承诺虚假的自动重试、存储恢复后的日志编号以及日志故障不影响游戏请求原始结论。
+18 -6
View File
@@ -38,7 +38,17 @@ def decode(raw, key):
class ApiError(RuntimeError): 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): def server_id(server):
@@ -177,20 +187,22 @@ class Client:
headers=dict(result.headers), elapsed_ms=round((time.monotonic() - started) * 1000), 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) body_preview=result.content[:4000].decode("utf-8", errors="replace"), bytes_received=len(result.content), decoded=False)
if result.status_code != 200: 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 raise
if self.trace: if self.trace:
self.trace.emit("response", operation, request_id=identifier, url=url, http_status=result.status_code, 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) headers=dict(result.headers), elapsed_ms=round((time.monotonic() - started) * 1000), body=response, decoded=True)
if result.status_code != 200: 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): if not isinstance(response, dict):
raise ApiError("游戏接口响应不是 JSON 对象,请查看调试窗口") raise ApiError("游戏接口响应不是 JSON 对象,请查看调试窗口")
code = response.get("resCode") code = response.get("resCode")
if code not in (0, "0"): if code not in (0, "0"):
if str(code) == "408": if str(code) == "408":
raise ApiError("会话已失效,请重新登录或导入有效会话") raise SessionExpiredError("会话已失效,请手动恢复会话或重新登录", code=408)
raise ApiError(f"游戏接口返回 {code},已停止本轮操作") raise ApiError(f"游戏接口返回 {code},已停止本轮操作", code=code)
except ApiError as error: except ApiError as error:
if self.trace: if self.trace:
self.trace.emit("error", operation, request_id=identifier, url=url, message=str(error)) self.trace.emit("error", operation, request_id=identifier, url=url, message=str(error))
@@ -198,7 +210,7 @@ class Client:
except requests.RequestException as error: except requests.RequestException as error:
if self.trace: if self.trace:
self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error)) 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: except (ValueError, TypeError) as error:
if self.trace: if self.trace:
self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error)) self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error))
+1 -1
View File
@@ -990,8 +990,8 @@ class Engine:
def keep_alive(self): def keep_alive(self):
if self.demo: if self.demo:
return "离线演示无需心跳" return "离线演示无需心跳"
self.last_heartbeat = time.monotonic()
self.client.call("heartBeatService/keepAlive") self.client.call("heartBeatService/keepAlive")
self.last_heartbeat = time.monotonic()
return "会话心跳已更新" return "会话心跳已更新"
@single_flight @single_flight
+10
View File
@@ -32,6 +32,14 @@ py -3 -m venv .venv-web
健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。重启、恢复会话或导入策略后仍需手动开启运行。 健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。重启、恢复会话或导入策略后仍需手动开启运行。
### 后台运行与断线处理
关闭网页或退出 Web 管理登录不会停止服务器上的账号监控和已开启策略。账号监控和策略执行由服务端管理;“停止”策略后仍保留状态监控,退出游戏账号或停止服务后结束监控。
账号状态区分游戏在线、临时故障重试、游戏登录过期和未连接,显示最后成功通信时间及具体原因。临时网络故障采用退避后的只读状态检查;无法确认的操作保留核对记录,不自动重复提交。游戏会话失效后停止策略和游戏轮询,需在登录页重新登录或恢复有效会话;成功恢复后仍需手动开启策略。
服务重启会保留配置与加密会话,但不会自动连接游戏或恢复策略。登录页与运行日志会提示需要恢复会话。普通运行日志在各账号目录中限量持久保存,服务重启后仍可查看;调试请求详情仅在当前进程中按原有上限缓存。页面展示旧角色数据时会标注缓存状态,不把页面刷新视作游戏连接成功。
## Linux Python 与环境变量 ## Linux Python 与环境变量
```sh ```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个后端模块,避免发现并混入浏览器测试: 独立管理登录页调整后的完整非浏览器后端验证为 **193项:192通过、1跳过(Windows符号链接权限),0失败/错误,用时26.994秒**。以下命令显式列出全部10个后端模块,避免发现并混入浏览器测试:
```console ```console
+242
View File
@@ -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
+3 -1
View File
@@ -576,8 +576,10 @@ def create_app(data_dir=None, manager=None, config=None, updates=None) -> FastAP
def public_summary(value): def public_summary(value):
if not isinstance(value, dict): if not isinstance(value, dict):
raise HTTPException(500, "账号状态返回格式不正确") 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["error"] = public_error(result["error"])
result["connection_message"] = public_error(result["connection_message"])
player = value.get("player") 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 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) return public(result)
+20
View File
@@ -19,6 +19,24 @@ class AccountSchedule:
self.next_fast = {kind: math.inf for kind in FAST_KINDS} self.next_fast = {kind: math.inf for kind in FAST_KINDS}
self.monitoring = False self.monitoring = False
self.last_maintenance_error = {} 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): def monitor(self, enabled=True):
self.monitoring = bool(enabled) self.monitoring = bool(enabled)
@@ -69,6 +87,8 @@ class AccountSchedule:
def due(self, engine, config, running): def due(self, engine, config, running):
now = self.clock() 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): def allowed(kind):
return now - self.last_maintenance_error.get(kind, -math.inf) >= 30 return now - self.last_maintenance_error.get(kind, -math.inf) >= 30
+187 -13
View File
@@ -35,20 +35,23 @@ from __future__ import annotations
from collections import OrderedDict, deque from collections import OrderedDict, deque
from copy import copy, deepcopy from copy import copy, deepcopy
from dataclasses import asdict, dataclass from dataclasses import asdict, dataclass
from datetime import datetime, timezone from datetime import datetime, timedelta, timezone
import json import json
import math import math
import re import re
import threading import threading
import uuid 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.battles import CancelledBeforeDispatch
from ranch_assistant.debug import TraceLog, sensitive from ranch_assistant.debug import TraceLog, sensitive
from ranch_assistant.engine import Engine from ranch_assistant.engine import Engine
from ranch_assistant.login import PasswordLogin from ranch_assistant.login import PasswordLogin
from ranch_assistant.model import Catalog from ranch_assistant.model import Catalog
from .activity import ActivityLog, ActivityLogError
from .policies import apply_config, default_config, validate_config from .policies import apply_config, default_config, validate_config
from .scheduler import AccountSchedule, FAST_KINDS, Scheduler from .scheduler import AccountSchedule, FAST_KINDS, Scheduler
from .store import WebStore, session_identity from .store import WebStore, session_identity
@@ -143,10 +146,19 @@ class AccountWorker:
self._secrets = set() self._secrets = set()
self._pending = deque() self._pending = deque()
self._jobs = OrderedDict() 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_entries = OrderedDict()
self._debug_bytes = 0 self._debug_bytes = 0
self._log_sequence = 0
self._views = OrderedDict() self._views = OrderedDict()
self._view_jobs = {} self._view_jobs = {}
self._view_epoch = 0 self._view_epoch = 0
@@ -166,12 +178,21 @@ class AccountWorker:
self._restore_factory = getattr(manager.login_factory, "client_factory", Client) self._restore_factory = getattr(manager.login_factory, "client_factory", Client)
self.active_identity = None self.active_identity = None
self.error = "" 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.schedule = AccountSchedule()
self.state_root = self.state = manager.store.role_root(self.id, demo=self.demo) 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.config, self.revision = self._load_config(self.state_root)
self.trace = WebTrace(self) self.trace = WebTrace(self)
self.engine = self._engine() self.engine = self._engine()
self._summary = self._make_summary() 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 = threading.Thread(target=self._run, name="ranch-web-" + self.id[:8], daemon=True)
self.thread.start() self.thread.start()
self.enqueue("__initialize", {}, internal=True) self.enqueue("__initialize", {}, internal=True)
@@ -240,8 +261,27 @@ class AccountWorker:
entry = {"time": datetime.now(timezone.utc).isoformat(timespec="milliseconds"), entry = {"time": datetime.now(timezone.utc).isoformat(timespec="milliseconds"),
"message": self.safe_text(message), "debug": bool(debug), "level": "debug" if debug else "info"} "message": self.safe_text(message), "debug": bool(debug), "level": "debug" if debug else "info"}
with self.lock: with self.lock:
try:
if self._activity_warning:
# Confirm an actual durable write before declaring recovery;
# debug appends within a reserved block alone need no IO.
recovered = self._activity.append({"time": entry["time"], "debug": False, "level": "info",
"message": "运行日志持久化已恢复;降级期间的日志仅保留在内存"}, after_sequence=self._log_sequence)
self._logs.append(recovered)
self._log_sequence = recovered["seq"]
self._activity_warning = False
entry = self._activity.append(entry, after_sequence=self._log_sequence)
except ActivityLogError:
# Keep retrying the same writer on later events. Logging must
# never replace a dispatched game's result or original error.
if not self._activity_warning:
self._activity_warning = True
self._log_sequence += 1 self._log_sequence += 1
entry["id"] = entry["seq"] = self._log_sequence 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) self._logs.append(entry)
return entry["id"] return entry["id"]
@@ -275,9 +315,73 @@ class AccountWorker:
player[field] = master.get(field, 0) player[field] = master.get(field, 0)
player["name"] = master.get("roleName") or master.get("masterName") or master.get("name", "") 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)) 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, "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): def status(self):
with self.lock: with self.lock:
@@ -386,17 +490,22 @@ class AccountWorker:
self._active = self._execution = job self._active = self._execution = job
job.status = "running" job.status = "running"
final_status, final_error, public_result = "succeeded", "", None final_status, final_error, public_result = "succeeded", "", None
failure_sequence = self._game_failure_sequence
try: try:
result = self._execute(job) result = self._execute(job)
public_result = self.public_json(result) public_result = self.public_json(result)
with self.lock: if failure_sequence != self._game_failure_sequence:
self.error = "" final_status, final_error = "failed", self._last_game_error_message
except CancelledBeforeDispatch: except CancelledBeforeDispatch:
final_status, final_error = "cancelled", "未发送的操作已取消;已发请求保留核对记录" final_status, final_error = "cancelled", "未发送的操作已取消;已发请求保留核对记录"
except Exception as error: 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 final_status, final_error = "failed", message
with self.lock: with self.lock:
if self.connection_state not in {"expired", "retrying"} and not (
self.engine.client is not None and job.operation in {"login", "enter_server", "restore_session"}):
self.error = message self.error = message
if job.consuming: if job.consuming:
self.stop() self.stop()
@@ -443,6 +552,8 @@ class AccountWorker:
self.config, self.revision = self._load_config(self.state_root) self.config, self.revision = self._load_config(self.state_root)
self.active_identity = saved self.active_identity = saved
self.engine = self._engine() self.engine = self._engine()
self.connection_message = "服务已启动或重启;已保留保存的会话,请手动恢复会话或重新登录,策略保持停止"
self.log(self.connection_message)
if self.demo: if self.demo:
self.result(*self.engine.poll()) self.result(*self.engine.poll())
self.schedule.monitor(True) self.schedule.monitor(True)
@@ -462,8 +573,9 @@ class AccountWorker:
return getattr(self, "_" + operation)(payload) return getattr(self, "_" + operation)(payload)
if job.workspace != self._workspace(): if job.workspace != self._workspace():
raise RevisionConflict("账号角色已切换,原角色的操作未执行;请刷新后重试") raise RevisionConflict("账号角色已切换,原角色的操作未执行;请刷新后重试")
if not self.demo and not self.engine.client and operation not in LOCAL_ACTIONS: local = operation in LOCAL_ACTIONS or operation == "refresh" and payload.get("page") in {"statistics", "yields", "plans"}
raise ValueError("尚未连接游戏角色,请先登录并选择区服或恢复会话") if not self.demo and not local:
self._require_game()
from .actions import execute_action from .actions import execute_action
# A manual refresh previews state while the chosen execution switch stays on. # A manual refresh previews state while the chosen execution switch stays on.
self.engine.auto = False self.engine.auto = False
@@ -573,6 +685,17 @@ class AccountWorker:
return None return None
auto = False auto = False
try: 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 kind in FAST_KINDS:
if not self._set_auto(True): if not self._set_auto(True):
return None return None
@@ -616,11 +739,13 @@ class AccountWorker:
if not isinstance(client.session, Session): if not isinstance(client.session, Session):
raise ValueError("登录客户端未提供受支持的会话") raise ValueError("登录客户端未提供受支持的会话")
self.remember(asdict(client.session)) self.remember(asdict(client.session))
self._share_session_counters(client.session)
client.trace = self.trace client.trace = self.trace
self._session_write_error = "" self._session_write_error = ""
def persist(current): def persist(current):
try: try:
self._share_session_counters(current)
self.securestore.save(current, self._session_label(current)) self.securestore.save(current, self._session_label(current))
self._last_persisted_session = self._session_stamp(current) self._last_persisted_session = self._session_stamp(current)
self._session_write_error = "" self._session_write_error = ""
@@ -634,13 +759,42 @@ class AccountWorker:
def guarded_call(*args, **kwargs): def guarded_call(*args, **kwargs):
self.check_intent() 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 # A repaired directory may be retried. Client.persist_session
# sets this before Trace.begin blocks an unsafe dispatch. # sets this before Trace.begin blocks an unsafe dispatch.
self._session_write_error = "" 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.call = guarded_call
client._ranch_web_owner = self 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) http = getattr(client, "http", None)
if http is not None: if http is not None:
def guarded_transport(method): def guarded_transport(method):
@@ -659,6 +813,18 @@ class AccountWorker:
setattr(http, name, guarded_transport(method)) setattr(http, name, guarded_transport(method))
return client 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): def _session_label(self, session):
role = "" role = ""
if self.engine.client is not None and self.engine.client.session is session and self.engine.snapshot: 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) self.manager._release_identity(self, previous_identity)
if old_client is not None and old_client is not client: if old_client is not None and old_client is not client:
old_client.close() old_client.close()
self._game_succeeded()
return {"connected": True, "running": False, "has_saved_password": self._has_saved_password} return {"connected": True, "running": False, "has_saved_password": self._has_saved_password}
def _login(self, payload): def _login(self, payload):
@@ -843,6 +1010,11 @@ class AccountWorker:
with self.lock: with self.lock:
self._servers = [] self._servers = []
self.schedule.monitor(False) 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._refresh_login_metadata()
self._invalidate_views(clear=True) self._invalidate_views(clear=True)
return {"connected": False, "running": False} return {"connected": False, "running": False}
@@ -856,6 +1028,8 @@ class AccountWorker:
def _start(self, payload): def _start(self, payload):
self.check_intent() self.check_intent()
if not self.demo:
self._require_game()
if self.engine.snapshot is None or not (self.demo or self.engine.client): if self.engine.snapshot is None or not (self.demo or self.engine.client):
raise ValueError("请先登录并选择区服或打开离线演示") raise ValueError("请先登录并选择区服或打开离线演示")
value = validate_config(self.config) value = validate_config(self.config)
+105 -24
View File
@@ -4,20 +4,77 @@ import {el, $, $$, clone, getPath, setPath, pathKey, textValue, number, chinaTim
import {PageView, PAGES} from './pages.js'; import {PageView, PAGES} from './pages.js';
import {notice, dialog, confirm, filePicker, fileBase64} from './ui.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 current = () => state.accounts.get(state.active);
const currentPage = () => { const account=current(); return account?.pages.get(account.page); }; const currentPage = () => { const account=current(); return account?.pages.get(account.page); };
const terminal = new Set(['succeeded','failed','cancelled']); const terminal = new Set(['succeeded','failed','cancelled']);
const jobLabels = {queued:'排队中',running:'执行中',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 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) { 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, 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 setStatus(message) { state.statusMessage=message;renderStatus(); }
function error(error) { if(state.redirecting)return;notice(error.message || String(error),true); setStatus(error.message || String(error)); } 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() { function renderAccountTabs() {
const root=$('#account-tabs'); 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'})); 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); 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-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.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() { function renderSummary() {
const account=current(),summary=account?.summary,player=summary?.player || {}; const account=current(),summary=account?.summary,player=summary?.player || {};
const connected=summary?.connected,demo=summary?.demo; const kind=connectionState(summary),connected=gameAvailable(account),demo=summary?.demo,details=connectionDetails(account);
$('#connection').textContent=demo?'离线演示':connected?'已登录':'未登录'; $('#connection').textContent=state.webStatusError || account?.transportErrors.has('status')?'Web 状态重试中':demo?'离线演示':connectionLabels[kind];
$('#connection').className=`connection${demo?' demo':connected?' online':''}`; $('#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 || ''; $('#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]); 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)}`; $('#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; $('#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.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); if (account?.config && document.activeElement!==$('#refresh-interval')) $('#refresh-interval').value=String(account.config.interval);
$('#refresh-interval').disabled=!account?.config; $('#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; const task=account?[...account.jobs.values()].at(-1)?.job:null;
$('#job-status').textContent=task?`${operationLabels[task.operation] || task.operation} · ${jobLabels[task.status]}`:summary?.busy?'后台任务执行中':''; $('#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); syncSaveStatus(account);
} }
@@ -164,30 +226,35 @@ async function pollJob(account,record) {
if(record.polling)return;record.polling=true; if(record.polling)return;record.polling=true;
try { try {
const job=await api.job(account.id,record.job.id);record.job=job; const job=await api.job(account.id,record.job.id);record.job=job;
account.transportErrors.delete(`job:${job.id}`);
if(terminal.has(job.status)){ if(terminal.has(job.status)){
account.jobs.delete(job.id); account.jobs.delete(job.id);
if(job.status==='succeeded')record.resolve(job.result); if(job.status==='succeeded')record.resolve(job.result);
else record.reject(new Error(job.error || '任务已取消')); 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();} finally{record.polling=false;renderSummary();}
} }
async function perform(account,operation,payload={},options={}) { async function perform(account,operation,payload={},options={}) {
if(!account)throw new Error('请先新增或选择一个账号。'); if(!account)throw new Error('请先新增或选择一个账号。');
if(gameRefreshOperations.has(operation) && !gameAvailable(account))throw connectionError(account);
if(operation==='start'){ if(operation==='start'){
const invalid=account.pages.get(account.page)?.root.querySelector(':invalid'); const invalid=account.pages.get(account.page)?.root.querySelector(':invalid');
if(invalid){invalid.reportValidity();throw new Error('请先完成当前输入,再开启策略。');} if(invalid){invalid.reportValidity();throw new Error('请先完成当前输入,再开启策略。');}
} }
if(operation!=='stop')await flushConfig(account); if(operation!=='stop')await flushConfig(account);
if(gameRefreshOperations.has(operation) && !gameAvailable(account))throw connectionError(account);
const job=await api.action(account.id,operation,payload); 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); const result=await trackJob(account,job);
if(!state.accounts.has(account.id))return result; if(!state.accounts.has(account.id))return result;
if(result?.config){account.config=clone(result.config);account.revision=result.revision;} 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); 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(); 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); 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==='login'&&result)account.pages.get('login')?.login?.update(result);
if(operation==='enter_server'||operation==='restore_session')notice('已读取角色。策略保持关闭,请配置功能后开启。'); if(operation==='enter_server'||operation==='restore_session')notice('已读取角色。策略保持关闭,请配置功能后开启。');
@@ -206,14 +273,16 @@ function getPage(account,key) {
} }
async function loadPage(page,force=false) { 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;} if(page.fetching){if(force)page.reload=true;return;}
page.fetching=true;const generation=page.generation || 0; page.fetching=true;const generation=page.generation || 0;
try { try {
const response=await api.view(page.account.id,page.key,page.query); const response=await api.view(page.account.id,page.key,page.query);
if(generation!==(page.generation||0))return; if(generation!==(page.generation||0))return;
page.clearError();page.render(response.data,response.loading);page.lastLoad=Date.now(); page.clearError();page.render(response.data,response.loading);page.lastLoad=Date.now();
if(response.loading){clearTimeout(page.loadTimer);page.loadTimer=setTimeout(()=>loadPage(page),650);} transportError(page.account,`view:${page.key}`,'页面数据',null);renderPageConnection(page);
}catch(failure){page.showError(failure.message);} 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);}} 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==='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==='save'){await flushConfig(account);notice('策略已保存。');return;}
if(name==='stop'||name==='start')return await perform(account,name); 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.length<accounts.length)notice('已跳过未连接游戏的账号,请在登录页登录或恢复会话。',true);
return;
}
if(name==='logout')return await perform(account,'logout'); if(name==='logout')return await perform(account,'logout');
if(name==='forget-login'){ if(name==='forget-login'){
if(await confirm('退出并清除登录记录','将退出当前角色,删除当前账号保存的登录会话和账号密码。培养策略和其他账号不受影响。',{confirm:'清除登录记录',danger:true}))await perform(account,'forget_login');return; if(await confirm('退出并清除登录记录','将退出当前角色,删除当前账号保存的登录会话和账号密码。培养策略和其他账号不受影响。',{confirm:'清除登录记录',danger:true}))await perform(account,'forget_login');return;
@@ -435,7 +510,8 @@ async function fetchLogs(account) {
account.logs.entries.push(...(response.entries || []).filter(entry=>entry.id==null||!seen.has(entry.id)));account.logs.next=response.next; account.logs.entries.push(...(response.entries || []).filter(entry=>entry.id==null||!seen.has(entry.id)));account.logs.next=response.next;
if(account.id===state.active)renderLogs(); 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);} 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) { async function showDebugEntry(account,entry) {
@@ -455,11 +531,14 @@ function showNoAccounts() {
} }
async function syncAccounts() { 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)); 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);} 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=>{ 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)); else state.accounts.set(summary.id,makeAccount(summary));
}); });
renderAccountTabs();renderSummary(); renderAccountTabs();renderSummary();
@@ -467,9 +546,11 @@ async function syncAccounts() {
} }
async function tick() { async function tick() {
if(state.ready)renderSummary();
if(!state.ready||state.polling)return;state.polling=true; if(!state.ready||state.polling)return;state.polling=true;
try{ 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);} 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;} }finally{state.polling=false;}
} }
@@ -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()
@@ -283,10 +283,17 @@ class WorkbenchBrowserTests(unittest.TestCase):
def test_fake_login_uses_servers_without_persisting_password(self): def test_fake_login_uses_servers_without_persisting_password(self):
payloads = [] payloads = []
login_result = {"servers": [{"id": 7, "name": "测试区", "role_name": "测试角色"}], "has_saved_password": True}
def route_login(route): def route_login(route):
payloads.append(route.request.post_data_json) 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}/actions/login", route_login)
self.page.route(f"**/api/accounts/{self.first}/views/login?*", route_login_view)
self.open() self.open()
panel = self.go("login") panel = self.go("login")
panel.get_by_label("游戏账号", exact=True).fill("offline-test") panel.get_by_label("游戏账号", exact=True).fill("offline-test")
+301
View File
@@ -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, "<redacted>")
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()
+10
View File
@@ -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.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) 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): 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}) response = self.client.post(self.url + "/actions/login", json={"account": "fake-account", "password": "GAME_PASSWORD", "remember": True})
self.assertEqual(response.status_code, 202) self.assertEqual(response.status_code, 202)
+442
View File
@@ -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)