fix: recover interrupted Web battles in 2.0.10
This commit is contained in:
+12
-10
@@ -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#验证);历史版本结果不计入本版。
|
||||
|
||||
|
||||
+11
-7
@@ -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#验证),以下历史记录也不计入本版验收。
|
||||
|
||||
|
||||
@@ -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"]
|
||||
|
||||
+3
-1
@@ -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)
|
||||
|
||||
+70
-14
@@ -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:
|
||||
|
||||
@@ -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})));}
|
||||
}
|
||||
|
||||
@@ -26,7 +26,7 @@
|
||||
</div></details>
|
||||
<details class="menu"><summary accesskey="h">帮助<span class="access-key">(H)</span></summary><div class="menu-popup"><button data-command="updates">检查版本更新…</button><button data-command="debug">调试日志</button><button data-command="about">关于…</button></div></details>
|
||||
</nav>
|
||||
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.9</span></span>
|
||||
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.10</span></span>
|
||||
<span id="access-mode" class="muted"></span>
|
||||
</header>
|
||||
<div class="account-bar"><div id="account-tabs" class="account-tabs" role="tablist" aria-label="账号"></div><button id="add-account" class="compact" title="新增账号">+ 新增账号</button></div>
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
+1
-1
@@ -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))
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user