Compare commits

..
47 changed files with 3949 additions and 92 deletions

No files matched your search

+10 -5
View File
@@ -1,9 +1,14 @@
# CBB 中心库上传后校验工具
当前补丁:**[v0.2.2-beta.1](docs/releases/v0.2.2-beta.1.md)(Beta 预发布,待现场验收)**,替代 0.2.1。数据库所有权或关闭状态不确定时停止批次、保留现场;不自动移走地址文件、接管带锁设计或强杀 PCB 进程树。已修复真实试跑发现的已验证块重复 Forward Annotation 问题,以及工程文件编码、目录越界、互斥和依赖漏洞。详见 [本地验证与安全审查](docs/releases/2026-10-26-local-validation-and-audit.md)。下方日期记录描述历史版本,以本补丁说明为准。
当前补丁:**[v0.2.3-beta.1](docs/releases/v0.2.3-beta.1.md)(Beta 预发布,待现场验收)**,替代 0.2.2-beta.1。数据库所有权或关闭状态不确定时停止批次、保留现场;不自动移走地址文件、接管带锁设计或强杀 PCB 进程树。新增全库 ICDB 维护、同名 CBB 完整备份恢复弹窗及严格的原生复核流程。详见 [v0.2.3-beta.1 发布说明](docs/releases/v0.2.3-beta.1.md)。下方日期记录描述历史版本,以本补丁说明为准。
本目录是独立的 CBB 中心库上传后校验工具,不属于 Part Replacement,也不负责 CBB 工程复制或中心库上传。
针对 `The last server session ... lost the connection to the database`,修复分支增加
`ICDB_REPAIR_REQUIRED` 专项识别、共享符号库路径诊断及停止批次处理。现场原生修复步骤及实现边界见
[iCDB 旧服务器会话失联分析](docs/diagnostics/2026-10-27-icdb-lost-server-session.md)。
当前分支会在目标明确、完整备份和所有权释放证据齐全时尝试一次同版本原生 Repair;共享符号库没有 PRJ 入口时停止并要求人工处理。
## 功能边界
| 工具 | 处理对象 | 核心动作 | 结果 |
@@ -135,8 +140,8 @@ python -m cbb_refresh_verify
- **不注入鼠标或键盘输入,不切换 Windows 桌面,不改写中心库源文件。** 生产路径在本次运行创建的私有桌面内启动中心库目录绑定的 ReusableCircuit PCB,随后用 COM 完成刷新、保存和关闭;只读状态桥在结束后确认 LMC 的 READY。Library Manager 菜单派发仅作为显式诊断路径保留。`tests/test_safety.py` 会在离线测试中阻止真实输入注入 API 重新进入生产代码。
- 所有自动化都跑在本进程创建的**私有 Windows 桌面**上:用户看不到窗口,光标不会被移动。
- 弹窗只认领本次运行自己启动的进程,并在该进程的私有桌面内投递 `BM_CLICK`。数据库异常恢复提示默认选择“最后一次用户保存的数据库”;其他弹窗优先确认/继续/恢复,只有 Project Integration 进度窗(仅有 Cancel)保持不动。所有弹窗文本和实际控件 ID 都写入 `dialogs.jsonl`。
- 超时或失败时停止自动化客户端,保留可能仍在写库的原生会话并停止批次。监督器核对进程是否退出,记录 `process_exit_confirmed` 或 `process_retained`;无法确认释放时输出 `recovery-required.json`,不以强杀代替数据库安全关闭。
- 弹窗只认领本次运行的私有桌面/进程,依据已知规则投递 `BM_CLICK`。数据库恢复、会话失联和设计锁接管提示会阻断并保留现场;不会自动选择恢复或接管。未知弹窗也会阻断,Project Integration 进度窗保持观察。动作/错误弹窗和实际控件 ID 写入 `dialogs.jsonl`。
- 超时或失败时停止自动化客户端,保留可能仍在写库的原生会话并停止批次。内容检查超时也不再强杀整个进程树;监督器核对进程是否退出,记录 `process_exit_confirmed` 或 `process_retained`;无法确认释放时输出 `recovery-required.json`,不以强杀代替数据库安全关闭。已确认身份且原生调用返回的失败文档会通过 32 位助手执行 `Close(False)`,再确认进程和 iCDB 地址释放。
## 环境要求
@@ -163,7 +168,7 @@ Windows 版本判断以 Build 为准:`22000` 及以上归为 Win11,`10240–
## 批量策略
每个 CBB 独立执行并写入自己的 evidence 和结果行。缺少 PCB/PRJ、内容检查失败、刷新失败或超时只影响当前项,记录 `BLOCKED/FAIL/TIMEOUT` 后继续下一项;不会因为单项失败终止整批。只有点击“当前项完成后停止”(或执行器返回 `QUEUE_STOP`)才把后续项目标为 `SKIPPED`。
每个 CBB 独立执行并写入自己的 evidence 和结果行。可确认安全的单项失败允许继续;遇到 `ICDB_REPAIR_REQUIRED`、超时、原生会话释放未确认等情况,会停止整批并把后续项目标为 `SKIPPED`。点击“当前项完成后停止”或执行器返回 `QUEUE_STOP` 也会停止队列。
GUI 中状态为 `绿色 / Ready` 的条目不能勾选、也不会进入批量队列。
@@ -196,7 +201,7 @@ Mentor 桥耗时需在目标机器另行测量。
- `save.log`:`LICENSE_OK / SAVE_OK / IS_SAVED / POST_SAVE_SYNCHRONIZED / CLOSE_OK / QUIT_OK`;
- `result.json`:状态、中心库标志读取结果、阻断原因;
- `image-status-map.json`:按中心库路径隔离的本机动态 `image_id` 校准快照(当前格式 `schema_version=2`);旧版本或无版本缓存会自动忽略并重新校准,日志会记录当前样本、缓存样本、Ready 主 ID、未映射 ID 和逐项决策原因;
- `backup/`:仅本地盘操作前的稳定文件副本;网络盘/UNC 跳过前置递归备份(`backup_skipped`);`database/LogFiles/tmp` 等易变目录和日志文件会排除,备份超时或失败不会阻断 PCB 校验。每个 CBB 结束后默认自动删除该目录,只保留 `events.jsonl`、`dialogs.jsonl`、`save.log` 和 `result.json` 等轻量证据。
- `backup/`:仅本地盘操作前的稳定文件副本;网络盘/UNC 跳过前置递归备份(`backup_skipped`);`database/LogFiles/tmp` 等易变目录和日志文件会排除,备份超时或失败不会阻断 PCB 校验。仅在成功且确认安全后清理该目录,失败时保留已有副本及日志;它不是完整数据库回滚备份。
超时采用无进展计时:界面和批量请求默认 600 秒无进展超时;它不是整个 CBB 的固定总时限,而是连续 600 秒没有可观察进展时才终止。PCB/COM 阶段切换、Project Integration 状态变化、保存标记变化和弹窗处理都会刷新计时器;重复的状态轮询不算进展。需要更快失败时仍可在界面将单项预算调低,但 30 秒只适合已确认 PCB 启动稳定的环境。
+77
View File
@@ -0,0 +1,77 @@
# iCDB 原生手动修复与工程更新
适用:本机 Mentor EE7.9.5。菜单已从实际安装的原生程序资源核对;修复、失败诊断和修复后重新打开已在隔离工程实测。
## 先确定要处理的目标
以本轮原生日志的数据库路径为准。`ReusableBlocksLP/<CBB>/Work/database` 属于该工程;`SymbolLibs/__ReusableBlocksSymb` 属于中心库共享符号数据库。共享符号库不能靠修复无关的 CBB Work 工程替代。
操作前正常关闭使用相同库的 PCB、Library Manager、原理图/符号编辑客户端,核对原服务器会话已结束,保留包含数据库、原备份和日志的完整一致副本。以下写入先在副本上进行。
## 原生工程数据库 Repair
1. 启动本机的 iCDB Project Backup,并打开实际报错工程对应的 `.prj`。本机可用 PowerShell 命令形式如下,工程路径需替换为自己的隔离副本:
```powershell
& 'D:\Mentor\7.9.5EE\SDD_HOME\iCDB\win32\bin\iCDBProjectBackup.exe' -p 'F:\隔离副本\ReusableBlocksLP\IP101GR\Work\IP101GR.prj'
```
2. 核对窗口标题中的完整 PRJ 路径,确认它关联本轮日志中的数据库。
3. 选择 **Project → Repair**,阅读确认框后执行。原生工具会检查工程并尝试修复,事先创建当前状态备份。
4. 查看 **View → Output** 中的完整输出;必要时使用 **Backup → View operation log**。记录选择了哪份历史备份、是否恢复旧版本,以及是否明确报错。
5. 正常关闭原生修复工具,再打开原先失败的同一工程。检查原数据库错误是否消失,并执行下节同步/Verify。
前面的自动化测试调用的就是此原生 Repair 入口。手动操作可直接看到原生诊断和恢复选择,但不能保证对同样的损坏取得不同修复结果。
### 如何判断结果
| 原生结果 | 后续操作 |
| --- | --- |
| 原位检查/修复完成 | 再次打开同一目标,核对数据库加载、工程同步、保存和关闭 |
| 从某个历史备份恢复 | 核对备份日期、原理图、PCB 和约束内容版本,再决定是否使用;不能直接等同无损修复 |
| `Cannot repair the project - there is no backup of missing iCDB` | 停止反复重试;当前状态备份只保留损坏现场,寻找有效恢复源或厂商支持 |
| 仍有占用或原生操作未结束 | 先确认实际会话和操作状态,不通过强杀或删除地址/锁文件替代修复 |
文件头损坏且没有历史备份的本机实测已得到第三种结果。会话失联故障是否能够原位修复仍需按实际原生诊断单独验证。
## 能够正常打开后的手动工程更新
1. 打开当前工程的 PCB,进入 **Project Integration** 窗口。
2. 查看 Forward Annotation、CES/约束加载与同步、Back Annotation 状态。对原生允许且标记 Required 的动作逐项执行,每次执行后重新观察状态。
3. 确认所需项目达到同步状态,保存工程并正常关闭。
4. 在 Library Manager 中选中对应 Reusable Block,使用 **Verify**,再读取真实校验结果。工具中的权威状态检查可以进一步确认 `READY / raw=1`。
本机生产流程及实机日志已验证四项同步、保存、关闭和权威 Ready 状态。这些更新动作要求工程数据库能够加载;若一打开就报告 ICDB 数据库无法加载,应先处理修复/恢复。
## 检查与升级相关入口的实际用途
| 本机确认的入口 | 用途与验证边界 |
| --- | --- |
| iCDB Server Manager → Tools → Diagnostics → Check database | 数据库诊断;本轮只确认菜单存在,未在现场库执行。不能视为另一种已验证的修复方式 |
| iCDB Project Backup → Project → Create support package | 创建支持资料,供对应版本技术支持分析;本轮只确认菜单存在 |
| Library Manager → Tools → Update DxSystems Designer Cache | DxSystems Designer 缓存更新,不能据菜单名称推断它能恢复损坏的工程或共享符号数据库 |
| `conv2iCDBpi` | 本机内置帮助标明用于旧 CDB/CES 到 iCDB 的转换,`-updatepowers` 只更新已转换库的 POWER 属性;未验证为损坏库修复路线 |
| `SideFiles2iCDB` | 包装到 `sandboxfile.exe`,帮助标明从文件导入 pin package length 数据,要求已有 iCDB、snapshot、topblock;没有验证其具有通用重建能力 |
本次实际核对的 iCDB Project Backup 菜单中没有独立的“强制升级损坏数据库”入口。更新 Mentor 软件、安装补丁或正常格式迁移应根据工程创建版本、目标版本兼容说明及正式向导,在完整副本上操作;升级软件不能保证补回损坏或丢失的数据。
本机旧 CHM 帮助重定向到 InfoHub,但当前安装的完整 InfoHub 文档不齐全。上述菜单以实际二进制菜单资源为依据,转换工具用途以本机内置帮助字符串为依据;未确认的升级步骤没有作为可执行指令列出。
## 本仓库实机记录
- `docs/releases/2026-10-28-icdb-open-repair-reopen-validation.md`:实际报错 → 原生恢复 → 同一工程重新打开 PASS/READY。
- `docs/releases/2026-10-28-icdb-no-history-repair-validation.md`:没有历史备份时同类文件头损坏未能修复,保留原生 no-backup 错误文本。
若现场报错明确指向共享符号数据库,应继续核对该共享存储支持的原生恢复/重建入口和原始符号来源。目前没有已验证的共享库强制更新修复步骤。
## 工具中的“从备份恢复 CBB”弹窗
读取中心库后,点击数据库维护区的“从备份恢复 CBB…”,选择目标名称及独立备份中的同名工程 PRJ,再点击“恢复并校验”。备份必须包含完整工程目录,包括原理图 ICDB、PCB、布局数据库和相关工程文件;仅有 PRJ 或单个 `icdb.dat` 不够。
程序保留完整目标库副本,先在独立库副本中验证所选备份。验证通过后把原 Work 保留为 `Work.before-restore-*`,恢复完整 Work,再打开目标执行集成、保存、关闭和 Ready 检查。副本准备阶段会显示文件数量,运行时需等待原生操作完成再关闭弹窗。整个过程需要存放两个中心库副本及工程副本的额外磁盘空间。
恢复结果采用所选备份的工程版本。原工程、来源副本、库快照和原生日志都保留在恢复记录中。程序不会在失败后自动覆盖共享库回退,也不会把未确认结果标为成功。
此入口用于已有同名 CBB 的完整工程恢复,不删除库条目,不等同跨库原生重新导入。共享符号库自身损坏、备份引用外部工程或数据库、工程不完整、仍有活动会话时会停止;当前工程数据库需要位于完整 Work 目录中。
公开网络资料核对见 `docs/diagnostics/2026-10-28-icdb-web-recovery-research.md`,包含可读原文链接及适用范围。原生 Repair 的图文用户案例与上述菜单步骤一致;新的网络监听配置案例不能代替数据库修复。文件头损坏的无备份试验也不能代表原始会话失联故障必定不可原位修复。
@@ -0,0 +1,116 @@
# iCDB 旧服务器会话失联:分析、恢复步骤与分支改动
分支:`codex/icdb-lost-session-diagnostics`,基于 `a11eb3c`(`v0.2.2-beta.1`)。
## 错误的含义和影响范围
现场消息为:
```text
The last server session on different server machine lost the connection
to the database. Please use iCDB Project Backup 'Repair project'
functionality to fix this issue.
Machine: [200091-CBB]
Session: [2026-10-24 08.22.29-10308]
```
原生 iCDB 检测到先前服务器会话的数据库状态需要检查/修复。这不是
“当前网络连接已经恢复就可以继续”的提示,也不能仅凭它认定端口被 Windows 保留。
`Machine` 和 `Session` 是故障记录中的原服务器、会话标识,不能当作当前进程 PID。
用户贴出的路径包含 `5:\5ymbolLibsReusableBlockssymb`,存在文字识别/转录歧义。
本机隔离样本确实存在 `SymbolLibs\__ReusableBlocksSymb\icdb.dat`:如果现场原文
指向这个结构,问题影响的是中心库共享符号数据库,而非单个 CBB 的
`ReusableBlocksLP\<CBB>\Work\database`。必须以现场原始日志为准,不能自动把
`5:` 改成 `S:`,或根据 CBB 名称推导修复目标。
异常关闭、原服务器/网络存储断开、写库期间复制工程、跨机器访问不一致的
路径,都可能涉及此类状态。现有消息不能区分这些原因,也不能证明
“校验失败一定导致损坏”;数据库异常本身同样会导致校验失败。共享符号库
出问题时,不同失败 CBB 可能只是访问了同一个有问题的数据库。
## 现场恢复步骤
1. 停止批量校验,核对 `200091-CBB` 和其他访问同一中心库的客户端。
正常关闭占用该目标的 Library Manager、PCB、原理图/符号编辑会话,并确认
原数据库服务器的实际状态;只看本机没有 PCB 或 TCP 探测失败不足以确认独占。
2. 在会话正常关闭后保留完整、一致的工程/中心库副本。共享库问题需包括
`.lmc`、相关 `SymbolLibs` 数据库、原有 `ProjectBackup`/数据库备份和日志。
工具日常的 `backup/` 排除了 `database` 等目录,网络操作还可能跳过备份,
因而不能把它当作这次修复所需的完整回滚副本。
3. 使用现场相同 Mentor 版本的 **iCDB Project Backup**,先核对打开的工程或
备份存储确实关联报错数据库,再执行 **Project → Repair**(错误提示称为
`Repair project`)。如果目标是共享符号库,而工具无法识别对应库/存储,
应由库管理员按该版本支持的库恢复流程处理,不能改选无关的 Work PRJ。
4. 保留原生工具的修复输出及 `Project Repair` 备份,确认修复结果。
不通过删除 `sAddress.adr`、锁文件、`icdb.dat`,也不通过强杀数据库服务器
来代替 Repair。如果原生修复失败,再依据原生日志选择一致备份恢复。
5. 正常重新打开原先失败的目标,先复测一个 CBB,检查本轮原生日志、
Project Integration、Save/Close 和进程释放,再以 `IsVerifiedReuseBlock`
返回 `READY/raw=1` 确认校验成功。之后再扩大批次。
本机已确认原生入口:
```text
%SDD_HOME%\iCDB\win32\bin\iCDBProjectBackup.exe
```
只读检查其命令行帮助显示 `-p <project file>`、`-ver`、`-h`;菜单资源确认存在
`Project → Repair`。没有查到公开的直接 Repair 命令行开关,因此本分支没有
编造 `-repair` 参数,也没有自动投递写库修复命令。曾在本机既有隔离样本上
打开原生管理界面进行入口检查,未执行 Repair;本机没有用户本次故障库,
未在 `200091-CBB` 或现场网络库上执行恢复。
## 代码修复
- 在内容检查输出、实时弹窗和本轮 `PCBLogFile.txt`、`ForwardAnnotation.txt`、
`MsgBoxResponse.log`、`PartPkg.log` 中识别完整的服务器会话失联消息。
- 分类为 `ICDB_REPAIR_REQUIRED`,保留原始错误和 `Machine/Path/Session`,
区分共享符号库、Work 工程数据库及不能确定的目标;写入
`diagnostics/icdb-recovery.json` 并在失败清单显示恢复说明。
- 该错误优先于通用打开失败、JobPrefs 错误及清理失败;即使内容检查同时
输出成功文字和退出码 0,也不能变成 PASS。标记 `safe_to_continue=False`,
后续条目标记 SKIPPED,沿用现有会话、证据、网络映射保留机制。
- 将当前日志与启动前检查点比较,支持追加、截断、等长/增长重写、UTF-16
及 UTF-8;恢复识别每次最多读取两个 128 KiB 片段。不能确认日志新旧时
保留原始失败,不据旧记录推荐本轮修复。重写后保留的同一历史会话不作为
新证据;可验证的追加则允许识别同一会话再次报错。
- 通用 `Could not run server` 不再直接推断端口保留并提示重启 WinNAT。
启动前独立端口绑定探测保留原逻辑。
## 验证和边界
原分支基线:`python -m pytest -q`,383 项通过。
新增回归包括原错误、共享库身份、内容检查停止队列、多行集成日志、
日志重写及历史错误隔离、编码、证据写入失败和监督器失败摘要。
诊断修复阶段验证(后续生命周期修复见下方链接):
- 全量 Python 测试 **417 项通过**,含 34 项新增回归;仍有基线已有的
一条 pywinauto STA COM 模式提示。
- 两组 PowerShell 测试、`python -m compileall -q src tests`、
`git diff --check` 通过。
- 只读解析仓库留存的真实 TUNER_R836_A 现场日志,正确提取到机器 `EDA03`、
`S:\ReusableBlocksLP\TUNER_R836_A\Work\database` 及会话
`2025-01-21 14.44.46-2323356`。该记录仅用于解析验证,不代表本次现场故障。
- 独立代码复查发现的集成日志遗漏、通用端口建议覆盖具体原因、历史日志
重写误判、不可读/超出窗口的基线问题,均补充回归并通过复核。
本分支修复自动化的错误识别、误导性建议和失败后的继续执行风险,
现在还会在目标明确、会话完全释放且完整备份成功时,自动调用同版本原生
Project → Repair,并只在原生诊断、Project Repair 备份、目标数据库关闭等
证据全部满足时重试一次校验。共享符号库路径没有 PRJ 入口时会明确阻断,
不会猜测或改修某个 CBB 的 Work 数据库。
这次在新复制的 IP101GR 工程上完成了真实隔离验证:Repair 菜单确认、完整
备份、原生 `dbcheck`/数据库日志、`Project Repair` ZIP 校验和数据库关闭均
成功;Repair worker 退出码为 0,随后才允许重试。该验证没有接触生产库。
仍然**没有修复现场受损数据库,也没有在 `200091-CBB` 上执行恢复**。
恢复识别仅覆盖已知日志末尾的有限窗口;错误出现在窗口外、相同历史会话
在重写时被原样重报、超出基线窗口的大日志发生重写、以及现场不同日志位置/格式,
仍需结合完整原生日志确认。这些不能确认新旧的情况不会自动提升为本轮修复诊断。
用户后续确认事故版本为 r4 或更早。失败强杀根因、正常关闭修复、自动 Repair
范围和 448 项最终回归详见
[失败生命周期与恢复验证](../releases/2026-10-27-icdb-failure-lifecycle-and-recovery.md)。
@@ -0,0 +1,47 @@
# ICDB 故障修复公开网络资料核对
检索日期:2026-10-28。目标是寻找原生会话失联、无备份恢复以及中心库共享符号数据库的可核实修复步骤。
## 能够读到原文的资料
1. **《Mentor XP如何修复文件》**,CSDN 用户经验文章:
https://blog.csdn.net/qq_53931654/article/details/147240707
已获取实际正文,内容为:打开 iCDB Project Backup、指定损坏文件路径、执行 Project → Repair,并有三张操作截图。该路线与本机 EE7.9.5 实际菜单及隔离实测一致。文章没有提供无健康恢复源时的通用强制修复办法,也没有验证共享 SymbolLibs 存储的修复入口。
2. **《Xpedition 2409 Designer 无法打开 icdb 连接》**,CSDN 用户经验文章:
https://blog.csdn.net/kkisscj/article/details/144323677
已获取实际正文。作者参考 VX2.8 的 icdb_admin 文档,将工作目录下 Server 配置中 Network/Address 设置为本机监听地址,解决其连接失败。这是 2409 版本的连接配置案例,不能直接当作 EE7.9.5 的数据库损坏或旧服务器会话失联修复方法,本轮未据此修改任何网络或数据库配置。
3. **Siemens Support Center 官方入口**:
https://support.sw.siemens.com/en-US/
本环境请求返回 HTTP 403,未读取到官方知识库文章。因此没有将检索摘要、第三方说法或猜测写成官方恢复结论。可以由具备相应产品支持权限的用户在此检索 iCDB administration、Project Backup Repair 和原始失联错误文本。
## 未找到能够验证的公开方案
本轮没有找到可核实的公开说明,能够保证在缺少有效恢复源时重建已经破坏的 icdb.dat,或直接修复 `SymbolLibs/__ReusableBlocksSymb` 的跨机器会话失联。检索无结果不能证明厂商没有内部恢复方式,只能说明当前没有依据提供相应可执行指令。
已排除 DLL 修复下载广告、AI 聚合回答,以及与原始故障不同的连接配置说明。没有根据这些结果操作现场库或删除数据库/锁文件。
## 对前面试验结论的必要限定
人为清零文件头得到的是 `old, unsupported format`。在无历史备份时,该特定试验原生 Repair 报告 `Cannot repair the project - there is no backup of missing iCDB`。
用户最初讨论的是 `The last server session on different server machine lost the connection to the database`。两者不是同一种故障,不能从文件头损坏试验推出“实际会话失联没有备份就一定修不好”。后者仍应在完整副本、实际占用已释放、目标身份明确的前提下尝试同版本原生 Repair,并根据修复后再次打开的结果判断。
## 当前可执行路线
对明确属于 Work/database 的工程数据库:正常结束实际写入会话 → 保留完整工程副本 → 用原生 iCDB Project Backup 打开对应 PRJ → Project/Repair → 查看 Output 是否原位修复、选择历史备份或明确失败 → 正常重新打开同一工程 → Project Integration/保存关闭/Verify。
若错误路径属于共享 SymbolLibs 数据库,本轮未找到已验证的 PRJ 替代入口。不能把任意 CBB 的 Work PRJ 指给它。需要针对该存储使用对应版本厂商支持的恢复/重建路线。
本机静态资源复核也显示 iCDBProjectBackup 的工程选择过滤器为 `Project file (*.prj)|*.prj||`,没有据此推断它可直接接受 LMC 或共享符号库目录。
已有 r4 现场日志中还保留一条具体工程失联记录,路径为 `S:\ReusableBlocksLP\TUNER_R836_A\Work\database`、原服务器 `EDA03`。这是旧日志,不能自动等同于当前 `200091-CBB` 故障,但说明现场历史中也存在工程数据库故障,需要逐条按原生 Path 区分。
网络检索原始页面及正文摘录保存在 `diagnostics/icdb-web-research-20261028`;未随源码发布第三方完整网页。
@@ -0,0 +1,99 @@
# r4 失败后 iCDB 断库:根因修复与受控恢复
分支:`codex/icdb-lost-session-diagnostics`。用户确认现场事故使用 r4 或更早版本。
## 工具侧根因
在 r4(`11a2b2e`)中,单项校验失败和监督器超时都会进入强制进程树清理:
- `DesktopWorker` 设置 `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`,`kill()` 调用
`TerminateJobObject`,回退路径是 `taskkill /T /F`。
- `cleanup_verify_processes()` 对目标 PCB 执行同样的强制进程树终止。
- `prepare_icdb_address()` 会在 TCP 探测失败后移走地址文件。连通性失败
不能证明服务器已安全退出;移走地址也不能修复数据库中未完成的会话状态。
这条失败收尾路径能连带杀死 PCB 启动的 iCDB 服务器,打断数据库事务或关闭过程,
留下 dirty session。下次由其他机器打开时,iCDB 拒绝继续并要求 Repair,
与用户描述的“未校验成功后才出现失联消息”吻合。现有代码足以确认该缺陷,
但没有 200091-CBB 本次完整进程/数据库日志,不能确定具体中断的是哪次事务。
`a11eb3c` 已修掉主要 PCB 强杀路径;继续检查发现内容检查超时仍保留
`taskkill /T /F`,以及失败文档只保留在隐藏桌面、没有正常关闭尝试。
这些遗漏在本分支继续修复,不能让用户继续用 r4 的收尾逻辑测试。
## 本轮行为
- 内容检查超时保留 importer 及原生子进程,使用文件承接输出,防止父进程
退出造成管道阻塞/断管;记录 PID、命令和退出状态并停止后续队列。
- 校验超时/监督器丢失改为协作取消。阻塞中的原生调用先返回,再在操作边界
停止后续动作;不终止正在 Save 的助手。
- 原生调用返回且已确认身份的失败文档,由 x86 助手核对 PRJ 和 PCB 名称后
执行 `Close(False)`,释放引用后正常 Quit。若另一个文档仍活动则保留应用;
慢 Close 同样保留助手,不用强杀代替完成。
- 写入前和成功前同时核对 Work、PCB 及中心库
`SymbolLibs/__ReusableBlocksSymb` 的地址所有权。隐藏 Library Manager
在失败 PCB 正常关闭后也请求正常关闭;所有权未知时继续停止批次。
- 只读状态桥先关闭标准输入并等待 EOF 清理,避免正常退出也被立即终止。
## 自动 Repair 的范围
只有本轮明确的 `ICDB_REPAIR_REQUIRED`、完整会话身份、可映射到当前
Work/PCB PRJ 的数据库,才进入一次原生恢复尝试。TIMEOUT、未释放的
importer/PCB/Library Manager/助手、外部目标及路径歧义都不会启动 Repair。
恢复前通过 Windows 独占文件访问确认目标 `icdb.dat` 没有仍打开的客户端,
完整复制工程全部文件(包括数据库、锁、原备份、日志),逐项校验副本及
源文件集合。该副本与平日排除数据库的轻量 evidence 备份不同。
Repair worker 绑定监督进程和确切私有桌面。它从安装程序资源解析
`Project → Repair`,核对原生窗口中的完整 PRJ,只接受实际验证过的
Repair 确认文本。备份期间取消会阻止后续启动;原生 Repair 已经开始后,
超时或监督器丢失不会强制终止它。
恢复成功需要本次原生 PID 的诊断完成、数据库关闭、完整 `Project Repair`
ZIP、原生进程正常退出及地址释放。满足后只重试一次完整校验,仍以
`IsVerifiedReuseBlock READY/raw=1` 为最终成功条件。原错误、原 evidence
和恢复结果保存在 `recovery_attempts`,完整修复备份保留。
**共享符号库边界:** 本机同版本 Project Backup 直接打开符号数据库目录时,
明确拒绝并要求 `.prj`。因此对 `SymbolLibs/__ReusableBlocksSymb` 的已损坏
数据库,本分支会报告 `SHARED_DATABASE_REPAIR_UNSUPPORTED`,不会改修一个
不相关的 Work 工程,也不会删地址/锁或猜测私有 ABI。正常关闭和共享所有权
检查用于防止再制造这类问题;已有共享库损坏仍需匹配该库的原生恢复入口。
## 实际验证
以下写入均针对本轮新副本,未修复或改动现场 200091-CBB 数据:
- 真实 Windows 无害 importer/子进程试验:超时后均存活,后续队列停止。
- x86 cscript 测试:核对身份、失败关闭用 `Close(False)`、不保存错误结果、
另有活动文档时不 Quit、Save 返回后响应取消。
- 新 IP101GR 副本主动注入空闲时的同步失败:输出 `FAILURE_CLOSE_OK`、
`FAILURE_QUIT_OK`,随后确认 PCB 进程退出;失败结果保持 FAIL。
- 同一隔离库随后正常校验:PASS/GREEN,Save/Close/退出和
`READY (IsVerifiedReuseBlock, raw=1)` 均确认。
- 原生 Repair 模块真实执行:完整备份、Repair 确认、本 PID 的 dbcheck/
数据库关闭日志、Project Repair ZIP 校验齐全,最终 `REPAIRED`、退出码 0。
这验证了原生恢复链,不代表复现并恢复了现场同一个 dirty session。
- 完整自动恢复链:向隔离副本的首次校验注入合成失联错误,之后实际执行
正常关闭、完整备份和原生 Repair,再启动第二次真实校验,最终
PASS/GREEN、`safe_to_continue=True`。只启动两次校验 worker、一次 Repair;
原错误及 evidence 保留。没有故意破坏数据库,也没有恢复现场损坏库。
- PyInstaller 目录包构建和冻结 GUI 生命周期冒烟通过;直接使用生成的 EXE
在另一个独立工程副本上运行 Repair worker,最终 `REPAIRED`、退出码 0。
因此原生修复入口也已验证能在冻结包内工作。
- 原样本 21,011 个文件在上述试验前后 SHA-256 内容指纹一致。
- 最终 Python 全量回归 **448 项通过**(含前次 417 项基线);仍有基线已有的
一条 pywinauto STA COM 模式提示。两组 PowerShell 测试、编译和 Git 空白检查通过。
- 独立复查指出的未释放 importer 进入 Repair、备份期间取消、修复 worker
父进程丢失、共享 COM 应用退出等边界均已修正,并补充对应回归。
本地原始证据位于 `diagnostics/icdb-auto-recovery-20261027`,不随包发布。
## 分支试用包
本地 `CbbRefreshVerify-icdb-recovery-20261027.zip` 包含完整目录程序、试用说明、
本报告和逐文件 SHA-256 构建清单;压缩包旁另有 SHA-256 文件。源码构建提交为
`9cd4968`,版本号仍为 `0.2.2b1`,这是分支修复试用包,不是新正式版本。
解压整个目录后启动 `CbbRefreshVerify.exe`,必须保留 `_internal`。尚未部署到
200091-CBB,也未推送远端;现场已有共享库损坏仍受上述原生入口限制。
@@ -0,0 +1,47 @@
# CBB 完整工程备份恢复弹窗实机验证
分支:`codex/icdb-global-repair`。本轮新增“从备份恢复 CBB…”入口,弹窗仅包含目标 CBB、备份工程 PRJ、“恢复并校验”和“关闭”。
## 已验证的行为
现有同名 CBB 的完整工程备份先在独立中心库副本中验证;只有原生流程、权威 Ready 和会话释放全部通过,才保留原 Work 并恢复目标,再对目标实际打开、保存、关闭和读取状态。全程保留完整库回退副本、来源副本、原工程和日志。
## 真实损坏与恢复
测试材料位于 `diagnostics/icdb-backup-dialog-live-20261028`,只改动新建的隔离副本,CBB 为 `IP101GR`。
1. 从健康库复制目标,移除目标 Work 中的 `ProjectBackup`、`cdbback` 历史目录,清零 `Work/database/icdb.dat` 的前 64 字节。
2. 实际打开该目标,得到 `MENTOR_DATABASE_LOAD_FAILED`。原生日志明确为 `Database cannot be loaded ... Please use iCDB Project Backup 'Repair project' ... icdb.dat ... old, unsupported format`。正常关闭未加载工程的原生窗口后继续。
3. 在真实主窗口点击“从备份恢复 CBB…”,选择独立健康来源 `verify-library/ReusableBlocksLP/IP101GR/Work/IP101GR.prj`,再点击“恢复并校验”;没有替换 reader、recoverer 或 verifier。
4. 验证库位于 `C:\Users\ABS_Windows\.cbb-restore\b963898c4e91`。17:47:59 原生 COM 确认该副本工程身份;四项集成状态均为 InSynch。17:48:19 已确认原生退出,结果 `PASS / GREEN / READY (raw=1)`。
5. 保留旧工程为 `Work.before-restore-b963898c4e91`,安装验证过的完整 Work。
6. 17:50:54 原生 COM 确认重新打开的正是最初失败的目标路径。四项集成状态均为 InSynch,Save、IsSaved、Close、Quit 标记完整;17:51:24 确认退出。目标结果 `PASS / GREEN / READY (raw=1)`,`safe_to_continue=True`,原来的数据库加载错误消失。
`comparison.json` 的七项检查全部通过:真实打开失败、备份副本验证成功、相同目标重新打开、最终 Ready、损坏 Work 保留、原始源库未变、原生加载错误消失。原始源库 21,029 个文件的 SHA-256 对照一致。
主要证据:
- `open-before.json`、`open-before-PCBLogFile.txt`。
- `data/evidence/backup-restore-b963898c4e91/recovery-result.json`。
- `source-verify/verify-bec9008be868`、`target-verify/verify-22808a7f330a` 下的结果、事件和原生日志。
- `dialog-before.png`、`dialog-after.png`、`window-after.png`、`ui-state.json`、`comparison.json`。
## 停止条件和兼容修正
实际观察到“工程已打开保存、但最终仍为 PENDING”的失败情形,恢复流程在替换目标前停止;损坏目标字节保持原样。短路径复核取得 Ready 后,生产实现采用真正较短的用户目录,避免深层证据目录及 MSIX 对 AppData 的重定向。
原生 PCB 工程允许多个配置段具有 `CentralLibrary` 引用,所有需要变更的引用均对齐。语义已指向目标库的引用保留原字节及时间。绝对工程/数据库引用、目录链接、不完整来源、来源/目标内容变化、未释放会话均会阻止安装。原生目标操作保留映射盘/别名;文件快照和 Work 替换使用实际路径。
## 回归与交付
- `python -m pytest -q`:471 passed,1 个既有 pywinauto STA 提示。
- 16 项新增恢复和弹窗测试覆盖输入校验、来源失败、最终失败、来源保护、并行快照、junction 拒绝、目标别名、等价引用、界面响应及异常终态。
- PyInstaller 构建及冻结程序启动/退出 smoke 检查通过。
- `frozen-modules.json` 确认恢复模块、弹窗、主窗和 Mentor 适配模块的冻结代码与当前源代码一致。
- 程序:`dist-icdb-backup-dialog-20261028/CbbRefreshVerify-Background/CbbRefreshVerify.exe`。
复现脚本:`tools/validate_backup_recovery_dialog.py`,依次执行 `setup`、`open-before`、`restore`、`compare`。`setup` 仅创建全新的测试目录;再次试验前保留现有证据,并将脚本中的输出 `root` 改为另一个全新诊断目录。
## 范围
本功能恢复已有同名 CBB 的完整工程,依赖目标库中已有的依赖数据,不删除库条目,不等同原生跨库重新导入或共享符号库重建。测试复现的是数据库文件头损坏;没有复现原始不同服务器会话丢失的问题,不能据此承诺所有 ICDB 故障均可恢复。恢复内容采用用户选择的备份版本。
@@ -0,0 +1,46 @@
# 全库 ICDB 检查与修复按钮实机验证
日期:2026-10-28。分支:`codex/icdb-global-repair`。
## 行为与界面
独立“数据库维护”面板提供“全库 ICDB 检查与修复”按钮。确认框展示当前库、可用项目数、Ready 项数和缺文件跳过数,说明操作会重新校验并保存工程。队列包含 Ready 项,串行执行,显示当前检查/备份/原生修复阶段及已处理数量;可请求当前项结束后停止。
复用现有本轮失联证据、目标身份、独占访问、完整备份、原生 Repair 和单次重试约束。共享符号库自动修复仍不支持。Ready 项同样预检工程文件,缺少 Work/PRJ/PCB 时跳过。失败后清除本次无法确认的绿色状态。
结果分别报告校验通过、失败/受阻、队列未执行、原生修复完成、恢复旧备份待复核和修复未确认。额外 JSON 报告保留每项原始错误、恢复尝试和证据路径。
## 实机按钮路径
使用 Windows 本机 Qt 界面,通过 QTest 点击实际按钮和实际确认框,未替换 reader/verifier,未注入合成失联错误。测试工具为 `tools/validate_icdb_button.py`。
输入是新复制的本地隔离库,包含一个实际可校验的 IP101GR(读取时 Ready)。按钮仍运行此项目,最终:
- `PASS`、`safe_to_continue=True`。
- `READY (IsVerifiedReuseBlock, raw=1)`。
- 四项集成状态 InSynch;Save/IsSaved/Close 成功,PCB 正常退出。
- 本轮正常校验不需要原生 Repair,恢复尝试数为 0。
- 测试源库 21,029 个文件逐项 SHA-256 比对一致。
原始证据:`diagnostics/icdb-button-live-20261028/outcome.json`、`data/evidence/verify-ebe807433b4f/result.json`、`data/reports/icdb-20261028-120446-f28be8.json`。`loaded.png`、`confirmation.png`、`finished.png` 是实际运行截图;`final-layout.png` 使用该次真实结果回放验证最后的两行摘要布局。
## 真实损坏试验及修复边界
`tools/probe_icdb_corruption.py` 在另一个新隔离工程副本中将 `database/icdb.dat` 前 64 字节清零,然后直接调用生产原生修复 worker。完整备份、原生 Repair 备份均保留。该试验直接验证原生修复 worker,不代表按钮已经复现现场跨机器失联故障的自动恢复链。
原生工具在本机从工程内的 `2026-09-18 10.44.14 - consDefUpgr.zip` 恢复数据库,输出 dbrestore DONE 和 Diagnostic FINISH。程序识别这属于已有备份恢复,返回 `RESTORED_REVIEW_REQUIRED`,正常关闭空闲原生窗口并确认进程退出,未将其提升为 `REPAIRED`,未自动重试校验。恢复版本和工程内容仍需复核,不能据此宣称无损修复。
原始证据:`diagnostics/icdb-corruption-probe-20261028-r2/damage.json`、`repair/repair-result.json`、`repair/complete-backup/backup-manifest.json`。原生测试 PID 29096 已退出;前次保留 PID 18452 也已核对空闲状态并请求正常关闭。
## 验证与试用程序
- 全量 Python 回归 455 项通过;一条既有 pywinauto STA COM 提示。最终摘要布局另跑 21 项界面回归通过。
- 独立代码审查提出 Ready 缺文件预检遗漏,已补充先失败后通过的回归并修正。
- 首次回归与实机校验并发,12 项被真实全局互斥锁拦住;实机结束后完整重跑得到上述 455 项通过,未改弱互斥保护。
- PyInstaller 目录程序位于 `dist-icdb-button-20261028/CbbRefreshVerify-Background/CbbRefreshVerify.exe`。已核对冻结包内四个变更模块与最终源码语义一致。
- 最终冻结程序启动冒烟完成,记录 `gui_smoke_window_created` 和 `application_clean_shutdown exit_code=0`;日志在 `diagnostics/icdb-button-live-20261028/frozen-smoke-final/logs/application.log`。
- 未部署或修改现场库。实机正常路径仅覆盖这个隔离库中的一个有效 CBB;共享符号库原生修复入口尚未支持。
## 后续实际打开对照验证
用户要求确认修复前工程实际报错、修复后再次打开。后续已在新隔离库完成:原生打开报告 ICDB 数据库格式不支持,原生恢复后同一工程重新打开并达到 PASS/READY raw=1。恢复使用旧备份,仍保留内容版本复核要求;没有复现现场跨机器失联报错。完整范围和前后证据见 `2026-10-28-icdb-open-repair-reopen-validation.md`。
@@ -0,0 +1,41 @@
# ICDB 无历史备份修复试验
日期:2026-10-28。分支:`codex/icdb-global-repair`。
## 实机结论
针对本次清零 `icdb.dat` 前 64 字节产生的文件头/格式损坏,没有可用历史备份时,EE7.9.5 原生 Repair 未能修复。此结论限于该故障类型,不应推断所有会话状态或一致性故障都必须使用历史备份。
原生 Project Backup 输出:
> The iCDB database is corrupted.
> There is no backup of iCDB.
> Repair project error [Cannot repair the project - there is no backup of missing iCDB].
> The project is probably in inconsistent state. Please restore the project from one of previous backups.
修复尝试前后数据库 SHA-256 相同:`b3a026b0bc9f695444220008527cbc3c5c2e53a7ce4eaf7bbccac297158b7e20`。本轮新建的 Project Repair ZIP 保存的是已经损坏的状态,不能充当损坏前的健康恢复源。原生输出也区分了“修复前状态备份”与缺失的有效 iCDB 备份。
## 测试范围与证据
使用新的隔离工程副本,复制时排除所有 ProjectBackup 和 cdbback 目录,只复制使用相对路径 `./backups` 的配置,启动前断言工程树内没有 ZIP 历史档案。完整损坏副本另行保留,再调用生产原生修复 worker,没有删除源工程的任何备份。
程序未取得修复成功证据,结果为 `UNCONFIRMED`,没有自动重新校验。读取原生 Output 面板确认明确的 no-backup 终止错误、窗口空闲且地址释放后,正常关闭测试进程 PID 18092。
原始证据目录:`diagnostics/icdb-no-history-probe-20261028`。
- `damage.json`:破坏方式和无历史备份测试标记。
- `native-output.json`:从原生 RichEdit Output 控件读取的完整错误文本。
- `probe-result.json`:结果及修复前后字节一致的 SHA-256 证据。
- `repair/complete-backup`:完整损坏状态保留副本。
可复现命令(需先设置 `PYTHONPATH=src`):
`python tools/probe_icdb_corruption.py --without-history --output icdb-no-history-probe-20261028`
输出目录必须新建,已有目录会拒绝覆盖。
## 没有历史备份时的处理
首先正常关闭写入方并完整保留当前损坏工程,在副本上使用匹配版本的原生工具检查。仅会话状态或部分一致性问题是否能够原位修复,应按实际诊断分别验证。
当原生工具像本次一样明确报告缺少有效恢复源,应寻找服务器快照、文件历史版本、其他机器的完整工程副本或厂商支持的恢复方式。若没有任何有效恢复源且原生修复失败,只能评估数据恢复或由仍完整的设计资料重建,不能承诺恢复全部原始内容。
@@ -0,0 +1,61 @@
# ICDB 实际打开报错、修复与再次打开对照验证
日期:2026-10-28。分支:`codex/icdb-global-repair`。环境:Windows 11,Mentor EE7.9.5。
## 结论
在新的本地隔离库中,实际打开 IP101GR 工程确认原生 ICDB 数据库加载失败;调用原生 Repair 后,再次打开同一工程,数据库报错消失,完整校验、保存、关闭和权威 Ready 确认均成功。本次补齐了前次试验缺少的修复前打开失败与修复后再次打开对照。
本次错误由清零隔离副本 `Work/database/icdb.dat` 前 64 字节产生,实际原生错误为数据库格式不支持。没有复现现场的 `last server session on different server machine lost the connection` 错误,不能将两种故障混为一谈。
## 修复前实际打开
使用生产 ReusableCircuit PCB 打开与校验流程,设置 `auto_repair=False`,没有注入合成错误或替换原生结果。工程为:
`diagnostics/icdb-open-repair-reopen-20261028/library/ReusableBlocksLP/IP101GR/Work/IP101GR.prj`
2026-10-28 13:49:14,PCB 原生弹窗报告:
> Problem encountered while opening one of the database files. See PCBLogFile.txt for details. Loading of the job has failed.
原生 PCBLogFile.txt 明确报告并指出被破坏的确切路径:
> Database cannot be loaded and the server cannot be started, the project will not be opened. Please use iCDB Project Backup 'Repair project' functionality to fix this issue. (Database [...]\Work\database\icdb.dat in old, unsupported format)
结果为 `FAIL / MENTOR_DATABASE_LOAD_FAILED`,未进入自动修复。原生失败会话经核对启动命令、空工程窗口和数据库地址释放后,请求正常关闭;没有强杀原生进程或删除地址文件。
证据目录 `diagnostics/icdb-open-repair-reopen-20261028` 中保留:
- `open-before.json` 与 `open-before-PCBLogFile.txt`。
- `open-before/verify-95ae0baa92f3/dialogs.jsonl` 中的原生弹窗及控件文本。
- `open-before/verify-95ae0baa92f3/diagnostics` 中的原生日志副本。
## 原生修复
先保留完整一致工程备份,再对同一 `IP101GR.prj` 和同一 `Work/database` 调用生产原生修复 worker。原生工具从工程内 `2026-09-18 10.44.14 - consDefUpgr.zip` 恢复数据库,完成 dbrestore 和 Diagnostic FINISH,并正常退出。
生产修复结果仍为 `RESTORED_REVIEW_REQUIRED`。本次依据用户明确要求,在隔离副本上手动继续再次打开验证;没有放宽旧备份恢复后的生产自动重试限制,也不宣称无损修复。
证据:`repair/repair-result.json`、`repair/repair-events.jsonl`、`repair/complete-backup/backup-manifest.json`、`repair-summary.json`。
## 修复后再次打开
再次使用生产校验流程和相同工程路径,保持 `auto_repair=False`。
- 13:54:45,原生 COM 确认工程身份:相同 `IP101GR.prj` 和 `IP101GR.pcb`;四项集成状态均为 InSynch。
- 保存、IsSaved、保存后同步检查、Close 和 Quit 均完成。
- 13:55:19,确认 PCB 进程退出;数据库地址释放。
- 最终 `PASS`、`safe_to_continue=True`、`READY (IsVerifiedReuseBlock, raw=1)`。
- 修复后的本轮 PCBLogFile.txt 不再出现修复前的 `Database cannot be loaded` 错误。
证据:`open-after.json`、`open-after-PCBLogFile.txt`、`open-after/verify-6b9874897377/events.jsonl`、`open-after/verify-6b9874897377/save.log`。
## 对照检查与可复现步骤
`comparison.json` 的七项检查全部为 true:同一工程、同一数据库、修复前原生 ICDB 报错成立、修复后工程身份匹配、原错误消失、完整校验通过、源工程数据库 SHA-256 不变。
测试脚本:`tools/validate_icdb_open_repair_reopen.py`。设置 `PYTHONPATH=src` 后,按顺序执行 `setup`、`open-before`、`repair`、`open-after`、`compare`。每一步需检查上一步的真实原生日志;失败打开留下的空闲原生窗口应核对目标后正常关闭,不能强杀或删锁。
本次按阶段直接调用生产原生修复 worker,未通过新按钮自动触发格式损坏修复。当前按钮的自动 Repair 仍以受支持的本轮失联诊断为入口。本次证明的是原生恢复确实消除了这个实际打开时的 ICDB 格式损坏报错;已有备份恢复后的工程内容版本仍需复核。
后续又用不含历史备份的副本测试相同文件头损坏,原生工具明确报告没有可用 iCDB 备份,无法修复,数据库字节未变。见 `2026-10-28-icdb-no-history-repair-validation.md`。
+27
View File
@@ -0,0 +1,27 @@
# CBB Verify v0.2.3-beta.1
**Beta 预发布,供隔离副本和小范围现场验收使用。**
版本标识:`0.2.3b1`;Git 标签:`v0.2.3-beta.1`。
## 本版内容
- 增加“全库 ICDB 检查与修复”维护入口,包含 Ready 项、串行进度、结果统计和维护报告。
- 增加“从备份恢复 CBB…”弹窗:选择同名 CBB 的完整工程 `.prj` 备份,先在独立短路径副本中验证,再保留原 Work、恢复目标并重新打开校验。
- 恢复只有在原生打开、集成、保存关闭、进程释放和权威 `READY / raw=1` 全部满足时才报告成功;失败保留回退副本并清除旧绿色状态。
- 加强 ICDB 会话所有权、原生修复备份恢复状态、目录链接/外部路径检查和异常 worker 的安全处理。
- 补充真实损坏工程恢复记录、无历史备份边界说明、手动原生修复文档和自动化验证脚本。
## 验证记录
- `python -m pytest -q`:471 passed,1 条既有 pywinauto STA 提示。
- `tests/CBBRefresh.Core.Tests.ps1`:通过。
- `tests/ContentCheck.ExitCode.Tests.ps1`:通过。
- EE7.9.5 隔离实测:破坏 ICDB 文件头后实际打开失败;通过恢复弹窗恢复同名完整备份;同一目标重新打开达到 `PASS / GREEN / READY (raw=1)`。
- PyInstaller 构建和冻结程序 smoke 检查通过。
## 范围限制
恢复功能支持已有同名 CBB 的完整工程备份,不自动删除旧库条目,不实现跨库重导入或共享符号数据库重建。共享库损坏、外部路径引用、不完整备份和未释放原生会话会停止操作。恢复采用用户选择的备份版本,发布前请在隔离副本和现场版本上复核。
详细实机记录:[2026-10-28-cbb-backup-dialog-validation.md](2026-10-28-cbb-backup-dialog-validation.md)。
@@ -0,0 +1,42 @@
# iCDB failure lifecycle and recovery implementation plan
**Goal:** Prevent failed verification from aborting iCDB owners, close owned idle failed documents normally, and attempt native recovery only against a validated idle target with a complete backup.
**Context:** User confirmed the incident used r4 or earlier. r4 enables `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, calls `TerminateJobObject` and `taskkill /T /F` on failures and native owners. a11eb3c removed those PCB paths, but content-check timeout still kills a process tree. Failed worker exceptions currently release COM references without requesting normal document closure.
**Architecture:** Keep native transactions alive through timeouts. Signal cooperative cancellation to the worker; let blocking native calls return before closing a document. A separate recovery module owns target checks, backup and the official GUI repair transaction; failed or ambiguous repair remains failed. Work and central-library database ownership are checked separately.
**Tech stack:** Python 3.12, Windows process handles/private desktops, x86 cscript and Mentor EE7.9.5 native tools. Continue on `codex/icdb-lost-session-diagnostics`.
## Task 1 — Retain native owners on content timeout
- [x] Add a regression that starts a harmless importer with a harmless child, times out, and checks both survive until normal exit or test cleanup.
- [x] Add a content-timeout batch regression proving the second item does not start.
- [x] Remove tree/client termination from `_run_process` timeout; retain/drain the process in a background observer, record PID/command/release in evidence, and return TIMEOUT with `safe_to_continue=False`.
- [x] Verify targeted tests and the existing content-check tests.
## Task 2 — Normal close of failed owned sessions
- [x] Add x86 cscript harness tests for failed Save and close-only operation, checking `Close(False)`, reference release and Quit, with failure status preserved and mismatched identity untouched.
- [x] Implement an identity-checked close helper and call it only after the worker has returned from its native call and released Python references. Retain busy helpers instead of terminating them.
- [x] Add cooperative cancellation at Python/VBS native-operation boundaries; a supervisor timeout/crash must not terminate a pending native Save.
- [x] Add targeted tests for cancel before Save, cancel after a pending call returns, supervisor loss and blocked native-call retention.
- [x] Check shared `SymbolLibs/__ReusableBlocksSymb` ownership as well as Work/PCB database ownership before writing and before declaring release.
- [x] Give the status reader an EOF shutdown grace period before any fallback termination.
## Task 3 — Attempt official native recovery
- [x] Probe native UI on new isolated copies only; record accepted project/database identity, exact command, backup creation and completion signals. Do not invent CLI Repair flags or manipulate native ownership metadata.
- [x] Add recovery-policy tests: reject foreign/unresolved targets, active clients, inconsistent backups and repeat repair; preserve the original error; at most one recovery attempt.
- [x] Implement the supported native repair route with a complete backup and exact target checks. If the installed native tool cannot accept a shared symbol database, retain that explicit blocked result instead of repairing an unrelated Work project.
- [x] Retry opening/verifying only after native success and confirmed release; authoritative READY remains the success criterion.
## Validation and delivery
- [x] Run full Python and PowerShell regressions, compilation and whitespace checks, plus independent code review.
- [x] Verify a successful native run and a controlled failed integration/close on an isolated library, and source fingerprints afterward.
- [x] Record precisely which recovery target types were actually exercised and any remaining field-only limitations; commit changes on the current branch.
## Execution evidence
Completed on 2026-10-27. See `docs/releases/2026-10-27-icdb-failure-lifecycle-and-recovery.md` for 448 passing Python regressions, PowerShell and x86 harness checks, real failed-session close, real native Repair, the synthetic-error/real-repair/real-retry chain, frozen EXE Repair validation, and trial-package scope. Shared symbol databases without a supported PRJ entry remain explicitly unsupported; no field database was repaired.
@@ -0,0 +1,55 @@
# 从健康 CBB 来源恢复的增量设计
状态:同名 CBB 完整工程备份恢复弹窗已实现,并通过真实损坏打开失败 → 弹窗恢复 → 同一目标重新打开 PASS/READY 的闭环验证。471 项回归通过;原生跨库重新导入替换闭环仍未验证。
实机记录:`docs/releases/2026-10-28-cbb-backup-dialog-validation.md`。
## 本轮确定的实现范围
采用简单弹窗:目标 CBB、完整备份工程 PRJ、“恢复并校验”和“关闭”。选择的工程名和顶层块必须与目标一致,必须保留完整 Work 数据,不能仅选择单个数据库文件。
后台先保存完整目标库快照及 SHA256 清单,复制来源工程,在另一份目标库副本中恢复来源并通过原生 PCB 打开、集成、保存、关闭及权威 Ready 检查。通过后再次检查来源/目标内容及会话释放状态,保留原 Work 为同级 `Work.before-restore-*`,安装已验证的工程副本,再实际打开目标校验。只有 PASS、GREEN 和已释放的结果视为成功。失败保留回退库、来源快照、旧 Work 和原生日志,不自动覆盖共享数据库回退。
验证副本放在用户目录 `.cbb-restore/<编号>`,记录其实际路径。避开深层日志目录及 MSIX 对 AppData 的长路径重定向;本机短路径原生复核已通过 Ready 检查。目标原生操作保留映射盘/别名,文件快照和 Work 替换使用实际路径。原本已指向目标库的等价相对引用不重写,保留工程字节和日期。
该功能恢复现有条目的工程数据;不删除库条目,不宣称已完成原生跨库重新导入或共享符号库重建。原生导入探测已在新建的隔离库通过“Reusable Blocks / New Reusable Block”从 PRJ 创建 IP101GR,但替换损坏条目和依赖完整性尚未形成完整验证闭环,因此本轮不开放自动先删后导入。
真实验证脚本:`tools/validate_backup_recovery_dialog.py`,分 setup、open-before、restore、compare 四阶段。测试目标移除历史备份并破坏数据库文件头,使用独立健康来源;restore 阶段点击实际主窗口按钮及弹窗“恢复并校验”,使用生产后端。
目标:原生 Repair 无法恢复时,允许选择其他目录或库中的健康 CBB 作为恢复来源,重建目标 CBB 的可用状态,并保留完整回退材料。
## 已确认的原生行为
安装自带 `SDD_HOME/lm/win32/lib/upc_utils.tcl` 提供以下依据:
- `runReuseBlockLoader` 使用 DMS 的 `com.mentor.dms.rbloader.jar` 执行 `copyout`,下载/恢复 CBB。
- `processReuseBlockChunk` 在下载 CBB 和相关 Cell 后调用 `runReuseBlockImporter ... move`,同步 CBB 在共享 iCDB 中的符号。
- `removeReuseBlocks` 经 CleanWGLib 处理 CBB 移除;注释明确说明 Cell 和 iCDB 符号也由原生清理处理。
- `ReuseBlockImporter` 因此不能仅凭名字被当成通用完整 CBB 备份导入程序。任意本地目录/压缩包的完整原生导入方式仍需验证。
## 两种故障分开处理
1. 单个 CBB 的 Work 数据库损坏、目标中心库及共享符号库可用:可验证恢复该 CBB,并通过原生流程重新建立元数据、Cell 和符号关联。
2. `SymbolLibs/__ReusableBlocksSymb` 等共享数据库损坏:在同一损坏目标中删除或导入 CBB 都可能因无法访问共享库失败。应先恢复共享库,或评估建立健康新库并迁移 CBB 及依赖;该迁移路线尚未实测。
不将删除日志、地址文件、锁文件或修改私有数据库会话字段作为恢复方法。
## 建议操作流程
1. 选择健康来源:完整工程/可导入的 CBB 包、来源库或受支持的 DMS 版本。核对 CBB 类型、名称、分区、软件版本、来源时间及符号/Cell/零件依赖;名称相同不证明内容等价。
2. 在来源副本上验证可以打开,保留原始来源不被校验保存修改。
3. 在隔离目标副本中验证原生导入/恢复路径。目标中心库必须可访问,错误类别和数据库路径必须明确。
4. 通过原生流程替换/移除旧条目并恢复健康 CBB,确认 .lmc 元数据、CBB 工程、Cell 和共享符号关联一致。先验证是否支持原生替换;不盲目采用先删后导入,也不假定导入具备原子回退。
5. 实际打开恢复的工程,完成集成、保存、关闭和权威 Verify 状态确认。失败保留原始工程、恢复来源、原生日志和完整备份;不将失败结果改为绿色。
## 对现有按钮的建议升级
维护入口展示原生修复结果;受阻项目可选择“从健康 CBB 恢复”。启动前显示来源与目标、覆盖范围和版本差异;结果区分别报告“原位修复”“从备份恢复”“重新导入恢复”“共享库阻断”和“未确认”。
程序可以负责来源核对、隔离验证、备份、原生操作编排和复核。若本机版本只能使用 GUI 导入,先提供原生窗口及操作指引;没有可靠的原生命令/界面路径之前,不声称支持自动重新导入。
## 后续验证门槛
- 确定一个完整、可打开的来源 CBB,并在独立副本上复现目标报错。
- 记录本机原生本地导入/跨库复制/受支持 DMS 恢复的确切入口、替换策略、冲突提示和日志。
- 对照恢复前后的实际工程打开结果与依赖完整性,包含导入失败、来源版本不匹配、目标共享库不可用的停止行为。
@@ -0,0 +1,24 @@
# ICDB Global Check and Repair Implementation Plan
**Goal:** Provide a separate full-library action that checks each available CBB and invokes the existing evidence-bound iCDB recovery when appropriate.
**Architecture:** Reuse the serial verification queue, including Ready rows, and the existing backup, ownership, native repair and retry safeguards. Confirm the full-library write scope before starting; stop on unconfirmed ownership and retain existing reports and evidence. Shared symbol database repair remains unsupported.
**Tech Stack:** Python 3.12, PySide6, pytest, Windows native Mentor tools.
1. Add UI tests for confirmation, Ready-row inclusion, skipped projects, busy state and cancellation.
2. Add the button and route the full set of eligible rows through the existing queue without changing ordinary Verify behavior.
3. Run focused and full regression tests. On a new isolated project copy, attempt a reproducible native session failure and run the repair; retain evidence and explicitly report whether actual corruption and recovery were demonstrated.
## Button design and acceptance (2026-10-28)
- [x] Put the action in a separate database maintenance panel with the supported scope beside it.
- [x] Confirmation displays the exact library, eligible count, Ready count and missing-project count, and explains that verification saves projects.
- [x] Show item progress and separate checking, backup and native repair phases; allow stopping after the current item.
- [x] Report verified items, native repairs, restored backups requiring review, unconfirmed repairs and unexecuted items separately. Save a JSON maintenance report with original error and repair evidence.
- [x] Detect native restoration from an existing backup without treating it as an automatic repair success or retrying verification. Close only after restoration/diagnostics complete, the native main window is idle and the database address has been released.
- [x] Exercise the actual Qt button on a fresh local library copy using the production reader and verifier, capture screenshots and check source fingerprints afterwards.
- [x] Repeat the real header-corruption/native-repair probe with a 180-second native deadline and verify the restoration-review result and normal process exit.
- [x] Run the full regression suite and record the supported scope and practical limits in a release validation note.
Results: `docs/releases/2026-10-28-icdb-maintenance-button-validation.md`. Actual button run PASS/READY raw=1 on IP101GR; all 21,029 source file hashes unchanged. Real header corruption led to native restoration of an older backup and RESTORED_REVIEW_REQUIRED, without automatic retry. Full regression: 455 passed. Final Windows EXE smoke: clean exit 0.
+2 -1
View File
@@ -13,11 +13,12 @@ a = Analysis(
if verify_probe_path.is_file() else []
),
datas=[(str(project_root / 'src' / 'cbb_refresh_verify' / 'save_verified_block.vbs'), 'cbb_refresh_verify'),
(str(project_root / 'src' / 'cbb_refresh_verify' / 'close_failed_block.vbs'), 'cbb_refresh_verify'),
(str(assets_root / 'cbb_refresh_verify.ico'), 'cbb_refresh_verify/assets'),
(str(assets_root / 'cbb_refresh_verify.png'), 'cbb_refresh_verify/assets'),
(str(assets_root / 'cbb_refresh_verify.svg'), 'cbb_refresh_verify/assets'),
(str(assets_root / 'dialog_rules.v1.json'), 'cbb_refresh_verify/assets')],
hiddenimports=['win32com.client','win32com.client.dynamic','pythoncom','pywintypes','win32job','pywinauto','pywinauto.uia_defines','pywinauto.controls.uiawrapper','pywinauto.win32_element_info','cbb_refresh_verify.dialog_agent','cbb_refresh_verify.dialog_probe','cbb_refresh_verify.dialog_rules','cbb_refresh_verify.ui.main_window','dx_productivity.trial_task_center.logging_setup','dx_productivity.trial_task_center.errors','dx_productivity.trial_task_center.retention'],
hiddenimports=['win32com.client','win32com.client.dynamic','pythoncom','pywintypes','win32job','pywinauto','pywinauto.uia_defines','pywinauto.controls.uiawrapper','pywinauto.win32_element_info','cbb_refresh_verify.dialog_agent','cbb_refresh_verify.dialog_probe','cbb_refresh_verify.dialog_rules','cbb_refresh_verify.ui.main_window','cbb_refresh_verify.content_check','cbb_refresh_verify.failed_session','cbb_refresh_verify.icdb_ownership','cbb_refresh_verify.native_repair','cbb_refresh_verify.native_repair_ui','dx_productivity.trial_task_center.logging_setup','dx_productivity.trial_task_center.errors','dx_productivity.trial_task_center.retention'],
excludes=['PySide6.QtDesigner','PySide6.QtMultimedia','PySide6.QtMultimediaWidgets','PySide6.QtOpenGL','PySide6.QtOpenGLWidgets','PySide6.QtPdf','PySide6.QtPdfWidgets','PySide6.QtQml','PySide6.QtQuick','PySide6.QtQuickWidgets','PySide6.QtWebChannel','PySide6.QtWebEngineCore','PySide6.QtWebEngineWidgets'],
)
excluded_qt_binaries = {'icudt78.dll','icuuc.dll','qpdf.dll','qt6pdf.dll','qt6qml.dll','qt6qmlmeta.dll','qt6qmlmodels.dll','qt6qmlworkerscript.dll','qt6quick.dll','qt6quickwidgets.dll'}
+1 -1
View File
@@ -3,7 +3,7 @@ requires = ["setuptools>=84.1.0"]
build-backend = "setuptools.build_meta"
[project]
name = "cbb-refresh-verify"
version = "0.2.2b1"
version = "0.2.3b1"
requires-python = ">=3.12,<3.13"
dependencies = ["PySide6>=6.7,<7", "pywin32>=306", "pywinauto>=0.6.9,<0.7", "Pillow>=13.0.0,<14"]
+1 -1
View File
@@ -1 +1 @@
__version__ = "0.2.2b1"
__version__ = "0.2.3b1"
+4
View File
@@ -46,6 +46,7 @@ def resolve_data_root(cli_value: Path | None) -> Path:
def main(argv: Sequence[str] | None = None) -> int:
parser = argparse.ArgumentParser(prog="CbbRefreshVerify")
parser.add_argument('--verify-worker', type=Path, help=argparse.SUPPRESS)
parser.add_argument('--repair-worker', type=Path, help=argparse.SUPPRESS)
parser.add_argument('--dialog-agent', type=Path, help=argparse.SUPPRESS)
parser.add_argument('--collect-failure-logs', type=Path, help=argparse.SUPPRESS)
parser.add_argument('--batch-lmc', type=Path, help=argparse.SUPPRESS)
@@ -55,6 +56,9 @@ def main(argv: Sequence[str] | None = None) -> int:
parser.add_argument('--mentor-bin', default='', help=argparse.SUPPRESS)
parser.add_argument("--smoke-test", action="store_true", help=argparse.SUPPRESS); parser.add_argument("--data-root", type=Path, help=argparse.SUPPRESS)
args = parser.parse_args(list(argv) if argv is not None else None)
if args.repair_worker:
from .native_repair_ui import repair_worker_main
return repair_worker_main(args.repair_worker)
if args.collect_failure_logs:
from .verify_diagnostics import failure_logs_main
return failure_logs_main(args.collect_failure_logs)
+315
View File
@@ -0,0 +1,315 @@
"""Restore a complete same-CBB Work backup, then reopen through native Verify.
This restores project data for an existing library entry. It is not a native
cross-library import and does not delete library records or shared symbols.
"""
from contextlib import ExitStack
from concurrent.futures import ThreadPoolExecutor
from dataclasses import asdict, replace
import hashlib
import json
import os
from pathlib import Path
import re
import shutil
import stat
from uuid import uuid4
from .verify_runner import VerifyResult, preflight
def _hash(path):
digest = hashlib.sha256()
with path.open('rb') as stream:
for data in iter(lambda: stream.read(1024 * 1024), b''):
digest.update(data)
return digest.hexdigest()
def _scan(root):
if root.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
raise ValueError(f'不支持通过目录链接恢复:{root}')
entries = {}
folders = [root]
while folders:
with os.scandir(folders.pop()) as scanned:
for entry in scanned:
metadata = entry.stat(follow_symlinks=False)
if metadata.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
raise ValueError(f'目录含文件或目录链接,停止恢复:{entry.path}')
path = Path(entry.path)
entries[path] = metadata
if stat.S_ISDIR(metadata.st_mode):
folders.append(path)
return dict(sorted(entries.items()))
def _paths(root):
return list(_scan(root))
def _manifest(root, *, exclude=None):
entries = _scan(root)
paths = [path for path in entries
if exclude is None or not path.is_relative_to(exclude)]
def entry(path):
return str(path.relative_to(root)), _hash(path) if stat.S_ISREG(entries[path].st_mode) else None
with ThreadPoolExecutor(max_workers=8) as pool:
return dict(pool.map(entry, paths))
def _copy_verified(source, destination, *, progress=None):
"""Copy every file, refusing links and changed files; lock native databases."""
import win32con, win32file
entries = _scan(source)
paths = list(entries)
destination.mkdir(parents=True, exist_ok=False)
record = {}
with ExitStack() as stack:
locks = {}
for path in paths:
if stat.S_ISREG(entries[path].st_mode) and (path.name.casefold() == 'icdb.dat' or path.suffix.casefold() == '.lmc'):
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
stack.callback(handle.Close)
locks[path] = handle
files = []
for path in paths:
relative = str(path.relative_to(source))
copied = destination / relative
if stat.S_ISDIR(entries[path].st_mode):
copied.mkdir(parents=True, exist_ok=True)
record[relative] = None
continue
files.append(path)
def copy_file(path):
relative = str(path.relative_to(source))
copied = destination / relative
before = entries[path]
copied.parent.mkdir(parents=True, exist_ok=True)
if path in locks:
with copied.open('wb') as stream:
while True:
_, data = win32file.ReadFile(locks[path], 1024 * 1024)
if not data:
break
stream.write(data)
shutil.copystat(path, copied)
digest = _hash(copied)
else:
digest = _hash(path)
shutil.copy2(path, copied)
if _hash(copied) != digest:
raise OSError(f'副本校验失败:{path}')
after = path.stat()
if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns):
raise OSError(f'复制期间文件变化:{path}')
return relative, digest
with ThreadPoolExecutor(max_workers=8) as pool:
for count, (relative, digest) in enumerate(pool.map(copy_file, files), 1):
record[relative] = digest
if progress and (count % 256 == 0 or count == len(files)):
progress(count, len(files))
if _manifest(source) != record:
raise OSError(f'复制期间目录内容变化:{source}')
return record
def _idle_check(library, project, pcb):
from .mentor_adapter import pcb_processes, _process_details
from .icdb_ownership import unreleased_addresses
if pcb_processes() or any(_process_details(name) for name in (
'LibraryManager.exe', 'viewdraw.exe')):
raise ValueError('请先正常关闭 PCB、Library Manager 和原理图编辑器,再恢复备份。')
addresses = unreleased_addresses(library, project, pcb)
if addresses:
raise ValueError(f'数据库会话尚未释放,停止恢复:{addresses}')
def _project_text(path):
data = path.read_bytes()
if data.startswith((b'\xff\xfe', b'\xfe\xff')):
return data.decode('utf-16')
try:
return data.decode('utf-8-sig')
except UnicodeDecodeError:
return data.decode('mbcs')
def _source_check(source, name, original):
if not source.is_file() or source.suffix.casefold() != '.prj':
raise ValueError('请选择完整健康备份中的工程 .prj。')
_paths(source.parent)
text = _project_text(source)
roots = re.findall(r'^KEY RootBlock "([^"]+)"', text, re.M)
if (source.name.casefold() != original.name.casefold() or not roots
or any(root.casefold() != name.casefold() for root in roots)):
raise ValueError('当前仅支持同名 CBB 的完整工程备份,工程名和顶层块必须与目标一致。')
refs = re.findall(r'^KEY PCBDesignPath "([^"]+)"', text, re.M)
if len(refs) != 1:
raise ValueError('备份工程必须包含唯一的 PCBDesignPath。')
def require_relative(value):
if Path(value).drive or Path(value).root:
raise ValueError('备份工程、PCB 和数据库必须使用工程内的相对路径,不能指向原备份位置。')
require_relative(refs[0])
pcb = (source.parent / refs[0]).resolve()
if not pcb.is_relative_to(source.parent.resolve()):
raise ValueError('备份 PCB 引用越出工程目录。')
if not all(path.is_file() for path in (pcb, pcb.parent/'Layout/LayoutDB.lyt',
pcb.parent/'pcb.prj', source.parent/'database/icdb.dat')):
raise ValueError('备份不完整:需要原理图数据库、PCB、布局数据库和 PCB 工程文件。')
project_refs = re.findall(r'^KEY ProjectFile "([^"]+)"', _project_text(pcb), re.M)
for value in project_refs:
require_relative(value)
if len(project_refs) != 1 or (pcb.parent/project_refs[0]).resolve() != source.resolve():
raise ValueError('备份 PCB 必须引用所选工程,不能引用其他位置的工程。')
for project in (source, pcb.parent/'pcb.prj'):
data = _project_text(project)
for value in re.findall(r'^KEY iCDBDir "([^"]+)"', data, re.M):
require_relative(value)
if not (project.parent/value).resolve().is_relative_to(source.parent.resolve()):
raise ValueError('备份数据库引用越出工程目录。')
return pcb
def _align_library(project, pcb, library):
from .mentor_adapter import ensure_project_central_library, ensure_pcb_central_library
for path in (project, pcb.parent/'pcb.prj'):
if not re.findall(r'^KEY CentralLibrary "([^"]*)"', _project_text(path), re.M):
raise ValueError('备份工程缺少 CentralLibrary 引用。')
def already_references(path):
return all((path.parent/value).resolve() == Path(library).resolve()
for value in re.findall(r'^KEY CentralLibrary "([^"]*)"', _project_text(path), re.M))
if not already_references(project):
ensure_project_central_library(project, library)
if not already_references(pcb.parent/'pcb.prj'):
ensure_pcb_central_library(pcb, library)
def recover_from_backup(request, source, *, progress=None, verifier=None, idle_check=None):
"""Validate in copies before changing Work; preserve all recovery evidence."""
import pythoncom, win32con, win32event
from .network_path import absolute_preserving_drive
from .verify_runner import run_verify, read_library_flag_if_available
verifier = verifier or run_verify
idle_check = idle_check or _idle_check
source = Path(source).resolve()
library = absolute_preserving_drive(request.lmc_file)
library_root = library.parent.resolve()
root = Path(request.evidence_dir).resolve() / ('backup-restore-' + uuid4().hex[:12])
# Packaged desktop apps can redirect AppData to a very deep MSIX path.
# Keep native EE7.9 files in a genuinely short, user-owned directory.
validation_base = Path.home() / '.cbb-restore'
validation_dir = validation_base.resolve() / root.name.removeprefix('backup-restore-')
if root.is_relative_to(library_root) or library_root.is_relative_to(root):
return VerifyResult('BLOCKED', stderr='恢复记录目录与目标中心库不能相互包含。')
if root.is_relative_to(source.parent):
return VerifyResult('BLOCKED', stderr='恢复记录目录不能位于备份工程内。')
if validation_dir.is_relative_to(library_root) or validation_dir.is_relative_to(source.parent):
return VerifyResult('BLOCKED', stderr='本机验证目录不能位于目标库或备份工程内。')
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
acquired = False
installed = False
record = {'operation': 'same_cbb_complete_project_restore', 'source': str(source),
'library': str(library), 'block': request.block_name, 'installed': False,
'validation_library': str(validation_dir/library.name)}
def emit(stage, message):
if progress:
progress({'stage': stage, 'block': request.block_name, 'message': message})
def save(result):
record.update({'installed': installed, 'result': asdict(result)})
root.mkdir(parents=True, exist_ok=True)
report = root/'recovery-result.json'
report.write_text(json.dumps(record, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
return replace(result, evidence_path=report)
pythoncom.CoInitialize()
try:
acquired = win32event.WaitForSingleObject(mutex, 0) in (
win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
if not acquired:
return VerifyResult('BLOCKED', stderr='已有 CBB 任务运行,请等待结束。', safe_to_continue=False)
if source.is_relative_to(library_root):
raise ValueError('请选择目标中心库之外的独立备份工程。')
project, pcb = preflight(replace(request, lmc_file=library))
source_pcb = _source_check(source, request.block_name, project)
idle_check(library, project, pcb)
idle_check(library, source, source_pcb)
root.mkdir(parents=True, exist_ok=False)
validation_base.mkdir(parents=True, exist_ok=True)
library_size = sum(info.st_size for info in _scan(library_root).values() if stat.S_ISREG(info.st_mode))
source_size = sum(info.st_size for info in _scan(source.parent).values() if stat.S_ISREG(info.st_mode))
same_drive = root.anchor.casefold() == validation_dir.anchor.casefold()
required = library_size * (2 if same_drive else 1) + source_size * 3
if (shutil.disk_usage(root).free < required
or shutil.disk_usage(validation_base).free < library_size + source_size * 2):
raise ValueError('磁盘空间不足:需要容纳中心库回退副本和验证副本。')
(root/'recovery-request.json').write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8')
emit('backup', '正在保留完整中心库副本…')
original_manifest = _copy_verified(library_root, root/'library-before', progress=lambda n, total:
emit('backup', f'正在保留中心库副本:{n} / {total} 个文件…'))
(root/'library-before-manifest.json').write_text(json.dumps(original_manifest, indent=2), encoding='utf-8')
emit('prepare_source', '正在准备备份验证副本…')
source_manifest = _copy_verified(source.parent, root/'source-before')
_copy_verified(root/'library-before', validation_dir, progress=lambda n, total:
emit('prepare_source', f'正在准备验证库:{n} / {total} 个文件…'))
staged_library = validation_dir/library.name
staged_work = staged_library.parent/'ReusableBlocksLP'/request.block_name/'Work'
# Both paths are newly created private copies; originals are retained.
resolved_work = staged_work.resolve()
if not resolved_work.is_relative_to(validation_dir.resolve()):
raise ValueError('验证副本工程路径越界。')
shutil.rmtree(resolved_work)
_copy_verified(root/'source-before', staged_work)
staged_project = staged_work/source.name
staged_pcb = staged_work/source_pcb.relative_to(source.parent)
_align_library(staged_project, staged_pcb, staged_library)
_source_check(staged_project, request.block_name, project)
validation = replace(request, lmc_file=staged_library, evidence_dir=root/'source-verify',
auto_repair=False, libspec='', dms_login_config='', mapped_drive='', mapped_remote_root='',
native_lm_verify=False, interactive_input=False)
preflight(validation)
emit('validate_source', '正在副本中打开备份工程并执行原生校验…')
source_result = verifier(validation, progress=progress, flag_reader=read_library_flag_if_available)
record['source_validation'] = asdict(source_result)
if (source_result.status != 'PASS' or source_result.library_flag != 'GREEN'
or not source_result.safe_to_continue):
return save(replace(source_result, status='FAIL', stderr=
'备份校验未通过,目标未更改。\n' + (source_result.stderr or source_result.library_flag_detail)))
idle_check(library, project, pcb)
idle_check(staged_library, staged_project, staged_pcb)
if _manifest(source.parent) != source_manifest:
raise ValueError('备份来源在验证期间发生变化,目标未更改。')
token = root.name.removeprefix('backup-restore-')
work = project.parent.resolve()
incoming = work.with_name('Work.restore-' + token)
retained = work.with_name('Work.before-restore-' + token)
_copy_verified(staged_work, incoming)
_align_library(incoming/source.name, incoming/source_pcb.relative_to(source.parent), library)
if _manifest(library_root, exclude=incoming.resolve()) != original_manifest:
raise ValueError('目标中心库在验证期间发生变化,停止恢复。')
emit('install', '备份已通过验证,正在保留原工程并恢复…')
work.rename(retained)
try:
incoming.rename(work)
except Exception:
retained.rename(work)
raise
installed = True
record['retained_work'] = str(retained)
emit('verify_target', '正在重新打开恢复后的目标工程并校验…')
final = verifier(replace(request, lmc_file=library, evidence_dir=root/'target-verify',
auto_repair=False, native_lm_verify=False, interactive_input=False),
progress=progress, flag_reader=read_library_flag_if_available)
if final.status == 'PASS' and (final.library_flag != 'GREEN' or not final.safe_to_continue):
final = replace(final, status='FAIL', stderr='目标工程恢复后的 Ready 状态未确认。')
if final.status != 'PASS':
final = replace(final, stderr=(final.stderr + '\n原工程和完整库副本已保留,请查看恢复记录。').strip())
return save(final)
except Exception as error:
return save(VerifyResult('FAIL' if installed else 'BLOCKED', stderr=str(error),
safe_to_continue=False))
finally:
if acquired:
win32event.ReleaseMutex(mutex)
mutex.Close()
pythoncom.CoUninitialize()
@@ -0,0 +1,29 @@
Option Explicit
Dim app, doc, pi, licensing, token, closed, remaining
Set app = GetObject(, "MGCPCB.Application")
Set doc = app.ActiveDocument
If doc Is Nothing Then WScript.Quit 3
Set pi = doc.ProjectIntegration
If LCase(pi.ProjectFile) <> LCase(WScript.Arguments(0)) Then WScript.Quit 2
If LCase(doc.Name) <> LCase(WScript.Arguments(1)) Then WScript.Quit 2
Set pi = Nothing
WScript.Echo "FAILURE_IDENTITY_OK"
Set licensing = CreateObject("MGCPCBAutomationLicensing.Application")
token = licensing.GetToken(doc.Validate(0))
doc.Validate token
WScript.Echo "FAILURE_CLOSE_START"
closed = doc.Close(False)
If Not closed Then WScript.Quit 4
WScript.Echo "FAILURE_CLOSE_OK"
Set doc = Nothing
Set licensing = Nothing
Set remaining = app.ActiveDocument
If Not remaining Is Nothing Then
Set remaining = Nothing
WScript.Echo "FAILURE_APP_RETAINED"
WScript.Quit 5
End If
Set remaining = Nothing
app.Quit
WScript.Echo "FAILURE_QUIT_OK"
Set app = Nothing
+46
View File
@@ -0,0 +1,46 @@
"""Run the native importer without aborting database owners on timeout."""
import json
import os
from pathlib import Path
import subprocess
import tempfile
import threading
def run_content_check(command, timeout_seconds, cwd, *, evidence_root=None):
root = (Path(evidence_root) if evidence_root is not None else
Path(tempfile.mkdtemp(prefix='cbb-content-check-')))
root.mkdir(parents=True, exist_ok=True)
stdout_path, stderr_path = root/'content-check.stdout.log', root/'content-check.stderr.log'
record_path = root/'content-check-process.json'
with stdout_path.open('wb') as stdout, stderr_path.open('wb') as stderr:
process = subprocess.Popen(command, cwd=str(cwd), stdout=stdout, stderr=stderr,
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
record = {'pid': process.pid, 'command': list(command), 'cwd': str(cwd),
'stdout': str(stdout_path), 'stderr': str(stderr_path)}
def save_record(**fields):
try:
record_path.write_text(json.dumps({**record, **fields}, ensure_ascii=False, indent=2),
encoding='utf-8')
except OSError:
pass
save_record(status='RUNNING')
try:
process.wait(timeout=max(.1, float(timeout_seconds)))
except subprocess.TimeoutExpired:
# Never kill this client or its descendants. The importer can own the
# shared symbol database even though contents checking sounds read-only.
# Files avoid pipe backpressure/BrokenPipe if the supervisor exits.
save_record(status='RETAINED', safe_to_continue=False)
def observe_exit():
process.wait()
save_record(status='EXITED', returncode=process.returncode,
note='Importer exit alone does not prove native database release.')
threading.Thread(target=observe_exit, name='retained-content-check', daemon=True).start()
return (None, stdout_path.read_bytes().decode('utf-8', errors='replace'),
stderr_path.read_bytes().decode('utf-8', errors='replace') +
f'\nIMPORTER_RELEASE_UNCONFIRMED: pid={process.pid}; '
f'内容检查超时,保留原生操作并停止批次;进程记录:{record_path}', True)
save_record(status='EXITED', returncode=process.returncode)
return (process.returncode, stdout_path.read_bytes().decode('utf-8', errors='replace'),
stderr_path.read_bytes().decode('utf-8', errors='replace'), False)
+20 -3
View File
@@ -1,6 +1,7 @@
"""Launch automation on a private Windows desktop, never the input desktop."""
import subprocess
import os
from pathlib import Path
import threading
import win32con
import win32event
@@ -21,7 +22,7 @@ def launch_save_helper(command, **kwargs):
return helper
def start_supervisor_watchdog(supervisor_pid):
def start_supervisor_watchdog(supervisor_pid, *, cancel_path=None):
"""A crashed supervisor must not leave unsupervised automation writing.
Stop only this Python worker and its registered automation clients. Native
@@ -33,6 +34,11 @@ def start_supervisor_watchdog(supervisor_pid):
def watch():
try:
win32event.WaitForSingleObject(parent, win32event.INFINITE)
if cancel_path is not None:
# Let native calls finish before the worker closes its exact
# document. Killing a pending automation client can abandon it.
Path(cancel_path).touch()
return
with _automation_clients_lock:
for helper in _automation_clients:
try:
@@ -42,7 +48,8 @@ def start_supervisor_watchdog(supervisor_pid):
pass
finally:
parent.Close()
os._exit(75)
if cancel_path is None:
os._exit(75)
thread = threading.Thread(target=watch, name='supervisor-watchdog', daemon=True)
thread.start()
@@ -139,6 +146,16 @@ class DesktopWorker:
except Exception:
pass
def bind_cancellation(self, path):
self.cancel_path = Path(path)
def request_stop(self):
if not hasattr(self, 'cancel_path'):
# Compatibility for diagnostic workers without the Verify protocol.
self.kill()
return
self.cancel_path.touch()
def wait(self, timeout=5):
if win32event.WaitForSingleObject(self.handle, int(timeout*1000)) != win32con.WAIT_OBJECT_0:
raise TimeoutError('Automation worker did not exit')
@@ -148,7 +165,7 @@ class DesktopWorker:
# Releasing Python resources must not kill native database owners.
try:
if self.poll() is None:
self.kill()
self.request_stop()
except Exception:
pass
for companion in self.companions:
+4
View File
@@ -193,6 +193,10 @@ def decide(snapshot: WindowSnapshot, rules: Sequence[DialogRule]) -> RuleDecisio
and not snapshot.controls):
return RuleDecision(rule_id='ime-floating-language-bar', category='OBSERVE_PROGRESS')
combined = normalize_text(' '.join((snapshot.title, *snapshot.texts)))
from .icdb_recovery import ERROR_CODE, parse_session_loss
if parse_session_loss(combined):
return RuleDecision(error_code=ERROR_CODE,
detail=' | '.join(snapshot.texts) or snapshot.title)
# These prompts require knowledge of database ownership or a recovery
# choice. A generic Yes/restore rule cannot establish either fact.
if any(marker in combined for marker in (
@@ -351,6 +351,11 @@ def classify_dialog(snapshot: DialogSnapshot) -> DialogDecision:
joined = " ".join(snapshot.texts).casefold()
combined = f"{title} {joined}"
from .icdb_recovery import ERROR_CODE, parse_session_loss
if parse_session_loss(combined):
return DialogDecision(error_code=ERROR_CODE,
detail=' | '.join(snapshot.texts) or snapshot.title)
if ("problem encountered while opening one of the database files" in combined
and "loading of the job has failed" in combined):
return DialogDecision(action="decline_database_log",
+30
View File
@@ -0,0 +1,30 @@
"""Close only an idle document whose native identity was already established."""
import json
import os
from pathlib import Path
import time
def close_failed_document(job, *, emit=lambda **event: None, timeout_seconds=30):
from .desktop_worker import launch_save_helper
root = Path(job['root'])
log_path = root/'failure-close.log'
command = [str(Path(os.environ.get('WINDIR', r'C:\Windows'))/'SysWOW64/cscript.exe'),
'//nologo', str(Path(__file__).with_name('close_failed_block.vbs')),
job['project'], Path(job['pcb']).name]
with log_path.open('w', encoding='utf-8') as log:
process = launch_save_helper(command, stdout=log, stderr=log)
emit(stage='failure_close_started', helper_pid=process.pid)
deadline = time.monotonic()+max(.1, float(timeout_seconds))
while process.poll() is None and time.monotonic() < deadline:
time.sleep(.2)
# A slow native Close can still be flushing. Retain the helper as well as
# PCB/iCDB; never force it to abandon the native call at this deadline.
text = log_path.read_text('utf-8', errors='replace')
result = {'status': ('CLOSED' if process.poll() == 0 and
all(marker in text.splitlines() for marker in ('FAILURE_CLOSE_OK', 'FAILURE_QUIT_OK'))
else 'RETAINED' if process.poll() is None else 'UNCONFIRMED'),
'helper_pid': process.pid, 'returncode': process.poll(), 'log': str(log_path)}
(root/'failure-close.json').write_text(json.dumps(result, indent=2), encoding='utf-8')
emit(stage='failure_close_result', **result)
return result
@@ -0,0 +1,25 @@
"""Reports for the explicit full-library maintenance action."""
from dataclasses import asdict
import json
def maintenance_counts(results):
attempts = [attempt for result in results for attempt in result.recovery_attempts]
repaired = sum(attempt.get('status') == 'REPAIRED' for attempt in attempts)
review = sum(attempt.get('status') == 'RESTORED_REVIEW_REQUIRED' for attempt in attempts)
return {'total': len(results), 'passed': sum(r.status == 'PASS' for r in results),
'skipped': sum(r.status == 'SKIPPED' for r in results),
'repaired': repaired, 'review_required': review,
'repair_unconfirmed': len(attempts)-repaired-review}
def write_maintenance_report(requests, results, batch_report, skipped_names):
path = batch_report.with_name(batch_report.name.replace('batch-', 'icdb-', 1)).with_suffix('.json')
record = {'operation': 'full_library_icdb_check_and_repair',
'library': str(requests[0].lmc_file), 'includes_ready': True,
'shared_database_repair_supported': False,
'preflight_skipped': sorted(skipped_names), 'counts': maintenance_counts(results),
'results': [{'block': req.block_name, **asdict(result)}
for req, result in zip(requests, results)]}
path.write_text(json.dumps(record, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
return path
+16
View File
@@ -0,0 +1,16 @@
"""Known native database owners touched by a CBB verification operation."""
from pathlib import Path
def database_directories(lmc_file, project, pcb):
return tuple(dict.fromkeys((
Path(project).parent/'database',
Path(pcb).parent/'database',
Path(lmc_file).parent/'SymbolLibs/__ReusableBlocksSymb',
)))
def unreleased_addresses(lmc_file, project, pcb):
return [str(path/'cdbsvr/sAddress.adr')
for path in database_directories(lmc_file, project, pcb)
if (path/'cdbsvr/sAddress.adr').exists()]
+144
View File
@@ -0,0 +1,144 @@
"""Recognize native iCDB recovery requests without changing database state."""
import hashlib
import ntpath
from pathlib import Path
import re
ERROR_CODE = 'ICDB_REPAIR_REQUIRED'
LOG_LIMIT = 128 * 1024
RECOVERY_ACTION = (
'停止批次并确认原服务器及其他客户端已正常关闭;保留完整一致副本后,'
"使用同版本 iCDB Project Backup 的 Repair project 检查并修复正确目标。"
'共享符号库问题需核对中心库,不能只修复单个 CBB 的 Work 工程。'
'不要删除 sAddress.adr/锁文件;修复后重新打开、校验并确认权威 READY。'
)
_SESSION_LOSS = re.compile(
r'\bthe\s+last\s+server\s+session\s+on\s+different\s+server\s+machine\s+'
r'lost\s+the\s+connection\s+to\s+the\s+database\b', re.IGNORECASE)
def parse_session_loss(text):
"""Keep the native target verbatim; never infer a local repair target."""
text = str(text or '')
match = _SESSION_LOSS.search(text)
if match is None:
return None
# A log may contain several sessions. Use the identity following this
# error, never an unrelated Machine/Path header earlier in the log.
message = text[match.start():]
next_error = _SESSION_LOSS.search(message, 1)
if next_error:
message = message[:next_error.start()]
record = {'error_code': ERROR_CODE, 'native_message': message,
'machine': '', 'database_path': '', 'session': '', 'scope': 'unknown'}
for native_key, key in (('machine', 'machine'), ('path', 'database_path'),
('session', 'session')):
field = re.search(
rf'\b{native_key}\s*:\s*(?:\[([^\]]*)\]|([^\r\n]*?)(?=\s+\b(?:machine|path|session)\s*:|[\r\n]|$))',
message, re.IGNORECASE)
if field:
record[key] = (field.group(1) if field.group(1) is not None else field.group(2)).strip()
parts = ntpath.normpath(record['database_path']).casefold().split('\\')
if 'symbollibs' in parts:
record['scope'] = 'central_library'
elif 'work' in parts and parts[-1] == 'database':
record['scope'] = 'project'
return record
def recovery_detail(record):
target = ('中心库共享符号数据库' if record['scope'] == 'central_library' else
'工程数据库' if record['scope'] == 'project' else '报错中指定的数据库')
return (
f"{ERROR_CODE}: {target}的上次服务器会话失联。\n"
f"{record['native_message']}\n"
f'{RECOVERY_ACTION}'
)
def snapshot_log(path):
"""Fingerprint a bounded tail before launch, including a missing log."""
try:
with Path(path).open('rb') as stream:
stream.seek(0, 2)
size = stream.tell()
stream.seek(max(0, size-LOG_LIMIT))
tail = stream.read(LOG_LIMIT)
losses = [_session_identity(record) for record in _session_losses(decode_log(tail))]
return {'size': size, 'tail_sha256': hashlib.sha256(tail).hexdigest(),
'truncated': size > LOG_LIMIT,
'session_losses': losses}
except FileNotFoundError:
return {'size': 0, 'tail_sha256': hashlib.sha256(b'').hexdigest()}
except OSError as error:
return {'error': str(error)}
def _read_log_delta(path, baseline):
"""Read new bytes, detecting truncate/rewrite as well as append.
Unknown baselines cannot prove freshness. At most two bounded tails are
read, even when a native log is large or located on a network share.
"""
if not baseline or 'error' in baseline:
return b'', False
old_size = int(baseline['size'])
try:
with Path(path).open('rb') as stream:
stream.seek(0, 2)
size = stream.tell()
offset = 0
appended = False
if size >= old_size:
stream.seek(max(0, old_size-LOG_LIMIT))
old_tail = stream.read(min(old_size, LOG_LIMIT))
if hashlib.sha256(old_tail).hexdigest() == baseline['tail_sha256']:
offset = old_size
appended = True
stream.seek(max(offset, size-LOG_LIMIT))
return stream.read(LOG_LIMIT), appended
except OSError:
return b'', False
def _session_losses(text):
matches = list(_SESSION_LOSS.finditer(text))
for index, match in enumerate(matches):
end = matches[index+1].start() if index+1 < len(matches) else len(text)
yield parse_session_loss(text[match.start():end])
def _session_identity(record):
return [record[key] for key in ('machine', 'database_path', 'session')]
def read_log_failure(path, baseline):
"""Return new log text and a recovery request with evidence of freshness.
A rewritten header does not prove that a retained old session failed
again. In that ambiguous case keep the generic failure; a verified append
can report even the same old session as a current native error.
"""
data, appended = _read_log_delta(path, baseline)
text = decode_log(data)
if not appended and baseline and baseline.get('truncated'):
# A rewrite may expose an old error outside our bounded baseline.
# Without positive append evidence its age cannot be established.
return text, None
historical = baseline.get('session_losses', []) if baseline else []
recovery = next((record for record in _session_losses(text)
if appended or _session_identity(record) not in historical), None)
return text, recovery
def decode_log(data):
if data.startswith((b'\xff\xfe', b'\xfe\xff')):
return data.decode('utf-16', errors='replace')
# Appended UTF-16 bytes and bounded tails no longer contain a BOM.
sample = data[:200]
if sample[1::2].count(0) > len(sample)//8:
return data.decode('utf-16-le', errors='replace')
if sample[::2].count(0) > len(sample)//8:
return data.decode('utf-16-be', errors='replace')
return data.decode('utf-8', errors='replace')
+101 -25
View File
@@ -101,7 +101,14 @@ def ensure_pcb_central_library(pcb_path, lmc_path, *, evidence_dir=None,
is copied into evidence before a replacement, so the change is auditable
and recoverable.
"""
project = Path(pcb_path).parent / 'pcb.prj'
return ensure_project_central_library(Path(pcb_path).parent/'pcb.prj', lmc_path,
evidence_dir=evidence_dir, emit=emit)
def ensure_project_central_library(project, lmc_path, *, evidence_dir=None,
emit=lambda **event: None):
"""Align one native project file while preserving its original encoding."""
project = Path(project)
target = str(lmc_path)
if not project.is_file() or not target:
return False
@@ -214,6 +221,7 @@ def _process_details(name):
'ExpeditionPCB.exe': "SELECT ProcessId, ParentProcessId, ExecutablePath, CommandLine FROM Win32_Process WHERE Name='ExpeditionPCB.exe'",
'LibraryManager.exe': "SELECT ProcessId, ParentProcessId, ExecutablePath, CommandLine FROM Win32_Process WHERE Name='LibraryManager.exe'",
'cscript.exe': "SELECT ProcessId, ParentProcessId, ExecutablePath, CommandLine FROM Win32_Process WHERE Name='cscript.exe'",
'viewdraw.exe': "SELECT ProcessId, ParentProcessId, ExecutablePath, CommandLine FROM Win32_Process WHERE Name='viewdraw.exe'",
}
if name not in queries:
raise ValueError(f'Unsupported process query: {name}')
@@ -633,12 +641,13 @@ def execute_job(job, emit):
emit(stage='backup_done', status=backup.get('status'), detail=backup.get('detail'))
# Backup is evidence only, never a prerequisite for launching PCB. Volatile
# database/log directories are intentionally excluded to avoid file locks.
icdb_address = prepare_icdb_address(
Path(job['project']).parent / 'database', root, emit=emit)
if icdb_address.get('status') != 'ABSENT':
raise RuntimeError(
'ICDB_SESSION_UNCONFIRMED: 数据库存在服务器地址记录,无法确认独占使用;'
'已保留地址文件,请先检查原 PCB/iCDB 会话。' + str(icdb_address))
from .icdb_ownership import database_directories, unreleased_addresses
for database in database_directories(job['lmc_file'], job['project'], job['pcb']):
icdb_address = prepare_icdb_address(database, root, emit=emit)
if icdb_address.get('status') != 'ABSENT':
raise RuntimeError(
'ICDB_SESSION_UNCONFIRMED: 数据库存在服务器地址记录,无法确认独占使用;'
'已保留地址文件,请先检查原 PCB/iCDB 会话。' + str(icdb_address))
from .verify_diagnostics import collect_preflight_diagnostics, collect_native_failure_logs
diagnostics = collect_preflight_diagnostics(job['pcb'], root)
emit(stage='preflight_diagnostics', non_blocking=True,
@@ -647,10 +656,8 @@ def execute_job(job, emit):
evidence=str(root/'diagnostics/preflight.json'))
cert_project = block_root/'Cert'/Path(job['project']).name
pcb_log = Path(job['pcb']).parent/'LogFiles'/'PCBLogFile.txt'
try:
pcb_log_offset = pcb_log.stat().st_size
except OSError:
pcb_log_offset = 0
from .icdb_recovery import snapshot_log
pcb_log_offset = snapshot_log(pcb_log)
integration_log_dir = Path(job['pcb']).parent / 'LogFiles'
integration_offsets = {}
for name in ('ForwardAnnotation.txt', 'MsgBoxResponse.log', 'PartPkg.log'):
@@ -664,6 +671,28 @@ def execute_job(job, emit):
}
except OSError:
integration_offsets[path] = {'size': 0, 'mtime_ns': None, 'digest': ''}
integration_offsets[path]['icdb_baseline'] = snapshot_log(path)
try:
(root/'diagnostics/startup-log-baseline.json').write_text(json.dumps({
'source': str(pcb_log), 'baseline': pcb_log_offset,
'integration_logs': {str(path): value['icdb_baseline']
for path, value in integration_offsets.items()},
}, ensure_ascii=False), encoding='utf-8')
except OSError as error:
emit(stage='startup_log_baseline_unavailable', detail=str(error))
def native_error():
if job.get('cancel_signal') and Path(job['cancel_signal']).exists():
return 'VERIFY_CANCELLED: 停止后续操作并正常关闭目标文档'
# Inspect every source before returning a generic server/packager
# failure: either can be a consequence of a lost library session.
startup = pcb_log_reports_missing_server(job['pcb'], offset=pcb_log_offset)
integration = pcb_log_reports_integration_error(job['pcb'], offsets=integration_offsets)
if 'ICDB_REPAIR_REQUIRED' in startup:
return startup
if 'ICDB_REPAIR_REQUIRED' in integration:
return integration
return startup or integration
emit(stage='pcb_baseline', pids=sorted(pcb_before))
lm_session = None
lm_pid = None
@@ -671,6 +700,7 @@ def execute_job(job, emit):
worker_parent_pid = None
launcher_process = None
completed = False
identity_verified = False
helper = None
app = doc = pi = None
try:
@@ -712,6 +742,8 @@ def execute_job(job, emit):
pcb_deadline = reset_verify_activity_deadline(
0.0, time.monotonic(), timeout_seconds=pcb_startup_timeout_seconds(job['timeout']))
while time.monotonic() < pcb_deadline:
if job.get('cancel_signal') and Path(job['cancel_signal']).exists():
raise RuntimeError('VERIFY_CANCELLED: PCB 启动期间收到停止请求')
records = _process_details('ExpeditionPCB.exe')
worker = select_reusable_circuit_worker(
records,
@@ -735,8 +767,9 @@ def execute_job(job, emit):
process_alive=lambda: any(candidate_pid in {lm_pid, worker_pid, worker_parent_pid}
for candidate_pid, _, _ in pcb_processes()),
emit=emit,
error_reader=lambda: pcb_log_reports_missing_server(job['pcb'], offset=pcb_log_offset),
error_reader=native_error,
)
identity_verified = True
# Do not acquire MGCPCBAutomationLicensing from this 64-bit Python
# worker. EE7.9 registers that automation class for the 32-bit host;
# the old, working path acquires the token inside the SysWOW64
@@ -746,18 +779,21 @@ def execute_job(job, emit):
pi,
emit=emit,
timeout_seconds=job['timeout'],
error_reader=lambda: pcb_log_reports_integration_error(job['pcb'], offsets=integration_offsets),
error_reader=native_error,
)
# The x86 helper acquires its own COM references. Keeping these Python
# references alive prevents the native PCB server from exiting cleanly.
pi = doc = app = None
gc.collect()
if job.get('cancel_signal') and Path(job['cancel_signal']).exists():
raise RuntimeError('VERIFY_CANCELLED: 未开始保存')
emit(stage='save_start')
script = Path(__file__).with_name('save_verified_block.vbs')
cscript = Path(os.environ.get('WINDIR', r'C:\Windows'))/'SysWOW64'/'cscript.exe'
from .desktop_worker import launch_save_helper
with (root/'save.log').open('w', encoding='utf-8') as log:
helper = launch_save_helper([str(cscript), '//nologo', str(script), job['project']],
helper = launch_save_helper([str(cscript), '//nologo', str(script), job['project'],
Path(job['pcb']).name, str(job.get('cancel_signal') or '')],
stdout=log, stderr=log, creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
emit(stage='save_helper', helper_pid=helper.pid)
last_markers = ()
@@ -796,9 +832,9 @@ def execute_job(job, emit):
baseline_pids=pcb_before, emit=emit)
if not released or not released.get('safe_to_continue'):
raise RuntimeError(f'PCB_RELEASE_UNCONFIRMED: 未确认 PCB 退出: {released}')
address = Path(job['project']).parent / 'database/cdbsvr/sAddress.adr'
if address.exists():
raise RuntimeError(f'ICDB_RELEASE_UNCONFIRMED: PCB 已退出但数据库地址记录仍存在;保留文件并停止批次: {address}')
addresses = unreleased_addresses(job['lmc_file'], job['project'], job['pcb'])
if addresses:
raise RuntimeError(f'ICDB_RELEASE_UNCONFIRMED: PCB 已退出但数据库地址记录仍存在;保留文件并停止批次: {addresses}')
cert_pcb = block_root/'Cert'/Path(job['pcb']).relative_to(block_root/'Work')
cert_evidence = collect_cert_evidence(block_root, cert_project, cert_pcb)
emit(stage='cert_diagnostics', **cert_evidence)
@@ -818,8 +854,15 @@ def execute_job(job, emit):
# Diagnostic failure must not erase the native error or cleanup.
pass
if helper is not None and helper.poll() is None:
# Stop only the automation client, never a native database tree.
helper.terminate()
emit(stage='save_helper_retained', helper_pid=helper.pid)
elif not completed and identity_verified:
try:
from .failed_session import close_failed_document
failed_close = close_failed_document(job, emit=emit)
if failed_close.get('status') == 'CLOSED' and lm_session is not None:
lm_session.close()
except Exception as error:
emit(stage='failure_close_unconfirmed', detail=str(error))
cleanup_verify_processes(
lm_pid,
worker_pid,
@@ -906,7 +949,7 @@ def worker_main(request_path):
try:
if job.get('supervisor_pid'):
from .desktop_worker import start_supervisor_watchdog
start_supervisor_watchdog(job['supervisor_pid'])
start_supervisor_watchdog(job['supervisor_pid'], cancel_path=job.get('cancel_signal'))
start_gate = Path(job.get('start_gate', '')) if job.get('start_gate') else None
if start_gate is not None:
gate_deadline = time.monotonic() + 15
@@ -1040,17 +1083,27 @@ def icdb_ports_bindable(ports=(10000, 10050, 10100)):
def pcb_log_reports_missing_server(pcb_path, *, offset=0):
"""Detect the same failure from ExpeditionPCB's own log, as a second signal."""
"""Detect startup failure from this run, preserving native recovery causes."""
from .icdb_recovery import (decode_log, parse_session_loss, read_log_failure,
recovery_detail)
log = Path(pcb_path).parent/'LogFiles'/'PCBLogFile.txt'
try:
with log.open('rb') as stream:
stream.seek(max(0, offset))
text = stream.read().decode('utf-8', errors='replace')
if isinstance(offset, dict):
text, recovery = read_log_failure(log, offset)
else:
# Retain the byte-offset interface for existing diagnostic callers.
with log.open('rb') as stream:
stream.seek(max(0, offset))
text = decode_log(stream.read())
recovery = parse_session_loss(text)
except Exception:
return ''
if recovery:
return recovery_detail(recovery)
for marker in ("could not bring it alive", 'Could not run server'):
if marker.lower() in text.lower():
return RESERVED_PORT_MESSAGE
return (f'DESIGN_SERVER_FAILED: {marker}。请检查本轮原生日志中的数据库/服务器原因;'
'此信息本身不能证明端口被系统保留。')
return ''
@@ -1065,6 +1118,7 @@ _INTEGRATION_ERROR_LINE = re.compile(
def pcb_log_reports_integration_error(pcb_path, *, offsets=None):
"""Read explicit Project Integration errors produced by this run."""
from .icdb_recovery import parse_session_loss, read_log_failure, recovery_detail
log_dir = Path(pcb_path).parent / 'LogFiles'
offsets = offsets or {}
details = []
@@ -1073,6 +1127,19 @@ def pcb_log_reports_integration_error(pcb_path, *, offsets=None):
try:
size = path.stat().st_size
baseline = offsets.get(path, offsets.get(str(path), 0))
has_icdb_baseline = isinstance(baseline, dict) and any(
key in baseline for key in ('icdb_baseline', 'tail_sha256', 'error'))
icdb_baseline = baseline.get('icdb_baseline', baseline) if isinstance(baseline, dict) else None
if icdb_baseline and 'tail_sha256' in icdb_baseline:
text, recovery = read_log_failure(path, icdb_baseline)
if recovery:
return recovery_detail(recovery)
if 'tail_sha256' in baseline:
# New bounded checkpoints can also be supplied directly.
details.extend(line.strip() for line in text.splitlines()
if _INTEGRATION_ERROR_LINE.search(line.strip())
and not parse_session_loss(line))
continue
if isinstance(baseline, dict):
baseline_size = int(baseline.get('size', 0) or 0)
baseline_mtime = baseline.get('mtime_ns')
@@ -1103,8 +1170,17 @@ def pcb_log_reports_integration_error(pcb_path, *, offsets=None):
text = stream.read().decode('utf-8', errors='replace')
except OSError:
continue
# Legacy byte offsets/digests remain accepted by offline callers.
if not has_icdb_baseline:
recovery = parse_session_loss(text)
if recovery:
return recovery_detail(recovery)
for line in text.splitlines():
cleaned = line.strip()
if has_icdb_baseline and parse_session_loss(cleaned):
# read_log_failure already rejected this retained old session.
# Do not let the generic ERROR filter promote it again.
continue
if _INTEGRATION_ERROR_LINE.search(cleaned) and cleaned not in details:
details.append(cleaned)
return ' | '.join(details[:8])
+186
View File
@@ -0,0 +1,186 @@
"""Backed-up, single-attempt recovery through the installed native tool."""
from dataclasses import dataclass
import hashlib
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import time
from uuid import uuid4
@dataclass(frozen=True)
class RepairTarget:
project: Path
database: Path
def select_repair_target(request, diagnosis):
from .verify_runner import preflight
if diagnosis.get('error_code') != 'ICDB_REPAIR_REQUIRED' or not diagnosis.get('session'):
raise ValueError('REPAIR_TARGET_UNCONFIRMED: 缺少原生失联会话信息')
if diagnosis.get('scope') == 'central_library':
raise ValueError('SHARED_DATABASE_REPAIR_UNSUPPORTED: 当前原生 Repair 入口要求 PRJ,不能改修无关的 Work 工程')
project, pcb = preflight(request)
try:
reported = Path(diagnosis.get('database_path', '')).resolve(strict=True)
except OSError as error:
raise ValueError(f'REPAIR_TARGET_UNCONFIRMED: 报错数据库路径不可用:{error}') from error
for candidate in (project, pcb.parent/'pcb.prj'):
database = candidate.parent/'database'
if (candidate.is_file() and database.resolve() == reported
and reported.is_relative_to(project.parent.resolve())):
if not (reported/'icdb.dat').is_file():
raise ValueError('REPAIR_TARGET_UNCONFIRMED: 未找到目标 icdb.dat')
return RepairTarget(candidate.resolve(), reported)
raise ValueError('REPAIR_TARGET_UNCONFIRMED: 报错数据库不属于本次工程,未猜测或改写路径')
def _hash(path):
digest = hashlib.sha256()
with path.open('rb') as stream:
for chunk in iter(lambda: stream.read(1024*1024), b''):
digest.update(chunk)
return digest.hexdigest()
def backup_project(target, destination):
"""Keep every original file, holding icdb.dat exclusively during the copy."""
import win32con, win32file, pywintypes
source = target.project.parent.resolve()
destination = Path(destination).resolve()
if destination.is_relative_to(source) or source.is_relative_to(destination):
raise ValueError('REPAIR_BACKUP_INVALID: 备份与源工程不能相互包含')
paths = list(source.rglob('*'))
if any(path.is_symlink() or path.is_junction() for path in paths):
raise ValueError('REPAIR_BACKUP_INVALID: 工程包含目录链接,不能完整备份')
if (source/'backup-manifest.json').exists():
raise ValueError('REPAIR_BACKUP_INVALID: 原工程含同名备份清单')
database_file = target.database/'icdb.dat'
try:
handle = win32file.CreateFile(str(database_file), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
except pywintypes.error as error:
raise OSError(f'REPAIR_DATABASE_IN_USE: 无法独占读取数据库:{error}') from error
try:
destination.mkdir(parents=True, exist_ok=False)
files = {}
for path in paths:
relative = path.relative_to(source)
copied = destination/relative
if path.is_dir():
copied.mkdir(parents=True, exist_ok=True)
continue
before = path.stat()
copied.parent.mkdir(parents=True, exist_ok=True)
if path == database_file:
with copied.open('wb') as stream:
while True:
try:
_, data = win32file.ReadFile(handle, 1024*1024)
except pywintypes.error as error:
if error.winerror == 38: # ERROR_HANDLE_EOF
break
raise
if not data:
break
stream.write(data)
os.utime(copied, ns=(before.st_atime_ns, before.st_mtime_ns))
digest = _hash(copied)
else:
digest = _hash(path)
shutil.copy2(path, copied)
if _hash(copied) != digest:
raise OSError(f'REPAIR_BACKUP_CHANGED: 文件副本校验失败:{path}')
after = path.stat()
if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns):
raise OSError(f'REPAIR_BACKUP_CHANGED: 备份期间源文件变化:{path}')
files[str(relative)] = {'size': before.st_size, 'sha256': digest}
if {path.relative_to(source) for path in source.rglob('*')} != {
path.relative_to(source) for path in paths}:
raise OSError('REPAIR_BACKUP_CHANGED: 备份期间工程文件集合变化')
record = {'complete': True, 'source': str(source), 'files': files}
(destination/'backup-manifest.json').write_text(json.dumps(record, ensure_ascii=False, indent=2),
encoding='utf-8')
return record
finally:
handle.Close()
def attempt_recovery(request, diagnosis, evidence_root, *, progress=None):
root = Path(evidence_root)/'native-repair'
root.mkdir(exist_ok=True)
marker = root/'attempt.json'
if marker.exists():
return {'status': 'BLOCKED', 'detail': 'REPAIR_ALREADY_ATTEMPTED', 'evidence': str(root)}
record = {'status': 'BLOCKED', 'evidence': str(root)}
try:
process_record = Path(evidence_root)/'content-check-process.json'
if process_record.is_file():
state = json.loads(process_record.read_text('utf-8')).get('status')
if state in {'RUNNING', 'RETAINED'}:
raise ValueError('IMPORTER_RELEASE_UNCONFIRMED: 内容检查客户端仍占有数据库,未尝试 Repair')
with marker.open('x', encoding='utf-8') as stream:
json.dump({'status': 'PREPARING', 'diagnosis': diagnosis}, stream, ensure_ascii=False)
target = select_repair_target(request, diagnosis)
if progress:
progress({'stage': 'native_repair_start', 'block': request.block_name,
'detail': '正在备份并尝试原生数据库修复', 'project': str(target.project)})
from .mentor_adapter import pcb_processes, _process_details
if pcb_processes() or _process_details('LibraryManager.exe'):
raise ValueError('REPAIR_DATABASE_IN_USE: 原生 PCB/Library Manager 会话尚未退出')
for _pid, _exe, command, _parent in _process_details('cscript.exe'):
if str(target.project).casefold() in str(command).casefold():
raise ValueError('REPAIR_DATABASE_IN_USE: 目标的保存/关闭助手尚未退出')
callback = (lambda event: progress({'block': request.block_name, **event})) if progress else None
record = run_native_repair(target, root, mentor_bin=request.mentor_bin,
timeout_seconds=max(60, request.timeout_seconds), progress=callback)
except Exception as error:
record['detail'] = str(error)
marker.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8')
return record
def run_native_repair(target, root, *, mentor_bin='', timeout_seconds=300, progress=None):
"""Supervise the GUI on its own desktop; a repair timeout never kills it."""
from .desktop_worker import DesktopWorker
root = Path(root)
root.mkdir(parents=True, exist_ok=True)
job_path = root/'repair-request.json'
cancel = root/'cancel-repair.signal'
desktop = 'CbbRepair_'+uuid4().hex[:12]
job_path.write_text(json.dumps({'project': str(target.project), 'database': str(target.database),
'root': str(root), 'mentor_bin': str(mentor_bin or ''), 'timeout': timeout_seconds,
'cancel_signal': str(cancel), 'supervisor_pid': os.getpid(), 'desktop': desktop},
ensure_ascii=False), encoding='utf-8')
command = ([sys.executable] if getattr(sys, 'frozen', False) else
[sys.executable, '-m', 'cbb_refresh_verify']) + ['--repair-worker', str(job_path)]
worker = DesktopWorker(command, desktop)
worker.bind_cancellation(cancel)
deadline = time.monotonic()+max(1, float(timeout_seconds))+5
event_count = 0
try:
while worker.poll() is None and time.monotonic()<deadline:
event_file = root/'repair-events.jsonl'
if progress and event_file.is_file():
lines = event_file.read_text('utf-8').splitlines()
for line in lines[event_count:]:
try:
progress(json.loads(line))
except json.JSONDecodeError:
break
event_count += 1
time.sleep(.2)
outcome = root/'repair-result.json'
if worker.poll() is None or not outcome.is_file():
worker.request_stop()
return {'status': 'RETAINED', 'worker_pid': worker.pid, 'desktop': desktop,
'detail': '原生修复尚未确认结束,保留操作并停止批次', 'evidence': str(root)}
result = json.loads(outcome.read_text('utf-8'))
if worker.returncode != 0 and result.get('status') == 'REPAIRED':
result['status'] = 'UNCONFIRMED'
return {**result, 'evidence': str(root)}
finally:
worker.close()
+225
View File
@@ -0,0 +1,225 @@
"""Drive the installed Project Backup Repair command on a private desktop."""
import ctypes
from ctypes import wintypes
import json
import ntpath
from pathlib import Path
import re
import subprocess
import time
import zipfile
def confirmation_allowed(main_title, project, text):
title = main_title.removeprefix('iCDB Project Backup - ')
if ntpath.normcase(ntpath.normpath(title)) != ntpath.normcase(ntpath.normpath(str(project))):
return False
normalized = ' '.join(text.casefold().split())
return all(marker in normalized for marker in (
'the project content will be validated and repaired if necessary.',
'a project backup will be created before any action take place.',
'you will be able to revert all changes using that backup.'))
def repair_completed(diagnostic_text, database_text, *, native_backup):
combined = diagnostic_text+'\n'+database_text
if re.search(r'\bERROR\s*:|not repaired|repair.*failed', combined, re.IGNORECASE):
return False
return bool(native_backup and 'Diagnostic: FINISH' in diagnostic_text
and ('Diagnostic: Snapshot:' in diagnostic_text or 'Diagnostic: START' in diagnostic_text)
and 'iCDBProjectBackupRepair' in database_text and 'IC: Closing project' in database_text)
def _current_desktop_name():
kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
user32 = ctypes.WinDLL('user32', use_last_error=True)
kernel32.GetCurrentThreadId.restype = wintypes.DWORD
user32.GetThreadDesktop.argtypes = [wintypes.DWORD]
user32.GetThreadDesktop.restype = wintypes.HANDLE
user32.GetUserObjectInformationW.argtypes = [wintypes.HANDLE, ctypes.c_int,
wintypes.LPVOID, wintypes.DWORD, ctypes.POINTER(wintypes.DWORD)]
desktop = user32.GetThreadDesktop(kernel32.GetCurrentThreadId())
name = ctypes.create_unicode_buffer(512)
required = wintypes.DWORD()
if not user32.GetUserObjectInformationW(desktop, 2, name, ctypes.sizeof(name), ctypes.byref(required)):
raise ctypes.WinError(ctypes.get_last_error())
return name.value
def _repair_command(executable):
import win32api, win32gui, win32con
user32 = ctypes.WinDLL('user32')
user32.GetMenuStringW.argtypes = [wintypes.HMENU, wintypes.UINT, wintypes.LPWSTR,
ctypes.c_int, wintypes.UINT]
library = win32api.LoadLibraryEx(str(executable), 0, 2) # data resources only
commands = set()
def walk(menu, parents=()):
for index in range(win32gui.GetMenuItemCount(menu)):
value = ctypes.create_unicode_buffer(512)
user32.GetMenuStringW(menu, index, value, len(value), win32con.MF_BYPOSITION)
label = value.value.replace('&', '').split('\t')[0].strip().casefold()
sub = win32gui.GetSubMenu(menu, index)
if sub:
walk(sub, (*parents, label))
elif parents == ('project',) and label == 'repair':
commands.add(win32gui.GetMenuItemID(menu, index))
try:
for name in win32api.EnumResourceNames(library, 4):
menu = win32gui.LoadMenu(library, name)
try:
walk(menu)
finally:
win32gui.DestroyMenu(menu)
finally:
win32api.FreeLibrary(library)
if len(commands) != 1:
raise ValueError('NATIVE_REPAIR_UNSUPPORTED: 未唯一定位原生 Project/Repair 菜单')
return commands.pop()
def _windows(pid):
import win32gui, win32process
windows = []
def observe(hwnd, _):
if win32process.GetWindowThreadProcessId(hwnd)[1] != pid or not win32gui.IsWindowVisible(hwnd):
return
children = []
def child(handle, _):
if win32gui.IsWindowVisible(handle):
children.append({'hwnd': handle, 'text': win32gui.GetWindowText(handle),
'class': win32gui.GetClassName(handle), 'id': win32gui.GetDlgCtrlID(handle),
'enabled': bool(win32gui.IsWindowEnabled(handle))})
win32gui.EnumChildWindows(hwnd, child, None)
windows.append({'hwnd': hwnd, 'title': win32gui.GetWindowText(hwnd),
'class': win32gui.GetClassName(hwnd), 'enabled': bool(win32gui.IsWindowEnabled(hwnd)),
'children': children})
win32gui.EnumWindows(observe, None)
return windows
def _native_evidence(project, database, pid, started_ns, baseline):
"""Use only this native process's new diagnostic/close and backup evidence."""
def read_logs(folder):
text = []
for path in (database/'cdbsvr'/folder).glob(f'*-{pid}/*.txt'):
if path.stat().st_mtime_ns >= started_ns:
text.append(path.read_bytes()[-256*1024:].decode('utf-8', errors='replace'))
return '\n'.join(text)
from .icdb_recovery import read_log_failure
backup_log = project.parent/'Log Files/ProjectBackupLog.txt'
text, _ = read_log_failure(backup_log, baseline)
matches = re.findall(r'Successfully created \[Project Repair\] backup \[([^\]]+)\]', text)
native_backup = False
for name in matches:
# Native default storage verified here; alternate storage needs its own
# target/backup validation and must not silently become success.
if Path(name).name != name:
continue
archive = project.parent/'ProjectBackup/backups'/name
if archive.is_file():
with zipfile.ZipFile(archive) as zipped:
native_backup = bool(zipped.namelist()) and zipped.testzip() is None
diagnostic, db_log = read_logs('dbcheck'), read_logs('log')
restore_log = read_logs('dbrestore')
restored = re.search(r'iCDB database restored from backup:\s*([^\r\n]+)', restore_log)
valid = (not restored and str(database).casefold() in db_log.casefold()
and repair_completed(diagnostic, db_log, native_backup=native_backup))
return {'confirmed': bool(valid), 'native_backup': native_backup,
'diagnostic_tail': diagnostic[-8192:], 'database_tail': db_log[-8192:],
'restored_from_backup': restored.group(1).strip() if restored else '',
'restore_complete': bool(restored and '[0] DONE' in restore_log
and 'Diagnostic: FINISH' in diagnostic),
'restore_tail': restore_log[-8192:]}
def repair_worker_main(job_path):
import win32con, win32gui
from .native_repair import RepairTarget, backup_project
from .mentor_paths import discover_sdd_home
from .icdb_recovery import snapshot_log
job = json.loads(Path(job_path).read_text('utf-8'))
root = Path(job['root'])
project, database = Path(job['project']), Path(job['database'])
result = {'status': 'BLOCKED', 'project': str(project), 'database': str(database)}
process = None
def emit(**event):
with (root/'repair-events.jsonl').open('a', encoding='utf-8') as stream:
stream.write(json.dumps(event, ensure_ascii=False)+'\n')
try:
if (not str(job.get('desktop', '')).startswith('CbbRepair_')
or _current_desktop_name() != job['desktop']):
raise ValueError('REPAIR_PRIVATE_DESKTOP_REQUIRED')
if not job.get('supervisor_pid'):
raise ValueError('REPAIR_SUPERVISOR_REQUIRED')
from .desktop_worker import start_supervisor_watchdog
start_supervisor_watchdog(job['supervisor_pid'], cancel_path=job['cancel_signal'])
if project.suffix.casefold() != '.prj' or database.resolve() != (project.parent/'database').resolve():
raise ValueError('REPAIR_TARGET_UNCONFIRMED')
home = discover_sdd_home(job.get('mentor_bin'))
if home is None:
raise ValueError('NATIVE_REPAIR_UNAVAILABLE: 未找到 Mentor 安装目录')
executable = home/'iCDB/win32/bin/iCDBProjectBackup.exe'
command_id = _repair_command(executable)
from .mentor_adapter import pcb_processes, _process_details
if pcb_processes() or _process_details('LibraryManager.exe'):
raise ValueError('REPAIR_DATABASE_IN_USE')
backup_project(RepairTarget(project, database), root/'complete-backup')
emit(stage='complete_backup_verified', path=str(root/'complete-backup'))
if Path(job['cancel_signal']).exists():
raise ValueError('REPAIR_CANCELLED_AFTER_BACKUP')
baseline = snapshot_log(project.parent/'Log Files/ProjectBackupLog.txt')
started_ns = time.time_ns()
process = subprocess.Popen([str(executable), '-p', str(project)], cwd=str(project.parent))
result['native_pid'] = process.pid
emit(stage='native_started', pid=process.pid, project=str(project))
deadline = time.monotonic()+max(1, float(job['timeout']))
invoked = confirmed = closing = False
evidence = None
while process.poll() is None and time.monotonic()<deadline:
windows = _windows(process.pid)
main = next((w for w in windows if w['class'].startswith('Afx:')
and w['title'].casefold() == ('iCDB Project Backup - '+str(project)).casefold()), None)
dialogs = [w for w in windows if w['class'] == '#32770']
if not invoked and main and not dialogs and main['enabled']:
if Path(job['cancel_signal']).exists():
raise ValueError('REPAIR_CANCELLED_BEFORE_START')
win32gui.PostMessage(main['hwnd'], win32con.WM_COMMAND, command_id, 0)
invoked = True
emit(stage='native_repair_requested', command=command_id)
if invoked and not confirmed and main:
for dialog in dialogs:
text = '\n'.join(c['text'] for c in dialog['children'])
if confirmation_allowed(main['title'], project, text):
if Path(job['cancel_signal']).exists():
raise ValueError('REPAIR_CANCELLED_BEFORE_CONFIRM')
button = next((c for c in dialog['children'] if c['class'] == 'Button'
and c['id'] == 1 and c['enabled']), None)
if button:
win32gui.PostMessage(button['hwnd'], win32con.BM_CLICK, 0, 0)
confirmed = True
emit(stage='native_repair_confirmed', text=text)
if confirmed and not closing and main and not dialogs and main['enabled']:
evidence = _native_evidence(project, database, process.pid, started_ns, baseline)
if (evidence['confirmed'] or (evidence.get('restore_complete')
and evidence['native_backup']
and not (database/'cdbsvr/sAddress.adr').exists())):
win32gui.PostMessage(main['hwnd'], win32con.WM_CLOSE, 0, 0)
closing = True
emit(stage='native_repair_finished', **evidence)
time.sleep(.2)
if (closing and process.poll() == 0 and evidence and evidence.get('restore_complete')
and not (database/'cdbsvr/sAddress.adr').exists()):
result.update(status='RESTORED_REVIEW_REQUIRED', evidence=evidence,
detail='原生工具从已有备份恢复数据库;需核对恢复版本和工程内容,未自动重试校验')
elif (closing and process.poll() == 0 and evidence and evidence['confirmed']
and not (database/'cdbsvr/sAddress.adr').exists()):
result.update(status='REPAIRED', evidence=evidence)
else:
result.update(status='RETAINED' if process.poll() is None else 'UNCONFIRMED',
detail='原生 Repair 未取得完整成功/释放证据,未重试校验')
except Exception as error:
result.update(detail=str(error), status='RETAINED' if process and process.poll() is None else 'BLOCKED')
# Never terminate a repair or its database owner. Retained PID/desktop is
# reported to the parent, including unknown native prompts.
(root/'repair-result.json').write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding='utf-8')
return 0 if result['status'] == 'REPAIRED' else 1
@@ -5,8 +5,12 @@ Set app = GetObject(, "MGCPCB.Application")
Set doc = app.ActiveDocument
Set pi = doc.ProjectIntegration
If LCase(pi.ProjectFile) <> LCase(expected) Then WScript.Quit 2
If WScript.Arguments.Count > 1 Then
If LCase(doc.Name) <> LCase(WScript.Arguments(1)) Then WScript.Quit 2
End If
If pi.ForwardAnnotationStatus <> 2 Or pi.SynchCESStatus <> 2 Or pi.LoadCESStatus <> 2 Or pi.BackAnnotationStatus <> 2 Then WScript.Quit 3
WScript.Echo "VALIDATE_START"
CheckCancellation
measuredStart = Timer
Set licensing = CreateObject("MGCPCBAutomationLicensing.Application")
token = licensing.GetToken(doc.Validate(0))
@@ -14,11 +18,13 @@ doc.Validate token
LogElapsed "validate", measuredStart
WScript.Echo "LICENSE_OK"
WScript.Echo "SAVE_START"
CheckCancellation
measuredStart = Timer
operationOK = doc.Save()
LogElapsed "save", measuredStart
If Not operationOK Then WScript.Quit 4
WScript.Echo "SAVE_OK"
CheckCancellation
measuredStart = Timer
operationOK = doc.IsSaved()
LogElapsed "is_saved", measuredStart
@@ -40,6 +46,7 @@ If Not stable Then WScript.Quit 7
WScript.Echo "POST_SAVE_SYNCHRONIZED"
If Not doc.IsSaved() Then WScript.Quit 8
WScript.Echo "CLOSE_START"
CheckCancellation
measuredStart = Timer
operationOK = doc.Close(True)
LogElapsed "close", measuredStart
@@ -54,6 +61,18 @@ LogElapsed "quit", measuredStart
WScript.Echo "QUIT_OK"
Set app = Nothing
Sub CheckCancellation()
Dim fso, cancelPath
If WScript.Arguments.Count < 3 Then Exit Sub
cancelPath = WScript.Arguments(2)
If Len(cancelPath) = 0 Then Exit Sub
Set fso = CreateObject("Scripting.FileSystemObject")
If fso.FileExists(cancelPath) Then
WScript.Echo "VERIFY_CANCELLED"
WScript.Quit 9
End If
End Sub
Sub LogElapsed(phaseName, started)
Dim elapsed
elapsed = Timer - started
+9 -6
View File
@@ -315,15 +315,18 @@ class StatusBridgeServer:
except OSError:
pass
if process.poll() is None:
process.terminate()
try:
process.wait(timeout=2)
except subprocess.TimeoutExpired:
try:
process.kill()
except OSError:
pass
process.terminate()
try:
process.wait(timeout=2)
except subprocess.TimeoutExpired:
pass
try:
process.kill()
except OSError:
pass
try:
process.wait(timeout=2)
except subprocess.TimeoutExpired:
pass
@@ -0,0 +1,128 @@
"""Small, asynchronous entry point for recovery from a healthy CBB project."""
from pathlib import Path
from PySide6.QtCore import QObject, QThreadPool, Signal
from PySide6.QtWidgets import (QComboBox, QDialog, QFileDialog, QFormLayout,
QHBoxLayout, QLabel, QLineEdit, QPushButton)
from .workers import ServiceWorker
class RecoverySignals(QObject):
progress = Signal(object)
class BackupRecoveryDialog(QDialog):
started = Signal(str)
completed = Signal(str, object)
def __init__(self, names, request_factory, parent=None, *, recoverer=None):
super().__init__(parent)
self.setWindowTitle('从备份恢复 CBB')
self.resize(620, 230)
self.request_factory = request_factory
self.recoverer = recoverer
self.busy = False
self.pool = QThreadPool(self)
self.pool.setMaxThreadCount(1)
self.signals = RecoverySignals(self)
self.signals.progress.connect(self._progress)
self.block_combo = QComboBox()
self.block_combo.addItems(list(names))
self.source_edit = QLineEdit()
self.source_edit.setPlaceholderText('选择同名 CBB 完整备份中的工程 .prj')
self.browse_button = QPushButton('选择…')
self.browse_button.clicked.connect(self._browse)
self.restore_button = QPushButton('恢复并校验')
self.restore_button.clicked.connect(self._restore)
self.close_button = QPushButton('关闭')
self.close_button.clicked.connect(self.reject)
self.status_label = QLabel('使用所选备份版本恢复同名 CBB。先在库副本中验证,原工程与完整库副本会保留;需要额外磁盘空间。')
self.status_label.setWordWrap(True)
layout = QFormLayout(self)
layout.addRow('目标 CBB', self.block_combo)
source = QHBoxLayout()
source.addWidget(self.source_edit)
source.addWidget(self.browse_button)
layout.addRow('备份工程', source)
layout.addRow(self.status_label)
buttons = QHBoxLayout()
buttons.addStretch()
buttons.addWidget(self.restore_button)
buttons.addWidget(self.close_button)
layout.addRow(buttons)
def _browse(self):
path, _ = QFileDialog.getOpenFileName(self, '选择健康备份工程', '', '工程 (*.prj)')
if path:
self.source_edit.setText(path)
def _restore(self):
if self.busy:
return
source = Path(self.source_edit.text().strip())
if not source.is_file() or source.suffix.casefold() != '.prj':
self.status_label.setText('请选择有效的备份工程 .prj 文件。')
return
name = self.block_combo.currentText()
if not name:
self.status_label.setText('请选择目标 CBB。')
return
try:
request = self.request_factory(name)
recoverer = self.recoverer
if recoverer is None:
from cbb_refresh_verify.backup_recovery import recover_from_backup
recoverer = recover_from_backup
except Exception as error:
self.status_label.setText(str(error))
return
self.busy = True
self._set_enabled(False)
self.status_label.setText('正在准备恢复…')
self.started.emit(name)
self.worker = ServiceWorker(lambda: recoverer(
request, source, progress=self.signals.progress.emit))
self.worker.signals.succeeded.connect(lambda result: self._result(name, result))
self.worker.signals.failed.connect(lambda error: self._failed(name, error))
self.worker.signals.finished.connect(self._finished)
self.pool.start(self.worker)
def _set_enabled(self, enabled):
for widget in (self.block_combo, self.source_edit, self.browse_button,
self.restore_button, self.close_button):
widget.setEnabled(enabled)
def _progress(self, event):
if isinstance(event, dict):
message = event.get('message') or event.get('detail')
if message:
self.status_label.setText(str(message))
def _result(self, name, result):
if result.status == 'PASS':
message = '恢复完成,工程打开与校验通过。'
else:
message = f'恢复未通过:{result.stderr or result.stdout or result.status}'
if result.evidence_path:
message += f'\n记录:{result.evidence_path}'
self.status_label.setText(message)
self.completed.emit(name, result)
def _failed(self, name, error):
from cbb_refresh_verify.verify_runner import VerifyResult
self._result(name, VerifyResult('FAIL', stderr=f'恢复未完成:{error}', safe_to_continue=False))
def _finished(self):
self.busy = False
self._set_enabled(True)
def reject(self):
if not self.busy:
super().reject()
def closeEvent(self, event):
if self.busy:
event.ignore()
else:
super().closeEvent(event)
+153 -14
View File
@@ -8,7 +8,7 @@ from PySide6.QtCore import QObject, QThreadPool, Signal, Qt
from PySide6.QtGui import QColor, QIcon
from PySide6.QtWidgets import (QWidget, QLineEdit, QPushButton, QFormLayout,
QTextEdit, QFileDialog, QHBoxLayout, QLabel, QSpinBox, QMessageBox, QToolButton,
QTableWidget, QTableWidgetItem, QHeaderView, QCheckBox)
QTableWidget, QTableWidgetItem, QHeaderView, QCheckBox, QGroupBox, QVBoxLayout, QProgressBar)
from PySide6.QtWidgets import QStyle
try:
from dx_productivity.trial_task_center.ui.workers import ServiceWorker
@@ -79,6 +79,8 @@ class MainWindow(QWidget):
self.busy = False; self.loaded_path = None; self.stop = Event(); self.ready_names = set()
self._row_by_name = {}
self.skipped_names = set(); self.skip_reasons = {}
self._global_icdb_run = False
self._icdb_completed = 0
self.signals = ProgressSignals(self); self.signals.event.connect(self._progress)
self.lmc_edit = QLineEdit()
self.libspec_edit = QLineEdit(os.environ.get('CBB_LIBSPEC', 'EE7.9'))
@@ -112,6 +114,10 @@ class MainWindow(QWidget):
self.browse_button = QPushButton('选择'); self.browse_button.clicked.connect(self.choose_library)
self.selected_batch_button = QPushButton('批量校验已选'); self.selected_batch_button.clicked.connect(self.verify_selected)
self.batch_button = QPushButton('批量校验全部 CBB'); self.batch_button.clicked.connect(self.verify_all)
self.icdb_repair_button = QPushButton('全库 ICDB 检查与修复'); self.icdb_repair_button.clicked.connect(self.repair_icdb_all)
self.icdb_repair_button.setToolTip('重新检查所有可用 CBB,包含 Ready 项;确认工程数据库失联后备份并尝试原生修复。')
self.backup_restore_button = QPushButton('从备份恢复 CBB…')
self.backup_restore_button.clicked.connect(self.restore_backup)
self.stop_button = QPushButton('当前项完成后停止'); self.stop_button.clicked.connect(self.request_stop)
self.logs_button = QPushButton('打开日志目录'); self.logs_button.clicked.connect(self.open_logs)
self.recovery_button = QPushButton('打开异常证据'); self.recovery_button.setEnabled(False)
@@ -120,6 +126,7 @@ class MainWindow(QWidget):
self.browse_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_DirOpenIcon))
self.selected_batch_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_ArrowRight))
self.batch_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaPlay))
self.icdb_repair_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_BrowserReload))
self.stop_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaStop))
self.logs_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_DirOpenIcon))
self.recovery_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MessageBoxWarning))
@@ -128,6 +135,7 @@ class MainWindow(QWidget):
self.recovery_path = None
self.status_label = QLabel('请选择并读取中心库。校验期间可以使用其他前台应用。')
self.status_label.setWordWrap(True)
self.status_label.setMinimumHeight(self.status_label.fontMetrics().lineSpacing()*2)
self.output = QTextEdit(); self.output.setReadOnly(True)
# Integration emits repeated status snapshots. Keep the visible
# diagnostic buffer bounded so a 3,000-CBB run cannot grow the GUI
@@ -141,7 +149,25 @@ class MainWindow(QWidget):
'填写 LibSpec 与 DMS 登录配置后,会先执行一次 ReuseBlockImporter 内容检查。'))
controls = QHBoxLayout()
for widget in (self.selected_batch_button, self.batch_button, self.stop_button, self.logs_button): controls.addWidget(widget)
layout.addRow(controls); layout.addRow(self.status_label); layout.addRow(self.output)
layout.addRow(controls)
maintenance = QGroupBox('数据库维护')
maintenance_layout = QVBoxLayout(maintenance)
maintenance_row = QHBoxLayout()
maintenance_row.addWidget(self.icdb_repair_button)
description = QLabel('包含 Ready 项,逐个重新校验。确认工程数据库失联后,先备份再修复。\n共享符号库需另行处理;无法确认会话安全时停止。')
description.setWordWrap(True)
maintenance_row.addWidget(description, 1)
maintenance_layout.addLayout(maintenance_row)
maintenance_layout.addWidget(self.backup_restore_button)
self.icdb_progress = QProgressBar()
self.icdb_progress.setVisible(False)
self.icdb_phase = QLabel('')
self.icdb_phase.setWordWrap(True)
self.icdb_phase.setVisible(False)
maintenance_layout.addWidget(self.icdb_progress)
maintenance_layout.addWidget(self.icdb_phase)
layout.addRow(maintenance)
layout.addRow(self.status_label); layout.addRow(self.output)
layout.addRow(self.recovery_button)
self.lmc_edit.textChanged.connect(self._invalidate)
for field in (self.libspec_edit, self.dms_edit, self.mentor_bin_edit):
@@ -154,6 +180,8 @@ class MainWindow(QWidget):
self._release_library_lease()
self.loaded_path = None; self.mentor_lmc_path = None; self.cbb_table.setRowCount(0); self._row_by_name = {}
self.ready_names = set(); self.skipped_names = set(); self.skip_reasons = {}; self._update()
self._global_icdb_run = False
self.icdb_progress.hide(); self.icdb_phase.hide()
def _release_library_lease(self):
lease, self.library_lease = self.library_lease, None
@@ -173,6 +201,10 @@ class MainWindow(QWidget):
and self.cbb_table.item(row, 0).text() not in self.skipped_names
for row in range(self.cbb_table.rowCount())))
self.selected_batch_button.setEnabled(ready and bool(self._selected_names()))
self.icdb_repair_button.setEnabled(ready and any(
self.cbb_table.item(row, 0).text() not in self.skipped_names
for row in range(self.cbb_table.rowCount())))
self.backup_restore_button.setEnabled(ready)
for widget in (self.lmc_edit, self.browse_button, self.load_button, self.cbb_table,
self.timeout_spin, self.advanced_toggle, self.advanced_panel):
widget.setEnabled(not self.busy)
@@ -192,6 +224,8 @@ class MainWindow(QWidget):
def load_library(self):
if self.busy or not self.lmc_edit.text(): return
self._global_icdb_run = False
self.icdb_progress.hide(); self.icdb_phase.hide()
self._release_library_lease()
self.loaded_path = None; self.cbb_table.setRowCount(0); self._row_by_name = {}; self.ready_names = set()
self.skipped_names = set(); self.skip_reasons = {}
@@ -223,10 +257,9 @@ class MainWindow(QWidget):
skip_reasons = {}
if not result.error:
for record in result.records:
if record.status != 'READY':
reason = preflight_skip_reason(mentor_path, record.name)
if reason:
skip_reasons[record.name] = reason
reason = preflight_skip_reason(mentor_path, record.name)
if reason:
skip_reasons[record.name] = reason
return result, skip_reasons, lease, mentor_path
except Exception:
if 'lease' in locals():
@@ -245,7 +278,7 @@ class MainWindow(QWidget):
self.mentor_lmc_path = mentor_path
self.loaded_path = path
self.cbb_table.setRowCount(0)
self.ready_names = {r.name for r in result.records if r.status == 'READY'}
self.ready_names = {r.name for r in result.records if r.status == 'READY' and r.name not in skip_reasons}
self.skip_reasons = dict(skip_reasons)
self.skipped_names = set(skip_reasons)
# Populating a large library emits itemChanged for every cell.
@@ -274,7 +307,7 @@ class MainWindow(QWidget):
# synchronously in this GUI callback, making large libraries
# appear frozen. The verify worker performs it when queued.
self.cbb_table.setItem(row, 3, QTableWidgetItem('未检查'))
if record.status == 'READY':
if record.status == 'READY' and record.name not in self.skipped_names:
self._mark_row_ready(row)
elif record.name in self.skipped_names:
self.cbb_table.item(row, 0).setToolTip(self.skip_reasons[record.name])
@@ -326,24 +359,97 @@ class MainWindow(QWidget):
names = [self.cbb_table.item(row, 0).text() for row in range(self.cbb_table.rowCount())]
self._run([name for name in names if name not in self.ready_names and name not in self.skipped_names])
def _run(self, names):
def repair_icdb_all(self):
if self.busy or not self.loaded_path: return
names = [name for name in names if name not in self.ready_names and name not in self.skipped_names]
names = [self.cbb_table.item(row, 0).text() for row in range(self.cbb_table.rowCount())
if self.cbb_table.item(row, 0).text() not in self.skipped_names]
if not names: return
answer = QMessageBox.question(self, '全库 ICDB 检查与修复',
f'当前中心库:{self.loaded_path}\n\n'
f'将检查 {len(names)} 个 CBB,其中 Ready {len(self.ready_names)} 个;'
f'缺少工程文件跳过 {len(self.skipped_names)} 个。\n'
'操作会重新校验并保存工程。确认失联问题后,完整备份目标工程并尝试一次原生修复。\n'
'共享符号库不支持自动修复。若原生工具恢复了旧备份,需人工核对版本;'
'会话安全无法确认时停止队列。\n\n是否开始检查与修复?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if answer == QMessageBox.Yes:
self._run(names, include_ready=True)
def restore_backup(self):
if self.busy or not self.loaded_path:
return
from .backup_recovery_dialog import BackupRecoveryDialog
names = [self.cbb_table.item(row, 0).text() for row in range(self.cbb_table.rowCount())]
if not names:
return
self.backup_dialog = BackupRecoveryDialog(names, self._request, self)
row = self.cbb_table.currentRow()
if row >= 0:
self.backup_dialog.block_combo.setCurrentText(self.cbb_table.item(row, 0).text())
self.backup_dialog.started.connect(self._backup_started)
self.backup_dialog.completed.connect(self._backup_completed)
self.backup_dialog.finished.connect(lambda _code: self._finished())
self.backup_dialog.setModal(True)
self.backup_dialog.show()
def _backup_started(self, name):
self.busy = True
self._global_icdb_run = False
self.ready_names.discard(name)
row = self._row_by_name.get(name)
if row is not None:
self.cbb_table.item(row, 2).setText('恢复中 / 需确认')
self.cbb_table.item(row, 0).setFlags(
self.cbb_table.item(row, 0).flags() | Qt.ItemIsUserCheckable)
for column in range(self.cbb_table.columnCount()):
self.cbb_table.item(row, column).setBackground(QColor('#FFF8E1'))
self._update()
self.stop_button.setEnabled(False)
def _backup_completed(self, name, result):
if not result.safe_to_continue and self.library_lease is not None:
self.library_lease.retain_for_recovery()
row = self._row_by_name.get(name)
if row is not None and result.status != 'PASS':
self.cbb_table.item(row, 2).setText('未知 / 需确认')
self._progress({'block': name, 'stage': result.status, 'detail': result.stderr,
'evidence': str(result.evidence_path or '')})
def _run(self, names, *, include_ready=False):
if self.busy or not self.loaded_path: return
names = [name for name in names if (include_ready or name not in self.ready_names) and name not in self.skipped_names]
if not names:
self.status_label.setText('没有需要校验的 CBB(全部已经是绿色 / Ready)。')
self._update()
return
requests = [self._request(name) for name in names]
self._global_icdb_run = include_ready
self._icdb_completed = 0
self.icdb_progress.setVisible(include_ready)
self.icdb_phase.setVisible(include_ready)
if include_ready:
self.icdb_progress.setRange(0, len(requests))
self.icdb_progress.setValue(0)
self.icdb_progress.setFormat('已处理 %v / %m 个 CBB')
self.icdb_phase.setText('准备检查…')
self.stop.clear(); self.recovery_path = None; self.recovery_button.setEnabled(False)
self.output.clear(); self.status_label.setText(f'正在校验:共 {len(names)} 个 CBB')
self.output.clear(); self.status_label.setText(
f'正在全库 ICDB 检查与修复:共 {len(names)} 个 CBB' if include_ready
else f'正在校验:共 {len(names)} 个 CBB')
def action():
from cbb_refresh_verify.verify_runner import read_library_flag_if_available, run_verify
verifier = self.verifier or (lambda req: run_verify(
verify = self.verifier or (lambda req: run_verify(
req, progress=lambda e: self.signals.event.emit(e),
flag_reader=read_library_flag_if_available))
def verifier(req):
if include_ready:
self.signals.event.emit({'block': req.block_name, 'stage': 'icdb_check_start'})
return verify(req)
results = run_batch(requests, verifier=verifier, stop=self.stop,
progress=lambda name, result: self.signals.event.emit({'block': name, 'stage': result.status, 'detail': result.stderr, 'evidence': str(result.evidence_path or '')}))
report = write_batch_report(requests, results, self.data_root/'reports')
if include_ready:
from cbb_refresh_verify.icdb_maintenance import write_maintenance_report
write_maintenance_report(requests, results, report, self.skipped_names)
return results, report
self._start(action, self._batch_done)
@@ -353,6 +459,18 @@ class MainWindow(QWidget):
if event.get(key): line += f' | {event[key]}'
self.output.append(line)
block = event.get('block'); stage = event.get('stage')
if self._global_icdb_run:
if stage in {'PASS', 'FAIL', 'BLOCKED', 'TIMEOUT', 'SKIPPED', 'QUEUE_STOP'}:
self._icdb_completed += 1
self.icdb_progress.setValue(self._icdb_completed)
phases = {'icdb_check_start': '检查工程数据库与校验状态',
'native_repair_start': '准备完整备份与原生修复',
'complete_backup_verified': '完整备份已校验',
'native_repair_requested': '正在原生修复',
'native_repair_confirmed': '正在原生修复',
'native_repair_finished': '原生修复已结束,正在核对结果'}
if stage in phases:
self.icdb_phase.setText(f'{block or ""} · {phases[stage]}')
if block and stage in {'PASS', 'FAIL', 'BLOCKED', 'TIMEOUT', 'SKIPPED'}:
row = self._row_by_name.get(block)
if row is not None:
@@ -362,6 +480,13 @@ class MainWindow(QWidget):
self.ready_names.add(block)
self._mark_row_ready(row)
else:
if getattr(self, '_global_icdb_run', False) and stage != 'SKIPPED':
self.ready_names.discard(block)
self.cbb_table.item(row, 2).setText('未知 / 需确认')
item = self.cbb_table.item(row, 0)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
for column in range(self.cbb_table.columnCount()):
self.cbb_table.item(row, column).setBackground(QColor('#FFF8E1'))
detail = str(event.get('detail') or event.get('error') or '').strip()
label = str(stage) if not detail else f'{stage}: {detail[:96]}'
self.cbb_table.item(row, 3).setText(label)
@@ -394,11 +519,25 @@ class MainWindow(QWidget):
failed = len(results)-passed-skipped
text = (f'已结束:成功 {passed},失败 {failed},预检跳过 {len(self.skipped_names)},'
f'队列未执行 {skipped}。\n完整日志:{report}\n仅失败日志:{failure_report_path(report)}')
if self._global_icdb_run:
from cbb_refresh_verify.icdb_maintenance import maintenance_counts
counts = maintenance_counts(results)
text = ('全库 ICDB 检查已结束\n'
f'校验通过 {passed},失败/受阻 {failed},队列未执行 {skipped},预检跳过 {len(self.skipped_names)}\n'
f'原生修复完成 {counts["repaired"]},恢复备份待复核 {counts["review_required"]},'
f'修复未确认 {counts["repair_unconfirmed"]}\n'
f'完整日志:{report}\n仅失败日志:{failure_report_path(report)}')
self.icdb_phase.setText('已停止,存在待处理项目' if failed or skipped else '已完成全库检查')
if any(not result.safe_to_continue for result in results):
text += '\n未确认数据库或会话安全,已停止剩余校验。请查看恢复现场。'
self.status_label.setText(text); self.output.append(text)
status_text = text
if self._global_icdb_run:
status_text = (f'全库检查结束:通过 {passed},失败/受阻 {failed},未执行 {skipped}。\n'
f'原生修复 {counts["repaired"]},恢复备份待复核 {counts["review_required"]},'
f'修复未确认 {counts["repair_unconfirmed"]}。')
self.status_label.setText(status_text); self.output.append(text)
self.summary = QMessageBox(self)
self.summary.setWindowTitle('CBB 校验结果'); self.summary.setText(text)
self.summary.setWindowTitle('全库 ICDB 检查与修复结果' if self._global_icdb_run else 'CBB 校验结果'); self.summary.setText(text)
self.summary.setIcon(QMessageBox.Warning if failed else QMessageBox.Information)
# Modeless notification: do not force activation or steal keyboard focus.
from PySide6.QtCore import Qt
@@ -113,6 +113,8 @@ def collect_native_failure_logs(pcb_path, evidence_root, *, max_bytes=NATIVE_LOG
target = destination/(label+'-'+source.name)
target.write_bytes(data)
item.update(evidence=str(target), copied_bytes=len(data))
if label == 'pcb-logfiles' and source.name != 'ReusableBlock.txt':
_collect_icdb_recovery(source, evidence_root)
except FileNotFoundError:
item['exists'] = False
except OSError as error:
@@ -120,6 +122,23 @@ def collect_native_failure_logs(pcb_path, evidence_root, *, max_bytes=NATIVE_LOG
return _write_record(destination.parent/'native-logs.json', record)
def _collect_icdb_recovery(source, evidence_root):
"""Only promote a native error whose log changed after this launch."""
from .icdb_recovery import read_log_failure
root = Path(evidence_root)/'diagnostics'
try:
baseline = json.loads((root/'startup-log-baseline.json').read_text('utf-8'))
checkpoint = (baseline['baseline'] if baseline['source'] == str(source) else
baseline.get('integration_logs', {}).get(str(source)))
if checkpoint is None:
return
_, recovery = read_log_failure(source, checkpoint)
if recovery:
_write_record(root/'icdb-recovery.json', {**recovery, 'source': str(source)})
except (OSError, ValueError, KeyError, TypeError):
pass # Unknown freshness must not replace the original failure.
def failure_logs_main(request_path):
job = json.loads(Path(request_path).read_text(encoding='utf-8'))
+87 -34
View File
@@ -62,6 +62,7 @@ class VerifyRequest:
# it before launching Library Manager/PCB.
mapped_drive: str = ''
mapped_remote_root: str = ''
auto_repair: bool = True
@dataclass(frozen=True)
@@ -80,6 +81,7 @@ class VerifyResult:
bridge_attempts: tuple[dict, ...] = ()
timings_seconds: dict[str, float] = field(default_factory=dict)
incomplete_timing_phases: tuple[str, ...] = ()
recovery_attempts: tuple[dict, ...] = ()
def resolve_importer(mentor_bin: str | None = None) -> Path:
@@ -127,6 +129,9 @@ def classify_output(exit_code: int | None, output: str, *, timed_out: bool = Fal
"""Never invent success: PASS needs the success text and no error marker."""
if timed_out:
return 'TIMEOUT'
from .icdb_recovery import parse_session_loss
if parse_session_loss(output):
return 'FAIL'
if exit_code == 0 and SUCCESS_TEXT.search(output) and not ERROR_TEXT.search(output):
return 'PASS'
if ERROR_TEXT.search(output):
@@ -182,7 +187,7 @@ def preflight_skip_reason(lmc_file, block_name):
return ''
work = library.parent / 'ReusableBlocksLP' / str(block_name) / 'Work'
if not work.is_dir():
return ''
return f'{block_name}: 缺少 Work 工程目录'
request = VerifyRequest(library, str(block_name), library.parent / '.cbb-preflight-evidence')
try:
preflight(request)
@@ -195,38 +200,18 @@ def preflight_skip_reason(lmc_file, block_name):
return ''
def _run_process(command, timeout_seconds, cwd):
"""Run the importer, draining both pipes while it works (no pipe deadlock)."""
process = subprocess.Popen(command, cwd=str(cwd), stdout=subprocess.PIPE, stderr=subprocess.PIPE,
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
try:
stdout, stderr = process.communicate(timeout=timeout_seconds)
return process.returncode, stdout.decode('utf-8', errors='replace'), stderr.decode('utf-8', errors='replace'), False
except subprocess.TimeoutExpired:
# A timed-out importer may have spawned a child that still owns the
# pipes. Bound both tree termination and the final drain so a hung
# helper cannot turn a 30-second item timeout into an unbounded wait.
try:
subprocess.run([str(Path(os.environ.get('WINDIR', r'C:\Windows'))/'System32'/'taskkill.exe'), '/PID', str(process.pid), '/T', '/F'],
capture_output=True, timeout=5,
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
except (OSError, subprocess.TimeoutExpired):
pass
try:
process.kill()
except OSError:
pass
try:
stdout, stderr = process.communicate(timeout=5)
except subprocess.TimeoutExpired:
stdout, stderr = b'', b''
return None, stdout.decode('utf-8', errors='replace'), stderr.decode('utf-8', errors='replace'), True
def _run_process(command, timeout_seconds, cwd, *, evidence_root=None):
from .content_check import run_content_check
return run_content_check(command, timeout_seconds, cwd, evidence_root=evidence_root)
def _stop_worker(process, *, timeout=5):
"""Stop automation clients; native database owners are preserved."""
try:
process.kill()
if hasattr(process, 'request_stop'):
process.request_stop()
else:
process.kill()
except Exception:
pass
try:
@@ -277,6 +262,9 @@ def read_library_flag_with_retry(reader, library, block_name, *, attempts=3,
def classify_failure_category(detail):
text = str(detail or '')
lower = text.casefold()
from .icdb_recovery import ERROR_CODE, parse_session_loss
if ERROR_CODE.casefold() in lower or parse_session_loss(text):
return ERROR_CODE
if any(code in lower for code in (
'pcb_release_unconfirmed', 'icdb_release_unconfirmed',
'icdb_session_unconfirmed', 'pcb_session_active', 'database_recovery_required')):
@@ -526,10 +514,33 @@ def run_verify(request, *, progress=None, flag_reader=None, process_runner=None,
if not acquired:
return VerifyResult('BLOCKED', stderr='已有 CBB 校验任务运行,请等待结束。',
safe_to_continue=False)
return _run_verify_serialized(
result = _run_verify_serialized(
request, progress=progress, flag_reader=flag_reader,
process_runner=process_runner, port_check=port_check,
dialog_supervisor_factory=dialog_supervisor_factory)
if (request.auto_repair and result.status not in {'TIMEOUT', 'BLOCKED'}
and result.error_category == 'ICDB_REPAIR_REQUIRED'
and result.evidence_path):
from .native_repair import attempt_recovery
try:
diagnosis = json.loads((result.evidence_path.parent/'diagnostics/icdb-recovery.json').read_text('utf-8'))
original = result
recovery = attempt_recovery(request, diagnosis, result.evidence_path.parent, progress=progress)
recovery = {**recovery, 'original_error': original.stderr,
'original_evidence': str(original.evidence_path)}
if recovery.get('status') == 'REPAIRED':
result = _run_verify_serialized(
replace(request, auto_repair=False), progress=progress, flag_reader=flag_reader,
process_runner=process_runner, port_check=port_check,
dialog_supervisor_factory=dialog_supervisor_factory)
result = replace(result, recovery_attempts=(recovery,))
result.evidence_path.write_text(json.dumps({'block_name': request.block_name, **asdict(result)},
ensure_ascii=False, default=str, indent=2), encoding='utf-8')
except Exception as error:
result = replace(result, status='FAIL' if result.status == 'PASS' else result.status,
safe_to_continue=False,
stderr=(result.stderr+f'\nREPAIR_UNCONFIRMED: {error}').strip())
return result
finally:
if acquired:
win32event.ReleaseMutex(mutex)
@@ -554,6 +565,31 @@ def _run_verify_serialized(request, *, progress=None, flag_reader=None, process_
pass
finally:
timing.end('failure_diagnostics')
if result.status not in {'PASS', 'SKIPPED', 'QUEUE_STOP'}:
from .icdb_recovery import ERROR_CODE, RECOVERY_ACTION, parse_session_loss, recovery_detail
recovery = parse_session_loss(result.stderr)
if recovery is None and result.evidence_path:
try:
saved = json.loads(result.evidence_path.with_name('diagnostics').joinpath(
'icdb-recovery.json').read_text('utf-8'))
recovery = parse_session_loss(saved.get('native_message', ''))
except (OSError, ValueError, AttributeError):
pass
if recovery or ERROR_CODE.casefold() in result.stderr.casefold():
detail = result.stderr
if recovery and RECOVERY_ACTION not in detail:
detail = (detail + '\n' + recovery_detail(recovery)).strip()
result = replace(result, safe_to_continue=False, stderr=detail,
error_category=ERROR_CODE)
if recovery and result.evidence_path:
try:
record_path = result.evidence_path.parent/'diagnostics/icdb-recovery.json'
record_path.parent.mkdir(parents=True, exist_ok=True)
if not record_path.is_file():
record_path.write_text(json.dumps(recovery, ensure_ascii=False, indent=2),
encoding='utf-8')
except OSError:
pass
durations, unfinished = timing.snapshot()
result = replace(result, timings_seconds=durations, incomplete_timing_phases=unfinished,
error_category=(result.error_category or classify_failure_category(result.stderr)
@@ -599,7 +635,8 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
progress({'stage': 'runtime_fingerprint', 'block': request.block_name,
**fingerprint})
result_path = root/'result.json'
runner = process_runner or _run_process
runner = process_runner or (lambda command, timeout, cwd:
_run_process(command, timeout, cwd, evidence_root=root))
def finish(result):
# Only reclaim auxiliary backups after confirmed success. Failed runs
@@ -621,6 +658,17 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
finally:
timing.end('preflight')
from .icdb_ownership import unreleased_addresses
try:
addresses = unreleased_addresses(request.lmc_file, project, pcb)
if addresses:
return finish(VerifyResult('BLOCKED', safe_to_continue=False,
stderr='ICDB_SESSION_UNCONFIRMED: 原生数据库所有权未释放,未开始内容检查或校验:'
+ '; '.join(addresses)))
except OSError as error:
return finish(VerifyResult('BLOCKED', safe_to_continue=False,
stderr=f'ICDB_SESSION_UNCONFIRMED: 无法确认数据库所有权:{error}'))
content_check_enabled = bool(str(request.libspec).strip() and str(request.dms_login_config).strip())
if content_check_enabled:
try:
@@ -648,7 +696,8 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
# A contents failure or an unusable DMS must block before touching the PCB.
return finish(VerifyResult(status if status in ('FAIL', 'TIMEOUT') else 'BLOCKED',
stderr=combined.strip() or f'内容检查结果未知(退出码 {exit_code})',
stdout=stdout, report_path=report, content_check_exit_code=exit_code))
stdout=stdout, report_path=report, content_check_exit_code=exit_code,
safe_to_continue=not timed_out))
if progress:
progress({'stage': 'content_check_done', 'block': request.block_name, 'status': 'PASS'})
@@ -672,6 +721,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
'interactive_input': bool(request.interactive_input),
'native_lm_verify': bool(request.native_lm_verify),
'desktop': 'CbbVerify_' + uuid4().hex[:12],
'cancel_signal': str(root/'cancel-worker.signal'),
'start_gate': str(root/'start-worker.signal')}
job_path = root/'request.json'
job_path.write_text(json.dumps(job, ensure_ascii=False), encoding='utf-8')
@@ -702,6 +752,8 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
worker_command(job_path), None, interactive_input=True)
else:
process = DesktopWorker(worker_command(job_path), job['desktop'])
if hasattr(process, 'bind_cancellation'):
process.bind_cancellation(job['cancel_signal'])
deadline = ActivityDeadline(request.timeout_seconds)
last_activity_key = None
phase = DialogPhase.PCB_STARTING
@@ -886,10 +938,11 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
except Exception as error:
release_result = {'safe_to_continue': False, 'error': str(error)}
try:
address = Path(project).parent / 'database/cdbsvr/sAddress.adr'
if address.exists():
from .icdb_ownership import unreleased_addresses
addresses = unreleased_addresses(request.lmc_file, project, pcb)
if addresses:
release_result = {**(release_result or {}), 'safe_to_continue': False,
'icdb_address': str(address)}
'icdb_address': addresses[0], 'icdb_addresses': addresses}
except OSError as error:
close_errors.append(str(error))
if close_errors:
+190
View File
@@ -0,0 +1,190 @@
import pytest
from pathlib import Path
from cbb_refresh_verify.verify_runner import VerifyRequest, VerifyResult
def project(work, name, data):
(work/'database').mkdir(parents=True)
(work/'database/icdb.dat').write_bytes(data)
(work/'PCB/Layout').mkdir(parents=True)
(work/'PCB/Layout/LayoutDB.lyt').write_bytes(data)
(work/'PCB'/f'{name}.pcb').write_text(f'SECTION Integration\nKEY ProjectFile "..\\{name}.prj"\nENDSECTION\n')
(work/'PCB/pcb.prj').write_text('SECTION Project\nKEY CentralLibrary "old.lmc"\nENDSECTION\n')
path = work/f'{name}.prj'
path.write_text(f'SECTION Board1\nKEY RootBlock "{name}"\nKEY PCBDesignPath "PCB\\{name}.pcb"\nENDSECTION\n'
'SECTION DesignInfo\nKEY CentralLibrary "old.lmc"\nENDSECTION\n'
'SECTION iCDB\nKEY iCDBDir ".\\database"\nENDSECTION\n')
return path
@pytest.fixture
def recovery_files(tmp_path, monkeypatch):
monkeypatch.setattr(Path, 'home', lambda: tmp_path/'profile')
library = tmp_path/'target/target.lmc'
original = project(library.parent/'ReusableBlocksLP/A/Work', 'A', b'damaged')
library.write_bytes(b'library')
source = project(tmp_path/'backup/Work', 'A', b'healthy')
return VerifyRequest(library, 'A', tmp_path/'evidence'), original, source
def test_restore_checks_source_in_library_copy_then_opens_actual_target(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
pcb_project = source.parent/'PCB/pcb.prj'
pcb_project.write_text(pcb_project.read_text() +
'SECTION SecondNativeConfiguration\nKEY CentralLibrary "old.lmc"\nENDSECTION\n')
before = source.read_bytes()
calls = []
def verify(req, **kwargs):
work = req.lmc_file.parent/'ReusableBlocksLP/A/Work'
assert (work/'database/icdb.dat').read_bytes() == b'healthy'
if calls:
assert req.lmc_file == request.lmc_file
else:
assert req.lmc_file != request.lmc_file
assert not req.lmc_file.is_relative_to(request.evidence_dir)
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
calls.append(req)
assert not req.auto_repair
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'PASS'
assert len(calls) == 2
assert source.read_bytes() == before
assert (original.parent/'database/icdb.dat').read_bytes() == b'healthy'
retained = list(original.parent.parent.glob('Work.before-restore-*'))
assert len(retained) == 1
assert (retained[0]/'database/icdb.dat').read_bytes() == b'damaged'
assert list(request.evidence_dir.rglob('library-before/target.lmc'))
def test_invalid_source_does_not_touch_target(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
source.write_text(source.read_text().replace('RootBlock "A"', 'RootBlock "OTHER"'))
result = recover_from_backup(request, source, verifier=lambda *_: pytest.fail('must not verify'),
idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert '同名' in result.stderr
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_unusable_backup_never_replaces_target(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
result = recover_from_backup(request, source, verifier=lambda *a, **k:
VerifyResult('FAIL', stderr='ICDB cannot load'), idle_check=lambda *_: None)
assert result.status == 'FAIL'
assert '目标未更改' in result.stderr
assert not list(original.parent.parent.glob('Work.before-restore-*'))
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_final_open_failure_preserves_original_and_does_not_report_pass(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
calls = []
def verify(req, **kwargs):
calls.append(req)
return (VerifyResult('PASS', library_flag='GREEN') if len(calls) == 1 else
VerifyResult('FAIL', stderr='共享符号库不可用', safe_to_continue=False))
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'FAIL'
assert not result.safe_to_continue
assert '共享符号库不可用' in result.stderr
assert list(original.parent.parent.glob('Work.before-restore-*'))
def test_source_verify_must_confirm_green_and_release(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
result = recover_from_backup(request, source, verifier=lambda *a, **k:
VerifyResult('PASS', library_flag='UNKNOWN'), idle_check=lambda *_: None)
assert result.status != 'PASS'
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_external_changes_during_validation_stop_install(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
def verify(*args, **kwargs):
(original.parent/'database/icdb.dat').write_bytes(b'another-user')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status != 'PASS'
assert '变化' in result.stderr
assert (original.parent/'database/icdb.dat').read_bytes() == b'another-user'
@pytest.mark.parametrize('field', ['ProjectFile', 'iCDBDir'])
def test_absolute_source_references_are_rejected_before_native_open(recovery_files, field):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
if field == 'ProjectFile':
path = source.parent/'PCB/A.pcb'
path.write_text(f'SECTION Integration\nKEY ProjectFile "{source}"\nENDSECTION\n')
else:
source.write_text(source.read_text().replace('".\\database"', f'"{source.parent / "database"}"'))
result = recover_from_backup(request, source, verifier=lambda *a, **k:
pytest.fail('must not launch native against source'), idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert '相对' in result.stderr
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_idle_guard_queries_supported_native_process_names(recovery_files, monkeypatch):
import win32com.client
from cbb_refresh_verify.backup_recovery import _idle_check
request, original, source = recovery_files
queries = []
class EmptyProcesses:
def ExecQuery(self, query):
queries.append(query)
return []
monkeypatch.setattr(win32com.client, 'GetObject', lambda _: EmptyProcesses())
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
assert any("Name='viewdraw.exe'" in query for query in queries)
def test_copy_refuses_directory_junction_before_copying(tmp_path):
import subprocess
from cbb_refresh_verify.backup_recovery import _copy_verified
source = tmp_path/'source'; source.mkdir()
outside = tmp_path/'outside'; outside.mkdir()
(outside/'sentinel').write_bytes(b'do not copy or modify')
linked = source/'linked'
result = subprocess.run(['cmd', '/c', 'mklink', '/J', str(linked), str(outside)], capture_output=True)
assert result.returncode == 0
with pytest.raises(ValueError, match='链接'):
_copy_verified(source, tmp_path/'destination')
assert not (tmp_path/'destination').exists()
assert (outside/'sentinel').read_bytes() == b'do not copy or modify'
def test_target_native_verification_keeps_selected_library_alias(recovery_files):
import subprocess
from dataclasses import replace
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
alias = request.lmc_file.parent.with_name('selected-library')
made = subprocess.run(['cmd', '/c', 'mklink', '/J', str(alias), str(request.lmc_file.parent)], capture_output=True)
assert made.returncode == 0
selected = alias/request.lmc_file.name
calls = []
def verify(req, **kwargs):
calls.append(req.lmc_file)
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(replace(request, lmc_file=selected), source,
verifier=verify, idle_check=lambda *_: None)
assert result.status == 'PASS'
assert calls[-1] == selected
def test_equivalent_library_reference_preserves_native_project_bytes_and_date(recovery_files):
from cbb_refresh_verify.backup_recovery import _align_library
request, original, source = recovery_files
original.write_text(original.read_text().replace('old.lmc', '../../../target.lmc'))
before = original.read_bytes(), original.stat().st_mtime_ns
_align_library(original, original.parent/'PCB/A.pcb', request.lmc_file)
assert (original.read_bytes(), original.stat().st_mtime_ns) == before
+90
View File
@@ -0,0 +1,90 @@
from pathlib import Path
from threading import Event
from cbb_refresh_verify.verify_runner import VerifyRequest, VerifyResult
def test_backup_dialog_requires_a_project_and_passes_selected_target(qtbot, tmp_path):
from cbb_refresh_verify.ui.backup_recovery_dialog import BackupRecoveryDialog
calls = []
def recover(request, source, **kwargs):
calls.append((request.block_name, source))
return VerifyResult('PASS', stdout='restored')
dialog = BackupRecoveryDialog(('A', 'B'),
lambda name: VerifyRequest(tmp_path/'target.lmc', name, tmp_path/'evidence'),
recoverer=recover)
qtbot.addWidget(dialog)
dialog.restore_button.click()
assert not calls
assert '备份' in dialog.status_label.text()
source = tmp_path/'B.prj'; source.touch()
dialog.block_combo.setCurrentText('B')
dialog.source_edit.setText(str(source))
dialog.restore_button.click()
qtbot.waitUntil(lambda: not dialog.busy)
assert calls == [('B', source)]
assert '通过' in dialog.status_label.text()
def test_backup_dialog_keeps_ui_responsive_and_cannot_close_during_restore(qtbot, tmp_path):
from cbb_refresh_verify.ui.backup_recovery_dialog import BackupRecoveryDialog
entered, release = Event(), Event()
def recover(*args, **kwargs):
entered.set(); release.wait(3)
return VerifyResult('FAIL', stderr='共享符号库不可用', safe_to_continue=False)
dialog = BackupRecoveryDialog(('A',),
lambda name: VerifyRequest(tmp_path/'target.lmc', name, tmp_path/'evidence'),
recoverer=recover)
qtbot.addWidget(dialog)
source = tmp_path/'A.prj'; source.touch()
dialog.source_edit.setText(str(source)); dialog.show()
dialog.restore_button.click()
try:
qtbot.waitUntil(entered.is_set)
assert not dialog.close_button.isEnabled()
dialog.reject()
assert dialog.isVisible()
finally:
release.set()
qtbot.waitUntil(lambda: not dialog.busy)
assert '共享符号库不可用' in dialog.status_label.text()
assert dialog.close_button.isEnabled()
def test_main_window_opens_simple_dialog_and_failure_clears_ready(qtbot, tmp_path):
from cbb_refresh_verify.ui.main_window import MainWindow
from cbb_refresh_verify.library_reader import CbbRecord, LibraryReadResult
window = MainWindow(reader=lambda _: LibraryReadResult((
CbbRecord('A', 'LP', status='READY'), CbbRecord('B', 'LP'))), data_root=tmp_path)
qtbot.addWidget(window)
window.lmc_edit.setText('lib.lmc'); window.load_library()
qtbot.waitUntil(lambda: not window.busy)
window.cbb_table.selectRow(0)
window.backup_restore_button.click()
dialog = window.backup_dialog
assert dialog.isVisible()
assert dialog.block_combo.currentText() == 'A'
dialog.started.emit('A')
assert window.busy
assert 'A' not in window.ready_names
dialog.completed.emit('A', VerifyResult('FAIL', stderr='损坏'))
assert window.cbb_table.item(0, 2).text() == '未知 / 需确认'
dialog.reject()
qtbot.waitUntil(lambda: not window.busy)
def test_unhandled_worker_error_notifies_main_window_of_unsafe_result(qtbot, tmp_path):
from cbb_refresh_verify.ui.backup_recovery_dialog import BackupRecoveryDialog
def recover(*args, **kwargs):
raise OSError('磁盘写入失败')
dialog = BackupRecoveryDialog(('A',),
lambda name: VerifyRequest(tmp_path/'target.lmc', name, tmp_path/'evidence'), recoverer=recover)
qtbot.addWidget(dialog)
completed = []
dialog.completed.connect(lambda name, result: completed.append((name, result)))
source = tmp_path/'A.prj'; source.touch()
dialog.source_edit.setText(str(source)); dialog.restore_button.click()
qtbot.waitUntil(lambda: not dialog.busy)
assert len(completed) == 1
assert completed[0][0] == 'A'
assert not completed[0][1].safe_to_continue
+306
View File
@@ -0,0 +1,306 @@
import json
import os
from pathlib import Path
import subprocess
import sys
import time
import pytest
from cbb_refresh_verify import verify_runner as runner
def test_content_timeout_preserves_importer_and_native_like_child(tmp_path):
import win32api, win32con, win32process
script = tmp_path/'importer.py'
pids = tmp_path/'pids.json'
script.write_text(
'import subprocess,sys,time,os,json\nfrom pathlib import Path\n'
'child=subprocess.Popen([sys.executable,"-c","import time;time.sleep(30)"],'
'stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)\n'
f'Path({str(pids)!r}).write_text(json.dumps([os.getpid(),child.pid]))\n'
'time.sleep(30)\n', encoding='utf-8')
handles = []
try:
result = runner._run_process([sys.executable, str(script)], 2, tmp_path)
assert result[3] is True
assert pids.is_file()
for pid in json.loads(pids.read_text()):
try:
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION |
win32con.PROCESS_TERMINATE, False, pid)
except Exception:
pytest.fail(f'Timeout terminated database-related process {pid}')
handles.append(handle)
assert win32process.GetExitCodeProcess(handle) == 259
finally:
for handle in handles:
win32process.TerminateProcess(handle, 0)
handle.Close()
def test_content_timeout_stops_remaining_batch(tmp_path, monkeypatch):
from test_verify_runner import fixture, request
fixture(tmp_path)
monkeypatch.setattr(runner, 'resolve_importer', lambda *_: Path('ReuseBlockImporter.exe'))
calls = []
def timeout(*args):
calls.append(args)
return None, '', 'content check still running', True
req = request(tmp_path, libspec='EE', dms_login_config='login')
results = runner.run_batch([req, req], verifier=lambda item: runner.run_verify(item,
process_runner=timeout, port_check=lambda: pytest.fail('PCB must not start')))
assert len(calls) == 1
assert results[0].status == 'TIMEOUT'
assert results[0].safe_to_continue is False
assert results[1].status == 'SKIPPED'
@pytest.mark.parametrize('identity,close_ok,other_document,expected_code', [
(True, True, False, 0), (False, True, False, 2), (True, False, False, 4), (True, True, True, 5)])
def test_failed_document_close_uses_native_discard_and_rejects_wrong_identity(
tmp_path, identity, close_ok, other_document, expected_code):
source = Path('src/cbb_refresh_verify/close_failed_block.vbs').read_text('utf-8')
classes = r'''
Dim nativeClosed
nativeClosed = False
Class FakePi
Public ProjectFile
Private Sub Class_Initialize
ProjectFile = PROJECT_VALUE
End Sub
End Class
Class FakeDoc
Public Name
Private Sub Class_Initialize
Name = "CBB.pcb"
End Sub
Public Property Get ProjectIntegration
Set ProjectIntegration = New FakePi
End Property
Public Function Validate(value)
Validate = 17
End Function
Public Function Close(saveChanges)
If saveChanges Then WScript.Quit 90
WScript.Echo "NATIVE_DISCARD_CLOSE"
nativeClosed = CLOSE_RETURN
Close = CLOSE_RETURN
End Function
End Class
Class FakeApp
Public Property Get ActiveDocument
If nativeClosed And Not OTHER_DOCUMENT Then
Set ActiveDocument = Nothing
Else
Set ActiveDocument = New FakeDoc
End If
End Property
Public Sub Quit()
WScript.Echo "NATIVE_QUIT"
End Sub
End Class
Class FakeLic
Public Function GetToken(value)
GetToken = value
End Function
End Class
'''.replace('PROJECT_VALUE', 'WScript.Arguments(0)' if identity else '"OTHER.prj"')
classes = classes.replace('CLOSE_RETURN', str(close_ok))
classes = classes.replace('OTHER_DOCUMENT', str(other_document))
source = source.replace('Option Explicit', 'Option Explicit\n'+classes)
source = source.replace('GetObject(, "MGCPCB.Application")', 'New FakeApp')
source = source.replace('CreateObject("MGCPCBAutomationLicensing.Application")', 'New FakeLic')
harness = tmp_path/'close.vbs'
harness.write_text(source, encoding='ascii')
outcome = subprocess.run([str(Path(os.environ['WINDIR'])/'SysWOW64/cscript.exe'),
'//nologo', str(harness), 'expected.prj', 'CBB.pcb'], capture_output=True, text=True, timeout=10)
assert outcome.returncode == expected_code, outcome.stderr
assert ('NATIVE_DISCARD_CLOSE' in outcome.stdout) is identity
assert ('NATIVE_QUIT' in outcome.stdout) is (identity and close_ok and not other_document)
def test_cancel_after_native_save_returns_stops_later_native_operations(tmp_path):
source = Path('src/cbb_refresh_verify/save_verified_block.vbs').read_text('utf-8')
classes = r'''
Class FakePi
Public ProjectFile, ForwardAnnotationStatus, SynchCESStatus, LoadCESStatus, BackAnnotationStatus
Private Sub Class_Initialize
ProjectFile = WScript.Arguments(0)
ForwardAnnotationStatus = 2
SynchCESStatus = 2
LoadCESStatus = 2
BackAnnotationStatus = 2
End Sub
End Class
Class FakeDoc
Public Name
Private Sub Class_Initialize
Name = "CBB.pcb"
End Sub
Public Property Get ProjectIntegration
Set ProjectIntegration = New FakePi
End Property
Public Function Validate(token)
Validate = 17
End Function
Public Function Save()
Dim fso, flag
Set fso = CreateObject("Scripting.FileSystemObject")
Set flag = fso.CreateTextFile(WScript.Arguments(2), True)
flag.Close
WScript.Sleep 120
WScript.Echo "NATIVE_SAVE_RETURNED"
Save = True
End Function
Public Function IsSaved()
IsSaved = True
End Function
Public Function Close(saveChanges)
Close = True
End Function
End Class
Class FakeApp
Public Property Get ActiveDocument
Set ActiveDocument = New FakeDoc
End Property
Public Sub Quit()
End Sub
End Class
Class FakeLic
Public Function GetToken(value)
GetToken = value
End Function
End Class
'''
source = source.replace('Option Explicit', 'Option Explicit\n'+classes)
source = source.replace('GetObject(, "MGCPCB.Application")', 'New FakeApp')
source = source.replace('CreateObject("MGCPCBAutomationLicensing.Application")', 'New FakeLic')
harness = tmp_path/'save-cancel.vbs'
harness.write_text(source, encoding='ascii')
outcome = subprocess.run([str(Path(os.environ['WINDIR'])/'SysWOW64/cscript.exe'),
'//nologo', str(harness), 'expected.prj', 'CBB.pcb', str(tmp_path/'cancel.signal')],
capture_output=True, text=True, timeout=10)
assert 'NATIVE_SAVE_RETURNED' in outcome.stdout
assert outcome.returncode == 9, outcome.stderr
assert 'VERIFY_CANCELLED' in outcome.stdout
assert 'CLOSE_OK' not in outcome.stdout
def test_worker_attempts_normal_close_after_idle_integration_failure(tmp_path, monkeypatch):
from test_verify_worker_stability import exercise_worker
from cbb_refresh_verify import mentor_adapter as adapter
job, events, execute = exercise_worker(tmp_path, monkeypatch, integration_error='packaging rejected')
closes = []
monkeypatch.setattr('cbb_refresh_verify.failed_session.close_failed_document',
lambda value, **kwargs: closes.append(value) or {'status': 'CLOSED'})
with pytest.raises(RuntimeError, match='packaging rejected'):
execute()
assert closes == [job]
assert not any(event['stage'] == 'save_start' for event in events)
def test_stop_requests_cooperative_cancel_without_terminating_busy_client(tmp_path):
calls = []
class BusyWorker:
def request_stop(self): calls.append('cancel')
def wait(self, timeout): raise TimeoutError('native Save still running')
def kill(self): calls.append('kill')
runner._stop_worker(BusyWorker(), timeout=0)
assert calls == ['cancel']
def test_status_server_close_allows_eof_cleanup_before_termination(tmp_path):
from cbb_refresh_verify.status_bridge import StatusBridgeServer
script = tmp_path/'reader.py'
marker = tmp_path/'released.txt'
script.write_text('import sys,time\nfrom pathlib import Path\n'
'for line in sys.stdin: pass\n'
'time.sleep(.1)\n'
f'Path({str(marker)!r}).write_text("native handles released")\n', encoding='utf-8')
server = StatusBridgeServer(script)
server.start()
time.sleep(.2)
server.close()
assert marker.is_file()
def test_shared_symbol_database_owner_blocks_content_check_and_pcb(tmp_path, monkeypatch):
from test_verify_runner import fixture, request
fixture(tmp_path)
address = tmp_path/'SymbolLibs/__ReusableBlocksSymb/cdbsvr/sAddress.adr'
address.parent.mkdir(parents=True)
address.write_bytes(b'unknown native owner')
req = request(tmp_path, libspec='EE', dms_login_config='login')
outcome = runner.run_verify(req, process_runner=lambda *args: pytest.fail('must not launch importer'))
assert outcome.status == 'BLOCKED'
assert outcome.safe_to_continue is False
assert '__ReusableBlocksSymb' in outcome.stderr
assert address.read_bytes() == b'unknown native owner'
def test_shared_symbol_database_must_be_released_before_pass(tmp_path, monkeypatch):
from test_verify_worker_stability import exercise_worker
from cbb_refresh_verify import mentor_adapter as adapter
job, events, execute = exercise_worker(tmp_path, monkeypatch)
original = adapter.subprocess.Popen
def helper(*args, **kwargs):
address = Path(job['lmc_file']).parent/'SymbolLibs/__ReusableBlocksSymb/cdbsvr/sAddress.adr'
address.parent.mkdir(parents=True)
address.write_bytes(b'shared owner retained')
return original(*args, **kwargs)
monkeypatch.setattr(adapter.subprocess, 'Popen', helper)
with pytest.raises(RuntimeError, match='ICDB_RELEASE_UNCONFIRMED'):
execute()
assert not any(event['stage'] == 'complete' for event in events)
def test_cooperative_supervisor_loss_keeps_pending_save_helper_alive(tmp_path):
import win32api, win32con, win32process
supervisor = subprocess.Popen([sys.executable, '-c', 'import time;time.sleep(30)'])
script, ready, cancel = tmp_path/'worker.py', tmp_path/'ready.json', tmp_path/'cancel.signal'
script.write_text('import subprocess,sys,time,json\nfrom pathlib import Path\n'
'from cbb_refresh_verify.desktop_worker import start_supervisor_watchdog,launch_save_helper\n'
f'start_supervisor_watchdog({supervisor.pid},cancel_path={str(cancel)!r})\n'
'helper=launch_save_helper([sys.executable,"-c","import time;time.sleep(30)"])\n'
f'Path({str(ready)!r}).write_text(json.dumps(helper.pid))\n'
'time.sleep(30)\n', encoding='utf-8')
worker = subprocess.Popen([sys.executable, str(script)])
handle = None
try:
deadline = time.monotonic()+5
while not ready.exists() and time.monotonic()<deadline:
time.sleep(.05)
assert ready.exists()
handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_TERMINATE,
False, json.loads(ready.read_text()))
supervisor.terminate()
supervisor.wait(3)
deadline = time.monotonic()+3
while not cancel.exists() and time.monotonic()<deadline:
time.sleep(.05)
assert cancel.exists()
assert worker.poll() is None
assert win32process.GetExitCodeProcess(handle) == 259
finally:
for process in (worker, supervisor):
if process.poll() is None: process.terminate()
process.wait(3)
if handle:
win32process.TerminateProcess(handle, 0)
handle.Close()
def test_idle_failed_native_verify_closes_its_library_manager_owner(tmp_path, monkeypatch):
from types import SimpleNamespace
from test_verify_worker_stability import exercise_worker
job, events, execute = exercise_worker(tmp_path, monkeypatch, integration_error='packaging rejected')
job['native_lm_verify'] = True
closed = []
monkeypatch.setattr('cbb_refresh_verify.library_manager_verify.launch_library_verify',
lambda *a, **kw: SimpleNamespace(process=SimpleNamespace(pid=11), close=lambda: closed.append(11)))
monkeypatch.setattr('cbb_refresh_verify.failed_session.close_failed_document',
lambda *a, **kw: {'status':'CLOSED'})
with pytest.raises(RuntimeError, match='packaging rejected'):
execute()
assert closed == [11]
+310
View File
@@ -0,0 +1,310 @@
import json
from pathlib import Path
import pytest
from cbb_refresh_verify import mentor_adapter as adapter
from cbb_refresh_verify import verify_runner as runner
ERROR = (
"The last server session on different server machine lost the connection\n"
"to the database. Please use iCDB Project Backup 'Repair project' functionality "
"to fix this issue. (Machine:[200091-CBB] Path:"
"[S:\\SymbolLibs\\__ReusableBlocksSymb] session:[2026-10-24 08.22.29-10308])"
)
def test_native_session_loss_has_priority_over_generic_load_and_cleanup_errors():
detail = 'DATABASE_LOAD_FAILED: Could not load Job Preferences DB\n' + ERROR
detail += '\nPCB_RELEASE_UNCONFIRMED'
assert runner.classify_failure_category(detail) == 'ICDB_REPAIR_REQUIRED'
def test_live_repair_dialog_blocks_without_clicking():
from test_dialog_rules import prompt, ASSETS
from cbb_refresh_verify.dialog_rules import decide, load_rules
from cbb_refresh_verify.dialog_supervisor import classify_dialog, DialogSnapshot, DialogControl
decision = decide(prompt(ERROR), load_rules(ASSETS/'dialog_rules.v1.json'))
legacy = classify_dialog(DialogSnapshot(1, 2, 'Expedition PCB', (
DialogControl(3, 1, 'Static', ERROR, True),)))
for item in (decision, legacy):
assert item.error_code == 'ICDB_REPAIR_REQUIRED'
assert not item.action
assert '200091-CBB' in item.detail
def test_startup_probe_reports_session_loss_instead_of_port_reset(tmp_path):
log = tmp_path/'LogFiles/PCBLogFile.txt'
log.parent.mkdir()
log.write_text(ERROR + '\nCould not run server', encoding='utf-8')
detail = adapter.pcb_log_reports_missing_server(tmp_path/'CBB.pcb')
assert 'ICDB_REPAIR_REQUIRED' in detail
assert '__ReusableBlocksSymb' in detail
assert 'Repair project' in detail
assert 'net stop winnat' not in detail
def test_generic_server_log_does_not_claim_port_reservation(tmp_path):
log = tmp_path/'LogFiles/PCBLogFile.txt'
log.parent.mkdir()
log.write_text('Could not run server', encoding='utf-8')
detail = adapter.pcb_log_reports_missing_server(tmp_path/'CBB.pcb')
assert 'DESIGN_SERVER_FAILED' in detail
assert 'WinError 10013' not in detail
assert 'net stop winnat' not in detail
@pytest.mark.parametrize('mode', ['append', 'shorter', 'same_size', 'longer'])
def test_current_run_probe_handles_appended_and_rewritten_logs(tmp_path, mode):
from cbb_refresh_verify.icdb_recovery import snapshot_log
log = tmp_path/'LogFiles/PCBLogFile.txt'
log.parent.mkdir()
old = 'old harmless text\n' if mode == 'longer' else 'x'*(len(ERROR.encode())+40)
if mode == 'same_size':
old = 'x'*len(ERROR.encode())
log.write_text(old, encoding='utf-8')
baseline = snapshot_log(log)
log.write_text(old+ERROR if mode == 'append' else ERROR, encoding='utf-8')
assert 'ICDB_REPAIR_REQUIRED' in adapter.pcb_log_reports_missing_server(
tmp_path/'CBB.pcb', offset=baseline)
def test_old_loss_record_does_not_fail_a_new_run(tmp_path):
from cbb_refresh_verify.icdb_recovery import snapshot_log
log = tmp_path/'LogFiles/PCBLogFile.txt'
log.parent.mkdir()
log.write_text(ERROR, encoding='utf-8')
baseline = snapshot_log(log)
assert adapter.pcb_log_reports_missing_server(tmp_path/'CBB.pcb', offset=baseline) == ''
with log.open('a', encoding='utf-8') as stream:
stream.write('\nNormal startup completed\n')
assert adapter.pcb_log_reports_missing_server(tmp_path/'CBB.pcb', offset=baseline) == ''
def test_rewritten_header_does_not_promote_retained_old_session_loss(tmp_path):
from cbb_refresh_verify.icdb_recovery import snapshot_log
log = tmp_path/'LogFiles/PCBLogFile.txt'
log.parent.mkdir()
log.write_text('old header\n'+ERROR, encoding='utf-8')
baseline = snapshot_log(log)
log.write_text('new header\n'+ERROR+'\nNormal startup\n', encoding='utf-8')
assert adapter.pcb_log_reports_missing_server(tmp_path/'CBB.pcb', offset=baseline) == ''
def test_repeated_old_session_loss_is_current_when_verifiably_appended(tmp_path):
from cbb_refresh_verify.icdb_recovery import snapshot_log
log = tmp_path/'LogFiles/PCBLogFile.txt'
log.parent.mkdir()
log.write_text(ERROR+'\n', encoding='utf-8')
baseline = snapshot_log(log)
with log.open('a', encoding='utf-8') as stream:
stream.write(ERROR)
assert 'ICDB_REPAIR_REQUIRED' in adapter.pcb_log_reports_missing_server(
tmp_path/'CBB.pcb', offset=baseline)
@pytest.mark.parametrize('name', ['MsgBoxResponse.log', 'ForwardAnnotation.txt', 'PartPkg.log'])
def test_integration_log_retains_multiline_loss_identity(tmp_path, name):
from cbb_refresh_verify.icdb_recovery import snapshot_log
log = tmp_path/'LogFiles'/name
log.parent.mkdir()
baseline = snapshot_log(log)
log.write_text(ERROR.replace(' (Machine:', '\nMachine:').replace(' Path:', '\nPath:')
.replace(' session:', '\nSession:'), encoding='utf-8')
detail = adapter.pcb_log_reports_integration_error(tmp_path/'CBB.pcb', offsets={log: baseline})
assert 'ICDB_REPAIR_REQUIRED' in detail
assert '200091-CBB' in detail
assert '__ReusableBlocksSymb' in detail
assert '2026-10-24 08.22.29-10308' in detail
@pytest.mark.parametrize('production_checkpoint', [False, True])
def test_integration_generic_filter_does_not_repromote_historical_repair(tmp_path, production_checkpoint):
import hashlib
from cbb_refresh_verify.icdb_recovery import snapshot_log
log = tmp_path/'LogFiles/MsgBoxResponse.log'
log.parent.mkdir()
old = 'old header\nERROR: '+ERROR.replace('\n', ' ')
log.write_text(old, encoding='utf-8')
baseline = snapshot_log(log)
if production_checkpoint:
raw = log.read_bytes()
baseline = {'size': len(raw), 'digest': hashlib.sha256(raw).hexdigest(),
'icdb_baseline': baseline}
log.write_text(old.replace('old header', 'new header')+'\nnormal startup', encoding='utf-8')
detail = adapter.pcb_log_reports_integration_error(tmp_path/'CBB.pcb', offsets={log: baseline})
assert 'ICDB_REPAIR_REQUIRED' not in detail
assert runner.classify_failure_category(detail) != 'ICDB_REPAIR_REQUIRED'
def test_unreadable_integration_baseline_never_falls_back_to_historical_log(tmp_path):
log = tmp_path/'LogFiles/MsgBoxResponse.log'
log.parent.mkdir()
log.write_text('ERROR: '+ERROR.replace('\n', ' '), encoding='utf-8')
baseline = {'size': 0, 'mtime_ns': None, 'digest': '',
'icdb_baseline': {'error': 'access denied'}}
detail = adapter.pcb_log_reports_integration_error(tmp_path/'CBB.pcb', offsets={log: baseline})
assert runner.classify_failure_category(detail) != 'ICDB_REPAIR_REQUIRED'
def test_rewrite_of_large_log_does_not_promote_error_outside_baseline_window(tmp_path):
from cbb_refresh_verify.icdb_recovery import LOG_LIMIT, snapshot_log
log = tmp_path/'LogFiles/PCBLogFile.txt'
log.parent.mkdir()
log.write_text(ERROR+'\n'+'normal\n'*LOG_LIMIT, encoding='utf-8')
baseline = snapshot_log(log)
log.write_text('changed header\n'+ERROR, encoding='utf-8')
assert adapter.pcb_log_reports_missing_server(tmp_path/'CBB.pcb', offset=baseline) == ''
def test_integration_session_loss_has_priority_over_generic_startup_error(tmp_path, monkeypatch):
from test_verify_worker_stability import exercise_worker
from cbb_refresh_verify.pcb_bridge import PcbBridgeError
job, events, execute = exercise_worker(tmp_path, monkeypatch)
def attach(job, provider, **kwargs):
logs = Path(job['pcb']).parent/'LogFiles'
logs.mkdir()
(logs/'PCBLogFile.txt').write_text('Could not run server', encoding='utf-8')
(logs/'MsgBoxResponse.log').write_text(ERROR, encoding='utf-8')
detail = kwargs['error_reader']()
assert 'ICDB_REPAIR_REQUIRED' in detail
assert 'net stop winnat' not in detail
raise PcbBridgeError('PCB_STARTUP_FAILED', detail)
monkeypatch.setattr('cbb_refresh_verify.pcb_bridge.wait_for_target_document', attach)
with pytest.raises(PcbBridgeError, match='ICDB_REPAIR_REQUIRED'):
execute()
assert not any(event['stage'] == 'save_start' for event in events)
def test_optional_baseline_evidence_write_failure_does_not_block_verify(tmp_path, monkeypatch):
from test_verify_worker_stability import exercise_worker
job, events, execute = exercise_worker(tmp_path, monkeypatch)
original = Path.write_text
def deny_baseline(path, *args, **kwargs):
if path.name == 'startup-log-baseline.json':
raise PermissionError('diagnostic evidence unavailable')
return original(path, *args, **kwargs)
monkeypatch.setattr(Path, 'write_text', deny_baseline)
assert execute()['status'] == 'PASS'
def test_recovery_record_preserves_identity_and_distinguishes_shared_library():
from cbb_refresh_verify.icdb_recovery import parse_session_loss
record = parse_session_loss(ERROR)
assert record['machine'] == '200091-CBB'
assert record['database_path'] == r'S:\SymbolLibs\__ReusableBlocksSymb'
assert record['session'] == '2026-10-24 08.22.29-10308'
assert record['scope'] == 'central_library'
assert parse_session_loss(ERROR.replace(r'S:\SymbolLibs\__ReusableBlocksSymb',
r'S:\ReusableBlocksLP\CBB\Work\database'))['scope'] == 'project'
assert parse_session_loss('Could not run server') is None
@pytest.mark.parametrize('encoding', ['utf-8', 'utf-16', 'utf-16-le'])
def test_new_utf16_or_utf8_log_errors_are_detected_after_append(tmp_path, encoding):
from cbb_refresh_verify.icdb_recovery import snapshot_log
log = tmp_path/'LogFiles/PCBLogFile.txt'
log.parent.mkdir()
log.write_bytes('old text\n'.encode(encoding))
baseline = snapshot_log(log)
with log.open('ab') as stream:
stream.write(ERROR.encode('utf-16-le' if encoding == 'utf-16' else encoding))
assert 'ICDB_REPAIR_REQUIRED' in adapter.pcb_log_reports_missing_server(
tmp_path/'CBB.pcb', offset=baseline)
@pytest.mark.parametrize('baseline_state', ['stale', 'absent', 'unreadable'])
def test_historical_log_evidence_never_creates_a_repair_recommendation(tmp_path, baseline_state):
from cbb_refresh_verify.icdb_recovery import snapshot_log
from cbb_refresh_verify.verify_diagnostics import collect_native_failure_logs
pcb = tmp_path/'Work/PCB/CBB.pcb'
log = pcb.parent/'LogFiles/PCBLogFile.txt'
log.parent.mkdir(parents=True)
log.write_text(ERROR, encoding='utf-8')
evidence = tmp_path/'evidence'
(evidence/'diagnostics').mkdir(parents=True)
if baseline_state != 'absent':
baseline = snapshot_log(log) if baseline_state == 'stale' else {'error': 'access denied'}
(evidence/'diagnostics/startup-log-baseline.json').write_text(json.dumps({
'source': str(log), 'baseline': baseline}), encoding='utf-8')
collect_native_failure_logs(pcb, evidence)
assert not (evidence/'diagnostics/icdb-recovery.json').exists()
def test_content_success_text_cannot_override_native_session_loss():
assert runner.classify_output(0, 'content checking completed successfully\n'+ERROR) == 'FAIL'
@pytest.mark.parametrize('name', ['PCBLogFile.txt', 'MsgBoxResponse.log', 'ForwardAnnotation.txt', 'PartPkg.log'])
def test_native_log_capture_generates_only_fresh_repair_evidence(tmp_path, name):
from cbb_refresh_verify.icdb_recovery import snapshot_log
from cbb_refresh_verify.verify_diagnostics import collect_native_failure_logs
pcb = tmp_path/'Work/PCB/CBB.pcb'
log = pcb.parent/'LogFiles'/name
log.parent.mkdir(parents=True)
evidence = tmp_path/'evidence'
(evidence/'diagnostics').mkdir(parents=True)
log.write_text('old text', encoding='utf-8')
(evidence/'diagnostics/startup-log-baseline.json').write_text(json.dumps({
'source': str(pcb.parent/'LogFiles/PCBLogFile.txt'),
'baseline': snapshot_log(pcb.parent/'LogFiles/PCBLogFile.txt'),
'integration_logs': {str(log): snapshot_log(log)}}), encoding='utf-8')
log.write_text(ERROR, encoding='utf-8')
collect_native_failure_logs(pcb, evidence)
report = json.loads((evidence/'diagnostics/icdb-recovery.json').read_text('utf-8'))
assert report['scope'] == 'central_library'
assert report['source'] == str(log)
assert log.read_text('utf-8') == ERROR
def test_contents_session_loss_stops_batch_before_any_pcb_launch(tmp_path, monkeypatch):
from test_verify_runner import fixture, request
fixture(tmp_path)
monkeypatch.setattr(runner, 'resolve_importer', lambda *_: Path('ReuseBlockImporter.exe'))
calls = []
def content_check(*args):
calls.append(args)
return 1, ERROR, '', False
results = runner.run_batch([request(tmp_path, libspec='EE', dms_login_config='login')]*2,
verifier=lambda req: runner.run_verify(req, process_runner=content_check,
port_check=lambda: pytest.fail('PCB must not start')))
assert len(calls) == 1
assert results[0].error_category == 'ICDB_REPAIR_REQUIRED'
assert results[0].safe_to_continue is False
assert 'Repair project' in results[0].stderr
assert results[1].status == 'SKIPPED'
def test_supervisor_enriches_generic_failure_from_fresh_native_log(tmp_path, monkeypatch):
from test_verify_runner import fixture, request
from cbb_refresh_verify.icdb_recovery import snapshot_log
from cbb_refresh_verify.verify_diagnostics import failure_logs_main
work = fixture(tmp_path)
log = work/'PCB/LogFiles/PCBLogFile.txt'
log.parent.mkdir()
class Worker:
desktop = None
returncode = 1
def __init__(self, command, *_a, **_kw):
root = Path(command[-1]).parent
(root/'diagnostics').mkdir()
(root/'diagnostics/startup-log-baseline.json').write_text(json.dumps({
'source': str(log), 'baseline': snapshot_log(log)}), encoding='utf-8')
log.write_text(ERROR, encoding='utf-8')
(root/'outcome.json').write_text(json.dumps({
'status': 'FAIL', 'stderr': 'MENTOR_DATABASE_LOAD_FAILED: opening failed',
'safe_to_continue': False}), encoding='utf-8')
def poll(self): return 1
def close(self): pass
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', Worker)
monkeypatch.setattr(runner, '_cleanup_session_processes', lambda *a, **k: {'safe_to_continue': True})
monkeypatch.setattr('cbb_refresh_verify.verify_diagnostics.capture_failure_logs_with_timeout', failure_logs_main)
result = runner.run_verify(request(tmp_path), port_check=lambda: (True, ''))
assert result.error_category == 'ICDB_REPAIR_REQUIRED'
assert result.safe_to_continue is False
assert 'opening failed' in result.stderr
assert '200091-CBB' in result.stderr
assert '__ReusableBlocksSymb' in result.stderr
assert '2026-10-24 08.22.29-10308' in result.stderr
assert json.loads(result.evidence_path.read_text('utf-8'))['error_category'] == 'ICDB_REPAIR_REQUIRED'
+266
View File
@@ -0,0 +1,266 @@
import json
from pathlib import Path
import pytest
def target_fixture(tmp_path):
from test_verify_runner import fixture, request
from cbb_refresh_verify.native_repair import select_repair_target
work = fixture(tmp_path)
database = work/'database'
database.mkdir()
(database/'icdb.dat').write_bytes(b'original damaged database')
diagnosis = {'error_code': 'ICDB_REPAIR_REQUIRED', 'machine': 'OLD-PC',
'database_path': str(database), 'session': '2026-10-24 08.22.29-10308', 'scope': 'project'}
return request(tmp_path), diagnosis, select_repair_target(request(tmp_path), diagnosis)
def test_repair_target_matches_actual_database_not_guessed_cbb_name(tmp_path):
request, record, target = target_fixture(tmp_path)
assert target.project.name == 'CBB1.prj'
assert target.database == target.project.parent/'database'
@pytest.mark.parametrize('change', ['foreign', 'shared', 'missing_session'])
def test_repair_target_rejects_unresolved_or_shared_database(tmp_path, change):
from cbb_refresh_verify.native_repair import select_repair_target
request, record, target = target_fixture(tmp_path)
if change == 'foreign': record['database_path'] = str(tmp_path/'foreign/database')
if change == 'shared':
record.update(scope='central_library', database_path=str(tmp_path/'SymbolLibs/__ReusableBlocksSymb'))
if change == 'missing_session': record['session'] = ''
with pytest.raises(ValueError):
select_repair_target(request, record)
def test_repair_backup_contains_database_locks_backups_and_original_files(tmp_path):
from cbb_refresh_verify.native_repair import backup_project
request, record, target = target_fixture(tmp_path)
for relative in ('database/cdbsvr/sAddress.adr', 'ProjectBackup/backups/old.zip',
'PCB/copy.lock', 'Log Files/ProjectBackupLog.txt'):
path = target.project.parent/relative
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(b'original '+relative.encode())
destination = tmp_path/'repair-backup'
manifest = backup_project(target, destination)
assert manifest['complete'] is True
assert (destination/'database/icdb.dat').read_bytes() == b'original damaged database'
assert (destination/'database/cdbsvr/sAddress.adr').read_bytes().startswith(b'original')
assert (destination/'ProjectBackup/backups/old.zip').is_file()
assert (destination/'PCB/copy.lock').is_file()
def test_repair_backup_refuses_database_open_by_another_client(tmp_path):
import win32file, win32con
from cbb_refresh_verify.native_repair import backup_project
request, record, target = target_fixture(tmp_path)
handle = win32file.CreateFile(str(target.database/'icdb.dat'), win32con.GENERIC_READ,
win32con.FILE_SHARE_READ, None, win32con.OPEN_EXISTING, 0, None)
try:
with pytest.raises(OSError):
backup_project(target, tmp_path/'backup')
finally:
handle.Close()
assert not (tmp_path/'backup/backup-manifest.json').exists()
def test_repair_backup_rejects_reparse_directory(tmp_path):
import _winapi
from cbb_refresh_verify.native_repair import backup_project
request, record, target = target_fixture(tmp_path)
outside = tmp_path/'outside'
outside.mkdir()
_winapi.CreateJunction(str(outside), str(target.project.parent/'linked'))
with pytest.raises(ValueError):
backup_project(target, tmp_path/'backup')
def test_native_confirmation_requires_exact_target_and_known_repair_prompt():
from cbb_refresh_verify.native_repair_ui import confirmation_allowed
assert confirmation_allowed('iCDB Project Backup - C:\\exact.prj', r'C:\exact.prj',
'The project content will be validated and repaired if necessary.\n'
'A project backup will be created before any action take place.\n'
'You will be able to revert all changes using that backup.')
assert not confirmation_allowed('iCDB Project Backup - C:\\OTHER.prj', r'C:\exact.prj',
'The project content will be validated and repaired if necessary.')
assert not confirmation_allowed('iCDB Project Backup - C:\\exact.prj', r'C:\exact.prj',
'Confirm no other clients are connected. Continue anyway?')
def test_native_diagnostics_finish_alone_does_not_prove_repair_success():
from cbb_refresh_verify.native_repair_ui import repair_completed
assert not repair_completed('Diagnostic: FINISH', 'IC: Closing project', native_backup=False)
assert not repair_completed('ERROR: invalid database\nDiagnostic: FINISH',
'iCDBProjectBackupRepair\nIC: Closing project', native_backup=True)
assert repair_completed('Diagnostic: START\nDiagnostic: FINISH',
'iCDBProjectBackupRepair\nIC: Closing project', native_backup=True)
def test_native_restore_of_old_backup_requires_review_even_when_diagnostics_finish(tmp_path):
from cbb_refresh_verify.native_repair_ui import _native_evidence
from cbb_refresh_verify.icdb_recovery import snapshot_log
project = tmp_path/'project.prj'
database = tmp_path/'database'
project.touch()
log = tmp_path/'Log Files/ProjectBackupLog.txt'
log.parent.mkdir()
baseline = snapshot_log(log)
for folder, text in (
('dbcheck', 'Diagnostic: START\nDiagnostic: FINISH'),
('dbrestore', f'iCDB database restored from backup: {tmp_path}/old.zip\n[0] DONE')):
path = database/'cdbsvr'/folder/'new-1234/log.txt'
path.parent.mkdir(parents=True)
path.write_text(text)
evidence = _native_evidence(project, database, 1234, 0, baseline)
assert evidence['restored_from_backup'] == f'{tmp_path}/old.zip'
assert evidence['restore_complete'] is True
assert evidence['confirmed'] is False
def test_automatic_repair_retries_only_once_and_preserves_original_failure(tmp_path, monkeypatch):
from dataclasses import replace
from cbb_refresh_verify import verify_runner as runner
from cbb_refresh_verify import native_repair
request, record, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(record))
original = runner.VerifyResult('FAIL', stderr='native lost session',
safe_to_continue=False, error_category='ICDB_REPAIR_REQUIRED', evidence_path=evidence)
calls = []
def verify(req, **kwargs):
calls.append(req)
return original
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: {'status':'REPAIRED'})
outcome = runner.run_verify(request)
assert len(calls) == 2
assert outcome.status == 'FAIL'
assert outcome.stderr == 'native lost session'
assert outcome.recovery_attempts[0]['original_error'] == 'native lost session'
@pytest.mark.parametrize('repair_status', ['BLOCKED', 'RESTORED_REVIEW_REQUIRED'])
def test_automatic_repair_does_not_retry_busy_or_unsupported_target(tmp_path, monkeypatch, repair_status):
from cbb_refresh_verify import verify_runner as runner
from cbb_refresh_verify import native_repair
request, record, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(record))
calls = []
def verify(req, **kwargs):
calls.append(req)
return runner.VerifyResult('FAIL', stderr='native lost session',
error_category='ICDB_REPAIR_REQUIRED', safe_to_continue=False, evidence_path=evidence)
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: {'status':repair_status})
outcome = runner.run_verify(request)
assert len(calls) == 1
assert outcome.safe_to_continue is False
assert outcome.recovery_attempts[0]['status'] == repair_status
def test_timeout_never_enters_automatic_repair(tmp_path, monkeypatch):
from cbb_refresh_verify import verify_runner as runner, native_repair
request, record, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(record))
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **kw:
runner.VerifyResult('TIMEOUT', error_category='ICDB_REPAIR_REQUIRED',
safe_to_continue=False, evidence_path=evidence))
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw:
pytest.fail('A timed-out native owner must not be repaired'))
assert runner.run_verify(request).status == 'TIMEOUT'
def test_retained_importer_blocks_repair_even_without_an_open_database_handle(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair
request, record, target = target_fixture(tmp_path)
evidence = tmp_path/'original'
evidence.mkdir()
(evidence/'content-check-process.json').write_text(json.dumps({'status':'RETAINED','pid':123}))
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **kw:
pytest.fail('Do not repair between importer transactions'))
outcome = native_repair.attempt_recovery(request, record, evidence)
assert outcome['status'] == 'BLOCKED'
assert 'IMPORTER_RELEASE_UNCONFIRMED' in outcome['detail']
def test_repair_cancellation_during_backup_prevents_native_launch(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair_ui as ui, native_repair, mentor_adapter
request, record, target = target_fixture(tmp_path)
root = tmp_path/'worker'
root.mkdir()
cancel = root/'cancel.signal'
job = root/'request.json'
job.write_text(json.dumps({'project':str(target.project),'database':str(target.database),
'root':str(root),'cancel_signal':str(cancel),'timeout':1,
'supervisor_pid':123,'desktop':'CbbRepair_test'}))
calls = []
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.start_supervisor_watchdog',
lambda *a, **kw: calls.append('watchdog'))
monkeypatch.setattr(ui, '_current_desktop_name', lambda: 'CbbRepair_test', raising=False)
monkeypatch.setattr(ui, '_repair_command', lambda *_: 32924)
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: [])
def backup(*a):
assert calls == ['watchdog'], 'Watch supervisor before the potentially long backup'
cancel.touch()
calls.append('backup')
monkeypatch.setattr(native_repair, 'backup_project', backup)
monkeypatch.setattr(ui.subprocess, 'Popen', lambda *a, **kw: pytest.fail('Repair must not start'))
assert ui.repair_worker_main(job) == 1
outcome = json.loads((root/'repair-result.json').read_text('utf-8'))
assert 'REPAIR_CANCELLED_AFTER_BACKUP' in outcome['detail']
def test_repair_worker_refuses_the_input_desktop_before_backup(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair_ui as ui, native_repair
request, record, target = target_fixture(tmp_path)
root = tmp_path/'worker'
root.mkdir()
job = root/'request.json'
job.write_text(json.dumps({'project':str(target.project),'database':str(target.database),
'root':str(root),'cancel_signal':str(root/'cancel.signal'),'timeout':1,
'supervisor_pid':123,'desktop':'CbbRepair_test'}))
monkeypatch.setattr(ui, '_current_desktop_name', lambda: 'Default', raising=False)
monkeypatch.setattr(native_repair, 'backup_project', lambda *a: pytest.fail('Input desktop repair forbidden'))
assert ui.repair_worker_main(job) == 1
assert 'REPAIR_PRIVATE_DESKTOP_REQUIRED' in json.loads((root/'repair-result.json').read_text('utf-8'))['detail']
def test_repair_worker_job_binds_supervisor_and_private_desktop(tmp_path, monkeypatch):
from cbb_refresh_verify.native_repair import run_native_repair
request, record, target = target_fixture(tmp_path)
class Worker:
returncode = 0
def __init__(self, command, desktop):
job = json.loads(Path(command[-1]).read_text('utf-8'))
assert job['supervisor_pid'] > 0
assert job['desktop'] == desktop
assert desktop.startswith('CbbRepair_')
(Path(job['root'])/'repair-result.json').write_text('{"status":"BLOCKED"}')
def poll(self): return 0
def bind_cancellation(self, path): pass
def close(self): pass
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', Worker)
assert run_native_repair(target, tmp_path/'native')['status'] == 'BLOCKED'
def test_backup_detects_a_file_added_during_the_copy(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair
request, record, target = target_fixture(tmp_path)
original = native_repair.shutil.copy2
def changed(source, destination):
result = original(source, destination)
(target.project.parent/'new-file.txt').write_bytes(b'concurrent writer')
return result
monkeypatch.setattr(native_repair.shutil, 'copy2', changed)
with pytest.raises(OSError, match='REPAIR_BACKUP_CHANGED'):
native_repair.backup_project(target, tmp_path/'backup')
+8 -2
View File
@@ -1,9 +1,10 @@
"""Production safeguards: no input injection, no desktop switching, no menu driving.
"""Production safeguards: no input injection or uncontrolled menu driving.
These asserts encode the operating rules for this tool: the user's mouse,
keyboard and desktop are never touched. Dialogs that belong to a process this
run started are answered with a posted BM_CLICK, which is a message to that
dialog and not user input.
dialog and not user input. Native Project Backup Repair is restricted to an
owned private desktop/PID, a resolved resource command and an exact PRJ.
"""
from pathlib import Path
@@ -40,6 +41,11 @@ def test_no_input_injection_or_desktop_switching_in_production_code():
for path in production_sources():
text = path.read_text(encoding='utf-8')
for api in FORBIDDEN_APIS:
if path.name == 'native_repair_ui.py' and api == 'WM_COMMAND':
# Only the installed Project Backup Repair menu is allowed:
# resolve its native resource, own the private desktop/PID,
# and confirm the exact PRJ before posting the command.
continue
if path.name == 'library_manager_verify.py' and api in {'WM_MOUSEMOVE', 'TVM_SELECTITEM'}:
continue
if path.name == 'library_manager_verify.py' and api == 'click_input':
+84
View File
@@ -20,6 +20,90 @@ def test_application_palette_keeps_table_text_readable(qtbot):
assert base.value() > 180
def fake_reader(_): return LibraryReadResult((CbbRecord('CBB1','Reusable Blocks'),))
def test_global_icdb_action_confirms_and_includes_ready_rows(qtbot, tmp_path, monkeypatch):
from PySide6.QtWidgets import QMessageBox
calls = []
window = MainWindow(reader=lambda _: LibraryReadResult((
CbbRecord('READY', 'LP', status='READY'), CbbRecord('PENDING', 'LP'))),
verifier=lambda req: (calls.append(req.block_name) or VerifyResult('PASS')),
data_root=tmp_path)
qtbot.addWidget(window)
window.lmc_edit.setText('lib.lmc'); window.load_library()
qtbot.waitUntil(lambda: not window.busy)
monkeypatch.setattr(QMessageBox, 'question', lambda *a, **k: QMessageBox.No)
window.icdb_repair_button.click()
assert calls == []
monkeypatch.setattr(QMessageBox, 'question', lambda *a, **k: QMessageBox.Yes)
window.icdb_repair_button.click()
qtbot.waitUntil(lambda: not window.busy)
assert calls == ['READY', 'PENDING']
def test_global_icdb_action_disabled_without_library_or_while_busy(qtbot):
window = MainWindow(reader=fake_reader)
qtbot.addWidget(window)
assert not window.icdb_repair_button.isEnabled()
window.lmc_edit.setText('lib.lmc'); window.load_library()
qtbot.waitUntil(lambda: not window.busy)
assert window.icdb_repair_button.isEnabled()
window.busy = True; window._update()
assert not window.icdb_repair_button.isEnabled()
def test_global_icdb_failure_clears_ready_and_stops_queue(qtbot, tmp_path, monkeypatch):
from PySide6.QtWidgets import QMessageBox
calls = []
window = MainWindow(reader=lambda _: LibraryReadResult((
CbbRecord('A', 'LP', status='READY'), CbbRecord('B', 'LP'))),
verifier=lambda req: (calls.append(req.block_name) or VerifyResult(
'FAIL', stderr='unconfirmed', safe_to_continue=False)), data_root=tmp_path)
qtbot.addWidget(window)
window.lmc_edit.setText('lib.lmc'); window.load_library()
qtbot.waitUntil(lambda: not window.busy)
monkeypatch.setattr(QMessageBox, 'question', lambda *a, **k: QMessageBox.Yes)
window.icdb_repair_button.click()
qtbot.waitUntil(lambda: not window.busy)
assert calls == ['A']
assert 'A' not in window.ready_names
assert window.cbb_table.item(0, 2).text() == '未知 / 需确认'
assert window.cbb_table.item(1, 3).text().startswith('SKIPPED')
def test_global_icdb_progress_and_repair_summary(qtbot, tmp_path, monkeypatch):
from PySide6.QtWidgets import QMessageBox
confirmations = []
def confirm(*args, **kwargs):
confirmations.append(args[2])
return QMessageBox.Yes
monkeypatch.setattr(QMessageBox, 'question', confirm)
window = MainWindow(reader=fake_reader, data_root=tmp_path,
verifier=lambda _: VerifyResult('FAIL', safe_to_continue=False, recovery_attempts=(
{'status': 'RESTORED_REVIEW_REQUIRED', 'detail': 'restored old backup'},)))
qtbot.addWidget(window)
window.lmc_edit.setText('lib.lmc'); window.load_library()
qtbot.waitUntil(lambda: not window.busy)
window.icdb_repair_button.click()
qtbot.waitUntil(lambda: not window.busy)
assert 'lib.lmc' in confirmations[0]
assert 'Ready' in confirmations[0]
assert window.icdb_progress.value() == 1
assert window.icdb_progress.maximum() == 1
assert '恢复备份待复核 1' in window.status_label.text()
assert window.summary.windowTitle() == '全库 ICDB 检查与修复结果'
reports = list((tmp_path/'reports').glob('icdb-*.json'))
assert len(reports) == 1
def test_ready_row_missing_project_is_skipped_by_global_maintenance(qtbot, tmp_path):
library = tmp_path/'library.lmc'
library.touch()
window = MainWindow(reader=lambda _: LibraryReadResult((CbbRecord('MISSING', 'LP', status='READY'),)),
data_root=tmp_path)
qtbot.addWidget(window)
window.lmc_edit.setText(str(library)); window.load_library()
qtbot.waitUntil(lambda: not window.busy)
assert window.skipped_names == {'MISSING'}
assert 'MISSING' not in window.ready_names
assert not window.icdb_repair_button.isEnabled()
assert window.cbb_table.item(0, 2).text().startswith('跳过')
def test_verify_requires_loaded_library_and_invalidates_on_path_change(qtbot):
window=MainWindow(reader=fake_reader, verifier=lambda _: VerifyResult('PASS')); qtbot.addWidget(window)
assert not window.batch_button.isEnabled()
+52
View File
@@ -0,0 +1,52 @@
"""Destructive probe restricted to a fresh copy of the local test fixture."""
from pathlib import Path
import argparse
import hashlib
import json
import shutil
from cbb_refresh_verify.native_repair import RepairTarget, run_native_repair
def main():
base = Path(__file__).resolve().parents[1]
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--output', default='icdb-corruption-probe-20261028-r2')
parser.add_argument('--without-history', action='store_true',
help='Exclude historical ProjectBackup/cdbback data from the new test copy')
args = parser.parse_args()
source = base / 'diagnostics/icdb-auto-recovery-20261027/project-copy'
root = (base/'diagnostics'/args.output).resolve()
if root.parent != (base/'diagnostics').resolve():
raise ValueError('Output must be a new direct child of the diagnostics directory')
root.mkdir(parents=True, exist_ok=False)
project_dir = root / 'project'
if any(p.is_symlink() or p.is_junction() for p in source.rglob('*')):
raise RuntimeError('Fixture contains links')
shutil.copytree(source, project_dir, ignore=(
shutil.ignore_patterns('ProjectBackup', 'cdbback') if args.without_history else None))
if args.without_history:
storage = project_dir/'ProjectBackup'
(storage/'backups').mkdir(parents=True)
shutil.copy2(source/'ProjectBackup/ProjectBackup.cfg', storage/'ProjectBackup.cfg')
if list(project_dir.rglob('*.zip')):
raise RuntimeError('Historical archives remain in the no-history test copy')
database = project_dir / 'database/icdb.dat'
original = database.read_bytes()
damaged = bytes(64) + original[64:]
database.write_bytes(damaged)
record = {'source_sha256': hashlib.sha256(original).hexdigest(),
'damaged_sha256': hashlib.sha256(damaged).hexdigest(),
'damage': 'first 64 bytes zeroed in isolated copy',
'without_historical_backups': args.without_history}
(root/'damage.json').write_text(json.dumps(record, indent=2), encoding='utf-8')
result = run_native_repair(RepairTarget(project_dir/'IP101GR.prj', database.parent),
root/'repair', timeout_seconds=180)
result['database_sha256_after'] = hashlib.sha256(database.read_bytes()).hexdigest()
result['damaged_bytes_unchanged'] = result['database_sha256_after'] == record['damaged_sha256']
(root/'probe-result.json').write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding='utf-8')
print(json.dumps(result, ensure_ascii=False))
if __name__ == '__main__':
main()
+147
View File
@@ -0,0 +1,147 @@
"""Real damaged-open / popup recovery / reopened-target comparison.
All damage and recovery are confined to a fresh diagnostics fixture. The popup
uses the production backend and native verifier without injected substitutes.
"""
from dataclasses import asdict
import argparse
import json
from pathlib import Path
import shutil
import subprocess
from cbb_refresh_verify.backup_recovery import _manifest
from cbb_refresh_verify.verify_runner import VerifyRequest, run_verify, read_library_flag_if_available
def write(path, value):
path.write_text(json.dumps(value, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('phase', choices=('setup', 'open-before', 'restore', 'compare'))
args = parser.parse_args()
base = Path(__file__).resolve().parents[1]
root = base/'diagnostics/icdb-backup-dialog-live-20261028'
library = root/'library/mentor_lib.lmc'
source = base/'diagnostics/icdb-auto-recovery-20261027/verify-library'
project = library.parent/'ReusableBlocksLP/IP101GR/Work/IP101GR.prj'
if args.phase == 'setup':
root.mkdir(parents=True, exist_ok=False)
if any(p.is_symlink() or p.is_junction() for p in source.rglob('*')):
raise ValueError('Source contains links')
copied = subprocess.run(['robocopy', str(source), str(library.parent), '/E', '/COPY:DAT',
'/DCOPY:T', '/MT:8', '/R:1', '/W:1', '/NFL', '/NDL', '/NJH', '/NJS', '/NP'],
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
(root/'copy.log').write_bytes(copied.stdout)
if copied.returncode > 7:
raise RuntimeError(f'Fixture copy failed: {copied.returncode}')
# Remove historical backups only in this new, resolved fixture Work.
for path in sorted(project.parent.rglob('*'), reverse=True):
if path.is_dir() and path.name in {'ProjectBackup', 'cdbback'}:
resolved = path.resolve()
if not resolved.is_relative_to((root/'library').resolve()):
raise ValueError('History cleanup escaped test fixture')
shutil.rmtree(resolved)
database = project.parent/'database/icdb.dat'
healthy = database.read_bytes()
if healthy[:64] == bytes(64):
raise ValueError('Fixture baseline is not healthy')
database.write_bytes(bytes(64) + healthy[64:])
write(root/'source-before.json', _manifest(source))
write(root/'setup.json', {'project': project, 'database': database,
'damage': 'First 64 bytes zeroed in isolated Work database',
'historical_backups_removed': True})
print('SETUP_DONE', flush=True)
return
request = VerifyRequest(library, 'IP101GR', root/args.phase, timeout_seconds=300, auto_repair=False)
if args.phase == 'open-before':
result = run_verify(request, progress=lambda e: print(json.dumps(e, ensure_ascii=True), flush=True),
flag_reader=read_library_flag_if_available)
write(root/'open-before.json', asdict(result))
log = project.parent/'PCB/LogFiles/PCBLogFile.txt'
if log.is_file():
(root/'open-before-PCBLogFile.txt').write_bytes(log.read_bytes())
print(json.dumps(asdict(result), default=str, ensure_ascii=True), flush=True)
return
if args.phase == 'restore':
before = json.loads((root/'open-before.json').read_text('utf-8'))
log = (root/'open-before-PCBLogFile.txt').read_text('utf-8', errors='replace')
if before['status'] != 'FAIL' or 'Database cannot be loaded' not in log:
raise ValueError('Actual damaged target opening failure must be confirmed first')
from PySide6.QtCore import QTimer, Qt
from PySide6.QtTest import QTest
from PySide6.QtWidgets import QApplication
from cbb_refresh_verify.application import configure_qt_application
from cbb_refresh_verify.ui.main_window import MainWindow
app = QApplication([]); configure_qt_application(app)
window = MainWindow(data_root=root/'data'); window.resize(1060, 860)
window.show(); window.lmc_edit.setText(str(library))
window.libspec_edit.clear(); window.dms_edit.clear()
state = {'phase': 'loading'}
def tick():
if state['phase'] == 'loading' and not window.busy:
if not window.loaded_path:
raise RuntimeError(window.status_label.text())
state['phase'] = 'restoring'
QTest.mouseClick(window.backup_restore_button, Qt.LeftButton)
dialog = window.backup_dialog
def progress(event):
print(json.dumps(event, ensure_ascii=True, default=str), flush=True)
if event.get('stage') == 'validate_source':
candidates = list((root/'data/evidence').glob('backup-restore-*/recovery-request.json'))
current = max(candidates, key=lambda p: p.stat().st_mtime_ns)
config = json.loads(current.read_text('utf-8'))
flag = read_library_flag_if_available(Path(config['validation_library']), 'IP101GR')
write(current.parent/'source-before-native-flag.json', asdict(flag))
dialog.signals.progress.connect(progress)
dialog.source_edit.setText(str(source/'ReusableBlocksLP/IP101GR/Work/IP101GR.prj'))
dialog.grab().save(str(root/'dialog-before.png'))
def done(name, result):
write(root/'restore-ui-result.json', asdict(result))
state['phase'] = 'finishing'
QTimer.singleShot(200, finish)
dialog.completed.connect(done)
QTest.mouseClick(dialog.restore_button, Qt.LeftButton)
def finish():
timer.stop()
dialog = window.backup_dialog
dialog.grab().save(str(root/'dialog-after.png'))
window.grab().save(str(root/'window-after.png'))
write(root/'ui-state.json', {'status': dialog.status_label.text(),
'target_ready': 'IP101GR' in window.ready_names, 'busy': dialog.busy})
dialog.reject(); window.close(); app.quit()
timer=QTimer(); timer.setInterval(100); timer.timeout.connect(tick)
window.load_library(); timer.start(); app.exec()
print((root/'restore-ui-result.json').read_text('utf-8'), flush=True)
return
before = json.loads((root/'open-before.json').read_text('utf-8'))
restored = json.loads((root/'restore-ui-result.json').read_text('utf-8'))
record = json.loads(Path(restored['evidence_path']).read_text('utf-8'))
final = record['result']
retained = Path(record.get('retained_work', ''))
after_evidence = Path(final['evidence_path']).parent
events = [json.loads(line) for line in (after_evidence/'events.jsonl').read_text('utf-8').splitlines()]
native_log = project.parent/'PCB/LogFiles/PCBLogFile.txt'
text = native_log.read_text('utf-8', errors='replace')
checks = {
'real_open_failed_before': before['status'] == 'FAIL' and before['error_category'] == 'MENTOR_DATABASE_LOAD_FAILED',
'source_copy_verified': record['source_validation']['status'] == 'PASS'
and record['source_validation']['library_flag'] == 'GREEN',
'same_target_opened_after': any(e.get('stage') == 'identity_verified'
and e.get('project') == str(project) for e in events),
'restored_target_passed': final['status'] == 'PASS' and final['library_flag'] == 'GREEN'
and final['safe_to_continue'],
'old_damaged_work_retained': (retained/'database/icdb.dat').read_bytes()[:64] == bytes(64),
'original_source_unchanged': _manifest(source) == json.loads((root/'source-before.json').read_text('utf-8')),
'load_error_absent_after': 'Database cannot be loaded' not in text,
}
write(root/'comparison.json', {'checks': checks, 'passed': all(checks.values())})
print(json.dumps(checks), flush=True)
if not all(checks.values()):
raise RuntimeError('Real recovery comparison failed')
if __name__ == '__main__':
main()
+99
View File
@@ -0,0 +1,99 @@
"""Exercise the real Qt button and native verifier on a fresh local fixture copy.
Run with PYTHONPATH=src. No verifier/reader stubs or synthetic errors are used.
The source library is fingerprinted before and after the run.
"""
from pathlib import Path
import hashlib
import json
import shutil
import time
from PySide6.QtCore import QTimer, Qt
from PySide6.QtTest import QTest
from PySide6.QtWidgets import QApplication, QMessageBox
from cbb_refresh_verify.application import configure_qt_application
from cbb_refresh_verify.ui.main_window import MainWindow
def fingerprint(root):
result = {}
for path in root.rglob('*'):
if path.is_symlink() or path.is_junction():
raise ValueError('Test source contains links')
if path.is_file():
with path.open('rb') as stream:
result[str(path.relative_to(root))] = hashlib.file_digest(stream, 'sha256').hexdigest()
return result
def main():
base = Path(__file__).resolve().parents[1]
source = base/'diagnostics/icdb-auto-recovery-20261027/verify-library'
root = base/'diagnostics/icdb-button-live-20261028'
root.mkdir(parents=True, exist_ok=False)
before = fingerprint(source)
(root/'source-before.json').write_text(json.dumps(before), encoding='utf-8')
library = root/'library'
shutil.copytree(source, library)
app = QApplication([])
configure_qt_application(app)
window = MainWindow(data_root=root/'data')
window.resize(1060, 820)
window.show()
window.libspec_edit.clear()
window.dms_edit.clear()
window.lmc_edit.setText(str(library/'mentor_lib.lmc'))
state = {'phase': 'loading', 'started': time.monotonic()}
def event(record):
if record.get('stage') in {'icdb_check_start', 'native_repair_start', 'PASS', 'FAIL', 'BLOCKED', 'TIMEOUT'}:
print(json.dumps(record, ensure_ascii=True), flush=True)
window.signals.event.connect(event)
def tick():
for widget in app.topLevelWidgets():
if isinstance(widget, QMessageBox) and widget.isVisible() and widget.windowTitle() == '全库 ICDB 检查与修复':
widget.grab().save(str(root/'confirmation.png'))
state['confirmation'] = widget.text()
QTest.mouseClick(widget.button(QMessageBox.Yes), Qt.LeftButton)
if state['phase'] == 'loading' and not window.busy:
if not window.loaded_path:
state.update(phase='load_failed', detail=window.status_label.text())
finish()
return
state.update(phase='running', rows=window.cbb_table.rowCount(),
ready_before=len(window.ready_names), preflight_skipped=len(window.skipped_names))
window.grab().save(str(root/'loaded.png'))
QTimer.singleShot(0, lambda: QTest.mouseClick(window.icdb_repair_button, Qt.LeftButton))
elif state['phase'] == 'running' and not window.busy and hasattr(window, 'summary'):
state.update(phase='finished', detail=window.status_label.text(), ready_after=len(window.ready_names))
window.grab().save(str(root/'finished.png'))
window.summary.grab().save(str(root/'summary.png'))
finish()
elif time.monotonic()-state['started'] > 900 and not window.stop.is_set():
window.request_stop()
def finish():
timer.stop()
after = fingerprint(source)
state.update(source_unchanged=before == after, source_file_count=len(before),
elapsed_seconds=time.monotonic()-state['started'])
(root/'outcome.json').write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding='utf-8')
print(json.dumps(state, ensure_ascii=True), flush=True)
if hasattr(window, 'summary'):
window.summary.close()
window.close()
app.quit()
timer = QTimer()
timer.setInterval(100)
timer.timeout.connect(tick)
window.load_library()
timer.start()
app.exec()
if __name__ == '__main__':
main()
+136
View File
@@ -0,0 +1,136 @@
"""Real before/repair/after test, confined to a newly cloned local fixture.
Run each phase separately so the actual native failure can be reviewed before
repair. The opening phases use the production verifier with auto repair off.
"""
import argparse
from dataclasses import asdict
import hashlib
import json
from pathlib import Path
import subprocess
from cbb_refresh_verify.native_repair import RepairTarget, run_native_repair
from cbb_refresh_verify.verify_runner import VerifyRequest, preflight, run_verify, read_library_flag_if_available
def write(path, record):
path.write_text(json.dumps(record, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
def require_released():
from cbb_refresh_verify.mentor_adapter import pcb_processes, _process_details
if pcb_processes() or _process_details('LibraryManager.exe'):
raise RuntimeError('Native PCB or Library Manager remains open; stop before repair/reopen')
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('phase', choices=('setup', 'open-before', 'repair', 'open-after', 'compare'))
parser.add_argument('--output', default='icdb-open-repair-reopen-20261028')
args = parser.parse_args()
base = Path(__file__).resolve().parents[1]
root = (base/'diagnostics'/args.output).resolve()
if root.parent != (base/'diagnostics').resolve():
raise ValueError('Output must be a direct child of diagnostics')
require_released()
if args.phase == 'setup':
root.mkdir(parents=True, exist_ok=False)
source = base/'diagnostics/icdb-auto-recovery-20261027/verify-library'
if any(p.is_symlink() or p.is_junction() for p in source.rglob('*')):
raise ValueError('Source contains directory/file links')
command = ['robocopy', str(source), str(root/'library'), '/E', '/COPY:DAT', '/DCOPY:T',
'/MT:8', '/R:1', '/W:1', '/NFL', '/NDL', '/NJH', '/NJS', '/NP']
copied = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
(root/'copy.log').write_bytes(copied.stdout)
if copied.returncode > 7:
raise RuntimeError(f'Fixture copy failed: {copied.returncode}')
request = VerifyRequest(root/'library/mentor_lib.lmc', 'IP101GR', root/'preflight')
project, pcb = preflight(request)
database = project.parent/'database/icdb.dat'
original = database.read_bytes()
if not original or original[:64] == bytes(64):
raise ValueError('Source is not a healthy baseline')
(root/'original-icdb.dat').write_bytes(original)
damaged = bytes(64)+original[64:]
database.write_bytes(damaged)
write(root/'setup.json', {'source': source, 'library': request.lmc_file,
'project': project, 'pcb': pcb, 'database': database,
'source_sha256': hashlib.sha256(original).hexdigest(),
'damaged_sha256': hashlib.sha256(damaged).hexdigest(),
'damage': 'Zero first 64 bytes in the new isolated Work database',
'auto_repair_during_open': False})
print('SETUP_DONE', flush=True)
return
config = json.loads((root/'setup.json').read_text('utf-8'))
project, database = Path(config['project']), Path(config['database'])
if not project.resolve().is_relative_to(root) or not database.resolve().is_relative_to(root):
raise ValueError('Target escaped the isolated test directory')
if args.phase == 'compare':
before = json.loads((root/'open-before.json').read_text('utf-8'))
after = json.loads((root/'open-after.json').read_text('utf-8'))
repair = json.loads((root/'repair/repair-result.json').read_text('utf-8'))
before_job = json.loads(Path(before['evidence_path']).with_name('request.json').read_text('utf-8'))
after_job = json.loads(Path(after['evidence_path']).with_name('request.json').read_text('utf-8'))
before_log = (root/'open-before-PCBLogFile.txt').read_text('utf-8', errors='replace')
after_log = (root/'open-after-PCBLogFile.txt').read_text('utf-8', errors='replace')
events = [json.loads(line) for line in
Path(after['evidence_path']).with_name('events.jsonl').read_text('utf-8').splitlines()]
source_database = Path(config['source'])/'ReusableBlocksLP/IP101GR/Work/database/icdb.dat'
checks = {
'same_project': before_job['project'] == after_job['project'] == str(project),
'same_database_repaired': repair['database'] == str(database.parent),
'native_icdb_error_confirmed_before': before['status'] == 'FAIL'
and str(database) in before_log and 'iCDB Project Backup' in before_log,
'identity_verified_after': any(e.get('stage') == 'identity_verified'
and e.get('project') == str(project) for e in events),
'opening_error_absent_after': 'Database cannot be loaded' not in after_log and not after['stderr'],
'verification_passed_after': after['status'] == 'PASS' and after['safe_to_continue']
and after['library_flag'] == 'GREEN',
'original_source_database_unchanged': hashlib.sha256(source_database.read_bytes()).hexdigest()
== config['source_sha256'],
}
result = {'checks': checks, 'comparison_passed': all(checks.values()),
'before_error_category': before['error_category'],
'native_repair_status': repair['status'],
'restored_from_backup': repair.get('evidence', {}).get('restored_from_backup', ''),
'after_library_flag': after['library_flag_detail'],
'server_session_loss_reproduced': 'last server session' in before_log.casefold()}
write(root/'comparison.json', result)
print(json.dumps(result, ensure_ascii=True), flush=True)
if not result['comparison_passed']:
raise RuntimeError('Before/repair/reopen comparison did not pass every check')
return
from cbb_refresh_verify.icdb_ownership import unreleased_addresses
addresses = unreleased_addresses(config['library'], project, config['pcb'])
if addresses:
raise RuntimeError(f'Database ownership not released: {addresses}')
if args.phase == 'repair':
before = json.loads((root/'open-before.json').read_text('utf-8'))
if before['status'] in {'PASS', 'TIMEOUT'}:
raise RuntimeError('No confirmed opening failure available for a repair comparison')
native_error = (root/'open-before-PCBLogFile.txt').read_text('utf-8', errors='replace')
if str(database).casefold() not in native_error.casefold() or 'iCDB Project Backup' not in native_error:
raise RuntimeError('Native log does not confirm an iCDB repair request for the damaged target')
result = run_native_repair(RepairTarget(project, database.parent), root/'repair', timeout_seconds=240)
write(root/'repair-summary.json', result)
else:
if args.phase == 'open-after':
repaired = json.loads((root/'repair-summary.json').read_text('utf-8'))
if repaired['status'] not in {'REPAIRED', 'RESTORED_REVIEW_REQUIRED'}:
raise RuntimeError('Repair did not reach a completed native result')
request = VerifyRequest(Path(config['library']), 'IP101GR', root/args.phase,
timeout_seconds=300, auto_repair=False)
def progress(event):
print(json.dumps(event, ensure_ascii=True, default=str), flush=True)
result = asdict(run_verify(request, progress=progress,
flag_reader=read_library_flag_if_available))
write(root/(args.phase+'.json'), result)
native_log = Path(config['pcb']).parent/'LogFiles/PCBLogFile.txt'
if native_log.is_file():
(root/(args.phase+'-PCBLogFile.txt')).write_bytes(native_log.read_bytes())
print(json.dumps(result, ensure_ascii=True, default=str), flush=True)
if __name__ == '__main__':
main()