From 9f3945a717f29b65634e462fa5aa1549f40f3730 Mon Sep 17 00:00:00 2001 From: AttilaNet Date: Sat, 14 Nov 2026 10:56:43 +0800 Subject: [PATCH] fix: recover interrupted Web battles in 2.0.10 --- .github/workflows/web-image.yml | 14 + Dockerfile | 2 +- README.md | 12 +- analysis/RELEASE_2_0_10.md | 23 + compose.yaml | 4 +- deploy/web/README.md | 18 +- deploy/web/image.env.example | 4 +- ranch_assistant/battle_simulator.py | 25 +- ranch_assistant/battles.py | 317 +++++++++-- ranch_assistant/engine.py | 69 ++- .../test_battle_capability_presentation.py | 139 +++++ ranch_assistant/tests/test_battle_recovery.py | 492 ++++++++++++++++++ .../tests/test_battle_worker_transport.py | 146 ++++++ ranch_web/PRODUCT.md | 22 +- ranch_web/README.md | 18 +- ranch_web/__init__.py | 2 +- ranch_web/app.py | 4 +- ranch_web/service.py | 84 ++- ranch_web/static/app.js | 4 +- ranch_web/static/index.html | 2 +- .../tests/test_battle_recovery_contract.py | 247 +++++++++ ranch_web/tests/test_lifecycle_recovery.py | 345 ++++++++++++ ranch_web/tests/test_status_recovery_api.py | 44 ++ ranch_web/views.py | 2 +- 24 files changed, 1912 insertions(+), 127 deletions(-) create mode 100644 analysis/RELEASE_2_0_10.md create mode 100644 ranch_assistant/tests/test_battle_capability_presentation.py create mode 100644 ranch_assistant/tests/test_battle_recovery.py create mode 100644 ranch_assistant/tests/test_battle_worker_transport.py create mode 100644 ranch_web/tests/test_battle_recovery_contract.py create mode 100644 ranch_web/tests/test_lifecycle_recovery.py create mode 100644 ranch_web/tests/test_status_recovery_api.py diff --git a/.github/workflows/web-image.yml b/.github/workflows/web-image.yml index b7ad71f..ba8b866 100644 --- a/.github/workflows/web-image.yml +++ b/.github/workflows/web-image.yml @@ -83,6 +83,20 @@ jobs: ranch_web.tests.test_commission_procurement_views -v - name: Offline updater and task log regression run: python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package ranch_web.tests.test_activity ranch_web.tests.test_task_logs -v + - name: Offline battle transport, recovery, and capability regression + timeout-minutes: 3 + run: | + python -B -m unittest \ + ranch_assistant.tests.test_battle_worker_transport \ + ranch_assistant.tests.test_battle_recovery \ + ranch_assistant.tests.test_battle_capability_presentation \ + ranch_web.tests.test_lifecycle_recovery -v + - name: Offline Web battle recovery contract and status API regression + timeout-minutes: 3 + run: | + python -B -m unittest \ + ranch_web.tests.test_battle_recovery_contract \ + ranch_web.tests.test_status_recovery_api -v - name: Offline account recovery regression run: python -B -m unittest ranch_web.tests.test_run_intent ranch_web.tests.test_scheduler_recovery ranch_web.tests.test_auto_relogin ranch_web.tests.test_connection_state -v - name: Build image diff --git a/Dockerfile b/Dockerfile index 0f30afc..7318c9d 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,6 +1,6 @@ FROM python:3.12-slim-bookworm -ARG WEB_VERSION=2.0.9 +ARG WEB_VERSION=2.0.10 ARG VCS_REF=unknown LABEL org.opencontainers.image.source="https://github.com/attilanet/myrzx_bot" \ org.opencontainers.image.title="myrzx_bot Web" \ diff --git a/README.md b/README.md index 9609306..1765621 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,11 @@ # 牧羊人之心Bot -Web **2.0.9**,源码发布入口为 `main`;原生 PySide6 桌面正式版本保留 **1.2.0**(`v1.2.0`)。两者的适配资料基线均为《牧羊人之心》Android **1.9.68**。 +Web **2.0.10**,源码发布入口为 `main`;原生 PySide6 桌面正式版本保留 **1.2.0**(`v1.2.0`)。两者的适配资料基线均为《牧羊人之心》Android **1.9.68**。 支持多账号独立运行、牧场培养、每日事务、主线与委托推进、近似战斗模拟、探险、扫荡及本地掉落分析,能力与验证限制见下文。 ## 运行指引 -### Web 2.0.9(源码发布入口 main) +### Web 2.0.10(源码发布入口 main) Windows 使用 Python 3.12+,在项目根目录执行: @@ -19,9 +19,11 @@ py -3 -m venv .venv-web Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`。Linux Python 启动、离线演示与环境配置见 [Web 运行说明](ranch_web/README.md);单服务 Docker、`/data` 持久化、子路径反代与宿主机受控更新见 [Web 部署说明](deploy/web/README.md)。 -**2.0.9** 清理设置页重复运行提示,沿用原单一底部分类日志。委托明确显示中文未接取原因,成熟魔物需求联动购蛋、孵化,先备齐资源再接取;按剩余步骤计算缺口,继续遵守预算及魔物保护设置。 +**2.0.10** 修复 Linux 战斗子进程输入传输、中断恢复、停止检查及导航能力误报。升级后,符合证据的旧委托备料战斗可按原客户端协议记录失败并退出一次;完整战果可续交尚未发送的结果,未知已发送写请求不重放。来源策略关闭时明确等待启用,保留用户运行意愿,不自动开启策略。 -正常自动战斗默认使用快速数值模型,保留现有伤害配置,无需另选模式;按双方属性、血量、伤害、时间及关卡目标估算胜负,逐帧实现仅供研发。358/358份主线与委托战斗配置通过输入预检,表示配置可计算,实际仍可能打不过。正常潜能误报也已修复;验证结果见 [发布说明](analysis/RELEASE_2_0_9.md)。 +本版后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**。正式镜像与稳定 Release 就绪后,由用户通过“帮助 → 检查版本更新…”在线升级,详情见 [本版发布说明](analysis/RELEASE_2_0_10.md)。 + +沿用 2.0.9 的快速数值模型、伤害配置、委托备料与潜能误报修复;模型按双方属性、血量、伤害、时间及关卡目标估算胜负,逐帧实现仅供研发。2.0.9 的配置预检与历史验证见 [历史发布说明](analysis/RELEASE_2_0_9.md)。 **2.0.8** 自动委托提供“当前委托 / 每日记录”,跨城市按合格候选的预计氪金 **20→15→10** 排序并说明回退原因;按角色、北京时间自然日持久记录接取、推进和领奖,保留最近90天、每角色最多5000条事件。静态预计奖励与领奖回包确认金额分开,缺失金额保持未确认;旧历史仅从本地任务 journal 可证实的部分回填。详见 [2.0.8 发布说明](analysis/RELEASE_2_0_8.md)。 @@ -42,7 +44,7 @@ Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web` | 组件与版本 | 《牧羊人之心》Android 基线 | 入口与状态 | | --- | --- | --- | -| Web 2.0.9 | 1.9.68 | 源码发布入口 `main`,`Start_Ranch_Web.cmd` / `sh start-web.sh` | +| Web 2.0.10 | 1.9.68 | 源码发布入口 `main`,`Start_Ranch_Web.cmd` / `sh start-web.sh` | | 桌面 1.2.0(`v1.2.0`) | 1.9.68 | 当前桌面版本;`Start_Ranch_Helper.cmd` / `python -m ranch_assistant` | | 桌面 1.1.1(`v1.1.1`) | 1.9.68 | 历史正式版本,1.1 系列修复与界面更新 | | 桌面 1.1.0(`v1.1.0`) | 1.9.68 | 历史已发布版本 | diff --git a/analysis/RELEASE_2_0_10.md b/analysis/RELEASE_2_0_10.md new file mode 100644 index 0000000..c7e302a --- /dev/null +++ b/analysis/RELEASE_2_0_10.md @@ -0,0 +1,23 @@ +# Web 2.0.10 发布说明 + +Web **2.0.10** 基于 **2.0.9**;游戏资料 **1.9.68**,桌面正式版 **1.2.0**。 + +## 本版范围 + +- **Linux 输入传输**:战斗子进程从匿名临时文件一次读取完整 stdin,修复 Python 3.12 管道重试丢失剩余输入导致的技术超时,保留取消与大小限制。 +- **旧战斗失败退出**:升级后,旧委托备料记录若已确认入场、未发送结算且符合技术失败条件,按原客户端协议发送 `recordBattleResult`、`result=0` 退出一次;兼容来源任务与步骤均为0的记录,不重新入场、不提交胜利。 +- **按证据恢复**:保存的原始战斗输入最多用于一次本地恢复;完整战果校验通过后按战斗时钟续交尚未发送的结果。未知已发送写请求不重放。 +- **停止与等待**:停止检查覆盖恢复提交;内部暂停保留用户运行意愿,来源策略关闭时明确等待启用,不自动开启策略。 +- **状态与能力展示**:接口透出5个安全策略状态字段,区分运行意愿、实际执行与等待原因;包含 2.0.9 后的导航能力误报修正,真实输入不支持、资源不足及失败原因继续保留。 + +沿用现有快速 HP/DPS 模型、伤害配置与工作台布局。 + +## 验证 + +后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过。 + +本轮验证未写入真实游戏 API、未手动部署、未修改生产 journal。升级后依据持久化证据及策略授权恢复。 + +## 发布与升级 + +正式镜像与稳定 Release 就绪后,由用户在“帮助 → 检查版本更新…”发起在线升级,见 [部署说明](../deploy/web/README.md)。 diff --git a/compose.yaml b/compose.yaml index 6cd62c4..bcd60fa 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,11 +1,11 @@ name: ranch-web services: web: - image: ${RANCH_WEB_IMAGE:-ghcr.io/attilanet/myrzx_bot-web:v2.0.9} + image: ${RANCH_WEB_IMAGE:-ghcr.io/attilanet/myrzx_bot-web:v2.0.10} build: context: . args: - WEB_VERSION: ${RANCH_WEB_BUILD_VERSION:-2.0.9} + WEB_VERSION: ${RANCH_WEB_BUILD_VERSION:-2.0.10} user: "10001:10001" init: true restart: unless-stopped diff --git a/deploy/web/README.md b/deploy/web/README.md index db53ebf..d404e04 100644 --- a/deploy/web/README.md +++ b/deploy/web/README.md @@ -1,8 +1,8 @@ # Web 2 Linux Docker 部署与更新 -当前应用及更新示例为 `v2.0.9`。下文首次初始化章节保留 2.0.1 流程及历史版本示例。游戏资料基线为 `1.9.68`,桌面版保留 `1.2.0`。镜像流水线成功、Git tag 与 GitHub Release 是不同的发布步骤:在线更新必须等对应镜像及非草稿、非预发布的 Release 均发布后才能使用。私有仓库未获授权返回 404 属于访问失败,不代表没有版本;只有成功读取列表且没有稳定 2.x 时才显示“暂无正式版”。 +当前应用及更新示例为 `v2.0.10`。下文首次初始化章节保留 2.0.1 流程及历史版本示例。游戏资料基线为 `1.9.68`,桌面版保留 `1.2.0`。镜像流水线成功、Git tag 与 GitHub Release 是不同的发布步骤:在线更新必须等对应镜像及非草稿、非预发布的 Release 均发布后才能使用。私有仓库未获授权返回 404 属于访问失败,不代表没有版本;只有成功读取列表且没有稳定 2.x 时才显示“暂无正式版”。 -2.0.9 仅整理设置页重复运行提示,21项相关测试通过;以下历史结果不计入本补丁,见 [本版发布说明](../../analysis/RELEASE_2_0_9.md)。 +2.0.10 修复 Linux 战斗输入传输、中断恢复、停止检查及能力状态误报。升级后按持久化证据恢复:符合条件的旧委托备料技术失败记录退出一次;来源策略关闭时明确等待启用,保留运行意愿,不自动开启策略;未知已发送写请求不重放。已有宿主机由用户在 Web 内发起在线更新,见 [本版发布说明](../../analysis/RELEASE_2_0_10.md)。 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,稳定 Release 与正式镜像发布后,可直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器。尚未接入私有在线更新的宿主机才需参考下文“已有宿主机首次初始化”。 @@ -23,7 +23,7 @@ sudo install -m 0600 -o root -g root deploy/web/image.env.example .image.env sudoedit .env .image.env ``` -在 `.env` 填入独立的 `RANCH_WEB_PASSWORD`,这是 Web 管理密码,不是游戏密码;`.image.env` 的目标示例为 `RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.9`,需确认对应镜像已发布后再 pull。Compose 默认只发布到宿主机 `127.0.0.1:8765`,容器内监听 `0.0.0.0:8765` 并强制管理密码。使用域名反代时,同时配置 `RANCH_WEB_ALLOWED_HOSTS` 与 `RANCH_WEB_ALLOWED_ORIGINS`;TLS 入口设置 `RANCH_WEB_SECURE_COOKIE=true`。代理保留正确的 Host,写请求依赖来源校验。 +在 `.env` 填入独立的 `RANCH_WEB_PASSWORD`,这是 Web 管理密码,不是游戏密码;`.image.env` 的目标示例为 `RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.10`,需确认对应镜像已发布后再 pull。Compose 默认只发布到宿主机 `127.0.0.1:8765`,容器内监听 `0.0.0.0:8765` 并强制管理密码。使用域名反代时,同时配置 `RANCH_WEB_ALLOWED_HOSTS` 与 `RANCH_WEB_ALLOWED_ORIGINS`;TLS 入口设置 `RANCH_WEB_SECURE_COOKIE=true`。代理保留正确的 Host,写请求依赖来源校验。 `/opt/ranch-web/data` 挂到容器 `/data`,包括账号、加密会话与密钥、配置、委托历史、SQLite 统计和更新请求;独立于桌面数据。心跳控制目录独立只读挂到 `/run/ranch-updater`。使用 bind mount 的目录必须预先创建,Compose 不会悄悄创建 root 所有、容器无法写入的目录。默认容器用户 `10001:10001`,根文件系统只读,临时文件写到 `/tmp`。不要对现有账号目录重新初始化密钥。 @@ -55,7 +55,7 @@ Web 只读检查官方 GitHub Releases;默认只接受 `v2.MINOR.PATCH`,跳 ### 已完成 2.0.1 初始化的宿主机 -稳定 Release 与正式镜像发布后,用户打开“帮助 → 检查版本更新…”,检查到 2.0.9 后手动提交更新请求,可从 2.0.1 直接安装。现有私有仓库认证、GHCR 登录与宿主机更新器继续使用;Web 按钮仍要求有效心跳及 `accept_web_requests=true`。请求显示 `pending` 只表示已提交,宿主机完成备份、安装及健康检查后才确认成功;升级完成后刷新网页以加载新版界面,底部日志默认收起。Windows 或未启用执行器时仍仅可检查版本。自动安装默认关闭。 +稳定 Release 与正式镜像发布后,用户打开“帮助 → 检查版本更新…”,检查到 2.0.10 后手动提交更新请求,可从 2.0.1 直接安装。现有私有仓库认证、GHCR 登录与宿主机更新器继续使用;Web 按钮仍要求有效心跳及 `accept_web_requests=true`。请求显示 `pending` 只表示已提交,宿主机完成备份、安装及健康检查后才确认成功;升级完成后刷新网页以加载新版界面,底部日志默认收起。Windows 或未启用执行器时仍仅可检查版本。自动安装默认关闭。 ### 全新宿主机安装 @@ -110,7 +110,7 @@ python3 -B /opt/ranch-web/updater.pyz --version Docker 保存的宿主机登录配置供更新器拉镜像使用;不要复制开发机的 Git/registry 凭据,也不要把 Docker 凭据放进 GitHub Token 文件或 Web 容器。[GHCR 官方认证说明](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry) -4. 使用新包先检查再由用户明确发起在线更新。以下 `--apply v2.0.1` 仅保留首次初始化的历史示例,不是本轮 2.0.9 升级命令: +4. 使用新包先检查再由用户明确发起在线更新。以下 `--apply v2.0.1` 仅保留首次初始化的历史示例,不是本轮 2.0.10 升级命令: ```sh sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --check @@ -165,12 +165,14 @@ Windows 或未安装执行器的 Docker 部署仍能检查版本,但按钮会 [web-image.yml](../../.github/workflows/web-image.yml) 仅对官方仓库的严格稳定 `v2.x.y` tag 推送 `ghcr.io/attilanet/myrzx_bot-web:v2.x.y`;校验 `ranch_web.__version__` 必须与 tag 一致,不能只改变镜像 label。PR 与手动运行只测试、构建,不推送。开发分支 push 不触发正式镜像发布,也没有 `latest` 滚动升级通道。CI 执行更新器、私有凭据和独立包回归,并在无外网容器中检查 healthcheck、非 root 数据写权限、无 Qt 和正常停止;镜像发布状态以对应 tag 的工作流结果为准。 +2.0.10 后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过。本轮验证未写入真实游戏 API、未手动部署、未修改生产 journal;升级后的恢复以保存证据与策略授权为准。 + 2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过,详见 [发布说明](../../analysis/RELEASE_2_0_8.md#验证)。2.0.7 结果保留在 [历史发布说明](../../analysis/RELEASE_2_0_7.md#验证)。以下命令可复现本地更新器构建与离线检查;历史 Windows 离线验证与 Linux 部署烟测见 [Web 运行说明](../../ranch_web/README.md#离线验证),不计入本版验收。可在无 Docker 的机器上构建临时更新器资产并打印计划;`--dry-run` 不联网、不读取凭据、不调用 Docker,也不写文件: ```sh -python -B tools/build_web_updater.py --output test-artifacts/releases/v2.0.9/updater.pyz -python -B test-artifacts/releases/v2.0.9/updater.pyz --version -python -B test-artifacts/releases/v2.0.9/updater.pyz --config deploy/web/updater.example.toml --apply v2.0.9 --dry-run +python -B tools/build_web_updater.py --output test-artifacts/releases/v2.0.10/updater.pyz +python -B test-artifacts/releases/v2.0.10/updater.pyz --version +python -B test-artifacts/releases/v2.0.10/updater.pyz --config deploy/web/updater.example.toml --apply v2.0.10 --dry-run python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package -v ``` diff --git a/deploy/web/image.env.example b/deploy/web/image.env.example index 074a013..9f5c5e0 100644 --- a/deploy/web/image.env.example +++ b/deploy/web/image.env.example @@ -1,2 +1,2 @@ -# Pull only after the v2.0.9 image publishing workflow succeeds and the image is available. -RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.9 +# Pull only after the v2.0.10 image publishing workflow succeeds and the image is available. +RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.10 diff --git a/ranch_assistant/battle_simulator.py b/ranch_assistant/battle_simulator.py index dd61c54..2849ef8 100644 --- a/ranch_assistant/battle_simulator.py +++ b/ranch_assistant/battle_simulator.py @@ -1363,6 +1363,8 @@ class ExperimentalBattleRuntime: diagnostics=[{"code": "static_data", "message": str(exc)}]) def run(self, request, *, cancel_event=None, timeout=30.0): + import tempfile + timeout = _number(timeout, "timeout") if timeout < 0: raise SimulationInputError("timeout must be nonnegative") @@ -1380,13 +1382,18 @@ class ExperimentalBattleRuntime: started = time.monotonic() process = None try: - process = subprocess.Popen( - [sys.executable, "-m", "ranch_assistant.battle_simulator", "--worker"], - cwd=str(Path(__file__).resolve().parent.parent), - stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, - creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0), - ) - pending_input = wire + # POSIX communicate(None) retries do not resume a partial stdin write. + # A bounded, rewound file gives the child all input and EOF once; + # its inherited handle remains valid after the parent closes its copy. + with tempfile.TemporaryFile(mode="w+b") as input_stream: + input_stream.write(wire) + input_stream.seek(0) + process = subprocess.Popen( + [sys.executable, "-m", "ranch_assistant.battle_simulator", "--worker"], + cwd=str(Path(__file__).resolve().parent.parent), + stdin=input_stream, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0), + ) while True: if cancel_event is not None and cancel_event.is_set(): return _execution_failure("cancelled", "worker_cancelled") @@ -1394,10 +1401,10 @@ class ExperimentalBattleRuntime: if left <= 0: return _execution_failure("timeout", "worker_wall_clock_limit") try: - stdout, stderr = process.communicate(input=pending_input, timeout=min(.05, left)) + stdout, stderr = process.communicate(timeout=min(.05, left)) break except subprocess.TimeoutExpired: - pending_input = None + pass if len(stdout) > MAX_WIRE_BYTES or len(stderr) > 65536: return _execution_failure("error", "worker_output_exceeds_limit") result = json.loads(stdout) diff --git a/ranch_assistant/battles.py b/ranch_assistant/battles.py index 95732bd..f4ac066 100644 --- a/ranch_assistant/battles.py +++ b/ranch_assistant/battles.py @@ -172,6 +172,9 @@ class BattleJournal: value(intent, "stage_id", ""), value(intent, "difficulty", "1"))}) if value(intent, "token") and value(intent, "account_key"): record.update(intent_id=value(intent, "token"), account_key=value(intent, "account_key")) + if record.get("source_task_type_id") and not record.get("source_task_id"): + from .progression import ProgressionPlanner + record["source_offer_day"] = ProgressionPlanner._loop_day(snapshot, snapshot.now - 10) state = self.role(snapshot) state["records"].append(record) state["pending"] = record["attempt_id"] @@ -428,7 +431,8 @@ class BattleOrchestrator: "experimental_settlement_eligible", "execution_mode", "execution_status", "terminal", "diagnostics", "ignored_mechanics", "anomalies", "assumptions", "experimental_eligibility_reasons", "omitted_events", "model", "simulation_method", "team_budgets", "generated_units", "spawn_bound_reached", - "damage_profile", "damage_multiplier", "damage_cap", "damage_profile_digest", "damage_profile_scope")}} + "damage_profile", "damage_multiplier", "damage_cap", "damage_profile_digest", "damage_profile_scope", + "supported", "timeout_kind")}} trace = value(result, "trace") if trace is None: trace = value(result, "events") @@ -441,8 +445,88 @@ class BattleOrchestrator: evidence["trace"] = public_data(trace) return evidence + @staticmethod + def combat_resource_digest(): + # Bind retries to the same combat tables and quick-model mathematics. + # Worker transport changes do not alter this contract. + root = Path(__file__).parent + return digest([hashlib.sha256(path.read_bytes()).hexdigest() for path in + (root / "data" / "combat_manifest.json", root / "battle_quick.py")]) + + def save_combat_request(self, record, request): + if request.get("battle_mode") != "experimental": + return {} + from .battle_simulator import _transport_request + combat = public_data(_transport_request(request)) + raw = combat.get("roster") + if isinstance(raw, dict): + teams = [{key: row[key] for key in ("teamName", "teamType", "monsters") if key in row} + for row in raw.get("teams", []) if row.get("teamName") == combat["team"]] + for row in teams: + members = row.get("monsters") or [] + if isinstance(members, str): + members = members.split(",") + # Preserve lineup order and empty slots; exploration helpers + # discard those slots and therefore cannot normalize combat. + row["monsters"] = [int(mid) if str(mid).strip() else 0 for mid in members] + ids = {str(mid) for row in teams for mid in row["monsters"]} + if not teams: + ids = set(combat["team"].split(",")) + fields = {"id", "typeId", "level", "mode", "tpLevel", "feel", "upStar", "potentialLevel", "skin", "controller", + "skill_1", "skill_2", "skill_1_lv", "skill_2_lv", *["equip" + str(i) for i in range(1, 6)], + *[prefix + stat for prefix in ("g", "p") for stat in ("Atk", "Def", "Hp", "Dex")]} + raw["teams"] = teams + raw["monsters"] = [{key: val for key, val in row.items() if key in fields} + for row in raw.get("monsters", []) if str(row.get("id")) in ids] + raw["monsterAttributes"] = [row for row in raw.get("monsterAttributes", []) or [] if str(row.get("monsterId")) in ids] + combat["battle_mode"] = "experimental" + return {"combat_request": combat, "combat_request_digest": digest(combat), + "combat_resource_digest": self.combat_resource_digest()} + + def accept_runtime_result(self, record, request, result, started, cancel): + mode = request.get("battle_mode", "original") + evidence = self.runtime_evidence(result, mode) + for key in ("damage_profile", "damage_multiplier", "damage_cap", "damage_profile_digest", "damage_profile_scope"): + if evidence.get(key) is None: + evidence.pop(key, None) + self.journal.update(record, "runtime_returned", runtime_outcome=value(result, "outcome"), **evidence) + outcome, data = value(result, "outcome"), value(result, "battle_data") + eligible = outcome in ("win", "loss") + if mode == "experimental": + eligible = (eligible and value(result, "experimental_settlement_eligible") is True + and value(result, "execution_mode") == "experimental" and value(result, "execution_status") == "completed" + and value(result, "supported") is True and value(result, "terminal") is True + and value(result, "approximate") is True and value(result, "faithful") is False + and not value(result, "anomalies") and not any(row.get("blocking") is True + for row in value(result, "diagnostics", []) or [] if isinstance(row, dict))) + else: + eligible = (eligible and value(result, "settlement_eligible") is True + and value(result, "faithful") is True and value(result, "approximate") is not True) + if not eligible or not isinstance(data, dict) or type(data.get("win")) is not bool: + message = ("本地战斗运行超时,已入场但尚无战果,等待恢复核对" if value(result, "execution_status") == "timed_out" + else "战斗已取消、超时或结果不确定,等待核对") + self._unknown(record, message) + return False + if data["win"] != (outcome == "win"): + self._unknown(record, "运行结果与战果胜负不一致,未提交结算") + return False + position = data.get("battlePosition") + if (not isinstance(position, dict) or {k: v for k, v in position.items() if v is not None} + != {k: v for k, v in request["battle_position"].items() if v is not None}): + self._unknown(record, "运行时战果定位不匹配,未提交结算") + return False + # A generation cancellation does not invalidate an already computed result. + self.journal.update(record, "runtime_complete", battle_data=data) + ready = self.wait_for_battle_clock(record, request, result, data, started, cancel) + if cancel.is_set(): + self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对") + return False + return ready + def wait_for_battle_clock(self, record, request, result, data, started, cancel): if value(result, "requires_realtime_wait") is not True: + self.journal.update(record, "waiting_for_battle_clock", battle_clock_seconds=0, + battle_ready_at=time.time(), resume_clock_ready=True) return True duration = None for field, scale in (("model_elapsed_ms", .001), ("battle_elapsed_ms", .001), ("elapsed_ms", .001), @@ -471,39 +555,154 @@ class BattleOrchestrator: self._unknown(record, "等待战斗时钟期间已取消,开战记录保留待核对") return False + @staticmethod + def confirmed_start(record): + response = record.get("start_response") + task = bool(record.get("task_id")) + path = "battleService/battleStart" if task else "stageService/stageStart" + return (record.get("start_path") == path and isinstance(response, dict) + and response.get("resCode", 0) in (0, "0") and (task or response.get("triggerEvent") is False + or type(response.get("triggerEvent")) is int and response["triggerEvent"] == 0)) + + @staticmethod + def source_matches(record, snapshot): + if not record.get("source_task_type_id"): + return True + if not record.get("source_task_id") and not record.get("source_step_number"): + from .progression import ProgressionPlanner + history = snapshot.raw.get("history", {}) + offers = history.get("loopTask") or {} + today = ProgressionPlanner._loop_day(snapshot, snapshot.now - 10) + return (record.get("source_offer_day") == today and history.get("loopTaskTime") is not None + and ProgressionPlanner._loop_day(snapshot, history["loopTaskTime"]) == today + and isinstance(offers, dict) and any(str(key) == str(record["source_task_type_id"]) + for rows in offers.values() if isinstance(rows, (list, tuple)) for key in rows) + and not any(str(task.get("typeId")) == str(record["source_task_type_id"]) + for task in snapshot.raw.get("currentTasks", []))) + return any(str(task.get("id")) == str(record.get("source_task_id")) + and str(task.get("typeId")) == str(record["source_task_type_id"]) + and str(task.get("curStep")) == str(record.get("source_step_number")) + for task in snapshot.raw.get("currentTasks", [])) + + @staticmethod + def legacy_stage_failure(record): + return (record.get("kind") == "stage_battle" and not record.get("task_id") + and not record.get("task_type_id") and record.get("battle_kind") == "ordinary_stage" + and record.get("stage_category") in (None, "", "ordinary") and record.get("source_task_type_id") + and record.get("execution_mode") == "experimental" and record.get("terminal") is False + and record.get("terminal_reason") in ("worker_wall_clock_limit", "worker_cancelled", "worker_interrupted") + and record.get("execution_status") in ("cancelled", "timed_out") and not record.get("battle_data")) + @staticmethod def resumable_task_clock(record): - common = bool(record and ((record.get("kind") == "progression_battle" and record.get("task_id")) - or (record.get("kind") == "map_battle" and not record.get("task_id"))) - and record.get("execution_mode") == "experimental" and record.get("execution_status") == "completed" - and record.get("experimental_settlement_eligible") is True and record.get("terminal") is True - and record.get("approximate") is True and record.get("faithful") is False + common = bool(record and record.get("kind") in ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle") + and ((record.get("execution_mode") == "experimental" and record.get("execution_status") == "completed" + and record.get("experimental_settlement_eligible") is True and record.get("terminal") is True + and record.get("approximate") is True and record.get("faithful") is False) + or (record.get("battle_mode") == "original" and record.get("settlement_eligible") is True + and record.get("faithful") is True and record.get("approximate") is not True)) and not record.get("anomalies") and not any(row.get("blocking") is True for row in record.get("diagnostics") or [] if isinstance(row, dict)) and isinstance(record.get("battle_data"), dict) and type(record["battle_data"].get("win")) is bool) if not common: return False - if (record.get("kind") == "map_battle" and record.get("phase") == "settlement_acknowledged" - and record.get("settlement_confirmed") is True): + if record.get("phase") in ("record_pending", "record_unknown"): + return False + if not record.get("task_id") and record.get("settlement_confirmed") is True: return (record["battle_data"]["win"] is True and isinstance(record.get("response"), dict) - and record["response"].get("resCode", 0) in (0, "0")) - return (record.get("phase") in ("unknown", "waiting_for_battle_clock") + and record["response"].get("resCode", 0) in (0, "0") + and (not record.get("record_dispatched") or record.get("record_confirmed") is True)) + return (record.get("phase") in ("unknown", "runtime_complete", "waiting_for_battle_clock", "record_acknowledged") and record.get("path") in ("", "battleService/battleStart", "stageService/stageStart") and not record.get("settlement_confirmed") and not record.get("settlement_dispatched") + and (not record.get("record_dispatched") or record.get("record_confirmed") is True) and (record.get("resume_clock_ready") is True or + record.get("phase") == "runtime_complete" or record.get("message") == "等待战斗时钟期间已取消,开战记录保留待核对")) + def recovery_status(self, record, *, snapshot=None): + """Read-only classification. Resumable never grants permission to write.""" + def status(state, message=""): + return {"state": state, "resumable": state not in ("none", "blocked"), "message": message} + if not record: + return status("none") + if isinstance(snapshot, dict): + snapshot = SimpleNamespace(raw=snapshot, now=time.time()) + if record.get("kind") not in ("progression_battle", "map_battle", "stage_battle", "battle", "task_battle"): + return status("blocked", record.get("message") or "任务请求待核对,不能按战斗恢复") + if snapshot and str(record.get("role_id")) != role_id(snapshot): + return status("blocked", "角色与原入场记录不匹配,保留待核对记录") + preaccept = not record.get("source_task_id") and not record.get("source_step_number") + source_matches = snapshot is None or self.source_matches(record, snapshot) + if (not source_matches + and not (preaccept and self.legacy_stage_failure(record))): + return status("blocked", "角色或来源委托步骤已变化,保留原战斗记录等待核对") + if record.get("abandon_requested") and record.get("record_confirmed") is True and record.get("record_result") is False: + return status("finish_abandonment", "失败退出已确认,等待完成本地记录") + if self.resumable_task_clock(record): + return status("resume_result", "完整战果已保存,可续交尚未发送的结果") + if record.get("phase") in ("record_pending", "record_unknown") or record.get("record_dispatched"): + return status("blocked", "战果记录请求已发送但结果未确认,禁止重复发送") + if record.get("settlement_dispatched") or record.get("settlement_confirmed") or record.get("path") not in ( + "", None, "stageService/stageStart", "battleService/battleStart"): + return status("blocked", "结算请求可能已发送,等待服务器证据,禁止重复结算") + if record.get("phase") == "prepared" and record.get("start_dispatched") is False and not record.get("start_response"): + return status("unsent", "开战请求尚未发送,可取消本地准备记录") + if not self.confirmed_start(record): + return status("blocked", "开战请求结果未确认,禁止重新入场或自动退出") + interrupted = (record.get("runtime_not_started") is True or record.get("phase") in ("started", "running", "hidden_started") or + record.get("execution_status") in ("cancelled", "timed_out", "error")) + if not interrupted or record.get("battle_data"): + return status("blocked", "没有可验证的完整战果或安全恢复证据,保留待核对记录") + combat = record.get("combat_request") + if not isinstance(combat, dict): + # Original AIR: BattlePausePanel.yesEscapeHandler -> checkGameOver + # (run=True, winnerTeam=2) -> BattlePanel.showLose -> battleResult(false). + if self.legacy_stage_failure(record): + return status("abandon_stage", "旧记录缺少原始战斗输入,本地计算已超时或取消;开启后按原客户端退出协议记录失败,不推进任务") + return status("blocked", "旧记录缺少原始战斗输入,不能用当前属性重算;需要权威记录或原客户端退出核对") + if self.legacy_stage_failure(record) and (not source_matches or record.get("runtime_recovery_attempts", 0) >= 1): + return status("abandon_stage", "本地战斗未完成且来源委托已变化或恢复已用尽;开启后按原客户端退出协议记录失败") + if record.get("runtime_recovery_attempts", 0) >= 1: + return status("blocked", "本地战斗恢复已尝试一次仍未完成,保留入场记录等待核对") + if (record.get("battle_mode") != "experimental" or digest(combat) != record.get("combat_request_digest") + or self.combat_resource_digest() != record.get("combat_resource_digest")): + return status("blocked", "保存的原始战斗输入或资源校验不匹配,禁止改用当前属性重算") + return status("retry_local_runtime", "入场已确认且结算未发送,可用保存的原始输入恢复一次本地战斗") + def resume_task_clock(self, client, snapshot, intent, policy, *, cancel): - """Resume an unsent result, or finish recording a confirmed map settlement.""" + """Recover this entry only; never replay start or an uncertain server write.""" with self.journal.lock: + self.journal.reload() record = self.journal.pending(snapshot) - if not policy.enabled or cancel.is_set() or not self.resumable_task_clock(record): + recovery = self.recovery_status(record, snapshot=snapshot) + if not policy.enabled or cancel.is_set() or not recovery["resumable"]: return "" if str(record.get("role_id")) != str(role_id(snapshot)): return "" if any(str(record.get(key)) != str(value(intent, key)) for key in ("kind", "task_id", "task_type_id", "step_number")): return "" + if not record.get("task_id") and any(str(record.get(key)) != str(value(intent, key)) for key in + ("stage_id", "difficulty", "battle_kind", "source_task_id", "source_task_type_id", "source_step_number")): + return "" + if recovery["state"] == "unsent": + if self.observer and (record.get("task_id") or record.get("map_roster_signature")): + self.observer("cancelled_before_start", intent, None) + self.journal.finish(snapshot, record, "cancelled", "已取消尚未发送的开战准备记录;未重新入场") + return record["message"] + if recovery["state"] in ("abandon_stage", "finish_abandonment"): + try: + if recovery["state"] == "abandon_stage": + self.journal.update(record, "abandon_pending", abandon_requested=True) + self._record(client, record, record["stage_id"], False, cancel=cancel) + self.journal.finish(snapshot, record, "abandoned", "已按原客户端退出协议确认失败;未提交胜利战果或推进来源委托") + return record["message"] + except CancelledBeforeDispatch: + return "策略已停止,失败退出请求尚未发送,保留原入场记录" + except Exception as error: + self._unknown(record, "失败退出请求结果未确认,禁止重复发送", error_type=type(error).__name__) + raise task_battle = bool(record.get("task_id")) if task_battle: task = next((row for row in snapshot.raw.get("currentTasks", []) @@ -516,6 +715,25 @@ class BattleOrchestrator: "stageLevel": None if task_battle else str(record.get("difficulty")), "taskTypeId": str(record["task_type_id"]) if task_battle else None, "taskStep": int(record["step_number"]) - 1 if task_battle else 0} + if recovery["state"] == "retry_local_runtime": + request = deepcopy(record["combat_request"]) + position = request.get("battle_position") + if (not isinstance(position, dict) or {k: v for k, v in position.items() if v is not None} + != {k: v for k, v in expected.items() if v is not None} + or request.get("team") != record.get("team")): + return "保存的原始战斗输入与入场定位不匹配,保留待核对记录" + supported, reason = self.inspect(request) + if not supported: + return "保存的原始战斗输入当前无法执行:" + reason + self.journal.update(record, "running", runtime_recovery_attempts=1, runtime_not_started=False) + try: + started = self.clock() + result = self.runtime.run(request, cancel_event=cancel) + if not self.accept_runtime_result(record, request, result, started, cancel): + return record["message"] + except Exception as error: + self._unknown(record, "本地战斗恢复未完成,保留原入场记录", error_type=type(error).__name__) + raise data = record["battle_data"] position = data.get("battlePosition") if not isinstance(position, dict) or {key: val for key, val in position.items() if val is not None} != { @@ -524,6 +742,10 @@ class BattleOrchestrator: ready = 0 if record.get("settlement_confirmed") else record.get("battle_ready_at") if ready is None: duration = record.get("battle_clock_seconds") + if duration is None and record.get("requires_realtime_wait") is not True: + duration = 0 + if duration is None and type(record.get("elapsed_ms")) in (int, float): + duration = record["elapsed_ms"] / 1000 stamp = record.get("updated_at") if any(type(number) not in (int, float) or not math.isfinite(number) or number < 0 for number in (duration, stamp)): @@ -536,7 +758,7 @@ class BattleOrchestrator: return "已核对保存的战果;尚未到结算时间,2分钟内自动复查" try: if not data["win"]: - if not task_battle or record.get("battle_kind") == "passStage": + if (not task_battle or record.get("battle_kind") == "passStage") and not record.get("record_confirmed"): self._record(client, record, record["stage_id"], False, cancel=cancel) if self.observer: self.observer("loss", intent, None) @@ -552,17 +774,18 @@ class BattleOrchestrator: response = self._call(client, path, payload, cancel=cancel) self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response), settlement_confirmed=True, reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward")) - if not task_battle: - self._record(client, record, record["stage_id"], True) + if not task_battle and not record.get("record_confirmed"): + self._record(client, record, record["stage_id"], True, cancel=cancel) if self.observer: self.observer("settled", intent, response) elif task_battle: self.journal.checkpoint(snapshot, intent, response) - self.journal.finish(snapshot, record, "win", "已自动续交保存的战果;未重新开战或重新模拟") + self.journal.finish(snapshot, record, "win", "已恢复此入场的战果并确认结算;未重新开战") return record["message"] except CancelledBeforeDispatch: - self.journal.update(record, "waiting_for_battle_clock", path="battleService/battleStart" if task_battle else "stageService/stageStart", - settlement_dispatched=False, resume_clock_ready=True) + if not record.get("settlement_confirmed"): + self.journal.update(record, "waiting_for_battle_clock", path="battleService/battleStart" if task_battle else "stageService/stageStart", + settlement_dispatched=False, resume_clock_ready=True) return "策略已停止,保存的战果将在重新开启后续交" except Exception as error: self._unknown(record, "续交请求结果未确认,将自动查询状态,不重复发送", error_type=type(error).__name__) @@ -601,24 +824,31 @@ class BattleOrchestrator: return "任务 / 战斗已取消,未开始" record = self.journal.begin(snapshot, intent) try: + self.journal.update(record, "prepared", start_dispatched=False) if self.observer: self.observer("started", intent, None) if value(intent, "task_id"): path, payload = "battleService/battleStart", {"battleType": "task", "taskTypeId": str(value(intent, "task_type_id"))} else: path, payload = "stageService/stageStart", {"stageTypeId": str(value(intent, "stage_id")), "stageLevel": str(value(intent, "difficulty", "1"))} - self.journal.update(record, "start_pending", start_path=path, input_digest=digest(public_data(request)), + self.journal.update(record, "start_pending", + **{key: val for key, val in self._inspection_evidence.items() if key not in ("battle_mode", "resource_identity")}, + **self.save_combat_request(record, request), + path=path, start_path=path, start_dispatched=True, settlement_dispatched=False, record_dispatched=False, + input_digest=digest(public_data(request)), team=policy.team, battle_mode=mode, resource_identity=(request.get("original_data") or {}).get("manifest", {}).get("source")) try: started = self._call(client, path, payload, cancel=cancel) except CancelledBeforeDispatch: + self.journal.update(record, "start_pending", start_dispatched=False) if self.observer: self.observer("cancelled_before_start", intent, None) self.journal.finish(snapshot, record, "cancelled", "开战请求尚未发送,已取消;未消耗入场资源") return record["message"] battle_started = self.clock() - self.journal.update(record, "started", start_response=gameplay_response(started)) + self.journal.update(record, "started", start_confirmed=True, start_confirmed_at=time.time(), + runtime_not_started=True, start_response=gameplay_response(started)) if not value(intent, "task_id"): reward = event_reward(started) if reward is not None: @@ -638,38 +868,17 @@ class BattleOrchestrator: supported, reason = self.inspect(request) if not supported: return self._unknown(record, "隐藏关卡待处理:" + reason) - self.journal.update(record, "hidden_started", stage_id=hidden, difficulty="1") + self.journal.update(record, "hidden_started", stage_id=hidden, difficulty="1", + **self.save_combat_request(record, request)) else: return self._unknown(record, "探索事件或开战状态未知,等待核对") if cancel.is_set(): return self._unknown(record, "开战后已取消,等待服务器状态核对") - self.journal.update(record, "running") + self.journal.update(record, "running", runtime_not_started=False) result = self.runtime.run(request.get("runtime_request", request), cancel_event=cancel) - evidence = self.runtime_evidence(result, mode) - self.journal.update(record, "runtime_returned", **evidence) - if cancel.is_set() or value(result, "outcome") in ("cancelled", "cancel", "timeout", "unknown", "unsupported"): - return self._unknown(record, "战斗已取消、超时或结果不确定,等待核对") - data = value(result, "battle_data") - eligible = value(result, "outcome") in ("win", "loss") - if mode == "experimental": - eligible = (eligible and value(result, "experimental_settlement_eligible") is True - and value(result, "execution_mode") == "experimental" and value(result, "execution_status") == "completed" - and value(result, "supported") is True and value(result, "terminal") is True - and value(result, "approximate") is True and value(result, "faithful") is False and not value(result, "anomalies")) - else: - eligible = eligible and value(result, "settlement_eligible") is True and value(result, "faithful") is True and value(result, "approximate") is not True - if not eligible or not isinstance(data, dict) or type(data.get("win")) is not bool: - return self._unknown(record, "所选运行时未提供可结算的实际执行结果,未提交结算") - if data["win"] != (value(result, "outcome") == "win"): - return self._unknown(record, "运行结果与战果胜负不一致,未提交结算") - position = data.get("battlePosition") - if (not isinstance(position, dict) or {k: v for k, v in position.items() if v is not None} - != {k: v for k, v in request["battle_position"].items() if v is not None}): - return self._unknown(record, "运行时战果定位不匹配,未提交结算") - # Keep all statistics and integrity records exactly as supplied. - self.journal.update(record, "runtime_complete", battle_data=data) - if not self.wait_for_battle_clock(record, request, result, data, battle_started, cancel): + if not self.accept_runtime_result(record, request, result, battle_started, cancel): return record["message"] + data = record["battle_data"] if not data["win"]: if not value(intent, "task_id") or value(intent, "battle_kind") == "passStage": self._record(client, record, request["stage_id"], False, cancel=cancel) @@ -683,7 +892,7 @@ class BattleOrchestrator: "taskTypeId": str(value(intent, "task_type_id")), "removeIds": None, "battleData": data} else: path, payload = "battleService/battleEnd", {"battleData": data} - self.journal.update(record, "settlement_pending", path=path) + self.journal.update(record, "settlement_pending", path=path, settlement_dispatched=True) response = self._call(client, path, payload, cancel=cancel) self.journal.update(record, "settlement_acknowledged", response=gameplay_response(response), settlement_confirmed=True, reward=response["stageReward"] if response.get("stageReward") is not None else response.get("reward")) @@ -700,6 +909,11 @@ class BattleOrchestrator: label = "实验模型胜利(近似)" if mode == "experimental" else "实际胜利" self.journal.finish(snapshot, record, "win", label + ",结算接口已确认;后续进度以服务器快照核对") return label + ",已确认对应结算" + except CancelledBeforeDispatch: + if not record.get("settlement_confirmed"): + self.journal.update(record, "waiting_for_battle_clock", path=record["start_path"], + settlement_dispatched=False, resume_clock_ready=True) + return "策略已停止,保存的战果将在重新开启后续交" except Exception as error: self._unknown(record, "任务 / 战斗请求或运行未确认;禁止自动重试", error_type=type(error).__name__) raise @@ -739,12 +953,17 @@ class BattleOrchestrator: return response def _record(self, client, record, stage, win, *, cancel=None): - self.journal.update(record, "record_pending") + phase = record["phase"] + self.journal.update(record, "record_pending", record_dispatched=True, record_result=win) try: - self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel) + response = self._call(client, "battleService/recordBattleResult", {"stageId": str(stage), "cityId": str(stage)[1:2], "result": int(win)}, cancel=cancel) + except CancelledBeforeDispatch: + self.journal.update(record, phase, record_dispatched=False) + raise except Exception: self.journal.update(record, "record_unknown", message="战果记录未确认,不能重放战斗") raise + self.journal.update(record, "record_acknowledged", record_confirmed=True, record_response=gameplay_response(response)) def _unknown(self, record, message, **fields): phase = "record_unknown" if record["phase"] == "record_unknown" else "unknown" diff --git a/ranch_assistant/engine.py b/ranch_assistant/engine.py index 340ce6c..dcab052 100644 --- a/ranch_assistant/engine.py +++ b/ranch_assistant/engine.py @@ -588,14 +588,43 @@ class Engine: or self._breakthrough_pending and now - self._breakthrough_pending_last_check >= 120)) return not self.demo and bool(automation or self._progression_pending() and now - self.last_pending_check >= 120) - def _resume_pending_task_clock(self): + def pending_battle_recovery(self): + """Read-only recovery contract for desktop/Web pending guards.""" + record = self.battle_journal.pending(self.snapshot) if self.snapshot is not None else None + status = self.battles.recovery_status(record, snapshot=self.snapshot) + if status["resumable"]: + if self.game_data is None and (record.get("source_task_type_id") or record.get("task_type_id")): + from .game_data import load_progression_data + self.game_data = load_progression_data() + if not self._intent_policy(record).enabled: + origin = ("自动扫荡" if record.get("kind") == "map_battle" else + "自动委托" if self._is_commission(record) else "自动主线") + return {"state": "blocked_policy", "resumable": False, + "message": "等待启用" + origin + "来源策略;已保留待核对战斗"} + return status + + def _resume_pending_task_clock(self, *, running=None, generation=None): record = self.battle_journal.pending(self.snapshot) - if not self.auto or self._progression_cancel.is_set() or not self.battles.resumable_task_clock(record): + if not self.pending_battle_recovery()["resumable"]: return "" - if record.get("kind") == "map_battle": + with self._progression_cancel_lock: + if (not (self.auto if running is None else running is True) + or generation is not None and generation != self._progression_cancel_generation): + return "" + # Web deliberately keeps auto=False. Only its current running intent + # may rearm an older cancellation; a newer Stop always wins. + if running is True and self._progression_cancel.is_set(): + self._progression_cancel = threading.Event() + cancel = self._progression_cancel + if cancel.is_set(): + return "" + if not record.get("task_id"): intent = {key: record.get(key) for key in ("kind", "task_id", "task_type_id", "step_number", "stage_category", - "stage_id", "difficulty", "battle_kind", "team", "path")} - return self.battles.resume_task_clock(self.client, self.snapshot, intent, self._map_policy(), cancel=self._progression_cancel) + "stage_id", "difficulty", "battle_kind", "team", "path", "source_task_id", "source_task_type_id", "source_step_number")} + policy = self._intent_policy(intent) + if self.pending_battle_recovery()["state"] == "retry_local_runtime": + self._select_battle_runtime(record["battle_mode"]) + return self.battles.resume_task_clock(self.client, self.snapshot, intent, policy, cancel=cancel) pending = self.progression_planner.pending(self.snapshot) if self.progression_planner else None if not pending or not isinstance(pending.get("intent"), dict): return "" @@ -607,8 +636,10 @@ class Engine: if intent.token in issued and issued[intent.token] != intent.to_dict(): return "" issued[intent.token] = intent.to_dict() + if self.pending_battle_recovery()["state"] == "retry_local_runtime": + self._select_battle_runtime(record["battle_mode"]) return self.battles.resume_task_clock(self.client, self.snapshot, intent, self._intent_policy(intent), - cancel=self._progression_cancel) + cancel=cancel) def _battle_capability(self, intent): try: @@ -648,7 +679,11 @@ class Engine: supported, reason = self._commission_offer_checks[key] if not supported: intent = replace(intent, block_reason=reason) - if (value(intent, "kind") in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle") + # Local battle preludes share the planner's cached input preflight. + prelude = value(intent, "task_id") and value(intent, "battle_kind") in battle_kinds and ( + value(intent, "kind") == "progression_navigate" or + value(intent, "kind") == "progression_dialogue" and value(intent, "phase") == "before") + if (prelude or value(intent, "kind") in ("progression_battle", "battle", "task_battle", "stage_battle", "map_battle") or self._is_farm(intent) and not self._is_sweep_intent(intent)) and not value(intent, "block_reason"): supported, reason = self._battle_capability(intent) reasons[str(value(intent, "source_task_type_id") or value(intent, "task_type_id"))] = (supported, reason) @@ -673,14 +708,15 @@ class Engine: stage_id=value(farm, "stage_id"), difficulty=value(farm, "difficulty")) reason = row.get("block_reason") or row.get("blocked_reason") or "" if row.get("battle_kind") in battle_kinds: - supported, runtime_reason = reasons.get(str(row.get("task_type_id")), - (False, "战斗运行时能力尚未核对;配置存在不代表已支持实战")) - row["supported"] = bool(source_supported and supported and not reason) + supported, runtime_reason = reasons.get(str(row.get("task_type_id")), (None, "")) reason = reason or runtime_reason + row["supported"] = False if not source_supported or reason else supported else: row["supported"] = bool(source_supported and not reason) row["block_reason"] = row["blocked_reason"] = reason - row["reason_kind"] = commission_reason_kind(reason) + row["reason_kind"] = "unchecked" if row["supported"] is None else commission_reason_kind(reason) + if row["supported"] is None and row.get("category") == "mainline" and not self.progression_policy.enabled: + row.setdefault("status", "自动主线策略未启用") return rows, adjusted def _battle_request(self, snapshot, intent, policy, request): @@ -1331,7 +1367,10 @@ class Engine: @single_flight @account_serial - def poll(self, *, hatch_only=False, defer_hatch=False): + def poll(self, *, hatch_only=False, defer_hatch=False, resume_pending=None): + if resume_pending is not None and type(resume_pending) is not bool: + raise ValueError("resume_pending must be a boolean or None") + recovery_generation = self._progression_cancel_generation self.last_executed = False settled = False if self.demo: @@ -1355,7 +1394,7 @@ class Engine: if self._progression_pending(): self.pending_hatches = [] pending_map = (self.battle_journal.pending(self.snapshot) or {}).get("kind") == "map_battle" - recovered = self._resume_pending_task_clock() if not self.demo else "" + recovered = self._resume_pending_task_clock(running=resume_pending, generation=recovery_generation) if not self.demo else "" if recovered: self.last_executed = True if not self.battle_journal.pending(self.snapshot): @@ -1364,7 +1403,9 @@ class Engine: self.stage_cache.get(self.snapshot, refresh=True) return self.snapshot, self.plans(), recovered pending = self.battle_journal.pending(self.snapshot) or {} - return self.snapshot, [], message + ";" + (pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作") + ";后台每2分钟自动核对" + recovery = self.pending_battle_recovery() + detail = recovery["message"] or pending.get("message") or "有待核对的任务 / 战斗,已暂停冲突操作" + return self.snapshot, [], message + ";" + detail explore_pending = self.explore_planner.pending(self.snapshot) if explore_pending or self._breakthrough_pending: self.pending_hatches = [] diff --git a/ranch_assistant/tests/test_battle_capability_presentation.py b/ranch_assistant/tests/test_battle_capability_presentation.py new file mode 100644 index 0000000..ce5d72f --- /dev/null +++ b/ranch_assistant/tests/test_battle_capability_presentation.py @@ -0,0 +1,139 @@ +"""Offline presentation regressions: input support never predicts a victory.""" +from copy import deepcopy +import unittest +from unittest.mock import Mock, patch + +from ranch_assistant.engine import Engine +from ranch_assistant.game_data import ProgressionData +from ranch_assistant.model import Catalog, Policy, Snapshot +from ranch_assistant.progression import ProgressionPolicy +from ranch_web.policies import default_config +from ranch_web.views import build_view + + +class BattleCapabilityPresentationTests(unittest.TestCase): + def setUp(self): + self.runtime = Mock() + self.runtime.inspect.return_value = {"supported": True, "settlement_eligible": True, + "faithful": True, "approximate": False} + self.runtime.run.side_effect = AssertionError("presentation must not simulate") + self.client = Mock() + self.client.call.side_effect = AssertionError("offline: no game calls") + self.client.snapshot.side_effect = AssertionError("offline: no snapshot requests") + self.step = {"statusType": "passStage", "statusValue": {"stage": "0216", "level": "1"}, + "position": "city1_wild_stage0216_level1", "story": "before", "afterStory": "after"} + self.data = ProgressionData({"task_info": {"1002013": {"type": 1, "name": "offline mainline", + "steps": [self.step]}}, "scripts": {"before": {"supported": True}, "after": {"supported": True}}, + "game_setting": {"cityInfo": {"1": {"name": "offline city"}}}, + "stage_info": {"0216": {"city": 1, "cost": {"ti": 6}, + "level": {"1": {"cost": 0, "battle": {"fixture": True}}}}}}) + self.engine = Engine(Catalog(), self.client, game_data=self.data, battle_runtime=self.runtime) + self.engine.progression_policy = ProgressionPolicy(enabled=True) + self.engine.policy = Policy(enabled=False, gift_enabled=False, fill=False) + self.engine.snapshot = Snapshot({"master": {"id": 1, "level": 20, "ti": 100, "money": 1000}, + "currentTasks": [{"id": 11, "typeId": "1002013", "curStep": 1, "stepValue": 0}], + "monsters": [{"id": 101, "typeId": 1001010, "mode": 2, "process": 3, "level": 20}], + "teams": [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [101]}], + "items": [], "stacks": [], "rooms": [], + "history": {"unlockCity": {"1": True}, "unlockStage": {"0216": [1]}}}) + self.addCleanup(self.assert_read_only) + + def assert_read_only(self): + self.client.call.assert_not_called() + self.client.snapshot.assert_not_called() + self.runtime.run.assert_not_called() + + def refresh(self): + self.engine._refresh_progression_cache(force=True) + self.assertEqual(self.engine._progression_error, "") + return next(row for row in self.engine.progression_rows() if row["task_type_id"] == "1002013") + + def mainline_view(self): + # Rendering consumes prepared DTOs; it must never inspect or plan. + with patch.object(self.engine, "_battle_capability", side_effect=AssertionError("view inspection")), \ + patch.object(self.engine, "_refresh_progression_cache", side_effect=AssertionError("view planning")): + return build_view(self.engine, "mainline", default_config()) + + def test_navigation_and_before_story_reuse_positive_preflight_without_a_false_block(self): + row = self.refresh() + self.assertEqual(self.engine._progression_intents[0].kind, "progression_navigate") + self.assertTrue(row["supported"]) + self.assertEqual((row["block_reason"], row["blocked_reason"], row["reason_kind"]), ("", "", "ready")) + self.assertIn("前往任务位置", row["next_action"]) + self.refresh() + self.runtime.inspect.assert_called_once() + self.assertEqual(self.mainline_view()["rows"][0]["support"], "已支持") + _, account = self.engine.progression_planner._account(self.engine.snapshot) + account["position"] = self.step["position"] + row = self.refresh() + action = self.engine._progression_intents[0] + self.assertEqual((action.kind, action.phase), ("progression_dialogue", "before")) + self.assertIs(row["supported"], True) + self.assertEqual(row["blocked_reason"], "") + self.runtime.inspect.assert_called_once() + + def test_disabled_mainline_is_neutral_without_execution_intents(self): + self.engine.progression_policy.enabled = False + row = self.refresh() + self.assertEqual(self.engine._progression_intents, []) + self.assertIsNone(row["supported"]) + self.assertEqual((row["blocked_reason"], row["reason_kind"]), ("", "unchecked")) + self.assertEqual(row["status"], "自动主线策略未启用") + self.assertIn("前往任务位置", row["next_action"]) + view = self.mainline_view() + self.assertEqual(view["rows"][0]["support"], "支持状态未确认") + self.assertNotIn("模型尚未支持", str(view)) + self.engine.progression_policy.enabled = True + self.assertIs(self.refresh()["supported"], True) + self.runtime.inspect.assert_called_once() + + def test_real_unsupported_inputs_keep_their_reason_even_while_paused(self): + reason = "Unsupported monster controller: fixture" + self.runtime.inspect.return_value.update(supported=False, reasons=[reason]) + for enabled in (True, False): + with self.subTest(enabled=enabled): + self.engine.progression_policy.enabled = enabled + row = self.refresh() + self.assertIs(row["supported"], False) + self.assertEqual((row["blocked_reason"], row["reason_kind"]), (reason, "model_unsupported")) + self.runtime.inspect.assert_called_once() + + def test_resource_policy_and_unchecked_rows_keep_truthful_reasons_without_inspections(self): + for field, invalid, word in (("teams", [], "队"), ("ti", 0, "体力")): + with self.subTest(field=field): + target = self.engine.snapshot.raw if field == "teams" else self.engine.snapshot.raw["master"] + original = target[field] + target[field] = invalid + row = self.refresh() + self.assertIs(row["supported"], False) + self.assertIn(word, row["blocked_reason"]) + self.assertNotEqual(row["reason_kind"], "model_unsupported") + target[field] = original + source = [{"task_type_id": str(i), "battle_kind": "passStage", "supported": supported, + "block_reason": reason} for i, (supported, reason) in enumerate(( + (False, ""), (True, "自动对话未启用"), (False, "前置任务尚未完成")))] + rows, _ = self.engine._overlay_battle_capabilities(deepcopy(source), []) + self.assertTrue(all(row["supported"] is False for row in rows)) + self.assertEqual([row["blocked_reason"] for row in rows], [row["block_reason"] for row in source]) + rows = [{"task_type_id": str(i), "state": state, "category": "mainline", "battle_kind": "passStage", + "supported": state == "received"} for i, state in enumerate(["finished", "locked", "received"] * 400)] + rows, _ = self.engine._overlay_battle_capabilities(rows, []) + self.assertTrue(all(row["block_reason"] == "" and row["reason_kind"] != "model_unsupported" for row in rows)) + self.assertTrue(all(row["supported"] is None and row["reason_kind"] == "unchecked" + for row in rows if row["state"] == "received")) + self.runtime.inspect.assert_not_called() + + def test_inspect_support_does_not_relabel_a_recorded_loss_as_unsupported_or_win(self): + row = self.refresh() + self.assertIs(row["supported"], True) + self.engine._progression_records = [{"task_type_id": "1002013", "task_id": 11, + "battle_kind": "passStage", "battle_mode": "experimental", "outcome": "loss"}] + before = deepcopy(self.engine._progression_records) + view = build_view(self.engine, "battles", default_config()) + self.assertEqual(view["rows"][0]["outcome"], "loss") + self.assertIn("打不过", view["rows"][0]["outcome_label"]) + self.assertEqual(self.engine._progression_records, before) + + +if __name__ == "__main__": + unittest.main() diff --git a/ranch_assistant/tests/test_battle_recovery.py b/ranch_assistant/tests/test_battle_recovery.py new file mode 100644 index 0000000..6fb4d46 --- /dev/null +++ b/ranch_assistant/tests/test_battle_recovery.py @@ -0,0 +1,492 @@ +"""Interrupted combat recovery; all server calls and worker results are offline fakes.""" +from copy import deepcopy +import json +import threading +import unittest +from unittest.mock import Mock, patch + +from ranch_assistant.battles import BattleJournal, BattleOrchestrator +from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime, fixture, intent, policy +from ranch_assistant.tests.test_core import workspace_temp + + +class BattleRecoveryTests(unittest.TestCase): + def setUp(self): + self.folder = self.enterContext(workspace_temp()) + self.path = self.folder / "journal.json" + self.catalog, self.snapshot = fixture() + self.snapshot.raw["currentTasks"] = [{"id": 51, "typeId": "1002013", "curStep": 1}] + self.runtime = ExperimentalRuntime() + self.client = Mock() + self.client.call.side_effect = lambda path, payload: {"resCode": 0, "triggerEvent": False, "reward": {}} + self.runner = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime) + self.action = intent(kind="stage_battle", source_task_id=51, source_task_type_id="1002013", source_step_number=1) + self.policy = policy(battle_mode="experimental") + + def paths(self): + return [call.args[0] for call in self.client.call.call_args_list] + + def restart(self): + self.runner = BattleOrchestrator(self.catalog, BattleJournal(self.path), self.runtime) + + def test_generation_cancel_inside_worker_retries_saved_combat_without_second_entry(self): + cancel = threading.Event() + original = self.runtime._run + captured = [] + def interrupted(request, *, cancel_event): + captured.append(deepcopy(request)) + cancel_event.set() + return {"outcome": "cancelled", "execution_mode": "experimental", "execution_status": "cancelled", + "faithful": False, "approximate": True, "terminal": False, "terminal_reason": "worker_cancelled"} + self.runtime.run.side_effect = interrupted + self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel) + self.assertEqual(self.paths(), ["stageService/stageStart"]) + self.restart() + record = self.runner.pending(self.snapshot) + self.assertEqual(self.runner.recovery_status(record)["state"], "retry_local_runtime") + self.snapshot.raw["monsters"][0]["level"] = 999 + retried = [] + def complete(request, *, cancel_event): + retried.append(deepcopy(request)) + return original(request, cancel_event=cancel_event) + self.runtime.run.side_effect = complete + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(retried[0], record["combat_request"]) + self.assertNotIn("level", retried[0]["roster"]["monsters"][0]) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) + self.assertIsNone(self.runner.pending(self.snapshot)) + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(len(self.paths()), 3) + + def test_cancel_at_completed_result_preserves_it_without_resimulation(self): + cancel = threading.Event() + def complete(request, *, cancel_event): + result = self.runtime._run(request, cancel_event=cancel_event) + cancel_event.set() + return result + self.runtime.run.side_effect = complete + self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel) + self.restart() + record = self.runner.pending(self.snapshot) + self.assertTrue(record["battle_data"]["win"]) + self.assertTrue(self.runner.resumable_task_clock(record)) + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.runtime.run.call_count, 1) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) + + def test_cancel_during_wait_resumes_saved_stage_battle_without_new_worker(self): + self.runner.clock = lambda: 0 + cancel = threading.Event() + cancel.wait = Mock(side_effect=lambda timeout: cancel.set() or True) + self.runtime.run.side_effect = lambda request, cancel_event: self.runtime._run(request, cancel_event=cancel_event) | { + "requires_realtime_wait": True, "model_elapsed_ms": 10000} + self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel) + self.restart() + record = self.runner.pending(self.snapshot) + self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result") + self.runner.journal.update(record, record["phase"], battle_ready_at=1) + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.runtime.run.call_count, 1) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) + + def test_save_combat_request_normalizes_comma_lineup_without_losing_slots_or_inputs(self): + from ranch_assistant.battle_quick import simulate_quick + from ranch_assistant.tests.test_battle_simulator import monster, request + for members in ([100001, 0, 100002], "100001,0,100002"): + with self.subTest(members=members): + combat = request(players=[monster(mid=100001), monster(mid=100002)], master_level=62, + battle_mode="experimental") + combat["roster"]["teams"][0]["monsters"] = members + combat["roster"]["master"]["sessionKey"] = "credential-canary" + combat["roster"]["monsters"][0]["nicName"] = "nickname-canary" + combat["roster"]["monsters"][0]["token"] = "credential-canary" + before = deepcopy(combat) + saved = self.runner.save_combat_request({}, combat)["combat_request"] + self.assertEqual(saved["roster"]["teams"][0]["monsters"], [100001, 0, 100002]) + self.assertEqual([row["id"] for row in saved["roster"]["monsters"]], [100001, 100002]) + normalized = deepcopy(before) + normalized["roster"]["teams"][0]["monsters"] = [100001, 0, 100002] + self.assertEqual(simulate_quick(saved), simulate_quick(normalized)) + self.assertNotIn("canary", json.dumps(saved)) + self.assertEqual(combat, before) + + def test_combat_input_is_durable_before_start_and_original_profile_survives_timeout(self): + self.runner.request_builder = lambda snapshot, action, chosen, request: request | {"damage_profile": "client_v4_x10"} + original = self.client.call.side_effect + def call(path, payload): + if path.endswith("stageStart"): + pending = BattleJournal(self.path).pending(self.snapshot) + self.assertEqual(pending["combat_request"]["damage_profile"], "client_v4_x10") + self.assertFalse(pending["settlement_dispatched"]) + return original(path, payload) + self.client.call.side_effect = call + self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental", + "execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit", + "faithful": False, "approximate": True, "damage_profile": None} + self.runner.run(self.client, self.snapshot, self.action, self.policy) + self.restart() + self.assertEqual(self.runner.pending(self.snapshot)["combat_request"]["damage_profile"], "client_v4_x10") + self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "retry_local_runtime") + + def test_settlement_lost_reply_is_never_replayed_even_with_saved_inputs(self): + def call(path, payload): + if path.endswith("battleEnd"): + raise TimeoutError() + return {"resCode": 0, "triggerEvent": False} + self.client.call.side_effect = call + with self.assertRaises(TimeoutError): + self.runner.run(self.client, self.snapshot, self.action, self.policy) + self.restart() + self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "blocked") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"]) + + def test_cancel_before_settlement_dispatch_remains_resumable(self): + cancel = threading.Event() + update = self.runner.journal.update + def stop(record, phase, **fields): + update(record, phase, **fields) + if phase == "settlement_pending": + cancel.set() + self.runner.journal.update = stop + self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=cancel) + self.restart() + record = self.runner.pending(self.snapshot) + self.assertFalse(record["settlement_dispatched"]) + self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) + + def test_preaccept_retry_requires_current_offer_day_and_never_reopens_entry(self): + self.action.update(source_task_id=0, source_task_type_id="4001004", source_step_number=0) + self.snapshot.raw["history"].update(loopTask={"1": ["4001004"]}, loopTaskTime=self.snapshot.now) + self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental", + "execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit", + "faithful": False, "approximate": True} + self.runner.run(self.client, self.snapshot, self.action, self.policy) + self.restart() + record = self.runner.pending(self.snapshot) + self.assertEqual(self.runner.recovery_status(record, snapshot=self.snapshot)["state"], "retry_local_runtime") + self.snapshot.raw["history"]["loopTaskTime"] -= 86400 + self.assertEqual(self.runner.recovery_status(record, snapshot=self.snapshot)["state"], "abandon_stage") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.runtime.run.call_count, 1) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"]) + self.assertEqual(self.client.call.call_args.args[1]["result"], 0) + + def test_local_retry_is_bounded_then_uses_failure_exit_without_another_worker(self): + self.runtime.run.side_effect = lambda *args, **kwargs: {"outcome": "timeout", "execution_mode": "experimental", + "execution_status": "timed_out", "terminal": False, "terminal_reason": "worker_wall_clock_limit", + "faithful": False, "approximate": True} + self.runner.run(self.client, self.snapshot, self.action, self.policy) + self.restart() + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.restart() + self.assertEqual(self.runner.pending(self.snapshot)["runtime_recovery_attempts"], 1) + self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "abandon_stage") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.runtime.run.call_count, 2) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/recordBattleResult"]) + + def test_stage_battle_with_confirmed_settlement_restart_only_finishes_record(self): + with patch.object(self.runner, "_record", side_effect=SystemExit("crash after durable settlement reply")): + with self.assertRaises(SystemExit): + self.runner.run(self.client, self.snapshot, self.action, self.policy) + self.restart() + self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "resume_result") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.runtime.run.call_count, 1) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) + + def test_stop_during_recovery_settlement_keeps_ack_and_resumes_only_optional_record(self): + initial_cancel = threading.Event() + def complete(request, *, cancel_event): + result = self.runtime._run(request, cancel_event=cancel_event) + cancel_event.set() + return result + self.runtime.run.side_effect = complete + self.runner.run(self.client, self.snapshot, self.action, self.policy, cancel=initial_cancel) + self.restart() + self.assertEqual(self.paths(), ["stageService/stageStart"]) + recovery_cancel = threading.Event() + def settlement_ack_after_stop(path, payload): + if path == "battleService/battleEnd": + recovery_cancel.set() + return {"resCode": 0, "reward": {"money": 11}} + self.client.call.side_effect = settlement_ack_after_stop + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=recovery_cancel) + self.assertTrue(recovery_cancel.is_set()) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"]) + self.restart() + record = self.runner.pending(self.snapshot) + self.assertEqual(record["phase"], "settlement_acknowledged") + self.assertTrue(record["settlement_confirmed"]) + self.assertFalse(record["record_dispatched"]) + self.assertIsNot(record.get("record_confirmed"), True) + self.assertEqual(record["response"], {"resCode": 0, "reward": {"money": 11}}) + self.assertEqual(self.runner.recovery_status(record)["state"], "resume_result") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=recovery_cancel) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd"]) + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.paths(), ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) + self.assertIsNone(self.runner.pending(self.snapshot)) + self.assertEqual(self.runtime.run.call_count, 1) + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(len(self.paths()), 3) + + def legacy_timeout(self, **changes): + record = self.runner.journal.begin(self.snapshot, self.action) + self.runner.journal.update(record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart", + start_response={"resCode": 0, "stageEvent": None, "triggerEvent": False}, + battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False, + terminal_reason="worker_wall_clock_limit", message="战斗已取消、超时或结果不确定,等待核对") + self.runner.journal.update(record, "unknown", **changes) + return record + + def test_legacy_worker_timeout_uses_original_failure_exit_once(self): + self.legacy_timeout() + before = deepcopy(self.snapshot.raw) + self.restart() + status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot) + self.assertEqual(status["state"], "abandon_stage") + self.assertIn("原始战斗输入", status["message"]) + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.paths(), ["battleService/recordBattleResult"]) + self.assertEqual(self.client.call.call_args.args[1], {"stageId": "0101", "cityId": "1", "result": 0}) + self.assertIsNone(self.runner.pending(self.snapshot)) + done = self.runner.journal.records(self.snapshot)[0] + self.assertEqual(done["outcome"], "abandoned") + self.assertTrue(done["record_confirmed"]) + self.assertNotIn("battle_data", done) + self.assertEqual(self.snapshot.raw, before) + self.runtime.run.assert_not_called() + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(len(self.paths()), 1) + + def test_lost_failure_response_stays_pending_and_is_never_replayed(self): + self.legacy_timeout() + self.client.call.side_effect = TimeoutError("lost failure acknowledgement") + with self.assertRaises(TimeoutError): + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.restart() + record = self.runner.pending(self.snapshot) + self.assertEqual(record["phase"], "record_unknown") + self.assertTrue(record["record_dispatched"]) + self.assertEqual(self.runner.recovery_status(record)["state"], "blocked") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.paths(), ["battleService/recordBattleResult"]) + + def test_real_preaccept_source_zero_legacy_timeout_exits_without_task_or_offer(self): + self.action.update(stage_id="0102", task_type_id="", source_task_id=0, + source_task_type_id="4001004", source_step_number=0, stage_category=None) + self.legacy_timeout() + before = deepcopy(self.snapshot.raw) + self.restart() + status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot.raw) + self.assertEqual(status["state"], "abandon_stage") + self.assertIn("旧记录缺少原始战斗输入", status["message"]) + self.assertNotIn("来源委托已变化", status["message"]) + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertEqual(self.paths(), ["battleService/recordBattleResult"]) + self.assertEqual(self.client.call.call_args.args[1], {"stageId": "0102", "cityId": "1", "result": 0}) + self.assertIsNone(self.runner.pending(self.snapshot)) + self.assertEqual(self.snapshot.raw, before) + self.assertEqual(self.runner.journal.role(self.snapshot)["losses"], 0) + self.assertEqual(self.runner.journal.records(self.snapshot)[0]["outcome"], "abandoned") + + def test_failure_acknowledged_before_crash_finishes_locally_without_second_record(self): + self.legacy_timeout() + finish = self.runner.journal.finish + self.runner.journal.finish = Mock(side_effect=SystemExit("crash after durable failure reply")) + with self.assertRaises(SystemExit): + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.runner.journal.finish = finish + self.restart() + self.assertEqual(self.runner.recovery_status(self.runner.pending(self.snapshot))["state"], "finish_abandonment") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.assertIsNone(self.runner.pending(self.snapshot)) + self.assertEqual(self.paths(), ["battleService/recordBattleResult"]) + + def test_unconfirmed_start_or_changed_source_or_settlement_attempt_blocks_failure_exit(self): + self.legacy_timeout() + for changes in ({"start_response": None}, {"settlement_dispatched": True}, + {"path": "battleService/battleEnd"}, {"source_task_id": 999}, + {"terminal_reason": "unclassified_failure"}): + with self.subTest(changes=changes): + original = deepcopy(self.runner.pending(self.snapshot)) + self.runner.journal.update(self.runner.pending(self.snapshot), "unknown", **changes) + status = self.runner.recovery_status(self.runner.pending(self.snapshot), snapshot=self.snapshot) + self.assertEqual(status["state"], "blocked") + self.runner.resume_task_clock(self.client, self.snapshot, self.action, self.policy, cancel=threading.Event()) + self.runner.journal.role(self.snapshot)["records"][-1] = original + self.runner.journal.save() + self.assertIsNotNone(self.runner.pending(self.snapshot)) + self.client.call.assert_not_called() + self.runtime.run.assert_not_called() + + +class EngineBattleRecoveryTests(unittest.TestCase): + def setUp(self): + from ranch_assistant.engine import Engine, demo_snapshot + from ranch_assistant.game_data import ProgressionData + from ranch_assistant.model import Catalog, Policy, Snapshot + from ranch_assistant.progression import ProgressionPolicy + self.folder = self.enterContext(workspace_temp()) + self.catalog = Catalog() + self.raw = deepcopy(demo_snapshot(self.catalog).raw) + self.raw["currentTasks"] = [{"id": 71, "typeId": "1002013", "curStep": 1}] + self.client = Mock() + self.client.snapshot.side_effect = lambda: Snapshot(deepcopy(self.raw)) + self.client.call.return_value = {"resCode": 0, "triggerEvent": False} + self.engine = Engine(self.catalog, self.client, self.folder / "purchase.json", + game_data=ProgressionData({"task_info": {}, "stage_info": {}, "game_setting": {}}), + experimental_runtime=ExperimentalRuntime()) + self.engine.policy = Policy(enabled=False, gift_enabled=False, fill=False) + self.engine.progression_policy = ProgressionPolicy(enabled=True, battle_mode="experimental") + self.engine.snapshot = Snapshot(deepcopy(self.raw)) + self.engine.master_sync.settle = Mock() + self.action = intent(kind="stage_battle", stage_id="0102", task_type_id="", source_task_id=0, + source_task_type_id="4001004", source_step_number=0) + self.record = self.engine.battle_journal.begin(self.engine.snapshot, self.action) + self.engine.battle_journal.update(self.record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart", + start_response={"resCode": 0, "stageEvent": None, "triggerEvent": False}, + battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False, + terminal_reason="worker_wall_clock_limit") + self.engine.auto = False + + def test_disabled_cold_commission_origin_blocks_until_quest_policy_is_enabled(self): + self.engine.game_data = None + self.engine.quest_policy.enabled = False + self.engine.daily_policy.enabled = True + before = self.engine.battle_journal.path.read_bytes() + record = deepcopy(self.record) + status = self.engine.pending_battle_recovery() + self.assertEqual(status["state"], "blocked_policy") + self.assertFalse(status["resumable"]) + self.assertIn("等待启用自动委托来源策略", status["message"]) + self.assertEqual(self.engine.battle_journal.path.read_bytes(), before) + self.engine.poll(resume_pending=True) + self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot), record) + self.client.call.assert_not_called() + self.assertFalse(self.engine.quest_policy.enabled) + self.assertTrue(self.engine.daily_policy.enabled) + self.engine.quest_policy.enabled = True + self.assertTrue(self.engine.pending_battle_recovery()["resumable"]) + self.engine.poll(resume_pending=True) + self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot)) + self.assertEqual(self.client.call.call_count, 1) + self.assertEqual(self.client.call.call_args.args[0], "battleService/recordBattleResult") + + def test_enabled_cold_commission_origin_does_not_require_mainline_policy(self): + self.engine.game_data = None + self.engine.progression_policy.enabled = False + self.engine.quest_policy.enabled = True + status = self.engine.pending_battle_recovery() + self.assertEqual(status["state"], "abandon_stage") + self.assertTrue(status["resumable"]) + self.assertIsNotNone(self.engine.game_data) + self.assertTrue(self.engine._is_commission(self.record)) + self.assertFalse(self.engine.progression_policy.enabled) + self.client.call.assert_not_called() + + def test_disabled_map_and_mainline_origins_name_their_policies(self): + self.engine.progression_policy.enabled = False + self.engine.sweep_policy.enabled = False + for kind, source_id, source_type, source_step, label in ( + ("map_battle", 0, "", 0, "自动扫荡"), + ("stage_battle", 71, "1002013", 1, "自动主线")): + with self.subTest(kind=kind): + self.engine.game_data = None + self.engine.battle_journal.update(self.record, "waiting_for_battle_clock", kind=kind, + source_task_id=source_id, source_task_type_id=source_type, source_step_number=source_step, + battle_data={"win": True}, execution_status="completed", terminal=True, + experimental_settlement_eligible=True, approximate=True, faithful=False, resume_clock_ready=True) + self.assertTrue(self.engine.battles.recovery_status(self.record, snapshot=self.engine.snapshot)["resumable"]) + status = self.engine.pending_battle_recovery() + self.assertEqual(status["state"], "blocked_policy") + self.assertFalse(status["resumable"]) + self.assertIn("等待启用" + label + "来源策略", status["message"]) + self.client.call.assert_not_called() + + def test_web_explicit_running_resumes_preaccept_failure_while_auto_stays_false(self): + self.engine.cancel_progression() + self.engine.poll(resume_pending=False) + self.client.call.assert_not_called() + self.assertTrue(self.engine.pending_battle_recovery()["resumable"]) + self.engine.poll(resume_pending=True) + self.assertFalse(self.engine.auto) + self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot)) + self.assertEqual(self.client.call.call_count, 1) + self.assertEqual(self.client.call.call_args.args, ("battleService/recordBattleResult", {"stageId": "0102", "cityId": "1", "result": 0})) + self.assertEqual(self.engine.snapshot.raw["currentTasks"], self.raw["currentTasks"]) + self.assertFalse(self.engine._progression_pending()) + self.engine._require_no_battle() # Other selected strategies are no longer blocked. + self.engine.poll(resume_pending=True) + self.assertEqual(self.client.call.call_count, 1) + + def test_new_stop_during_snapshot_read_wins_over_old_running_argument(self): + read = self.client.snapshot.side_effect + def read_then_stop(): + result = read() + self.engine.cancel_progression() + return result + self.client.snapshot.side_effect = read_then_stop + self.engine.poll(resume_pending=True) + self.assertTrue(self.engine._progression_cancel.is_set()) + self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot)) + self.client.call.assert_not_called() + self.client.snapshot.side_effect = read + self.engine.poll(resume_pending=True) + self.assertEqual(self.client.call.call_count, 1) + + def test_guard_is_read_only_and_unknown_settlement_is_blocked(self): + self.engine.battle_journal.update(self.record, "unknown", path="battleService/battleEnd", settlement_dispatched=True) + before = self.engine.battle_journal.path.read_bytes() + status = self.engine.pending_battle_recovery() + self.assertEqual(status["state"], "blocked") + self.assertFalse(status["resumable"]) + self.assertEqual(self.engine.battle_journal.path.read_bytes(), before) + record = deepcopy(self.engine.battle_journal.pending(self.engine.snapshot)) + self.engine.poll(resume_pending=True) + self.assertEqual(self.engine.battle_journal.pending(self.engine.snapshot), record) + self.client.call.assert_not_called() + self.assertIsNotNone(self.engine.battle_journal.pending(self.engine.snapshot)) + + def test_engine_generation_cancel_in_worker_resumes_single_started_entry(self): + from ranch_assistant.model import Snapshot + from ranch_assistant.progression import ProgressionIntent + self.engine.battle_journal.finish(self.engine.snapshot, self.record, "cancelled") + self.raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [900]}] + self.raw["history"]["unlockStage"] = {"0102": [1]} + self.raw["history"].update(loopTask={"1": ["4001004"]}, loopTaskTime=self.engine.snapshot.now) + self.engine.snapshot = Snapshot(deepcopy(self.raw)) + self.engine.battles.catalog = fixture()[0] + self.engine.game_data.stages["0102"] = {"level": {"1": {"battle": {"fixture": True}}}} + self.engine._battle_catalog_ready = True + self.engine._ensure_progression() + scope, _ = self.engine.progression_planner._account(self.engine.snapshot) + action = ProgressionIntent(kind="stage_battle", description="offline preaccept farming", stage_id="0102", + difficulty=1, battle_kind="ordinary_stage", path="stageService/stageStart", team="teamA", + battle_mode="experimental", account_key=scope, token="offline-fixture", source_task_type_id="4001004") + self.engine.progression_planner._issued[action.token] = action.to_dict() + self.engine._select_battle_runtime("experimental") + runtime = self.engine.battles.runtime + def interrupted(request, *, cancel_event): + self.engine.cancel_progression() + return {"outcome": "cancelled", "execution_mode": "experimental", "execution_status": "cancelled", + "faithful": False, "approximate": True, "terminal": False, "terminal_reason": "worker_cancelled"} + runtime.run.side_effect = interrupted + self.engine.battles.run(self.client, self.engine.snapshot, action, + self.engine.progression_policy, cancel=self.engine._progression_cancel) + self.assertEqual(self.engine._progression_cancel_generation, 1) + self.assertEqual(self.engine.pending_battle_recovery()["state"], "retry_local_runtime") + runtime.run.side_effect = runtime._run + self.engine.poll(resume_pending=True) + self.assertIsNone(self.engine.battle_journal.pending(self.engine.snapshot)) + self.assertEqual([call.args[0] for call in self.client.call.call_args_list], + ["stageService/stageStart", "battleService/battleEnd", "battleService/recordBattleResult"]) + self.assertEqual(runtime.run.call_count, 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/ranch_assistant/tests/test_battle_worker_transport.py b/ranch_assistant/tests/test_battle_worker_transport.py new file mode 100644 index 0000000..0c5774d --- /dev/null +++ b/ranch_assistant/tests/test_battle_worker_transport.py @@ -0,0 +1,146 @@ +"""Bounded, offline regressions for the fixed battle worker's stdin transport.""" +import json +import subprocess +import sys +import threading +import unittest +from unittest.mock import patch + +from ranch_assistant import battle_simulator as simulator +from ranch_assistant.battle_quick import simulate_quick +from ranch_assistant.tests.test_battle_simulator import request + + +# Delay the real worker's first read past several parent polling quanta. +SLOW_WORKER = """ +import runpy, sys, time +time.sleep(.2) +sys.argv = ['ranch_assistant.battle_simulator', '--worker'] +runpy.run_module('ranch_assistant.battle_simulator', run_name='__main__') +""" + + +class PartialFirstWrite: + """Reproduce POSIX's partial-write/None-retry behavior on every platform. + + The child and its pipes are real. A tiny first write followed by a timeout + leaves stdin open; a retry without input never resumes that write. No + background writer is needed, so killed children cannot leave writer threads. + """ + + def __init__(self, process): + self.process = process + self.partial_write = False + self.timeouts = 0 + + def __getattr__(self, name): + return getattr(self.process, name) + + def communicate(self, input=None, timeout=None): + if self.process.stdin is not None and self.process.poll() is None: + if input is not None: + self.process.stdin.write(input[:512]) + self.process.stdin.flush() + self.partial_write = True + try: + self.process.wait(timeout=timeout) + except subprocess.TimeoutExpired: + self.timeouts += 1 + raise + try: + return self.process.communicate(input=input, timeout=timeout) + except subprocess.TimeoutExpired: + self.timeouts += 1 + raise + + +class BattleWorkerTransportTests(unittest.TestCase): + def large_request(self): + payload = request() + # A valid snapshot field retained by the combat-only serializer. + payload['roster']['monsters'][0]['nicName'] = 'x' * (128 * 1024) + return payload + + def launch_slow_worker(self, *, partial=False, cancel_event=None): + real_popen = subprocess.Popen + launched = [] + streams = [] + + def launch(command, **kwargs): + self.assertEqual(command, [sys.executable, '-m', + 'ranch_assistant.battle_simulator', '--worker']) + self.assertNotIn('shell', kwargs) + stream = kwargs['stdin'] + if stream != subprocess.PIPE: + streams.append(stream) + wire = stream.read() + self.assertGreater(len(wire), 128 * 1024) + self.assertLessEqual(len(wire), simulator.MAX_WIRE_BYTES) + self.assertNotIn(b'account-secret', wire) + self.assertEqual(json.loads(wire)['request']['roster']['monsters'][0]['nicName'], + 'x' * (128 * 1024)) + stream.seek(0) + process = real_popen([sys.executable, '-c', SLOW_WORKER], **kwargs) + observed = PartialFirstWrite(process) if partial else process + launched.append(observed) + if cancel_event is not None: + cancel_event.set() + return observed + + return launch, launched, streams + + def assert_cleaned_up(self, processes, streams): + self.assertEqual(len(processes), 1) + self.assertIsNotNone(processes[0].poll()) + self.assertTrue(processes[0].stdout.closed) + self.assertTrue(processes[0].stderr.closed) + for stream in streams: + self.assertTrue(stream.closed) + + def test_partial_first_quantum_delivers_one_complete_request(self): + payload = self.large_request() + expected = simulate_quick(payload) + self.assertIn(expected['outcome'], ('win', 'loss')) + launch, processes, streams = self.launch_slow_worker(partial=True) + with patch.object(simulator.subprocess, 'Popen', side_effect=launch): + actual = simulator.ExperimentalBattleRuntime().run(payload, timeout=1.5) + self.assert_cleaned_up(processes, streams) + self.assertGreaterEqual(processes[0].timeouts, 2) + self.assertEqual(actual, expected) + + def test_native_slow_reader_preserves_result_and_omits_credentials(self): + payload = self.large_request() + expected = simulate_quick(payload) + payload['credentials'] = 'account-secret' + payload['roster']['master']['token'] = 'account-secret' + launch, processes, streams = self.launch_slow_worker() + with patch.object(simulator.subprocess, 'Popen', side_effect=launch): + actual = simulator.ExperimentalBattleRuntime().run(payload, timeout=1.5) + self.assert_cleaned_up(processes, streams) + self.assertEqual(actual, expected) + + def test_cancel_and_deadline_reap_slow_reader_and_close_input(self): + for cancelled in (False, True): + with self.subTest(cancelled=cancelled): + event = threading.Event() + launch, processes, streams = self.launch_slow_worker( + cancel_event=event if cancelled else None) + with patch.object(simulator.subprocess, 'Popen', side_effect=launch): + result = simulator.ExperimentalBattleRuntime().run( + self.large_request(), cancel_event=event, + timeout=1.5 if cancelled else .1) + self.assertEqual(result['outcome'], 'cancelled' if cancelled else 'timeout') + self.assertFalse(result['terminal']) + self.assertIsNone(result['battle_data']) + self.assert_cleaned_up(processes, streams) + + def test_oversize_input_never_launches_worker(self): + with patch.object(simulator, 'MAX_WIRE_BYTES', 1024), \ + patch.object(simulator.subprocess, 'Popen') as launch: + result = simulator.ExperimentalBattleRuntime().run(self.large_request()) + launch.assert_not_called() + self.assertEqual(result['terminal_reason'], 'request_exceeds_worker_input_limit') + + +if __name__ == '__main__': + unittest.main() diff --git a/ranch_web/PRODUCT.md b/ranch_web/PRODUCT.md index fad2654..6cc1f6a 100644 --- a/ranch_web/PRODUCT.md +++ b/ranch_web/PRODUCT.md @@ -1,10 +1,10 @@ -# 牧羊人之心牧场助手 · Web 2.0.9 +# 牧羊人之心牧场助手 · Web 2.0.10 ## 产品约束 -把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。Web `2.0.9`,源码发布入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md),既有功能与历史验证见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。 +把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。Web `2.0.10`,源码发布入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md),既有功能与历史验证见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。 -2.0.9 包含界面清理、委托补缺、默认快速战斗与潜能误报修复;保留账号简短状态、错误、表格、表单与原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_9.md)。 +2.0.10 聚焦战斗输入传输、中断恢复、启停意愿与能力状态纠正;保留账号简短状态、错误、表格、表单与原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_10.md)。 使用者在 Windows 本机配置、验证,随后可在 Linux Docker 常驻运行。多个浏览器访问同一个管理员工作台;账号互相隔离,各账号串行执行,账号之间可以并行。 @@ -28,13 +28,15 @@ - 帮助可检查 GitHub 正式版本并提交受控更新请求。未配置部署器时明确显示原因,更新提交不表示更新成功。 - 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,稳定 Release 与正式镜像发布后,可直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器;升级完成后刷新网页以加载新版界面,安装结果以宿主机健康检查为准。 -## 2.0.9 本轮范围 +## 2.0.10 本轮范围 -默认使用快速数值模型,委托按剩余步骤统一计算采购和提交需求: +- Linux 战斗子进程从匿名临时文件一次读取完整 stdin,保留取消、超时及输入大小检查。 +- 升级后,旧委托备料记录若已确认入场、未发送结算且符合技术失败条件,按原客户端协议记录失败并退出一次;兼容来源任务与步骤均为0的记录,不重新入场或提交胜利。 +- 保存的原始战斗输入最多用于一次本地恢复;完整战果校验通过后按战斗时钟续交尚未发送的结果。未知已发送写请求不重放。 +- 手动停止阻止恢复提交;内部暂停保留用户运行意愿,来源策略关闭时明确等待启用,不自动开启策略。 +- 状态接口透出5个安全策略状态字段,区分运行意愿、实际执行与等待原因;修复导航及策略关闭时的能力误报,保留真实不支持、资源不足及失败原因。具体行为见 [发布说明](../analysis/RELEASE_2_0_10.md)。 -- 委托用明确中文说明未接取的实际原因;成熟魔物交付需求联动购蛋、孵化,优先备齐所需资源再接取。锁定、培养、优质备份等魔物继续受保护,采购与孵蛋遵守耗用预算和需求缺口限制。 -- 正常执行默认使用现有内置实验运行时入口的快速 HP/DPS 模型,保留现有伤害配置,无需选择新模式;逐帧实现仅供研发。模型结合双方属性、血量、每秒伤害(DPS)、有效血量(EHP)、时间与关卡目标估算胜利、战败或超时,仍有机制简化,不保证全部关卡可通关或与客户端结果一致。 -- 潜能检查依据合法的 `PotentialPanel` 上限区分正常数值与异常,修复正常潜能的误报。 +沿用 2.0.9 的快速 HP/DPS 模型、伤害配置、按剩余步骤计算的委托备料及正常潜能误报修复,历史范围见 [2.0.9 发布说明](../analysis/RELEASE_2_0_9.md)。 ## 2.0.8 自动委托与每日历史 @@ -89,9 +91,9 @@ ## 安全与验证 -2.0.9 快速模型可读取358/358份主线与委托战斗配置,表示输入可计算。离线样本有胜有败,8个20氪金委托战斗为5胜3败;当前卡点样本的默认路径结果及耗时见 [发布说明](../analysis/RELEASE_2_0_9.md#验证)。 +2.0.10 后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过。范围见 [本版发布说明](../analysis/RELEASE_2_0_10.md#验证);战斗模型仍为近似实现。 -617项唯一回归用例中615项通过,2项因Windows环境跳过;另有8项界面浏览器测试通过。多步骤采购修复已通过独立复核;未在线提交游戏结算。 +2.0.9 的历史验证见 [历史发布说明](../analysis/RELEASE_2_0_9.md#验证),不计入本版。 2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过。证据与发布门禁见 [发布说明](../analysis/RELEASE_2_0_8.md#验证);历史版本结果不计入本版。 diff --git a/ranch_web/README.md b/ranch_web/README.md index 4564d8b..35c0486 100644 --- a/ranch_web/README.md +++ b/ranch_web/README.md @@ -1,8 +1,8 @@ -# Web 2.0.9 运行说明 +# Web 2.0.10 运行说明 -Web **2.0.9**,源码发布入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。自动委托提供当前委托与每日记录,功能和历史验证状态见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。 +Web **2.0.10**,源码发布入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。自动委托提供当前委托与每日记录,功能和历史验证状态见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。 -2.0.9 清理重复运行提示,补齐委托资源准备、默认快速战斗及正常潜能误报修复。委托明确显示中文未接取原因,成熟魔物需求联动购蛋、孵化;按剩余步骤备料,遵守预算、需求缺口及魔物保护设置。详情继续使用原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_9.md)。 +2.0.10 修复 Linux 战斗子进程大输入传输、停止检查及导航能力误报。升级后按保存的入场、原始输入与战果证据恢复:符合条件的旧委托备料技术失败记录退出一次,完整战果续交尚未发送的结果;未知已发送写请求不重放。中文状态明确指出等待原因,详情继续使用原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_10.md)。 正常执行默认使用现有内置实验运行时入口的快速 HP/DPS 模型,保留现有伤害配置,无需选择新模式;逐帧实现仅供研发。模型按双方属性、血量、每秒伤害、时间与目标估算胜利、战败或超时,仍有机制简化,不保证全部关卡可通关或与客户端结果一致。 @@ -49,7 +49,7 @@ py -3 -m venv .venv-web 关闭网页或退出 Web 管理登录不会停止服务器上的账号监控和已开启策略。账号监控、重登及策略执行都由服务端管理。手动“停止”只暂停策略,连接监控与掉线重登继续;该暂停在重新登录和服务重启后仍保留,点击“开启”恢复。 -临时网络故障采用退避后的只读状态检查,确认角色连接恢复后自动继续原先启用的策略。会话失效时按登录页等待时长自动重新登录。账号状态区分用户暂停、临时恢复和请求待核对,心跳成功不等于策略已经运行;日志保留失败原因及恢复结果。未确认的消耗请求仍保留核对记录,不自动重复提交。 +临时网络故障采用退避后的只读状态检查,确认角色连接恢复后自动继续原先启用的策略。会话失效时按登录页等待时长自动重新登录。账号状态区分用户暂停、临时恢复和请求待核对,心跳成功不等于策略已经运行;日志保留失败原因及恢复结果。内部暂停保留用户运行意愿;来源策略关闭时明确等待启用,不自动勾选。已保存的完整战果仅在用户允许运行、来源策略已启用、原入场及来源校验通过且战斗时钟满足时续交尚未发送的结果;手动停止阻止恢复提交,未知已发送写请求保留核对记录,不自动重发。 服务重启会保留配置、加密会话及启停选择,并自动恢复有登录记录的账号。只有清除登录记录或移除账号才取消持续自动登录;缺少密码、区服或原角色信息时显示具体原因。运行日志按账号限量持久保存,旧角色数据会标注缓存状态。 @@ -108,13 +108,17 @@ 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 认证的部署,稳定 Release 和正式镜像就绪、宿主机心跳有效后,可直接通过“帮助 → 检查版本更新…”升级 **2.0.9**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。 +已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,稳定 Release 和正式镜像就绪、宿主机心跳有效后,可直接通过“帮助 → 检查版本更新…”升级 **2.0.10**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。 ## 离线验证 -2.0.9 快速模型的输入预检覆盖358/358份主线与委托战斗配置。当前卡点的真实账号离线样本预计战斗5秒,直接计算约1.2毫秒,含隔离进程启动与检查约0.21秒;8个20氪金委托战斗的离线结果为5胜3败,见 [本版发布说明](../analysis/RELEASE_2_0_9.md#验证)。 +2.0.10 后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过,见 [本版发布说明](../analysis/RELEASE_2_0_10.md#验证)。镜像工作流新增子进程传输、战斗恢复、能力展示、Web 生命周期、恢复契约及状态 API 六个定向模块: -617项唯一回归用例中615项通过,2项因Windows环境跳过;另有8项界面浏览器测试通过。多步骤采购循环已经修复并独立复核。本轮未在线提交游戏结算或手动部署X99。 +```console +python -B -m unittest ranch_assistant.tests.test_battle_worker_transport ranch_assistant.tests.test_battle_recovery ranch_assistant.tests.test_battle_capability_presentation ranch_web.tests.test_lifecycle_recovery ranch_web.tests.test_battle_recovery_contract ranch_web.tests.test_status_recovery_api -v +``` + +2.0.9 的历史验证见 [历史发布说明](../analysis/RELEASE_2_0_9.md#验证),不计入本版。 2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过。分组结果与证据见 [发布说明](../analysis/RELEASE_2_0_8.md#验证)。2.0.7 的结果保留在 [历史发布说明](../analysis/RELEASE_2_0_7.md#验证),以下历史记录也不计入本版验收。 diff --git a/ranch_web/__init__.py b/ranch_web/__init__.py index 4322e05..ea0014b 100644 --- a/ranch_web/__init__.py +++ b/ranch_web/__init__.py @@ -1,6 +1,6 @@ """Headless Web workspace for the ranch assistant.""" -__version__ = "2.0.9" +__version__ = "2.0.10" GAME_VERSION = "1.9.68" __all__ = ["__version__", "GAME_VERSION"] diff --git a/ranch_web/app.py b/ranch_web/app.py index 57b30c2..6161ce9 100644 --- a/ranch_web/app.py +++ b/ranch_web/app.py @@ -577,9 +577,11 @@ def create_app(data_dir=None, manager=None, config=None, updates=None) -> FastAP if not isinstance(value, dict): raise HTTPException(500, "账号状态返回格式不正确") result = {field: value.get(field) for field in ("id", "label", "connected", "demo", "running", "busy", "revision", "error", - "connection_state", "connection_message", "last_game_success_at", "next_retry_at")} + "connection_state", "connection_message", "last_game_success_at", "next_retry_at", + "strategy_requested", "manual_stop", "strategy_state", "strategy_message", "strategy_retry_at")} result["error"] = public_error(result["error"]) result["connection_message"] = public_error(result["connection_message"]) + result["strategy_message"] = public_error(result["strategy_message"]) auto = value.get("auto_relogin_status") result["auto_relogin_status"] = ({field: auto.get(field) for field in ("state", "message", "next_attempt_at")} if isinstance(auto, dict) else None) diff --git a/ranch_web/service.py b/ranch_web/service.py index c0eff90..a200fa3 100644 --- a/ranch_web/service.py +++ b/ranch_web/service.py @@ -335,12 +335,54 @@ class AccountWorker: self._legacy_pending.pop(identity) self._save_run_intents() + def _pending_battle_recovery(self): + classify = getattr(self.engine, "pending_battle_recovery", None) + if callable(classify): + status = classify() + return status if isinstance(status, dict) else {} + # Compatibility for older Engine test doubles without the public API. + if self.engine.snapshot is not None: + record = self.engine.battle_journal.pending(self.engine.snapshot) + if record: + if self.engine.battles.resumable_task_clock(record) is True: + return {"resumable": True, "message": "战果已保存;等待结算时间及对应策略启用后续交"} + return {} + def _pending_execution_reason(self): + suffix = ";禁止自动重发,请在游戏内核对结果" 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 "存在未确认的任务、战斗、探险或突破请求,禁止自动重发;后台继续核对,核对完成后恢复已勾选策略" + kind = self._legacy_pending[self.active_identity]["kind"] + return {"gift": "赠礼", "hatch": "装填", "feed": "喂养"}[kind] + "请求结果待核对" + suffix + if self.engine.snapshot is None: + return "" + if self.engine._progression_pending(): + sweep = self.engine.sweeper.state.get("pending") + if sweep: + return f"扫荡(关卡 {sweep.get('stage', '')}):{sweep.get('phase') or '请求结果待核对'}" + suffix + recovery = self._pending_battle_recovery() + if recovery.get("state") == "blocked_policy": + return recovery.get("message") or "等待启用本次战斗的来源策略后恢复" + if recovery.get("resumable") is not True: + record = self.engine.battle_journal.pending(self.engine.snapshot) or {} + label = record.get("description") or ("战斗" if record.get("stage_id") else "任务") + if record.get("stage_id"): + label += f"(关卡 {record['stage_id']},难度 {record.get('difficulty') or 1})" + detail = record.get("message") or "请求结果待核对" + if record.get("execution_status") == "timed_out" or record.get("terminal_reason") == "worker_wall_clock_limit": + detail = "本地战斗计算超时" + if (not record.get("battle_data") and not record.get("settlement_dispatched") + and not record.get("settlement_confirmed") + and record.get("path") in ("", "battleService/battleStart", "stageService/stageStart")): + detail += ",尚未提交结算" + return label + ":" + detail + suffix + explore = self.engine.explore_planner.pending(self.engine.snapshot) + if explore: + label = "探险出发" if explore.get("kind") == "explore_start" else "探险领奖" + return f"{label}(队伍 {explore.get('team_id', '')}):{explore.get('message') or '请求结果待核对'}" + suffix + if self.engine._breakthrough_pending: + record = self.engine._breakthrough_pending + label = "潜能提升" if record.get("kind") == "potential" else "突破" + return label + ":" + (record.get("message") or "请求结果待核对") + suffix return "" def _refresh_execution(self): @@ -372,6 +414,9 @@ class AccountWorker: state, message = "recovering", self.connection_message elif not self._running: state, message = "offline", self.connection_message + elif (recovery := self._pending_battle_recovery()).get("resumable") is True: + state = "recovering" + message = recovery.get("message") or "等待对应策略允许恢复" else: state, message = "running", "已勾选的策略将自动执行" return {"strategy_requested": requested, "manual_stop": not requested, @@ -1117,15 +1162,24 @@ class AccountWorker: self.schedule.next_fast[kind] = math.inf auto = True value = self.engine.poll_automation(kind) - elif kind == "poll": - auto = self._set_auto(self._running) - value = self.engine.poll(defer_hatch=True) - self.schedule.poll_finished(self.config) - elif kind == "reconcile": - self._set_auto(False) - # Engine's durable pending barriers reconcile before planning. - # A check never silently replays an uncertain write. - value = self.engine.poll(defer_hatch=True) + elif kind in ("poll", "reconcile"): + recovering = self._pending_battle_recovery().get("resumable") is True + with self.lock: + # Recover only the original entry, with general automation + # disabled. Stop/config changes still revoke this job. + auto = self._set_auto(self._running and kind == "poll" and not recovering) + resume_pending = bool(recovering and self._running and self.strategy_requested + and not self._closing and not self.manager._closing and job.generation == self._generation) + if resume_pending: + job.consuming = True + self.check_intent() + if callable(getattr(self.engine, "pending_battle_recovery", None)): + value = self.engine.poll(defer_hatch=True, resume_pending=resume_pending) + else: + # Older Engine doubles use auto to authorize saved results. + if resume_pending: + auto = self._set_auto(True) + value = self.engine.poll(defer_hatch=True) self.schedule.poll_finished(self.config) else: self._set_auto(False) @@ -1140,7 +1194,9 @@ class AccountWorker: # by the current Engine generation turns that switch off. if auto and job.generation == self._generation and not self.engine.auto: if self._pending_execution_reason(): - self.stop() + # A pending barrier pauses execution, not user intent + # or the generation of other queued local edits. + self._refresh_execution() else: self._execution_failed(ValueError(value[2] or "策略暂不可用")) elif auto and job.generation == self._generation: diff --git a/ranch_web/static/app.js b/ranch_web/static/app.js index 13d66c2..70dbee0 100644 --- a/ranch_web/static/app.js +++ b/ranch_web/static/app.js @@ -415,7 +415,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.9'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`})),{info:true}); + if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.10'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`})),{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('请先新增或选择账号。'); @@ -640,7 +640,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.9';$('#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.10';$('#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})));} } diff --git a/ranch_web/static/index.html b/ranch_web/static/index.html index 2d9d912..1c0840b 100644 --- a/ranch_web/static/index.html +++ b/ranch_web/static/index.html @@ -26,7 +26,7 @@ - 牧羊人之心牧场助手 2.0.9 + 牧羊人之心牧场助手 2.0.10
diff --git a/ranch_web/tests/test_battle_recovery_contract.py b/ranch_web/tests/test_battle_recovery_contract.py new file mode 100644 index 0000000..f278421 --- /dev/null +++ b/ranch_web/tests/test_battle_recovery_contract.py @@ -0,0 +1,247 @@ +"""Web authorization of Engine-classified recovery, using offline clients only.""" +from copy import deepcopy +import math +import time +from types import SimpleNamespace +import unittest +from unittest.mock import Mock, patch + +from ranch_assistant.game_data import ProgressionData +from ranch_assistant.model import Snapshot +from ranch_web.service import AccountWorker +from ranch_web.tests import test_lifecycle_recovery as lifecycle +from ranch_web.tests import test_service as fixtures +from ranch_web.views import build_view + + +class RecoveryGuardContractTests(unittest.TestCase): + def worker(self, runtime): + worker = AccountWorker.__new__(AccountWorker) + worker.active_identity, worker._legacy_pending = None, {} + record = {"kind": "stage_battle", "stage_id": "0102", "phase": "unknown", + "execution_status": "timed_out", "terminal_reason": "worker_wall_clock_limit", + "path": "stageService/stageStart"} + worker.engine = SimpleNamespace(snapshot=object(), battles=runtime, + battle_journal=SimpleNamespace(pending=lambda snapshot: record), + _progression_pending=lambda: record, sweeper=SimpleNamespace(state={}), + explore_planner=SimpleNamespace(pending=lambda snapshot: None), _breakthrough_pending=None) + return worker, record + + def test_engine_recovery_contract_overrides_old_clock_predicate(self): + for allowed in (False, True): + with self.subTest(allowed=allowed): + runtime = SimpleNamespace(recovery_status=Mock(return_value={ + "state": "abandon_stage" if allowed else "blocked", "resumable": allowed, + "message": "已确认开战,按原客户端协议退出"}), + resumable_task_clock=Mock(return_value=not allowed)) + worker, record = self.worker(runtime) + worker.engine.pending_battle_recovery = Mock(return_value=runtime.recovery_status.return_value) + self.assertEqual(worker._pending_execution_reason() == "", allowed) + worker.engine.pending_battle_recovery.assert_called_once_with() + runtime.recovery_status.assert_not_called() + runtime.resumable_task_clock.assert_not_called() + + def test_truthy_recovery_flag_does_not_grant_write_permission(self): + for flag in (1, "true", None): + with self.subTest(flag=flag): + worker, _ = self.worker(SimpleNamespace(recovery_status=lambda *args, **kwargs: { + "state": "abandon_stage", "resumable": flag, "message": ""}, + resumable_task_clock=lambda record: True)) + worker.engine.pending_battle_recovery = lambda: {"state": "abandon_stage", "resumable": flag, "message": ""} + self.assertTrue(worker._pending_execution_reason()) + + def test_runtime_without_recovery_helper_keeps_old_clock_fallback(self): + for allowed in (False, True): + with self.subTest(allowed=allowed): + worker, _ = self.worker(SimpleNamespace(resumable_task_clock=lambda record: allowed)) + self.assertEqual(worker._pending_execution_reason() == "", allowed) + + def test_disabled_origin_uses_specific_engine_policy_message(self): + worker, _ = self.worker(SimpleNamespace(resumable_task_clock=lambda record: True)) + message = "对应委托策略已关闭,等待启用委托策略后恢复原战斗" + worker.engine.pending_battle_recovery = lambda: { + "state": "blocked_policy", "resumable": False, "message": message} + self.assertEqual(worker._pending_execution_reason(), message) + + +class LegacyBattleRecoveryTests(unittest.TestCase): + setUp = fixtures.ServiceTests.setUp + account = fixtures.ServiceTests.account + idle = fixtures.ServiceTests.idle + job = fixtures.ServiceTests.job + connected = lifecycle.LifecycleRecoveryTests.connected + tick = lifecycle.LifecycleRecoveryTests.tick + paths = lifecycle.LifecycleRecoveryTests.paths + + def login(self, identifier): + return fixtures.ServiceTests.login(self, identifier, account="recovery-" + identifier) + + def legacy_timeout(self, *, unaccepted=False): + identifier, worker = self.connected() + engine = worker.engine + source_id, source_type, source_step = (0, "4001004", 0) if unaccepted else (51, "1002013", 1) + engine.client.raw["currentTasks"] = ([] if unaccepted else [ + {"id": source_id, "typeId": source_type, "curStep": source_step, "stepValue": 0}]) + engine.snapshot = Snapshot(deepcopy(engine.client.raw)) + engine.game_data = ProgressionData({"task_info": {source_type: {"type": 4, "name": "离线材料委托", + "steps": [{"statusType": "none", "statusValue": {}}]}}}) + config = self.manager.get_config(identifier) + config["config"]["quest_policy"]["enabled"] = True + self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"]) + journal = engine.battle_journal + record = journal.begin(engine.snapshot, {"kind": "stage_battle", "stage_id": "0102", "difficulty": 1, + "battle_kind": "ordinary_stage", "description": "离线委托材料关卡", "task_id": None, + "task_type_id": None, "source_task_id": source_id, + "source_task_type_id": source_type, "source_step_number": source_step}) + journal.update(record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart", + start_response={"resCode": 0, "triggerEvent": False, "stageEvent": None}, + battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False, + terminal_reason="worker_wall_clock_limit", message="战斗已取消、超时或结果不确定,等待核对") + self.assertEqual(engine.battles.recovery_status(record, snapshot=engine.snapshot)["state"], "abandon_stage") + engine.last_pending_check = time.monotonic() - 121 + worker.schedule.next_poll = math.inf + return identifier, worker + + def test_legacy_timeout_blocked_by_default_when_engine_denies_recovery(self): + identifier, worker = self.legacy_timeout() + evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot)) + before = len(fixtures.FakeClient.calls) + with patch.object(worker.engine, "pending_battle_recovery", return_value={ + "state": "blocked", "resumable": False, "message": "尚无可验证的安全恢复证据"}): + self.job(identifier, self.manager.submit(identifier, "start"), status="failed") + self.tick(identifier, worker) + self.assertFalse(worker.running) + self.assertTrue(worker.strategy_requested) + self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before))) + self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence) + + def test_strict_safe_legacy_timeout_starts_then_exits_on_reconcile_without_reentry(self): + identifier, worker = self.legacy_timeout() + self.assert_failure_exit(identifier, worker) + + def test_unaccepted_commission_legacy_timeout_exits_without_reentry_or_reward(self): + identifier, worker = self.legacy_timeout(unaccepted=True) + self.assert_failure_exit(identifier, worker) + + def assert_failure_exit(self, identifier, worker): + before = len(fixtures.FakeClient.calls) + self.job(identifier, self.manager.submit(identifier, "start")) + self.assertTrue(worker.running) + self.assertFalse(worker.engine.auto, "Start must not dispatch recovery inline") + self.assertEqual(len(fixtures.FakeClient.calls), before) + state = self.manager.status(identifier) + self.assertEqual(state["strategy_state"], "recovering") + self.assertIn("退出", state["strategy_message"]) + self.assertNotIn("战果已保存", state["strategy_message"]) + worker.schedule.next_poll = math.inf + after = self.manager.logs(identifier)["next"] + poll = worker.engine.poll + + def recovery_poll(**kwargs): + self.assertFalse(worker.engine.auto, "Recovery must not enable other strategies") + self.assertIs(kwargs.get("resume_pending"), True) + return poll(**kwargs) + + with patch.object(worker.engine, "poll", side_effect=recovery_poll): + self.assertEqual(self.tick(identifier, worker)["result"]["kind"], "reconcile") + writes = [("/".join(url.rsplit("/", 2)[-2:]), + {key: value for key, value in payload.items() if key not in {"token", "reqid", "reqsid"}}) + for _, url, payload in fixtures.FakeClient.calls[before:] + if not url.endswith("masterService/masterQueryDetail")] + self.assertEqual(writes, [("battleService/recordBattleResult", {"stageId": "0102", "cityId": "1", "result": 0})]) + self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot)) + self.assertTrue(worker.running) + self.assertTrue(worker.strategy_requested) + record = worker.engine.battle_journal.records(worker.engine.snapshot)[0] + self.assertEqual(record["outcome"], "abandoned") + self.assertNotIn("battle_data", record) + rows = build_view(worker.engine, "battles", worker.config)["rows"] + row = next(row for row in rows if row["outcome"] == "abandoned") + self.assertIn("已放弃(本地计算失败)", row["outcome_label"]) + self.assertNotIn("打不过", row["outcome_label"]) + logs = self.manager.logs(identifier, after=after)["entries"] + self.assertTrue(any("退出" in row["message"] for row in logs)) + self.assertFalse(any("打不过" in row["message"] for row in logs)) + + def test_manual_refresh_never_authorizes_safe_source_zero_recovery(self): + identifier, worker = self.legacy_timeout(unaccepted=True) + self.job(identifier, self.manager.submit(identifier, "start")) + before = len(fixtures.FakeClient.calls) + evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot)) + self.job(identifier, self.manager.submit(identifier, "refresh")) + self.assertTrue(worker.running) + self.assertFalse(worker.engine.auto) + self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence) + self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before))) + + def test_manual_stop_prevents_safe_legacy_failure_exit(self): + identifier, worker = self.legacy_timeout() + self.manager.submit(identifier, "stop") + before = len(fixtures.FakeClient.calls) + evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot)) + self.tick(identifier, worker) + self.assertTrue(self.manager.status(identifier)["manual_stop"]) + self.assertFalse(worker.running) + self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence) + self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before))) + + def test_disabled_source_policy_prevents_safe_legacy_failure_exit(self): + identifier, worker = self.legacy_timeout(unaccepted=True) + config = self.manager.get_config(identifier) + config["config"]["quest_policy"]["enabled"] = False + config["config"]["daily_policy"].update(enabled=True, selected=["gift"]) + self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"]) + worker.schedule.next_poll = math.inf + before = len(fixtures.FakeClient.calls) + evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot)) + self.job(identifier, self.manager.submit(identifier, "start"), status="failed") + self.tick(identifier, worker) + self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence) + self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before))) + state = self.manager.status(identifier) + self.assertFalse(state["running"]) + self.assertEqual(state["strategy_state"], "blocked") + self.assertTrue(state["strategy_requested"]) + self.assertFalse(state["manual_stop"]) + recovery = worker.engine.pending_battle_recovery() + self.assertEqual(recovery["state"], "blocked_policy") + self.assertEqual(state["strategy_message"], recovery["message"]) + self.assertIn("委托", state["strategy_message"]) + self.assertIn("启用", state["strategy_message"]) + self.assertFalse(worker.engine.quest_policy.enabled) + self.assertTrue(worker.engine.daily_policy.enabled) + + config = self.manager.get_config(identifier) + config["config"]["quest_policy"]["enabled"] = True + self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"]) + self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence) + worker.engine.last_pending_check = time.monotonic() - 121 + worker.schedule.next_poll = math.inf + self.tick(identifier, worker) + writes = [("/".join(url.rsplit("/", 2)[-2:]), payload.get("result")) + for _, url, payload in fixtures.FakeClient.calls[before:] + if not url.endswith("masterService/masterQueryDetail")] + self.assertEqual(writes, [("battleService/recordBattleResult", 0)]) + self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot)) + self.assertTrue(worker.running) + self.assertTrue(worker.strategy_requested) + + def test_unknown_start_settlement_or_failure_reply_never_grants_recovery(self): + for changes in ({"start_response": None}, {"settlement_dispatched": True, "path": "battleService/battleEnd"}, + {"record_dispatched": True}): + with self.subTest(changes=changes): + identifier, worker = self.legacy_timeout() + journal = worker.engine.battle_journal + journal.update(journal.pending(worker.engine.snapshot), "unknown", **changes) + evidence = deepcopy(journal.pending(worker.engine.snapshot)) + before = len(fixtures.FakeClient.calls) + self.job(identifier, self.manager.submit(identifier, "start"), status="failed") + self.tick(identifier, worker) + self.assertFalse(worker.running) + self.assertTrue(worker.strategy_requested) + self.assertEqual(journal.pending(worker.engine.snapshot), evidence) + self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before))) + + +if __name__ == "__main__": + unittest.main() diff --git a/ranch_web/tests/test_lifecycle_recovery.py b/ranch_web/tests/test_lifecycle_recovery.py new file mode 100644 index 0000000..bb253ef --- /dev/null +++ b/ranch_web/tests/test_lifecycle_recovery.py @@ -0,0 +1,345 @@ +"""Web recovery through real Engine barriers, temporary stores and offline HTTP.""" +from copy import deepcopy +import json +import math +import threading +import time +import unittest +from unittest.mock import patch + +import requests + +from ranch_assistant.game_data import ProgressionData +from ranch_assistant.model import Snapshot +from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime +from ranch_web.service import WebManager +from ranch_web.tests import test_service as fixtures + + +class LifecycleRecoveryTests(unittest.TestCase): + setUp = fixtures.ServiceTests.setUp + account = fixtures.ServiceTests.account + idle = fixtures.ServiceTests.idle + job = fixtures.ServiceTests.job + login = fixtures.ServiceTests.login + + def connected(self): + identifier = self.account(False) + self.login(identifier) + 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 + self.enterContext(patch.object(worker.engine, "master_sync_due", return_value=False)) + self.enterContext(patch.object(worker.engine, "growth_sync_due", return_value=False)) + return identifier, worker + + def battle(self, identifier, worker, *, timed_out=False): + """Small task fixture already used by Engine's orchestration regressions.""" + engine = worker.engine + raw = engine.client.raw + raw["master"].update(ti=1000, money=1000, timeTi=0) + raw["currentTasks"] = [{"id": 51, "typeId": "100", "curStep": 1, "stepValue": 0}] + raw["history"] = {"unlockCity": {"1": True}, "unlockStage": {"0101": [1, 2, 3]}} + raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [raw["monsters"][0]["id"]]}] + raw["taskStepValue"] = 0 + engine.snapshot = Snapshot(deepcopy(raw)) + engine.game_data = ProgressionData({ + "task_info": {"100": {"type": 1, "name": "离线任务", "steps": [ + {"statusType": "passStage", "statusValue": {"stage": "0101", "level": 1}}]}}, + "game_setting": {"cityInfo": {"1": {"name": "离线城市"}}}, + "stage_info": {"0101": {"city": 1, "cost": {"ti": 6}, "level": { + str(n): {"cost": 0, "battle": {"fixture": True}} for n in (1, 2, 3)}}}}) + runtime = ExperimentalRuntime() + original = runtime._run + if timed_out: + runtime.run.return_value = {"outcome": "timeout", "execution_mode": "experimental", + "execution_status": "timed_out", "terminal_reason": "worker_wall_clock_limit"} + runtime.run.side_effect = None + else: + runtime.run.side_effect = lambda request, cancel_event: original(request, cancel_event=cancel_event) | { + "requires_realtime_wait": True, "model_elapsed_ms": 10000} + engine._battle_runtimes["experimental"] = runtime + engine.battles.request_builder = None + config = self.manager.get_config(identifier) + config["config"]["progression_policy"].update(enabled=True, battle_mode="experimental", reserve_ti=0) + self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"]) + worker.schedule.next_poll = 0 + return runtime + + def tick(self, identifier, worker): + return self.job(identifier, worker.enqueue("__tick")) + + def paths(self, start=0): + return ["/".join(url.rsplit("/", 2)[-2:]) for _, url, _ in fixtures.FakeClient.calls[start:]] + + def interrupted_clock(self): + identifier, worker = self.connected() + runtime = self.battle(identifier, worker) + entered = threading.Event() + original = worker.engine.battles.wait_for_battle_clock + + def computed_wait(record, request, result, data, started, cancel): + wait = cancel.wait + + def clock_wait(timeout): + entered.set() + return wait(timeout) + + with patch.object(cancel, "wait", side_effect=clock_wait): + return original(record, request, result, data, started, cancel) + + with patch.object(worker.engine.battles, "wait_for_battle_clock", side_effect=computed_wait): + tick = worker.enqueue("__tick") + self.assertTrue(entered.wait(3), "Offline battle never entered the computed clock wait") + config = self.manager.get_config(identifier) + config["config"]["policy"]["keep_money"] += 1 + changed = self.manager.set_config(identifier, config["config"], config["revision"]) + self.job(identifier, tick) + self.job(identifier, changed["job"]) + record = worker.engine.battle_journal.pending(worker.engine.snapshot) + self.assertTrue(worker.engine.battles.resumable_task_clock(record), record) + self.assertTrue(worker.engine._progression_cancel.is_set()) + return identifier, worker, runtime, record + + def ready(self, worker): + journal = worker.engine.battle_journal + record = journal.pending(worker.engine.snapshot) + journal.update(record, record["phase"], battle_ready_at=1) + worker.engine.last_pending_check = time.monotonic() - 121 + worker.schedule.next_poll = math.inf + + def test_config_cancelled_computed_clock_resumes_on_reconcile_without_new_start(self): + identifier, worker, runtime, record = self.interrupted_clock() + saved = deepcopy(record["battle_data"]) + self.ready(worker) + before = len(fixtures.FakeClient.calls) + self.assertEqual(self.tick(identifier, worker)["result"]["kind"], "reconcile") + self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot)) + writes = [path for path in self.paths(before) if path != "masterService/masterQueryDetail"] + self.assertEqual(writes, ["taskService/taskCompleteStep"]) + payload = next(payload for _, url, payload in fixtures.FakeClient.calls[before:] + if url.endswith("taskService/taskCompleteStep")) + self.assertEqual(payload["battleData"], saved) + self.assertEqual(runtime.run.call_count, 1) + self.assertEqual(self.paths().count("battleService/battleStart"), 1) + self.assertTrue(self.manager.status(identifier)["strategy_requested"]) + self.assertTrue(worker.running) + + def test_start_accepts_saved_computed_result_but_does_not_settle_inline(self): + identifier, worker, _, _ = self.interrupted_clock() + self.manager.submit(identifier, "stop") + before = len(fixtures.FakeClient.calls) + self.job(identifier, self.manager.submit(identifier, "start")) + self.assertTrue(worker.running) + self.assertFalse(worker.engine.auto) + self.assertEqual(len(fixtures.FakeClient.calls), before) + self.assertEqual(self.manager.status(identifier)["strategy_state"], "recovering") + + def test_computed_result_waits_for_deadline_and_manual_refresh_stays_read_only(self): + identifier, worker, runtime, _ = self.interrupted_clock() + journal = worker.engine.battle_journal + record = journal.pending(worker.engine.snapshot) + journal.update(record, record["phase"], battle_ready_at=time.time() + 3600) + worker.engine.last_pending_check = time.monotonic() - 121 + worker.schedule.next_poll = math.inf + before = len(fixtures.FakeClient.calls) + self.tick(identifier, worker) + self.job(identifier, self.manager.submit(identifier, "refresh")) + self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before))) + self.assertIsNotNone(journal.pending(worker.engine.snapshot)) + self.assertEqual(runtime.run.call_count, 1) + self.assertTrue(worker.running) + self.assertFalse(worker.engine.auto) + self.assertEqual(self.manager.status(identifier)["strategy_state"], "recovering") + + def test_lost_resumed_settlement_reply_becomes_query_only_without_replay(self): + identifier, worker, runtime, _ = self.interrupted_clock() + self.ready(worker) + post = worker.engine.client.http.post + attempted = [] + + def lost_reply(url, *args, **kwargs): + if url.endswith("taskService/taskCompleteStep"): + attempted.append(url) + raise requests.ReadTimeout("offline lost settlement reply") + return post(url, *args, **kwargs) + + with patch.object(worker.engine.client.http, "post", side_effect=lost_reply): + self.job(identifier, worker.enqueue("__tick"), status="failed") + record = worker.engine.battle_journal.pending(worker.engine.snapshot) + self.assertTrue(record["settlement_dispatched"]) + self.assertFalse(worker.engine.battles.resumable_task_clock(record)) + for _ in range(3): + self.now += 121 + worker.engine.last_heartbeat = self.now + worker.engine.last_pending_check = time.monotonic() - 121 + self.tick(identifier, worker) + self.assertEqual(len(attempted), 1) + self.assertEqual(runtime.run.call_count, 1) + self.assertEqual(self.paths().count("battleService/battleStart"), 1) + self.assertFalse(worker.running) + self.assertTrue(worker.strategy_requested) + + def test_manual_stop_keeps_computed_result_unsent_through_config_and_restart(self): + identifier, worker, _, _ = self.interrupted_clock() + self.manager.submit(identifier, "stop") + self.ready(worker) + journal_path = worker.engine.battle_journal.path + evidence = journal_path.read_bytes() + config = self.manager.get_config(identifier) + config["config"]["policy"]["keep_money"] += 1 + self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"]) + before = len(fixtures.FakeClient.calls) + self.tick(identifier, worker) + self.assertEqual(journal_path.read_bytes(), evidence) + self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before))) + self.assertTrue(self.manager.status(identifier)["manual_stop"]) + self.manager.close() + self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin) + self.addCleanup(self.manager.close) + self.idle(identifier) + self.assertTrue(self.manager.status(identifier)["manual_stop"]) + self.assertEqual(journal_path.read_bytes(), evidence) + + def test_stop_racing_authorized_reconcile_cancels_settlement_before_dispatch(self): + identifier, worker, _, _ = self.interrupted_clock() + self.ready(worker) + entered, release = threading.Event(), threading.Event() + poll = worker.engine.poll + journal_path = worker.engine.battle_journal.path + evidence = journal_path.read_bytes() + + def held_poll(**kwargs): + self.assertFalse(worker.engine.auto) + self.assertIs(kwargs.get("resume_pending"), True) + entered.set() + self.assertTrue(release.wait(3)) + return poll(**kwargs) + + before = len(fixtures.FakeClient.calls) + with patch.object(worker.engine, "poll", side_effect=held_poll): + tick = worker.enqueue("__tick") + try: + self.assertTrue(entered.wait(3), self.manager.job(identifier, tick["id"])) + self.manager.submit(identifier, "stop") + finally: + release.set() + self.job(identifier, tick, status="cancelled") + self.assertEqual(len(fixtures.FakeClient.calls), before) + self.assertEqual(journal_path.read_bytes(), evidence) + self.assertFalse(worker.running) + self.assertTrue(self.manager.status(identifier)["manual_stop"]) + + def test_runtime_recovery_timeout_stays_blocked_after_single_local_retry(self): + identifier, worker = self.connected() + runtime = self.battle(identifier, worker, timed_out=True) + self.tick(identifier, worker) + record = worker.engine.battle_journal.pending(worker.engine.snapshot) + self.assertEqual(record["execution_status"], "timed_out") + self.assertFalse(worker.engine.battles.resumable_task_clock(record)) + self.assertNotIn("battle_data", record) + self.assertTrue(worker.engine.pending_battle_recovery()["resumable"]) + self.job(identifier, self.manager.submit(identifier, "start")) + worker.engine.last_pending_check = time.monotonic() - 121 + worker.schedule.next_poll = math.inf + self.tick(identifier, worker) + record = worker.engine.battle_journal.pending(worker.engine.snapshot) + self.assertEqual(record["runtime_recovery_attempts"], 1) + self.assertFalse(worker.engine.pending_battle_recovery()["resumable"]) + evidence = worker.engine.battle_journal.path.read_bytes() + before = len(fixtures.FakeClient.calls) + self.job(identifier, self.manager.submit(identifier, "start"), status="failed") + for _ in range(3): + self.now += 121 + worker.engine.last_heartbeat = self.now + worker.engine.last_pending_check = time.monotonic() - 121 + self.tick(identifier, worker) + self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before))) + self.assertEqual(worker.engine.battle_journal.path.read_bytes(), evidence) + self.assertEqual(runtime.run.call_count, 2) + self.assertEqual(self.paths().count("battleService/battleStart"), 1) + state = self.manager.status(identifier) + self.assertFalse(state["running"]) + self.assertTrue(state["strategy_requested"]) + self.assertFalse(state["manual_stop"]) + self.assertIn("本地战斗计算超时", state["strategy_message"]) + self.assertIn("尚未提交结算", state["strategy_message"]) + + def test_stage_farming_timeout_reports_its_operation_without_promising_resolution(self): + identifier, worker = self.connected() + fixtures.ServiceTests.enable(self, identifier) + self.job(identifier, self.manager.submit(identifier, "start")) + journal = worker.engine.battle_journal + record = journal.begin(worker.engine.snapshot, {"kind": "stage_battle", "stage_id": "0102", + "difficulty": 1, "path": "stageService/stageStart", "task_id": 0}) + journal.update(record, "unknown", start_response={"resCode": 0, "triggerEvent": False, "stageEvent": None}, + execution_status="timed_out", terminal_reason="worker_wall_clock_limit", + message="战斗已取消、超时或结果不确定,等待核对") + self.tick(identifier, worker) + state = self.manager.status(identifier) + self.assertTrue(state["connected"]) + self.assertFalse(state["running"]) + self.assertIn("0102", state["strategy_message"]) + self.assertIn("本地战斗计算超时", state["strategy_message"]) + worker.schedule.monitor(False) + reason = worker._pending_execution_reason() + self.assertNotIn("后台继续", reason) + self.assertNotIn("自动恢复", reason) + config = self.manager.get_config(identifier) + config["config"]["policy"]["keep_money"] += 1 + self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"]) + self.assertEqual(worker.config["policy"]["keep_money"], config["config"]["policy"]["keep_money"]) + self.assertTrue(worker.strategy_requested) + intent = json.loads((worker.profile_root / "run_intent.json").read_text(encoding="utf-8")) + self.assertTrue(intent["roles"][worker.active_identity]) + + def test_config_cancellation_before_start_dispatch_replans_without_unknown_barrier(self): + identifier, worker = self.connected() + runtime = self.battle(identifier, worker, timed_out=True) + update = worker.engine.battle_journal.update + changed = [] + + def cancel_before_send(record, phase, **fields): + update(record, phase, **fields) + if phase == "start_pending": + config = self.manager.get_config(identifier) + config["config"]["policy"]["keep_money"] += 1 + changed.append(self.manager.set_config(identifier, config["config"], config["revision"])["job"]) + + with patch.object(worker.engine.battle_journal, "update", side_effect=cancel_before_send): + self.tick(identifier, worker) + self.job(identifier, changed[0]) + self.assertNotIn("battleService/battleStart", self.paths()) + self.assertFalse(worker.engine._progression_pending()) + self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot)) + self.assertIsNone(worker.engine.progression_planner.pending(worker.engine.snapshot)) + runtime.run.assert_not_called() + self.assertTrue(worker.running) + self.assertTrue(worker.strategy_requested) + worker.schedule.next_poll = 0 + self.tick(identifier, worker) + self.assertEqual(self.paths().count("battleService/battleStart"), 1) + + def test_internal_pending_pause_does_not_revoke_generation_or_persist_manual_stop(self): + identifier, worker = self.connected() + worker.schedule.next_poll = 0 + generation = worker._generation + + def paused(**kwargs): + journal = worker.engine.battle_journal + record = journal.begin(worker.engine.snapshot, {"kind": "stage_battle", "stage_id": "0102"}) + journal.update(record, "unknown", message="请求结果未知") + worker.engine.auto = False + return worker.engine.snapshot, [], "请求结果未知" + + with patch.object(worker.engine, "poll", side_effect=paused): + self.tick(identifier, worker) + self.assertEqual(worker._generation, generation) + self.assertTrue(worker.strategy_requested) + self.assertFalse(self.manager.status(identifier)["manual_stop"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/ranch_web/tests/test_status_recovery_api.py b/ranch_web/tests/test_status_recovery_api.py new file mode 100644 index 0000000..b644c01 --- /dev/null +++ b/ranch_web/tests/test_status_recovery_api.py @@ -0,0 +1,44 @@ +"""Public account summaries preserve execution intent without private recovery data.""" +import unittest + +from ranch_web.tests import test_api as fixtures + + +class RecoveryStatusApiTests(unittest.TestCase): + setUp = fixtures.ApiTests.setUp + + def test_accounts_and_status_preserve_blocked_intent_and_explicit_stop(self): + source = self.manager.accounts[self.account_id] + fields = {"strategy_requested": True, "manual_stop": False, "strategy_state": "blocked", + "strategy_message": "本地战斗计算超时,尚未提交结算", "strategy_retry_at": None} + source.update(fields, running=False, journal={"payload": "PRIVATE_RECOVERY"}) + for values in (fields, fields | {"strategy_requested": False, "manual_stop": True, + "strategy_state": "stopped", "strategy_message": "已按用户选择停止策略"}): + source.update(values) + for url in ("/api/accounts", self.url + "/status"): + with self.subTest(url=url, state=values["strategy_state"]): + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + body = response.json() + summary = body[0] if isinstance(body, list) else body + for field, expected in values.items(): + self.assertEqual(summary.get(field), expected, field) + self.assertFalse(summary["running"]) + self.assertNotIn("journal", summary) + self.assertNotIn("PRIVATE_RECOVERY", response.text) + + def test_strategy_message_uses_the_connection_error_redactor(self): + source = self.manager.accounts[self.account_id] + for message in ("本地计算失败 token=STATUS_PRIVATE C:/private/battle.json", "Traceback: STATUS_PRIVATE"): + source.update(strategy_message=message, connection_message=message) + response = self.client.get(self.url + "/status") + self.assertEqual(response.status_code, 200) + body = response.json() + self.assertIsInstance(body.get("strategy_message"), str) + self.assertEqual(body["strategy_message"], body["connection_message"]) + self.assertNotIn("STATUS_PRIVATE", response.text) + self.assertNotIn("C:/private", response.text) + + +if __name__ == "__main__": + unittest.main() diff --git a/ranch_web/views.py b/ranch_web/views.py index 25fdd10..932785a 100644 --- a/ranch_web/views.py +++ b/ranch_web/views.py @@ -463,7 +463,7 @@ STATES = {"available": "可接取", "unaccepted": "未接取", "active": "进行 STATE_ALIASES = {"active": "received", "in_progress": "received", "available": "unlocked", "unaccepted": "unlocked", "offered": "unlocked", "ready": "ready_to_reward", "completed": "finished", "complete": "finished", "claimed": "finished", "blocked": "received"} STATE_FILTERS = [("current", "当前(进行中 + 待接取 + 待领奖)"), ("received", "进行中"), ("unlocked", "待接取"), ("ready_to_reward", "待领奖"), ("finished", "已完成"), ("locked", "未解锁"), ("", "全部状态")] -OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件", "completed": "已完成", "cancelled": "已取消", "timeout": "超时", "unknown": "结果待核对"} +OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件", "completed": "已完成", "cancelled": "已取消", "abandoned": "已放弃(本地计算失败)", "timeout": "超时", "unknown": "结果待核对"} CHINA_TIME = timezone(timedelta(hours=8))