fix: preserve strategy intent and recover accounts automatically

This commit is contained in:
AttilaNet
2026-11-11 19:37:15 +08:00
parent ccb945631d
commit 5c253d5cf9
26 changed files with 1628 additions and 236 deletions
+10 -4
View File
@@ -1,8 +1,8 @@
# 牧羊人之心牧场助手 · Web 2.0.3
# 牧羊人之心牧场助手 · Web 2.0.4
## 产品约束
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。本轮 Web 发布目标为 `2.0.3`,源码入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md)。
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。本轮 Web 发布目标为 `2.0.4`,源码入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md)。
使用者在 Windows 本机配置、验证,随后可在 Linux Docker 常驻运行。多个浏览器访问同一个管理员工作台;账号互相隔离,各账号串行执行,账号之间可以并行。
@@ -24,7 +24,13 @@
- 数据分析用真实 DTO 绘制 SVG 条形图,保留来源筛选、体力效率、样本和不确定性说明。没有样本时明确说明。
- 策略统一导入导出;收益 CSV/XLSX 导入与可用数据下载。错误展示具体原因,不把不支持的任务伪装成可执行任务。
- 帮助可检查 GitHub 正式版本并提交受控更新请求。未配置部署器时明确显示原因,更新提交不表示更新成功。
- 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,可在 2.0.3 发布就绪后直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器;升级完成后刷新网页以加载新版界面,安装结果以宿主机健康检查为准。
- 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,可在 2.0.4 发布就绪后直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器;升级完成后刷新网页以加载新版界面,安装结果以宿主机健康检查为准。
## 2.0.4 持续运行与自动恢复
账号登录后默认执行已勾选策略,只有用户点击“停止”才暂停;点击“开启”恢复。启停选择由服务端持久保存,掉线、重新登录、关闭网页或服务重启不会误改。停止策略不停止连接监控与自动重登。
网络超时先进行只读恢复检查,成功后继续策略;会话失效按登录页等待分钟数重新登录,失败继续等待重试。保存过登录记录的账号在服务启动时自动恢复;只有清除登录记录或删除账号才取消。原有未确认请求核对与禁止重放规则保留。
## 2.0.3 底部分类日志
@@ -47,7 +53,7 @@
- 同一账号共用日志拉取;浏览器缓存最多 1200 条,底部最多显示最近 600 条。已有分类与保守旧记录推断沿用原实现,无法明确归属的记录不补入登录或其他功能日志。
- 手动刷新成功时仅显示简短状态,详细日志只在原底部日志区查看,不弹出诊断提示或大段浮动消息,也不自动展开日志;错误与登录认证反馈沿用原有行为。
本补丁只调整日志展示与 Web 版本元数据,游戏玩法、策略及后端日志分类/持久化沿用现有实现。功能与验证范围见 [2.0.3 发布说明](../analysis/RELEASE_2_0_3.md)。
2.0.3 补丁只调整日志展示与 Web 版本元数据,游戏玩法、策略及后端日志分类/持久化沿用现有实现。功能与验证范围见 [2.0.3 发布说明](../analysis/RELEASE_2_0_3.md)。
## 安全与验证
+14 -15
View File
@@ -1,6 +1,6 @@
# Web 2.0.3 运行说明
# Web 2.0.4 运行说明
本轮 Web 发布目标 **2.0.3**,源码入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。
本轮 Web 发布目标 **2.0.4**,源码入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。
Web 采用 FastAPI / Uvicorn 和原生 HTML/CSS/ES 模块,无 Node、npm 或前端编译步骤,不安装 PySide6。页面和策略能力沿用现有核心,详细业务范围与原有限制见 [桌面使用说明](../ranch_assistant/README.md)。多浏览器连接同一个管理员工作台;一个服务实例内,各账号独立线程并行,同一账号操作串行。
@@ -10,7 +10,8 @@ Web 采用 FastAPI / Uvicorn 和原生 HTML/CSS/ES 模块,无 Node、npm 或
- [x] 保留账号页签、顶部数值与统一启停、可调日志;规则自动保存,配置与统计按账号/角色隔离,每次成功登录后自动执行已配置且已勾选的功能,可在顶部停止。
- [x] Windows Python 启动与离线演示;Web 导入链和依赖不使用 Qt,无 Node 构建步骤。
- [x] 提供 Linux Docker 与稳定 2.x 受控更新、停机备份及失败回滚脚本;历史 Linux Docker 部署、持久化权限、健康检查和定时更新检查烟测见下文。
- [x] 本轮发布目标为 `2.0.3`,保留桌面兼容;战斗模拟为近似模型,特殊关卡并非全部支持,真实游戏 API 验收范围不因版本号变更而扩大。
- [x] 本轮发布目标为 `2.0.4`,保留桌面兼容;战斗模拟为近似模型,特殊关卡并非全部支持,真实游戏 API 验收范围不因版本号变更而扩大。
- 2.0.4 修复掉线恢复后策略意外停止,启停选择跨重登与重启保留;登录记录存在即持续自动重登。详见 [本版发布说明](../analysis/RELEASE_2_0_4.md)。
- 2.0.3 修复 2.0.2 日志布局:所有页签复用原有底部日志区,按当前账号与功能筛选,默认收起;操作约定见 [产品说明](PRODUCT.md#203-底部分类日志),验收结果见 [发布说明](../analysis/RELEASE_2_0_3.md#验证)。
## Windows 本地运行
@@ -31,15 +32,15 @@ py -3 -m venv .venv-web
.\Start_Ranch_Web.cmd --demo --data-dir "$env:TEMP\ranch-web-demo-new" --no-browser
```
健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。手动选服、恢复会话及自动重登成功读取角色后,均默认开启策略,只执行已勾选的功能,子功能不会全选。顶部“停止”暂停策略,仍保留状态监控;可用“开启”继续。导入配置只替换规则并停止执行,下次成功登录仍会自动开启;服务重启后未成功登录时不直接执行。
健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。手动选服、恢复会话及自动重登成功读取角色后,均默认开启策略,只执行已勾选的功能,子功能不会全选。顶部“停止”暂停策略,仍保留状态监控;可用“开启”继续。登录后默认执行已勾选策略;只有手动“停止”才暂停,手动“开启”恢复。启停选择跨掉线、重新登录和服务重启保存,导入策略不会改变这个选择。
### 后台运行与断线处理
关闭网页或退出 Web 管理登录不会停止服务器上的账号监控和已开启策略。账号监控和策略执行由服务端管理;“停止”策略后仍保留状态监控,退出游戏账号或停止服务后结束监控。
关闭网页或退出 Web 管理登录不会停止服务器上的账号监控和已开启策略。账号监控、重登及策略执行都由服务端管理。手动“停止”只暂停策略,连接监控与掉线重登继续;该暂停在重新登录和服务重启后仍保留,点击“开启”恢复。
账号状态区分游戏在线、临时故障重试、游戏登录过期和未连接,显示最后成功通信时间及具体原因。临时网络故障采用退避后的只读状态检查;无法确认的操作保留核对记录,不自动重复提交。游戏会话失效后停止策略和游戏轮询,按自动重登录设置等待处理,或在登录页手动恢复;成功登录后自动执行已配置且已勾选的功能,可在顶部停止。仅获取区服候选、候选角色验证失败或会话恢复失败,均不显示为登录成功。
临时网络故障采用退避后的只读状态检查,确认角色连接恢复后自动继续原先启用的策略。会话失效时按登录页等待时长自动重新登录。账号状态区分用户暂停、临时恢复和请求待核对,心跳成功不等于策略已经运行;日志保留失败原因及恢复结果。未确认的消耗请求仍保留核对记录,不自动重复提交。
服务重启会保留配置与加密会话;未启用自动重登录时,需要手动恢复会话。普通运行日志在各账号目录中限量持久保存,服务重启后仍可查看;调试请求详情仅在当前进程中按原有上限缓存。页面展示旧角色数据时会标注缓存状态,不把页面刷新视作游戏连接成功。
服务重启会保留配置、加密会话及启停选择,并自动恢复有登录记录的账号。只有清除登录记录或移除账号才取消持续自动登录;缺少密码、区服或原角色信息时显示具体原因。运行日志按账号限量持久保存,旧角色数据会标注缓存状态。
### 底部分类日志(2.0.3)
@@ -55,13 +56,11 @@ py -3 -m venv .venv-web
### 掉线后自动重新登录
在“登录”页开启“掉线后自动重新登录”,设置等待时长,默认 **30 分钟**,修改后自动保存。该开关默认关闭,各账号独立配置。使用前请在游戏登录时勾选“记住账号和密码”,并成功进入目标区服;密码仍由服务端加密保存。
登录成功并保存原区服、原角色后,自动保持登录;“登录”页只需设置重登等待时长,默认 **30 分钟**,可改为 **10 分钟**,每账号独立保存。请勾选“记住账号和密码”,密码由服务端加密保存。旧版关闭的自动重登开关不再阻止已保存账号恢复登录。
登录偏好保存在本账号中,进入其他区服或退出登录后仍保留设置;便携策略导入导出不携带、也不覆盖该登录偏好。
掉线后从首次失败开始计时;普通只读重试不会延后重登时间。密码重登失败后按同一时长继续尝试,登录成功后仅执行原有已勾选功能;如果你手动停止过策略,则继续保持暂停。关闭浏览器不影响计时,退出游戏连接仍会安排恢复;彻底取消请清除登录记录或删除账号。
检测到掉线后,服务端按等待时长重新进行账号密码登录,回到原区服、原角色。登录页显示安排时间及执行结果,关闭浏览器不影响计时。临时网络故障的只读恢复检查继续运行,连接提前恢复后会取消重登录计划。重登录失败后按配置时长等待下一次尝试;缺少保存的密码或目标角色时会显示具体原因。
开启此功能且保留有效登录记录时,服务重启也会先等待所设时长,再尝试重登录;等待及失败阶段不执行策略。主动退出、清除登录记录或移除账号会取消自动计划。重登录成功读取原区服、原角色后,恢复状态监控并默认开启策略,自动执行已勾选功能,可点击顶部“停止”暂停。
登录偏好与策略启停不随便携策略导入导出,避免在其他账号误用。后台保留未确认请求证据,恢复连接不会重放这些请求。
## Linux Python 与环境变量
@@ -98,13 +97,13 @@ sh start-web.sh --no-browser
Web 检查固定官方 GitHub Releases 的稳定 `v2.x.y`,跳过桌面 1.x、未来 3.x、草稿和预发布。开发版本 `2.0.0.dev1` 可升级至同数字的正式 `v2.0.0`;没有正式 Web 2 发布时明确显示暂无更新。Windows 默认仅检查;Web “更新”按钮仅在宿主机显式启用并有有效只读心跳时可提交 `pending` 请求,安装、备份和回滚由宿主机执行。默认定时检查只通知,自动安装需操作者 opt-in。
已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,可在 2.0.3 稳定 Release 和正式镜像就绪、宿主机心跳有效后,直接通过“帮助 → 检查版本更新…”升级 **2.0.3**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。
已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,可在 2.0.4 稳定 Release 和正式镜像就绪、宿主机心跳有效后,直接通过“帮助 → 检查版本更新…”升级 **2.0.4**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。
## 离线验证
2.0.3 验证结果统一见 [发布说明](../analysis/RELEASE_2_0_3.md#验证),以下历史记录不计入本版验收。
2.0.4 验证结果统一见 [发布说明](../analysis/RELEASE_2_0_4.md#验证),以下历史记录不计入本版验收。
### 历史验证记录(不计入 2.0.3)
### 历史验证记录(不计入 2.0.4)
2.0.2 验证记录见 [历史发布说明](../analysis/RELEASE_2_0_2.md#验证)。
+1 -1
View File
@@ -1,6 +1,6 @@
"""Headless Web workspace for the ranch assistant."""
__version__ = "2.0.3"
__version__ = "2.0.4"
GAME_VERSION = "1.9.68"
__all__ = ["__version__", "GAME_VERSION"]
+43 -14
View File
@@ -1,6 +1,7 @@
"""Desktop scheduling semantics without Qt timers or concurrent Engine access."""
from __future__ import annotations
import logging
import math
import random
import threading
@@ -8,6 +9,7 @@ import time
FAST_KINDS = ("hatch", "gift", "explore", "breakthrough")
logger = logging.getLogger(__name__)
class AccountSchedule:
@@ -17,6 +19,7 @@ class AccountSchedule:
self.clock, self.uniform = clock, uniform
self.wall_clock = wall_clock
self.next_poll = math.inf
self._poll_deferred = False
self.next_fast = {kind: math.inf for kind in FAST_KINDS}
self.monitoring = False
self.last_maintenance_error = {}
@@ -43,7 +46,7 @@ class AccountSchedule:
return None
origin = max(self.disconnected_at, self.auto_relogin_failed_at
if self.auto_relogin_failed_at is not None else self.disconnected_at)
return origin + preference["delay_minutes"] * 60
return origin + preference.get("delay_minutes", 30) * 60
def auto_relogin_failed(self):
# Back off from completion, including time spent authenticating.
@@ -59,15 +62,21 @@ class AccountSchedule:
self.retry_deadline = self.clock() + delay
return delay
def game_resumed(self):
def game_resumed(self, *, clear_disconnection=True):
"""Resume monitored reads; the service decides if outage evidence clears."""
was_paused = self.game_paused
self.game_paused = False
self.retry_deadline = None
self.retry_attempt = 0
self.clear_disconnection()
if clear_disconnection:
self.clear_disconnection()
if self.monitoring and (was_paused or self.next_poll == math.inf):
self.next_poll = min(self.next_poll, self.clock())
def monitor(self, enabled=True):
self.monitoring = bool(enabled)
self.next_poll = self.clock() if enabled else math.inf
self._poll_deferred = False
def stop(self):
for kind in FAST_KINDS:
@@ -75,6 +84,7 @@ class AccountSchedule:
def poll_finished(self, config):
self.next_poll = self.clock() + self.uniform(0, config.get("interval", 30))
self._poll_deferred = False
def maintenance_failed(self, kind):
self.last_maintenance_error[kind] = self.clock()
@@ -83,7 +93,7 @@ class AccountSchedule:
if completed in self.next_fast:
self.next_fast[completed] = math.inf
snapshot = engine.snapshot
if not self.monitoring or not running or snapshot is None:
if not self.monitoring or self.game_paused or not running or snapshot is None:
self.stop()
return
now = self.clock()
@@ -123,22 +133,35 @@ class AccountSchedule:
def allowed(kind):
return now - self.last_maintenance_error.get(kind, -math.inf) >= 30
poll_due = self.monitoring and now >= self.next_poll and allowed("poll")
if not poll_due:
self._poll_deferred = False
elif self._poll_deferred:
return "poll"
def before_poll(kind):
# Preserve maintenance/hatch priority once, then give an overdue
# snapshot its turn even if the preceding work remains due.
if poll_due:
self._poll_deferred = True
return kind
connected = not engine.demo and engine.client is not None and engine.snapshot is not None
if connected and engine.heartbeat_enabled and now - engine.last_heartbeat >= 240 and allowed("heartbeat"):
return "heartbeat"
return before_poll("heartbeat")
if connected and self.monitoring and engine.pending_recovery_due() and allowed("reconcile"):
return "reconcile"
return before_poll("reconcile")
if connected and engine.heartbeat_enabled and engine.master_sync_due() and allowed("master_sync"):
return "master_sync"
return before_poll("master_sync")
if connected and engine.heartbeat_enabled and engine.growth_sync_due() and allowed("growth_sync"):
return "growth_sync"
if self.monitoring and running and now >= self.next_fast["hatch"]:
return "hatch"
if self.monitoring and now >= self.next_poll:
return before_poll("growth_sync")
if self.monitoring and running and now >= self.next_fast["hatch"] and allowed("hatch"):
return before_poll("hatch")
if poll_due:
return "poll"
if self.monitoring and running:
for kind in ("gift", "explore", "breakthrough"):
if now >= self.next_fast[kind]:
if now >= self.next_fast[kind] and allowed(kind):
return kind
return None
@@ -155,8 +178,14 @@ class Scheduler:
def _run(self):
while not self.closed.wait(self.interval):
for worker in self.workers():
worker.request_tick()
try:
for worker in self.workers():
try:
worker.request_tick()
except Exception:
logger.exception("Unable to request account tick; continuing other accounts")
except Exception:
logger.exception("Unable to enumerate account workers; retrying next scheduler pass")
def close(self):
self.closed.set()
+243 -35
View File
@@ -50,13 +50,13 @@ from ranch_assistant.battles import CancelledBeforeDispatch
from ranch_assistant.debug import TraceLog, sensitive
from ranch_assistant.engine import Engine
from ranch_assistant.login import PasswordLogin
from ranch_assistant.model import Catalog
from ranch_assistant.model import Catalog, seconds
from .activity import ActivityLog, ActivityLogError
from .log_categories import endpoint_category, legacy_category, normalize_category, note_hints, operation_category, route_message
from .policies import apply_config, default_config, validate_config
from .scheduler import AccountSchedule, FAST_KINDS, Scheduler
from .store import WebStore, session_identity
from .store import WebStore, _unlinked, atomic_json, session_identity
PAGES = frozenset("login incubator bag ranch daily hatching mainline battles gifts commissions exploration maps statistics plans yields".split())
@@ -172,6 +172,14 @@ class AccountWorker:
self._view_epoch = 0
self._generation = 0
self._running = False
self._intent_error = ""
self._legacy_pending = {}
self._run_intents = self._load_run_intents()
self._execution_retry_deadline = None
self._execution_retry_at = None
self._execution_retry_attempt = 0
self._execution_error = ""
self._execution_block = ""
self._closing = False
self._active = None
self._execution = None
@@ -222,8 +230,163 @@ class AccountWorker:
login = self.manager.store.load_config(self._login_settings_root)
if login:
value["auto_relogin"] = validate_config(login["config"])["auto_relogin"]
# A saved role is durable keep-login authorization. Old releases used
# enabled=False as their default; it was never an explicit account clear.
if re.fullmatch(r"[a-f0-9]{64}", folder.name):
value["auto_relogin"]["enabled"] = True
return value, revision
def _load_run_intents(self):
try:
path = _unlinked(self.profile_root / "run_intent.json")
if not path.exists():
return {}
value = json.loads(path.read_text(encoding="utf-8"))
if (not isinstance(value, dict) or value.get("schema") != 1
or not isinstance(value.get("roles"), dict)
or any(not isinstance(scope, str) or not re.fullmatch(r"[a-f0-9]{64}|demo|disconnected", scope)
or type(requested) is not bool for scope, requested in value["roles"].items())):
raise ValueError("invalid run intent")
pending = value.get("legacy_pending", {})
if (not isinstance(pending, dict) or any(not re.fullmatch(r"[a-f0-9]{64}", scope)
or not isinstance(record, dict) or record.get("kind") not in {"gift", "hatch", "feed"}
or not isinstance(record.get("evidence"), dict) for scope, record in pending.items())):
raise ValueError("invalid pending evidence")
self._legacy_pending = pending
return value["roles"]
except (OSError, ValueError, TypeError):
self._intent_error = "运行意愿记录无法读取;已保留原文件,请检查 Web 数据目录后重试"
return {}
@property
def strategy_requested(self):
# Missing records migrate to enabled. Transient running=False from an
# old process is not evidence that the user pressed Stop.
if self.demo:
return self._run_intents.get("demo", False)
return self._run_intents.get(self._workspace(), self._run_intents.get("disconnected", True))
def _set_strategy_requested(self, requested):
"""Only the explicit manager Stop and Start paths may call this."""
with self.lock:
if requested:
# The Start may have waited behind persistence while a later
# synchronous Stop revoked its generation.
self.check_intent()
if self._intent_error:
raise OSError(self._intent_error)
self._run_intents[self._workspace()] = bool(requested)
self._save_run_intents()
def _save_run_intents(self):
try:
atomic_json(self.profile_root / "run_intent.json", {"schema": 1, "roles": self._run_intents,
"legacy_pending": self._legacy_pending})
except (OSError, ValueError):
self._intent_error = "运行意愿或待核对记录无法持久保存;请检查 Web 数据目录"
raise OSError(self._intent_error) from None
def _legacy_write(self, path, payload):
"""Fence only three legacy writes lacking Engine's durable journals."""
if path not in {"monsterService/monsterSendGift", "stackService/stackAddMonster", "monsterService/monsterIntensify"}:
return None
if not self.active_identity or self.engine.snapshot is None:
return None
if self.active_identity in self._legacy_pending:
raise ValueError("上次赠礼、装填或喂养请求待核对,禁止自动重发")
payload = payload or {}
if path == "monsterService/monsterSendGift":
mid = int(payload["monsterId"])
evidence = {"monster": mid, "gift_time": seconds(self.engine.snapshot.monsters[mid].get("giftTime"))}
kind = "gift"
elif path == "stackService/stackAddMonster":
stacks = {int(row["id"]): int(row.get("monsterId") or 0) for row in self.engine.snapshot.raw.get("stacks", [])}
evidence = {str(egg["stackId"]): stacks[int(egg["stackId"])] for egg in payload["eggs"]}
kind = "hatch"
elif path == "monsterService/monsterIntensify" and payload.get("foods"):
evidence = {"foods": list(payload["foods"])}
kind = "feed"
else:
return None
with self.lock:
self._legacy_pending[self.active_identity] = {"kind": kind, "evidence": evidence}
self._save_run_intents() # A failure here prevents sending the write.
return self.active_identity
def _reconcile_legacy_write(self, snapshot, identity):
# Raw server snapshots precede Engine's local optimistic gift/growth
# overlays. An unchanged read, heartbeat or elapsed time is not proof.
with self.lock:
record = self._legacy_pending.get(identity)
if not record:
return
evidence, kind = record["evidence"], record["kind"]
if kind == "gift":
mon = snapshot.monsters.get(int(evidence["monster"]))
confirmed = mon is None or seconds(mon.get("giftTime")) > seconds(evidence["gift_time"])
elif kind == "feed":
confirmed = all(int(mid) not in snapshot.monsters for mid in evidence["foods"])
else:
stacks = {str(row["id"]): int(row.get("monsterId") or 0) for row in snapshot.raw.get("stacks", [])}
confirmed = bool(evidence) and all(stacks.get(slot, 0) > 0 and stacks[slot] != previous
for slot, previous in evidence.items())
if confirmed:
self._legacy_pending.pop(identity)
self._save_run_intents()
def _pending_execution_reason(self):
if self.active_identity in self._legacy_pending:
return "赠礼、装填或喂养请求结果待核对,禁止自动重发;后台继续读取游戏状态,确认后自动恢复已勾选策略"
if self.engine.snapshot is not None and (self.engine._progression_pending()
or self.engine.explore_planner.pending(self.engine.snapshot) or self.engine._breakthrough_pending):
return "存在未确认的任务、战斗、探险或突破请求,禁止自动重发;后台继续核对,核对完成后恢复已勾选策略"
return ""
def _refresh_execution(self):
"""Rearm desired execution, never grant writes to a read-only callback."""
with self.lock:
self._execution_block = self._intent_error or self._pending_execution_reason()
ready = self.demo or self.connection_state == "online" and self.engine.client is not None
if ready and self.engine.snapshot is not None and not self.schedule.monitoring:
self.schedule.monitor(True)
if self._execution_retry_deadline is not None and self.schedule.clock() >= self._execution_retry_deadline:
self._execution_retry_deadline = self._execution_retry_at = None
self._running = bool(self.strategy_requested and ready and self.engine.snapshot is not None
and not self._execution_block and self._execution_retry_deadline is None
and not self._closing and not self.manager._closing and not getattr(self, "_session_write_error", ""))
if not self._running:
self.engine.auto = False
self.schedule.stop()
return self._running
def _strategy_status(self):
requested = self.strategy_requested
if not requested:
state, message = "stopped", "已按用户选择停止策略;离线后仍按配置间隔重登,点击开始可恢复策略"
elif self._execution_block:
state, message = "blocked", self._execution_block
elif self._execution_retry_deadline is not None:
state, message = "recovering", self._execution_error + ";等待退避后自动恢复已勾选策略"
elif self.connection_state == "retrying":
state, message = "recovering", self.connection_message
elif not self._running:
state, message = "offline", self.connection_message
else:
state, message = "running", "已勾选的策略将自动执行"
return {"strategy_requested": requested, "manual_stop": not requested,
"strategy_state": state, "strategy_message": self.safe_text(message),
"strategy_retry_at": self._execution_retry_at or (self.next_retry_at if requested else None)}
def _execution_failed(self, error):
self.stop()
if self._pending_execution_reason():
return
self._execution_retry_attempt += 1
delay = min(5 * 2 ** min(self._execution_retry_attempt - 1, 4), 60)
self._execution_retry_deadline = self.schedule.clock() + delay
self._execution_retry_at = (datetime.now(timezone.utc) + timedelta(seconds=delay)).isoformat(timespec="milliseconds")
self._execution_error = self.safe_text(str(error)) or type(error).__name__
def _engine(self, client=None, *, state_root=None, config=None):
state_root = self.state_root if state_root is None else state_root
config = self.config if config is None else config
@@ -425,7 +588,7 @@ class AccountWorker:
"demo": self.demo, "running": self._running, "busy": False, "player": player,
"revision": self.revision, "error": self.error, "connection_state": self.connection_state,
"connection_message": self.connection_message, "last_game_success_at": self.last_game_success_at,
"next_retry_at": self.next_retry_at, "auto_relogin_status": self._auto_relogin_status()})
"next_retry_at": self.next_retry_at, "auto_relogin_status": self._auto_relogin_status(), **self._strategy_status()})
def _auto_relogin_status(self):
with self.lock:
@@ -504,6 +667,7 @@ class AccountWorker:
# 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._execution_failed(error)
self.log(self.error, level="error")
return
self.engine.heartbeat_enabled = False
@@ -514,11 +678,11 @@ class AccountWorker:
self.next_retry_at = None
if expired:
self.connection_state = "expired"
message = "游戏会话已失效(408);策略已停止,游戏请求已暂停,请手动恢复会话或重新登录"
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} 秒后只读重试,未确认记录保留"
message = f"{reason};{delay} 秒后只读重试,连接恢复后自动继续已勾选策略,未确认记录保留"
self.next_retry_at = (datetime.now(timezone.utc) + timedelta(seconds=delay)).isoformat(timespec="milliseconds")
elif temporary:
self.connection_state = "offline"
@@ -546,6 +710,7 @@ class AccountWorker:
self._auto_relogin_blocked = False
self.schedule.game_resumed()
self.engine.heartbeat_enabled = True
self._refresh_execution()
if previous != "online" and not activated:
self.log("游戏连接已确认;" + ("已勾选的策略继续运行" if self.running else "策略保持停止"), category="login")
@@ -554,6 +719,7 @@ class AccountWorker:
result = deepcopy(self._summary)
result.update(running=self._running, busy=bool(self._active or self._pending))
result["auto_relogin_status"] = self._auto_relogin_status()
result.update(self._strategy_status())
return result
@property
@@ -675,13 +841,15 @@ class AccountWorker:
if self.connection_state not in {"expired", "retrying"} and not (
self.engine.client is not None and job.operation in {"login", "enter_server", "restore_session"}):
self.error = message
if job.consuming:
self.stop()
if (job.consuming and job.operation != "start"
and failure_sequence == self._game_failure_sequence):
self._execution_failed(error)
self.log(message, category=job.category, level="error")
finally:
job.payload = {}
try:
self._persist_session()
self._refresh_execution()
summary = self._make_summary()
except Exception as error:
self.stop()
@@ -722,12 +890,12 @@ class AccountWorker:
self.config, self.revision = self._load_config(self.state_root)
self.active_identity = saved
self.engine = self._engine()
self.connection_message = "服务已启动或重启;已保留保存的会话,请手动恢复会话或重新登录,策略保持停止"
self.connection_message = "服务已启动或重启;已保留会话与策略运行意愿,将等待配置分钟后重新登录原区服、原角色"
# Opt-in only: retain the known startup offline origin even
# while disabled, so enabling later can reuse that timestamp.
self._mark_disconnected(session, saved)
if self.config["auto_relogin"]["enabled"]:
self.connection_message = "服务已启动或重启;将等待配置分钟后使用保存的密码重新登录原区服、原角色,策略保持停止"
self.connection_message = "服务已启动或重启;将等待配置分钟后使用保存的密码重新登录原区服、原角色"
self.log(self.connection_message, category="login")
if self.demo:
self.result(*self.engine.poll())
@@ -791,6 +959,8 @@ class AccountWorker:
# login authorization. Never erase or enable this preference.
source["auto_relogin"] = deepcopy(self.config["auto_relogin"])
value = validate_config(source)
if self.active_identity and not self.demo:
value["auto_relogin"]["enabled"] = True
new_revision = self.revision + 1
self.manager.store.save_config(self.state_root, value, new_revision)
if self.state_root != self._login_settings_root:
@@ -802,8 +972,9 @@ class AccountWorker:
with self.lock:
self.config, self.revision = value, new_revision
# A policy job never clears cancellation or resurrects a stopped start.
self.engine.auto = bool(self._running and not self._closing and self._execution
and self._execution.generation == self._generation)
if not (self._running and not self._closing and self._execution
and self._execution.generation == self._generation):
self.engine.auto = False
self.schedule.poll_finished(value)
self.schedule.arm(self.engine, value, self._running, self.engine.plans() if self.engine.snapshot else ())
self._invalidate_views()
@@ -863,6 +1034,7 @@ class AccountWorker:
return active
def _tick(self, job):
self._refresh_execution()
kind = self.schedule.due(self.engine, self.config, self._running)
job.due_kind, job.category = kind, operation_category(kind)
if kind is None:
@@ -897,6 +1069,7 @@ class AccountWorker:
self.engine.snapshot = self.engine.client.snapshot()
finally:
self._retry_probe = False
self._refresh_execution()
self.schedule.poll_finished(self.config)
self._invalidate_views()
return {"kind": kind}
@@ -928,7 +1101,13 @@ class AccountWorker:
# while preserving the user's running switch. Only a pause
# by the current Engine generation turns that switch off.
if auto and job.generation == self._generation and not self.engine.auto:
self.stop()
if self._pending_execution_reason():
self.stop()
else:
self._execution_failed(ValueError(value[2] or "策略暂不可用"))
elif auto and job.generation == self._generation:
self._execution_retry_attempt = 0
self._execution_error = ""
self.schedule.arm(self.engine, self.config, self._running, value[1], completed=kind)
elif isinstance(value, str):
self._log_message(value)
@@ -1069,11 +1248,32 @@ class AccountWorker:
# A repaired directory may be retried. Client.persist_session
# sets this before Trace.begin blocks an unsafe dispatch.
self._session_write_error = ""
legacy = self._legacy_write(path, args[1] if len(args) > 1 else kwargs.get("payload")) if active else None
try:
response = original(*args, **kwargs)
except Exception as error:
if legacy is not None and (isinstance(error, CancelledBeforeDispatch)
or isinstance(error, ApiError) and error.code is not None):
# A decoded rejection did not apply the write; it needs
# bounded backoff and fresh planning, not uncertainty.
with self.lock:
self._legacy_pending.pop(legacy, None)
self._save_run_intents()
self._game_failed(error, client)
raise
if legacy is not None and path == "monsterService/monsterSendGift":
try:
feel, gifted_at = float(response["feel"]), seconds(response["giftDate"])
before = self._legacy_pending[legacy]["evidence"]["gift_time"]
confirmed = math.isfinite(feel) and feel >= 0 and math.isfinite(gifted_at) and gifted_at > before
except (KeyError, TypeError, ValueError):
confirmed = False
if confirmed:
# The same authoritative response used by GiftPlanner's
# cooldown is sufficient even if role reads lag behind.
with self.lock:
self._legacy_pending.pop(legacy, None)
self._save_run_intents()
path = args[0] if args else kwargs.get("path")
if active and path == "heartBeatService/keepAlive":
self._game_succeeded()
@@ -1091,6 +1291,7 @@ class AccountWorker:
except Exception as error:
self._game_failed(error, client)
raise
self._reconcile_legacy_write(snapshot, session_identity(client.session))
if client is self.engine.client:
self._game_succeeded()
return snapshot
@@ -1178,15 +1379,10 @@ class AccountWorker:
self.schedule.poll_finished(self.config)
self._game_succeeded(activated=True)
self._invalidate_views(clear=True)
# Activation and its new start authorization share the final
# generation check/lock. Never queue a start that could outlive
# a stop, logout or policy replacement during persistence.
try:
self._start({}, require_selection=False)
except ValueError as error:
message = login_message + ";策略保持停止:" + self.safe_text(str(error))
else:
message = login_message + ";策略已自动开启,仅执行已勾选的规则"
# A verified connection never changes durable user intent or
# grants writes to this authentication/read-only operation.
self._refresh_execution()
message = login_message + ";" + self._strategy_status()["strategy_message"]
result = {"connected": True, "running": self._running,
"has_saved_password": self._has_saved_password, "message": message}
self.log(message, category="login")
@@ -1312,20 +1508,19 @@ class AccountWorker:
client.close()
def _logout(self, payload):
identity = self.active_identity
session = (self.engine.client.session if self.engine.client is not None else
self.securestore.load(identity) if identity else None)
self._release_clients()
self.manager._release_identity(self)
self.active_identity = None
self.securestore.set_active(None)
self.state_root = self.state = self.manager.store.role_root(self.id, demo=self.demo)
config, revision = self._load_config(self.state_root)
self.config, self.revision = config, max(self.revision, revision) + 1
self.engine = self._engine()
with self.lock:
self._servers = []
self.schedule.monitor(False)
self.schedule.game_failed()
if session is not None:
self._mark_disconnected(session, identity)
self.connection_state = "offline"
self.connection_message = "已手动退出游戏;请登录或手动恢复保存的会话,策略保持停止"
self.connection_message = "已退出当前游戏连接;会话、密码与策略运行意愿已保留,将按配置间隔重新登录"
self.next_retry_at = None
self.error = ""
self._refresh_login_metadata()
@@ -1335,12 +1530,20 @@ class AccountWorker:
def _forget_login(self, payload):
self._logout(payload)
self.securestore.forget()
self.manager._release_identity(self)
self.active_identity = None
self.state_root = self.state = self.manager.store.role_root(self.id, demo=self.demo)
config, revision = self._load_config(self.state_root)
self.config, self.revision = config, max(self.revision, revision) + 1
self.engine = self._engine()
self.connection_message = "已清空保存的登录,不再自动重登;请重新登录并选择区服"
self._refresh_login_metadata()
self._invalidate_views()
return {"connected": False, "running": False, "has_saved_password": False}
def _start(self, payload, *, require_selection=True):
self.check_intent()
self._set_strategy_requested(True)
if not self.demo:
self._require_game()
if self.engine.snapshot is None or not (self.demo or self.engine.client):
@@ -1354,16 +1557,19 @@ class AccountWorker:
raise ValueError("请先勾选至少一项功能,并启用对应策略")
if require_selection and ranch and not other and not any(rule["enabled"] for rule in policy["egg_rules"].values()):
raise ValueError("请先在背包魔物蛋勾选要孵化的蛋,并设置优先级和孵出后的去向")
if (self.engine._progression_pending() or self.engine.explore_planner.pending(self.engine.snapshot)
or self.engine._breakthrough_pending):
raise ValueError("存在未确认的任务、战斗、探险或突破请求,禁止自动重发;请先核对")
reason = self._pending_execution_reason()
if reason:
raise ValueError(reason)
with self.lock:
self.check_intent()
self._running = self.engine.auto = True
self._execution_retry_deadline = self._execution_retry_at = None
self._execution_retry_attempt = 0
self._execution_error = ""
self._refresh_execution()
self.engine.heartbeat_enabled = True
self.schedule.monitor(True)
self._invalidate_views()
return {"running": True}
return {"running": self._running, **self._strategy_status()}
def _stop(self, payload):
# submit('stop') already made cancellation effective synchronously.
@@ -1513,12 +1719,14 @@ class WebManager:
with worker.condition:
if operation == "stop":
worker.stop()
worker._set_strategy_requested(False)
# Stop is complete before returning; it never waits behind a model.
job = _Job(uuid.uuid4().hex, operation, {}, worker._generation, status="succeeded", result={"running": False})
job = _Job(uuid.uuid4().hex, operation, {}, worker._generation, status="succeeded",
result={"running": False, **worker._strategy_status()})
worker._jobs[job.id] = job
return job.public()
if operation in STOP_ACTIONS or operation in {"login", "enter_server", "restore_session", "logout", "forget_login"}:
if operation in {"login", "enter_server", "restore_session", "logout", "forget_login"}:
if operation == "forget_login":
worker.suspend_auto_relogin()
worker.stop()
consuming = operation not in READ_ACTIONS and operation not in LOCAL_ACTIONS and operation not in {"logout", "forget_login"}
+51 -20
View File
@@ -22,6 +22,35 @@ function connectionState(summary) {
function gameAvailable(account) { return Boolean(account && !state.webStatusError && !account.transportErrors.has('status') && connectionState(account.summary)==='online'); }
function strategyRequested(summary) { return typeof summary?.strategy_requested==='boolean'?summary.strategy_requested:Boolean(summary?.running); }
function strategyDetails(account) {
if(!account)return '';
const summary=account.summary,requested=strategyRequested(summary);
if(!requested)return summary.strategy_requested===false?'策略已停止(用户暂停);暂停会保留到再次“开启”,账号仍会按设定时长自动重登。':'策略已停止,可在顶部“开启”继续执行已勾选功能。';
if(summary.strategy_state==='blocked')return `策略等待处理:${summary.strategy_message || '请检查执行结果,确认后再继续。'}`;
if(summary.running && gameAvailable(account))return '角色状态自动刷新,正在自动执行已配置且已勾选的功能;可在顶部“停止”。';
const parts=['已请求自动执行已勾选功能,等待恢复;可在顶部“停止”暂停执行。'];
if(summary.strategy_message)parts.push(summary.strategy_message);
const value=summary.strategy_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} 秒后检查策略恢复`:'等待策略恢复检查结果');
}
return parts.join(';');
}
function acceptSummary(account,summary) {
account.summary=summary;
// Keep the last observed failure separate from current connection health.
const kind=connectionState(summary);
const failure=summary.error || (['retrying','expired'].includes(kind)?summary.connection_message:'');
if(failure)account.lastFailure=failure;
}
function failureHistory(account) { return account?.lastFailure && connectionState(account.summary)==='online'?`上次失败:${account.lastFailure}`:''; }
function connectionReason(summary) {
return summary?.connection_message || summary?.error || {retrying:'游戏请求暂时失败,等待重试。',expired:'游戏登录状态已失效,请在登录页重新登录或恢复会话。',offline:'尚未连接游戏,请在登录页登录或恢复已保存会话。'}[connectionState(summary)] || '';
}
@@ -46,7 +75,8 @@ function connectionDetails(account) {
function transportMessages(account=current()) { return [...(account?.transportErrors.values() || [])]; }
function renderStatus() {
const message=[connectionDetails(current()),...transportMessages()].filter(Boolean).join(';') || state.statusMessage;
const account=current();
const message=[connectionDetails(account),typeof account?.summary.strategy_requested==='boolean'?strategyDetails(account):'',failureHistory(account),...transportMessages()].filter(Boolean).join(';') || state.statusMessage;
const node=$('#status-text');if(node.textContent!==message)node.textContent=message;node.title=message;
}
@@ -72,8 +102,9 @@ function renderPageConnection(page) {
}
function makeAccount(summary) {
return {id:summary.id,summary,config:null,revision:null,edits:new Map(),pages:new Map(),page:'login',jobs:new Map(),savePromise:null,saveError:null,
logs:createLogState(),loadingConfig:false,transportErrors:new Map()};
const account={id:summary.id,summary,config:null,revision:null,edits:new Map(),pages:new Map(),page:'login',jobs:new Map(),savePromise:null,saveError:null,
logs:createLogState(),loadingConfig:false,transportErrors:new Map(),lastFailure:''};
acceptSummary(account,summary);return account;
}
function setStatus(message) { state.statusMessage=message;renderStatus(); }
@@ -90,9 +121,9 @@ function renderAccountTabs() {
}
const summary=account.summary,selected=state.active===account.id,kind=connectionState(summary);
$('.account-label',button).textContent=summary.label || summary.player?.name || '账号';
$('.account-dot',button).className=`account-dot${summary.error || kind!=='online'?' error':summary.running?' running':''}`;
$('.account-dot',button).className=`account-dot${kind!=='online' || summary.strategy_state==='blocked'?' error':summary.running?' running':''}`;
button.setAttribute('aria-selected',String(selected));button.tabIndex=selected?0:-1;
button.title=[summary.label || '账号',summary.demo?'离线演示':connectionLabels[kind],summary.running?'策略运行中':'',kind==='online'?summary.error:connectionReason(summary)].filter(Boolean).join(' · ');
button.title=[summary.label || '账号',summary.demo?'离线演示':connectionLabels[kind],strategyDetails(account),kind==='online'?failureHistory(account):connectionReason(summary)].filter(Boolean).join(' · ');
});
}
@@ -113,9 +144,9 @@ function renderSummary() {
for (const [id,key] of [['player-level','level'],['player-money','money'],['player-ke','ke'],['player-ti','ti']]) $('#'+id).textContent=number(player[key]);
$('#player-exp').textContent=player.exp==null?'—':`${number(player.exp)} / ${number(player.next_exp)}`;
$('#experience-progress').max=Math.max(1,Number(player.next_exp)||1);$('#experience-progress').value=Number(player.exp)||0;
const run=$('#strategy-toggle');run.textContent=summary?.running?'停止':'开启';run.classList.toggle('running',Boolean(summary?.running));run.disabled=!account || !summary?.running && (!account.config || !connected);
run.setAttribute('aria-pressed',String(Boolean(summary?.running)));
run.title=summary?.running?'停止自动执行已勾选功能;取消尚未发送的请求':!connected?details:'开启后自动执行各页面已勾选功能';
const requested=strategyRequested(summary),run=$('#strategy-toggle');run.textContent=requested?'停止':'开启';run.classList.toggle('running',requested);run.disabled=!account || !requested && (!account.config || !connected);
run.setAttribute('aria-pressed',String(requested));
run.title=requested?'暂停自动执行已勾选功能,取消尚未发送的请求;掉线、重新登录和服务重启后仍保持暂停,直到再次“开启”;账号仍会自动重登。':!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);
@@ -123,7 +154,7 @@ function renderSummary() {
$('#refresh').disabled=!connected;$('#refresh').title=connected?'读取游戏状态并预览策略':details;
const task=account?[...account.jobs.values()].at(-1)?.job:null;
$('#job-status').textContent=task?`${operationLabels[task.operation] || task.operation} · ${jobLabels[task.status]}`:summary?.busy?'后台任务执行中':'';
const message=[details || summary?.error || (demo?'当前为离线演示,不连接游戏服务器。':connected?summary.running?'角色状态自动刷新,正在自动执行已配置且已勾选的功能;可在顶部“停止”。':'角色状态自动刷新;策略已停止,可在顶部“开启”继续执行已勾选功能。':'请在登录页输入账号密码,或恢复已保存会话。'),...transportMessages(account)].filter(Boolean).join(';');
const message=[demo?'当前为离线演示,不连接游戏服务器。':'',strategyDetails(account),details,failureHistory(account),...transportMessages(account)].filter(Boolean).join(';');
$('#data-summary').textContent=message;$('#data-summary').title=message;
account?.pages.forEach(renderPageConnection);renderStatus();
syncSaveStatus(account);
@@ -254,13 +285,14 @@ async function perform(account,operation,payload={},options={}) {
if(!state.accounts.has(account.id))return result;
if(result?.config){account.config=clone(result.config);account.revision=result.revision;}
if(['enter_server','restore_session','logout','forget_login','import_config','import_yields'].includes(operation))await refreshConfig(account);
try{account.summary=await api.status(account.id);account.transportErrors.delete('status');}
try{acceptSummary(account,await api.status(account.id));account.transportErrors.delete('status');}
catch(failure){transportError(account,'status','Web 账号状态',failure);failure.connection=true;throw failure;}
renderAccountTabs();renderSummary();
if((gameRefreshOperations.has(operation)||loginOperations.has(operation)) && !gameAvailable(account)){setStatus('工作台状态已更新');throw connectionError(account);}
const page=options.page || account.pages.get(account.page);if(page)await loadPage(page,true);
if(operation==='login'&&result)account.pages.get('login')?.login?.update(result);
const message=loginOperations.has(operation)?account.summary.running?'已读取角色,已自动开启策略,执行已配置且已勾选的功能;可在顶部“停止”。':'已读取角色。策略已停止,可在顶部“开启”继续执行已勾选功能。':result?.message;
if(operation==='forget_login')account.lastFailure='';
const message=loginOperations.has(operation)?account.summary.running && strategyRequested(account.summary)?'已读取角色,已自动开启策略,执行已配置且已勾选的功能;可在顶部“停止”。':`已读取角色。${strategyDetails(account)}`:result?.message;
if(message && operation!=='refresh')notice(message);
setStatus(operation==='refresh'?'状态已刷新':message || `${operationLabels[operation] || '操作'}已完成`);
return result;
@@ -325,10 +357,9 @@ async function pageAction(page,action,currency) {
if(operation==='reveal_breakthrough'){page.root.querySelector('th[data-column=breakthrough_selected]')?.scrollIntoView({block:'nearest',inline:'center'});return;}
if(operation==='apply_preset'){
const preset=page.data.details.preset;
if(account.summary.running)await perform(account,'stop');
Object.entries(preset.patch || {}).forEach(([section,fields])=>Object.entries(fields).forEach(([key,value])=>editConfig(account,[section,key],value)));
editConfig(account,['policy','egg_rules'],preset.egg_rules);
await flushConfig(account);notice('预设已保存。开启顶部策略后运行。');return;
await flushConfig(account);notice(`预设已保存;${strategyDetails(account)}`);return;
}
if(operation==='expand_regions'||operation==='collapse_regions'){page.table?.expand(operation==='expand_regions');return;}
if(operation==='import_yields'){return importYields(account);}
@@ -378,7 +409,7 @@ async function exportYields(account=current()) {
async function command(name,account=current()) {
try {
if(name==='add-account'||name==='add-demo')return await addAccount(name==='add-demo');
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.3'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`}),el('p',{class:'info-note',text:'与桌面助手共用核心策略。配置在服务端自动保存;每次成功登录后自动执行已勾选功能,可在顶部“停止”。服务重启后须先成功登录才执行。'})),{info:true});
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.4'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`}),el('p',{class:'info-note',text:'与桌面助手共用核心策略。配置在服务端自动保存;在线时默认自动执行已勾选功能,连接恢复后继续执行。顶部“停止”仅暂停执行,暂停在重新登录和服务重启后仍保留,直到再次“开启”。已保存的账号按设定时长自动重登,退出登录不取消;只有清除登录记录或删除账号才取消。'})),{info:true});
if(name==='updates')return await showUpdates();
if(name==='admin-logout'){hideWorkbench();try{await api.logout();}finally{requireAuth();}return;}
if(!account)throw new Error('请先新增或选择账号。');
@@ -394,7 +425,7 @@ async function command(name,account=current()) {
}
if(name==='logout')return await perform(account,'logout');
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;
}
if(name==='remove-account'){
if(!await confirm('移除当前账号',`移除“${account.summary.label || '当前账号'}”及其保存的会话和策略?此操作无法撤销。`,{confirm:'移除账号',danger:true}))return;
@@ -408,8 +439,8 @@ async function command(name,account=current()) {
if(name==='import-config'){
const file=await filePicker('.json');if(!file)return;if(file.size>1024*1024)throw new Error('策略文件过大。');
let config;try{config=JSON.parse(await file.text());}catch{throw new Error('策略文件不是有效的 JSON。');}
if(!await confirm('导入当前账号策略','将替换当前账号策略并停止执行;下次成功登录会自动执行已勾选功能。',{confirm:'导入策略'}))return;
await flushConfig(account);const result=await trackJob(account,await api.importConfig(account.id,config));await refreshConfig(account);notice('策略已导入,执行已停止;下次成功登录会自动执行已勾选功能。');await loadPage(getPage(account,account.page),true);return result;
if(!await confirm('导入当前账号策略','将替换当前账号策略配置;自动执行仍遵循当前开启 / 停止设置。',{confirm:'导入策略'}))return;
await flushConfig(account);const result=await trackJob(account,await api.importConfig(account.id,config));await refreshConfig(account);notice('策略已导入;自动执行仍遵循当前开启 / 停止设置。');await loadPage(getPage(account,account.page),true);return result;
}
if(name==='import-yields')return await importYields(account);
if(name==='export-yields')return await exportYields(account);
@@ -555,7 +586,7 @@ async function syncAccounts() {
const ids=new Set(summaries.map(summary=>summary.id));
for(const [id,account]of state.accounts)if(!ids.has(id)){account.pages.forEach(page=>{clearTimeout(page.loadTimer);page.root.remove();});state.accounts.delete(id);}
summaries.forEach(summary=>{
const account=state.accounts.get(summary.id);if(account){account.summary=summary;account.transportErrors.delete('status');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){acceptSummary(account,summary);account.transportErrors.delete('status');if(account.config&&account.revision!==summary.revision&&!account.edits.size&&!account.savePromise)refreshConfig(account).catch(error);}
else state.accounts.set(summary.id,makeAccount(summary));
});
renderAccountTabs();renderSummary();
@@ -595,7 +626,7 @@ async function bootstrap() {
$('#app').hidden=false;
const [meta,schema]=await Promise.all([api.meta(),api.schema()]);state.meta=meta;state.schema=schema;
if(state.redirecting)return;
$('#app-version').textContent=meta.version || '2.0.3';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
$('#app-version').textContent=meta.version || '2.0.4';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
await syncAccounts();if(state.redirecting)return;state.ready=true;setStatus('工作台已连接');
}catch(failure){if(failure.status===401||$('#app').hidden){requireAuth();return;}if(state.redirecting)return;setStatus(failure.message);$('#page-host').replaceChildren(el('div',{class:'initial-state'},el('p',{text:failure.message}),el('button',{text:'重新连接',onClick:bootstrap})));}
}
@@ -607,7 +638,7 @@ document.addEventListener('click',event=>{if(!event.target.closest('.menu'))$$('
document.addEventListener('keydown',event=>{if(event.key==='Escape')$$('.menu[open]').forEach(menu=>menu.open=false);});
$$('.menu').forEach(menu=>menu.addEventListener('toggle',()=>{if(menu.open)$$('.menu').filter(other=>other!==menu).forEach(other=>other.open=false);}));
$('#add-account').addEventListener('click',()=>command('add-account'));
$('#strategy-toggle').addEventListener('click',()=>command(current()?.summary.running?'stop':'start'));
$('#strategy-toggle').addEventListener('click',()=>command(strategyRequested(current()?.summary)?'stop':'start'));
$('#refresh').addEventListener('click',()=>{const account=current();if(account)perform(account,'refresh',{page:account.page}).catch(error);});
$('#refresh-interval').addEventListener('change',event=>{if(current())editConfig(current(),['interval'],Number(event.target.value));});
$('#save-status').tabIndex=0;$('#save-status').addEventListener('click',()=>command('save'));$('#save-status').addEventListener('keydown',event=>{if(event.key==='Enter')command('save');});
+1 -1
View File
@@ -26,7 +26,7 @@
</div></details>
<details class="menu"><summary accesskey="h">帮助<span class="access-key">(H)</span></summary><div class="menu-popup"><button data-command="updates">检查版本更新…</button><button data-command="debug">调试日志</button><button data-command="about">关于…</button></div></details>
</nav>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.3</span></span>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.4</span></span>
<span id="access-mode" class="muted">正在连接本地服务</span>
</header>
<div class="account-bar"><div id="account-tabs" class="account-tabs" role="tablist" aria-label="账号"></div><button id="add-account" class="compact" title="新增账号">+ 新增账号</button></div>
+6 -6
View File
@@ -48,11 +48,11 @@ class LoginPage {
this.restore = el('button', {type: 'button', text: '恢复选中会话(无需重新输密码)', disabled: true, onClick: () => page.perform('restore_session', {session_id: this.saved.value}).catch(page.error)});
this.root.append(form,
field('第二步:区服 / 角色', el('div', {class: 'server-row'}, this.servers, this.enter)),
el('p', {class: 'info-note', text: '账号验证 → 获取官方区服 → 选择区服 → 进入区服 → 读取角色。成功登录后自动刷新状态并执行已配置且已勾选的功能,可在顶部“停止”。'}),
el('p', {class: 'info-note', text: '账号验证 → 获取官方区服 → 选择区服 → 进入区服 → 读取角色。在线时默认自动刷新状态并自动执行已勾选功能;顶部“停止”仅暂停执行,重新登录和服务重启后仍保持暂停,直到再次“开启”。'}),
el('div', {class: 'session-block policy-form'}, field('已保存账号 / 区服 / 角色', this.saved), el('div', {class: 'login-actions'}, this.restore)),
el('div', {class: 'page-toolbar'}, el('button', {type: 'button', text: '退出登录', onClick: () => page.perform('logout').catch(page.error)}),
el('button', {type: 'button', text: '退出并清除登录记录…', onClick: () => page.options.command('forget-login', page.account)})),
el('p', {class: 'info-note', text: '记住的账号密码和登录会话由服务端加密保存。浏览器不会保存游戏凭据。手动选服、恢复会话和自动重登成功后,均自动执行已勾选功能;退出登录后停止执行。'}));
el('p', {class: 'info-note', text: '记住的账号密码和登录会话由服务端加密保存。浏览器不会保存游戏凭据。账号登录并保存原区服、原角色后会持续保持登录:掉线、退出登录或服务重启,均按设定时长自动重登并恢复监控;默认等待 30 分钟,可修改为 10 分钟等时长。关闭页面不影响自动重登。只有“退出并清除登录记录”或删除账号才取消自动重登;手动停止的执行仍保持暂停。'}));
host.append(this.autoReloginStatus, this.root);
}
@@ -71,13 +71,12 @@ class LoginPage {
}
updateStatus() {
const enabled = this.page.account.config?.auto_relogin?.enabled === true;
const status = this.page.account.summary?.auto_relogin_status;
const message = status?.message || (enabled ? '自动重登已开启,等待服务端状态。' : '自动重登未开启。');
const message = status?.message || '已保存的账号会持续自动重登,等待服务端状态;可设置重登等待时长。';
if (this.autoReloginMessage.textContent !== message) this.autoReloginMessage.textContent = message;
this.autoReloginCredentials.hidden = !enabled || this.hasSavedPassword !== false;
this.autoReloginCredentials.hidden = this.hasSavedPassword !== false;
const attemptAt = typeof status?.next_attempt_at === 'string' ? Date.parse(status.next_attempt_at) : NaN;
this.autoReloginCountdown.hidden = !enabled || !Number.isFinite(attemptAt);
this.autoReloginCountdown.hidden = !Number.isFinite(attemptAt);
if (!this.autoReloginCountdown.hidden) {
const remaining = Math.max(0, Math.ceil((attemptAt - Date.now()) / 1000));
const countdown = remaining ? `${remaining} 秒后自动重新登录(${chinaTime(status.next_attempt_at, {date: true})},北京时间)` : '等待服务端执行自动重登';
@@ -230,6 +229,7 @@ export class PageView {
this.summary.textContent = typeof data.summary === 'string' ? data.summary : textValue(data.summary || '');
this.updateRuntimeStatus(data.details || {});
let fields = data.form || this.options.schema(this.key);
if (this.key === 'login') fields = fields.filter(field => !(field.path?.[0] === 'auto_relogin' && field.path[1] === 'enabled'));
fields=fields.map(field=>field.path?.[0]==='policy'&&field.path[1]==='buy_ten'?{...field,disabled:!this.account.config?.policy?.allow_single_draw}:field);
if (this.key === 'hatching' && this.activeSubtab) fields = fields.filter(field => !field.group || field.group === this.activeSubtab);
const policyTab = this.key === 'mainline' && ['policy', 'settings', '推进策略'].includes(this.activeSubtab);
@@ -27,16 +27,14 @@ class AutoReloginSchemaTests(unittest.TestCase):
catalog = Catalog()
fields = next(page["form"] for page in schema(catalog)["pages"] if page["key"] == "login")
fields = {tuple(field["path"]): field for field in fields}
enabled = fields[("auto_relogin", "enabled")]
delay = fields[("auto_relogin", "delay_minutes")]
self.assertEqual(enabled["label"], "掉线后自动重新登录")
self.assertEqual(enabled["type"], "boolean")
self.assertIs(enabled["value"], False)
self.assertNotIn(("auto_relogin", "enabled"), fields)
self.assertIsInstance(default_config()["auto_relogin"]["enabled"], bool)
self.assertEqual((delay["type"], delay["min"], delay["max"], delay["value"]), ("integer", 1, 10080, 30))
engine = SimpleNamespace(catalog=catalog, snapshot=None, demo=False)
view = build_view(engine, "login", default_config())
values = {tuple(field["path"]): field["value"] for field in view["form"]}
self.assertIs(values[("auto_relogin", "enabled")], False)
self.assertNotIn(("auto_relogin", "enabled"), values)
self.assertEqual(values[("auto_relogin", "delay_minutes")], 30)
@@ -77,8 +75,9 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.configs[identifier]["auto_relogin"] = {"enabled": False, "delay_minutes": 30}
summary = copy.deepcopy(self.manager.status(identifier))
summary.update(demo=False, connected=False, running=False, connection_state="offline",
connection_message="尚未连接游戏", error="", revision=9000)
summary["auto_relogin_status"] = {"state": "disabled", "message": "自动重登未开启", "next_attempt_at": None}
connection_message="尚未连接游戏", error="", revision=9000,
strategy_requested=False, strategy_state="stopped", strategy_message="", strategy_retry_at=None)
summary["auto_relogin_status"] = {"state": "missing_identity", "message": "尚未保存登录角色", "next_attempt_at": None}
self.summaries[identifier] = summary
self.login_data[identifier] = build_view(engine, "login", default_config())
self.login_data[identifier].update(account="offline-fixture", has_saved_password=True)
@@ -122,9 +121,10 @@ class AutoReloginBrowserTests(unittest.TestCase):
route.abort()
return
self.summaries[identifier].update(connected=False, running=False, connection_state="offline")
self.set_status(identifier, "cancelled", "手动退出登录,已取消本次自动重登")
self.waiting(identifier, message="退出登录后仍按设定时长自动重登",
requested=self.summaries[identifier]["strategy_requested"])
self.fulfill(route, {"id": "mock-logout", "operation": operation, "status": "succeeded",
"result": {"message": "已退出登录并取消自动重登"}})
"result": {"message": "已退出当前连接,仍会自动重登"}})
return
if request.method in ("POST", "PUT", "DELETE", "PATCH"):
self.unexpected_actions.append(path)
@@ -146,15 +146,21 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.summaries[identifier]["auto_relogin_status"] = {
"state": state, "message": message, "next_attempt_at": next_attempt_at}
def waiting(self, identifier=None, *, seconds=45, message="掉线后等待自动重登"):
def waiting(self, identifier=None, *, seconds=45, message="掉线后等待自动重登", requested=True):
identifier = identifier or self.first
self.configs[identifier]["auto_relogin"]["enabled"] = True
summary = self.summaries[identifier]
summary["strategy_requested"] = requested
if not requested:
summary["strategy_state"] = "stopped"
elif summary["strategy_state"] == "stopped":
summary["strategy_state"] = "offline"
target = (datetime.now(timezone.utc) + timedelta(seconds=seconds)).isoformat().replace("+00:00", "Z")
self.set_status(identifier, "waiting", message, target)
return target
def controls(self, panel):
return panel.get_by_role("checkbox", name="掉线后自动重新登录", exact=True), panel.get_by_role("spinbutton", name="重登等待时长(分钟)", exact=True)
def delay_control(self, panel):
expect(panel.get_by_role("checkbox", name="掉线后自动重新登录", exact=True)).to_have_count(0)
return panel.get_by_role("spinbutton", name="重登等待时长(分钟)", exact=True)
def saved(self, identifier, enabled, minutes):
self.page.wait_for_function("() => document.querySelector('#save-status').textContent === '策略已自动保存'")
@@ -162,27 +168,27 @@ class AutoReloginBrowserTests(unittest.TestCase):
def complete_login(self, operation, *, running=True):
self.summaries[self.first].update(connected=True, connection_state="online",
connection_message="游戏连接正常", error="", running=running)
connection_message="游戏连接正常", error="", running=running,
strategy_requested=running, strategy_state="running" if running else "stopped")
return {"id": "mock-" + operation, "operation": operation, "status": "succeeded", "result": {}}
def test_defaults_visible_explanations_and_existing_layout(self):
self.open()
panel = self.go("login")
enabled, delay = self.controls(panel)
expect(enabled).to_be_visible()
expect(enabled).not_to_be_checked()
delay = self.delay_control(panel)
expect(delay).to_be_visible()
expect(delay).to_have_value("30")
for attribute, value in (("min", "1"), ("max", "10080"), ("step", "1")):
expect(delay).to_have_attribute(attribute, value)
for text in ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "自动执行已勾选功能", "顶部“停止”", "关闭页面", "服务重启"):
for text in ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "自动执行已勾选功能", "顶部“停止”", "关闭页面", "服务重启", "退出登录", "只有", "清除登录记录", "暂停"):
expect(panel).to_contain_text(text)
self.assertTrue(enabled.evaluate("node => Boolean(node.closest('.policy-form'))"))
self.assertTrue(enabled.evaluate("node => Boolean(node.compareDocumentPosition(document.querySelector('.login-layout')) & Node.DOCUMENT_POSITION_FOLLOWING)"))
self.assertTrue(delay.evaluate("node => Boolean(node.closest('.policy-form'))"))
self.assertTrue(delay.evaluate("node => Boolean(node.compareDocumentPosition(document.querySelector('.login-layout')) & Node.DOCUMENT_POSITION_FOLLOWING)"))
expect(panel.get_by_role("button", name="保存", exact=True)).to_have_count(0)
for width, height in ((1280, 800), (390, 844)):
self.page.set_viewport_size({"width": width, "height": height})
self.assertLessEqual(self.page.evaluate("document.documentElement.scrollWidth"), width)
expect(enabled).to_be_visible()
expect(delay).to_be_visible()
self.assertEqual(self.writes, [])
self.assertEqual(self.actions, [])
@@ -196,7 +202,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
return {"id": "mock-login", "operation": "login", "status": "succeeded", "result": candidates}
def stop(payload):
self.summaries[self.first]["running"] = False
self.summaries[self.first].update(running=False, strategy_requested=False, strategy_state="stopped")
return {"id": "mock-stop", "operation": "stop", "status": "succeeded", "result": {"message": "策略已停止"}}
self.action_handlers.update({(self.first, "login"): login,
@@ -230,13 +236,13 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.assertEqual(self.configs[self.first], original)
self.assertEqual(self.writes, [])
def test_import_stays_stopped_and_next_restored_session_runs_imported_selection(self):
def test_import_and_restored_session_preserve_explicit_pause_and_imported_selection(self):
imported = copy.deepcopy(default_config())
imported["daily_policy"].update(enabled=True, selected=["gift"])
portable = export_config(imported)
imports = []
self.login_data[self.first]["saved_sessions"] = [{"id": "offline-session", "label": "离线区服 / 原角色"}]
self.action_handlers[(self.first, "restore_session")] = lambda payload: self.complete_login("restore_session")
self.action_handlers[(self.first, "restore_session")] = lambda payload: self.complete_login("restore_session", running=False)
def import_config(route):
imports.append(route.request.post_data_json)
@@ -253,15 +259,15 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.page.locator('[data-command="import-config"]').click()
chooser.value.set_files({"name": "offline-policy.json", "mimeType": "application/json",
"buffer": json.dumps(portable).encode("utf-8")})
expect(self.page.locator("#dialog-content")).to_contain_text("下次成功登录会自动执行已勾选功能")
expect(self.page.locator("#dialog-content")).to_contain_text("仍遵循当前开启 / 停止设置")
self.page.locator("#dialog-confirm").click()
expect(self.page.locator("#notice")).to_contain_text("策略已导入,执行已停止")
expect(self.page.locator("#notice")).to_contain_text("策略已导入")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
self.assertEqual(imports, [portable])
self.assertEqual(self.actions, [])
panel.get_by_role("button", name="恢复选中会话(无需重新输密码)", exact=True).click()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#notice")).to_contain_text("已自动开启策略")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#notice")).to_contain_text("用户暂停")
self.assertEqual(self.actions, [(self.first, "restore_session", {"session_id": "offline-session"})])
self.assertEqual(self.configs[self.first], imported, "Restoring must preserve imported selections")
self.assertEqual(self.writes, [])
@@ -314,17 +320,12 @@ class AutoReloginBrowserTests(unittest.TestCase):
def test_native_autosave_range_validation_refresh_and_focus(self):
self.open()
panel = self.go("login")
enabled, delay = self.controls(panel)
enabled.check()
checkbox = enabled.element_handle()
self.page.wait_for_timeout(850)
self.saved(self.first, True, 30)
self.assertTrue(enabled.evaluate("(node, original) => node === original && node === document.activeElement", checkbox))
delay = self.delay_control(panel)
delay.fill("47")
original = delay.element_handle()
before = self.view_calls
self.page.wait_for_timeout(5200)
self.saved(self.first, True, 47)
self.saved(self.first, False, 47)
self.assertGreater(self.view_calls, before, "Offline login DTOs must keep refreshing")
self.assertTrue(delay.evaluate("(node, original) => node === original && node === document.activeElement", original))
for invalid in ("0", "10081", "1.5", ""):
@@ -336,9 +337,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
for valid in (1, 10080):
delay.fill(str(valid))
self.page.wait_for_timeout(850)
self.saved(self.first, True, valid)
enabled.uncheck()
self.page.wait_for_timeout(850)
self.saved(self.first, False, valid)
self.saved(self.first, False, 10080)
self.assertEqual(self.actions, [])
@@ -350,14 +349,13 @@ class AutoReloginBrowserTests(unittest.TestCase):
remember = panel.get_by_role("checkbox", name="记住账号和密码", exact=True)
remember.uncheck()
panel.get_by_role("textbox", name="游戏密码", exact=True).fill("mock-secret-never-send")
enabled, _ = self.controls(panel)
enabled.check()
self.delay_control(panel).fill("10")
hint = panel.locator("[data-auto-relogin-credentials]")
expect(hint).to_be_visible()
expect(hint).to_contain_text("缺少")
expect(hint).to_contain_text("记住账号和密码")
self.page.wait_for_timeout(1000)
self.saved(self.first, True, 30)
self.saved(self.first, False, 10)
expect(remember).not_to_be_checked()
self.assertTrue(self.writes)
payloads = json.dumps(self.writes, ensure_ascii=False)
@@ -370,26 +368,24 @@ class AutoReloginBrowserTests(unittest.TestCase):
def test_account_switch_isolates_pending_edits_status_and_minutes(self):
self.waiting(message="账号一正在等待自动重登")
self.set_status(self.second, "disabled", "账号二未开启自动重登")
self.set_status(self.second, "missing_identity", "账号二尚未保存登录角色")
self.open()
panel = self.go("login")
_, delay = self.controls(panel)
delay = self.delay_control(panel)
delay.fill("17")
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
panel = self.go("login")
enabled, second_delay = self.controls(panel)
expect(enabled).not_to_be_checked()
second_delay = self.delay_control(panel)
expect(second_delay).to_have_value("30")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("账号二未开启")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("账号二尚未保存")
expect(panel).not_to_contain_text("账号一正在等待")
enabled.check()
second_delay.fill("9")
self.page.wait_for_timeout(1000)
self.saved(self.second, True, 9)
self.assertEqual(self.configs[self.first]["auto_relogin"], {"enabled": True, "delay_minutes": 17})
self.saved(self.second, False, 9)
self.assertEqual(self.configs[self.first]["auto_relogin"], {"enabled": False, "delay_minutes": 17})
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
panel = self.go("login")
expect(self.controls(panel)[1]).to_have_value("17")
expect(self.delay_control(panel)).to_have_value("17")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("账号一正在等待")
self.assertEqual({identifier for identifier, _ in self.writes}, {self.first, self.second})
self.assertEqual(self.actions, [])
@@ -404,8 +400,8 @@ class AutoReloginBrowserTests(unittest.TestCase):
expect(status).to_contain_text("掉线后等待自动重登")
expect(countdown).to_contain_text("秒后自动重新登录")
expect(countdown).to_contain_text("北京时间")
expect(self.controls(panel)[0]).to_be_enabled()
delay = self.controls(panel)[1]
delay = self.delay_control(panel)
expect(delay).to_be_enabled()
delay.focus()
original = delay.element_handle()
before = countdown.inner_text()
@@ -421,10 +417,12 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.set_status(self.first, "failed", reason)
expect(status).to_contain_text(reason)
expect(status.locator("img")).to_have_count(0)
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
original = copy.deepcopy(self.configs[self.first])
self.set_status(self.first, "monitoring", "重登成功,已恢复监控并自动执行已勾选功能,可在顶部停止")
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常", running=True)
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常",
running=True, strategy_requested=True, strategy_state="running")
expect(status).to_contain_text("已恢复监控并自动执行已勾选功能")
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行已配置且已勾选的功能")
@@ -436,31 +434,35 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.open()
panel = self.go("login")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("服务重启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
before = len(self.writes)
self.page.reload(wait_until="networkidle")
panel = self.go("login")
expect(self.controls(panel)[0]).to_be_checked()
expect(self.controls(panel)[1]).to_have_value("30")
expect(self.delay_control(panel)).to_have_value("30")
expect(panel.locator("[data-auto-relogin-countdown]")).to_contain_text("秒后自动重新登录")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
self.page.goto("about:blank")
self.page.close()
self.assertEqual(len(self.writes), before)
self.assertEqual(self.summaries[self.first]["auto_relogin_status"]["next_attempt_at"], target)
self.assertEqual(self.actions, [])
def test_manual_logout_cancels_countdown_without_disabling_account_setting(self):
def test_manual_logout_keeps_countdown_and_preserves_strategy_pause(self):
self.waiting()
self.summaries[self.first].update(strategy_requested=False, strategy_state="stopped")
self.open()
panel = self.go("login")
expect(panel.locator("[data-auto-relogin-countdown]")).to_contain_text("秒后自动重新登录")
panel.get_by_role("button", name="退出登录", exact=True).click()
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("已取消本次自动重登")
expect(panel.locator("[data-auto-relogin-countdown]")).to_be_hidden()
expect(self.controls(panel)[0]).to_be_checked()
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("仍按设定时长自动重登")
expect(panel.locator("[data-auto-relogin-countdown]")).to_be_visible()
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#data-summary")).to_contain_text("用户暂停")
expect(self.delay_control(panel)).to_have_value("30")
self.assertEqual(self.actions, [(self.first, "logout", {})])
self.assertEqual(self.writes, [])
if __name__ == "__main__":
@@ -72,7 +72,8 @@ class ConnectionBrowserTests(unittest.TestCase):
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="登录凭据已失效,请重新登录。")
failure_reason = "登录凭据已失效,请重新登录。"
self.summary.update(connection_state="expired", connection_message=failure_reason, error=failure_reason)
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("缓存")
@@ -89,10 +90,14 @@ class ConnectionBrowserTests(unittest.TestCase):
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("#connection")).to_have_attribute("title", "游戏连接正常")
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("[data-connection-status]")).to_have_text("")
for selector in ("#data-summary", "#status-text"):
expect(self.page.locator(selector)).to_be_visible()
expect(self.page.locator(selector)).to_contain_text(f"上次失败:{failure_reason}")
expect(self.page.locator(f'.account-tab[data-account="{self.first}"] .account-dot')).not_to_have_class("account-dot error")
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, [])
@@ -0,0 +1,214 @@
"""Durable execution intent with synthetic API responses and loopback HTTP only."""
from __future__ import annotations
import unittest
from . import test_auto_relogin_browser as relogin
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 RunIntentBrowserTests(unittest.TestCase):
setUpClass = classmethod(relogin.AutoReloginBrowserTests.setUpClass.__func__)
tearDownClass = classmethod(relogin.AutoReloginBrowserTests.tearDownClass.__func__)
tearDown = relogin.AutoReloginBrowserTests.tearDown
await_job = fixtures.WorkbenchBrowserTests.await_job
open = fixtures.WorkbenchBrowserTests.open
go = fixtures.WorkbenchBrowserTests.go
fulfill = staticmethod(fixtures.WorkbenchBrowserTests.fulfill)
set_status = relogin.AutoReloginBrowserTests.set_status
waiting = relogin.AutoReloginBrowserTests.waiting
def setUp(self):
relogin.AutoReloginBrowserTests.setUp(self)
for summary in self.summaries.values():
summary.update(strategy_requested=False, strategy_state="stopped",
strategy_message="", strategy_retry_at=None)
self.summary = self.summaries[self.first]
self.online()
self.page.add_init_script("""(() => {
const original = window.setInterval;
window.setInterval = (callback, delay, ...args) => {
if (callback.name === 'tick') {window.__pollIntent = callback;return -1;}
return original(callback, delay, ...args);
};
})();""")
def poll(self):
self.page.evaluate("async () => {await window.__pollIntent();}")
self.page.wait_for_load_state("networkidle")
def online(self, *, running=True):
self.summary.update(connected=True, connection_state="online", connection_message="游戏连接正常",
error="", running=running, strategy_requested=True,
strategy_state="running" if running else "recovering", strategy_message="",
strategy_retry_at=None, next_retry_at=None)
def recovering(self):
self.summary.update(running=False, strategy_requested=True, connection_state="retrying",
connection_message="游戏请求超时,正在恢复连接。", error="游戏请求超时",
strategy_state="recovering", strategy_message="网络超时,等待只读检查后恢复策略。")
self.summary["strategy_retry_at"] = self.page.evaluate("new Date(Date.now()+30000).toISOString()")
self.summary["next_retry_at"] = self.summary["strategy_retry_at"]
self.waiting(seconds=600)
def test_timeout_heartbeat_only_and_recovery_preserve_stop_and_failure_history(self):
self.open()
toggle = self.page.locator("#strategy-toggle")
expect(toggle).to_have_text("停止")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.recovering()
self.poll()
expect(toggle).to_have_text("停止")
expect(toggle).to_be_enabled()
expect(toggle).to_have_class("run-button running")
expect(toggle).to_have_attribute("aria-pressed", "true")
expect(self.page.locator("#data-summary")).to_contain_text("等待")
expect(self.page.locator("#data-summary")).not_to_contain_text("用户暂停")
expect(self.page.locator("#connection")).to_have_text("正在重试")
expect(self.page.locator("#refresh")).to_be_disabled()
self.online(running=False)
self.poll()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#refresh")).to_be_enabled()
expect(self.page.locator("#data-summary")).to_contain_text("等待恢复")
expect(self.page.locator("#data-summary")).to_contain_text("上次失败")
expect(self.page.locator("#data-summary")).to_contain_text("游戏请求超时")
expect(toggle).to_have_text("停止")
expect(self.page.locator(f'.account-tab[data-account="{self.first}"] .account-dot')).not_to_have_class("account-dot error")
self.online()
self.poll()
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行")
expect(self.page.locator("#data-summary")).to_contain_text("上次失败")
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.assertEqual(self.actions, [])
self.assertEqual(self.writes, [])
def test_stop_during_recovery_persists_pause_while_relogin_continues(self):
self.open()
self.recovering()
self.poll()
def stop(payload):
self.summary.update(strategy_requested=False, running=False, strategy_state="stopped",
strategy_message="用户已停止策略,仍会保持登录。")
return {"id": "intent-stop", "operation": "stop", "status": "succeeded", "result": {}}
def start(payload):
self.online()
return {"id": "intent-start", "operation": "start", "status": "succeeded", "result": {}}
self.action_handlers[(self.first, "stop")] = stop
self.action_handlers[(self.first, "start")] = start
toggle = self.page.locator("#strategy-toggle")
toggle.click()
expect(toggle).to_have_text("开启")
expect(toggle).to_have_attribute("aria-pressed", "false")
expect(toggle).to_be_disabled()
expect(self.page.locator("#data-summary")).to_contain_text("用户暂停")
expect(self.page.locator('[data-auto-relogin-countdown]')).to_be_visible()
self.summary.update(connected=True, connection_state="online", connection_message="游戏连接正常", error="",
next_retry_at=None, strategy_retry_at=None)
self.poll()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(toggle).to_be_enabled()
expect(self.page.locator("#data-summary")).to_contain_text("用户暂停")
self.page.reload(wait_until="networkidle")
expect(toggle).to_have_text("开启")
expect(self.page.locator("#data-summary")).to_contain_text("用户暂停")
toggle.click()
expect(toggle).to_have_text("停止")
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行")
self.assertEqual([(account, operation) for account, operation, _ in self.actions],
[(self.first, "stop"), (self.first, "start")])
self.assertEqual(self.writes, [])
def test_online_execution_block_is_distinct_from_connection_health_and_can_be_stopped(self):
self.online(running=False)
reason = '交付结果待确认 <img src=x onerror="alert(1)">'
self.summary.update(strategy_state="blocked", strategy_message=reason)
self.open()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#refresh")).to_be_enabled()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#strategy-toggle")).to_be_enabled()
expect(self.page.locator("#data-summary")).to_contain_text(reason)
expect(self.page.locator("#data-summary img")).to_have_count(0)
expect(self.page.locator("#data-summary")).not_to_contain_text("正在自动执行")
expect(self.page.locator("#data-summary")).not_to_contain_text("用户暂停")
self.assertEqual(self.actions, [])
def test_legacy_status_falls_back_to_running_and_keeps_heartbeat_only_online(self):
for field in ("strategy_requested", "strategy_state", "strategy_message", "strategy_retry_at"):
self.summary.pop(field)
self.open()
toggle = self.page.locator("#strategy-toggle")
expect(toggle).to_have_text("停止")
self.summary["running"] = False
self.poll()
expect(toggle).to_have_text("开启")
expect(toggle).to_be_enabled()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#refresh")).to_be_enabled()
expect(self.page.locator("#data-summary")).not_to_contain_text("用户暂停")
self.assertEqual(self.actions, [])
def test_applying_preset_saves_rules_without_sending_stop_or_changing_intent(self):
view = {"loading": False, "data": {"page": "hatching", "form": [], "filters": [],
"columns": [], "rows": [], "actions": [], "details": {"preset": {
"label": "离线测试预设", "patch": {"policy": {"enabled": True, "collect": True}},
"egg_rules": {"1001010": {"enabled": True}}}}}}
self.page.route(f"**/api/accounts/{self.first}/views/hatching?*", lambda route: self.fulfill(route, view))
self.open()
panel = self.go("hatching")
panel.locator('button[data-operation="apply_preset"]').click()
expect(self.page.locator("#notice")).to_contain_text("预设已保存")
expect(self.page.locator("#notice")).to_contain_text("正在自动执行")
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
self.assertEqual(len(self.writes), 1)
self.assertTrue(self.configs[self.first]["policy"]["egg_rules"]["1001010"]["enabled"])
self.assertTrue(self.summary["strategy_requested"])
self.assertEqual(self.actions, [], "Applying a preset must not submit a durable user Stop")
def test_restart_wait_and_accounts_keep_intent_and_original_log_region_separate(self):
self.summary.update(connected=False, running=False, connection_state="offline", strategy_requested=True,
strategy_state="offline", strategy_message="等待重新登录后执行已勾选功能。")
self.configs[self.first]["auto_relogin"] = {"enabled": False, "delay_minutes": 10}
self.waiting(seconds=600, message="服务重启,等待返回原区服角色")
self.open()
toggle = self.page.locator("#strategy-toggle")
expect(toggle).to_have_text("停止")
expect(toggle).to_be_enabled()
expect(self.page.locator('[aria-label="重登等待时长(分钟)"]')).to_have_value("10")
expect(self.page.locator('[data-auto-relogin-countdown]')).to_be_visible()
expect(self.page.locator("#log-panel")).to_be_hidden()
self.page.locator("#log-toggle").click()
expect(self.page.locator("#log-panel")).to_be_visible()
self.page.locator("#log-search").fill("登录筛选")
original = self.page.locator("#log-panel").element_handle()
self.go("bag")
expect(self.page.locator("#log-panel")).to_be_visible()
expect(self.page.locator("#log-search")).to_have_value("")
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
expect(toggle).to_have_text("开启")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
expect(toggle).to_have_text("停止")
self.go("login")
expect(self.page.locator("#log-panel")).to_be_visible()
expect(self.page.locator("#log-search")).to_have_value("登录筛选")
self.assertTrue(self.page.locator("#log-panel").evaluate("(node, original) => node === original", original))
expect(self.page.locator('[role="log"]')).to_have_count(1)
self.page.reload(wait_until="networkidle")
expect(toggle).to_have_text("停止")
expect(self.page.locator("#log-panel")).to_be_hidden()
self.assertEqual(self.actions, [])
self.assertEqual(self.writes, [])
if __name__ == "__main__":
unittest.main()
+83 -17
View File
@@ -9,6 +9,7 @@ from unittest.mock import patch
import requests
from ranch_assistant.api import ApiError, SessionExpiredError
from ranch_assistant.model import Action
from ranch_web.policies import default_config, export_config, validate_config
from ranch_web.service import WebManager
from ranch_web.tests import test_service as fixtures
@@ -102,7 +103,7 @@ class AutoReloginTests(unittest.TestCase):
self.assertEqual(worker.engine.client.session.role_id, 102)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Authentication must not run selected writes inline")
self.assertTrue(result["running"])
self.assertIn("已勾选", result["message"])
self.assertEqual(worker.config, selected)
@@ -128,10 +129,39 @@ class AutoReloginTests(unittest.TestCase):
def test_recovery_clears_outage_and_next_outage_gets_fresh_delay(self):
identifier, worker = self.connected()
self.enable(identifier)
self.disconnect(identifier, worker, timeout=True)
before = len(fixtures.FakeClient.calls)
self.now += 5
self.tick(identifier, worker)
self.assertEqual(self.auto_status(identifier)["state"], "idle")
self.assertTrue(worker.running, "A confirmed read lost the user's execution request")
self.assertFalse(worker.engine.auto, "A retry must not authorize writes in its own job")
self.assertEqual([url.rsplit("/", 2)[-2:] for _, url, _ in fixtures.FakeClient.calls[before:]],
[["masterService", "masterQueryDetail"]])
monster = next(iter(worker.engine.snapshot.monsters))
action = Action("lock", "Synthetic selected action", "monsterService/monsterLock",
{"monsterId": monster, "lock": True})
writes = []
original = worker.engine.client.http.post
def transport(url, *args, **kwargs):
if url.endswith(action.path):
job = worker._execution
writes.append((job.operation, job.consuming, job.generation == worker._generation))
return original(url, *args, **kwargs)
with patch.object(worker.engine, "plans", return_value=[action]), \
patch.object(worker.engine.client.http, "post", side_effect=transport):
# This invokes the real Engine.poll/read_snapshot path. The
# snapshot callback must not enable the selected write inline.
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertEqual(writes, [])
self.assertFalse(worker.engine.auto)
worker.engine.last_heartbeat = self.now
worker.schedule.next_poll = 0
self.tick(identifier, worker)
self.assertEqual(writes, [("__tick", True, True)])
self.now += 100
self.disconnect(identifier, worker)
before = len(AutoLogin.calls)
@@ -142,9 +172,9 @@ class AutoReloginTests(unittest.TestCase):
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
def test_enabling_and_changing_delay_reuses_known_outage(self):
def test_changing_delay_reuses_known_outage(self):
identifier, worker = self.connected()
self.configure(identifier, enabled=False, delay=5)
self.configure(identifier, delay=5)
self.disconnect(identifier, worker)
self.now += 70
self.configure(identifier, delay=2)
@@ -242,9 +272,14 @@ class AutoReloginTests(unittest.TestCase):
self.login(identifier, server=2)
self.assertNotEqual(self.manager.get_config(identifier)["config"]["policy"]["keep_money"], 4321)
self.assertEqual(self.manager.get_config(identifier)["config"]["auto_relogin"]["delay_minutes"], 7)
worker = self.manager._worker(identifier)
identity = worker.active_identity
self.job(identifier, self.manager.submit(identifier, "logout"))
self.assertTrue(self.manager.get_config(identifier)["config"]["auto_relogin"]["enabled"])
self.assertEqual(self.auto_status(identifier)["state"], "suspended")
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.securestore.active(), identity)
self.assertTrue(worker.securestore.load_credentials()[0])
self.assertEqual(self.auto_status(identifier)["state"], "waiting")
def test_portable_import_preserves_local_login_preference(self):
identifier, worker = self.connected()
@@ -257,10 +292,14 @@ class AutoReloginTests(unittest.TestCase):
public = json.dumps(self.manager.get_config(identifier)) + json.dumps(export_config(worker.config))
self.assertNotIn("synthetic-password", public)
self.assertNotIn("synthetic-center-token", public)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
worker.engine.last_heartbeat = self.now
worker.schedule.next_poll = 0
self.tick(identifier, worker)
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertFalse(self.manager.status(identifier)["manual_stop"])
def test_restart_opt_in_activates_after_thirty_minutes_and_supersedes_old_stop(self):
def test_restart_reconnects_after_thirty_minutes_and_preserves_explicit_stop(self):
identifier, worker = self.connected()
self.enable(identifier)
self.configure(identifier, delay=30)
@@ -285,14 +324,16 @@ class AutoReloginTests(unittest.TestCase):
self.now = origin + 1800
result = self.tick(identifier, worker)["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertFalse(result["running"])
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertEqual(worker.config, selected)
self.assertEqual(len(AutoLogin.calls), before[0] + 1)
def test_final_activation_revocation_never_starts_relogin_candidate(self):
for operation in ("stop", "logout", "forget_login", "policy", "disable", "delay"):
for operation in ("stop", "logout", "forget_login", "policy", "delay"):
with self.subTest(operation=operation):
identifier, worker = self.connected()
self.enable(identifier)
@@ -337,7 +378,7 @@ class AutoReloginTests(unittest.TestCase):
self.assertFalse(any("已自动开启" in row["message"]
for row in self.manager.logs(identifier, after=before)["entries"]))
def test_restart_opt_in_waits_and_logout_disarms_restart(self):
def test_restart_waits_and_logout_retains_keep_login_across_restart(self):
identifier, worker = self.connected()
self.manager.close()
before = len(AutoLogin.calls)
@@ -361,13 +402,15 @@ class AutoReloginTests(unittest.TestCase):
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
self.now += 99999
self.now = worker.schedule.disconnected_at + 60
worker.schedule.clock = lambda: self.now
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before)
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertTrue(worker.running)
def test_logout_forget_and_delay_change_revoke_inflight_auth_immediately(self):
for operation in ("logout", "forget_login", "disable", "delay"):
for operation in ("logout", "forget_login", "delay"):
with self.subTest(operation=operation):
identifier, worker = self.connected()
self.disconnect(identifier, worker)
@@ -388,7 +431,6 @@ class AutoReloginTests(unittest.TestCase):
self.assertTrue(entered.wait(2))
if operation in {"logout", "forget_login"}:
next_job = self.manager.submit(identifier, operation)
self.assertEqual(self.auto_status(identifier)["state"], "suspended")
else:
config = self.manager.get_config(identifier)["config"]
config["auto_relogin"].update(enabled=operation != "disable", delay_minutes=2)
@@ -398,11 +440,22 @@ class AutoReloginTests(unittest.TestCase):
self.job(identifier, next_job)
self.assertEqual(len(AutoLogin.calls), before)
self.assertFalse(self.manager.status(identifier)["connected"])
if operation == "logout":
# Revoking an in-flight SDK call retains its completion
# backoff as well as keep-login authorization.
self.assertEqual(self.auto_status(identifier)["state"], "failed")
self.assertIsNotNone(self.auto_status(identifier)["next_attempt_at"])
self.assertTrue(worker.securestore.load_credentials()[0])
elif operation == "forget_login":
self.assertFalse(worker.securestore.load_credentials()[0])
self.assertIsNone(worker.active_identity)
def test_account_isolation(self):
first, first_worker = self.connected(account="owner-one")
second, second_worker = self.connected(account="owner-two")
self.configure(second, enabled=False)
self.enable(first)
self.enable(second)
self.configure(second, delay=2)
self.disconnect(first, first_worker)
self.disconnect(second, second_worker)
self.now += 60
@@ -412,6 +465,19 @@ class AutoReloginTests(unittest.TestCase):
self.assertEqual(AutoLogin.calls[before:], [("owner-one", "synthetic-password")])
self.assertTrue(self.manager.status(first)["connected"])
self.assertFalse(self.manager.status(second)["connected"])
self.manager.submit(first, "stop")
self.disconnect(first, first_worker)
self.now += 60
self.tick(first, first_worker)
self.tick(second, second_worker)
self.assertTrue(self.manager.status(first)["connected"])
self.assertFalse(first_worker.running)
self.assertTrue(self.manager.status(first)["manual_stop"])
self.assertTrue(self.manager.status(second)["connected"])
self.assertTrue(second_worker.running)
self.assertFalse(self.manager.status(second)["manual_stop"])
self.assertEqual(AutoLogin.calls[before + 1:],
[("owner-one", "synthetic-password"), ("owner-two", "synthetic-password")])
def test_stop_policy_and_delay_cancellation_back_off_even_after_transport_error(self):
for operation in ("stop", "policy", "delay"):
+66 -17
View File
@@ -12,6 +12,7 @@ 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
from ranch_web.tests.test_auto_relogin import AutoLogin
class ConnectionStateTests(unittest.TestCase):
@@ -73,9 +74,9 @@ class ConnectionStateTests(unittest.TestCase):
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}))
self.assertEqual(self.manager.status(identifier)["connection_state"], "online")
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Session verification must not authorize selected writes inline")
def test_explicit_stop_survives_heartbeat_local_refresh_and_monitor_until_login(self):
def test_explicit_stop_survives_heartbeat_refresh_monitor_and_relogin(self):
identifier, worker = self.connected(running=True)
self.manager.submit(identifier, "stop")
worker.engine.last_heartbeat = 0
@@ -90,8 +91,16 @@ class ConnectionStateTests(unittest.TestCase):
self.assertTrue(self.manager.status(identifier)["connected"])
result = self.job(identifier, self.manager.submit(identifier, "restore_session", {
"session_id": worker.active_identity}))["result"]
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(result["running"])
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
self.login(identifier)
self.assertFalse(worker.running, "Password login erased the same role's explicit Stop")
self.assertFalse(worker.engine.auto)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(self.manager.status(identifier)["manual_stop"])
def test_timeout_retries_only_snapshot_and_keeps_uncertain_write_evidence(self):
identifier, worker = self.connected(running=True)
@@ -127,6 +136,10 @@ class ConnectionStateTests(unittest.TestCase):
self.assertIsNone(self.manager.status(identifier)["next_retry_at"])
self.assertIsNotNone(self.manager.status(identifier)["last_game_success_at"])
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
self.assertFalse(self.manager.status(identifier)["manual_stop"])
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.
@@ -140,6 +153,9 @@ class ConnectionStateTests(unittest.TestCase):
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)
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(evidence.read_bytes(), before)
def test_business_rejection_keeps_connection_and_idle_does_not_clear_error(self):
identifier, worker = self.connected(running=True)
@@ -236,8 +252,8 @@ class ConnectionStateTests(unittest.TestCase):
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()
def test_failed_restore_and_login_candidates_preserve_online_client_and_monitor(self):
identifier, worker = self.connected(running=True)
client = worker.engine.client
original = deepcopy(self.manager.status(identifier))
response = self.expiry(worker)
@@ -250,6 +266,30 @@ class ConnectionStateTests(unittest.TestCase):
self.assertEqual(state["last_game_success_at"], original["last_game_success_at"])
self.assertEqual(state["connection_message"], original["connection_message"])
self.assertTrue(state["connected"])
for fail in (True, False):
with self.subTest(login_failure=fail):
before = len(fixtures.FakeClient.calls)
if fail:
with patch.object(fixtures.FakeLogin, "authenticate", side_effect=ApiError("Candidate login failed")):
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "synthetic-owner", "password": "synthetic-password"}), status="failed")
else:
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "synthetic-owner", "password": "synthetic-password"}))
self.assertIs(worker.engine.client, client)
self.assertFalse(client.closed)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(len(fixtures.FakeClient.calls), before,
"Server discovery issued old-role strategy writes inline")
self.now += 61
worker.engine.last_heartbeat = self.now
worker.schedule.next_poll = 0
with patch.object(worker.engine, "poll", wraps=worker.engine.poll) as poll:
self.tick(identifier, worker)
self.assertEqual(poll.call_count, 1, "An online role lost automatic polling after candidate login")
self.assertTrue(worker.schedule.monitoring)
self.assertTrue(worker.running)
def test_failed_same_protocol_restore_preserves_counter_high_water_before_wire_and_finally(self):
identifier, worker = self.connected()
@@ -321,7 +361,7 @@ class ConnectionStateTests(unittest.TestCase):
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"]))
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))
@@ -408,32 +448,41 @@ class ConnectionStateTests(unittest.TestCase):
self.assertEqual(messages[2], "账号工作区已载入")
self.assertFalse(any("无法持久保存" in message for message in messages[1:]))
def test_restart_and_explicit_logout_require_manual_restore(self):
def test_restart_and_logout_retain_explicit_stop_and_saved_login(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.manager = WebManager(self.root, start_scheduler=False, login_factory=AutoLogin)
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.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.assertTrue(state["manual_stop"])
self.assertFalse(state["strategy_requested"])
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}))
self.assertFalse(worker.running)
identity = worker.active_identity
self.job(identifier, self.manager.submit(identifier, "logout"))
calls = len(fixtures.FakeClient.calls)
self.now += 10000
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.securestore.active(), identity)
self.assertTrue(worker.securestore.load_credentials()[0])
self.assertEqual(self.manager.status(identifier)["auto_relogin_status"]["state"], "waiting")
# The delay is anchored in the restarted scheduler's own clock.
self.now = worker.schedule.disconnected_at + worker.config["auto_relogin"]["delay_minutes"] * 60
worker.schedule.clock = lambda: self.now
attempts = len(AutoLogin.calls)
self.tick(identifier, worker)
state = self.manager.status(identifier)
self.assertEqual(state["connection_state"], "offline")
self.assertIn("退出", state["connection_message"])
self.assertEqual(len(AutoLogin.calls), attempts + 1)
self.assertTrue(state["connected"])
self.assertEqual(state["auto_relogin_status"]["state"], "idle")
self.assertTrue(state["manual_stop"])
self.assertFalse(state["running"])
self.assertEqual(len(fixtures.FakeClient.calls), calls)
class ErrorClassificationTests(unittest.TestCase):
+346
View File
@@ -0,0 +1,346 @@
"""Durable user intent and recovery, using temporary stores and offline clients."""
from copy import deepcopy
import json
import math
import threading
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import requests
from ranch_assistant.api import ApiError, SessionExpiredError, encode
from ranch_web.policies import export_config
from ranch_web.service import WebManager
from ranch_web.tests import test_service as fixtures
from ranch_web.tests.test_auto_relogin import AutoLogin
class RunIntentTests(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, *, keep_login=False):
self.manager.login_factory = AutoLogin
identifier = self.account(False)
self.login(identifier, account="intent-owner-" + identifier[:8])
worker = self.manager._worker(identifier)
self.now = 1000.0
worker.schedule.clock = lambda: self.now
worker.schedule.uniform = lambda low, high: high
worker.engine.last_heartbeat = self.now
value = self.manager.get_config(identifier)["config"]
value["auto_relogin"] = {"enabled": keep_login, "delay_minutes": 10}
self.job(identifier, self.manager.set_config(identifier, value)["job"])
worker.schedule.next_poll = math.inf
return identifier, worker
def tick(self, identifier, worker, *, status="succeeded"):
return self.job(identifier, worker.enqueue("__tick"), status=status)
def fail_read(self, identifier, worker, error=None):
error = error or requests.ReadTimeout("offline synthetic timeout")
with patch.object(worker.engine.client.http, "post", side_effect=error) as post:
self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed")
self.assertEqual(post.call_count, 1)
def restart(self, identifier):
self.manager.close()
self.manager = WebManager(self.root, start_scheduler=False, login_factory=AutoLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
origin = worker.schedule.disconnected_at
self.now = origin if origin is not None else self.now
worker.schedule.clock = lambda: self.now
return worker
def pending(self, worker):
journal = worker.engine.battle_journal
record = journal.begin(worker.engine.snapshot, {"kind": "battle", "description": "unknown synthetic battle",
"path": "stageService/stageStart", "payload": {}, "stage_id": "0101", "difficulty": "1"})
journal.update(record, "unknown", message="请求结果未知,禁止自动重发")
return journal, journal.path.read_bytes()
def test_read_timeout_recovers_requested_execution_after_read_only_probe(self):
identifier, worker = self.connected()
self.assertTrue(worker.running)
self.fail_read(identifier, worker)
self.assertFalse(worker.running)
before = len(fixtures.FakeClient.calls)
self.now += 4
self.tick(identifier, worker)
self.assertEqual(len(fixtures.FakeClient.calls), before)
self.now += 1
self.tick(identifier, worker)
self.assertTrue(worker.running, "Successful retry restored online but permanently lost execution")
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertFalse(worker.engine.auto, "Reconnect verification enabled writes in its own job")
self.assertEqual([url.rsplit("/", 2)[-2:] for _, url, _ in fixtures.FakeClient.calls[before:]],
[["masterService", "masterQueryDetail"]])
worker.engine.last_heartbeat = self.now
worker.schedule.next_poll = 0
with patch.object(worker.engine, "master_sync_due", return_value=False), \
patch.object(worker.engine, "growth_sync_due", return_value=False), \
patch.object(worker.engine, "poll", wraps=worker.engine.poll) as poll:
self.tick(identifier, worker)
self.assertEqual(poll.call_count, 1)
self.assertTrue(worker.running)
def test_only_explicit_stop_persists_and_start_clears_it(self):
identifier, worker = self.connected()
identity = worker.active_identity
worker.stop() # Desktop adapter / cancellation is not the Stop button.
self.tick(identifier, worker)
self.assertTrue(worker.running)
self.manager.submit(identifier, "stop")
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
self.assertFalse(worker.running, "Activation erased the user's explicit Stop")
worker = self.restart(identifier)
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
self.assertFalse(worker.running)
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(self.manager.status(identifier)["manual_stop"])
worker = self.restart(identifier)
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
self.assertTrue(worker.running)
def test_stop_does_not_cancel_offline_password_reconnect(self):
identifier, worker = self.connected(keep_login=True)
self.fail_read(identifier, worker, SessionExpiredError("offline expired", code=408))
self.manager.submit(identifier, "stop")
before = len(AutoLogin.calls)
self.now += 599
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before)
self.now += 1
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertFalse(worker.running)
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
def test_logout_keeps_identity_credentials_and_reconnects_even_legacy_disabled(self):
identifier, worker = self.connected()
identity = worker.active_identity
self.job(identifier, self.manager.submit(identifier, "logout"))
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.securestore.active(), identity)
self.assertTrue(worker.securestore.load_credentials()[0])
before = len(AutoLogin.calls)
self.now += 600
self.tick(identifier, worker)
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertTrue(worker.running)
def test_startup_migrates_saved_identity_and_reconnects_without_button(self):
identifier, worker = self.connected()
identity = worker.active_identity
# Old installations have no intent file and could save enabled=False.
local = self.manager.store.load_config(worker._login_settings_root)
local["config"]["auto_relogin"]["enabled"] = False
self.manager.store.save_config(worker._login_settings_root, local["config"], local["revision"])
worker = self.restart(identifier)
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertTrue(worker.config["auto_relogin"]["enabled"])
self.assertIsNotNone(state["auto_relogin_status"]["next_attempt_at"])
self.now += 600
self.tick(identifier, worker)
self.assertTrue(worker.running)
self.assertEqual(worker.active_identity, identity)
def test_pending_barrier_keeps_requested_intent_and_resumes_after_resolution(self):
identifier, worker = self.connected()
journal, evidence = self.pending(worker)
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}))
state = self.manager.status(identifier)
self.assertFalse(state["running"])
self.assertTrue(state["strategy_requested"])
self.assertEqual(state["strategy_state"], "blocked")
self.assertIn("核对", state["strategy_message"])
self.assertEqual(journal.path.read_bytes(), evidence)
self.manager.submit(identifier, "stop")
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.assertTrue(self.manager.status(identifier)["strategy_requested"], "Start must clear Stop even while blocked")
self.assertEqual(journal.path.read_bytes(), evidence)
with patch.object(worker.engine, "_progression_pending", return_value=None):
self.tick(identifier, worker)
self.assertTrue(worker.running)
def test_intent_is_separate_from_portable_policy_and_scoped_to_role(self):
identifier, worker = self.connected()
first = worker.active_identity
config = deepcopy(worker.config)
self.manager.submit(identifier, "stop")
self.assertEqual(worker.config, config)
intent_path = worker.profile_root / "run_intent.json"
self.assertTrue(intent_path.is_file())
portable = json.dumps(export_config(worker.config))
for value in ("strategy_requested", "manual_stop", "intent-owner", first):
self.assertNotIn(value, portable)
self.login(identifier, account=worker._saved_account, server=2)
self.assertTrue(worker.running, "A different role inherited the first role's Stop")
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": first}))
self.assertFalse(worker.running)
def test_manual_refresh_does_not_enable_auto_inside_snapshot_callback(self):
identifier, worker = self.connected()
self.fail_read(identifier, worker)
self.now += 5
self.tick(identifier, worker)
seen = []
def read_only(*args, **kwargs):
worker.engine.read_snapshot(sync_master=False)
seen.append(worker.engine.auto)
return worker.engine.snapshot, [], "synthetic preview"
with patch.object(worker.engine, "poll", side_effect=read_only):
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertEqual(seen, [False])
self.assertTrue(worker.running)
def test_stop_racing_retry_callback_wins_without_disabling_keep_login(self):
identifier, worker = self.connected()
self.fail_read(identifier, worker)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker.engine.client.http.post
def held(*args, **kwargs):
entered.set()
if not release.wait(5):
raise AssertionError("offline retry gate not released")
return original(*args, **kwargs)
self.now += 5
with patch.object(worker.engine.client.http, "post", side_effect=held):
job = worker.enqueue("__tick")
self.assertTrue(entered.wait(5))
self.manager.submit(identifier, "stop")
release.set()
self.job(identifier, job)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertFalse(self.manager.status(identifier)["strategy_requested"])
def test_failed_candidate_login_rearms_existing_online_monitor(self):
identifier, worker = self.connected()
original = worker.engine.client
with patch.object(AutoLogin, "authenticate", side_effect=ValueError("synthetic candidate failure")):
self.job(identifier, self.manager.submit(identifier, "login", {
"account": worker._saved_account, "password": "synthetic-password"}), status="failed")
self.assertIs(worker.engine.client, original)
self.assertTrue(worker.schedule.monitoring)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.now += 5
with patch.object(worker.engine, "master_sync_due", return_value=False), \
patch.object(worker.engine, "growth_sync_due", return_value=False), \
patch.object(worker.engine, "poll", wraps=worker.engine.poll) as poll:
self.tick(identifier, worker)
self.assertEqual(poll.call_count, 1)
self.assertTrue(worker.running)
def test_transient_local_planner_error_has_bounded_backoff_without_stop_intent(self):
identifier, worker = self.connected()
worker.schedule.next_poll = 0
with patch.object(worker.engine, "master_sync_due", return_value=False), \
patch.object(worker.engine, "growth_sync_due", return_value=False), \
patch.object(worker.engine, "poll", side_effect=ValueError("synthetic planner unavailable")) as poll:
self.tick(identifier, worker, status="failed")
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertEqual(state["strategy_state"], "recovering")
self.assertIsNotNone(state["strategy_retry_at"])
self.assertEqual(worker._execution_retry_deadline, self.now + 5)
for _ in range(3):
self.tick(identifier, worker)
self.assertEqual(poll.call_count, 1)
self.now += 60 # Scheduler also applies its per-kind failure cooldown.
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)
self.assertTrue(worker.running)
self.assertIsNone(self.manager.status(identifier)["strategy_retry_at"])
def test_decoded_read_business_rejection_gets_execution_backoff(self):
identifier, worker = self.connected()
worker.schedule.next_poll = 0
with patch.object(worker.engine.client.http, "post", side_effect=ApiError("synthetic rejection", code=403)) as post:
self.tick(identifier, worker, status="failed")
self.assertEqual(post.call_count, 1)
self.assertFalse(worker.running)
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertEqual(state["strategy_state"], "recovering")
self.assertIsNotNone(state["strategy_retry_at"])
self.assertEqual(state["connection_state"], "online")
def test_uncertain_journaled_write_is_never_replayed_after_recovery(self):
identifier, worker = self.connected()
journal, evidence = self.pending(worker)
self.fail_read(identifier, worker)
before = len(fixtures.FakeClient.calls)
self.now += 5
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
self.assertEqual(journal.path.read_bytes(), evidence)
for _ in range(3):
self.now += 600
self.tick(identifier, worker)
self.assertEqual(journal.path.read_bytes(), evidence)
self.assertTrue(all(url.endswith(("masterService/masterQueryDetail", "heartBeatService/keepAlive"))
for _, url, _ in fixtures.FakeClient.calls[before:]))
def test_legacy_gift_unchanged_mixed_timestamp_units_stay_blocked_until_confirmed(self):
identifier, worker = self.connected()
mid = next(iter(worker.engine.snapshot.monsters))
original_time = 1_000_000_000
worker.engine.snapshot.monsters[mid]["giftTime"] = original_time
raw = next(mon for mon in worker.engine.client.raw["monsters"] if mon["id"] == mid)
raw["giftTime"] = original_time * 1000
def gift(*args):
worker.engine.client.call("monsterService/monsterSendGift", {"monsterId": mid, "itemId": 1})
return {"message": "synthetic response lacks gift confirmation"}
with patch("ranch_web.actions.execute_action", side_effect=gift):
self.job(identifier, self.manager.submit(identifier, "consume_probe"))
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked",
"Unchanged milliseconds were mistaken for a later gift than cached seconds")
raw["giftTime"] = (original_time + 60) * 1000
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertTrue(worker.running)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
def test_valid_gift_response_confirms_cooldown_without_waiting_for_role_read(self):
identifier, worker = self.connected()
mid = next(iter(worker.engine.snapshot.monsters))
worker.engine.snapshot.monsters[mid]["giftTime"] = 1_000_000_000
response = SimpleNamespace(status_code=200, headers={}, content=encode(
{"resCode": 0, "feel": 20, "giftDate": 1_000_000_060_000}, worker.engine.client.session.key))
def gift(*args):
worker.engine.client.call("monsterService/monsterSendGift", {"monsterId": mid, "itemId": 1})
return {"message": "synthetic confirmed gift"}
with patch("ranch_web.actions.execute_action", side_effect=gift), \
patch.object(worker.engine.client.http, "post", return_value=response):
self.job(identifier, self.manager.submit(identifier, "consume_probe"))
self.assertTrue(worker.running)
self.assertNotIn(worker.active_identity, worker._legacy_pending)
if __name__ == "__main__":
unittest.main()
+251
View File
@@ -0,0 +1,251 @@
"""Recovery deadlines and loop isolation with fake clocks and no transports."""
import math
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
from ranch_web.scheduler import AccountSchedule, FAST_KINDS, Scheduler
class SchedulerRecoveryTests(unittest.TestCase):
def setUp(self):
self.now = 1000.0
self.wall = 5000.0
self.schedule = AccountSchedule(clock=lambda: self.now,
wall_clock=lambda: self.wall, uniform=lambda low, high: high)
self.config = {"interval": 30, "auto_relogin": {"enabled": False}}
self.snapshot = SimpleNamespace(now=1000, raw={"exploreTeams": []})
self.engine = SimpleNamespace(demo=False, client=object(), snapshot=self.snapshot,
heartbeat_enabled=True, last_heartbeat=self.now,
pending_recovery_due=lambda: False, master_sync_due=lambda: False,
growth_sync_due=lambda: False, _progression_pending=lambda: None,
_breakthrough_pending=None, pending_hatches=[object()],
explore_planner=SimpleNamespace(pending=lambda snapshot: None),
gift_planner=SimpleNamespace(next_ready_at=None))
self.schedule.monitor()
def due(self, running=False):
return self.schedule.due(self.engine, self.config, running)
def test_stopped_strategy_repeats_password_login_at_configured_or_default_delay(self):
for preference, delay in (({"enabled": True, "delay_minutes": 10}, 600),
({"enabled": True}, 1800)):
with self.subTest(preference=preference):
self.setUp()
self.config["auto_relogin"] = preference
self.schedule.disconnected()
self.schedule.game_failed()
self.schedule.stop()
origin = self.schedule.disconnected_at
for attempt in range(3):
deadline = self.schedule.auto_relogin_deadline(self.config)
self.now = deadline - .001
self.assertIsNone(self.due())
self.now = deadline
self.assertEqual(self.due(), "auto_relogin")
self.now += 7 # Authentication consumes time before failing.
self.schedule.auto_relogin_failed()
self.assertEqual(self.schedule.auto_relogin_deadline(self.config), self.now + delay)
self.assertEqual(self.schedule.disconnected_at, origin)
self.assertIsNone(self.due())
def test_retries_and_settings_changes_keep_original_outage(self):
self.schedule.disconnected()
origin = (self.schedule.disconnected_at, self.schedule.disconnected_wall_at)
self.now += 100
self.wall += 10000
self.schedule.game_failed(retry=True)
self.schedule.disconnected()
self.config["auto_relogin"] = {"enabled": True, "delay_minutes": 10}
self.assertEqual(self.schedule.auto_relogin_deadline(self.config), 1600)
self.assertEqual((self.schedule.disconnected_at, self.schedule.disconnected_wall_at), origin)
self.config["auto_relogin"]["delay_minutes"] = 30
self.assertEqual(self.schedule.auto_relogin_deadline(self.config), 2800)
def test_password_login_due_outranks_read_probe_even_when_stopped(self):
self.config["auto_relogin"] = {"enabled": True, "delay_minutes": 10}
self.schedule.disconnected()
self.schedule.game_failed(retry=True)
self.now += 600
self.assertEqual(self.due(), "auto_relogin")
self.config["auto_relogin"]["enabled"] = False
self.assertEqual(self.due(), "retry")
def test_read_probe_backoff_caps_at_sixty_seconds_and_resets_on_recovery(self):
for delay in (5, 10, 20, 40, 60, 60, 60):
self.assertEqual(self.schedule.game_failed(retry=True), delay)
self.assertTrue(self.schedule.monitoring)
self.assertIsNone(self.due(running=True))
self.now += delay - .001
self.assertIsNone(self.due(running=True))
self.now += .001
self.assertEqual(self.due(running=True), "retry")
self.schedule.game_resumed()
self.assertEqual(self.schedule.game_failed(retry=True), 5)
def test_stop_preserves_monitoring_outage_and_pending_probe(self):
self.schedule.disconnected()
self.schedule.game_failed(retry=True)
retry = self.schedule.retry_deadline
self.schedule.stop()
self.assertTrue(self.schedule.monitoring)
self.assertEqual(self.schedule.retry_deadline, retry)
self.assertEqual(self.schedule.disconnected_at, 1000)
self.now = retry
self.assertEqual(self.due(), "retry")
def test_recovery_rearms_poll_without_enabling_fast_strategies(self):
for deadline in (math.inf, self.now + 3600):
with self.subTest(deadline=deadline):
self.schedule.game_failed(retry=True)
self.schedule.next_poll = deadline
self.schedule.game_resumed()
self.assertFalse(self.schedule.game_paused)
self.assertIsNone(self.schedule.retry_deadline)
self.assertEqual(self.schedule.next_poll, self.now)
self.assertEqual(self.due(), "poll")
self.assertTrue(all(math.isinf(value) for value in self.schedule.next_fast.values()))
def test_ordinary_success_preserves_armed_monitor_deadline(self):
for deadline in (self.now - 30, self.now + 30):
with self.subTest(deadline=deadline):
self.schedule.next_poll = deadline
self.schedule.game_resumed()
self.assertEqual(self.schedule.next_poll, deadline)
def test_recovery_keeps_explicitly_disabled_monitor_disabled(self):
self.schedule.monitor(False)
self.schedule.game_failed(retry=True)
self.schedule.game_resumed()
self.assertFalse(self.schedule.monitoring)
self.assertEqual(self.schedule.next_poll, math.inf)
self.assertIsNone(self.due())
def test_success_can_preserve_failed_auth_origin_until_verified_recovery(self):
self.config["auto_relogin"] = {"enabled": True, "delay_minutes": 10}
self.schedule.disconnected()
self.now += 600
self.schedule.auto_relogin_failed()
deadline = self.schedule.auto_relogin_deadline(self.config)
origin = (self.schedule.disconnected_at, self.schedule.disconnected_wall_at)
self.schedule.game_resumed(clear_disconnection=False)
self.assertEqual(self.schedule.auto_relogin_deadline(self.config), deadline)
self.assertEqual((self.schedule.disconnected_at, self.schedule.disconnected_wall_at), origin)
self.assertEqual(self.schedule.auto_relogin_failed_at, self.now)
self.schedule.game_resumed()
self.assertIsNone(self.schedule.auto_relogin_deadline(self.config))
self.assertIsNone(self.schedule.auto_relogin_failed_at)
def test_continuously_due_maintenance_cannot_starve_snapshot_poll(self):
for kind in ("heartbeat", "reconcile", "master_sync", "growth_sync"):
with self.subTest(kind=kind):
self.setUp()
if kind == "heartbeat":
self.engine.last_heartbeat = 0
else:
predicate = {"reconcile": "pending_recovery_due", "master_sync": "master_sync_due",
"growth_sync": "growth_sync_due"}[kind]
setattr(self.engine, predicate, lambda: True)
self.assertEqual(self.due(), kind)
self.schedule.game_resumed(clear_disconnection=False)
self.assertEqual(self.due(), "poll")
self.schedule.poll_finished(self.config)
self.now += 30
self.assertEqual(self.due(), kind)
self.assertEqual(self.due(), "poll")
def test_continuously_due_hatch_cannot_starve_snapshot_poll(self):
self.schedule.next_fast["hatch"] = self.now
self.assertEqual(self.due(running=True), "hatch")
self.assertEqual(self.due(running=True), "poll")
def test_failed_poll_cools_down_even_when_random_interval_is_zero(self):
self.schedule.uniform = lambda low, high: 0
self.schedule.maintenance_failed("poll")
self.schedule.poll_finished(self.config)
self.assertIsNone(self.due())
self.now += 29.999
self.assertIsNone(self.due())
self.now += .001
self.assertEqual(self.due(), "poll")
def test_failed_fast_kind_cools_down_without_blocking_monitor(self):
for kind in FAST_KINDS:
with self.subTest(kind=kind):
self.setUp()
self.schedule.next_fast[kind] = self.now
self.schedule.maintenance_failed(kind)
self.assertEqual(self.due(running=True), "poll")
self.schedule.next_poll = math.inf
self.now += 29.999
self.assertIsNone(self.due(running=True))
self.now += .001
self.assertEqual(self.due(running=True), kind)
def test_paused_session_allows_no_maintenance_or_strategy_without_probe(self):
self.engine.last_heartbeat = 0
self.schedule.next_fast = dict.fromkeys(FAST_KINDS, self.now)
self.schedule.game_failed()
self.now += 10000
self.assertIsNone(self.due(running=True))
def test_paused_game_does_not_rearm_fast_tasks_from_durable_run_intent(self):
self.config["policy"] = {"enabled": True, "fill": True}
self.schedule.game_failed(retry=True)
self.schedule.arm(self.engine, self.config, True)
self.assertTrue(all(math.isinf(value) for value in self.schedule.next_fast.values()))
def test_recovery_keeps_all_uncertain_write_barriers(self):
unknown = {"phase": "unknown", "attempt_id": "offline-attempt"}
self.config["policy"] = {"enabled": True, "fill": True}
for kind in ("progression", "explore", "breakthrough"):
with self.subTest(kind=kind):
self.engine._progression_pending = lambda: unknown if kind == "progression" else None
self.engine.explore_planner.pending = lambda snapshot: unknown if kind == "explore" else None
self.engine._breakthrough_pending = unknown if kind == "breakthrough" else None
self.schedule.game_failed(retry=True)
self.schedule.game_resumed()
self.schedule.arm(self.engine, self.config, True)
self.assertTrue(all(math.isinf(value) for value in self.schedule.next_fast.values()))
self.assertEqual(unknown, {"phase": "unknown", "attempt_id": "offline-attempt"})
class SchedulerLoopRecoveryTests(unittest.TestCase):
def run_passes(self, workers, passes):
# Run the real loop synchronously. The fake event ends it after exact passes.
with patch("ranch_web.scheduler.threading.Thread"):
scheduler = Scheduler(workers)
scheduler.closed = Mock()
scheduler.closed.wait.side_effect = [False] * passes + [True]
with self.assertLogs("ranch_web.scheduler", level="ERROR"):
scheduler._run()
return scheduler
def test_one_broken_account_does_not_kill_other_account_or_next_pass(self):
first = SimpleNamespace(request_tick=Mock(side_effect=RuntimeError("offline queue error")))
second = SimpleNamespace(request_tick=Mock())
scheduler = self.run_passes(lambda: [first, second], 3)
self.assertEqual(first.request_tick.call_count, 3)
self.assertEqual(second.request_tick.call_count, 3)
self.assertEqual(scheduler.closed.wait.call_count, 4)
def test_registry_failure_recovers_on_next_pass(self):
first, second = SimpleNamespace(request_tick=Mock()), SimpleNamespace(request_tick=Mock())
workers = Mock(side_effect=[RuntimeError("offline registry error"), [first, second]])
self.run_passes(workers, 2)
first.request_tick.assert_called_once_with()
second.request_tick.assert_called_once_with()
def test_lazy_registry_failure_does_not_stop_future_passes(self):
worker = SimpleNamespace(request_tick=Mock())
def workers():
yield worker
raise RuntimeError("offline iterator error")
self.run_passes(workers, 2)
self.assertEqual(worker.request_tick.call_count, 2)
if __name__ == "__main__":
unittest.main()
+149 -9
View File
@@ -17,7 +17,7 @@ from requests.sessions import Session as HttpSession
from ranch_assistant.api import Client, Session, decode, encode
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog
from ranch_assistant.model import Action, Catalog
from ranch_web.service import RevisionConflict, WebManager
from ranch_web.store import session_identity
@@ -162,7 +162,8 @@ class ServiceTests(unittest.TestCase):
restored = self.manager._worker(identifier).securestore.load(identity)
self.assertGreater(restored.reqid, before)
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(self.manager._worker(identifier).engine.auto)
self.assertFalse(self.manager._worker(identifier).engine.auto,
"Restoring a connection must not run selected writes inline")
def test_verified_login_starts_only_saved_selections_after_server_activation(self):
identifier = self.account(False)
@@ -180,7 +181,7 @@ class ServiceTests(unittest.TestCase):
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Server activation must not execute selected writes inline")
self.assertEqual(worker.config, selected, "Login changed the user's strategy selections")
self.assertIn("已勾选", result["message"])
self.assertEqual(self.manager.logs(identifier)["entries"][-1]["message"], result["message"])
@@ -193,10 +194,13 @@ class ServiceTests(unittest.TestCase):
"account": "synthetic-owner", "password": "synthetic-password"}))
worker = self.manager._worker(identifier)
selected = deepcopy(worker.config)
# First activation migrates the login preference to keep-login. The
# strategy selections themselves must remain identical.
selected["auto_relogin"]["enabled"] = True
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Server activation must not execute selected writes inline")
self.assertEqual(worker.config, selected)
self.assertIn("已勾选", result["message"])
self.assertEqual(worker.engine.plans(), [])
@@ -210,8 +214,11 @@ class ServiceTests(unittest.TestCase):
for _, url, _ in FakeClient.calls[before:]))
self.enable(identifier)
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Saving selections must not authorize writes inline")
self.assertTrue(worker.engine.daily_policy.enabled)
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.engine.auto)
def test_restore_with_unknown_write_keeps_evidence_and_never_replays(self):
identifier = self.account(False)
@@ -230,6 +237,9 @@ class ServiceTests(unittest.TestCase):
self.assertFalse(result["running"])
self.assertFalse(worker.engine.auto)
self.assertIn("核对", result["message"])
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
self.assertFalse(self.manager.status(identifier)["manual_stop"])
self.assertEqual(journal.path.read_bytes(), evidence)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
worker.engine.last_heartbeat = worker.schedule.clock()
@@ -240,6 +250,9 @@ class ServiceTests(unittest.TestCase):
for _, url, _ in FakeClient.calls[before:]))
def test_activation_persistence_can_be_revoked_before_final_commit(self):
other = self.account(False)
self.login(other, account="independent-owner")
self.enable(other)
for operation in ("enter_server", "restore_session"):
for revoke in ("stop", "logout", "forget_login", "config"):
with self.subTest(operation=operation, revoke=revoke):
@@ -275,11 +288,16 @@ class ServiceTests(unittest.TestCase):
else:
followup = self.manager.submit(identifier, revoke)
self.assertFalse(worker.running)
self.assertTrue(self.manager.status(other)["running"], "Cancellation leaked to another account")
release.set()
self.job(identifier, candidate, status="cancelled")
self.job(identifier, followup)
self.assertFalse(worker.running)
self.assertEqual(worker.running, revoke == "config",
"Only explicit Stop can persistently stop the still-online original role")
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(other)["running"])
self.assertFalse(self.manager.status(other)["manual_stop"])
self.assertEqual(self.manager.status(identifier)["manual_stop"], revoke == "stop")
if revoke in {"stop", "config"}:
self.assertIs(worker.engine.client, original_client)
else:
@@ -351,6 +369,28 @@ class ServiceTests(unittest.TestCase):
self.assertEqual(calls, ["refresh", "refresh"])
self.assertFalse(self.manager._worker(identifier).engine.auto)
self.assertTrue(self.manager._worker(identifier).engine._progression_cancel.is_set())
worker = self.manager._worker(identifier)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker._set_strategy_requested
def persist(requested):
if requested:
entered.set()
if not release.wait(5):
raise AssertionError("Start intent gate not released")
return original(requested)
with patch.object(worker, "_set_strategy_requested", side_effect=persist):
starting = self.manager.submit(identifier, "start")
self.assertTrue(entered.wait(2))
self.manager.submit(identifier, "stop")
release.set()
self.job(identifier, starting, status="cancelled")
state = self.manager.status(identifier)
self.assertFalse(state["strategy_requested"], "A canceled Start overwrote the later durable Stop")
self.assertTrue(state["manual_stop"])
self.assertFalse(state["running"])
def test_policy_queued_before_stop_saves_without_reactivating(self):
identifier = self.account()
@@ -415,7 +455,13 @@ class ServiceTests(unittest.TestCase):
result = self.job(identifier, self.manager.submit(identifier, "lock", {"monster_ids": [monster["id"]]}))
self.assertTrue(worker.engine.snapshot.monsters[monster["id"]]["lock"])
self.assertIn("message", result["result"])
self.assertFalse(worker.running)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertFalse(self.manager.status(identifier)["manual_stop"])
worker.engine.last_heartbeat = worker.schedule.clock()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.running, "The manual helper persisted an implicit Stop")
self.assertEqual(sum(url.endswith("monsterService/monsterLock") for _, url, _ in FakeClient.calls), 1)
def test_enter_job_is_not_terminal_until_persistence_and_summary_are_published(self):
identifier = self.account(False)
@@ -574,10 +620,14 @@ class ServiceTests(unittest.TestCase):
release.set()
self.job(identifier, pending["job"])
self.assertTrue(self.manager.status(identifier)["running"], "Config cancellation disabled the execution switch")
self.assertTrue(worker.engine.auto)
self.assertFalse(worker.engine.auto, "Config persistence must not authorize writes inline")
self.assertEqual(worker.engine.policy.keep_money, config["policy"]["keep_money"])
worker.engine.last_heartbeat = time.monotonic()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.engine.auto)
def test_engine_pause_in_current_generation_still_disables_execution(self):
def test_engine_pause_keeps_request_and_blocks_unconfirmed_legacy_writes(self):
identifier = self.account()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
@@ -593,6 +643,96 @@ class ServiceTests(unittest.TestCase):
self.idle(identifier)
self.assertFalse(self.manager.status(identifier)["running"])
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertFalse(self.manager.status(identifier)["manual_stop"])
# These legacy paths disable Engine.auto after an unconfirmed result
# without creating a battle/exploration pending record. Restoring user
# intent must preserve a write barrier across reads and process restart.
for kind in ("gift", "hatch", "feed"):
with self.subTest(kind=kind):
identifier = self.account(False)
self.login(identifier, account="legacy-" + identifier)
worker = self.manager._worker(identifier)
identity = worker.active_identity
clock = [1000.0]
worker.schedule.clock = lambda: clock[0]
worker.engine.last_heartbeat = clock[0]
monsters = list(worker.engine.snapshot.monsters)
if kind == "gift":
# Engine overlays confirmed gift timestamps in seconds,
# while an unchanged raw server snapshot uses milliseconds.
mon = next(row for row in worker.engine.client.raw["monsters"] if row["id"] == monsters[0])
mon["giftTime"] = 1_700_000_000_000
worker.engine.gift_planner.confirmed[monsters[0]] = {
"owner": str(worker.engine.snapshot.raw["master"]["id"]),
"type": str(mon["typeId"]), "feel": int(mon.get("feel") or 0),
"giftTime": 1_700_000_060}
action = Action(kind, "Unconfirmed gift", "monsterService/monsterSendGift",
{"monsterId": monsters[0], "itemId": 1})
elif kind == "hatch":
slot = worker.engine.client.raw["stacks"][0]
slot["monsterId"] = -1
action = Action(kind, "Unconfirmed hatch", "stackService/stackAddMonster",
{"eggs": [{"itemId": 1, "stackId": slot["id"]}]})
worker.engine.pending_hatches = [action]
else:
action = Action(kind, "Unconfirmed feed", "monsterService/monsterIntensify",
{"targetId": monsters[0], "foods": [monsters[1]]})
before = len(FakeClient.calls)
with patch.object(worker.engine, "plans", return_value=[action]):
if kind == "hatch":
worker.schedule.next_fast[kind] = 0
worker.schedule.next_poll = float("inf")
else:
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"), status="failed")
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1)
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertFalse(state["running"])
self.job(identifier, self.manager.submit(identifier, "refresh"))
for _ in range(3):
clock[0] += 121
worker.engine.last_heartbeat = clock[0]
worker.schedule.next_poll = 0
tick = worker.enqueue("__tick")
self.idle(identifier)
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Unchanged snapshots allowed an unconfirmed legacy write to replay")
self.assertEqual(self.manager.job(identifier, tick["id"])["status"], "succeeded")
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Unchanged snapshots allowed an unconfirmed legacy write to replay")
self.assertEqual(self.manager.status(identifier)["strategy_state"], "blocked")
unchanged = deepcopy(worker.engine.client.raw)
self.manager.close()
self.manager = WebManager(self.root, start_scheduler=False, login_factory=FakeLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
def restore(session, *, trace):
candidate = FakeClient(session, trace=trace)
candidate.raw = deepcopy(unchanged)
return candidate
worker._restore_factory = restore
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
worker = self.manager._worker(identifier)
with patch.object(worker.engine, "plans", return_value=[action]):
if kind == "hatch":
worker.engine.pending_hatches = [action]
worker.schedule.next_fast[kind] = 0
worker.engine.last_heartbeat = worker.schedule.clock()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertEqual(sum(url.endswith(action.path) for _, url, _ in FakeClient.calls[before:]), 1,
"Restart discarded the unconfirmed legacy write barrier")
state = self.manager.status(identifier)
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertEqual(state["strategy_state"], "blocked")
def test_view_task_indices_stay_bounded_after_many_filters_and_failure(self):
identifier = self.account()
+7 -3
View File
@@ -43,6 +43,7 @@ class TaskLogTests(unittest.TestCase):
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
login = fixtures.ServiceTests.login
enable = fixtures.ServiceTests.enable
def tick(self, identifier, kind, *, status="succeeded"):
worker = self.manager._worker(identifier)
@@ -129,11 +130,14 @@ class TaskLogTests(unittest.TestCase):
self.assertEqual(self.entries(identifier, after)[0]["category"], "general")
def test_fast_and_auth_errors_keep_source_category_and_error_level(self):
identifier = self.account()
worker = self.manager._worker(identifier)
for kind, category in (("hatch", "hatching"), ("gift", "gifts"), ("explore", "exploration"), ("breakthrough", "ranch"), ("auto_relogin", "login")):
with self.subTest(kind=kind):
worker._running = True
# Each error owns a bounded retry deadline. Use independent
# enabled workers so one error cannot suppress the next case.
identifier = self.account()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
worker = self.manager._worker(identifier)
after = self.manager.logs(identifier)["next"]
with patch.object(worker.engine, "poll_automation", side_effect=ValueError("task failed")), \
patch.object(worker, "_auto_relogin_status", return_value={"state": "waiting"}), \
+18 -4
View File
@@ -432,7 +432,7 @@ class WebIntegrationTests(unittest.TestCase):
point = next(point for point in dto["chart"]["series"] if point["id"] == "item:30005")
self.assertAlmostEqual(point["value"], .2)
def test_dto_egg_edit_autosaves_into_real_engine_plan_and_restart_stays_stopped(self):
def test_dto_egg_edit_autosaves_and_restart_preserves_explicit_execution_request(self):
config, row = self.hatch_config()
column = next(column for column in self.view("bag")["columns"] if column["key"] == "enabled")
self.assertEqual([row["id"] if part == "{id}" else part for part in column["edit"]["path"]], row["rule_path"] + ["enabled"])
@@ -454,7 +454,10 @@ class WebIntegrationTests(unittest.TestCase):
self.app.state.manager = self.manager
self.wait_idle()
self.assertEqual(self.config(), applied)
self.assertFalse(self.manager.status(self.account)["running"])
state = self.manager.status(self.account)
self.assertTrue(state["running"])
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertFalse(self.manager._worker(self.account).engine.auto)
def test_same_species_config_and_catalog_overrides_are_independent_between_accounts(self):
@@ -541,7 +544,7 @@ class WebIntegrationTests(unittest.TestCase):
self.assertFalse(self.manager._worker(account).engine.auto)
self.assertEqual(client.writes, [])
def test_legacy_schema_one_import_is_a_job_and_never_starts_engine(self):
def test_legacy_schema_one_import_preserves_execution_request_without_inline_writes(self):
from ranch_assistant.model import Policy
from ranch_assistant.policy_io import portable_policy
@@ -555,10 +558,21 @@ class WebIntegrationTests(unittest.TestCase):
before = deepcopy(engine.snapshot.raw)
value = self.response(self.http.post(self.path("config/import"), json={"config": bundle}), 202)
self.job(value)
self.assertFalse(self.manager.status(self.account)["running"])
state = self.manager.status(self.account)
self.assertTrue(state["running"])
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertFalse(engine.auto)
self.assertEqual(engine.snapshot.raw, before)
self.assertTrue(self.config()["config"]["policy"]["egg_rules"][row["id"]]["enabled"])
self.action("stop")
self.job(self.response(self.http.post(self.path("config/import"), json={"config": bundle}), 202))
state = self.manager.status(self.account)
self.assertFalse(state["running"])
self.assertFalse(state["strategy_requested"])
self.assertTrue(state["manual_stop"])
self.assertFalse(engine.auto)
self.assertEqual(engine.snapshot.raw, before)
exported = self.job(self.response(self.http.get(self.path("config/export")), 202))["result"]
self.assertEqual(exported["schema"], 2)
self.assertEqual(exported["format"], "ranch-helper-policies")
+2 -4
View File
@@ -91,10 +91,8 @@ def _strategy_fields(catalog):
"exploration": [_field(["explore_policy", "enabled"], "自动安排再次探险(完成后自动领奖)"),
_field(["explore_policy", "reserve_ti"], "保留体力", "integer", min=0, max=1_000_000_000)],
"yields": [_field(["yield_stars"], "星级", "multiselect", options=_options([(i, f"{i}星") for i in range(1, 6)]))],
"login": [_field(["auto_relogin", "enabled"], "掉线后自动重新登录", value=False,
help="需在服务端记住账号和密码,并已保存原区服和角色;开启后,掉线或服务重启均等待设定时长,再返回原区服、原角色。"),
_field(["auto_relogin", "delay_minutes"], "重登等待时长(分钟)", "integer", min=1, max=10080, value=30,
help="1~10080 的整数分钟,默认 30 分钟。重登成功恢复监控并自动执行已勾选功能,可在顶部“停止”;关闭页面不影响服务端自动重登,手动退出登录可取消本次安排。")],
"login": [_field(["auto_relogin", "delay_minutes"], "重登等待时长(分钟)", "integer", min=1, max=10080, value=30,
help="1~10080 的整数分钟,默认 30 分钟。登录并保存原区服、原角色后,掉线、退出登录或服务重启均自动重登并恢复监控。顶部“停止”仅暂停执行,重新登录后仍保持暂停;只有清除登录记录或删除账号才取消自动重登。")],
"incubator": [], "bag": [], "ranch": [], "battles": [], "statistics": [], "plans": []}