Compare commits

..
Author SHA1 Message Date
阿白叔 0fca6abb4e Merge branch 'codex/review-native-backend' into codex/review-ui-integration 2026-11-09 14:02:14 +08:00
阿白叔 342a7266c7 fix: retire result dialogs and clarify batch lifecycle 2026-11-09 13:51:32 +08:00
阿白叔 e8a1714d95 fix: clarify backend status freshness and scoped copy evidence 2026-11-09 13:50:04 +08:00
阿白叔 e73f9c6edc Merge branch 'codex/review-native-backend' into codex/review-ui-integration 2026-11-09 10:26:13 +08:00
阿白叔 b7baa24b5e fix: identify foreign CBB checkpoints in release evidence 2026-11-09 10:26:09 +08:00
阿白叔 3c1998f2ef Merge branch 'codex/review-native-backend' into codex/review-ui-integration 2026-11-06 11:41:03 +08:00
阿白叔 807aa26baf test: guard actual reads of unrelated CBB content 2026-11-06 11:41:00 +08:00
阿白叔 8c2c60fab1 fix: distinguish native outcomes from report and item recovery status 2026-11-06 11:36:19 +08:00
阿白叔 5b22787418 Merge branch 'codex/review-native-backend' into codex/review-ui-integration 2026-11-06 11:34:27 +08:00
阿白叔 679f33b8cc fix: keep prelaunch release-probe failures from stopping independent work 2026-11-06 11:34:25 +08:00
阿白叔 746e5b5145 Merge branch 'codex/review-native-backend' into codex/review-ui-integration 2026-11-06 11:21:21 +08:00
阿白叔 8eefecd9f0 fix: reconcile historical leases and record scoped native changes 2026-11-06 11:21:15 +08:00
阿白叔 d8156c57f0 Merge remote-tracking branch 'origin/main' into codex/review-native-backend 2026-11-06 11:14:58 +08:00
abaishu0730 959399b974 Merge pull request '审查拆分 1/4:只读占用探测与可取消任务队列' (#9) from codex/review-infrastructure into main 2026-11-06 10:25:10 +08:00
abaishu0730 46dae81190 Merge pull request 'docs: CBB Verify 全量扫描与阻塞分析(关联 #4)' (#5) from docs/scan-20261104-blockers into main 2026-11-06 10:20:23 +08:00
阿白叔 282be7be7f feat: integrate independent background checks and native management UI 2026-11-05 23:25:25 +08:00
阿白叔 da67de026f feat: integrate native diagnostics and coordinated CBB transactions 2026-11-05 23:18:00 +08:00
阿白叔 9e230e1a46 feat: add bounded read-only owner probes and cooperative native queue 2026-11-05 23:04:35 +08:00
abaishu0730 a56fd17b60 Merge pull request 'fix: release private desktop resources on launch failure' (#8) from codex/desktop-leak-main into main 2026-11-05 15:23:08 +08:00
阿白叔 766d67cb57 test: enforce desktop cleanup interfaces and guard reader setup 2026-11-05 14:59:19 +08:00
阿白叔 311d0dd9a4 fix: release private desktop on worker launch failure 2026-11-05 14:47:03 +08:00
abaishu0730 3dbfca0f44 docs: record full project scan and blocker analysis (#4) 2026-11-04 15:20:37 +08:00
阿白叔 39985f7cfd chore: release v0.2.3-beta.1 2026-10-29 09:54:10 +08:00
abaishu0730 ac9836a2d5 Merge pull request '增加 ICDB 全库维护与 CBB 备份恢复弹窗,完善会话安全处理' (#1) from codex/icdb-global-repair into main
Reviewed-on: #1
2026-10-28 20:57:02 +08:00
阿白叔 cdb8a6a28b feat: add ICDB maintenance and verified CBB backup recovery dialog 2026-10-28 19:43:07 +08:00
阿白叔 a851e47eca docs: record verified iCDB recovery trial and delivery scope 2026-10-27 18:15:00 +08:00
阿白叔 9cd4968a97 fix: enforce native repair ownership and cancellation boundaries 2026-10-27 18:08:14 +08:00
阿白叔 2490067b2d fix: prevent iCDB disconnects and recover failed projects 2026-10-27 17:51:53 +08:00
阿白叔 8a517d6f38 fix: diagnose iCDB lost sessions and stop unsafe verification 2026-10-27 16:38:51 +08:00
阿白叔 a11eb3c766 fix: harden PCB and iCDB verification lifecycle for beta release 2026-10-26 15:32:01 +08:00
170 changed files with 25064 additions and 966 deletions

No files matched your search

+1
View File
@@ -28,6 +28,7 @@ venv/
/dist/
/dist-*/
/*.zip
/*.zip.sha256
/*.rar
# Native compiler intermediates; retain the two verified x86 runtime bridges
+1 -1
View File
@@ -237,7 +237,7 @@ function Invoke-CbbReuseBlockContentCheck {
$combined = @($stdout, $stderr) -join "`r`n"
[IO.File]::WriteAllText($report, $combined, [Text.UTF8Encoding]::new($false))
if ($result -eq 'unknown') {
if ($combined -match '(?i)completed successfully' -and $combined -notmatch '(?i)failed|error') {
if ($exitCode -eq 0 -and $combined -match '(?i)completed successfully' -and $combined -notmatch '(?i)failed|error') {
$result = 'pass'
}
elseif ($combined -match '(?i)failed|error|cannot connect|bad data') {
+13 -6
View File
@@ -1,7 +1,14 @@
# CBB 中心库上传后校验工具
当前补丁:**[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 入口时停止并要求人工处理。
## 功能边界
| 工具 | 处理对象 | 核心动作 | 结果 |
@@ -10,9 +17,9 @@
| `cbb-upload-795` | CBB 工程/中心库 | 复制、Packager、上传、Verify | 中心库新增或更新 CBB |
| 本工具 | 已上传到中心库的 CBB 条目 | 在 Library Manager 中执行/确认 Verify,检查条目和 CBB 状态标志 | 中心库 CBB 校验完成且结果可追溯 |
这里的“刷新检验”明确指 CBB 上传中心库后的收尾校验:在 Library Manager 找到刚上传的 CBB,右键执行 `Verify`,处理 Verify 流程中的按钮/错误,并确认条目状态标志变为绿色。它不替换 Part Number,不同步 PCB,不改写中心库、`.prj` 或网表文件,也不负责上传动作本身。
这里的“刷新检验”指 CBB 上传中心库后的收尾校验。当前生产路径打开 ReusableCircuit PCB,执行 Project Integration、保存和关闭,再读取中心库权威状态。它不替换 Part Number,也不负责上传动作本身。
本校验工具不读取或修改 PCB 文件,也不依赖工作区中的 CBB 工程样本。
本工具会通过 Mentor 原生接口更新和保存 CBB 工程,并可能修正 `PCB/pcb.prj` 的 CentralLibrary 路径(保留原文件副本)。这不是只读检查;不要将“校验”理解为工程数据完全不变。
## 当前实现
@@ -133,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`。
- 超时或失败时,worker 所在 Job Object 连同 PCB、cscript 助手一并终止;如果外层 supervisor 先终止 worker,还会依据本次 CBB 的 PCB 命令行和启动前 PID 基线做一次定向清理。证据目录的 `events.jsonl` 会记录 `source=supervisor_cleanup` 的 `process_cleanup` 事件。
- 弹窗只认领本次运行的私有桌面/进程,依据已知规则投递 `BM_CLICK`。数据库恢复、会话失联和设计锁接管提示会阻断并保留现场;不会自动选择恢复或接管。未知弹窗也会阻断,Project Integration 进度窗保持观察。动作/错误弹窗和实际控件 ID 写入 `dialogs.jsonl`。
- 超时或失败时停止自动化客户端,保留可能仍在写库的原生会话并停止批次。内容检查超时也不再强杀整个进程树;监督器核对进程是否退出,记录 `process_exit_confirmed` 或 `process_retained`;无法确认释放时输出 `recovery-required.json`,不以强杀代替数据库安全关闭。已确认身份且原生调用返回的失败文档会通过 32 位助手执行 `Close(False)`,再确认进程和 iCDB 地址释放。
## 环境要求
@@ -161,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` 的条目不能勾选、也不会进入批量队列。
@@ -194,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,366 @@
# CBB 中心库上传后校验工具(cbb-refresh-verify-795)全面扫描与阻塞分析
- **扫描对象**:`https://git.simgreek.com/Skyworth_Digital_Hardware/cbb-refresh-verify-795`
- **默认分支**:`main` @ `39985f7`(`chore: release v0.2.3-beta.1`,2026-10-29)
- **活跃分支**:`codex/temp-issue-2-icdb-recovery` @ `29959e2`(2026-11-04 14:16,领先 `main` **49 个提交 / +13,173 行**,未合并、未发布)
- **标签**:`r4-stability-20260929`、`v0.2.2-beta.1`、`v0.2.3-beta.1`
- **扫描时间**:2026-11-04
- **扫描方式**:全量克隆 + 逐模块源码阅读(38 个源文件 / 8,180 行)+ 两个分支完整 pytest + 32 位桥 PE 导入表解析与实机启动 + 关键判定函数行为探针 + 与 `docs/` 现场记录交叉核对
---
> 关联工单:<https://git.simgreek.com/Skyworth_Digital_Hardware/cbb-refresh-verify-795/issues/4>
>
> 扫描基准:`main@39985f7`(v0.2.3-beta.1)、`codex/temp-issue-2-icdb-recovery@29959e2`。
> 本文是扫描时的静态与实测记录;修复进展以工单和后续 PR 为准。
## 0. 一页结论
1. **单机、Win11、有 32 位状态桥、CBB 无异常** 的条件下,`v0.2.3-beta.1` 的"ReusableCircuit PCB → Project Integration → Save/Close → `IsVerifiedReuseBlock` READY"链路是成立的(发布说明有隔离实机 PASS 记录),工具没有伪造绿色状态,失败即阻塞的设计方向正确。
2. **批量场景是这个工具真正的短板**:状态判定依赖外部 32 位桥,但**桥的 x86 VC++/MFC 运行时不随包提供**(本机实测 `0xC0000135` 无法启动);没有桥时工具仍会对每个 CBB 做完整刷新再判 FAIL;叠加"未知弹窗即停批""残留 `sAddress.adr` 即阻断""本机任何 PCB 打开即拒跑",批量任务在现场高概率中途停止。
3. **Win10 是明确的未验收边界**:LM 原生菜单在私有桌面上不派发 MFC 命令(`docs/API-FINDINGS.md`),直接 PCB 路线在 Win10 上是否会提交 Verify 状态没有现场证据。
4. **共享中心库并发没有真正的互斥**:`main` 只有进程内 `Local\` 命名互斥 + 本机进程探测;另一台机器/另一个工程师同时操作同名 CBB 时无任何防护。活跃分支新增了 sidecar 库锁,但它是"合作式"文件锁,Mentor 本身不参与。
5. **ICDB 失联修复尚未闭环**:分支已经做到"原生 Repair → 重开 → 历史版本选择 → 校验 → READY",但文档明确"服务器会话失联经实际按钮触发的完整链路仍需通过",并且出现过"Repair 后 BackAnnotate 被原生拒绝"的失败结论。
6. 代码质量整体高于同类现场工具(分层清晰、证据链完整、失败关闭),但存在若干**可复现的功能缺陷**(内容检查文本误判、`.prj` 编码假设、超时后孤儿 worker、save helper 无超时等),详见第 3 节。
**一句话**:这个工具现在能"证明一个 CBB 是否真的绿",但还不能稳定地"把一批 CBB 刷成绿";阻塞点不在算法,而在**判定链的部署完整性、现场弹窗/占用环境、以及批量的工程化**。
---
## 1. 系统定位与运行链路
### 1.1 定位
| 项 | 内容 |
| --- | --- |
| 处理对象 | 已上传到 Mentor 中心库(`.lmc` + `ReusableBlocksLP`)的 CBB 条目 |
| 核心动作 | 打开该 CBB 的 ReusableCircuit PCB → Project Integration 四项同步 → 保存 Reusable Block cell → 关闭 → 只读读取权威 Verify 状态 |
| 不做什么 | 不做 Part Number 替换、不做上传、不直接改写中心库数据来伪造绿色 |
| 成功判据 | `worker` 完成 + 32 位桥 `IsVerifiedReuseBlock` 返回 `READY / raw=1`,二者缺一即 FAIL |
### 1.2 主链路(`main`)
```
GUI (ui/main_window.py)
└─ run_batch (verify_runner.py) # 串行,max_workers=1
└─ run_verify # 会话级互斥 Local\CbbRefreshVerify795
├─ preflight # Work 下唯一 PRJ / PCBDesignPath / 链接越界
├─ unreleased_addresses # sAddress.adr 残留即 BLOCKED
├─ ReuseBlockImporter -chkContents # 可选:LibSpec + DMS 登录配置
├─ icdb_ports_bindable # 10000-10100 端口预检
├─ DesktopWorker (私有桌面) # 32 位桥/弹窗代理同桌面
│ └─ execute_job (mentor_adapter.py)
│ ├─ 备份(仅本地盘) / CentralLibrary 路径修正
│ ├─ ExpeditionPCB.exe <pcb> -ReusableCircuit
│ ├─ wait_for_target_document (COM 身份核对)
│ ├─ refresh_integration (四项 InSynch)
│ └─ cscript save_verified_block.vbs (Validate/Save/IsSaved/Close/Quit)
├─ cleanup_verify_processes # 只观察退出,不强杀
└─ IsVerifiedReuseBlock (status_bridge.py) → READY / PENDING / UNAVAILABLE
```
对话框监督是一条独立链路:`DesktopWorker` 在私有桌面启动 `--dialog-agent` 伴生进程,agent 用 Win32 + UIA 抓窗口快照,`dialog_supervisor` 按 `assets/dialog_rules.v1.json` 的**阶段化白名单规则**决策,通过 JSONL loopback IPC 回传。
### 1.3 每次校验的产物
`evidence/verify-*/`:`result.json`、`events.jsonl`、`dialogs.jsonl`、`save.log`、`performance.json`、`bridge-status.json`、`diagnostics/`(preflight、native-logs、icdb-recovery)、失败时的 `recovery-required.json`。
### 1.4 现场自述的验证状态(文档)
- `v0.2.3-beta.1`:`pytest` 471 passed;EE7.9.5 隔离实测"破坏 ICDB 文件头 → 备份恢复 → 重新打开 → PASS/GREEN/READY"。
- 明确未验收:Win10、真实网络库大批量、现场 ICDB 失联的自动 Repair 全链路。
- 旧批次 68 项中 51 PASS / 17 FAIL,失败类型已在 `docs/2026-09-29-stability-r4.md` 分类。
---
## 2. 规模与结构
| 指标 | main | temp-issue-2 分支 |
| --- | --- | --- |
| 提交数(相对 main) | — | +49 |
| 源文件 / 行数 | 38 / 8,180 | 47 / 约 13,000+ |
| 测试文件 / 行数 | 35 / 5,752 | 约 50 / 9,000+ |
| 测试用例 | 471 | 1,196 |
| 本机 pytest 结果 | **463 passed / 8 failed** | **1,178 passed / 18 failed** |
| Python / 依赖 | 3.12 + PySide6 6.11 + pywin32 + pywinauto + Pillow | 同 main |
| 打包 | PyInstaller onedir(`CbbRefreshVerify-Background`) | 同 main |
> 本机失败均与环境有关(未完成 `pip install -e .`、无 Mentor 安装、缺 x86 VC 运行时、长路径/编码),不是断言暴露的产品逻辑失败。具体归类见第 7 节。
---
## 3. 功能性问题清单
严重度:**P0** 阻塞交付 / 数据安全风险;**P1** 现场高概率失败或明显功能缺陷;**P2** 可用性、可维护性、规模化问题。
### 3.1 判定链与证据
| 编号 | 严重度 | 问题 | 代码证据 | 影响 |
| --- | --- | --- | --- | --- |
| **F-01** | P0 | **状态桥不可用时仍执行完整刷新,最后才判 FAIL**。批量入口不检查桥是否可用;桥只在 worker 成功后才查询 | `verify_runner.py:981-1000`;UI 读库 `ui/main_window.py:63-68`;`batch_status.authoritative_status_map` 失败只返回 `UNAVAILABLE` | 每个 CBB 白做 2-10 分钟原生刷新 + 一次 Save/Close,然后 `BRIDGE_UNAVAILABLE`;3000 项批量等于 3000 次无效写库 |
| **F-02** | P0 | **32 位状态桥依赖 x86 `mfc140/MSVCP140/VCRUNTIME140`,打包清单只带 exe、未声明或检测该运行时**。本机 SysWOW64 无 x86 运行时,桥启动即 `0xC0000135`(发布 ZIP 不在仓库中,需在发布包上复核是否另行分发) | `packaging/CbbRefreshVerify.spec:4-14` 仅 `binaries=[CbbStatusBridge32.exe]`;PE 导入表实测:`KERNEL32, mfc140, MSVCP140, VCRUNTIME140, api-ms-win-crt-*` | 未额外安装 VC++ 2015-2022 x86 运行时的机器,桥永远不可用 → 所有项最终 FAIL |
| **F-03** | P1 | 内容检查结果用正则 `failed\|error\|cannot connect\|bad data` 判失败,**"0 errors"、路径含 `error` 也会判 FAIL** | `verify_runner.py:30-31, 128-141`;本机实测 `classify_output(0, "...successfully! 0 errors...") == 'FAIL'` | 内容检查偶发误报阻断,且现场难以看出是文本匹配导致 |
| **F-04** | P1 | `preflight` 用 `read_text(encoding='utf-8', errors='replace')` 解析 `.prj`;UTF-16/ANSI 工程会读不到 `PCBDesignPath` → 误判"工程没有 PCBDesignPath" | `verify_runner.py:157-161`;对照 `backup_recovery._project_text`(`backup_recovery.py:129-136`)已正确区分 UTF-16/UTF-8/mbcs | 老工程/修复后工程被预检直接判 BLOCKED,且看起来像"工程数据坏了" |
| **F-05** | P1 | 内容检查报告写入**中心库目录** `LogFiles/`;写失败只拼进局部 `stderr`,PASS 路径下该信息被丢弃 | `verify_runner.py:688-693` | 只读共享/权限不足时无任何提示;中心库额外产生日志文件 |
| **F-06** | P2 | 备份只在 PASS 且 `safe_to_continue` 时清理;失败项 `backup/`(可能数 GB)永久保留,无保留策略 | `verify_runner.py:641-651`;`mentor_adapter.cleanup_evidence_backup` | 长时间批量后磁盘被失败证据占满 |
### 3.2 现场自动化(弹窗 / 桌面 / 进程)
| 编号 | 严重度 | 问题 | 代码证据 | 影响 |
| --- | --- | --- | --- | --- |
| **F-07** | P0 | **任何不在白名单里的弹窗 = `UNKNOWN_DIALOG` = 当前项 FAIL + 整批停止**。规则要求精确英文文本、`GXWND`+`Button` 类名 | `dialog_rules.py:216-236`、`188-236`;`dialog_supervisor.py:458-471` | Mentor 版本/语言/主题差异、任何新提示("Reusable block already exists""license checkout failed"…)都会中断整批;现场 6 项 IME 语言栏误判即此类 |
| **F-08** | P1 | 弹窗代理客户端**每请求 2 秒超时**,而 agent 端 `capture()` 最坏为"N 个窗口 × 0.75s UIA + 子控件枚举";UIA 探测超时后线程泄漏继续跑 | `dialog_agent.py:383-388`(默认 2.0s)、`dialog_probe.py:37-44, 242` | 机器繁忙/窗口多时 `DIALOG_PROTOCOL_TIMEOUT` 被当成致命错误;泄漏的 STA 线程与主探测并发调用 UIA,进一步拖慢 |
| **F-09** | P1 | **Win10 私有桌面上 UIA `InvokePattern` 只关闭原生菜单、不派发 MFC 命令**;`native_lm_verify` 默认关闭,只有显式勾选才走菜单路线 | `docs/API-FINDINGS.md` §7、README「Win10/Win11 兼容性边界」;`verify_runner.py:466-470` | Win10 现场两条路线都不保证成功;目前只能以"Win11 已验证"交付 |
| **F-10** | P1 | **本机只要有任何 `ExpeditionPCB.exe` 在跑就拒绝校验**(即使与本 CBB 无关) | `mentor_adapter.py:619-621` | 工程师日常开着 PCB 时无法点击校验;现场"先关掉所有 PCB"成为隐性前置条件 |
| **F-11** | P1 | `sAddress.adr` 任一残留即 `ICDB_SESSION_UNCONFIRMED` 阻断;正常/异常退出后残留都要人工处理 | `icdb_ownership.py:13-16`;`mentor_adapter.py:644-650`;`verify_runner.py:661-670` | 一次现场崩溃会让后续每次校验都失败,且错误信息指向"未释放",与真实原因(陈旧文件)难区分 |
| **F-12** | P1 | save helper 轮询循环**无超时、无取消检查**;helper 卡在 `doc.Save()` 时 worker 只能等监督器 600s 空闲超时 | `mentor_adapter.py:794-816` | 网络库/许可异常时单次长时间挂起;超时后 helper 仍可能继续写 |
| **F-13** | P0 | **超时/取消只"请求停止"(touch 取消文件),不终止 worker**;worker 只在启动前、PCB 启动循环、保存前 3 处检查取消 | `desktop_worker.py:149-157`;`mentor_adapter.py:684-689, 744-746, 787-789`;`verify_runner.py:892-903` | 监督器已返回 TIMEOUT/FAIL 并释放互斥;worker 仍可能在随后的几秒内完成 Save/Close。若清理时恰好观察到 PCB 已退出,会判定 `safe_to_continue=True` 并启动下一项,而上一项仍可能有迟到的原生写入 |
| **F-14** | P1 | supervisor 崩溃看门狗在 `cancel_path` 存在时(**生产总是存在**)只写取消文件然后返回,**不退出 worker**;只有 `cancel_path=None` 才 `os._exit(75)` | `desktop_worker.py:34-52`;`verify_runner.py:724` 恒写入 `cancel_signal` | 与 F-13 叠加:父进程崩溃后可能留下无监督的自动化进程继续写库 |
### 3.3 数据、权限与边界
| 编号 | 严重度 | 问题 | 代码证据 | 影响 |
| --- | --- | --- | --- | --- |
| **F-15** | P1 | 工具会**改写中心库内 `PCB/pcb.prj` 的 `CentralLibrary`**;修改前只在本次证据目录留单文件副本,网络库不做整工程备份 | `mentor_adapter.py:93-162, 707-712`;README 第 22 行亦承认 | 现场(网络中心库)没有可回退的工程副本;与 README「不允许直接改写中心库 .prj」的表述冲突 |
| **F-16** | P2 | `Work` 下 `.prj` 不唯一即预检跳过;修复/导入后残留的备份 PRJ 会被当作"无法唯一确定" | `verify_runner.py:152-155`;`preflight_skip_reason` | 条目被静默跳过(黄行),用户以为已校验 |
| **F-17** | P2 | Cert 完全不参与判定(设计取舍),但也没有"保存成功但未提交"的独立证据维度 | `verify_runner.py:313-330`;`collect_cert_evidence` 仅记路径 | 只能靠桥区分 PASS/PENDING;桥抖动时无法自证 |
| **F-18** | P2 | 备份策略:网络盘直接跳过递归备份(`backup_skipped`),本地盘 3-30s 预算 | `mentor_adapter.py:632-640, 399-453` | 现场中心库基本都在网络盘 → 实际上没有前置备份 |
### 3.4 性能与规模化
| 编号 | 严重度 | 问题 | 代码证据 | 影响 |
| --- | --- | --- | --- | --- |
| **F-19** | P1 | 每次"读取 CBB"都会:整文件 SHA-256 `.lmc` + 顶层目录指纹 + 逐 CBB 桥查询 + **逐 CBB `preflight_skip_reason`(网络 stat/glob/读 PRJ)** | `batch_status.py:95-122, 194-197`;`ui/main_window.py:257-263` | 3000 项网络库首屏可能数分钟到数十分钟;期间只有一个"正在读取中心库…"标签,无进度、不可取消 |
| **F-20** | P1 | 批量无进度条(仅全库 ICDB 模式有)、**不能取消当前项**(只能"当前项完成后停止")、崩溃后队列不持久化、不续跑 | `ui/main_window.py:417-454, 547-548`;`run_batch` 只在项间检查 stop | 长批次一旦中断只能从头再来;现场无法预估剩余时间 |
| **F-21** | P2 | 每次桥查询(单条路径)都新起一个 32 位进程;批量依赖常驻 `--server`,桥崩溃后整段剩余项直接标 UNAVAILABLE | `status_bridge.py:141-203, 206-332`;`batch_status.py:258-270` | 单条校验慢;桥异常时"剩余全部不可用",无法只重试当前项 |
| **F-22** | P2 | 多处 0.2s 轮询叠加 WMI 查询(`Win32_Process` 每次约 50-200ms)、integration 每次 `native_error()` 读 3 个原生日志 | `mentor_adapter.py:744-761, 800-809`;`integration.py:33-39`;`post_verify_diagnostics.py:32-39` | CPU/网络 I/O 放大;网络日志读取可能反过来拖慢原生操作 |
### 3.5 工程性 / 可维护性
| 编号 | 严重度 | 问题 | 证据 |
| --- | --- | --- | --- |
| **F-23** | P2 | 38 个源文件里 **102 处** `except Exception`/裸 `except`,大量 `except: pass`;故障常被降级成 `UNKNOWN/FAIL`,根因只留在日志 | 静态统计 |
| **F-24** | P2 | GUI/CLI 顶层异常只 `return 1`,不打对话框、不打印到控制台;批处理用户只看到退出码 | `application.py:134` |
| **F-25** | P2 | 无 CI 配置、无 lint/类型检查、无 LICENSE/CHANGELOG;300KB 二进制入库;`.gitattributes` 全量 `-text` | 仓库根目录 |
| **F-26** | P2 | 测试依赖"本机已 `pip install -e .` + 已装 Mentor + 有 x86 运行时",新克隆机器直接 pytest 会有 8 项环境失败 | 第 7 节 |
| **F-27** | P2 | 分支 49 个提交、+13k 行,`pyproject.toml` 版本仍是 `0.2.3b1`,候选包与正式包同版本号 | `pyproject.toml:6`(两分支相同) |
---
## 4. 阻塞点划分(任务视角)
把"阻塞"分成三类,避免把平台限制、工程缺陷、规模问题混在一起:
- **K1 平台/产品硬约束**:Mentor/Windows 决定,改代码无法消除,只能绕行、限定验收范围或推动替代方案。
- **K2 交付阻塞**:团队可修,但当前版本不满足"可交付/可批量"的最低条件。
- **K3 规模化阻塞**:单机少量可用,上批量/上团队前必须解决。
### 4.1 阻塞点总表
| 编号 | 阻塞点 | 类型 | 证据 | 受影响任务 | 解除条件 | 优先级 |
| --- | --- | --- | --- | --- | --- | --- |
| **K1-1** | Library Manager 没有公开的 CBB `Verify()` COM 方法,只有内部 32 位导出 | K1 | `docs/API-FINDINGS.md` §3;`LibraryManager.tlb` 审计 | 所有"编程触发 Verify"的路线 | 接受"只读判定 + ReusableCircuit 刷新"路线,或继续 ABI 研究 | — |
| **K1-2** | 状态判定只能靠 32 位 MFC ABI 桥,64 位 Python 不能直连 | K1 | `docs/API-FINDINGS.md` §3、§9 | 状态读取 | 保持独立 x86 桥(现状) | — |
| **K1-3** | 私有桌面上 LM 原生菜单不派发(Win10 UIA),`SwitchDesktop` 在本机不可用 | K1 | `docs/API-FINDINGS.md` §7 | Win10 现场 | 现场 Windows 10 真机验收;或限定仅 Win11 | — |
| **K1-4** | iCDB 服务器端口必须落在 10000–10100,可能被 Hyper-V/WSL 保留 | K1 | `mentor_adapter.py:978-1082`;文档 §8 | 所有 PCB 启动 | 管理员 `net stop winnat && net start winnat`(工具已给提示) | — |
| **K1-5** | Mentor 对"已验证工程"禁止 BackAnnotate;共享符号库没有 PRJ 入口 | K1 | 工单 #2 文档、`integration.py:93-100` | 已绿工程复检、共享库修复 | 按原生限制记录为"已同步/不支持",或人工处理 | — |
| **K2-1** | **桥不可用(缺 x86 运行时 / 未打包 / 路径找不到)仍可启动批量** | K2 | F-01、F-02 | 全部批量 | 打包 `VC_redist.x86` 或 `/MT` 静态链接;启动自检;无桥禁止批量 | **P0** |
| **K2-2** | **未知弹窗即停批**,白名单覆盖不了现场提示 | K2 | F-07 | 批量、Win10 | 规则分级(致命/可确认/仅记录)、未知弹窗可配置停机或继续并留证 | **P0** |
| **K2-3** | **超时/取消不终止 worker,孤儿进程可能继续写库** | K2 | F-13、F-14 | 数据安全、连续批量 | 明确"取消=停自动化客户端、保留原生会话"的边界;对 worker 进程做可验证的终止/对账;看门狗在崩溃时真正退出 | **P0** |
| **K2-4** | 共享中心库无跨机互斥;`main` 只有进程内互斥 + 本机 PCB 探测 | K2 | `verify_runner.py:504-547, 742-746`;分支 `library_lock.py` | 多人/多机使用 | 合并分支库锁并让上传工具/Mentor 侧协同;或规定"单人独占窗口" | **P1** |
| **K2-5** | 残留 `sAddress.adr` 永久阻断;本机任意 PCB 打开即拒跑 | K2 | F-10、F-11 | 日常使用 | 区分"陈旧地址文件"与"活会话"(探测可达性已具备,但策略过严);PCB 占用按 CBB/工程匹配而非全局 | **P1** |
| **K2-6** | ICDB 失联的自动 Repair 全链路未验收;Repair 后 BackAnnotate 被拒 | K2(分支) | `docs/releases/2026-11-03-field-feedback.md`、`2026-11-04-icdb-review-fixes.md` | 库损坏恢复、全库维护 | 现场真实失联库端到端验收;修复后重开/保存/READY 全绿 | **P0(分支)** |
| **K2-7** | Win10 未验证,且没有可用的菜单触发兜底 | K2 | F-09 | Win10 现场 | Win10 真机单 CBB 验收,或书面限定 Win11 | **P1** |
| **K2-8** | 内容检查文本误判 + `.prj` 编码假设 | K2 | F-03、F-04 | 启用内容检查的批次 | 修正解析/判定,补回归 | **P1** |
| **K3-1** | 首屏扫描 O(全库) + 逐 CBB 预检,无进度/不可取消 | K3 | F-19 | 3000 项批量 | 增量扫描、缓存指纹、预检并行/惰性、进度条 | **P1** |
| **K3-2** | 队列不持久化、不能取消当前项、无断点续跑 | K3 | F-20 | 长批次 | 队列清单落盘 + 逐项检查点 + 取消当前项 | **P1** |
| **K3-3** | 失败证据/备份无上限 | K3 | F-06 | 长期运行 | 证据保留策略(按天/按大小) | **P2** |
| **K3-4** | 质量门禁缺失(无 CI、版本号不变、环境耦合) | K3 | F-25、F-26、F-27 | 发布/回归 | CI(无 Mentor 的 mock 层 + 一台 Mentor 自托管 runner)、版本号规范 | **P2** |
### 4.2 任务可达性矩阵
| 任务场景 | 结论 | 关键阻塞 |
| --- | --- | --- |
| 单 CBB,Win11,本地/网络库,桥可用,无人占用 | ✅ **可用**(有隔离实机 PASS 记录) | 无 |
| 单 CBB,桥不可用/未装 x86 运行时 | ⛔ **必然 FAIL** | K2-1 |
| 小批量(10–50),工作时段 | ⚠️ **可用但易中断** | K2-2、K2-5、F-12 |
| 大批量(数百–3000) | ⛔ **时间与稳定性不可接受** | K3-1、K3-2、K2-2 |
| Win10 现场 | ⛔ **未验收** | K2-7、K1-3 |
| 共享中心库多人同时操作 | ⛔ `main` 无锁;分支为合作式锁 | K2-4 |
| 库损坏/ICDB 失联恢复 | ⚠️ 诊断与手动路径可用;自动 Repair 未闭环 | K2-6 |
| 无 Mentor 的开发机 | ✅ 仅单元测试(需先装包) | F-26 |
### 4.3 建议的解除顺序
1. **先让"批量的失败是可信且廉价的"**:桥预检 + 打包运行时(K2-1)→ 不做无用刷新。
2. **再让"批量的中断可控"**:弹窗分级(K2-2)、取消/超时语义(K2-3)、占用与残留地址策略(K2-5)。
3. **然后才谈规模化**:增量扫描、进度、续跑(K3-1、K3-2)。
4. **平台边界单独验收**:Win10(K2-7)、共享库并发(K2-4)、ICDB 修复闭环(K2-6)。
---
## 5. 现场失败模式 → 代码根因映射
| 现场现象(文档) | 代码根因 | 对应问题 |
| --- | --- | --- |
| 6 项 `UNKNOWN_DIALOG: TF_FloatingLangBar_WndTitle` | IME 语言栏过滤条件过窄(类名+标题+无控件同时满足) | F-07 |
| `TUNER_R836` Save/Close 后桥返回 PENDING | 桥判定 + Verify 未提交;或原生 BackAnnotate 被拒 | F-17、K1-5 |
| `TUNER_R836_A` 数据库打开失败被记 UNKNOWN_DIALOG | 早期靠文本分类;现走规则白名单 | F-07 |
| `1GPHY_8211` 打开时失联 → 后续 Repair `REPAIR_DATABASE_IN_USE` | 失败打开的 PCB 未被关闭(分支已修:启动失败关闭路径) | K2-6 |
| 5 项 Project Integration 符号错误 | 工程/符号数据问题,工具只负责分类与留证 | — |
| 3 项 JobPrefs / 本地 Cell Library 失败 | 环境/工程状态;工具仅诊断不修复 | — |
| 端口 10000-10100 被保留 | `WinError 10013`,Hyper-V/WSL 动态预留 | K1-4 |
| 桥 UNAVAILABLE 但报告"四绿"风险 | 已被 fail-closed 设计排除(不会伪造 READY) | — |
---
## 6. 活跃分支现状(`codex/temp-issue-2-icdb-recovery`)
### 6.1 新增能力(相对 main)
- 库锁与占用探测:`library_lock.py`、`owner_probe.py`、`native_occupancy.py`(与上传工具兼容的 `.cbb-upload.lock` / `.blocked.json` 协议)。
- CBB 管理:`management.py`、`native_management.py`、`management_transaction.py`、`native_engineering_identity.py`、`native_export_guard.py`(新增/同名替换/移除、身份与导出副本保护)。
- 恢复:`reimport_recovery.py`、`scoped_manifest.py`、`post_repair_consent.py`、`pcb_restore_prompt.py`、`maintenance_entry.py`(库外完整工程副本恢复、历史 PCB 版本选择)。
- 策略调整:取消应用自动备份,改为**弹窗提醒手动备份**(`docs/releases/2026-11-03-manual-backup.md`)。
- 启动失败关闭:`failed_session.py` 扩展为"预检失败/数据库打开失败也协作关闭 PCB"。
### 6.2 本机验证结果
- 1,178 passed / 18 failed;其中 8 项与 main 同因(环境),新增失败集中在:
- **长路径**(`native_add_failures` 两个用例,150 字符目录名 → Windows `MAX_PATH`);
- **owner probe 依赖安装**(`native_export_guard` 6 个用例:子进程 `-m cbb_refresh_verify` 不可用);
- **编码**(`native_repair` 一个用例按 cp1252 解码失败);
- **无 Mentor 安装**(`native_repair` 取消用例)。
### 6.3 分支仍未满足的门槛(文档自述)
- 服务器会话失联 → 实际按钮触发 → 自动 Repair → 重开 → 保存关闭 → READY 的**完整链路未验收**。
- `1GPHY_8212` 原生 Repair 后 **BackAnnotate 仍被拒**,结论未变。
- Windows 10 未验证(当前实机 Win11 / EE7.9.5)。
- 历史 PCB 版本恢复记为 `RESTORED_REVIEW_REQUIRED`,**不等于无损修复**。
- 目标缺 `PartsDB` 分区时无法完成完整校验。
- 共享符号库不支持自动修复。
- 版本号未递增、分支未合并。
> 结论:分支在"管理 + 恢复"上补齐了很多能力,但**没有解除 K2-6(ICDB 自动修复闭环)和 K2-7(Win10)**;同时引入了新的环境敏感性(长路径、owner probe 子进程、编码)。
---
## 7. 测试与质量评估
### 7.1 本机结果
```
main: 463 passed, 8 failed, 1 warning, 37.09s
branch: 1,178 passed, 18 failed, 1 warning, 92.29s
```
main 的 8 项失败归因:
| 失败 | 原因 |
| --- | --- |
| `test_application`(2 项)、`test_abnormal_shutdown`、`test_extended_safety`、`test_failure_lifecycle`(共 5 项) | 子进程 `python -m cbb_refresh_verify` 依赖 `pip install -e .`,本机安装未完成 |
| `test_native_repair::test_repair_cancellation...`、`test_verify_runner::test_pcb_launch...` | 本机无 `D:\Mentor\7.9.5EE` 安装 |
| `test_packaging_status_bridge::test_compiled_bridge...` | 缺 x86 VC/MFC 运行时,`0xC0000135` |
### 7.2 覆盖情况
**做得好的**:状态判定(PASS 只能来自桥 READY)、对话框规则/后置条件、ICDB 日志新鲜度、备份/恢复、进程释放、UI 交互都有大量单测,且测试直接编码了"不得伪造绿色"的安全契约。
**缺口**:
- 没有真实 Mentor 的集成测试(全部依赖 fake COM/进程边界);
- 没有 Win10 测试矩阵;
- 没有网络库并发/多人场景;
- 没有长时间稳定性与性能回归(600s 空闲超时、3000 项批量);
- 测试与"本机安装 + 本机 Mentor 路径"耦合,换机即红;
- 无 CI,测试结果靠人工粘贴进 release note。
### 7.3 代码静态指标
- 38 个源文件 / 8,180 行;**102 处**宽泛异常捕获;15 处 `time.sleep`;15 处 subprocess 调用。
- 硬编码 `D:\Mentor\7.9.5EE\SDD_HOME` 兜底 5 处(可作为默认,但需在 UI/日志里明确"发现失败")。新机器上会静默落到不存在的路径,报错信息偏底层。
---
## 8. 修复路线图(建议)
### P0(1–3 天,先让批量"失败得正确")
1. **桥部署闭环**
- 打包 `VC_redist.x86.exe`(或桥改 `/MT` 静态链接),安装脚本检测/安装;
- 启动时执行一次桥自检(`--codec-test` 或空查询),失败则禁用"批量校验"并给出可操作提示;
- `read_library_fast` 返回 `UNAVAILABLE` 时,UI 明确"无法判定绿色,批量将全部失败",不静默入队。
- 验收:干净 Win11 + 无 VC 运行时 → 工具提示安装而不是跑 3000 次无效刷新。
2. **未知弹窗分级**
- 规则增加 `on_unknown: stop | record_continue | block_item`;
- 默认对"无按钮/纯文本/IME/浏览器宿主"仅记录,对"数据库恢复/许可/保存失败"阻断;
- 每次未知弹窗都落 `dialogs.jsonl` + 截图证据,批量结束汇总"待人工确认弹窗"。
- 验收:新增一个未登记弹窗的模拟场景,批量不中断且证据可查。
3. **取消/超时语义**
- 明确"取消 = 停止自动化客户端,保留原生会话";对 worker 增加强制终止开关(仅在未进入 Save 阶段可用);
- 看门狗在 supervisor 退出时按"是否处于 Save/Close"决定终止或保留,并落 `watchdog-decision.json`;
- `run_verify` 在 worker 未确认退出时不得释放互斥、不得继续下一项(当前已部分满足,需把"进程仍活"纳入 `safe_to_continue`)。
- 验收:模拟 Save 卡死 → 工具超时后 worker 确实退出或明确标记"仍活",下一项不启动。
### P1(1–2 周,现场可用性)
4. 弹窗代理超时预算与 `capture()` 并发控制(F-08);UIA 探测改为按进程白名单 + 单窗口超时,禁止泄漏线程。
5. 占用/残留策略(F-10、F-11):PCB 占用按 CBB 路径匹配;`sAddress.adr` 增加"不可达 + 非本机进程 + 超时"三条件判定为陈旧并可清理(需用户确认)。
6. 内容检查判定(F-03)与 `.prj` 编码(F-04)。
7. 中心库写入保护(F-15):改写 `pcb.prj` 前做整文件副本 + 变更清单,网络库至少保留原文件并可一键回滚。
8. 合并分支库锁(K2-4),并与上传工具约定锁协议。
### P2(2–4 周,规模化)
9. 增量扫描/指纹缓存、预检惰性化、进度条、取消当前项、队列持久化与续跑(F-19、F-20)。
10. 证据保留策略与磁盘配额(F-06)。
11. CI:mock 层全量测试 + 一台 Mentor 自托管 runner 做冒烟;版本号规范(`0.2.3b1+candidate.49`)。
12. 清理宽泛异常,至少在关键路径保留 `error_code` 与原始异常链(F-23)。
---
## 9. 附:关键证据索引
| 主题 | 文件:行 |
| --- | --- |
| 成功判据(桥 READY) | `src/cbb_refresh_verify/verify_runner.py:313-330, 981-1000` |
| 内容检查判定 | `src/cbb_refresh_verify/verify_runner.py:30-31, 128-141` |
| 预检(PRJ/PCB/链接) | `src/cbb_refresh_verify/verify_runner.py:144-174` |
| 端口预检 | `src/cbb_refresh_verify/mentor_adapter.py:1061-1082` |
| 数据库地址阻断 | `src/cbb_refresh_verify/icdb_ownership.py:13-16` |
| PCB 全局占用检查 | `src/cbb_refresh_verify/mentor_adapter.py:619-621` |
| CentralLibrary 改写 | `src/cbb_refresh_verify/mentor_adapter.py:93-162, 707-712` |
| save helper 循环 | `src/cbb_refresh_verify/mentor_adapter.py:790-816` |
| 取消信号 | `src/cbb_refresh_verify/desktop_worker.py:149-157`;`mentor_adapter.py:684-689, 744-746, 787-789` |
| 看门狗 | `src/cbb_refresh_verify/desktop_worker.py:25-56` |
| 弹窗规则 | `src/cbb_refresh_verify/dialog_rules.py:188-236`;`assets/dialog_rules.v1.json` |
| 弹窗代理超时 | `src/cbb_refresh_verify/dialog_agent.py:383-388`;`dialog_probe.py:37-44, 242` |
| 状态桥 | `src/cbb_refresh_verify/status_bridge.py:115-203, 206-332` |
| 批量状态扫描 | `src/cbb_refresh_verify/batch_status.py:95-122, 184-277` |
| UI 读库/队列 | `src/cbb_refresh_verify/ui/main_window.py:225-335, 417-548` |
| 打包清单 | `packaging/CbbRefreshVerify.spec:4-25` |
| 分支库锁 | `src/cbb_refresh_verify/library_lock.py:80-200`(分支) |
### 复现命令
```powershell
git clone https://git.simgreek.com/Skyworth_Digital_Hardware/cbb-refresh-verify-795.git
cd cbb-refresh-verify-795
python -m pip install -e .
python -m pip install pytest pytest-qt
python -m pytest -q # main: 463 passed / 8 failed(本机环境)
git worktree add ..\cbb-branch origin/codex/temp-issue-2-icdb-recovery
cd ..\cbb-branch; python -m pytest -q # branch: 1178 passed / 18 failed(本机环境)
```
桥依赖验证:
```powershell
# 1) 导入表:KERNEL32 / mfc140 / MSVCP140 / VCRUNTIME140 / api-ms-win-crt-*
dumpbin /dependents .\tools\status_bridge\bin\CbbStatusBridge32.exe
# 2) 实机启动:缺 x86 运行时时的退出码 -1073741515 (0xC0000135)
.\tools\status_bridge\bin\CbbStatusBridge32.exe --codec-test
```
@@ -0,0 +1,47 @@
# Issue 5:私有桌面泄露
## 现象
代码与回归测试确认:原生 worker 创建私有 Windows Desktop 后,如果 Job Object 创建或 worker 进程启动失败,构造函数直接抛出异常,已创建的 Desktop 和 Job 句柄没有释放。重复失败存在累积私有桌面资源的风险;本次未对现场所有桌面异常作归因。
状态读取路径还有一个相同的边界:`read_library_flag` 在进入资源清理保护前加载 UI 依赖;依赖加载异常时,刚创建的私有桌面无法执行 `CloseDesktop`。
## 根因
1. `DesktopWorker.__init__` 的资源申请跨越多个可能失败的步骤,但没有事务式回滚。
2. 进程句柄、Job 句柄和 Desktop 句柄的释放顺序没有覆盖构造阶段异常。
3. `read_library_flag` 的依赖导入位于 `CreateDesktop` 之后、`try/finally` 之前。
4. `read_library_flag` 和 `read_library_tree_image_map` 都在清理保护外先创建 Desktop,再执行 `Path(library)` 等准备逻辑;准备阶段抛异常时也会泄漏。
## 解决方案
- 在 `DesktopWorker` 构造开始时初始化资源字段,并把 Desktop、Job、worker 创建放入同一异常边界。
- 构造失败时按 worker、Job、Desktop 顺序回滚;已启动的 worker 先终止,避免留下无父级的原生进程。
- 在状态读取创建 Desktop 前完成 UI 依赖加载,确保依赖异常不会产生未受保护的 Desktop。
- 两处状态读取均在准备逻辑完成后、`try/finally` 内创建 Desktop,清理时检查资源是否存在。
- 测试中分离 Desktop、Job、Process、Thread 的接口,断言失败后关闭顺序;覆盖四个构造失败点与进程创建后的终止分支。
## 影响范围
- 覆盖原生 worker 构造失败,以及状态读取准备和启动阶段的资源清理路径。
- 正常任务的私有桌面、Job Object、进程树和数据库释放策略不变。
- 不会切换用户输入桌面,也不会改变中心库写入策略。
## 验证
- 修复分支完整 `python -m pytest -q --tb=short`:480 passed。
- 同环境、同工作树切换到 `origin/main`(`39985f7`)完整运行相同命令:471 passed。两次运行依次执行,均仅有一条 pywinauto STA 警告。
- `tests/test_desktop_worker.py`:9 passed。两处状态读取准备阶段泄漏的新增测试在修复前 2 failed,修复后通过。
- 变异验证:把回滚中的 `self.job.Close()` 故意改为 `self.job.CloseDesktop()`,测试产生 2 failed;恢复正确代码后通过。
- `python -m compileall -q src tests`:通过。
- `git -c core.whitespace=cr-at-eol diff origin/main HEAD --check`:通过。命令显式识别 Windows CRLF;仓库 `.gitattributes` 为 `* -text`,保留源文件换行,不依赖本机 `core.whitespace` 配置。
此前 #7 将一次运行中的 `test_backup_recovery.py::test_invalid_source_does_not_touch_target` 失败称为既有基线问题,缺少同环境对照,撤回该归因。本次该用例在 main 与修复分支均通过。审查者在旧 WIP 基线测得的 19 个失败不属于本次从 main 独立提交后的测试范围。
## 合并范围修正
原 PR #7 以 ICDB WIP 分支为父提交,却以 main 为合并目标,实际携带 59 个提交、118 个文件。现从 main 单独 cherry-pick 桌面修复并补充上述审查修正;相对 main 只有本工单、两个源码文件和一个测试文件,共 4 个文件。独立代码复审未发现待处理问题。
## 分支
`codex/desktop-leak-main`
@@ -0,0 +1,38 @@
# 0.2.2 异常关闭补充验证
本轮没有修改生产代码,原 0.2.2 修复包仍适用。新增 10 项故障注入/进程测试,
与此前事故及扩展安全测试合跑,**47 项全部通过**。
命令:
```powershell
build\release-env\Scripts\python.exe -m pytest -q tests/test_abnormal_shutdown.py tests/test_incident_safety.py tests/test_extended_safety.py
```
## 覆盖情况
| 场景 | 结果与边界 |
| --- | --- |
| 正常关闭忙碌中的校验界面 | 现有 UI 行为为请求停止队列、等待当前项结束,不直接退出正在操作的进程。 |
| 强制结束监督程序 | 真实 Windows 无害进程试验:worker 退出码 75,已登记的保存助手退出,模拟原生数据库的进程仍存活。 |
| PCB 在 COM 就绪前退出 | 注入目标文档断开,worker 输出 FAIL、safe_to_continue=False,不启动保存。 |
| PCB/iCDB 在同步时断开 | 注入 COM/RPC 断开错误,worker 输出 FAIL、safe_to_continue=False,不启动保存。 |
| 保存助手异常退出 | 没有日志、只有 SAVE_START 或即使残留全部成功标记,只要退出码非零,均失败。 |
| 保存/关闭证据不完整 | 助手退出码为 0,但缺少 IS_SAVED 或 CLOSE_OK,仍然失败。 |
| worker 自身崩溃 | 无 outcome 文件或留下 PASS 文件但退出码非零,监督器仍判失败;不查询旧 READY 状态把失败变成成功。 |
| 进程或数据库地址残留 | 既有测试确认不报释放成功、不自动删地址文件、不强杀原生进程。 |
| 批次后续动作 | 既有测试确认 safe_to_continue=False 停止后续项;CLI/UI 保留恢复所需的临时网络映射。 |
真实进程试验使用独立的 Python 睡眠进程模拟监督程序、保存助手和原生数据库,
没有人为强杀真正处于写库中的 Mentor/iCDB。COM 断开和保存崩溃通过边界注入验证,
不能将它们说成已经实测过原生数据库崩溃后的完整性恢复。
## 不能保证的部分
工具退出保护旨在停止新的自动化操作并保留现场。已经发出的原生 COM 操作可能仍在进行,
本工具无法保证取消或回滚该操作。若 PCB/iCDB 本身被强杀、机器断电或磁盘写入失败,
数据库可能已经不一致,需要 Mentor 原生恢复或一致备份;程序不自动选择恢复版本或覆盖文件。
正常流程的本地真实验证另见
[本地验证与安全审查](2026-10-26-local-validation-and-audit.md):最终 EXE 校验成功,
Work/Cert 正常重新打开,最终无 PCB/iCDB 残留,原样本 20,994 个文件内容未变。
@@ -0,0 +1,72 @@
# 0.2.1 — PCB / iCDB emergency safety fix
Superseded by **0.2.2** after local Mentor testing found the already-verified
Forward Annotation defect. See [local validation and audit](2026-10-26-local-validation-and-audit.md).
Base: `11a2b2e` (`r4-stability-20260929`). This patch addresses confirmed unsafe
code paths. It does not establish the cause of a particular field incident and
does not repair an already damaged PCB/database.
## Changes
- Preserve `database/cdbsvr/sAddress.adr`. A TCP timeout is not evidence that its
owner is dead. Any existing advertisement (live, unreachable or invalid)
blocks automatic Verify until the native session is reviewed.
- Block a new Verify while any Expedition PCB session is already running,
before changing project configuration or attaching to shared COM objects.
- Do not auto-confirm design-lock overrides or choose a database restoration.
Record `DATABASE_RECOVERY_REQUIRED` without clicking the prompt.
- Release Python COM references before starting the save helper; release the
helper's document/integration references before `app.Quit`.
- Observe PCB/launcher/Library Manager exit. Neither a cleanup request nor
Save/Close markers alone count as process release. A surviving iCDB address
also prevents success.
- On timeout or failure, stop automation clients without killing the native
PCB/iCDB process tree. The Job Object no longer kills native descendants when
its handle closes. Library Manager shutdown requests no longer fall back to
force termination.
- Stop the batch on `safe_to_continue=False`, including unexpected exceptions.
Preserve available evidence backups on failure. Record retained processes,
the private desktop and project in `recovery-required.json`; the UI points
the operator to the recovery evidence.
## Operational consequences
The normal path still performs Project Integration and saves through Mentor.
It is **not** a read-only PCB check. The adapter can also align the CentralLibrary
entry in `PCB/pcb.prj`, preserving its original in the evidence directory.
A failure can deliberately leave a native session alive on the private desktop.
This avoids interrupting a database write; it is reported as a failure, never as
successful release. Review the recorded desktop/PIDs with the maintainer before
closing/recovering that session. Do not delete the address/lock files merely
because a connection probe timed out. The presence of an old address may require
manual Mentor recovery even when no local PCB process remains.
Existing partial backups exclude volatile database files and network runs may
skip them; they are **not** a complete database rollback. Before field testing,
use a consistent, isolated copy made after the original native session closes.
Opening a copied database can itself cause Mentor to report a moved/copied DB.
## Validation
The incident regression suite covers address preservation, ownership checks,
recovery prompts without clicks, COM reference lifetime, retained PCB/iCDB state,
supervisor rejection of false PASS, evidence retention and batch stopping.
A real Windows Job Object test uses harmless Python processes to check that
automation abort/handle closure does not terminate a native-like child.
Run `python -m pytest -q` and `python -m compileall -q src tests`. Packaging uses
`packaging/Build-CbbRefreshVerify.ps1`, including its frozen UI smoke check.
These checks do not validate recovery of the user's affected production PCB.
Validation completed on Windows 11 / Python 3.12.10:
- Full suite: **354 passed** (including 18 incident regression cases).
- Python compilation and Git whitespace checks passed.
- The 32-bit cscript host compiled a non-executing wrapper of the save helper
successfully; this checks syntax without connecting to Mentor.
- PyInstaller 6.22.3 build and frozen UI creation/clean-shutdown smoke passed.
Live Mentor verification and damaged-database recovery remain unvalidated.
The package has not been deployed to production or tested on Windows 10.
@@ -0,0 +1,82 @@
# 0.2.2 本地功能验证与安全审查
日期:2026-10-26。基线:`11a2b2e`,在 0.2.1 紧急补丁之上继续修复。
环境:Windows 11、Python 3.12.10、Mentor EE7.9.5EE。
## 真实试跑结果
使用仓库已有的历史成功样本 `IP101GR`,完整复制到
`diagnostics/local-verification-20261026/library`。原样本 20,994 个文件、
556,098,864 字节,验证前后 SHA-256 比对没有变化。所有写操作针对隔离副本。
| 检查 | 结果及证据 |
| --- | --- |
| 0.2.1 EXE 首次试跑 | **发现功能缺陷**:四项同步均为 2,`IsForwardAnnotationAllowed=False`,程序仍调用 ForwardAnnotate;Mentor 明确拒绝。保护机制停止批次、保留会话,没有误报 PASS。 |
| 首次失败后的关闭 | 精确核对隔离工程身份后,32 位助手正常 Close(False)/Quit;记录 `IsSaved=True`、`Close=True`。未强杀 PCB/iCDB。 |
| 修复后的源码试跑 | PASS、GREEN;`IsVerifiedReuseBlock` 返回 `READY/raw=1`;保存、关闭、进程退出均确认。 |
| 再次完整校验 | 第二次 PASS、GREEN;验证同一副本可重复校验。 |
| 最终 0.2.2 EXE 实测 | 打包后的 EXE 再次完成真实校验,退出码 0、PASS/GREEN;未遗留 PCB 进程。 |
| 正常打开 Work PCB | 不带 `-ReusableCircuit`,按普通 PCB 启动,COM 工程身份匹配,正常关闭,未发生数据库打不开错误。 |
| 正常打开 Cert PCB | 同上,Cert 工程身份匹配并正常关闭。 |
| 最终 EXE 校验后再打开 Work PCB | 再次普通打开、身份核对和正常关闭通过。 |
每次成功退出后检查没有残留的对应 PCB 进程,且工程的 `sAddress.adr`
已消失。新生成的 iCDB 日志记录 `Database closed` 和 `icdb.dat closed`。
保存日志仍有 Mentor 的子客户端自动解锁警告;随后数据库关闭、两份 PCB
重新打开均成功,未将这些警告视为已证实的数据库损坏。
原始证据在 `diagnostics/local-verification-20261026`:
`frozen-first-run`、`close-first-run.log`、`source-second-run`、
`source-third-run`、`normal-reopen-work`、`normal-reopen-cert`、
`frozen-final-run`、`normal-reopen-work-final`、`source-integrity.json`。
工程与原始现场文件不包含在发布 ZIP 中。
## 本轮修复
| 问题 | 修复 |
| --- | --- |
| 已验证、全同步的块被重复执行禁止的 Forward Annotation | 尊重原生 Allowed 标志;保留后续 Save/Close 和 READY 权威确认。需要同步却不允许执行时仍报错。 |
| `pcb.prj` 容错 UTF-8 解码可能替换 ANSI 字符 | 只替换目标字段的字节;严格处理 BOM/UTF-16,备份保持原字节。 |
| 写入异常可能截断 `pcb.prj` | 同卷暂存后原子替换;替换失败保持原文件。 |
| 目录 Junction 可绕过工程范围校验 | 校验真实解析路径;交给 Mentor 的路径仍保留原盘符表达。 |
| “成功文本”覆盖非零退出码 | Python 和旧 PowerShell 内容检查都要求退出码 0。 |
| 内容检查位于互斥锁之外 | 全流程持有串行互斥锁,包括内容检查及最终状态读取。 |
| 保留原生会话后仍可能卸载临时网络盘 | CLI 和 UI 在不安全结果/异常时保留本次映射,供恢复使用。 |
| 监督程序异常退出后自动化可能继续写入 | 子进程监视监督程序句柄;停止自动化及保存助手,保留原生数据库拥有者。用真实无害 Windows 进程测试此行为。 |
| 旧树状态读取路径强杀 Library Manager | 请求正常关闭并确认退出;未关闭则保留并报错。 |
| 动态 WMI 查询与相对系统命令查找 | 固定进程查询白名单;使用系统目录中的 taskkill.exe。移除未使用的自动丢弃文档处理器。 |
| 随包/构建依赖的已知漏洞 | Pillow 12.3.0 → 13.0.0;setuptools 84.0.0 → 84.1.0。只更新独立构建环境,不修改全局 Python。 |
## 自动化验证与扫描范围
- **373 项 pytest 通过**,包含初始事故和本轮扩展回归用例。
- 两组 PowerShell 测试通过。新增测试用无害的假 importer 验证“输出成功但退出码 7”必须失败,不打开 Mentor 数据。
- Python 编译检查通过。
- PyInstaller 构建、冻结版界面启动/关闭及真实校验均通过;检查 EXE
内部代码确认为 0.2.2,内部 Pillow 版本确认为 13.0.0,VBS 和规则文件
与已测试源码逐字节一致。
- Coverage:语句覆盖 72.19%,分支覆盖 62.69%,综合 70%。实际 Mentor
子进程试跑不计入此覆盖率;没有声称全部代码分支均被覆盖。
- Bandit 扫描整个 `src`:0 高、0 中、55 低。低等级提示分类:
8 个 subprocess 导入、12 个受控参数列表调用、25 个容错异常处理、
8 个诊断枚举跳过、2 个 Windows 打开日志目录操作。原始报告全部保留。
- 一处全接口端口检测明确标注 B104 排除:只尝试 bind 后立即关闭,
不调用 listen/accept,不提供网络服务。
- pip-audit 检查 18 个运行/构建依赖及其依赖:首次发现 38 条已知公告
(Pillow 37、setuptools 1),升级后复扫 **0 条已知漏洞**。
- 发布依赖清单:`packaging/requirements-build.txt`。扫描报告与覆盖率数据
在证据目录的 `bandit-final.json`、`dependency-audit-fixed.json`、`coverage.json`。
扫描覆盖本仓库 Python 运行代码、相关旧 PowerShell 入口和本次构建依赖;
没有对闭源 Mentor 二进制或整台 Windows 系统作“无漏洞”保证。
## 使用范围与未验证项
本轮真实样本为单个已经验证过的 IP101GR。非绿色状态推进、错误弹窗、
超时、取消、网络映射故障、并发和异常终止主要由隔离自动测试覆盖。
没有使用生产网络库、生产 DMS 凭据,也没有在 Windows 10 上运行。
本补丁防止不安全的继续操作;没有恢复用户原事故中受损的 PCB。
Verify 本身会通过 Mentor 更新工程数据,不能当作只读检查。
异常时可能保留私有桌面中的原生会话和临时盘符;查看恢复记录后进行
正常关闭或使用 Mentor 恢复流程,不应直接删锁或强杀数据库进程。
@@ -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`。
@@ -0,0 +1,7 @@
# PR #10 comment 309
Release proof now records the requested CBB, effective BLOCK/LIBRARY proof scope, identities/statuses of archived checkpoints and retained owners, and `reconciled_foreign_blockers`. For example, a BlockA operation which safely reconciles BlockB's historical checkpoint explicitly lists BlockB and the full-library proof. `data_recovery_confirmed` remains false. No extra gate, automatic backup or native action was added.
Three regressions first failed on missing evidence fields. After the fix, 94 backend/lease/release regressions passed; compileall and git diff --check passed. The tests use real temporary file/lease handles with the process-query boundary replaced; no production library was opened. Full regression is run again at the integrated chain tip. Real Mentor/shared-network acceptance and a rebuilt package remain outstanding.
Review: https://git.simgreek.com/Skyworth_Digital_Hardware/cbb-refresh-verify-795/pulls/10#issuecomment-309
@@ -0,0 +1,38 @@
# PR11 review 345 follow-up
Repeated CBB verification and ICDB check runs replace the previous result dialog
for the same operation. Closing a result retires its Qt widgets and action
references, while the check task keeps its requests, results, invalidated targets,
and recovery context. A result for the other operation stays available.
During application shutdown, the title and status show that background work and
path release are pending. After approximately 120 seconds a second notice says
the application is still waiting. This is a notice interval, not a deadline;
shutdown still waits for existing workers and never forces native tools to stop.
The batch CLI accepts an optional positive `--limit`:
```powershell
python -m cbb_refresh_verify --batch-lmc 'Z:\library\library.lmc' --limit 2
```
The limit selects the first requested names in their existing order. With no
`--block`, the existing non-READY selection supplies those names; repeated
`--block` options retain their explicit order. Omitting `--limit` retains the
existing all-requested behavior. `batch_selection` logs selected, total, and
remaining counts. On batch exceptions or unconfirmed native release,
`batch_drive_retained` identifies the drive, remote share, display library and
Mentor path, and directs the operator to the confirmed-release entry. It never
disconnects a mapping while a native writer may still be active.
Management change counts explicitly cover the compared engineering files only.
Removed from the standalone PR11 head: all five `if False` blocks for the later
release flow, and `_reload_after_maintenance` assignments and its unused reload
branch. The hidden release control and existing method signatures remain for
the later PR12 implementation. When integrating forward, preserve PR12's live
release/resume behavior and retire its dialog-owned action references as well.
Preserve PR13's asynchronous close and lease guards when adding the wait notice.
Validation uses the isolated offscreen review wrapper with fake native boundaries;
it does not open Mentor, kill native processes, invoke Repair, or back up a library.
+41
View File
@@ -0,0 +1,41 @@
# CBB Verify v0.2.2-beta.1
**Beta 预发布,供隔离副本和小范围现场验收使用,尚未完成生产验收。**
本版本修复 PCB/iCDB 校验流程中的会话释放与失败收尾风险。运行逻辑与已完成
本地真实验证的 0.2.2 一致,发布版本标识为 `0.2.2b1`,Git 标签为
`v0.2.2-beta.1`。
## 主要修复
- 保存关闭前释放 COM 引用,确认 PCB 退出及数据库地址释放后才允许成功。
- 不自动移走 `sAddress.adr`、接管带锁设计或选择数据库恢复;异常时停止批次,
保留原生会话、证据及恢复所需的网络映射。
- 监督程序异常退出时停止自动化和保存助手,不连带强杀原生 PCB/iCDB。
- 已验证且全同步的 CBB 尊重 Mentor 的 Allowed 标志,避免重复执行被禁止的
Forward Annotation;仍要求 Save/Close 和权威 READY 确认。
- 保留 `pcb.prj` 原始编码和备份,以同卷原子替换防止截断;阻止目录链接越界。
- 全流程串行互斥;Python/PowerShell 内容检查不再让成功文本覆盖非零退出码。
- 更新 Pillow 至 13.0.0、构建 setuptools 至 84.1.0;18 个依赖复扫无已知漏洞。
## 已有验证
- Windows 11 / Mentor EE7.9.5EE,本地 IP101GR 隔离副本重复真实校验通过。
- Work/Cert PCB 普通重新打开及关闭通过;最终无 PCB/iCDB 残留。
- 原样本 20,994 个文件内容指纹保持不变。
- 发布前全量 Python 测试 **383 项通过**,两组 PowerShell 测试和编译检查通过。
测试期间出现 1 条 pywinauto 的 STA COM 模式提示,未导致失败。
冻结版 UI 检查及构建指纹记录在安装包的 `BUILD-MANIFEST.json` 中。
- 异常关闭专项覆盖 47 项相关测试,包括真实 Windows 无害进程的监督程序退出试验。
## 安装及验收边界
下载 ZIP 后完整解压,运行 `CbbRefreshVerify.exe`,保留 `_internal` 目录。
先在正常关闭后取得的一致、隔离工程副本上验收,不直接覆盖原事故数据。
现场仍需验证客户实际机器、生产网络库、DMS、多个未校验 CBB 的连续运行和
原事故样本;Windows 10 尚未验证。本补丁不代表受损 PCB 已恢复,也不能保证
PCB/iCDB 被强杀或机器断电后数据库自动修复。
详见 [本地验证与安全审查](2026-10-26-local-validation-and-audit.md) 和
[异常关闭补充验证](2026-10-26-abnormal-shutdown-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)。
+13
View File
@@ -0,0 +1,13 @@
# 独立审查 1:只读进程探测与原生任务准入队列
基于 main `a56fd17`,不叠加 PR #3 的历史提交。
**行为变化:** 增加有界、版本化、只读 owner-probe helper 和可取消的 FIFO 原生任务队列。应用仅新增隐藏的只读 helper 分派;现有 UI、验证和原生写操作保持原来的入口。
**失败安全:** 查询超时或协议/身份异常返回未确认;暂停或取消的队列票据不会运行其动作,也不阻止后面的可执行任务。不启动或终止 Mentor 进程。
**回滚方式:** 尚未合入下游时撤销本提交即可;下游接入后须按依赖从上层向下回退。
完整回归:491 passed,1 条既有 pywinauto STA 提示。编译和 diff 检查通过。
与原评论建议的差别:`management_transaction` 直接导入管理模型和库锁;`scoped_manifest` 的协调记录与独占快照依赖库锁协议。这两者在后端审查中一起交付,避免构造导入不完整的“纯工具”基线。
+20
View File
@@ -0,0 +1,20 @@
# Native backend review unit
Base: codex/review-infrastructure. This unit integrates ICDB open diagnostics, scoped content manifests, native CBB transactions and the library-release protocol; it does not expose the new UI or residual termination action. Verification and ICDB checks remain separate, READY items are excluded from maintenance, and a released single-item failure can continue independent targets.
Failure safety: no automatic Repair/version choice, no server termination, no direct LMC edits or native lock-file deletion. Native writes are serialized, uncertain ownership retains evidence and mappings, and unfinished writes are shown without replay.
Dependency rationale: library release imports native engineering identity and retained management workers; engineering identity imports management source models and scoped manifests. Separating these into nominally independent utilities would leave runtime imports unresolved. This PR therefore keeps the backend dependency closure together; UI and user-confirmed termination remain separate later PRs.
Rollback: before dependents are merged, revert this commit. After merging dependents, revert in reverse order or use the previous candidate package after closing the current app. Code rollback does not undo a native transaction; use a consistent manual backup or explicitly selected native history on an isolated copy.
Validation: full Python suite 1,376 passed (one existing pywinauto COM-threading warning); compileall and git diff --check passed. Native field recovery, Windows 10 and cross-machine shared-library acceptance remain pending.
Review comment 344 follow-up (2026-11-09):
- Production status scans continue to query fresh bridge results. The low-level session now also defaults to fresh scans; explicit checkpoint reuse is documented as a controlled read-only option with no production resume promise.
- `library-changes.json` declares `rule_version`, the selected `scope`, excluded directory categories and suffixes, positional runtime rules, runtime filenames/prefixes, and recognized coordination checkpoints. Names, suffixes, prefixes and native database locations come from the same constants used by semantic classification. These are differences in participating engineering files; excluded content is not proven unchanged, and unrelated CBB content is not checked.
- Removed the tests-only `pcb_bridge.execution_outcome` helper. Production release safety continues to come from observed release state and remaining clients.
- Unlocked primary snapshots hash the copy stream, then independently hash the final source and destination. Source reads decrease from three to two. Rejected the suggestion to remove/threshold the final source hash: size and mtime cannot detect same-size, same-timestamp source edits. Locked LMC/icdb streams and owned lock snapshots retain their existing behavior; no source-rehash skip flag is added.
Validation for this follow-up: 287 targeted cases passed through the isolated mutex/PYTHONPATH wrapper (`test_batch_status`, `test_batch_status_faults`, `test_review_backend_followup`, `test_scoped_manifest`, `test_pcb_bridge`, `test_management_retry_blockers`, `test_backup_recovery`, `test_library_lock`, `test_management`). AST parsing, `git diff --check`, and original newline-style checks passed. No real Mentor, COM automation, shared library or process control was exercised; no full-suite run was requested.
@@ -0,0 +1,9 @@
# Application integration review unit
Base: codex/review-native-backend. Behavior: verification, ICDB batch checking and CBB management have separate tabs; background checks yield between items, keep browsing responsive and let other native tasks queue. READY targets are excluded at execution, status refresh is scoped, and manual version/copy decisions remain explicit.
Failure safety: a released item failure can continue independent targets; uncertain native ownership retains evidence and mappings. There is no residual-session release backend in this review stage: its button and result actions are hidden, and its callback is inert. The next PR restores the complete release entry together with its tested backend, rather than exposing a button with a missing import. No automatic Repair or native version selection is added.
Rollback: revert this UI commit before its dependent release PR; after dependents, revert in reverse order or close the current program and use the prior candidate. This does not roll back library writes.
Validation: 1,545 passed (one existing pywinauto COM-threading warning), compileall and diff checks passed. Release-specific tests are introduced in the dependent PR, never discarded from the final tree. Windows 10, real shared-library concurrency and field ICDB recovery remain pending.
@@ -0,0 +1,9 @@
# 评论 275:占用复核与变更报告
校验和管理共用历史释放记录复核:旧 JSON/内存租约触发实际进程、地址、独占文件和导出副本证明,不直接视为真实占用,不结束进程或执行 Repair。确认释放后归档旧记录并继续;失败且本项尚未启动时保留原记录,结果不会把本项标成未释放。校验结果兼容新增 release_proof,管理首次原生调用前保存释放经过;进程释放不等于历史数据已恢复。
写后仅对原先的目标 Work/Cert、中心库配置和共享依赖范围生成 SHA-256 差分,报告新增、删除、修改路径,并保存写后清单。范围沿用原有 ManifestScope.library,不增加整库备份或其他 CBB 内容哈希,不声称已证明所有其他 CBB 未被波及。已释放的部分失败也保留差分;仍有原生所有者时不为报告读取数据库。报告失败单独标为 UNCONFIRMED 并返回原因,不伪造未完成事务、不制造永久占用。
PASS 不再重复计入 unconfirmed。未改变实际原生写操作、人工备份政策或服务器保护,也没有恢复自动修复。
回归覆盖历史记录无占用/真实地址占用、首次原生调用前留证、目标及共享依赖差分、失败后差分、报告保存失败后可继续。完整回归和限制以最终验证记录及 PR 描述为准;真实 Mentor、Win10、跨机器共享库尚未因此取得新验收结论。
+7
View File
@@ -0,0 +1,7 @@
# 评论 275/283:结果口径接入
管理进度显示历史占用复核;结果分别呈现已确认的原生动作、变更清单完整性和历史会话释放事实。单项 RECOVERY_REQUIRED 但 safe_to_continue=True 时,不再声称整个队列停止;记录失败不伪装成原生上传/移除失败。
独立操作回归更新为实际历史记录归档流程:先证明当前占用已释放、保留归档字节,再进行普通验证;不自动 Repair,失败后不遗留新的占用锁。
本阶段相关 UI/独立操作/后端回归 29 passed。后端完整回归与最终集成回归另见验证记录。没有执行真实 Mentor 写操作;回退按依赖逆序,不代表恢复原生事务。
@@ -1,5 +1,7 @@
# CBB Batch Status Bridge Implementation Plan
Current behavior (2026-11-09): production status scans always query the bridge fresh and overwrite checkpoint evidence. `BatchStatusSession.scan` defaults to `resume=False`; `resume=True` remains an explicit low-level option for controlled read-only scans, not an exposed production resume feature. Its lightweight fingerprint cannot detect every native payload/database write, so saved READY/PENDING rows must not authorize production actions.
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
**Goal:** Read 180 to 3000 CBB Verify states through one resilient x86 Mentor bridge session with checkpoint recovery and authoritative `READY/PENDING` results.
@@ -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.
@@ -0,0 +1,25 @@
# Latest reviews for PR #10/#11/#12
Scope: user selected only the 2026-11-09 comments #309/#310/#313. Earlier deep-review backlog stays out of scope. Preserve ICDB automatic Repair OFF, serial writes, current icon and independent-library admission. No merge to main, issue closure or release.
## PR #10
- [ ] Reproduce BlockA releasing historical BlockB checkpoints and retained owners without naming BlockB in proof.
- [ ] Record requested block, actual proof scope, checkpoint identities and foreign names in existing release proof. Preserve original checkpoint bytes and data_recovery_confirmed=False; no new blocking gate.
- [ ] Run backend/lease regressions, compile/diff checks, commit on codex/review-native-backend.
## PR #11/#12
- [ ] Forward-merge backend into UI, then UI into residual branch; no history rewriting.
- [ ] Test one unreadable process/thread not affecting another, without fabricated modal windows; cover preview and action-time rechecks.
- [ ] Enumerate only target-process threads/windows, store incomplete-read metadata per PID. Keep unknown/active writers protected rather than adding a blind force override.
- [ ] Persist window identities and at most a 4 KiB output excerpt, preserve full preview in memory, stop duplicating activity output.
- [ ] Carry exact preview block scope into native Cancel and recheck identity/scope before clicking.
- [ ] Run residual/UI regressions, compile/diff checks, commit on residual branch.
## Chain tip
- [ ] Merge residual fixes into PR #13, preserving ca39fb3 and icon.
- [ ] Address #11's line-ending note once at the tip: application.py to LF; pin it and main_window.py in EditorConfig. Preserve all other file endings and the global * -text rule.
- [ ] Independent review, integrated full suite, compile/diff checks, validation records and fast-forward pushes to existing PR branches.
- [ ] Update PR descriptions with precise results and no new package/native acceptance. Leave #3 as historical umbrella, without merging or closing it.
@@ -1,5 +1,7 @@
# CBB 批量状态桥设计
Current behavior (2026-11-09): production status scans always query the bridge fresh and overwrite checkpoint evidence. `BatchStatusSession.scan` defaults to `resume=False`; `resume=True` remains an explicit low-level option for controlled read-only scans, not an exposed production resume feature. Its lightweight fingerprint cannot detect every native payload/database write, so saved READY/PENDING rows must not authorize production actions.
## 目标
支持对 180 到 3000 个 CBB 进行 Mentor authoritative Verify 状态读取,要求单条失败隔离、过程可恢复、结果可审计,并避免现有“一条 CBB 启动一个桥进程”的启动开销。
+18 -2
View File
@@ -1,8 +1,23 @@
from pathlib import Path
import os
import struct
project_root = Path(SPECPATH).parent
assets_root = project_root / 'src' / 'cbb_refresh_verify' / 'assets'
bridge_path = project_root / 'tools' / 'status_bridge' / 'bin' / 'CbbStatusBridge32.exe'
verify_probe_path = project_root / 'tools' / 'status_bridge' / 'bin' / 'VerifyProbe32.exe'
# App-local x86 runtime belongs beside the x86 bridge, separate from Qt/Python.
bridge_runtime = []
if bridge_path.is_file():
runtime_root = Path(os.environ.get('WINDIR', r'C:\Windows')) / 'SysWOW64'
for name in ('mfc140.dll', 'msvcp140.dll', 'vcruntime140.dll', 'concrt140.dll'):
runtime = runtime_root / name
if not runtime.is_file():
raise RuntimeError(f'Install the Microsoft VC++ 2015-2022 x86 runtime before packaging: {runtime}')
data = runtime.read_bytes()
pe_offset = struct.unpack_from('<I', data, 0x3c)[0]
if data[pe_offset:pe_offset+4] != b'PE\x00\x00' or struct.unpack_from('<H', data, pe_offset+4)[0] != 0x14c:
raise RuntimeError(f'Expected an x86 bridge runtime: {runtime}')
bridge_runtime.append((str(runtime), 'tools/status_bridge/bin'))
a = Analysis(
[str(project_root / 'src' / 'cbb_refresh_verify' / '__main__.py')],
pathex=[str(project_root / 'src'), r'F:\Sync Tool Skyworth\Work Maps\dxdesigner-part-replacement\src'],
@@ -12,12 +27,13 @@ a = Analysis(
[(str(verify_probe_path), 'tools/status_bridge/bin')]
if verify_probe_path.is_file() else []
),
datas=[(str(project_root / 'src' / 'cbb_refresh_verify' / 'save_verified_block.vbs'), 'cbb_refresh_verify'),
datas=bridge_runtime + [(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','win32timezone','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.ui.management_dialog','cbb_refresh_verify.management','cbb_refresh_verify.native_management','cbb_refresh_verify.library_lock','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'}
+19
View File
@@ -0,0 +1,19 @@
# Audited Windows release environment, 2026-10-26.
PySide6==6.11.2
PySide6_Addons==6.11.2
PySide6_Essentials==6.11.2
altgraph==0.17.5
comtypes==1.4.16
et_xmlfile==2.0.0
openpyxl==3.1.5
packaging==26.3
pefile==2024.8.26
pillow==13.0.0
pyinstaller==6.22.3
pyinstaller-hooks-contrib==2026.7
pywin32==312
pywin32-ctypes==0.2.3
pywinauto==0.6.9
setuptools==84.1.0
shiboken6==6.11.2
six==1.17.0
+3 -3
View File
@@ -1,11 +1,11 @@
[build-system]
requires = ["setuptools>=75"]
requires = ["setuptools>=84.1.0"]
build-backend = "setuptools.build_meta"
[project]
name = "cbb-refresh-verify"
version = "0.2.0"
version = "0.2.3b1"
requires-python = ">=3.12,<3.13"
dependencies = ["PySide6>=6.7,<7", "pywin32>=306", "pywinauto>=0.6.9,<0.7"]
dependencies = ["PySide6>=6.7,<7", "pywin32>=306", "pywinauto>=0.6.9,<0.7", "Pillow>=13.0.0,<14"]
[project.scripts]
cbb-refresh-verify = "cbb_refresh_verify.application:main"
+1 -1
View File
@@ -1 +1 @@
__version__ = "0.1.0"
__version__ = "0.2.3b1"
+50 -1
View File
@@ -27,6 +27,8 @@ def configure_qt_application(app):
}
for role, color in colors.items():
palette.setColor(role, QColor(color))
for role in (QPalette.ColorRole.WindowText, QPalette.ColorRole.Text, QPalette.ColorRole.ButtonText):
palette.setColor(QPalette.ColorGroup.Disabled, role, QColor('#858b94'))
app.setPalette(palette)
app.setStyleSheet(
'QWidget { color: #202124; }'
@@ -34,6 +36,7 @@ def configure_qt_application(app):
'background: #ffffff; color: #202124; selection-color: #202124; }'
'QHeaderView::section { background: #e9edf2; color: #202124; }'
'QPushButton, QToolButton { color: #202124; }'
'QPushButton:disabled, QToolButton:disabled { color: #858b94; background: #e3e6eb; }'
)
return app
@@ -43,18 +46,45 @@ def resolve_data_root(cli_value: Path | None) -> Path:
local = os.environ.get("LOCALAPPDATA")
return (Path(local) / "CbbRefreshVerify" if local else Path.home() / "AppData" / "Local" / "CbbRefreshVerify").resolve()
def _positive_int(value):
try:
number = int(value)
except ValueError:
raise argparse.ArgumentTypeError('must be a positive integer') from None
if number <= 0:
raise argparse.ArgumentTypeError('must be a positive integer')
return number
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('--owner-probe', type=Path, help=argparse.SUPPRESS)
parser.add_argument('--native-backup-worker', type=Path, help=argparse.SUPPRESS)
parser.add_argument('--management-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)
parser.add_argument('--block', action='append', default=[], help=argparse.SUPPRESS)
parser.add_argument('--limit', type=_positive_int, help='Maximum requested CBB names for --batch-lmc (default: all)')
parser.add_argument('--libspec', default='', help=argparse.SUPPRESS)
parser.add_argument('--dms-login-config', default='', help=argparse.SUPPRESS)
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.owner_probe:
from .owner_probe import owner_probe_main
return owner_probe_main(args.owner_probe)
if args.native_backup_worker:
from .native_backup import native_backup_worker_main
return native_backup_worker_main(args.native_backup_worker)
if args.management_worker:
from .native_management import management_worker_main
return management_worker_main(args.management_worker)
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)
@@ -91,6 +121,11 @@ def main(argv: Sequence[str] | None = None) -> int:
if library.error: raise RuntimeError(library.error)
names = [record.name for record in library.records if record.status != 'READY']
if not names: raise RuntimeError('中心库未读取到需要校验的 CBB')
total = len(names)
if args.limit is not None:
names = names[:args.limit]
logger.info('batch_selection selected=%s total=%s remaining=%s limit=%s',
len(names), total, total - len(names), args.limit or 'all')
requests = [VerifyRequest(mentor_path, name, context.root/'evidence',
libspec=args.libspec, dms_login_config=args.dms_login_config,
mentor_bin=args.mentor_bin, logging_context=context,
@@ -98,7 +133,21 @@ def main(argv: Sequence[str] | None = None) -> int:
mapped_remote_root=lease.remote_root,
native_lm_verify=native_lm_verify_enabled())
for name in names]
results = run_batch(requests)
def retain_mapping(reason):
lease.retain_for_recovery()
logger.warning(
'batch_drive_retained drive=%s remote=%s display=%s mentor=%s reason=%s '
'guidance=请打开此中心库的“释放残留会话…”入口,确认原生会话安全释放后再释放映射;'
'原生写入仍可能运行时请保留映射。',
lease.drive or '-', lease.remote_root or '-', lease.display_path,
mentor_path, reason)
try:
results = run_batch(requests)
except Exception:
retain_mapping('batch_exception')
raise
if any(not result.safe_to_continue for result in results):
retain_mapping('native_release_unconfirmed')
report = write_batch_report(requests, results, context.root/'reports')
logger.info('batch_report path=%s', report)
logger.info('failure_report path=%s', failure_report_path(report))
@@ -15,22 +15,18 @@
{
"rule_id": "database-restoration",
"priority": 95,
"category": "SAFE_RECOVERY",
"category": "FATAL_ACK",
"phases": ["PCB_STARTING", "DATABASE_RECOVERY", "DOCUMENT_ATTACH"],
"semantic_any": ["database restoration", "last user saved database", "数据库恢复"],
"action": "restore_last_saved",
"channels": ["uia_select", "win32_button_click", "uia_invoke"],
"postcondition": "window_gone"
"error_code": "DATABASE_RECOVERY_REQUIRED"
},
{
"rule_id": "open-lock-confirm",
"priority": 90,
"category": "SAFE_RECOVERY",
"category": "FATAL_ACK",
"phases": ["PCB_STARTING", "DOCUMENT_ATTACH"],
"semantic_any": ["continue to open the design with read/write access permission", "confirm that no other users have the design open"],
"action": "confirm_open_lock",
"channels": ["win32_button_click", "uia_invoke"],
"postcondition": "window_gone"
"error_code": "DATABASE_RECOVERY_REQUIRED"
},
{
"rule_id": "forward-annotation-confirm",
+295
View File
@@ -0,0 +1,295 @@
"""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 dataclasses import asdict, replace
import json
from pathlib import Path
import re
import shutil
import stat
from uuid import uuid4
from .verify_runner import VerifyResult, preflight
from .scoped_manifest import (ManifestScope, build_manifest, copy_verified,
hash_file as _hash, scan_tree as _scan)
def _manifest(root, *, scope=None, exclude=None, progress=None):
return build_manifest(root, scope=scope, exclude=exclude, progress=progress, hash_function=_hash)
def _copy_verified(source, destination, *, scope=None, progress=None):
return copy_verified(source, destination, scope=scope, progress=progress, hash_function=_hash)
def _paths(root):
return list(_scan(root))
def _idle_check(library, project, pcb):
from .mentor_adapter import _process_details
from .icdb_ownership import database_directories, unreleased_addresses
from contextlib import ExitStack
import win32con, win32file
directories = database_directories(library, project, pcb)
scope = (Path(project).parent, *directories)
for name in ('ExpeditionPCB.exe', 'LibraryManager.exe', 'viewdraw.exe',
'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe'):
for pid, executable, command, parent in _process_details(name):
match = _native_scope_match(command, roots=scope, files=(library, project, pcb))
if match is True:
raise ValueError(f'TARGET_NATIVE_OWNER_ACTIVE: 目标工程或共享库有原生会话,PID={pid}')
if match is None:
raise ValueError(f'TARGET_NATIVE_OWNER_UNCONFIRMED: 无法确认原生会话所属工程,PID={pid}')
addresses = unreleased_addresses(library, project, pcb)
if addresses:
raise ValueError(f'TARGET_DATABASE_ADDRESS_UNCONFIRMED: 地址记录需原生确认;未据此判定正在占用:{addresses}')
with ExitStack() as stack:
paths = [Path(library), Path(pcb).parent/'Layout/LayoutDB.lyt',
*(directory/'icdb.dat' for directory in directories)]
for path in dict.fromkeys(paths):
if path.is_file():
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, 0, None)
stack.callback(handle.Close)
def _native_scope_match(command, *, roots=(), files=()):
"""Match complete native path arguments; a missing identity remains unknown."""
from .failed_session import _command_args
if not command:
return None
expected_files = {Path(path).resolve() for path in files}
expected_roots = tuple(Path(path).resolve() for path in roots)
identities = []
for arg in _command_args(command)[1:]:
value = arg.split('=', 1)[-1].strip('"')
path = Path(value)
if not path.is_absolute():
continue
key = arg.split('=', 1)[0].lstrip('-/').casefold() if '=' in arg else ''
if (path.suffix.casefold() in ('.prj', '.pcb', '.lmc')
or path.name.casefold() in ('database', '__reusableblockssymb', 'icdb.dat')
or key in ('project', 'icdb', 'database', 'db', 'lmc', 'prj', 'pcb')):
identities.append(path.resolve())
if not identities:
return None
return any(path in expected_files or any(path == root or path.is_relative_to(root)
for root in expected_roots) for path in identities)
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
from .maintenance_entry import maintenance_project_files
projects = maintenance_project_files(project, pcb)
for path in projects:
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))
for path in projects:
if not already_references(path):
ensure_project_central_library(path, 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
library_lock = None
release_confirmed = True
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), 'backup_policy': 'manual'}
def emit(stage, message, **details):
if progress:
progress({'stage': stage, 'block': request.block_name, 'message': message, **details})
def copy_progress(stage, message):
def report(event):
details = {key: value for key, value in event.items() if key != 'stage'}
emit(stage, f'{message} {event["copied_files"]} / {event["total_files"]}',
manifest_stage=event['stage'], **details)
return report
def save(result):
record.update({'installed': installed, 'result': asdict(result)})
report = root/'recovery-result.json'
try:
root.mkdir(parents=True, exist_ok=True)
report.write_text(json.dumps(record, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
except OSError as error:
return replace(result, stderr=(result.stderr+'\n恢复报告写入失败:'+str(error)).strip())
return replace(result, evidence_path=report)
from .com_runtime import initialize_com, uninitialize_com
initialized = initialize_com()
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)
from .library_lock import LibraryLock
library_lock = LibraryLock(library, safe_to_release=lambda: release_confirmed)
library_lock.__enter__()
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 + source_size * 2) if same_drive else 0
if (shutil.disk_usage(root).free < required
or shutil.disk_usage(validation_base).free < library_size + source_size * 2
or shutil.disk_usage(library_root).free < source_size):
raise ValueError('磁盘空间不足:需要容纳隔离验证库和待安装工程。')
(root/'recovery-request.json').write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8')
emit('prepare_source', '正在准备隔离验证库;应用不自动创建回退备份…')
library_scope = ManifestScope.library(request.block_name, library.name)
original_manifest = _copy_verified(library_root, validation_dir, scope=library_scope,
progress=copy_progress('prepare_source', '正在准备验证库:'))
(root/'library-baseline-manifest.json').write_text(json.dumps(original_manifest, indent=2), encoding='utf-8')
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)
source_manifest = _copy_verified(source.parent, staged_work,
progress=copy_progress('prepare_source', '正在准备备份验证工程:'))
(root/'source-manifest.json').write_text(json.dumps(source_manifest, indent=2), encoding='utf-8')
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', '正在副本中打开备份工程并执行原生校验…')
release_confirmed = False
source_result = verifier(validation, progress=progress, flag_reader=read_library_flag_if_available)
release_confirmed = source_result.safe_to_continue
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)
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,
progress=copy_progress('prepare_source', '正在准备恢复工程:'))
_align_library(incoming/source.name, incoming/source_pcb.relative_to(source.parent), library)
idle_check(library, source, source_pcb)
if _manifest(source.parent) != source_manifest:
raise ValueError('备份来源在验证期间发生变化,目标未更改。')
if _manifest(library_root, scope=library_scope, 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', '正在重新打开恢复后的目标工程并校验…')
release_confirmed = False
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)
release_confirmed = final.safe_to_continue
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原 Work 已改名保留;应用未创建完整库备份,请查看恢复记录并使用手动备份。').strip())
return save(final)
except Exception as error:
return save(VerifyResult('FAIL' if installed else 'BLOCKED', stderr=str(error),
safe_to_continue=release_confirmed))
finally:
try:
if library_lock is not None:
library_lock.__exit__(None, None, None)
finally:
if acquired:
win32event.ReleaseMutex(mutex)
mutex.Close()
uninitialize_com(initialized)
+26 -10
View File
@@ -48,6 +48,7 @@ class BatchStatusRecord:
detail: str = ""
fingerprint: str = ""
timestamp: str = ""
block_type: str = "RULP"
@property
def completed(self) -> bool:
@@ -106,9 +107,11 @@ def fingerprint_library(lmc: Path) -> LmcFingerprint:
# Metadata alone is not a safe checkpoint key: on network shares and on
# file systems with coarse timestamp resolution, two different LMC
# contents can have the same size and mtime. Include the actual file
# digest so a changed central library can never reuse an old status row.
# digest to invalidate changed LMC bytes; payload edits remain outside this key.
content_sha256 = _sha256_file(path)
combined = hashlib.sha256()
combined.update(str(path).casefold().encode('utf-8', errors='surrogatepass'))
combined.update(b'\0')
combined.update(content_sha256.encode("ascii"))
combined.update(b"\0" + str(stat.st_size).encode("ascii"))
combined.update(b"\0" + str(stat.st_mtime_ns).encode("ascii") + b"\0")
@@ -165,6 +168,7 @@ class BatchCheckpoint:
detail=str(payload.get("detail") or ""),
fingerprint=str(payload.get("fingerprint") or ""),
timestamp=str(payload.get("timestamp") or ""),
block_type=str(payload.get("block_type") or "RULP"),
)
return cls(records)
@@ -182,7 +186,12 @@ def _now() -> str:
class BatchStatusSession:
"""Supervised serial bridge session with checkpoint recovery."""
"""Supervised serial bridge session; fresh status queries by default.
Checkpoints record scan evidence. Explicit ``resume=True`` is a low-level
opt-in for controlled read-only scans, not a production freshness proof:
the lightweight fingerprint does not cover native payload/database edits.
"""
def __init__(self, bridge: StatusBridgeClient, *, timeout_seconds: float = 10.0,
rotate_every: int = 500) -> None:
@@ -192,7 +201,7 @@ class BatchStatusSession:
self.restart_count = 0
def scan(self, names: Iterable[str], lmc_file: Path, checkpoint_path: Path,
*, block_type: str = "RULP", resume: bool = True) -> list[BatchStatusRecord]:
*, block_type: str = "RULP", resume: bool = False) -> list[BatchStatusRecord]:
fingerprint = fingerprint_library(Path(lmc_file))
if resume:
checkpoint = BatchCheckpoint.load(checkpoint_path)
@@ -211,7 +220,8 @@ class BatchStatusSession:
queried = 0
for index, name in enumerate(names):
previous = checkpoint.get(name)
if previous and previous.fingerprint == fingerprint.sha256:
if (previous and previous.status in {'READY', 'PENDING'}
and previous.fingerprint == fingerprint.sha256 and previous.block_type == block_type):
results.append(previous)
continue
try:
@@ -223,15 +233,18 @@ class BatchStatusSession:
block_name=name, status=result.status, source=result.source,
raw_status=result.raw_status, detail=result.detail,
fingerprint=fingerprint.sha256, timestamp=_now(),
block_type=block_type,
)
except BridgeUnavailable as error:
record = BatchStatusRecord(block_name=name, status="UNAVAILABLE",
detail=str(error), fingerprint=fingerprint.sha256,
timestamp=_now())
timestamp=_now(), block_type=block_type)
except BridgeResponseError as error:
message = str(error)
lower_message = message.casefold()
unavailable = any(marker in message for marker in ("LMCDLL70", "私有 MFC", "未找到可用"))
unavailable = any(marker in message for marker in ("LMCDLL70", "私有 MFC", "未找到可用")) or any(
code in lower_message for code in ('0xc0000135', '-1073741515', '3221225781',
'0xc000007b', '-1073741701', '3221225595'))
malformed = (any(marker in message for marker in (
"路径不匹配", "请求标识不匹配", "CBB 标识不匹配",
)) or "mismatch" in lower_message)
@@ -239,15 +252,15 @@ class BatchStatusSession:
else "UNAVAILABLE" if unavailable
else "MALFORMED" if malformed else "ERROR")
record = BatchStatusRecord(block_name=name, status=status, detail=message,
fingerprint=fingerprint.sha256, timestamp=_now())
if server is not None and status not in {"UNAVAILABLE", "MALFORMED"}:
fingerprint=fingerprint.sha256, timestamp=_now(), block_type=block_type)
if server is not None and status != "UNAVAILABLE":
try:
server.restart()
except BridgeUnavailable:
pass
except Exception as error: # bridge failures isolate one CBB
record = BatchStatusRecord(block_name=name, status="ERROR", detail=str(error),
fingerprint=fingerprint.sha256, timestamp=_now())
fingerprint=fingerprint.sha256, timestamp=_now(), block_type=block_type)
if server is not None:
try:
server.restart()
@@ -255,7 +268,7 @@ class BatchStatusSession:
pass
checkpoint.append(checkpoint_path, record)
results.append(record)
if record.status in {"UNAVAILABLE", "MALFORMED"} and index + 1 < len(names):
if record.status == "UNAVAILABLE" and index + 1 < len(names):
# Startup/protocol failures cannot be repaired by retrying
# the same request contract for every CBB.
# Preserve a terminal record for each remaining name so a
@@ -264,6 +277,7 @@ class BatchStatusSession:
unavailable_record = BatchStatusRecord(
block_name=remaining, status=record.status, detail=record.detail,
fingerprint=fingerprint.sha256, timestamp=_now(),
block_type=block_type,
)
checkpoint.append(checkpoint_path, unavailable_record)
results.append(unavailable_record)
@@ -282,6 +296,8 @@ def authoritative_status_map(names: Iterable[str], lmc_file: Path, checkpoint_pa
timeout_seconds: float = 10.0) -> dict[str, str]:
"""Return only bridge-backed statuses for an optional UI integration.
Production always queries fresh statuses, including after native writes;
saved READY/PENDING rows are never reused here.
A missing bridge is represented as ``UNAVAILABLE``/``UNKNOWN`` by callers;
it is never promoted to ``READY``.
"""
@@ -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
+18
View File
@@ -0,0 +1,18 @@
"""Balanced COM initialization without tearing down an existing MTA caller."""
def initialize_com():
import pythoncom
try:
pythoncom.CoInitializeEx(pythoncom.COINIT_APARTMENTTHREADED)
except pythoncom.com_error as error:
if error.hresult != -2147417850: # RPC_E_CHANGED_MODE
raise
return False # Existing apartment is usable; no reference was added.
return True
def uninitialize_com(initialized):
if initialized:
import pythoncom
pythoncom.CoUninitialize()
+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)
+2
View File
@@ -1,3 +1,5 @@
"""Shared execution defaults for GUI, batch requests and integration."""
DEFAULT_TIMEOUT_SECONDS = 600
DIALOG_AGENT_STARTUP_TIMEOUT_SECONDS = 30
WORKER_START_GATE_TIMEOUT_SECONDS = DIALOG_AGENT_STARTUP_TIMEOUT_SECONDS + 15
+160 -39
View File
@@ -1,5 +1,8 @@
"""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
import win32job
@@ -7,6 +10,54 @@ import win32process
import win32service
_automation_clients = []
_automation_clients_lock = threading.Lock()
def launch_save_helper(command, **kwargs):
"""Register the save client atomically with respect to supervisor loss."""
with _automation_clients_lock:
helper = subprocess.Popen(command, **kwargs)
_automation_clients.append(helper)
return helper
def start_supervisor_watchdog(supervisor_pid, *, cancel_path=None, stop_clients=False):
"""A crashed supervisor must not leave unsupervised automation writing.
Stop only this Python worker and its registered automation clients. Native
database owners remain alive, including a COM call already in progress.
"""
import win32api
parent = win32api.OpenProcess(win32con.SYNCHRONIZE, False, int(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()
if not stop_clients:
return
threading.Event().wait(5)
with _automation_clients_lock:
for helper in _automation_clients:
try:
if helper.poll() is None:
helper.terminate()
except OSError:
pass
finally:
parent.Close()
if cancel_path is None or stop_clients:
os._exit(75)
thread = threading.Thread(target=watch, name='supervisor-watchdog', daemon=True)
thread.start()
return thread
def startup_desktop_name(name, *, interactive_input=False):
"""Return the CreateProcess desktop target for a worker.
@@ -23,30 +74,58 @@ class DesktopWorker:
def __init__(self, command, name, *, interactive_input=False):
self.name = name
self.interactive_input = bool(interactive_input)
self.desktop = None if self.interactive_input else win32service.CreateDesktop(
name, 0, win32con.GENERIC_ALL, None)
# The worker spawns Expedition PCB and a cscript helper. Bind the whole
# tree to a job so a supervisor kill can never orphan a process.
self.job = win32job.CreateJobObject(None, '')
self.job_bound = False
self.desktop = None
self.job = None
self.handle = None
self.companions = []
self.companion_pids = []
startup = win32process.STARTUPINFO()
# subprocess.STARTUPINFO does NOT pass lpDesktop to CreateProcess.
startup.lpDesktop = startup_desktop_name(name, interactive_input=self.interactive_input)
self.handle, thread, self.pid, _ = win32process.CreateProcess(
command[0], subprocess.list2cmdline(command), None, None, False,
win32con.CREATE_NO_WINDOW, None, None, startup)
thread.Close()
self.job_bound = False
# Track the session, but never use kill-on-close: PCB descendants can
# still own a database transaction when the Python supervisor exits.
try:
info = win32job.QueryInformationJobObject(self.job, win32job.JobObjectExtendedLimitInformation)
info['BasicLimitInformation']['LimitFlags'] |= win32job.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
win32job.SetInformationJobObject(self.job, win32job.JobObjectExtendedLimitInformation, info)
win32job.AssignProcessToJobObject(self.job, self.handle)
self.job_bound = True
except Exception:
# Kill-through-job is a cleanup guarantee, not a launch requirement.
self.job_bound = False
self.desktop = None if self.interactive_input else win32service.CreateDesktop(
name, 0, win32con.GENERIC_ALL, None)
self.job = win32job.CreateJobObject(None, '')
startup = win32process.STARTUPINFO()
# subprocess.STARTUPINFO does NOT pass lpDesktop to CreateProcess.
startup.lpDesktop = startup_desktop_name(name, interactive_input=self.interactive_input)
self.handle, thread, self.pid, _ = win32process.CreateProcess(
command[0], subprocess.list2cmdline(command), None, None, False,
win32con.CREATE_NO_WINDOW, None, None, startup)
thread.Close()
try:
win32job.AssignProcessToJobObject(self.job, self.handle)
self.job_bound = True
except Exception:
# Kill-through-job is a cleanup guarantee, not a launch requirement.
self.job_bound = False
except Exception as error:
# No worker means no native descendants; a partial launch is uncertain.
error.worker_launch_release = {
'process_created': self.handle is not None,
'safe_to_continue': self.handle is None,
'worker_exited': self.handle is None,
'remaining_pids': [self.pid] if self.handle is not None else []}
if self.handle is not None:
try:
win32process.TerminateProcess(self.handle, 1)
except Exception:
pass
try:
self.handle.Close()
except Exception:
pass
if self.job is not None:
try:
self.job.Close()
except Exception:
pass
if self.desktop is not None:
try:
self.desktop.CloseDesktop()
except Exception:
pass
raise
def start_companion(self, command):
startup = win32process.STARTUPINFO()
@@ -72,56 +151,98 @@ class DesktopWorker:
return int(pid)
def poll(self):
if getattr(self, '_closed', False):
return self._exit_code
code = win32process.GetExitCodeProcess(self.handle)
return None if code == 259 else code
def _save_clients(self):
from .owner_probe import query_owners
from .failed_session import _command_args
expected = {Path(__file__).with_name(name).resolve()
for name in ('save_verified_block.vbs', 'close_failed_block.vbs')}
clients = []
# Interpreter + COM startup measures ~4.75s on the field machine.
for row in query_owners(('cscript.exe',), timeout_seconds=10):
if row.get('parent') != self.pid:
continue
args = _command_args(row['command'])
if any(Path(arg).resolve() in expected for arg in args[1:] if arg.casefold().endswith('.vbs')):
clients.append(row['pid'])
return clients
def automation_release_state(self):
try:
remaining = self._save_clients()
return {'safe_to_continue': self.poll() is not None and not remaining,
'remaining_pids': remaining}
except Exception as error:
return {'safe_to_continue': False, 'remaining_pids': [], 'error': str(error)}
def stop_automation_clients(self):
from .mentor_adapter import _terminate_pid
for pid in self._save_clients():
_terminate_pid(pid)
@property
def returncode(self):
return self.poll()
def kill(self):
if self.job_bound:
try:
win32job.TerminateJobObject(self.job, 1)
return
except Exception:
pass
# Fallback: terminate the worker and every descendant it launched.
"""Stop automation clients only; preserve native PCB/iCDB sessions."""
try:
subprocess.run(['taskkill', '/PID', str(self.pid), '/T', '/F'],
capture_output=True, timeout=20,
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
win32process.TerminateProcess(self.handle, 1)
except Exception:
pass
# The worker is now stopped and cannot spawn another save helper.
try:
self.wait(timeout=5)
self.stop_automation_clients()
except Exception:
pass
for companion in self.companions:
try:
win32process.TerminateProcess(self.handle, 1)
win32process.TerminateProcess(companion, 1)
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')
return self.poll()
def close(self):
# A job may be unavailable on a machine where the worker is already
# assigned to another job. In that case merely closing our handles
# would orphan PCB/cscript descendants, so terminate the tree before
# releasing the desktop and job handles.
if getattr(self, '_closed', False):
return
# 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:
try:
if win32process.GetExitCodeProcess(companion) == 259:
win32process.TerminateProcess(companion, 1)
companion.Close()
except Exception:
pass
self.companions.clear()
self.companion_pids.clear()
self._exit_code = self.poll()
self.handle.Close()
# Closing the last job handle reaps any survivor thanks to
# KILL_ON_JOB_CLOSE; this also covers a supervisor crash.
self._closed = True
# Native processes keep their desktop alive if manual recovery is needed.
self.job.Close()
if self.desktop is not None:
self.desktop.CloseDesktop()
+377
View File
@@ -0,0 +1,377 @@
"""Process-bound native opening check. This module never acquires PCB COM.
The caller must bind the newly launched PCB command/PID before entering here.
The check runs in that worker's private desktop and closes only that session.
"""
from __future__ import annotations
import ctypes
from ctypes import wintypes
import heapq
import hashlib
import ntpath
import os
from pathlib import Path
import re
import time
from .dialog_probe import _bounded_call
from .icdb_recovery import LOG_LIMIT, _read_log_delta, decode_log, snapshot_log
_MAX_WINDOWS = 128
_MAX_CHILDREN = 512
def _normal(path):
return ntpath.normcase(ntpath.normpath(str(path).strip()))
def _log_paths(job):
project = Path(job['project']).parent
pcb_logs = Path(job['pcb']).parent / 'LogFiles'
paths = [pcb_logs / 'PCBAutoSave.txt', pcb_logs / 'PCBLogFile.txt']
directory = project / 'database/cdbsvr/log'
directories = []
if directory.is_dir():
with os.scandir(directory) as entries:
directories = [entry.name for entry in entries if entry.is_dir(follow_symlinks=False)]
# Native names start with sortable YYYY-MM-DD HH.MM.SS. Only the
# newest candidates can describe this launch; history is never read.
for name in heapq.nlargest(8, directories):
with os.scandir(directory / name) as entries:
logs = heapq.nlargest(2, (entry.name for entry in entries
if entry.is_file(follow_symlinks=False) and entry.name.casefold().endswith('.txt')))
paths.extend(directory / name / log for log in logs)
return paths, directories
def _read_logs(job):
result = {}
paths, directories = _log_paths(job)
for path in paths:
try:
record = snapshot_log(path)
record['mtime_ns'] = path.stat().st_mtime_ns
result[str(path)] = record
except FileNotFoundError:
result[str(path)] = snapshot_log(path)
return {'files': result, 'server_directories': directories}
def _read_bounded(function):
try:
return _bounded_call(function, 2)
except TimeoutError as error:
# Abort this check, rather than spawning another reader while a slow
# share still owns the previous read. The daemon performs reads only.
raise RuntimeError('DIAGNOSTIC_LOG_READ_TIMEOUT: native evidence unavailable') from error
def snapshot_diagnostic_logs(job) -> dict:
"""Capture pre-launch content, so copied/stale successes cannot pass.
Store the returned JSON-compatible value at job['diagnostic_log_baseline'].
File count, content size and the entire read are bounded; failure is closed.
"""
started = time.time_ns()
return {'started_ns': started, **_read_bounded(lambda: _read_logs(job))}
def _fresh_logs_read(job, baseline):
paths, _ = _log_paths(job)
fresh = {}
for path in paths:
try:
stat = path.stat()
old = baseline['files'].get(str(path))
if stat.st_mtime_ns < baseline['started_ns']:
continue
if old is None:
if path.parent.name in baseline.get('server_directories', ()):
continue # An unobserved historical file cannot prove freshness.
old = {'size': 0, 'tail_sha256': hashlib.sha256(b'').hexdigest()}
if 'error' in old or (old.get('mtime_ns') == stat.st_mtime_ns and old['size'] == stat.st_size):
continue
content, appended = _read_log_delta(path, old)
if not content and stat.st_mtime_ns != old.get('mtime_ns') and stat.st_size == old['size']:
# Native PCBLog is overwritten with the same successful text.
content, _ = _read_log_delta(path, {'size': 0, 'tail_sha256': ''})
if not appended and old.get('truncated') and stat.st_size > LOG_LIMIT:
continue
fresh[str(path)] = decode_log(content)
except FileNotFoundError:
continue
return fresh
def _fresh_logs(job, baseline):
return _read_bounded(lambda: _fresh_logs_read(job, baseline))
def _load_evidence(job, pcb_pid, baseline, *, require_autosave=True):
logs = _fresh_logs(job, baseline)
project = Path(job['project']).parent
pcb = str(Path(job['pcb']))
auto_path = str(Path(job['pcb']).parent / 'LogFiles/PCBAutoSave.txt')
read_path = str(Path(job['pcb']).parent / 'LogFiles/PCBLogFile.txt')
names = re.findall(r'^Job Name:\s*(.*?)\s*$', logs.get(auto_path, ''), re.M | re.I)
if names and any(_normal(name) != _normal(pcb) for name in names):
return None
if require_autosave and not names:
return None
if 'Successfully read the design.' not in logs.get(read_path, ''):
return None
database = _normal(project / 'database')
project_file = _normal(job['project'])
for path, text in logs.items():
if path in (auto_path, read_path):
continue
db_paths = re.findall(r'S: Project path \[(.*?)\]', text)
prj_paths = re.findall(r'S: Project file \(\.prj\) path \[(.*?)\]', text)
startup = re.search(r'S: Started up automatically by iCDB Client: [^\r\n]*:' + str(pcb_pid) + r'\s*$', text, re.M)
client = re.search(r'Registered sub-client \[Expedition PCB[^\r\n]*process ID \[' + str(pcb_pid) + r'\]', text)
if (db_paths and all(_normal(value) == database for value in db_paths)
and prj_paths and all(_normal(value) == project_file for value in prj_paths)
and startup and client and 'S: iCDB database loaded' in text):
return {'pcb': pcb, 'pcb_pid': pcb_pid,
'logs': [auto_path, read_path, path], 'document_identity': 'native_path_pid_logs'}
return None
def _target_frame(windows, name):
matches = []
for window in windows:
if not window['class'].casefold().startswith('afx:') or not window.get('enabled', True):
continue
if not window['text'].casefold().startswith('expedition pcb') or f'[{name}]'.casefold() not in window['text'].casefold():
continue
mdi = {child['hwnd'] for child in window['children'] if child['class'].casefold() == 'mdiclient'}
if any(child.get('parent') in mdi and child['text'].casefold() == name.casefold()
and child['class'].casefold().startswith('afx:') for child in window['children']):
matches.append(window)
return matches[0] if len(matches) == 1 else None
def _windows(pid):
"""Read only this PID on the current desktop; cap text and enumeration work."""
import win32api
import win32gui
import win32process
user = ctypes.WinDLL('user32', use_last_error=True)
user.GetWindowTextW.argtypes = [wintypes.HWND, wintypes.LPWSTR, ctypes.c_int]
user.GetWindowTextW.restype = ctypes.c_int
deadline = time.monotonic() + .2
def text(hwnd):
if time.monotonic() >= deadline:
raise RuntimeError('DIAGNOSTIC_WINDOW_LIMIT: window scan exceeded 0.2s')
buffer = ctypes.create_unicode_buffer(4096)
# All handles belong to the external PCB PID: GetWindowText reads
# Windows' cached caption without sending a message to its UI thread.
# Custom controls may have no cached text; missing evidence fails closed.
user.GetWindowTextW(hwnd, buffer, len(buffer))
return buffer.value
result = []
seen = 0
def collect(hwnd, _):
nonlocal seen
if win32process.GetWindowThreadProcessId(hwnd)[1] != pid or not win32gui.IsWindowVisible(hwnd):
return True
seen += 1
if seen > _MAX_WINDOWS:
raise RuntimeError('DIAGNOSTIC_WINDOW_LIMIT: too many windows')
cls = win32gui.GetClassName(hwnd)
if cls.casefold() in {'uac_inputindicatoroverlaywnd', 'uac input indicator'}:
return True
children = []
count = 0
def child(ch, _):
nonlocal count
count += 1
if count > _MAX_CHILDREN:
raise RuntimeError('DIAGNOSTIC_WINDOW_LIMIT: too many controls')
child_cls = win32gui.GetClassName(ch)
if (cls == '#32770' or cls.casefold() == 'internet explorer_hidden'
or child_cls.casefold() == 'mdiclient' or child_cls.casefold().startswith('afx:')):
children.append({'hwnd': ch, 'class': child_cls, 'text': text(ch),
'id': win32gui.GetDlgCtrlID(ch), 'parent': win32gui.GetParent(ch),
'enabled': bool(win32gui.IsWindowEnabled(ch))})
return True
if cls == '#32770' or cls.casefold().startswith('afx:') or cls.casefold() == 'internet explorer_hidden':
win32gui.EnumChildWindows(hwnd, child, None)
caption = text(hwnd)
if cls.casefold() == 'internet explorer_hidden' and not caption and not children:
left, top, right, bottom = win32gui.GetWindowRect(hwnd)
if left == right and top == bottom:
return True
result.append({'hwnd': hwnd, 'pid': pid, 'class': cls, 'text': caption,
'enabled': bool(win32gui.IsWindowEnabled(hwnd)), 'children': children,
'owner': int(win32gui.GetWindow(hwnd, 4) or 0)})
return True
win32api.SetLastError(0)
try:
win32gui.EnumWindows(collect, None)
except Exception as error:
if getattr(error, 'winerror', None) not in (0, 2) or result:
raise
return result
class _NativeSession:
def __init__(self, job, pid, launcher):
if launcher is None or not callable(getattr(launcher, 'poll', None)):
raise RuntimeError('DIAGNOSTIC_LAUNCHER_REQUIRED: retain the exact launch process handle')
import win32api
import win32service
import win32con
import win32event
import win32gui
self.handles = []
self.pid = int(pid)
self.launcher = launcher
self.gui = win32gui
self.event = win32event
desktop = win32service.GetThreadDesktop(win32api.GetCurrentThreadId())
actual = win32service.GetUserObjectInformation(desktop, 2)
expected = str(job.get('desktop', '')).split('\\')[-1]
if not expected or expected.casefold() in {'default', 'winlogon', 'disconnect'} or actual.casefold() != expected.casefold():
raise RuntimeError('DIAGNOSTIC_DESKTOP_MISMATCH')
self.pcb = win32api.OpenProcess(win32con.SYNCHRONIZE, False, int(pid))
self.handles.append(self.pcb)
def pcb_alive(self):
return self.event.WaitForSingleObject(self.pcb, 0) != 0
def launcher_alive(self):
return self.launcher.poll() is None
def post(self, hwnd, message):
import win32process
if not self.pcb_alive() or win32process.GetWindowThreadProcessId(hwnd)[1] != self.pid:
raise RuntimeError('DIAGNOSTIC_STALE_WINDOW: target window identity changed')
self.gui.PostMessage(hwnd, message, 0, 0)
def close(self):
for handle in self.handles:
handle.Close()
self.handles.clear()
def _cancel(job):
if job.get('cancel_signal') and Path(job['cancel_signal']).exists():
raise RuntimeError('VERIFY_CANCELLED: native opening check cancelled')
def _pending_prompt(windows, *, closing=False, frame=None, session=None, clicked=None, pcb_name=''):
for window in windows:
known_titles = {'expedition pcb', 'expedition pcb - reusable block'}
if (window['class'].casefold().startswith('afx:') and not window.get('owner')
and (window['text'].casefold() in known_titles
or frame is not None and window['hwnd'] == frame['hwnd'])):
continue
text = ' '.join([window['text'], *(child['text'] for child in window['children'])]).casefold()
if not closing and ('select the desired product license' in text or window['text'] == 'Tip of the Day'):
return True # The caller's PID-scoped DialogAgent owns startup choices.
standard_save = (pcb_name and window['class'] == '#32770' and window['text'] == 'Expedition PCB'
and any(child['class'].casefold() == 'static'
and child['text'].strip().casefold() == f'Save changes to {pcb_name}?'.casefold()
for child in window['children'])
and {child.get('id') for child in window['children'] if child['class'].casefold() == 'button'} == {2, 6, 7})
if closing and window.get('owner') == frame['hwnd'] and (standard_save or 'do you want to save the reusable block cell' in text):
targets = [child for child in window['children'] if child['class'].casefold() == 'button'
and child.get('id') == 7 and child['text'].replace('&', '').strip().casefold() in {'no', '否(n)', '否'}
and child.get('enabled', True)]
if len(targets) == 1:
if window['hwnd'] not in clicked:
session.post(targets[0]['hwnd'], 0xF5)
clicked.add(window['hwnd'])
continue
raise RuntimeError('DIAGNOSTIC_CLOSE_UNCONFIRMED: unknown native prompt preserved; '
f"pid={window['pid']} hwnd={window['hwnd']} class={window['class']!r} "
f"title={window['text']!r}")
return False
def check_target_window(job, pcb_pid, *, emit, error_reader, launcher_process=None) -> dict:
"""Prove this launch opened its native document, close it, and prove exit.
PASS describes opening only; it does not imply refresh READY or unoccupied
shared library data. Unknown prompts are preserved for existing recovery.
"""
baseline = job.get('diagnostic_log_baseline')
if not isinstance(baseline, dict) or 'started_ns' not in baseline or 'files' not in baseline:
raise RuntimeError('DIAGNOSTIC_BASELINE_REQUIRED: snapshot before native launch')
session = _NativeSession(job, int(pcb_pid), launcher_process)
try:
deadline = time.monotonic() + max(.01, float(job['timeout']))
while True:
_cancel(job)
error = _read_bounded(error_reader) if error_reader else None
if error:
raise RuntimeError(str(error))
if not session.pcb_alive():
raise RuntimeError('DIAGNOSTIC_OPEN_UNCONFIRMED: target PCB exited before loaded evidence')
windows = _windows(int(pcb_pid))
if any(window['pid'] != int(pcb_pid) for window in windows):
raise RuntimeError('DIAGNOSTIC_PID_MISMATCH')
frame = _target_frame(windows, Path(job['pcb']).stem)
# Startup splash/control windows are transient. Unknown windows
# veto closing only once the target actually has loaded evidence.
pending = (_pending_prompt(windows, frame=frame, pcb_name=Path(job['pcb']).name)
if frame is not None else True)
evidence = (_load_evidence(job, int(pcb_pid), baseline, require_autosave=False)
if frame is not None and not pending else None)
if evidence is not None:
emit(stage='diagnostic_native_loaded_candidate', **evidence)
break
if time.monotonic() >= deadline:
raise RuntimeError('DIAGNOSTIC_OPEN_UNCONFIRMED: current target MDI/path/PID logs missing')
time.sleep(.1)
# Re-read the exact PID/frame before the sole close request.
_cancel(job)
windows = _windows(int(pcb_pid))
_pending_prompt(windows, frame=frame, pcb_name=Path(job['pcb']).name)
current = _target_frame(windows, Path(job['pcb']).stem)
if current is None or current['hwnd'] != frame['hwnd']:
raise RuntimeError('DIAGNOSTIC_CLOSE_UNCONFIRMED: target frame changed')
session.post(frame['hwnd'], 0x10)
emit(stage='diagnostic_wm_close', pcb_pid=int(pcb_pid), hwnd=frame['hwnd'])
close_deadline = time.monotonic() + 30
clicked = set()
last_pending = ''
while session.pcb_alive() or session.launcher_alive():
# Cancellation stops future work; an accepted normal close must
# still finish before its queue slot can be safely released.
windows = _windows(int(pcb_pid)) if session.pcb_alive() else []
previous_clicks = set(clicked)
pending_error = None
try:
_pending_prompt(windows, closing=True, frame=frame, session=session, clicked=clicked,
pcb_name=Path(job['pcb']).name)
except RuntimeError as error:
if not str(error).startswith('DIAGNOSTIC_CLOSE_UNCONFIRMED: unknown native prompt'):
raise
# WM_CLOSE creates and destroys native windows asynchronously;
# preserve them and wait for populated controls or process exit.
pending_error = error
if str(error) != last_pending:
last_pending = str(error)
emit(stage='diagnostic_close_pending', detail=last_pending)
for hwnd in clicked - previous_clicks:
emit(stage='diagnostic_save_no', pcb_pid=int(pcb_pid), hwnd=hwnd)
if time.monotonic() >= close_deadline:
if pending_error is not None:
raise pending_error
raise RuntimeError('DIAGNOSTIC_CLOSE_UNCONFIRMED: target PCB/launcher still running')
time.sleep(.1)
# EE7.9 buffers PCBAutoSave's complete Job Name until normal close.
# The candidate permits closing only; PASS still needs that exact path.
evidence = _load_evidence(job, int(pcb_pid), baseline)
if evidence is None:
raise RuntimeError('DIAGNOSTIC_OPEN_UNCONFIRMED: fresh full PCB path not confirmed after close')
emit(stage='diagnostic_native_open_confirmed', **evidence)
return {'status': 'PASS', 'check': 'native_open_only', 'native_processes_exited': True,
'library_ownership': 'NOT_ASSESSED', 'pcb_pid': int(pcb_pid),
'launcher_pid': getattr(launcher_process, 'pid', None), 'evidence': evidence,
'detail': 'Native target opened and its PCB/launcher exited; refresh readiness and shared library ownership not assessed.'}
finally:
session.close()
+55 -10
View File
@@ -236,6 +236,22 @@ class DialogActionExecutor:
def perform(self, snapshot: WindowSnapshot, action: dict) -> ActionResult:
channels = tuple(action.get("channels", ()))
action_name = action.get("action")
if action_name == 'user_selected_pcb_version':
try:
from .pcb_restore_prompt import validate_action_window
if channels != ('win32_button_click',):
raise ValueError('PCB_VERSION_ACTION_CHANNEL_MISMATCH')
validate_action_window(snapshot, action)
except Exception as error:
return ActionResult(error_code='PCB_VERSION_CHOICE_REQUIRED', detail=str(error))
if action_name == 'post_repair_local_read_write':
try:
from .post_repair_consent import validate_action_window
validate_action_window(snapshot, action)
if channels != ('win32_button_click',) or action.get('target') != {'control_id': 6}:
raise ValueError('POST_REPAIR_ACTION_MISMATCH')
except Exception as error:
return ActionResult(error_code='DATABASE_RECOVERY_REQUIRED', detail=str(error))
if action_name == "accept_license":
target = self._license_target(snapshot)
elif action_name == "restore_last_saved":
@@ -308,6 +324,7 @@ class DialogAgentServer:
self.channel = JsonChannel(connection)
self.channel.send({"token": paths.token}, timeout_seconds=10)
self.observed_snapshots = {}
self.observed_pids = None
@classmethod
def from_config(cls, config_path: Path, *, probe, executor=None):
@@ -332,7 +349,15 @@ class DialogAgentServer:
try:
phase = DialogPhase(request["phase"])
if request.get("op") == "observe":
snapshots = self.probe.capture(phase)
pids = request.get('pids')
if pids is not None and (not isinstance(pids, list)
or any(type(pid) is not int or pid <= 0 for pid in pids)):
raise ValueError('DIALOG_PID_SCOPE_INVALID')
self.observed_pids = set(pids) if pids is not None else None
snapshots = (self.probe.capture(phase, pids=self.observed_pids) if pids is not None
else self.probe.capture(phase))
if pids is not None:
snapshots = tuple(w for w in snapshots if w.pid in self.observed_pids)
self.observed_snapshots.clear()
for snapshot in snapshots:
self.observed_snapshots[stable_fingerprint(snapshot)] = snapshot
@@ -340,7 +365,9 @@ class DialogAgentServer:
return
if request.get("op") == "perform":
expected = self.observed_snapshots.get(request.get("fingerprint"))
if expected is None:
if (expected is None or int(request.get('hwnd', 0)) != expected.hwnd
or self.observed_pids is not None and (expected.pid not in self.observed_pids
or not self.probe.matches_identity(expected))):
self._response(request, result=ActionResult(
error_code="STALE_DIALOG",
detail="窗口已消失或指纹已变化",
@@ -406,27 +433,45 @@ class DialogAgentClient:
raise
@classmethod
def start(cls, worker, root: Path, *, timeout_seconds: float = 2.0):
def start(cls, worker, root: Path, *, timeout_seconds: float = 2.0, stop=None):
client = cls.prepare(root, desktop_name=worker.name, timeout_seconds=timeout_seconds)
try:
from .defaults import DIALOG_AGENT_STARTUP_TIMEOUT_SECONDS
worker.start_companion(dialog_agent_command(client.paths.config))
client._accept(timeout_seconds=10.0)
# Frozen imports can exceed ten seconds; PCB remains behind its gate.
client._accept(timeout_seconds=DIALOG_AGENT_STARTUP_TIMEOUT_SECONDS, stop=stop)
return client
except Exception:
client.close()
raise
def _accept(self, timeout_seconds):
def _accept(self, timeout_seconds, *, stop=None):
if self.channel is not None:
return
self.listener.settimeout(timeout_seconds)
connection, _address = self.listener.accept()
deadline = time.monotonic() + timeout_seconds
while True:
if stop is not None and stop.is_set():
raise InterruptedError('VERIFY_CANCELLED: 弹窗代理启动已取消,未启动 PCB')
remaining = deadline - time.monotonic()
if remaining <= 0:
raise TimeoutError('dialog-agent startup timed out')
self.listener.settimeout(min(.2, remaining))
try:
connection, _address = self.listener.accept()
break
except socket.timeout:
continue
channel = JsonChannel(connection)
try:
connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
hello = channel.receive(timeout_seconds)
remaining = deadline - time.monotonic()
if remaining <= 0:
raise TimeoutError('dialog-agent handshake timed out')
hello = channel.receive(min(self.timeout_seconds, remaining))
if hello.get("token") != self.paths.token:
raise DialogAgentProtocolError("dialog-agent authentication failed")
if stop is not None and stop.is_set():
raise InterruptedError('VERIFY_CANCELLED: 弹窗代理启动已取消,未启动 PCB')
self.channel = channel
except Exception:
channel.close()
@@ -457,8 +502,8 @@ class DialogAgentClient:
raise DialogAgentProtocolError(f"{response['error_code']}: {response.get('detail', '')}")
return response.get("result")
def observe(self, phase: DialogPhase) -> tuple[WindowSnapshot, ...]:
result = self._request("observe", phase)
def observe(self, phase: DialogPhase, *, pids=None) -> tuple[WindowSnapshot, ...]:
result = self._request("observe", phase, **({'pids': sorted(pids)} if pids is not None else {}))
return tuple(WindowSnapshot.from_record(item) for item in (result or ()))
def perform(self, *, hwnd: int, fingerprint: str, action: dict,
+15 -1
View File
@@ -265,9 +265,23 @@ class WindowProbe:
except Exception:
return None
def capture(self, phase: DialogPhase) -> tuple[WindowSnapshot, ...]:
def matches_identity(self, snapshot):
try:
return (self.win32gui.IsWindowVisible(snapshot.hwnd)
and self.win32process.GetWindowThreadProcessId(snapshot.hwnd)[1] == snapshot.pid
and self.win32gui.GetClassName(snapshot.hwnd) == snapshot.window_class)
except Exception:
return False
def capture(self, phase: DialogPhase, *, pids=None) -> tuple[WindowSnapshot, ...]:
snapshots = []
for hwnd in self._handles():
if pids is not None:
try:
if self.win32process.GetWindowThreadProcessId(hwnd)[1] not in pids:
continue
except Exception:
continue
try:
window_class = str(self.win32gui.GetClassName(hwnd) or "")
except Exception:
+52
View File
@@ -4,6 +4,7 @@ from __future__ import annotations
from dataclasses import dataclass, fields, replace
import json
import re
from pathlib import Path
import sys
from typing import Any, Sequence
@@ -185,6 +186,39 @@ def _decision(rule: DialogRule) -> RuleDecision:
)
def pcb_version_choice(snapshot):
"""Describe the captured native choice; never select or approve a version."""
if (snapshot.title != 'Database Restoration' or snapshot.window_class != '#32770'
or snapshot.process_name.casefold() != 'expeditionpcb.exe' or snapshot.process_role != 'pcb'
or snapshot.phase != DialogPhase.PCB_STARTING):
return None
explanation = ('The system has detected this design abnormally terminated the last time it was used. '
'The user has to decide what database (if any) to associate with the design.')
if not any(c.control_id == 6208 and ' '.join(c.name.split()) == explanation for c in snapshot.controls):
return None
candidates = []
for identifier, kind, prefix in ((6213, 'last_user_saved', 'Load the last user saved database dated '),
(6206, 'autosave', 'Load the autosave database dated ')):
controls = [c for c in snapshot.controls if c.control_id == identifier and c.class_name == 'Button']
if len(controls) != 1: return None
control = controls[0]
match = re.fullmatch(re.escape(prefix) + r'(.+)\.', ' '.join(control.name.split()))
if not match: return None
candidates.append({'kind': kind, 'control_id': identifier, 'label': control.name,
'date': match.group(1), 'enabled': control.enabled,
'selected': control.selected or control.checked})
return {'candidates': candidates, 'automatic_selection': False}
def archive_version_choice(snapshot, root):
choice = pcb_version_choice(snapshot)
if choice is None: raise ValueError('Not the recognized native PCB version choice')
path = Path(root)/'pcb-version-choice.json'
path.write_text(json.dumps({**choice, 'snapshot': snapshot.to_record()},
ensure_ascii=False, indent=2), encoding='utf-8')
return path
def decide(snapshot: WindowSnapshot, rules: Sequence[DialogRule]) -> RuleDecision:
# Windows Text Services Framework language-bar window exposed by Mentor's
# process is not a Mentor modal: it has no controls and must not abort a run.
@@ -193,6 +227,24 @@ 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)
choice = pcb_version_choice(snapshot)
if choice is not None:
labels = {'last_user_saved': '最后用户保存', 'autosave': '自动保存'}
detail = ';'.join(f'{labels[c["kind"]]}:{c["date"]}' for c in choice['candidates'])
return RuleDecision(error_code='PCB_VERSION_CHOICE_REQUIRED',
detail=f'PCB需选择恢复版本,尚未校验通过。候选版本:{detail}。未自动选择或确认任何版本。')
# 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 (
'continue to open the design with read/write access permission',
'confirm that no other users have the design open',
'database restoration', 'last user saved database', '数据库恢复')):
return RuleDecision(error_code='DATABASE_RECOVERY_REQUIRED',
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 RuleDecision(
+13 -4
View File
@@ -100,11 +100,15 @@ class DialogBackend(Protocol):
class AgentDialogBackend:
"""Adapt the private-desktop JSONL client to the supervisor backend."""
def __init__(self, client) -> None:
def __init__(self, client, *, pids=None) -> None:
self.client = client
self.pids = pids
def observe(self, phase: DialogPhase):
return self.client.observe(phase)
if self.pids is None:
return self.client.observe(phase)
pids = set(self.pids())
return tuple(w for w in self.client.observe(phase, pids=pids) if w.pid in pids)
def perform(self, snapshot: WindowSnapshot, action: dict, phase: DialogPhase) -> ActionResult:
return self.client.perform(
@@ -351,6 +355,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",
@@ -370,14 +379,14 @@ def classify_dialog(snapshot: DialogSnapshot) -> DialogDecision:
if ("database restoration" in title
or ("restore database" in joined and "last user saved database" in joined)
or "数据库恢复" in joined):
return DialogDecision(action="restore_last_saved")
return DialogDecision(error_code="DATABASE_RECOVERY_REQUIRED", detail=combined)
if "select the desired product license" in joined:
return DialogDecision(action="accept_license")
if "do you want to save the reusable block cell" in joined:
return DialogDecision(action="save_reusable_block")
if ("continue to open the design with read/write access permission" in joined
or "confirm that no other users have the design open" in joined):
return DialogDecision(action="confirm_open_lock")
return DialogDecision(error_code="DATABASE_RECOVERY_REQUIRED", detail=combined)
if "tip of the day" in combined:
return DialogDecision(action="dismiss_tip")
+219
View File
@@ -0,0 +1,219 @@
"""Close only an idle document whose native identity was already established."""
import json
import os
from pathlib import Path
import time
def _command_args(command):
import ctypes
from ctypes import wintypes
shell = ctypes.WinDLL('shell32', use_last_error=True)
kernel = ctypes.WinDLL('kernel32', use_last_error=True)
shell.CommandLineToArgvW.argtypes = [wintypes.LPCWSTR, ctypes.POINTER(ctypes.c_int)]
shell.CommandLineToArgvW.restype = ctypes.POINTER(wintypes.LPWSTR)
kernel.LocalFree.argtypes = [wintypes.HLOCAL]
kernel.LocalFree.restype = wintypes.HLOCAL
count = ctypes.c_int()
args = shell.CommandLineToArgvW(command, ctypes.byref(count))
if not args:
raise ctypes.WinError(ctypes.get_last_error())
try:
return list(args[:count.value])
finally:
kernel.LocalFree(ctypes.cast(args, wintypes.HLOCAL))
def _startup_snapshot(hwnd, pcb_pid):
import win32gui, win32process
from .dialog_models import ControlSnapshot, DialogPhase, WindowSnapshot
if win32process.GetWindowThreadProcessId(hwnd)[1] != pcb_pid:
raise ValueError('STARTUP_WINDOW_OWNER_CHANGED')
children = []
win32gui.EnumChildWindows(hwnd, lambda child, _: children.append(child), None)
controls = tuple(ControlSnapshot(child, win32gui.GetDlgCtrlID(child) & 0xffff,
win32gui.GetClassName(child), win32gui.GetWindowText(child),
enabled=bool(win32gui.IsWindowEnabled(child))) for child in children)
return WindowSnapshot(hwnd, pcb_pid, 'ExpeditionPCB.exe', 'pcb',
win32gui.GetClassName(hwnd), win32gui.GetWindowText(hwnd), DialogPhase.PCB_STARTING, controls)
def _cancel_target(snapshot):
from .post_repair_consent import exact_prompt
from .dialog_rules import pcb_version_choice
if exact_prompt(snapshot):
return 'read_write_access', next(c for c in snapshot.controls if c.control_id == 7)
if pcb_version_choice(snapshot) is not None:
buttons = [c for c in snapshot.controls if c.class_name == 'Button']
cancel = [c for c in buttons if c.control_id == 2 and c.name == 'Cancel' and c.enabled]
if (len(cancel) == 1 and {c.control_id for c in buttons} == {6212, 6213, 6206, 1, 2}
and any(c.control_id == 6211 and c.name == '* Cancelling will load no design.'
for c in snapshot.controls)):
return 'pcb_version_choice', cancel[0]
return None
def close_failed_startup(job, pcb_pid, *, baseline_pids=(), emit=lambda **event: None,
timeout_seconds=20, launcher_process=None):
"""Normally close our empty PCB after a diagnosed database startup failure.
No COM attach: the global ROT can name another session. Only the exact
read/write question is declined; no ownership is taken or version restored.
Unknown windows and documents are retained. WM_CLOSE is cooperative.
"""
import win32api, win32con, win32gui, win32process
from .mentor_adapter import _process_details
from .native_repair_ui import _current_desktop_name
from .icdb_ownership import unreleased_addresses
root = Path(job['root'])
result = {'status': 'RETAINED', 'pcb_pid': pcb_pid}
result['release'] = {'pcb_exited': False, 'launcher_exited': launcher_process is None,
'safe_to_continue': False}
if launcher_process is not None:
result['launcher_pid'] = launcher_process.pid
try:
desktop = job.get('desktop', '')
if (job.get('interactive_input') or not desktop.startswith('CbbVerify_')
or _current_desktop_name() != desktop):
raise ValueError('STARTUP_DESKTOP_UNCONFIRMED')
if not pcb_pid or pcb_pid in baseline_pids:
raise ValueError('STARTUP_PROCESS_UNCONFIRMED')
expected = os.path.normcase(os.path.abspath(job['pcb']))
deadline = time.monotonic() + max(0, timeout_seconds)
sent = False
declined_hwnd = None
declined_kind = None
cancelled_open = False
while True:
records = [r for r in _process_details('ExpeditionPCB.exe') if r[0] == pcb_pid]
if not records:
if declined_hwnd is not None:
cancelled_open = True
result['cancelled_prompt'] = declined_kind
addresses = unreleased_addresses(job['lmc_file'], job['project'], job['pcb'])
launcher_exited = launcher_process is None or launcher_process.poll() is not None
result['release'] = {'pcb_exited': True, 'launcher_exited': launcher_exited,
'addresses': addresses,
'safe_to_continue': launcher_exited and (cancelled_open or not addresses)}
if result['release']['safe_to_continue']:
result['status'] = 'CLOSED'
result.pop('detail', None)
break
result['detail'] = 'STARTUP_RELEASE_UNCONFIRMED: 等待启动器退出和数据库地址释放'
if time.monotonic() >= deadline:
break
time.sleep(.2)
continue
if not sent:
_, executable, command, _ = records[0]
args = _command_args(command)
if (Path(executable).name.casefold() != 'expeditionpcb.exe'
or '-reusablecircuit' not in [a.casefold() for a in args]
or expected not in [os.path.normcase(os.path.abspath(a)) for a in args[1:]]):
raise ValueError('STARTUP_PROCESS_UNCONFIRMED')
windows = []
def observe(hwnd, _):
if (win32process.GetWindowThreadProcessId(hwnd)[1] == pcb_pid
and win32gui.IsWindowVisible(hwnd)):
windows.append(hwnd)
win32api.SetLastError(0)
win32gui.EnumWindows(observe, None)
if declined_hwnd is not None and declined_hwnd not in windows:
cancelled_open = True
result['cancelled_prompt'] = declined_kind
if declined_hwnd is None:
for hwnd in windows:
if win32gui.GetClassName(hwnd) != '#32770':
continue
snapshot = _startup_snapshot(hwnd, pcb_pid)
target = _cancel_target(snapshot)
if target is None:
continue
# Re-read immediately before declining; never select a version.
current = _startup_snapshot(hwnd, pcb_pid)
if _cancel_target(current) != target or current != snapshot:
raise ValueError('STARTUP_CANCEL_PROMPT_CHANGED')
declined_kind, cancel = target
win32gui.PostMessage(cancel.handle, win32con.BM_CLICK, 0, 0)
declined_hwnd = hwnd
emit(stage='startup_open_declined', pcb_pid=pcb_pid, hwnd=hwnd,
control_id=cancel.control_id, prompt=declined_kind)
break
if declined_hwnd is not None:
continue
main = [w for w in windows if win32gui.GetClassName(w).startswith('Afx:')
and win32gui.GetWindowText(w).strip() in (
'Expedition PCB', 'Expedition PCB - Reusable Block')
and win32gui.IsWindowEnabled(w)]
observed = [{'hwnd': w, 'class': win32gui.GetClassName(w),
'title': win32gui.GetWindowText(w), 'enabled': bool(win32gui.IsWindowEnabled(w))}
for w in windows]
benign = [w for w in observed if w['title'] == '' and w['class'] in (
'UAC_InputIndicatorOverlayWnd', 'UAC Input Indicator')]
for window in observed:
if window['class'] == 'Internet Explorer_Hidden' and window['title'] == '':
window['rect'] = list(win32gui.GetWindowRect(window['hwnd']))
window['children'] = []
win32api.SetLastError(0)
win32gui.EnumChildWindows(window['hwnd'],
lambda hwnd, _: window['children'].append(int(hwnd)), None)
left, top, right, bottom = window['rect']
if left == right and top == bottom and not window['children']:
benign.append(window)
unknown = [w for w in observed if w['hwnd'] not in main and w not in benign]
result.update(owned_windows=observed, unknown_windows=unknown,
benign_auxiliary_windows=benign)
documents = []
def child(hwnd, _):
if (win32gui.GetClassName(hwnd) == 'MDIClient'
and win32gui.GetWindow(hwnd, win32con.GW_CHILD)):
documents.append(hwnd)
if len(main) == 1:
win32api.SetLastError(0)
win32gui.EnumChildWindows(main[0], child, None)
addresses = unreleased_addresses(job['lmc_file'], job['project'], job['pcb'])
if len(main) == 1 and not unknown and not documents and (cancelled_open or not addresses):
win32gui.PostMessage(main[0], win32con.WM_CLOSE, 0, 0)
sent = True
emit(stage='startup_close_requested', pcb_pid=pcb_pid, hwnd=main[0])
# Observe exit even when the caller requested no extra wait.
continue
result['detail'] = 'STARTUP_IDLE_UNCONFIRMED: 等待空闲窗口和数据库释放'
# After the single owned WM_CLOSE, WMI may lose the executable/
# command fields before removing the PID. Only observe exit here;
# never issue another close or treat missing fields as release.
if time.monotonic() >= deadline:
if sent:
result['detail'] = 'STARTUP_EXIT_UNCONFIRMED: 已请求正常关闭,但 PCB 尚未退出'
break
time.sleep(.2)
except Exception as error:
result['detail'] = str(error)
(root/'startup-close.json').write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding='utf-8')
emit(stage='startup_close_result', **result)
return result
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,44 @@
"""Reports for the explicit visible non-READY 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'
and attempt.get('native_status') == 'REPAIRED'
and attempt.get('validation_passed') is True
and result.status == 'PASS' and result.library_flag == 'GREEN'
and result.safe_to_continue
for result in results for attempt in result.recovery_attempts)
review = sum(attempt.get('status') == 'RESTORED_REVIEW_REQUIRED' for attempt in attempts)
version_choice = sum(attempt.get('status') == 'PCB_VERSION_CHOICE_REQUIRED'
and attempt.get('native_status') == 'REPAIRED'
and attempt.get('validation_passed') is False for attempt in attempts)
pending = sum(attempt.get('status') == 'REPAIRED_UNVERIFIED'
and attempt.get('native_status') == 'REPAIRED' for attempt in attempts)
return {'total': len(results), 'passed': sum(r.status == 'PASS' for r in results),
'checked_without_repair': sum(r.status == 'CHECKED' for r in results),
'issues_found': sum(r.error_category == 'ICDB_REPAIR_REQUIRED' for r in results),
'in_use': sum(r.error_category == 'ICDB_DATABASE_IN_USE' for r in results),
'unconfirmed': sum(r.status not in ('PASS', 'CHECKED', 'SKIPPED', 'CANCELLED')
and r.error_category not in ('ICDB_REPAIR_REQUIRED', 'ICDB_DATABASE_IN_USE') for r in results),
'cancelled': sum(r.status == 'CANCELLED' for r in results),
'skipped': sum(r.status == 'SKIPPED' for r in results),
'repaired': repaired, 'review_required': review,
'version_choice_required': version_choice,
'repaired_unverified': pending,
'repair_unconfirmed': len(attempts)-repaired-review-version_choice-pending}
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': 'visible_non_ready_icdb_batch_check', 'automatic_repair': False,
'library': str(requests[0].lmc_file), 'includes_ready': False,
'target_names': [request.block_name for request in requests],
'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()]
+176
View File
@@ -0,0 +1,176 @@
"""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)
_ICDB_MESSAGE = re.compile(r'(?<![A-Za-z0-9_])icdb(?![A-Za-z0-9_.\\/])', re.I)
_FAILURE_MESSAGE = re.compile(
r'\b(?:error|failed|failure|unable|cannot|could\s+not|lost|corrupt(?:ed|ion)?|'
r'inconsistent|unsupported|refused|denied)\b|失败|错误|异常|无法|损坏|失联|拒绝|未完成', re.I)
def _icdb_error_paragraphs(text, *, error_message=False):
text = str(text or '').replace('\r', '')
for record in _session_losses(text):
yield record['native_message'].strip()
for paragraph in text.splitlines():
# A pathname or our own category label is not native error content.
message = re.sub(r'\[[^\]\n]*[\\/][^\]\n]*\]', '', paragraph)
if _ICDB_MESSAGE.search(message) and (error_message or _FAILURE_MESSAGE.search(message)):
yield paragraph.strip()
def icdb_error_content(text, *, error_message=False):
"""Extract failure paragraphs mentioning iCDB; codes/healthy text do not qualify."""
return '\n\n'.join(dict.fromkeys(_icdb_error_paragraphs(text, error_message=error_message)))
def read_icdb_error(path, baseline):
"""Retain only new native error content, with the same bounded freshness rules."""
data, appended = _read_log_delta(path, baseline)
if not appended and (not baseline or baseline.get('truncated') or 'icdb_errors' not in baseline):
return ''
previous = baseline.get('icdb_errors', [])
return '\n\n'.join(message for message in _icdb_error_paragraphs(decode_log(data))
if appended or ' '.join(message.split()) not in previous)
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,
'icdb_errors': [' '.join(message.split()) for message in _icdb_error_paragraphs(decode_log(tail))],
'session_losses': losses}
except FileNotFoundError:
return {'size': 0, 'tail_sha256': hashlib.sha256(b'').hexdigest(), 'icdb_errors': []}
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')
+26 -8
View File
@@ -41,6 +41,7 @@ def refresh_integration(pi, *, emit=lambda **event: None, settle_seconds=5, time
deadline = ActivityDeadline(timeout_seconds, clock=clock) if timeout_seconds is not None else None
in_flight = {}
executed = set()
protected_green = set()
action_history = []
green_entry = None
previous_state = None
@@ -51,6 +52,13 @@ def refresh_integration(pi, *, emit=lambda **event: None, settle_seconds=5, time
emit(stage='integration_status', statuses=state)
if green_entry is None:
green_entry = all(status == 2 for status in state.values())
if green_entry and not bool(value(pi, 'IsForwardAnnotationAllowed')):
# Verified blocks can forbid another ForwardAnnotate despite
# all four statuses being InSynch. Respect the native gate;
# the caller still requires Save/Close and authoritative READY.
emit(stage='integration_complete', statuses=state, actions=[],
policy='already_synchronized_native_action_disallowed')
return state
if previous_state is not None and state != previous_state and deadline is not None:
deadline.touch()
previous_state = state
@@ -58,6 +66,8 @@ def refresh_integration(pi, *, emit=lambda **event: None, settle_seconds=5, time
# NoCES=3 is recorded as unsupported, never claimed green.
if status not in (1, 2):
raise IntegrationError(f'{name}: unsupported status {status}')
if status != 2:
protected_green.discard(name)
for name in tuple(in_flight):
if state[name] == 2:
started, call_elapsed = in_flight.pop(name)
@@ -67,11 +77,14 @@ def refresh_integration(pi, *, emit=lambda **event: None, settle_seconds=5, time
# When all four lamps start green, mirror the manual refresh: one
# ForwardAnnotate, then only repair statuses that actually become Required.
# Non-green entry keeps the previously validated four-action route.
refreshed = ('ForwardAnnotation' in executed if green_entry
else len(executed) == len(ACTIONS))
checked = executed | protected_green
refreshed = ('ForwardAnnotation' in checked if green_entry
else len(checked) == len(ACTIONS))
if refreshed and not in_flight and all(status == 2 for status in state.values()):
emit(stage='integration_complete', statuses=state, actions=action_history,
policy='green_first_only' if green_entry else 'required_full_sequence')
policy='green_first_only' if green_entry else
'required_with_native_gates' if protected_green else 'required_full_sequence',
skipped_synchronized=sorted(protected_green))
return state
if deadline is not None and deadline.expired():
raise IntegrationError('Project Integration timeout')
@@ -80,14 +93,19 @@ def refresh_integration(pi, *, emit=lambda **event: None, settle_seconds=5, time
continue
action_started = False
for name, method in ACTIONS:
if state[name] == 2 and (name in executed or
if state[name] == 2 and (name in checked or
(green_entry and name != 'ForwardAnnotation')):
continue
allowed = bool(value(pi, 'Is' + name + 'Allowed'))
# A green item still has to receive one Verify refresh attempt.
# Mentor may report the capability as false for that item; this
# flag is a gate only for a genuinely Required (status=1) item.
if state[name] != 2 and not allowed:
# Restored, previously verified CBBs can forbid a synchronized
# action even while another action is Required. Do not invoke a
# native-prohibited method or misreport the skip as a performed call.
if state[name] == 2 and not allowed:
protected_green.add(name)
emit(stage='integration_action_skipped', action=method, initial_status=2,
reason='synchronized_native_action_disallowed')
continue
if not allowed:
emit(stage='integration_action_unavailable', action=method,
initial_status=state[name], reason='mentor_not_allowed')
raise IntegrationError(f'{name}: required but not allowed')
+606
View File
@@ -0,0 +1,606 @@
"""Uploader-compatible exclusive sidecar lease. Metadata never proves ownership."""
from datetime import datetime, timezone
from contextlib import contextmanager, ExitStack
import json
import re
import os
from pathlib import Path
import socket
import threading
from uuid import uuid4
_guard = threading.RLock()
_owners = {}
class LibraryBusy(OSError):
pass
def inspect_residual_sessions(library, *, block_names=()):
from .residual_sessions import inspect_residual_sessions as inspect
return inspect(library, block_names=block_names)
def release_residual_sessions(plan, evidence_dir, *, stop=None, force=False):
from .residual_sessions import release_residual_sessions as release
return release(plan, evidence_dir, stop=stop, force=force)
def _key(path):
return str(Path(path).resolve()).casefold()
def blocker_path(library):
library = Path(library).resolve()
return library.with_name('.' + library.stem + '.cbb-upload.blocked.json')
def checkpoint_record(path):
"""Recognize only our reserved filename and complete versioned protocol."""
path = Path(path)
if not (path.name.endswith('.cbb-upload.blocked.json') or path.name.endswith('.cbb-upload.blocked.pending')):
return None
try:
import stat
if path.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
return None
record = json.loads(path.read_text(encoding='utf-8'))
library = Path(record['library'])
expected = '.' + library.stem + '.cbb-upload.blocked'
if (record.get('protocol') != 'cbb-refresh-verify-library-lease' or record.get('version') != 1
or not library.is_absolute() or library.suffix.casefold() != '.lmc'
or path.name not in (expected+'.json', expected+'.pending')
or not re.fullmatch('[0-9a-f]{32}', str(record.get('lease_id', '')))
or not isinstance(record.get('pid'), int) or record['pid'] <= 0
or record.get('status') not in ('OPERATION_IN_PROGRESS', 'OWNER_RELEASE_UNCONFIRMED')
or not isinstance(record.get('time'), str)):
return None
return record
except (OSError, ValueError, TypeError, KeyError):
return None
def has_blocker(library):
path = blocker_path(library)
# Complete snapshots retain every file, including their source lease
# checkpoint. Only a valid relocated snapshot record can be ignored.
for marker in (path, path.with_suffix('.pending')):
if marker.exists():
record = checkpoint_record(marker)
if record is None or _key(record['library']) == _key(library):
return True
return False
def has_retained_library(library):
"""Include leases retained without a JSON checkpoint, such as PCB checks."""
path = Path(library).resolve()
key = _key(path.with_name('.' + path.stem + '.cbb-upload.lock'))
with _guard:
owner = _owners.get(key)
return bool(owner and owner['retained'])
def recheck_previous_release(library, evidence_dir, *, block_name=None, required=False, progress=None):
"""Historical records trigger fresh proof, never process termination or repair."""
if not (required or has_blocker(library) or has_retained_library(library)):
return None
def notify(stage, **details):
if progress is not None:
try:
progress({'stage': stage, 'block': block_name or '', **details})
except Exception:
import logging
logging.getLogger(__name__).warning('Release progress observer failed', exc_info=True)
notify('previous_release_check', detail='正在复核历史记录对应的实际占用')
try:
proof = release_retained_library(library, evidence_dir, block_name=block_name)
except Exception as error:
notify('previous_release_unconfirmed', detail=str(error))
raise
notify('previous_release_confirmed', release_proof=proof,
detail='已确认会话释放并归档历史记录;这不表示历史数据已恢复')
return proof
def _persist_blocker(library, status='OWNER_RELEASE_UNCONFIRMED', *, lease_id, block_name=None):
import win32api, win32process
path = blocker_path(library)
pending = path.with_suffix('.pending')
previous = checkpoint_record(path)
export_record = ({'export_analysis': previous['export_analysis']}
if previous and previous['lease_id'] == lease_id and 'export_analysis' in previous else {})
if block_name is not None:
export_record['block_name'] = block_name
elif previous and previous['lease_id'] == lease_id and 'block_name' in previous:
export_record['block_name'] = previous['block_name']
with pending.open('w', encoding='utf-8') as stream:
json.dump({**export_record, 'protocol': 'cbb-refresh-verify-library-lease', 'version': 1,
'lease_id': lease_id, 'library': str(library), 'status': status,
'machine': socket.gethostname(),
'supervisor_created': win32process.GetProcessTimes(win32api.GetCurrentProcess())['CreationTime'].isoformat(),
'pid': os.getpid(), 'time': datetime.now(timezone.utc).isoformat()}, stream)
stream.flush(); os.fsync(stream.fileno())
pending.replace(path)
class LibraryLock:
def __init__(self, library, *, safe_to_release=None, checkpoint=True, block_name=None):
library = Path(library).resolve()
self.library = library
self.path = library.with_name('.' + library.stem + '.cbb-upload.lock')
self.key = _key(self.path)
self.entered = False
self.safe_to_release = safe_to_release
self.checkpoint = checkpoint
self.block_name = block_name
self.maintenance_guard = None
self.maintenance_mutex = None
@classmethod
def for_maintenance(cls, library, archive, guard, *, safe_to_release=None):
lease = cls(library, safe_to_release=safe_to_release)
lease.maintenance_guard = guard
lease.maintenance_archive = Path(archive)
return lease
def __enter__(self):
with _guard:
owner = _owners.get(self.key)
if owner and owner['retained'] and owner['depth'] == 0 and owner.get('release_probe'):
try:
released = owner['release_probe']() is True
except Exception:
released = False
if released:
if owner.get('checkpoint', True):
marker = blocker_path(self.library)
record = checkpoint_record(marker)
if (record is None or record['lease_id'] != owner['lease_id']
or 'export_analysis' in record or marker.with_suffix('.pending').exists()):
raise LibraryBusy('协调检查点身份或导出会话尚未确认,保持库锁。')
marker.unlink()
owner['handle'].Close()
del _owners[self.key]
owner = None
if self.maintenance_guard is not None:
return _enter_maintenance(self)
import win32con, win32file
with _guard:
owner = _owners.get(self.key)
if owner:
if owner['thread'] != threading.get_ident() or owner['retained']:
raise LibraryBusy(f'中心库被其他任务占用:{self.path}')
owner['depth'] += 1
else:
if self.checkpoint and has_blocker(self.library):
raise LibraryBusy(f'中心库存在未解除的会话阻止记录,请先执行释放检查:{blocker_path(self.library)}')
try:
lease_id = uuid4().hex
handle = win32file.CreateFile(str(self.path),
win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None,
win32con.OPEN_ALWAYS, win32con.FILE_ATTRIBUTE_NORMAL, None)
except Exception as error:
if getattr(error, 'winerror', None) not in (32, 33):
raise
raise LibraryBusy(f'中心库已锁定或无法创建协调锁:{self.path}: {error}') from error
try:
data = (f'machine={socket.gethostname()}; pid={os.getpid()}; '
f'startedUtc={datetime.now(timezone.utc).isoformat()}; '
f'library={self.library}').encode('utf-8')
win32file.SetFilePointer(handle, 0, win32con.FILE_BEGIN)
win32file.SetEndOfFile(handle)
win32file.WriteFile(handle, data)
win32file.FlushFileBuffers(handle)
# Closing flushes the last-write timestamp on Windows. Set
# it explicitly before complete-copy metadata is captured.
import pywintypes
win32file.SetFileTime(handle, None, None, pywintypes.Time(datetime.now()))
if self.checkpoint:
_persist_blocker(self.library, 'OPERATION_IN_PROGRESS', lease_id=lease_id,
block_name=self.block_name)
except Exception:
handle.Close()
raise
_owners[self.key] = {'thread': threading.get_ident(), 'depth': 1,
'handle': handle, 'retained': False, 'lease_id': lease_id,
'checkpoint': self.checkpoint,
'block_name': self.block_name,
'release_probe': self.safe_to_release}
self.entered = True
return self
def snapshot_bytes(self):
data = owned_snapshot(self.path)
if data is None:
raise LibraryBusy('当前线程不拥有此库协调锁')
return data
def retain(self):
with _guard:
if self.entered:
_owners[self.key]['retained'] = True
def __exit__(self, *_):
try:
self._exit_owned()
finally:
if self.maintenance_mutex is not None:
import win32event
win32event.ReleaseMutex(self.maintenance_mutex)
self.maintenance_mutex.Close()
self.maintenance_mutex = None
def _exit_owned(self):
with _guard:
if not self.entered:
return
owner = _owners[self.key]
if not owner.get('checkpoint', True):
if self.safe_to_release is not None:
try:
released = self.safe_to_release() is True
except Exception:
released = False
if not released:
owner['retained'] = True
owner['depth'] -= 1
self.entered = False
if owner['depth'] == 0 and not owner['retained']:
owner['handle'].Close()
del _owners[self.key]
return
checkpoint = checkpoint_record(blocker_path(self.library))
if checkpoint is not None and 'export_analysis' in checkpoint:
owner['retained'] = True
if self.safe_to_release is not None:
try:
safe = self.safe_to_release() is True
except Exception:
safe = False
if not safe:
# A supervisor can time out while its native child still
# owns the DB. Keep excluding the uploader until app exit.
owner['retained'] = True
owner['depth'] -= 1
self.entered = False
if owner['depth'] == 0 and not owner['retained']:
# This JSON is our durable operation checkpoint, not the
# uploader's .lock file. Clear only after proven normal release.
marker = blocker_path(self.library)
record = checkpoint_record(marker)
if marker.exists() and (record is None or record['lease_id'] != owner['lease_id']):
owner['retained'] = True
raise LibraryBusy('协调检查点被替换或损坏,保留冲突文件及库锁。')
try:
marker.unlink(missing_ok=True)
except OSError:
owner['retained'] = True
raise
owner['handle'].Close()
del _owners[self.key]
elif owner['retained']:
marker = blocker_path(self.library)
record = checkpoint_record(marker)
if marker.exists() and (record is None or record['lease_id'] != owner['lease_id']):
raise LibraryBusy('协调检查点被替换或损坏,保留冲突文件及库锁。')
_persist_blocker(self.library, lease_id=owner['lease_id'])
def _supervisor_alive(pid):
import pywintypes, win32api, win32con, win32event
try:
handle = win32api.OpenProcess(win32con.SYNCHRONIZE, False, int(pid))
except pywintypes.error as error:
if error.winerror == 87: return False
raise LibraryBusy('无法确认原监督进程退出') from error
try:
return win32event.WaitForSingleObject(handle, 0) != win32con.WAIT_OBJECT_0
finally:
handle.Close()
def _recorded_supervisor_alive(record):
"""None means legacy/unknown identity; the native/file guard still applies."""
if record.get('machine') != socket.gethostname() or not record.get('supervisor_created'):
return None
import pywintypes, win32api, win32con, win32process
try:
handle = win32api.OpenProcess(win32con.SYNCHRONIZE | 0x1000, False, record['pid'])
except pywintypes.error as error:
return False if error.winerror == 87 else None
try:
return (win32process.GetProcessTimes(handle)['CreationTime'].isoformat() == record['supervisor_created']
and _supervisor_alive(record['pid']))
finally:
handle.Close()
def _owner_matches_scope(item, library, roots):
"""False requires an explicit other project; a missing path stays unknown."""
import ntpath
from .failed_session import _command_args
command = str(item.get('command') or '')
if not command:
return None
try:
args = _command_args(command)
except (OSError, ValueError):
return None
candidates = []
worker_flags = {'--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker'}
for index, arg in enumerate(args[1:], 1):
if arg.casefold() in worker_flags and index + 1 < len(args):
try:
request = Path(args[index + 1])
if request.stat().st_size > 1024 * 1024:
return None
record = json.loads(request.read_text(encoding='utf-8'))
for key in ('library', 'lmc_file', 'project', 'database'):
if isinstance(record.get(key), str):
candidates.append(record[key])
except (OSError, ValueError, TypeError, AttributeError):
return None
value = arg.split('=', 1)[1] if arg.startswith('-') and '=' in arg else arg
if (ntpath.isabs(value) and (ntpath.splitext(value)[1].casefold() in ('.prj', '.pcb', '.lmc')
or arg.casefold().startswith(('-project=', '-icdb='))
or args[index - 1].casefold() in ('-icdb', '-project', '-p'))):
candidates.append(value)
normalized_roots = [ntpath.normcase(ntpath.normpath(str(root))) for root in roots]
expected_library = ntpath.normcase(ntpath.normpath(str(library)))
for candidate in candidates:
path = ntpath.normcase(ntpath.normpath(candidate))
if path == expected_library:
return True
for root in normalized_roots:
try:
if ntpath.commonpath((path, root)) == root:
return True
except ValueError:
pass
return False if candidates else None
def _enter_maintenance(lease):
"""Transfer only a valid known lease, after project admission under lock."""
import win32con, win32event, win32file
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
acquired = False
handle = None
existing = None
try:
acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
if not acquired: raise LibraryBusy('已有 CBB 操作运行,维护不能接续')
with _guard:
marker = blocker_path(lease.library)
if marker.with_suffix('.pending').exists():
raise LibraryBusy('未完成检查点写入,不能自动接续')
old = marker.read_bytes() if marker.exists() else None
record = checkpoint_record(marker) if old is not None else None
if old is not None and (record is None or _key(record['library']) != _key(lease.library)):
raise LibraryBusy('维护拒绝未知、损坏或其他库的检查点')
existing = _owners.get(lease.key)
if existing:
if (not existing['retained'] or existing['depth'] != 0 or record is None
or record['pid'] != os.getpid() or record['lease_id'] != existing['lease_id']):
raise LibraryBusy('本进程库锁仍在使用或检查点身份不符')
handle = existing['handle']
else:
if record is not None and record['pid'] != os.getpid() and _recorded_supervisor_alive(record) is True:
raise LibraryBusy('原监督进程仍存在,不能接续其库锁')
handle = win32file.CreateFile(str(lease.path), win32con.GENERIC_READ | win32con.GENERIC_WRITE,
0, None, win32con.OPEN_ALWAYS, win32con.FILE_ATTRIBUTE_NORMAL, None)
# All target/process/address/exclusive-file checks finish BEFORE
# any old checkpoint replacement. Keep the exact sidecar open.
from .native_export_guard import prove_export_copies_released
if record is not None and _recorded_supervisor_alive(record) is None:
from .maintenance_entry import assert_native_idle
assert_native_idle()
with prove_export_copies_released(lease.library), lease.maintenance_guard() as proof:
if (marker.read_bytes() if marker.exists() else None) != old:
raise LibraryBusy('维护检查期间检查点变化')
if old is not None:
lease.maintenance_archive.mkdir(parents=True, exist_ok=False)
saved = lease.maintenance_archive/'previous-checkpoint.json'
with saved.open('xb') as stream:
stream.write(old); stream.flush(); os.fsync(stream.fileno())
if saved.read_bytes() != old: raise OSError('原检查点归档校验失败')
lease_id = uuid4().hex
_persist_blocker(lease.library, 'OPERATION_IN_PROGRESS', lease_id=lease_id)
_owners[lease.key] = {'thread': threading.get_ident(), 'depth': 1, 'handle': handle,
'retained': False, 'lease_id': lease_id, 'checkpoint': True,
'release_probe': lease.safe_to_release, 'block_name': None}
lease.maintenance_proof = proof
lease.entered = True
lease.maintenance_mutex = mutex
return lease
except Exception:
if handle is not None and existing is None: handle.Close()
if acquired: win32event.ReleaseMutex(mutex)
mutex.Close()
raise
def owned_snapshot(path):
"""Read only a lease held by this thread, never reopen an exclusive file."""
import win32con, win32file
with _guard:
owner = _owners.get(_key(path))
if not owner or owner['thread'] != threading.get_ident() or owner['retained']:
return None
handle = owner['handle']
position = win32file.SetFilePointer(handle, 0, win32con.FILE_CURRENT)
try:
win32file.SetFilePointer(handle, 0, win32con.FILE_BEGIN)
size = win32file.GetFileSize(handle)
return win32file.ReadFile(handle, size)[1] if size else b''
finally:
win32file.SetFilePointer(handle, position, win32con.FILE_BEGIN)
@contextmanager
def _prove_library_released(library, block_name=None, *, allow_unknown_checkpoint=False):
"""Hold all native database read handles during explicit lease release."""
import stat
import win32con, win32file
from .owner_probe import query_owners
from .scoped_manifest import scan_tree
from .native_management import _retained_workers
from .native_export_guard import assert_retained_exports_idle, prove_export_copies_released
from .native_engineering_identity import _OWNER_NAMES
library = Path(library).resolve()
assert_retained_exports_idle(library)
if any(worker.poll() is None and (allow_unknown_checkpoint
or not getattr(worker, 'cbb_library', None) or _key(worker.cbb_library) == _key(library))
for worker in _retained_workers):
raise LibraryBusy('原生管理工作进程尚未返回,不能解除协调阻止。')
from .com_runtime import initialize_com, uninitialize_com
initialized = initialize_com()
try:
names = ('LibraryManager.exe', 'ExpeditionPCB.exe', 'viewdraw.exe',
'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe', 'CleanWGLib.exe',
'cscript.exe', 'wscript.exe', 'python.exe', 'pythonw.exe',
'CbbRefreshVerify.exe', *sorted(_OWNER_NAMES))
scope_root = (Path(library).resolve().parent/'ReusableBlocksLP'/block_name/'Work').resolve() if block_name else None
shared_root = Path(library).resolve().parent/'SymbolLibs'
if allow_unknown_checkpoint and scope_root is not None:
raise LibraryBusy('未知检查点必须执行完整库释放证明。')
def check_owners():
owners = []
for item in query_owners(names):
if item['pid'] == os.getpid():
continue
if not allow_unknown_checkpoint:
roots = (scope_root, shared_root) if scope_root is not None else (Path(library).parent,)
if _owner_matches_scope(item, library, roots) is False:
continue
automation = item['name'].casefold() in ('python.exe', 'pythonw.exe', 'cbbrefreshverify.exe')
command = item['command'].casefold()
if not automation or not command or any(flag in command for flag in (
'--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker')):
owners.append(item)
if owners:
raise LibraryBusy(f'原生进程仍存在,不能解除协调阻止:{owners}')
return owners
check_owners()
if scope_root is None:
entries = scan_tree(Path(library).parent)
else:
entries = {Path(library): Path(library).lstat()}
for root in (scope_root, shared_root):
if root.exists():
entries.update(scan_tree(root))
addresses = [str(path) for path in entries if path.name.casefold() == 'saddress.adr'
and (scope_root is None or path.is_relative_to(scope_root)
or path.is_relative_to(shared_root))]
if addresses:
raise LibraryBusy(f'库中仍有数据库地址记录,不能自动解除:{addresses}')
# scan_tree already rejects links; only native candidates need file opens.
native = [path for path, metadata in entries.items() if stat.S_ISREG(metadata.st_mode) and (
path == library
or (path.name.casefold() in ('icdb.dat', 'layoutdb.lyt')
and (scope_root is None or path.is_relative_to(scope_root)
or path.is_relative_to(shared_root))))]
if library not in native:
raise LibraryBusy('目标库身份缺失,不能解除协调阻止。')
with ExitStack() as stack:
export_proof = (prove_export_copies_released(library, allow_unknown_checkpoint=True)
if allow_unknown_checkpoint else prove_export_copies_released(library))
export_copies = stack.enter_context(export_proof)
for path in native:
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
stack.callback(handle.Close)
owners = check_owners()
yield {'native_owners': owners, 'addresses': addresses, 'export_copies': export_copies,
'unknown_checkpoint_recovery': allow_unknown_checkpoint,
'exclusive_files': [str(path) for path in native]}
finally:
uninitialize_com(initialized)
def release_retained_library(library, evidence_dir, *, block_name=None):
"""Reconcile historical leases after fresh owner/address/access proof.
The upload sidecar is never deleted. This acknowledges process release,
not the correctness of a partially changed library or its recovery state.
"""
import win32con, win32event, win32file
library = Path(library).resolve(strict=True)
evidence = Path(evidence_dir).resolve()
if evidence.is_relative_to(library.parent) or library.parent.is_relative_to(evidence):
raise ValueError('释放检查证据必须位于目标库之外。')
lease = LibraryLock(library)
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
acquired = False
external = None
try:
acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
if not acquired:
raise LibraryBusy('另一个 CBB 操作仍在运行。')
with _guard:
owner = _owners.get(lease.key)
if owner and (not owner['retained'] or owner['depth']):
raise LibraryBusy('本应用操作仍在使用库锁。')
if owner is None:
try:
external = win32file.CreateFile(str(lease.path),
win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None,
win32con.OPEN_ALWAYS, win32con.FILE_ATTRIBUTE_NORMAL, None)
except Exception as error:
if getattr(error, 'winerror', None) not in (32, 33):
raise
raise LibraryBusy('其他进程仍持有库锁,不能解除。') from error
marker = blocker_path(library)
checkpoints = (marker, marker.with_suffix('.pending'))
before = {path: path.read_bytes() if path.exists() else None for path in checkpoints}
unknown = any(data is not None and checkpoint_record(path) is None for path, data in before.items())
records = [checkpoint_record(path) for path, data in before.items() if data is not None]
scoped = (block_name if block_name and all(record and record.get('block_name') == block_name
for record in records) and (owner is None or owner.get('block_name') == block_name) else None)
reconciled = [{'kind': 'checkpoint', 'path': str(path), 'recognized': metadata is not None,
**{key: (metadata or {}).get(key) for key in ('block_name', 'lease_id', 'pid', 'status', 'time')}}
for path, data in before.items() if data is not None
for metadata in (checkpoint_record(path),)]
if owner:
reconciled.append({'kind': 'retained_owner', 'path': str(lease.path),
'block_name': owner.get('block_name'), 'lease_id': owner['lease_id'],
'status': 'OWNER_RELEASE_UNCONFIRMED'})
foreign = sorted({item['block_name'] for item in reconciled
if block_name and item.get('block_name') and item['block_name'] != block_name})
proof_context = (_prove_library_released(library, allow_unknown_checkpoint=True) if unknown else
_prove_library_released(library, block_name=scoped)
if scoped else _prove_library_released(library))
with proof_context as proof:
if unknown and proof.get('unknown_checkpoint_recovery') is not True:
raise LibraryBusy('未知检查点缺少完整库释放证明,保留原文件。')
if any((path.read_bytes() if path.exists() else None) != data for path, data in before.items()):
raise LibraryBusy('释放检查期间协调检查点变化,保留原文件。')
root = evidence/('release-' + uuid4().hex)
root.mkdir(parents=True, exist_ok=False)
record = {'library': str(library), 'status': 'RELEASE_CONFIRMED', **proof,
'requested_block_name': block_name, 'proof_scope': 'BLOCK' if scoped else 'LIBRARY',
'proof_block_name': scoped, 'reconciled_checkpoints': reconciled,
'reconciled_foreign_blockers': foreign,
'unknown_checkpoint_archived': unknown,
'data_recovery_confirmed': False, 'evidence_path': str(root/'release.json')}
(root/'release.json').write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8')
for index, checkpoint in enumerate(checkpoints):
if checkpoint.exists():
data = checkpoint.read_bytes()
archived = root/f'blocker-before-{index}.json'
archived.write_bytes(data)
if archived.read_bytes() != data:
raise OSError('阻止记录归档校验失败,保持库锁。')
checkpoint.unlink() # Checkpoint JSON only; never .lock.
if owner:
owner['handle'].Close()
del _owners[lease.key]
return record
finally:
if external is not None:
external.Close()
if acquired:
win32event.ReleaseMutex(mutex)
mutex.Close()
@@ -150,13 +150,11 @@ class LibraryVerifySession:
pass
try:
if self.process.poll() is None:
self.process.terminate()
self.process.wait(timeout=5)
except Exception:
try:
self.process.kill()
except Exception:
pass
# A slow native shutdown can still be flushing the library.
# The caller records the retained process and stops the batch.
pass
def launch_library_verify(
@@ -291,9 +289,6 @@ def launch_library_verify(
session = LibraryVerifySession(target, process, int(tree.handle), library, block_name)
return session
except Exception:
if session is None:
try:
process.terminate()
except Exception:
pass
emit(stage='lm_recovery_required', lm_pid=process.pid,
detail='Verify 启动异常;保留原生会话供检查,停止批次。')
raise
+451
View File
@@ -0,0 +1,451 @@
"""User-requested native inspection with or without an existing advertisement.
An advertisement is never deleted, quarantined or called stale by this module.
Exclusive access and exact project binding permit an official inspection.
"""
from contextlib import contextmanager, ExitStack
from dataclasses import asdict, replace
import json
import os
from pathlib import Path, PureWindowsPath
import re
import stat
from uuid import uuid4
def assert_native_idle(target=None):
from .owner_probe import query_owners
from .native_management import _retained_workers
from .native_export_guard import assert_retained_exports_idle
from .native_engineering_identity import _OWNER_NAMES
from .library_lock import _key, _owner_matches_scope
library = None
roots = ()
if target is not None:
from .backup_recovery import _project_text
roots = (Path(target.project).parent, Path(target.database))
try:
lines = re.findall(r'^KEY CentralLibrary\b[^\r\n]*', _project_text(target.project), re.M)
references = [re.fullmatch(r'KEY CentralLibrary "([^"\r\n]+)"\s*', line) for line in lines]
if not references or any(match is None for match in references):
raise ValueError('CentralLibrary references are missing or invalid.')
libraries = {(Path(target.project).parent/match[1]).resolve(strict=True) for match in references}
if len(libraries) == 1 and all(path.suffix.casefold() == '.lmc' and path.is_file() for path in libraries):
library = libraries.pop()
roots += (library.parent/'SymbolLibs',)
except (OSError, ValueError):
pass # Missing/ambiguous original references cannot narrow retained ownership.
assert_retained_exports_idle(library)
if any(worker.poll() is None and (library is None or not getattr(worker, 'cbb_library', None)
or _key(worker.cbb_library) == _key(library)) for worker in _retained_workers):
raise ValueError('MAINTENANCE_OWNER_ACTIVE: 管理工作进程尚未返回')
names = ('ExpeditionPCB.exe', 'LibraryManager.exe', 'viewdraw.exe', 'iCDBProjectBackup.exe',
'ReuseBlockImporter.exe', 'CleanWGLib.exe', 'cscript.exe', 'wscript.exe',
'python.exe', 'pythonw.exe', 'CbbRefreshVerify.exe', *sorted(_OWNER_NAMES))
owners = []
for item in query_owners(names):
if item['pid'] == os.getpid():
continue
name, command = item['name'].casefold(), item['command'].casefold()
automation = name in ('python.exe', 'pythonw.exe', 'cbbrefreshverify.exe')
if not automation or not command or any(flag in command for flag in (
'--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker')):
owners.append(item)
if target is not None:
owners = [item for item in owners if _owner_matches_scope(item, library, roots) is not False]
if owners:
raise ValueError(f'MAINTENANCE_OWNER_ACTIVE: 请正常关闭原生程序/操作助手:{owners}')
def _assert_native_idle_for(target):
"""Keep test/third-party zero-argument idle probes compatible."""
import inspect
if not inspect.signature(assert_native_idle).parameters:
return assert_native_idle()
return assert_native_idle(target)
def address_snapshot(paths):
from .scoped_manifest import hash_file
return {str(path.resolve()): {'sha256': hash_file(path), 'size': path.stat().st_size,
'mtime_ns': path.stat().st_mtime_ns}
for path in paths}
def maintenance_entries(request, *, check=None):
from .verify_runner import preflight
from .scoped_manifest import scan_tree
project, _ = preflight(request)
root = Path(request.lmc_file).parent
entries = scan_tree(project.parent, check=check)
shared = root/'SymbolLibs/__ReusableBlocksSymb'
if shared.exists():
entries.update(scan_tree(shared, check=check))
for library in root.glob('*.lmc'):
info = library.lstat()
if (info.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT
or not stat.S_ISREG(info.st_mode)):
raise ValueError(f'不支持通过文件链接维护:{library}')
entries[library] = info
return entries
def _scoped_addresses(request, *, check=None, entries=None):
from .scoped_manifest import scan_tree
root = Path(request.lmc_file).parent
addresses = []
if entries is None:
entries = maintenance_entries(request, check=check)
if check is not None: check()
for path in entries:
if path.name.casefold() != 'saddress.adr':
continue
parts = tuple(part.casefold() for part in path.relative_to(root).parts)
independent = (len(parts) >= 6 and parts[0] == 'reusableblockslp'
and parts[1] != request.block_name.casefold() and parts[2] == 'work'
and parts[3:] in (('database', 'cdbsvr', 'saddress.adr'),
('pcb', 'database', 'cdbsvr', 'saddress.adr')))
if not independent:
# Current project and shared/unknown scopes remain visible to the
# selector; only exact independent other-CBB Work stores are omitted.
addresses.append(path)
return addresses
def maintenance_project_files(project, pcb):
"""A legacy linked PCB need not contain the auxiliary PCB/pcb.prj.
Its explicit ProjectFile must bind back to the main project. Never guess
template.prj (or another PRJ) as an alternative database repair target.
"""
from .backup_recovery import _project_text
project, pcb = Path(project), Path(pcb)
auxiliary = pcb.parent/'pcb.prj'
if auxiliary.is_file():
return project, auxiliary
if os.path.lexists(auxiliary):
raise ValueError(f'MAINTENANCE_TARGET_UNCONFIRMED: 工程配置不是文件:{auxiliary}')
references = re.findall(r'^KEY ProjectFile "([^"\r\n]+)"', _project_text(pcb), re.M)
if (len(references) != 1 or (pcb.parent/references[0]).resolve() != project.resolve()):
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED: 缺少辅助 pcb.prj,且 PCB 的 ProjectFile 未唯一指向当前主工程')
return (project,)
def select_maintenance_target(request, *, check=None, entries=None):
from .verify_runner import preflight
from .backup_recovery import _project_text
from .native_repair import RepairTarget
from .scoped_manifest import scan_tree
if request.maintenance is not True:
raise ValueError('MAINTENANCE_INTENT_REQUIRED')
project, pcb = preflight(request)
if entries is None:
entries = maintenance_entries(request, check=check)
candidates = []
for candidate in maintenance_project_files(project, pcb):
if not candidate.is_file():
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED: 缺少工程配置')
text = _project_text(candidate)
values = re.findall(r'^KEY iCDBDir "([^"]*)"', text, re.M)
if candidate != project and not re.search(r'^KEY iCDBDir\b', text, re.M):
continue
if (len(values) != 1 or not values[0] or PureWindowsPath(values[0]).drive
or PureWindowsPath(values[0]).root):
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED: iCDBDir 必须唯一且为工程内相对路径')
database = (candidate.parent/values[0]).resolve()
# The proven Project Backup route binds PRJ.parent/database; do not
# guess alternate stores or route shared data through another PRJ.
if database != (candidate.parent/'database').resolve() or not database.is_relative_to(project.parent.resolve()):
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED: 未验证的 PRJ 数据库映射')
if not (database/'icdb.dat').is_file():
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED: 缺少 icdb.dat')
candidates.append(RepairTarget(candidate, candidate.parent/'database'))
addresses = _scoped_addresses(request, check=check, entries=entries)
if not addresses:
# A crashed project may retain its internal open state after the server
# advertisement disappears. Explicit maintenance must still inspect it.
references = re.findall(r'^KEY ProjectFile "([^"\r\n]+)"', _project_text(pcb), re.M)
if len(references) != 1 or (pcb.parent/references[0]).resolve() != project.resolve():
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED: PCB 的 ProjectFile 未唯一指向所选主工程')
if len(candidates) != 1:
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED: 无地址记录且存在多个工程数据库,不能推测修复目标')
return candidates[0], project, pcb, addresses
if len(addresses) != 1:
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED: 需要唯一工程地址记录;共享或多个数据库不能推测修复')
matches = [target for target in candidates
if (target.database/'cdbsvr/sAddress.adr').resolve() == addresses[0].resolve()]
if len(matches) != 1:
raise ValueError('SHARED_DATABASE_REPAIR_UNSUPPORTED: 地址记录不属于唯一匹配的工程数据库')
return matches[0], project, pcb, addresses
@contextmanager
def maintenance_target_guard(request, expected=None, *, stop=None):
"""Simultaneously hold native database files, preserving every address."""
import win32con, win32file
from .scoped_manifest import scan_tree, hash_file
def check():
if stop is not None and stop.is_set():
raise ValueError('MAINTENANCE_CANCELLED: 已取消占用检查')
check()
library_root = Path(request.lmc_file).parent
# Share one complete snapshot for target/address selection and file locks.
# Refresh it again while the handles are held; do not reuse across guards.
entries = maintenance_entries(request, check=check)
target, project, pcb, addresses = select_maintenance_target(request, check=check, entries=entries)
baseline = address_snapshot(addresses)
context = {'library': str(Path(request.lmc_file).resolve()), 'block': request.block_name,
'project': str(target.project.resolve()), 'database': str(target.database.resolve()),
'addresses': baseline,
'engineering_references': {str(p.resolve()): hash_file(p)
for p in (pcb, *maintenance_project_files(project, pcb))}}
if expected is not None and context != expected:
raise ValueError('MAINTENANCE_SOURCE_CHANGED: 目标或地址记录在检查后变化')
_assert_native_idle_for(target)
check()
def native_files(snapshot):
return {path for path, info in snapshot.items() if stat.S_ISREG(info.st_mode) and (
path.suffix.casefold() == '.lmc' or path.name.casefold() in ('icdb.dat', 'layoutdb.lyt'))}
files = native_files(entries)
with ExitStack() as stack:
for path in sorted(files):
check()
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
stack.callback(handle.Close)
_assert_native_idle_for(target)
current = maintenance_entries(request, check=check)
if native_files(current) != files:
raise ValueError('MAINTENANCE_SOURCE_CHANGED: 检查期间库文件集合发生变化')
current_addresses = _scoped_addresses(request, check=check, entries=current)
if address_snapshot(current_addresses) != baseline:
raise ValueError('MAINTENANCE_SOURCE_CHANGED: 地址记录在检查期间变化')
yield {'target': target, 'context': context, 'project': project, 'pcb': pcb}
def run_icdb_check(request, *, progress=None, stop=None):
"""Open PCB diagnostically and classify this attempt's native error content."""
from .verify_runner import VerifyResult, run_verify
from .icdb_recovery import icdb_error_content
root = Path(request.evidence_dir).resolve()/('icdb-check-'+uuid4().hex[:12])
library_root = Path(request.lmc_file).resolve().parent
if root.is_relative_to(library_root) or library_root.is_relative_to(root):
return VerifyResult('FAIL', error_category='ICDB_INSPECTION_UNCONFIRMED',
stderr='检查记录目录需位于中心库之外。')
record = {'operation': 'icdb_batch_check', 'automatic_repair': False,
'library': str(request.lmc_file), 'block': request.block_name}
started = False
def save(result):
report = root/'result.json'
recorded = replace(result, evidence_path=report)
try:
report.write_text(json.dumps({**record, 'result': asdict(recorded)},
ensure_ascii=False, default=str, indent=2), encoding='utf-8')
except OSError as error:
import logging
logging.getLogger(__name__).warning('icdb_check_report_unavailable path=%s error=%s', report, error)
return result
return recorded
try:
root.mkdir(parents=True, exist_ok=False)
if stop is not None and stop.is_set():
return save(VerifyResult('CANCELLED', stderr='已取消 ICDB 检查。'))
if progress:
progress({'stage': 'icdb_startup_check', 'block': request.block_name,
'detail': '正在打开工程并检查本次错误信息'})
started = True
startup = run_verify(replace(request, maintenance=False, auto_repair=False,
diagnostic_only=True, native_lm_verify=False, post_repair_proof=None,
evidence_dir=root/'pcb-open'), progress=progress, stop=stop)
record['native_open'] = asdict(startup)
if startup.status == 'CANCELLED' or stop is not None and stop.is_set():
return save(replace(startup, status='CANCELLED', recovery_attempts=()))
if startup.status == 'PASS' and startup.safe_to_continue:
return save(replace(startup, status='CHECKED', library_flag='UNKNOWN',
stdout='工程打开正常,未发现 ICDB 错误;未执行 CBB 校验。', recovery_attempts=()))
content = icdb_error_content(startup.stderr, error_message=True)
if (startup.evidence_path
and startup.evidence_path.resolve().is_relative_to(root/'pcb-open')):
try:
saved = json.loads(startup.evidence_path.with_name('diagnostics').joinpath(
'icdb-error-content.json').read_text('utf-8'))
native = icdb_error_content(saved.get('native_message', ''))
if native:
content = '\n'.join(dict.fromkeys(filter(None, (content, native))))
record['native_error'] = saved
except (OSError, ValueError, AttributeError):
pass
if content:
return save(replace(startup, status='FAIL', library_flag='UNKNOWN',
error_category='ICDB_REPAIR_REQUIRED',
stderr='发现 ICDB 错误,未执行修复。\n'+content, recovery_attempts=()))
category = startup.error_category
if not category or category.startswith('ICDB_'):
category = 'ICDB_INSPECTION_UNCONFIRMED'
return save(replace(startup, status='FAIL' if startup.status=='PASS' else startup.status,
error_category=category, library_flag='UNKNOWN', recovery_attempts=(),
stderr=startup.stderr or '工程打开或释放未完成,尚无法确认 ICDB 状态。'))
except Exception as error:
return save(VerifyResult('FAIL', safe_to_continue=not started,
error_category='ICDB_INSPECTION_UNCONFIRMED', stderr=f'无法确认 ICDB 状态:{error}'))
def run_diagnosed_maintenance(request, *, diagnose, progress=None, stop=None):
"""Open PCB once; only a current matching native fault admits maintenance."""
from .verify_runner import VerifyResult
from .icdb_recovery import parse_session_loss
from .native_repair import select_repair_target
if stop is not None and stop.is_set():
return VerifyResult('CANCELLED', stderr='已取消,未打开工程或请求修复。')
if progress:
progress({'stage': 'icdb_startup_check', 'block': request.block_name,
'detail': '尝试打开工程,依据本次原生报错判断是否需要 ICDB 维护'})
startup = diagnose(replace(request, maintenance=False, auto_repair=False,
diagnostic_only=True, native_lm_verify=False, post_repair_proof=None))
def finish(result):
if startup.evidence_path:
report = startup.evidence_path.with_name('maintenance-result.json')
recorded = replace(result, evidence_path=report)
try:
report.write_text(json.dumps({'block_name': request.block_name,
'startup_evidence': str(startup.evidence_path), **asdict(recorded)},
ensure_ascii=False, default=str, indent=2), encoding='utf-8')
except OSError as error:
import logging
logging.getLogger(__name__).warning('maintenance_result_write_failed path=%s error=%s', report, error)
else:
result = recorded
return result
if startup.status == 'PASS' and startup.safe_to_continue:
return finish(replace(startup, status='CHECKED', library_flag='UNKNOWN',
stdout='工程打开正常,无需 ICDB 修复;未执行 CBB 校验。'))
if startup.status == 'PASS':
return finish(replace(startup, status='FAIL', stderr='工程打开后未确认会话释放,未请求 ICDB 修复。'))
if startup.status != 'FAIL' or not startup.safe_to_continue:
return startup
# Do not search prior evidence directories or treat an error-code label,
# address/checkpoint file, timeout or generic server error as a diagnosis.
diagnosis = parse_session_loss(startup.stderr)
if diagnosis is None:
return startup
try:
target = select_repair_target(request, diagnosis)
except (ValueError, OSError) as error:
return finish(replace(startup, stderr=f'{startup.stderr}\n{error}',
error_stage='icdb_target_check'))
if stop is not None and stop.is_set():
return finish(replace(startup, status='CANCELLED', stderr='已取消,未请求 ICDB 修复。'))
return run_existing_address_maintenance(request, diagnosed_target=target, startup_result=startup,
progress=progress, stop=stop)
def run_existing_address_maintenance(request, *, diagnosed_target, startup_result, progress=None, stop=None):
from .library_lock import LibraryLock
from .native_repair import run_native_repair, native_success_confirmed, repair_release_state
from .verify_runner import VerifyResult
root = Path(request.evidence_dir).resolve()/('maintenance-' + uuid4().hex[:12])
library_root = Path(request.lmc_file).resolve().parent
if root.is_relative_to(library_root) or library_root.is_relative_to(root):
return VerifyResult('BLOCKED', stderr='维护证据必须位于目标库之外', safe_to_continue=False)
root.mkdir(parents=True, exist_ok=False)
record = {'operation': 'explicit_project_maintenance', 'library': str(request.lmc_file),
'block': request.block_name, 'stage': 'preflight',
'startup_diagnosis': asdict(startup_result)}
report = root/'result.json'
owner_safe = False
recovery = None
def emit(stage, **values):
record['stage'] = stage
if progress: progress({'stage': stage, 'block': request.block_name, **values})
def save(result):
result = replace(result, evidence_path=report)
record['result'] = asdict(result)
report.write_text(json.dumps(record, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
return result
def native_event(event):
emit(event['stage'], **{key: value for key, value in event.items() if key != 'stage'})
try:
if stop is not None and stop.is_set():
return save(VerifyResult('CANCELLED', stderr='维护已取消,未启动原生操作'))
emit('preflight', detail='正在核对工程、库文件和进程占用;可请求取消')
lease = LibraryLock.for_maintenance(request.lmc_file, root/'takeover',
lambda: maintenance_target_guard(request, stop=stop), safe_to_release=lambda: owner_safe)
with lease:
owner_safe = True # Admission completed; no native client exists yet.
checked = lease.maintenance_proof
target, context = checked['target'], checked['context']
record['maintenance_context'] = context
if (target.project.resolve() != diagnosed_target.project.resolve()
or target.database.resolve() != diagnosed_target.database.resolve()):
return save(VerifyResult('FAIL', safe_to_continue=owner_safe,
error_category='ICDB_TARGET_MISMATCH', error_stage='preflight',
stderr='本次打开报错的数据库与维护目标不一致,未请求 ICDB 修复。'))
if stop is not None and stop.is_set():
raise ValueError('MAINTENANCE_CANCELLED: 已取消,未启动原生检查')
emit('icdb_ownership_check', detail='调用原生 Project Backup 检查占用及恢复要求,不执行 Repair')
owner_safe = False
inspection = run_native_repair(target, root/'native-inspection',
mentor_bin=request.mentor_bin, timeout_seconds=min(30, request.timeout_seconds),
progress=native_event, maintenance_context=context, inspection_only=True, stop=stop)
record['native_inspection'] = inspection
owner_safe = (inspection.get('release', {}).get('native_exited') is True
or inspection.get('native_pid') is None and inspection.get('worker_pid') is None)
from .native_occupancy import confirmed_inspection
if not confirmed_inspection(target, inspection):
return save(VerifyResult('BLOCKED', safe_to_continue=owner_safe,
error_category='ICDB_INSPECTION_UNCONFIRMED',
stderr='原生占用检查未确认或已取消,未请求 Repair。' + str(inspection.get('detail', inspection.get('status')))))
if inspection['status'] == 'IN_USE':
return save(VerifyResult('BLOCKED', safe_to_continue=owner_safe,
error_category='ICDB_DATABASE_IN_USE', stderr='原生工具确认工程正在使用,未请求 Repair。'))
# Native loading may retire an old address itself. Permit only
# disappearance, never a new/changed advertisement or project.
with maintenance_target_guard(request, stop=stop) as refreshed:
updated = refreshed['context']
if ({k: v for k, v in context.items() if k != 'addresses'}
!= {k: v for k, v in updated.items() if k != 'addresses'}
or any(context['addresses'].get(k) != v for k, v in updated['addresses'].items())):
raise ValueError('MAINTENANCE_SOURCE_CHANGED: 原生检查后工程或地址身份变化')
context = updated
record['post_inspection_context'] = context
if not inspection['repair_required']:
return save(VerifyResult('CHECKED', safe_to_continue=owner_safe,
stdout='检查完成,无需修复。'))
if stop is not None and stop.is_set():
raise ValueError('MAINTENANCE_CANCELLED: 已取消,未开始 Repair')
emit('icdb_diagnosis_confirmed', detail='本轮原生检查明确要求修复当前数据库,且确认未占用')
native_root = root/'native-repair'; native_root.mkdir()
attempt = native_root/'attempt.json'
with attempt.open('x', encoding='utf-8') as stream:
json.dump({'intent': 'explicit_maintenance', 'target': asdict(target),
'maintenance_context': context}, stream, default=str, ensure_ascii=False)
emit('native_repair_start', detail='核对占用后由官方工具检查/修复;应用不自动备份')
# Repeat immediately before dispatch; the worker repeats before
# launching the native process as well.
with maintenance_target_guard(request, context, stop=stop): pass
owner_safe = False
recovery = run_native_repair(target, native_root, mentor_bin=request.mentor_bin,
timeout_seconds=max(60, request.timeout_seconds), progress=native_event,
maintenance_context=context, stop=stop)
_assert_native_idle_for(target)
recovery = {**recovery, 'native_status': recovery.get('status'), 'validation_passed': False}
recovery['release'] = repair_release_state(request, target, recovery)
safe = recovery['release'].get('safe_to_continue') is True
confirmed = recovery.get('status') == 'REPAIRED' and safe and native_success_confirmed(target, recovery)
# Release follows actual clients, not the repair/content verdict.
owner_safe = safe or (recovery['release'].get('native_exited') is True
and recovery['release'].get('database_exclusive') is True
and recovery['release'].get('remaining_pids') == [])
if confirmed:
emit('native_repair_complete', detail='原生 ICDB 修复完成,CBB 待单独校验')
recovery['status'] = 'REPAIRED_UNVERIFIED'
return save(VerifyResult('REPAIRED', safe_to_continue=owner_safe,
stdout='原生 ICDB 修复完成,CBB 待单独校验。', recovery_attempts=(recovery,)))
if recovery.get('status') == 'REPAIRED':
recovery['status'] = 'UNCONFIRMED'; owner_safe = False
return save(VerifyResult('FAIL', stderr=f'{recovery["status"]}: {recovery.get("detail", "原生维护未确认修复")}',
safe_to_continue=owner_safe, recovery_attempts=(recovery,), error_category='ICDB_MAINTENANCE_RESULT'))
except Exception as error:
return save(VerifyResult('BLOCKED' if recovery is None else 'FAIL', stderr=str(error),
safe_to_continue=False, recovery_attempts=(recovery,) if recovery else (),
error_category='ICDB_MAINTENANCE_BLOCKED', error_stage=record['stage']))
+431
View File
@@ -0,0 +1,431 @@
"""Checkpointed CBB mutations with native evidence and no automatic replay."""
from dataclasses import asdict, dataclass, field, replace
from datetime import datetime, timezone
import json
from pathlib import Path, PureWindowsPath
import re
from uuid import uuid4
from .library_lock import LibraryLock, LibraryBusy
from .scoped_manifest import (ManifestScope, build_manifest, build_exclusive_library_manifest,
comparison_rules, copy_verified, hash_file, scan_tree)
@dataclass(frozen=True)
class Capability:
supported: bool
reason: str
@dataclass(frozen=True)
class ManagementRequest:
operation: str
library: Path
name: str
partition: str = 'Logical-Physical'
source: Path | None = None
auto_verify: bool = True
evidence_dir: Path = Path('management-evidence')
top_level_block: str = ''
timeout_seconds: float = 180
mapped_drive: str = ''
mapped_remote_root: str = ''
transaction_token: str = ''
check_previous_release: bool = False
@dataclass(frozen=True)
class CatalogEntry:
name: str
partition: str
engineering_identity: dict = field(default_factory=dict)
@dataclass(frozen=True)
class Catalog:
library: Path
flow: int
entries: tuple[CatalogEntry, ...]
safe_to_continue: bool = True
@dataclass(frozen=True)
class NativeOutcome:
success: bool
safe_to_continue: bool
detail: str
identity_matches: bool | None = None
evidence_path: Path | None = None
identity_proof: dict | None = None
@dataclass(frozen=True)
class ManagementResult:
operation: str
library: Path
name: str
partition: str
source: Path | None
auto_verify: bool
stage: str
status: str
safe_to_continue: bool
detail: str = ''
evidence_path: Path | None = None
release_proof: dict | None = None
change_report: dict | None = None
def validate_name(value):
if (not value or value != value.strip() or value.endswith('.') or value in ('.', '..')
or any(ord(c) < 32 or c in '<>:"/\\|?*' for c in value)
or value.split('.')[0].upper() in {'CON', 'PRN', 'AUX', 'NUL',
*(f'COM{i}' for i in range(1, 10)), *(f'LPT{i}' for i in range(1, 10))}):
raise ValueError('CBB 名称/分区不是有效单一名称,禁止路径、控制字符或保留名称。')
def source_project(source, top_level_block=''):
"""Require complete PRJ/PCB and self-contained engineering references."""
from .backup_recovery import _project_text
source = Path(source).resolve(strict=True)
if source.suffix.casefold() != '.prj' or not source.is_file():
raise ValueError('请选择完整工程的 PRJ 文件。')
scan_tree(source.parent) # Reject reparse points, including file links.
text = _project_text(source)
roots = re.findall(r'^KEY RootBlock "([^"]+)"', text, re.M)
if len(roots) != 1 or top_level_block and roots[0] != top_level_block:
raise ValueError('工程顶层块不唯一或与输入不一致。')
validate_name(roots[0])
def reference(path, key):
values = re.findall(r'^KEY ' + re.escape(key) + r' "([^"]+)"', _project_text(path), re.M)
if len(values) != 1 or PureWindowsPath(values[0]).is_absolute() or PureWindowsPath(values[0]).drive:
raise ValueError(f'{key} 必须为唯一工程内相对引用。')
resolved = (path.parent/values[0]).resolve()
if not resolved.is_relative_to(source.parent):
raise ValueError(f'{key} 越出来源工程。')
return resolved
pcb = reference(source, 'PCBDesignPath')
if not pcb.is_file() or reference(pcb, 'ProjectFile') != source:
raise ValueError('PCB 未引用所选来源工程。')
from .maintenance_entry import maintenance_project_files
for path in maintenance_project_files(source, pcb):
if not path.is_file():
raise ValueError('工程缺少 PCB 工程配置。')
# Healthy Expedition PCB projects can use Layout/LayoutDB.lyt without
# declaring an independent iCDBDir. The schematic DB stays mandatory;
# an explicitly declared PCB DB must still pass every reference check.
if path != source and not re.search(r'^KEY iCDBDir\b', _project_text(path), re.M):
continue
db = reference(path, 'iCDBDir')
if not (db/'icdb.dat').is_file():
raise ValueError('工程缺少原理图/PCB 数据库。')
if not (pcb.parent/'Layout/LayoutDB.lyt').is_file():
raise ValueError('工程缺少布局数据库。')
return source, pcb, roots[0]
def engineering_identity(source):
"""Compare actual registered engineering bytes, not a name-only acknowledgment.
Conservative until native normalization has an independently proven semantic
comparison: changed database bytes cannot be claimed to match the source.
"""
source, pcb, top = source_project(source)
from .backup_recovery import _project_text
db = re.findall(r'^KEY iCDBDir "([^"]+)"', _project_text(source), re.M)[0]
return {'top_level_block': top, 'schematic_sha256': hash_file(source.parent/db/'icdb.dat'),
'layout_sha256': hash_file(pcb.parent/'Layout/LayoutDB.lyt')}
def _write_json(path, value):
path = Path(path)
pending = path.with_suffix('.pending')
with pending.open('w', encoding='utf-8') as stream:
json.dump(value, stream, ensure_ascii=False, default=str, indent=2)
stream.flush()
import os
os.fsync(stream.fileno())
pending.replace(path)
def unfinished_operations(root):
results = []
for path in sorted(Path(root).glob('*/checkpoint.json')):
try:
record = json.loads(path.read_text(encoding='utf-8'))
if (record.get('stage') != 'complete' or record.get('safe_to_continue') is False
or record.get('status') == 'RECOVERY_REQUIRED'):
results.append({**record, 'evidence_path': str(path)})
except (OSError, ValueError):
results.append({'status': 'CHECKPOINT_UNREADABLE', 'evidence_path': str(path)})
return results
def _may_have_mutated(record):
prewrite = {'preflight', 'release_check', 'catalog_before', 'baseline', 'stage_source', 'prepare_identity'}
history = record.get('history')
return (record.get('stage') not in prewrite | {'complete'} or record.get('status') == 'RECOVERY_REQUIRED'
or not isinstance(history, list) or not history
or any(not isinstance(item, dict) or item.get('stage') not in prewrite for item in history))
def run_management(request, *, adapter=None, verifier=None, idle_check=None, progress=None):
from .verify_runner import VerifyRequest, run_verify
from .backup_recovery import _idle_check
import win32con, win32event
import pythoncom
if adapter is None:
from .native_management import NativeManagementAdapter
adapter = NativeManagementAdapter()
verifier = verifier or run_verify
idle_check = idle_check or _idle_check
root = report = None
stage = 'preflight'
history = []
mutated = uploaded = removed = False
owner_safe = True
mutex = None
acquired = False
release_proof = None
original = None
change_report = None
def invoke(callback, *args):
nonlocal owner_safe
owner_safe = False
try:
result = callback(*args)
except Exception as error:
owner_safe = getattr(error, 'safe_to_continue', False) is True
raise
owner_safe = result.safe_to_continue
return result
def checkpoint(next_stage, **details):
nonlocal stage
stage = next_stage
history.append({'stage': stage, 'time': datetime.now(timezone.utc).isoformat(), **details})
if report:
_write_json(report, {**asdict(request), 'stage': stage, 'status': 'RUNNING',
'safe_to_continue': False, 'history': history, 'backup_policy': 'manual'})
if progress:
progress({'stage': stage, 'block': request.name, 'operation': request.operation, **details})
def finish(status, detail='', safe=True):
nonlocal change_report
if mutated and original is not None and change_report is None:
change_report = {'status': 'UNCONFIRMED', 'scope': original['scope'],
**comparison_rules(scope),
'unrelated_cbb_content_checked': False,
'detail': '原生会话尚未释放,未读取写后内容'}
if safe:
try:
after = build_exclusive_library_manifest(library_root, scope=scope, progress=progress)
_write_json(root/'library-after-manifest.json', after)
before_files, after_files = original['files'], after['files']
change_report.update(status='RECORDED', detail='目标工程及共享依赖的内容差分',
added=sorted(after_files.keys()-before_files.keys()),
deleted=sorted(before_files.keys()-after_files.keys()),
modified=sorted(path for path in before_files.keys() & after_files.keys()
if before_files[path] != after_files[path]))
except Exception as error:
change_report['detail'] = f'写后内容未确认:{error}'
try:
_write_json(root/'library-changes.json', change_report)
except OSError as error:
change_report.update(status='UNCONFIRMED', evidence_error=str(error),
detail=f'变更记录保存失败:{error}')
if change_report['status'] != 'RECORDED':
detail = (detail+'\n'+change_report['detail']).strip()
result = ManagementResult(request.operation, request.library, request.name, request.partition,
request.source, request.auto_verify, 'complete', status, safe, detail, report, release_proof, change_report)
if report:
try:
_write_json(report, {**asdict(result), 'history': history, 'backup_policy': 'manual'})
except OSError as error:
result = replace(result, detail=f'{detail}\n操作记录写入失败:{error}'.strip())
return result
from .com_runtime import initialize_com, uninitialize_com
initialized = initialize_com()
try:
if request.operation not in ('add', 'update', 'remove'):
raise ValueError('不支持的管理操作。')
validate_name(request.name); validate_name(request.partition)
from .network_path import absolute_preserving_drive
library = absolute_preserving_drive(request.library)
canonical_library = library.resolve(strict=True)
library_root = canonical_library.parent
if library.suffix.casefold() != '.lmc' or not library.is_file():
raise ValueError('中心库必须为现有 LMC 文件。')
evidence = Path(request.evidence_dir).resolve()
if evidence.is_relative_to(library_root) or library_root.is_relative_to(evidence):
raise ValueError('操作记录与暂存目录必须位于目标中心库之外,且不能包含目标库。')
capability = adapter.capabilities().get(request.operation, Capability(False, '未验证的原生接口'))
if not capability.supported:
return finish('UNSUPPORTED', capability.reason)
unfinished_target = None
for unfinished in unfinished_operations(evidence):
if (unfinished.get('library') and Path(unfinished['library']).resolve() == canonical_library
and _may_have_mutated(unfinished) and (not unfinished.get('name')
or str(unfinished['name']).casefold() == request.name.casefold())):
unfinished_target = unfinished
break
source = pcb = None
if request.operation in ('add', 'update'):
if request.source is None:
raise ValueError('新增/更新需要完整来源工程。')
source, pcb, top = source_project(request.source, request.top_level_block)
if (source.parent.is_relative_to(library_root) or library_root.is_relative_to(source.parent)
or evidence.is_relative_to(source.parent)
or source.parent.is_relative_to(evidence)):
raise ValueError('来源工程、目标库与操作证据必须使用独立目录。')
root = evidence/('management-' + uuid4().hex)
root.mkdir(parents=True, exist_ok=False)
report = root/'checkpoint.json'
checkpoint('release_check')
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
if not acquired:
return finish('BLOCKED', '已有 CBB 校验/管理/恢复任务运行;本次未启动。')
from .library_lock import recheck_previous_release
release_proof = recheck_previous_release(library, root/'previous-release', block_name=request.name,
required=request.check_previous_release or bool(unfinished_target
and unfinished_target.get('safe_to_continue') is not True), progress=progress)
if release_proof is not None:
checkpoint('release_check', release_proof=release_proof)
if unfinished_target:
return finish('BLOCKED', f'存在未完成/需恢复任务,禁止自动重放:{unfinished_target["evidence_path"]}')
if hasattr(adapter, 'bind_library_mapping'):
adapter.bind_library_mapping(request.mapped_drive, request.mapped_remote_root)
with LibraryLock(library, block_name=request.name, safe_to_release=lambda: owner_safe or (
callable(getattr(adapter, 'release_confirmed', None)) and adapter.release_confirmed(library))):
work = library.parent/'ReusableBlocksLP'/request.name/'Work'
target_project, target_pcb = work/(request.name+'.prj'), work/'PCB/pcb.pcb'
if request.operation != 'add':
# Read actual engineering references when available; fallback
# paths still permit removal of catalog entries missing Work.
from .verify_runner import preflight
try:
target_project, target_pcb = preflight(VerifyRequest(library, request.name, root))
except ValueError:
pass
idle_check(library, target_project, target_pcb)
if source:
idle_check(library, source, pcb)
checkpoint('catalog_before')
owner_safe = False
before = invoke(adapter.catalog, library, root/'before')
owner_safe = before.safe_to_continue
if not owner_safe or Path(before.library).resolve() != canonical_library or before.flow != 1:
return finish('BLOCKED', '原生目录身份/流程或所有者释放未确认。仅支持已验证 DxDesigner 流程。', owner_safe)
same_name = [entry for entry in before.entries if entry.name.casefold() == request.name.casefold()]
matches = [entry for entry in same_name if entry.partition == request.partition and entry.name == request.name]
if request.operation == 'add' and same_name:
return finish('UPLOAD_FAILED', '同名 CBB 已存在;新增禁止覆盖,请使用明确的同名更新。')
if request.operation != 'add' and len(matches) != 1:
return finish('BLOCKED', '目标名称和分区必须与原生目录唯一匹配。')
if hasattr(adapter, 'preflight'):
adapter.preflight(request, before)
# Native/project owners must be idle before snapshot or mutation.
idle_check(library, target_project, target_pcb)
scope = ManifestScope.library(request.name, library.name)
checkpoint('baseline')
original = build_exclusive_library_manifest(library_root, scope=scope, progress=progress)
_write_json(root/'library-baseline-manifest.json', original)
staged = request
identity = None
if source:
checkpoint('stage_source')
source_manifest = copy_verified(source.parent, root/'source', progress=progress)
_write_json(root/'source-manifest.json', source_manifest)
staged = replace(request, source=root/'source'/source.name, top_level_block=top)
identity = engineering_identity(staged.source)
if build_manifest(source.parent) != source_manifest:
raise OSError('来源工程在暂存期间变化。')
if source and hasattr(adapter, 'prepare_add_transaction'):
checkpoint('prepare_identity')
owner_safe = False
staged, proof = adapter.prepare_add_transaction(staged, root, original_source=source)
owner_safe = proof.safe_to_continue
if not owner_safe or proof.identity is None:
return finish('UPLOAD_FAILED', proof.detail, owner_safe)
identity = proof.identity
if build_exclusive_library_manifest(library_root, scope=scope, progress=progress) != original:
raise OSError('内容基线记录后中心库发生变化,停止写入。')
if request.operation in ('remove', 'update'):
checkpoint('native_remove')
mutated = True; owner_safe = False
native = invoke(adapter.remove, request, root/'remove')
owner_safe = native.safe_to_continue
if not owner_safe or not native.success:
return finish('RECOVERY_REQUIRED', native.detail, owner_safe)
idle_check(library, target_project, target_pcb)
after = invoke(adapter.catalog, library, root/'after-remove')
owner_safe = after.safe_to_continue
if (not owner_safe or Path(after.library).resolve() != canonical_library or after.flow != 1
or any(e.name == request.name and e.partition == request.partition for e in after.entries)):
return finish('RECOVERY_REQUIRED', '原生移除后目录未确认目标缺失。', owner_safe)
removed = True
checkpoint('removed')
if request.operation == 'remove':
return finish('REMOVED', '已由原生操作移除,重新读取目录确认不存在;应用未创建备份。')
checkpoint('native_add')
mutated = True; owner_safe = False
native = invoke(adapter.add, staged, root/'add')
owner_safe = native.safe_to_continue
if not owner_safe or not native.success:
return finish('RECOVERY_REQUIRED' if removed or not owner_safe else 'UPLOAD_FAILED',
native.detail, owner_safe)
idle_check(library, target_project, target_pcb)
after = invoke(adapter.catalog, library, root/'after-add')
owner_safe = after.safe_to_continue
matches = [entry for entry in after.entries if entry.name == request.name
and entry.partition == request.partition]
proof_matches = (native.identity_matches is True and native.identity_proof == identity
if hasattr(adapter, 'prepare_add_transaction') else
len(matches) == 1 and matches[0].engineering_identity == identity)
if (not owner_safe or Path(after.library).resolve() != canonical_library or after.flow != 1
or len(matches) != 1 or not proof_matches):
return finish('RECOVERY_REQUIRED', '原生新增后名称、分区或来源工程内容未确认一致。', owner_safe)
uploaded = True
checkpoint('uploaded')
if not request.auto_verify:
return finish('UPLOADED', '上传已确认;本批次未启用自动校验。')
# Adapter catalog cannot return until its exact native owner exits.
checkpoint('verify')
owner_safe = False
verified = verifier(VerifyRequest(library, request.name, root/'verify',
mapped_drive=request.mapped_drive, mapped_remote_root=request.mapped_remote_root), progress=progress)
owner_safe = verified.safe_to_continue
checkpoint('verified', verification=asdict(verified))
good = verified.status == 'PASS' and verified.library_flag == 'GREEN' and owner_safe
return finish('UPLOADED_VERIFIED' if good else 'UPLOADED_VERIFY_FAILED',
verified.stderr or verified.library_flag_detail, owner_safe)
except Exception as error:
if uploaded:
return finish('UPLOADED_VERIFY_FAILED', str(error), owner_safe)
status = 'RECOVERY_REQUIRED' if mutated else ('UPLOAD_FAILED' if request.operation in ('add', 'update') else 'BLOCKED')
# Bad input is never described as a native upload attempt.
if root is None and isinstance(error, ValueError):
status = 'BLOCKED'
if stage == 'release_check' and not mutated:
status = 'BLOCKED'
return finish(status, str(error), owner_safe)
finally:
if mutex is not None:
if acquired:
win32event.ReleaseMutex(mutex)
mutex.Close()
uninitialize_com(initialized)
def run_management_batch(requests, *, stop=None, progress=None, **kwargs):
results = []
for request in requests:
if stop is not None and stop.is_set():
break
result = run_management(request, progress=progress, **kwargs)
results.append(result)
if progress:
progress({'stage': result.status, 'block': result.name, 'detail': result.detail,
'evidence_path': str(result.evidence_path or '')})
if not result.safe_to_continue:
break
return results
@@ -0,0 +1,124 @@
"""Prepared Add authority bound to the engine checkpoint, baseline and live lease."""
import json
import os
from pathlib import Path
import threading
from uuid import uuid4
from .management import _write_json, engineering_identity
from .scoped_manifest import build_manifest
def _read(path):
return json.loads(Path(path).read_text(encoding='utf-8'))
def fixture_authority(root, library, token):
root = Path(root).resolve()
expected = root/'native-add/fixture/mentor_lib.lmc'
owner = _read(root/'probe-owner.json')
if (not token or owner.get('token') != token or not expected.is_file()
or Path(library).resolve() != expected.resolve()
or Path(owner.get('library', '')).resolve() != expected.resolve()):
raise ValueError('Management research requires the exact newly created owned fixture.')
return {'root': str(root), 'token': token}
def current_lease(library):
from .library_lock import LibraryLock, _guard, _owners, blocker_path, checkpoint_record
lease = LibraryLock(library)
with _guard:
owner = _owners.get(lease.key)
guard = checkpoint_record(blocker_path(library))
if (owner is None or owner['retained'] or owner['thread'] != threading.get_ident()
or guard is None or guard['pid'] != os.getpid()
or guard['status'] != 'OPERATION_IN_PROGRESS'
or owner['lease_id'] != guard['lease_id']
or Path(guard['library']).resolve() != Path(library).resolve()):
raise ValueError('Management transaction requires the current thread exact active library lease.')
return {'lease_id': owner['lease_id'], 'lease_handle': int(owner['handle']), 'supervisor_pid': os.getpid()}
def _authorize(record, mentor_home):
fixture = record.get('fixture')
if fixture is not None:
fixture_authority(fixture['root'], record['library'], fixture['token'])
else:
from .native_management import NativeManagementAdapter
capability = NativeManagementAdapter(mentor_home=mentor_home).capabilities()['add']
if not capability.supported: raise ValueError(capability.reason)
def prepare_transaction(request, root, expected_identity, *, mentor_home, fixture=None):
root = Path(root).resolve()
source = Path(request.source).resolve()
if source.parent != root/'source':
raise ValueError('Native Add accepts only the management engine staged source.')
library = Path(request.library).resolve()
if root.is_relative_to(library.parent) or library.parent.is_relative_to(root):
raise ValueError('Management transaction evidence overlaps the target library.')
checkpoint = _read(root/'checkpoint.json')
stages = {item['stage'] for item in checkpoint.get('history', [])}
if (checkpoint.get('status') != 'RUNNING' or checkpoint.get('stage') != 'prepare_identity'
or Path(checkpoint['library']).resolve() != library
or checkpoint['name'] != request.name or checkpoint['partition'] != request.partition
or not {'baseline', 'stage_source'}.issubset(stages)):
raise ValueError('Native Add requires the engine baseline/staging checkpoint.')
library_baseline = _read(root/'library-baseline-manifest.json')
baseline = _read(root/'source-identity/identity.json')
if baseline.get('safe_to_continue') is not True or baseline.get('identity') != expected_identity:
raise ValueError('Native source identity evidence is missing or changed.')
record = {**current_lease(library), 'nonce': uuid4().hex, 'library': str(library),
'name': request.name, 'partition': request.partition, 'top_level_block': request.top_level_block,
'source_name': source.name, 'source_identity': engineering_identity(source),
'source_manifest': build_manifest(source.parent), 'library_baseline': library_baseline,
'expected_identity': expected_identity, 'fixture': fixture}
_authorize(record, mentor_home)
_write_json(root/'native-add-prepared.json', record)
return record['nonce']
def validate_transaction(job, root, *, check_source=True):
from .library_lock import blocker_path, checkpoint_record, _supervisor_alive
import win32api, win32con, win32file
root = Path(root).resolve()
record = _read(root/'native-add-prepared.json')
library = Path(job['library']).resolve()
source = root/'source'/record['source_name']
guard = checkpoint_record(blocker_path(library))
checkpoint = _read(root/'checkpoint.json')
if (not job.get('transaction_nonce') or job['transaction_nonce'] != record['nonce']
or Path(record['library']).resolve() != library
or any(job.get(key) != record[key] for key in ('name', 'partition', 'top_level_block', 'source_identity'))
or source.parent != root/'source' or source.resolve().parent != (root/'source').resolve()
or Path(job['source']).resolve() != source.resolve()
or guard is None or guard['lease_id'] != record['lease_id']
or guard['pid'] != record['supervisor_pid'] or guard['pid'] != job['supervisor_pid']
or guard['status'] != 'OPERATION_IN_PROGRESS'
or Path(guard['library']).resolve() != library or not _supervisor_alive(guard['pid'])
or checkpoint.get('status') != 'RUNNING' or checkpoint.get('stage') != 'native_add'
or Path(checkpoint['library']).resolve() != library
or checkpoint['name'] != record['name'] or checkpoint['partition'] != record['partition']):
raise ValueError('Native Add transaction authority is missing, stale or foreign.')
_authorize(record, job['mentor_home'])
baseline = _read(root/'source-identity/identity.json')
if (baseline.get('safe_to_continue') is not True or baseline.get('identity') != record['expected_identity']
or _read(root/'library-baseline-manifest.json') != record['library_baseline']
or check_source and (build_manifest(source.parent) != record['source_manifest']
or engineering_identity(source) != record['source_identity'])):
raise ValueError('Native Add library baseline or staged source proof changed.')
process = win32api.OpenProcess(win32con.PROCESS_DUP_HANDLE, False, record['supervisor_pid'])
duplicate = None
try:
duplicate = win32api.DuplicateHandle(process, record['lease_handle'], win32api.GetCurrentProcess(),
0, False, win32con.DUPLICATE_SAME_ACCESS)
final_path = win32file.GetFinalPathNameByHandle(duplicate, 0)
if final_path.startswith('\\\\?\\UNC\\'): final_path = '\\\\'+final_path[8:]
elif final_path.startswith('\\\\?\\'): final_path = final_path[4:]
expected_lock = library.with_name('.'+library.stem+'.cbb-upload.lock')
if Path(final_path).resolve() != expected_lock.resolve():
raise ValueError('Native Add supervisor lease belongs to another library.')
finally:
if duplicate is not None: duplicate.Close()
process.Close()
return record
+338 -200
View File
@@ -25,6 +25,8 @@ import traceback
import logging
import shutil
import socket
import gc
import tempfile
from collections import Counter
logger = logging.getLogger(__name__)
@@ -99,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
@@ -109,31 +118,46 @@ def ensure_pcb_central_library(pcb_path, lmc_path, *, evidence_dir=None,
# Different drive letters or an unresolved UNC mapping cannot be
# represented relatively; preserve the explicit selected path.
project_target = target
try:
with project.open('r', encoding='utf-8', errors='replace', newline='') as stream:
original = stream.read()
except OSError:
return False
changed = False
def replace_match(match):
nonlocal changed
if match.group(2) == project_target:
return match.group(0)
changed = True
return f'{match.group(1)}{project_target}{match.group(3)}'
updated = _CENTRAL_LIBRARY_KEY.sub(replace_match, original)
if not changed:
original = project.read_bytes()
if original.startswith((b'\xff\xfe', b'\xfe\xff')):
# Strict, round-trippable Unicode; never substitute undecodable bytes.
codec = 'utf-16-le' if original.startswith(b'\xff\xfe') else 'utf-16-be'
text = original[2:].decode(codec)
updated = original[:2] + _CENTRAL_LIBRARY_KEY.sub(
lambda match: match[1] + project_target + match[3], text).encode(codec)
else:
# Patch only the ASCII key value, preserving all native ANSI comments,
# unrelated fields, newline bytes and the exact original backup.
try:
target_bytes = project_target.encode('ascii')
except UnicodeEncodeError:
if original.startswith(b'\xef\xbb\xbf'):
codec = 'utf-8'
elif any(byte > 127 for byte in original):
try:
original.decode('utf-8')
codec = 'utf-8'
except UnicodeDecodeError:
codec = 'mbcs'
else:
codec = 'mbcs' # unmarked EE7.9 native text uses Windows ACP
target_bytes = project_target.encode(codec, errors='strict')
bom = b'\xef\xbb\xbf' if original.startswith(b'\xef\xbb\xbf') else b''
pattern = re.compile(_CENTRAL_LIBRARY_KEY.pattern.encode('ascii'), re.I | re.M)
updated = bom + pattern.sub(
lambda match: match[1] + target_bytes + match[3], original[len(bom):])
if updated == original:
emit(stage='central_library_path', status='MATCH', path=str(project), target=target)
return False
if evidence_dir is not None:
evidence = Path(evidence_dir)
evidence.mkdir(parents=True, exist_ok=True)
(evidence / 'pcb.prj.before-central-library').write_text(original, encoding='utf-8')
with project.open('w', encoding='utf-8', newline='') as stream:
stream.write(updated)
(evidence / 'pcb.prj.before-central-library').write_bytes(original)
# Stage on the same volume. Failure cannot leave a truncated project file.
with tempfile.TemporaryDirectory(prefix='.cbb-prj-write-', dir=project.parent) as temporary:
staged = Path(temporary) / 'pcb.prj'
staged.write_bytes(updated)
os.replace(staged, project)
emit(stage='central_library_path', status='UPDATED', path=str(project), target=target)
return True
@@ -193,15 +217,12 @@ def launch_pcb_process(command, cwd):
def _process_details(name):
import win32com.client
service = win32com.client.GetObject('winmgmts:')
return [
(int(p.ProcessId), str(p.ExecutablePath or ''), str(p.CommandLine or ''),
int(p.ParentProcessId or 0))
for p in service.ExecQuery(
f"SELECT ProcessId, ParentProcessId, ExecutablePath, CommandLine "
f"FROM Win32_Process WHERE Name='{name}'")
]
if name not in {'ExpeditionPCB.exe', 'LibraryManager.exe', 'iCDBProjectBackup.exe',
'ReuseBlockImporter.exe', 'cscript.exe', 'viewdraw.exe'}:
raise ValueError(f'Unsupported process query: {name}')
from .owner_probe import query_owners
return [(row['pid'], row['executable'], row['command'], row['parent'])
for row in query_owners((name,))]
def _processes(name):
@@ -215,12 +236,13 @@ def pcb_processes():
def is_reusable_circuit_pcb(exe, command, expected_pcb):
"""Match the ReusableCircuit session for this CBB by argument, not install layout."""
from .failed_session import _command_args
exe = os.path.normcase(str(exe or ''))
command = os.path.normcase(str(command or ''))
args = _command_args(str(command or ''))
expected = os.path.normcase(os.path.abspath(str(expected_pcb)))
return (os.path.basename(exe) == 'expeditionpcb.exe'
and '-reusablecircuit' in command
and expected in command)
and '-reusablecircuit' in {arg.casefold() for arg in args[1:]}
and expected in {os.path.normcase(os.path.abspath(arg)) for arg in args[1:]})
def select_reusable_circuit_pcb(candidates):
@@ -338,8 +360,10 @@ def choose_dialog_action(title, texts):
joined = ' '.join(values).lower()
if ('database restoration' in str(title or '').lower()
or ('restore database' in joined and 'last user saved database' in joined)
or '数据库恢复' in joined):
return 'restore_last_saved'
or '数据库恢复' in joined
or 'continue to open the design with read/write access permission' in joined
or 'confirm that no other users have the design open' in joined):
return None
if 'your task is being' in joined and 'elapsed time' in joined:
return None
positive = ('yes', 'ok', 'continue', 'retry', 'restore', 'open', 'use', 'load',
@@ -582,32 +606,25 @@ def execute_job(job, emit):
root = Path(job['root'])
block_root = Path(job['project']).parent.parent
# Do not recursively snapshot a live CBB over SMB immediately before
# launching Mentor. The backup is evidence only; on Win10 a timed-out
# robocopy can retain network handles/oplocks and make Verify nondeterministic.
# Unrelated designs stay open; COM and save helpers still require the exact
# project identity before any integration or save call.
from .failed_session import _command_args
existing = tuple(pcb_processes())
pcb_before = {pid for pid, _, _ in existing}
expected = os.path.normcase(os.path.abspath(job['pcb']))
for pid, _, command in existing:
if command and expected in [os.path.normcase(os.path.abspath(a)) for a in _command_args(command)[1:]]:
raise RuntimeError(f'PCB_SESSION_ACTIVE: 目标工程已经打开:{pid}')
# Backups are user-managed on local and network libraries alike.
mapped_drive = str(job.get('mapped_drive') or '')
mapped_remote_root = str(job.get('mapped_remote_root') or '')
if mapped_drive and mapped_remote_root:
from .network_path import ensure_mapped_drive_visible
mapping = ensure_mapped_drive_visible(mapped_drive, mapped_remote_root)
emit(stage='mapped_drive_context', **mapping)
emit(stage='backup', block=job['block_name'])
if is_network_backed_path(block_root, mapped_drive=mapped_drive):
backup = {'status': 'SKIPPED',
'detail': '网络盘 CBB 跳过递归备份,避免 robocopy 与 Mentor 竞争 SMB 文件锁'}
emit(stage='backup_skipped', reason='network_source', source=str(block_root))
else:
backup_budget = backup_timeout_seconds(block_root)
emit(stage='backup_budget', timeout_seconds=backup_budget)
backup = best_effort_backup(block_root, root/'backup'/block_root.name,
timeout_seconds=backup_budget, emit=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') == 'STALE_UNMOVED':
emit(stage='icdb_address_warning', detail='旧 iCDB 地址无法隔离;继续启动以保留现场。')
emit(stage='backup_skipped', reason='manual_backup_policy', source=str(block_root),
detail='应用不自动备份;请在操作前手动备份。')
from .icdb_ownership import unreleased_addresses
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,
@@ -616,13 +633,11 @@ 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'):
for name in (() if job.get('diagnostic_only') else ('ForwardAnnotation.txt', 'MsgBoxResponse.log', 'PartPkg.log')):
path = integration_log_dir / name
try:
baseline = path.read_bytes()
@@ -633,7 +648,30 @@ def execute_job(job, emit):
}
except OSError:
integration_offsets[path] = {'size': 0, 'mtime_ns': None, 'digest': ''}
pcb_before = {pid for pid, _, _ in pcb_processes()}
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)
if job.get('diagnostic_only'):
return startup
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
@@ -641,14 +679,31 @@ def execute_job(job, emit):
worker_parent_pid = None
launcher_process = None
completed = False
identity_verified = False
diagnostic_close_attempted = False
helper = None
app = doc = pi = None
try:
ensure_pcb_central_library(
job['pcb'],
job['lmc_file'],
evidence_dir=Path(root) / 'diagnostics',
emit=emit,
)
if job.get('diagnostic_only'):
if job.get('native_lm_verify') or job.get('post_repair_consent'):
raise ValueError('DIAGNOSTIC_MODE_INVALID: 诊断不能执行原生校验菜单或恢复确认')
from .backup_recovery import _project_text
from .maintenance_entry import maintenance_project_files
library = Path(job['lmc_file']).resolve()
for config in maintenance_project_files(job['project'], job['pcb']):
for match in _CENTRAL_LIBRARY_KEY.finditer(_project_text(config)):
reference = match[2]
if not reference or (config.parent/reference).resolve() != library:
raise ValueError(f'DIAGNOSTIC_LIBRARY_MISMATCH: {config}: {reference}')
from .diagnostic_open import snapshot_diagnostic_logs
job['diagnostic_log_baseline'] = snapshot_diagnostic_logs(job)
else:
ensure_pcb_central_library(
job['pcb'],
job['lmc_file'],
evidence_dir=Path(root) / 'diagnostics',
emit=emit,
)
emit(
stage='verify_mode',
mode=('library_manager_native' if bool(job.get('native_lm_verify', False))
@@ -658,6 +713,7 @@ def execute_job(job, emit):
# The successful background runs use the normal ReusableCircuit
# launcher. Keep the experimental Library Manager menu route opt-in
# for diagnostics only; it is not the production trigger on EE7.9.
pcb_started_ns = time.time_ns()
if bool(job.get('native_lm_verify', False)):
from .library_manager_verify import launch_library_verify
emit(stage='lm_launch', library=job['lmc_file'], block=job['block_name'])
@@ -673,6 +729,9 @@ def execute_job(job, emit):
emit(stage='lm_session_ready', lm_pid=lm_pid, block=job['block_name'])
else:
command = build_pcb_launch_command(job['pcb'], job.get('mentor_bin'))
if job.get('post_repair_consent') is not None:
from .post_repair_consent import prepare_launch
prepare_launch(job, command)
emit(stage='pcb_launch', command=list(command), strategy='reusable_circuit_direct')
launcher_process = launch_pcb_process(command, Path(job['pcb']).parent)
worker_parent_pid = int(launcher_process.pid)
@@ -681,6 +740,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,
@@ -694,18 +755,51 @@ def execute_job(job, emit):
parent_pid=worker_parent_pid or lm_pid, command=worker_command,
binding='commandline' if is_reusable_circuit_pcb(
worker_executable, worker_command, job['pcb']) else 'launcher_child')
try:
from .mentor_paths import discover_sdd_home
home = discover_sdd_home(job.get('mentor_bin'))
wdir = os.environ.get('WDIR', '').split(';')[0].strip()
if wdir or home:
log_root = Path(os.path.expandvars(wdir)) if wdir else home/'standard'
(root/'diagnostics/native-client-context.json').write_text(json.dumps({
'native_pid': worker_pid, 'started_ns': pcb_started_ns,
'client_log_root': str(log_root/'iCDB/Client/Logs'),
'database': str(Path(job['project']).parent/'database')},
ensure_ascii=False), encoding='utf-8')
except (OSError, ValueError):
pass
break
time.sleep(.2)
if worker_pid is None:
raise RuntimeError('ReusableCircuit common 启动后未观察到 wg PCB 子进程')
app, doc, pi = wait_for_target_document(
job,
lambda: win32com.client.GetActiveObject('MGCPCB.Application'),
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),
)
if job.get('diagnostic_only'):
# Global PCB COM can wait on another design's modal window.
# Opening checks use only the newly bound process and fresh logs.
from .diagnostic_open import check_target_window
def diagnostic_emit(**event):
nonlocal diagnostic_close_attempted
if event.get('stage') == 'diagnostic_wm_close':
diagnostic_close_attempted = True
emit(**event)
checked = check_target_window(job, worker_pid, emit=diagnostic_emit,
error_reader=native_error, launcher_process=launcher_process)
released = cleanup_verify_processes(lm_pid, worker_pid, worker_parent_pid,
expected_pcb=job['pcb'], baseline_pids=pcb_before, emit=emit)
if (checked.get('status') != 'PASS' or not checked.get('native_processes_exited')
or not released or not released.get('safe_to_continue')):
raise RuntimeError(f'DIAGNOSTIC_CLOSE_UNCONFIRMED: {checked}; {released}')
from .diagnostic_open import _read_bounded
if detail := _read_bounded(native_error):
raise RuntimeError(detail)
completed = True
emit(stage='diagnostic_complete', status='PASS')
return {'status': 'PASS', 'stdout': 'ICDB 启动检查通过;工程及启动器已退出。'}
from .pcb_bridge import ProcessWatch
with ProcessWatch((lm_pid, worker_pid, worker_parent_pid)) as watch:
app, doc, pi = wait_for_target_document(
job, lambda: win32com.client.GetActiveObject('MGCPCB.Application'),
process_alive=watch.alive, emit=emit, 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
@@ -715,17 +809,27 @@ 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 = subprocess.Popen([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 = ()
while helper.poll() is None:
if job.get('cancel_signal') and Path(job['cancel_signal']).exists():
raise RuntimeError('VERIFY_CANCELLED: 已停止等待保存客户端')
try:
current = tuple(line.strip() for line in (root/'save.log').read_text(encoding='utf-8', errors='replace').splitlines() if line.strip())
except OSError:
@@ -753,17 +857,16 @@ def execute_job(job, emit):
process_exit_deadline = time.monotonic() + (15 if 'QUIT_OK' not in markers else 30)
while any(p in {lm_pid, worker_pid, worker_parent_pid} for p, _, _ in pcb_processes()):
if time.monotonic() >= process_exit_deadline:
emit(stage='pcb_exit_recovered', detail='Save/Close 已确认但 PCB 未自行退出,执行定向清理。')
cleanup_verify_processes(
lm_pid,
worker_pid,
worker_parent_pid,
expected_pcb=job.get('pcb'),
baseline_pids=pcb_before,
emit=emit,
)
break
raise RuntimeError('PCB_RELEASE_UNCONFIRMED: Save/Close 返回成功,但未确认 PCB 退出;保留原生进程并停止批次。')
time.sleep(.5)
released = cleanup_verify_processes(
lm_pid, worker_pid, worker_parent_pid, expected_pcb=job.get('pcb'),
baseline_pids=pcb_before, emit=emit)
if not released or not released.get('safe_to_continue'):
raise RuntimeError(f'PCB_RELEASE_UNCONFIRMED: 未确认 PCB 退出: {released}')
addresses = unreleased_addresses(job['lmc_file'], job['project'], job['pcb'])
if addresses:
emit(stage='icdb_address_remaining', addresses=addresses, non_blocking=True)
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)
@@ -771,6 +874,8 @@ def execute_job(job, emit):
emit(stage='complete', status='PASS', certified_project=str(cert_project), cert_evidence=cert_evidence)
return {'status': 'PASS', 'stdout': 'ReusableCircuit 校验;四项 InSynch;Save/IsSaved/Close 成功;PCB 已退出。'}
finally:
pi = doc = app = None
gc.collect()
if not completed:
try:
logs = collect_native_failure_logs(job['pcb'], root)
@@ -781,7 +886,28 @@ 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:
_terminate(helper, grace_seconds=1)
emit(stage='save_helper_retained', helper_pid=helper.pid)
elif diagnostic_close_attempted:
# The process-bound checker already sent its sole WM_CLOSE.
# Preserve an unknown prompt; never fall back to global COM Close.
pass
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))
elif not completed and worker_pid is not None:
try:
from .failed_session import close_failed_startup
failed_close = close_failed_startup(job, worker_pid, baseline_pids=pcb_before, emit=emit,
launcher_process=launcher_process)
if failed_close.get('status') == 'CLOSED' and lm_session is not None:
lm_session.close()
except Exception as error:
emit(stage='startup_close_unconfirmed', detail=str(error))
cleanup_verify_processes(
lm_pid,
worker_pid,
@@ -790,15 +916,15 @@ def execute_job(job, emit):
baseline_pids=pcb_before,
emit=emit,
)
if lm_session is not None:
if completed and lm_session is not None:
lm_session.close()
def _terminate_pid(pid, *, timeout=20):
"""Terminate only the PCB PID associated with the current Verify item."""
"""Terminate a validated automation helper PID, never its native children."""
try:
subprocess.run(
['taskkill', '/PID', str(int(pid)), '/T', '/F'],
[str(Path(os.environ.get('WINDIR', r'C:\Windows'))/'System32'/'taskkill.exe'), '/PID', str(int(pid)), '/F'],
capture_output=True,
timeout=timeout,
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0),
@@ -809,49 +935,38 @@ def _terminate_pid(pid, *, timeout=20):
def cleanup_verify_processes(lm_pid, worker_pid, worker_parent_pid=None, *,
expected_pcb=None, baseline_pids=(), emit=None):
"""Terminate every process created by one Verify session, child first.
"""Observe native process release without interrupting database writes.
The worker can be killed by the outer supervisor before it has observed the
``common``/``wg`` pair or before its own ``finally`` block runs. In that
case the explicit PIDs are incomplete, so discover only new
``ExpeditionPCB.exe`` processes whose command line contains this CBB's
``-ReusableCircuit`` path. Existing PCB sessions are excluded by the
baseline snapshot.
A cleanup request is not evidence of release. Retained or unobservable
sessions block the batch and require recovery; they must never be killed.
"""
seen = set()
targets = [('pcb_worker', worker_pid), ('pcb_launcher', worker_parent_pid)]
baseline = {int(pid) for pid in (baseline_pids or ())}
if expected_pcb:
try:
records = _process_details('ExpeditionPCB.exe')
except Exception:
records = ()
discovered = []
for pid, executable, command, parent_pid in records:
pid = int(pid)
if pid in baseline or not is_reusable_circuit_pcb(executable, command, expected_pcb):
continue
discovered.append((pid, int(parent_pid or 0), str(executable or '').casefold()))
discovered_pids = {pid for pid, _parent_pid, _executable in discovered}
# The worker path is the child in the normal common/wg pair. Parent
# first is intentionally avoided here: taskkill /T on the child is
# harmless, and the explicit parent is terminated in the next pass.
for pid, parent_pid, executable in discovered:
role = 'pcb_worker' if '\\wg\\' in executable else 'pcb_launcher'
targets.append((role, pid))
# Do not infer an arbitrary parent (usually this Python worker) as
# a Mentor launcher. Only add a parent that is itself one of the
# newly discovered PCB pair processes.
if parent_pid in discovered_pids:
targets.append(('pcb_launcher', parent_pid))
targets.append(('library_manager', lm_pid))
for role, pid in targets:
if not pid or int(pid) in seen:
continue
seen.add(int(pid))
_terminate_pid(int(pid))
if emit is not None:
emit(stage='process_cleanup', role=role, pid=int(pid))
tracked = {int(pid) for pid in (lm_pid, worker_pid, worker_parent_pid) if pid}
try:
pcb_records = _process_details('ExpeditionPCB.exe')
lm_records = _process_details('LibraryManager.exe') if lm_pid else ()
for pid, executable, command, _parent in pcb_records:
if (expected_pcb and int(pid) not in baseline
and is_reusable_circuit_pcb(executable, command, expected_pcb)):
tracked.add(int(pid))
# Native launcher children can omit the PCB argument. Track only new
# descendants of this task's already identified native processes.
while True:
children = {int(pid) for pid, _, _, parent in pcb_records
if int(pid) not in baseline and int(parent) in tracked}
if children.issubset(tracked):
break
tracked.update(children)
alive = {int(record[0]) for record in (*pcb_records, *lm_records)}
remaining = sorted(tracked & alive)
result = {'safe_to_continue': not remaining, 'remaining_pids': remaining}
except Exception as error:
result = {'safe_to_continue': False, 'remaining_pids': sorted(tracked),
'error': str(error)}
if emit is not None:
emit(stage=('process_exit_confirmed' if result['safe_to_continue']
else 'process_retained'), **result)
return result
def _terminate(process, *, grace_seconds=5, kill_timeout_seconds=20):
@@ -862,7 +977,7 @@ def _terminate(process, *, grace_seconds=5, kill_timeout_seconds=20):
return
except subprocess.TimeoutExpired:
pass
subprocess.run(['taskkill', '/PID', str(process.pid), '/T', '/F'], capture_output=True,
subprocess.run([str(Path(os.environ.get('WINDIR', r'C:\Windows'))/'System32'/'taskkill.exe'), '/PID', str(process.pid), '/T', '/F'], capture_output=True,
timeout=max(1.0, float(kill_timeout_seconds)),
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
except Exception:
@@ -872,25 +987,6 @@ def _terminate(process, *, grace_seconds=5, kill_timeout_seconds=20):
pass
def abort_job_document(job):
"""Discard a failed item's PCB document so later CBBs can still run."""
try:
import win32com.client
app = win32com.client.GetActiveObject('MGCPCB.Application')
doc = app.ActiveDocument
if doc and same_path(doc.ProjectIntegration.ProjectFile, job['project']):
try:
doc.Close(False)
except Exception:
pass
try:
app.Quit()
except Exception:
pass
except Exception:
pass
def worker_main(request_path):
import pythoncom
pythoncom.CoInitialize()
@@ -904,20 +1000,26 @@ def worker_main(request_path):
stream.write(json.dumps(event, ensure_ascii=False) + '\n')
try:
if job.get('supervisor_pid'):
from .desktop_worker import start_supervisor_watchdog
start_supervisor_watchdog(job['supervisor_pid'], cancel_path=job.get('cancel_signal'), stop_clients=True)
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
from .defaults import WORKER_START_GATE_TIMEOUT_SECONDS
gate_deadline = time.monotonic() + WORKER_START_GATE_TIMEOUT_SECONDS
while not start_gate.is_file():
if job.get('cancel_signal') and Path(job['cancel_signal']).exists():
raise RuntimeError('VERIFY_CANCELLED: 启动已取消,未启动 PCB')
if time.monotonic() >= gate_deadline:
raise RuntimeError('DIALOG_AGENT_START_TIMEOUT: 弹窗代理未就绪,未启动 PCB')
time.sleep(.05)
if job.get('cancel_signal') and Path(job['cancel_signal']).exists():
raise RuntimeError('VERIFY_CANCELLED: 启动已取消,未启动 PCB')
outcome = execute_job(job, emit)
except Exception as error:
traceback.print_exc()
abort_job_document(job)
message = str(error)
unsafe = any(marker in message for marker in ('timeout', '超时', 'unknown dialog', '未确认 PCB 退出'))
outcome = {'status': 'FAIL', 'stderr': message, 'safe_to_continue': not unsafe}
outcome = {'status': 'FAIL', 'stderr': message, 'safe_to_continue': False}
emit(stage='failed', error=message)
finally:
pythoncom.CoUninitialize()
@@ -986,14 +1088,10 @@ def probe_icdb_server(hosts, port, *, timeout_seconds=0.25):
def prepare_icdb_address(database_dir, evidence_root, *, emit=lambda **event: None):
"""Quarantine an unreachable stale iCDB address advertisement.
"""Inspect the advertisement without removing database ownership state.
``sAddress.adr`` is volatile runtime state. When a previous PCB/cdbsvr
session crashed, EE7.9 keeps the old network endpoint and the next PCB
launch spends its entire startup window retrying that dead server instead
of starting a local one. We preserve the file in this run's evidence and
remove only the unreachable advertisement; a live endpoint is never
touched.
Network timeout/refusal does not prove that the server has exited. Even a
reachable endpoint does not establish exclusive access for this Verify.
"""
address = Path(database_dir) / 'cdbsvr' / 'sAddress.adr'
if not address.is_file():
@@ -1012,20 +1110,9 @@ def prepare_icdb_address(database_dir, evidence_root, *, emit=lambda **event: No
'hosts': parsed['hosts'], 'detail': detail}
emit(stage='icdb_address_check', **result)
return result
archive = (Path(evidence_root) / 'diagnostics' / 'cdbsvr' /
f"sAddress.adr.stale-{time.strftime('%Y%m%d-%H%M%S')}")
try:
archive.parent.mkdir(parents=True, exist_ok=True)
shutil.move(str(address), str(archive))
except OSError as error:
result = {'status': 'STALE_UNMOVED', 'path': str(address), 'port': parsed['port'],
'hosts': parsed['hosts'], 'detail': f'{detail}; {error}'}
emit(stage='icdb_address_check', **result)
return result
result = {'status': 'STALE_MOVED', 'path': str(address), 'archive': str(archive),
result = {'status': 'UNREACHABLE', 'path': str(address),
'port': parsed['port'], 'hosts': parsed['hosts'], 'detail': detail}
emit(stage='icdb_address_check', **result)
emit(stage='icdb_address_stale', **result)
return result
@@ -1040,7 +1127,8 @@ def icdb_ports_bindable(ports=(10000, 10050, 10100)):
for port in ports:
probe = socket.socket()
try:
probe.bind(('0.0.0.0', port))
# Temporary native port preflight only; never listen or accept.
probe.bind(('0.0.0.0', port)) # nosec B104
return True, f'端口 {port} 可用'
except OSError as error:
failures.append(f'{port}: {error}')
@@ -1053,17 +1141,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 ''
@@ -1078,6 +1176,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 = []
@@ -1086,6 +1185,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')
@@ -1116,8 +1228,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])
@@ -1310,6 +1431,25 @@ def _private_library_window(desktop, library):
return None
def close_library_reader(pid, desktop, *, timeout_seconds=5):
"""Request native close and observe exit, never force-kill a reader."""
import win32con, win32gui, win32process
try:
for hwnd in desktop.EnumDesktopWindows():
if (win32process.GetWindowThreadProcessId(hwnd)[1] == int(pid)
and win32gui.GetWindowText(hwnd).startswith('Library Manager')):
win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
deadline = time.monotonic() + max(0, timeout_seconds)
while True:
if not any(int(item[0]) == int(pid) for item in _process_details('LibraryManager.exe')):
return True
if time.monotonic() >= deadline:
return False
time.sleep(.2)
except Exception:
return False
def read_library_flag(library, name, *, timeout_seconds=90, log_path=None):
"""Return (flag, detail) for one CBB by reading its tree icon.
@@ -1320,6 +1460,8 @@ def read_library_flag(library, name, *, timeout_seconds=90, log_path=None):
import win32con
import win32process
import win32service
from pywinauto import Desktop
from pywinauto.controls.common_controls import TreeViewWrapper
executable = library_manager_path()
if not executable.is_file():
@@ -1327,15 +1469,14 @@ def read_library_flag(library, name, *, timeout_seconds=90, log_path=None):
deadline = time.monotonic() + timeout_seconds
desktop_name = 'CbbFlagRead_' + os.urandom(5).hex()
desktop = win32service.CreateDesktop(desktop_name, 0, win32con.GENERIC_ALL, None)
from pywinauto import Desktop
from pywinauto.controls.common_controls import TreeViewWrapper
desktop = None
handle = None
pid = None
handled = set()
log = log_path or Path(library).parent/'LogFiles'/'cbb_flag_read_dialogs.jsonl'
try:
desktop = win32service.CreateDesktop(desktop_name, 0, win32con.GENERIC_ALL, None)
startup = win32process.STARTUPINFO()
startup.lpDesktop = 'winsta0\\' + desktop_name
handle, thread, pid, _ = win32process.CreateProcess(
@@ -1372,23 +1513,21 @@ def read_library_flag(library, name, *, timeout_seconds=90, log_path=None):
except Exception as error:
return FLAG_UNKNOWN, f'状态读取失败: {error}'
finally:
if pid is not None:
try:
subprocess.run(['taskkill', '/PID', str(pid), '/T', '/F'], capture_output=True,
timeout=5,
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
except (OSError, subprocess.TimeoutExpired):
pass
released = pid is None or close_library_reader(pid, desktop)
if handle is not None:
try:
handle.Close()
except Exception:
pass
try:
desktop.CloseDesktop()
if desktop is not None:
desktop.CloseDesktop()
except Exception:
pass
if not released:
raise RuntimeError(f'LIBRARY_RELEASE_UNCONFIRMED: pid={pid}; desktop={desktop_name}')
def read_library_tree_image_map(library, names, *, timeout_seconds=45, log_path=None):
"""Read all CBB tree icon resource IDs in one private LM session.
@@ -1411,12 +1550,13 @@ def read_library_tree_image_map(library, names, *, timeout_seconds=45, log_path=
if not executable.is_file():
return result
desktop_name = 'CbbStatusRead_' + os.urandom(5).hex()
desktop = win32service.CreateDesktop(desktop_name, 0, win32con.GENERIC_ALL, None)
desktop = None
handle = None
pid = None
handled = set()
log = log_path or Path(library).parent/'LogFiles'/'cbb_status_read_dialogs.jsonl'
try:
desktop = win32service.CreateDesktop(desktop_name, 0, win32con.GENERIC_ALL, None)
startup = win32process.STARTUPINFO()
startup.lpDesktop = 'winsta0\\' + desktop_name
handle, thread, pid, _ = win32process.CreateProcess(
@@ -1463,23 +1603,21 @@ def read_library_tree_image_map(library, names, *, timeout_seconds=45, log_path=
logger.warning('library_tree_image_item_missing name=%s reason=tree_path_lookup_failed', name)
return result
finally:
if pid is not None:
try:
subprocess.run(['taskkill', '/PID', str(pid), '/T', '/F'], capture_output=True,
timeout=5,
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
except (OSError, subprocess.TimeoutExpired):
pass
released = pid is None or close_library_reader(pid, desktop)
if handle is not None:
try:
handle.Close()
except Exception:
pass
try:
desktop.CloseDesktop()
if desktop is not None:
desktop.CloseDesktop()
except Exception:
pass
if not released:
raise RuntimeError(f'LIBRARY_RELEASE_UNCONFIRMED: pid={pid}; desktop={desktop_name}')
def read_library_status_map(library, names, *, timeout_seconds=45, log_path=None,
image_status_map=None):
@@ -0,0 +1,140 @@
"""Observed native copy failure and conservative legacy Win32 path admission."""
import hashlib
import json
from pathlib import Path
import re
import time
_COPY_ERROR = b'Error! Cannot copy iCDB base of Reusable Block project.'
_LOG_LIMIT = 2*1024*1024
def missing_other_pcb_notice(library, target, title, text, buttons):
"""Only the observed editor-open information about unrelated missing PCBs."""
from .management import validate_name
from .verify_runner import preflight_skip_reason
heading = ('The following Reusable Blocks do not contain PCB files and will not appear '
'in the list of available reusable blocks:')
if title != 'Library Manager' or len(text) > 131072 or len(buttons) != 1:
return None
button = buttons[0]
if (button.get('id') != 2 or button.get('class') != 'Button'
or button.get('text') not in ('OK', '确定') or button.get('enabled') is not True):
return None
lines = text.strip().splitlines()
if not lines or lines[0] != heading:
return None
names = []
for line in lines[1:]:
if not line.strip(): continue
if not line.startswith('\t'): return None
name = line[1:]
try: validate_name(name)
except ValueError: return None
if name.casefold() == str(target).casefold() or not preflight_skip_reason(library, name):
return None
names.append(name)
if not names or len(names) != len({name.casefold() for name in names}):
return None
return {'names': names, 'button': button['hwnd']}
def snapshot_add_log(library):
path = Path(library).parent/'LogFiles/ReuseBlockLogLO.txt'
try:
data = b''
if path.exists():
with path.open('rb') as stream: data = stream.read(_LOG_LIMIT+1)
if len(data) > _LOG_LIMIT: raise ValueError('Native Add log exceeds the bounded observation limit.')
return {'path': str(path), 'size': len(data), 'sha256': hashlib.sha256(data).hexdigest()}
except (OSError, ValueError) as error:
return {'path': str(path), 'unavailable': str(error)}
def fresh_add_failure(baseline, name):
if 'unavailable' in baseline: return None
try:
with Path(baseline['path']).open('rb') as stream:
data = stream.read(_LOG_LIMIT+1)
offset = baseline['size']
if (len(data) > _LOG_LIMIT or len(data) < offset
or hashlib.sha256(data[:offset]).hexdigest() != baseline['sha256']):
return None
marker = re.compile(rb'REUSE BLOCK:\s*INFORMATION:\s*'+re.escape(name.encode('mbcs'))
+rb'\s+'+re.escape(_COPY_ERROR))
for line in data[offset:].splitlines():
if marker.search(line): return line.decode('mbcs')
except (OSError, UnicodeError):
pass
return None
def failure_ack_button(title, static_text, buttons):
if title != 'Library Manager' or static_text.strip() != '系统找不到指定的路径。' or len(buttons) != 1:
return None
button = buttons[0]
if (button.get('id') == 2 and button.get('class') == 'Button'
and button.get('text') == '确定' and button.get('enabled') is True):
return button['hwnd']
return None
def validate_native_copy_paths(source, library, name):
from .scoped_manifest import scan_tree
from .network_path import absolute_preserving_drive
source = absolute_preserving_drive(source)
target = absolute_preserving_drive(library).parent/'ReusableBlocksLP'/name/'Work'
paths = [source.parent, *scan_tree(source.parent)]
for path in paths:
relative = path.relative_to(source.parent)
for label, candidate in (('暂存来源', path), ('目标', target/relative)):
# Legacy CopyFile's 260-WCHAR buffer includes the terminating NUL.
length = len(str(candidate).encode('utf-16-le'))//2
if length >= 260:
raise ValueError(f'NATIVE_PATH_TOO_LONG: {label}路径为 {length} 个字符,已超过原生复制支持范围。'
f'请缩短操作数据/证据目录或目标库路径后重试;所有工程和日志文件均保留。路径:{candidate}')
def observe_add_failure(desktop, owned_pids, root, baseline, name, state):
"""Record owned modal evidence and acknowledge only the observed error box."""
import pythoncom, win32con, win32gui, win32process
from .management import _write_json
fresh_log = fresh_add_failure(baseline, name)
for handle in desktop.EnumDesktopWindows():
hwnd = int(handle)
if (win32process.GetWindowThreadProcessId(hwnd)[1] not in owned_pids
or not win32gui.IsWindowVisible(hwnd) or win32gui.GetClassName(hwnd) != '#32770'):
continue
title = win32gui.GetWindowText(hwnd)
if title in ('New Reusable Block', 'Reusable Blocks'): continue
children = []
win32gui.EnumChildWindows(hwnd, lambda child, _: children.append(int(child)), None)
controls = [{'hwnd': child, 'id': win32gui.GetDlgCtrlID(child), 'class': win32gui.GetClassName(child),
'text': win32gui.GetWindowText(child), 'enabled': bool(win32gui.IsWindowEnabled(child))}
for child in children]
static = '\n'.join(c['text'] for c in controls if c['class'] == 'Static')
buttons = [c for c in controls if c['class'] == 'Button']
record = {'hwnd': hwnd, 'title': title, 'controls': controls, 'fresh_log_failure': fresh_log}
key = json.dumps(record, ensure_ascii=False, sort_keys=True)
if key not in state.setdefault('observed', set()):
state['observed'].add(key)
with (Path(root)/'native-add-dialogs.jsonl').open('a', encoding='utf-8') as stream:
stream.write(json.dumps(record, ensure_ascii=False)+'\n')
button = failure_ack_button(title, static, buttons)
if button is not None and win32process.GetWindowThreadProcessId(button)[1] in owned_pids:
win32gui.PostMessage(button, win32con.BM_CLICK, 0, 0)
deadline = time.monotonic()+2
while win32gui.IsWindow(hwnd) and time.monotonic() < deadline:
pythoncom.PumpWaitingMessages(); time.sleep(.05)
record['acknowledged'] = not win32gui.IsWindow(hwnd)
_write_json(Path(root)/'native-add-output.json', {'success_message': None, 'failure': record})
raise RuntimeError('NATIVE_ADD_FAILED: '+static.strip()
+ (' '+fresh_log if fresh_log else '')
+ ('' if record['acknowledged'] else ';原生错误对话框尚未确认关闭。'))
if fresh_log:
first_seen = state.setdefault('failure_seen_at', time.monotonic())
# Allow the paired native error popup to appear for normal acknowledgement.
if time.monotonic()-first_seen >= 2:
_write_json(Path(root)/'native-add-output.json', {'success_message': None,
'failure': {'fresh_log_failure': fresh_log, 'acknowledged': False}})
raise RuntimeError('NATIVE_ADD_FAILED: '+fresh_log)
+155
View File
@@ -0,0 +1,155 @@
"""Open the official backup UI; version selection and writes stay native."""
from dataclasses import dataclass
import json
from pathlib import Path
import stat
import subprocess
import sys
import time
from uuid import uuid4
def native_backup_executable(mentor_bin=''):
from .mentor_paths import discover_sdd_home
home = discover_sdd_home(mentor_bin)
executable = home/'iCDB/win32/bin/iCDBProjectBackup.exe' if home else None
if executable is None or not executable.is_file():
raise ValueError('未找到 iCDB Project Backup,请检查 Mentor 安装位置。')
return executable
def native_backup_project(library, block):
from .verify_runner import INVALID_NAME_CHARS
library = Path(library).absolute()
if not block or block in ('.', '..') or any(c in block for c in INVALID_NAME_CHARS):
raise ValueError('CBB 名称非法。')
if not library.is_file():
raise ValueError('中心库文件不存在。')
work = library.parent/'ReusableBlocksLP'/block/'Work'
expected = library.parent.resolve()/'ReusableBlocksLP'/block/'Work'
if work.resolve() != expected:
raise ValueError('工程路径通过链接指向其他位置。')
projects = list(work.glob('*.prj'))
if len(projects) != 1 or not projects[0].is_file():
raise ValueError('无法唯一确定所选 CBB 的工程 PRJ。')
project = projects[0]
if (project.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT
or not project.resolve().is_relative_to(expected)):
raise ValueError('工程文件通过链接指向其他位置。')
return project
@dataclass
class NativeBackupSession:
process: object
job: Path
library: Path
block: str
path_lease: object = None
def launch_native_backup(request):
project = native_backup_project(request.lmc_file, request.block_name)
native_backup_executable(request.mentor_bin)
root = Path(request.evidence_dir).resolve()/('native-backup-'+uuid4().hex[:12])
library_root = Path(request.lmc_file).resolve().parent
if root.is_relative_to(library_root) or library_root.is_relative_to(root):
raise ValueError('运行记录目录需位于中心库之外。')
root.mkdir(parents=True)
job = root/'request.json'
job.write_text(json.dumps({'library': str(request.lmc_file), 'block': request.block_name,
'project': str(project), 'mentor_bin': request.mentor_bin}, ensure_ascii=False), 'utf-8')
command = ([sys.executable] if getattr(sys, 'frozen', False) else
[sys.executable, '-m', 'cbb_refresh_verify'])+['--native-backup-worker', str(job)]
process = subprocess.Popen(command, creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
return NativeBackupSession(process, job, Path(request.lmc_file), request.block_name)
class _NativeBackupProcess:
"""Track this visible tool and its descendants without killing on close."""
def __init__(self, command, cwd):
import win32con, win32job, win32process
self.job = win32job.CreateJobObject(None, '')
startup = win32process.STARTUPINFO()
try:
self.handle, thread, self.pid, _ = win32process.CreateProcess(
command[0], subprocess.list2cmdline(command), None, None, False,
win32con.CREATE_SUSPENDED, None, str(cwd), startup)
except Exception:
self.job.Close()
raise
try:
win32job.AssignProcessToJobObject(self.job, self.handle)
win32process.ResumeThread(thread)
except Exception:
# No native code has run while suspended; there can be no DB write.
win32process.TerminateProcess(self.handle, 1)
self.handle.Close(); self.job.Close()
raise
finally:
thread.Close()
def poll(self):
import win32process
code = win32process.GetExitCodeProcess(self.handle)
return None if code == 259 else code
def session_pids(self):
import win32job
return win32job.QueryInformationJobObject(self.job, win32job.JobObjectBasicProcessIdList)
def close(self):
self.handle.Close(); self.job.Close()
def native_backup_worker_main(job, *, process_factory=None):
from .library_lock import LibraryLock
from .management import _write_json
job = Path(job)
result = {'status': 'FAILED', 'safe_to_continue': True, 'restore_confirmed': False}
native = None
def write_evidence(name, value):
try:
_write_json(job.with_name(name), value)
except Exception as error:
# Evidence storage must never end supervision of a live transaction.
result['evidence_error'] = str(error)
try:
record = json.loads(job.read_text('utf-8'))
library, block = Path(record['library']), record['block']
result.update(library=str(library), block=block)
project = native_backup_project(library, block)
if project != Path(record['project']):
raise ValueError('工程身份已变化,未打开原生工具。')
executable = native_backup_executable(record.get('mentor_bin', ''))
released = True
with LibraryLock(library, checkpoint=False, safe_to_release=lambda: released):
native = (process_factory or _NativeBackupProcess)([str(executable), '-p', str(project)], project.parent)
released = False
result.update(status='OPEN', native_pid=native.pid, project=str(project), safe_to_continue=False)
write_evidence('state.json', result)
waiting = False
while True:
try:
pids, exit_code = native.session_pids(), native.poll()
except Exception as error:
write_evidence('state.json', {**result,
'status': 'RELEASE_UNCONFIRMED', 'detail': str(error)})
time.sleep(.5)
continue # Keep the lease while the live session cannot be observed.
if not pids and exit_code is not None:
break
if exit_code is not None and not waiting:
waiting = True
write_evidence('state.json', {**result, 'status': 'WAITING_RELEASE'})
time.sleep(.25)
released = True
result.update(status='CLOSED', native_exit_code=exit_code, safe_to_continue=True)
return 0 if result['native_exit_code'] == 0 else 1
except Exception as error:
result.update(status='FAILED', detail=str(error), safe_to_continue=native is None)
return 1
finally:
write_evidence('result.json', result)
if native is not None:
native.close() # No kill-on-close: never interrupt a native transaction.
@@ -0,0 +1,476 @@
"""Pinned EE7.9.5 native logical exports plus conservative physical/assets proof.
This contract is not raw iCDB equivalence or a claim of exhaustive arbitrary CES
semantics. It compares the proven hierarchy/flat ASCII and CSV/property exports,
and preserves physical design and all other primary engineering assets exactly.
"""
from dataclasses import dataclass
import hashlib
from pathlib import Path
import re
import subprocess
import time
from .management import source_project, _write_json
from .scoped_manifest import ManifestScope, build_manifest, hash_file
POLICY = 'mentor795-native-content-v1'
COVERAGE = {'logical_connectivity_and_properties': 'native hierarchy/flat ASCII and CSV',
'physical_design_and_primary_assets': 'raw SHA256',
'schematic_graphical_geometry': 'native EDIF schematic', 'production_acceptance': True}
EXPORTER_PROOF = {
'icdb2ascii.exe': 'e37c87356eaf57c0b97e4183458bc8c5eb6eb0ac497cc7ad40dcd585d8cd213b',
'icdb2csv.exe': '22059f4a432e8eabf30a5326ebcbd463ed6fa6495af21d7aad5ab5d2f892f255',
'edifExporter.exe': '8b5f9682007da5b759e7b2f0fa9720f6771b2efb9a546636b270a58e1268a80e',
}
INF_HEADER = (b'Design Name\tSystem Name\tSystem Version\tSystem_Date\tCompany_Name\tDepartment_Name'
b'\tAddress\tAddress1\tCity\tState_Province\tCountry\tZip\tPhone\tPhone_Ext\tFax\tFax_Ext')
CSV_SUFFIXES = ('', '.esf', '.inf', '.npr', '.ppn', '.ppr', '.prm', '.prt', '.pth',
'.sht', '.spn', '.spr', '.sym', '.thn')
_retained_exports = []
_OWNER_NAMES = frozenset({'icdb2ascii.exe', 'icdb2csv.exe', 'edifexporter.exe', 'icdbnetserver.exe',
'icdbnetlauncher.exe', 'icdbservermanager.exe', 'icdbservermonitor.exe'})
@dataclass(frozen=True)
class IdentityOutcome:
identity: dict | None
safe_to_continue: bool
detail: str
evidence_path: Path
def _digest(data):
return hashlib.sha256(data).hexdigest()
def normalize_ascii(data, top):
"""Only the three observed, position-bound report metadata values vary."""
lines = data.splitlines(keepends=True)
prefixes = {0: b'iCDB Ascii Report Generation Date: ',
4: b'\t iCDB directory: ', 5: b'\t DATE: '}
if (len(lines) < 12 or lines[3].rstrip(b'\r\n') != b'\tReport Criteria:'
or any(not lines[i].startswith(prefix) or not lines[i][len(prefix):].strip()
for i, prefix in prefixes.items())):
raise ValueError('Incomplete or unknown native ASCII report header.')
header = b''.join(lines[:next((i for i, line in enumerate(lines) if line.startswith(b'Block ')), len(lines))])
required = (b'\t REPORT FORMAT: FREEFORM', b'\t MODE: HIER AND FLAT BLOCKS',
b'\t CONNECTION LISTS: ON', b'\t TEXT LISTS: ON')
if any(header.count(value) != 1 for value in required):
raise ValueError('Native ASCII export mode does not match the proven contract.')
top_bytes = top.encode('mbcs')
if (not any(line.rstrip(b'\r\n') == b'Block '+top_bytes+b' \tRoot' for line in lines)
or not any(line.startswith(b'Config ') for line in lines)):
raise ValueError('Native ASCII export lacks the exact root or flat configuration.')
for index, prefix in prefixes.items():
ending = b'\r\n' if lines[index].endswith(b'\r\n') else b'\n'
lines[index] = prefix+b'<REPORT_METADATA>'+ending
return b''.join(lines)
def normalize_inf(data):
lines = data.splitlines(keepends=True)
if len(lines) != 2 or lines[0].rstrip(b'\r\n') != INF_HEADER:
raise ValueError('Unknown native CSV information schema.')
values = lines[1].rstrip(b'\r\n').split(b'\t')
if len(values) != 16 or values[:3] != [b'identity', b'Design Capture', b'VB99.0']:
raise ValueError('Malformed native CSV information row.')
if not re.fullmatch(rb'\d{2}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}', values[3]):
raise ValueError('Unknown native CSV System_Date format.')
values[3] = b'<SYSTEM_DATE>'
ending = b'\r\n' if lines[1].endswith(b'\r\n') else b'\n'
return lines[0]+b'\t'.join(values)+ending
def normalize_edif(data, top):
"""Bounded structural parse; replace only root/status/written/timestamp."""
from datetime import datetime
if not data or len(data) > 64*1024*1024:
raise ValueError('EDIF report is empty or exceeds the supported parsing limit.')
token_pattern = re.compile(rb'\s+|[()]|"(?:[^"\\]|\\.)*"|[^\s()"]+')
stack, roots, nodes = [], [], []
position = 0
for match in token_pattern.finditer(data):
if match.start() != position: raise ValueError('Malformed EDIF token.')
position = match.end(); token = match.group()
if token.isspace(): continue
if token == b'(':
node = {'start': match.start(), 'items': []}
if stack: stack[-1]['items'].append(node)
else: roots.append(node)
nodes.append(node); stack.append(node)
if len(stack) > 256 or len(nodes) > 1000000:
raise ValueError('EDIF exceeds supported structural limits.')
elif token == b')':
if not stack: raise ValueError('Unbalanced EDIF report.')
node = stack.pop(); node['end'] = match.end()
if not node['items'] or not isinstance(node['items'][0], bytes):
raise ValueError('EDIF node has no keyword.')
else:
if not stack: raise ValueError('Unexpected EDIF content outside the root.')
stack[-1]['items'].append(token)
if position != len(data) or stack or len(roots) != 1 or roots[0]['items'][0] != b'edif':
raise ValueError('Unbalanced or unsupported EDIF root.')
def children(node, tag):
return [n for n in node['items'] if isinstance(n, dict) and n['items'][0] == tag]
def one(node, tag):
matches = children(node, tag)
if len(matches) != 1: raise ValueError(f'EDIF requires one {tag!r} node in the expected context.')
return matches[0]
root = roots[0]
if one(root, b'edifVersion')['items'] != [b'edifVersion', b'2', b'0', b'0']:
raise ValueError('Unsupported EDIF version.')
written = one(one(root, b'status'), b'written')
if one(written, b'program')['items'][1] != b'"DxDesigner Edif Exporter"':
raise ValueError('Unrecognized native EDIF exporter.')
stamp = one(written, b'timestamp')
values = stamp['items'][1:]
if len(values) != 6 or any(not isinstance(v, bytes) or not v.isdigit() for v in values):
raise ValueError('Malformed EDIF header timestamp.')
datetime(*(int(v) for v in values))
design = one(root, b'design')
top_bytes = top.encode('mbcs')
if re.fullmatch(rb'[A-Za-z][A-Za-z0-9_]*', top_bytes):
expected_identifier = top_bytes
elif re.fullmatch(rb'[0-9][A-Za-z0-9_]*', top_bytes):
# The installed exporter encodes digit-initial EDIF identifiers with
# '&' (observed cellRef &1GPHY_8212). Retain all report bytes; this is
# an exact identity check, not general name stripping or normalization.
expected_identifier = b'&' + top_bytes
else:
raise ValueError('Unsupported native EDIF RootBlock identifier representation.')
if one(design, b'cellRef')['items'][1] != expected_identifier:
raise ValueError('EDIF top design differs from the requested RootBlock.')
if (not any(n['items'] == [b'viewType', b'SCHEMATIC'] for n in nodes)
or any(not any(n['items'][0] == tag for n in nodes) for tag in (b'page', b'figure', b'pt'))):
raise ValueError('EDIF schematic drawing is absent or unsupported.')
return data[:stamp['start']]+b'(timestamp <EXPORT_TIME>)'+data[stamp['end']:]
def csv_identity(root):
from .scoped_manifest import scan_tree
root = Path(root)
paths = {p.relative_to(root).as_posix(): p for p in scan_tree(root) if p.is_file()}
expected = {'work/identity'+suffix for suffix in CSV_SUFFIXES}
if paths.keys() != expected or any(not p.stat().st_size for p in paths.values()):
raise ValueError('Native CSV export is empty, incomplete or an unsupported snapshot.')
index = paths['work/identity'].read_bytes().splitlines()
expected_index = {b'file:identity'+suffix.encode('ascii') for suffix in CSV_SUFFIXES if suffix}
if len(index) != len(expected_index) or set(index) != expected_index:
raise ValueError('Native CSV index does not bind every exported table.')
return {name: _digest(normalize_inf(path.read_bytes()) if name.endswith('.inf') else path.read_bytes())
for name, path in sorted(paths.items())}
def _project_encoding(data):
if data.startswith((b'\xff\xfe', b'\xfe\xff')): return 'utf-16'
if data.startswith(b'\xef\xbb\xbf'): return 'utf-8-sig'
try: data.decode('utf-8'); return 'utf-8'
except UnicodeDecodeError: return 'mbcs'
def project_library(source):
"""Require one existing approved source library across every project ref."""
from .backup_recovery import _project_text
source, pcb, _ = source_project(source)
from .maintenance_entry import maintenance_project_files
libraries = set()
for path in maintenance_project_files(source, pcb):
values = re.findall(r'^KEY CentralLibrary "([^"\r\n]+)"', _project_text(path), re.M)
if not values: raise ValueError('Project lacks CentralLibrary references.')
for value in values:
target = (path.parent/value).resolve(strict=True)
if target.suffix.casefold() != '.lmc' or not target.is_file():
raise ValueError('CentralLibrary is not an existing LMC.')
libraries.add(target)
if len(libraries) != 1: raise ValueError('Project CentralLibrary references disagree.')
return libraries.pop()
def _normalized_project(path, expected_library):
data = path.read_bytes(); encoding = _project_encoding(data)
text = data.decode(encoding)
refs = re.findall(r'^KEY CentralLibrary "([^"\r\n]*)"', text, re.M)
if not refs or any((path.parent/value).resolve() != expected_library.resolve() for value in refs):
raise ValueError(f'CentralLibrary reference does not resolve to the approved library: {path}')
return re.sub(r'(?m)^(KEY CentralLibrary ")[^"\r\n]*(")',
r'\1<CENTRAL_LIBRARY>\2', text).encode(encoding)
def asset_identity(source, expected_library):
from .backup_recovery import _project_text
source, pcb, top = source_project(source)
expected_library = Path(expected_library)
if not expected_library.is_file(): raise ValueError('Approved CentralLibrary is missing.')
root = source.parent
from .maintenance_entry import maintenance_project_files
projects = maintenance_project_files(source, pcb)
databases = []
for project in projects:
values = re.findall(r'^KEY iCDBDir "([^"\r\n]+)"', _project_text(project), re.M)
databases.extend((project.parent/value).resolve() for value in values)
main_database = databases[0]
runtime = [db/'cdbsvr' for db in databases]
files = build_manifest(root, scope=ManifestScope())['files']
assets = {}
for relative, record in files.items():
path = root/relative
known_runtime = False
for server_root in runtime:
if not path.is_relative_to(server_root): continue
parts = path.relative_to(server_root).parts
folded = tuple(p.casefold() for p in parts)
known_runtime = (len(parts) > 1 and folded[0] in ('log', 'dbcheck', 'dbrestore', 'dbupgrade', 'pimlog')
or folded in (('events', 'events.dat'), ('events', 'events.idx'))
or len(parts) == 2 and folded[0] == 'plog'
and re.fullmatch(r'\d{4}\.\d{2}\.\d{2}\.guid\.\d+\.txt', parts[1]) is not None)
break
if path == main_database/'icdb.dat' or known_runtime:
continue
if path in projects:
data = _normalized_project(path, expected_library)
assets[relative] = {'size': len(data), 'sha256': _digest(data)}
else:
assets[relative] = {'size': record['size'], 'sha256': record['sha256']}
return {'policy': POLICY, 'top_level_block': top,
'layout_sha256': hash_file(pcb.parent/'Layout/LayoutDB.lyt'), 'assets': assets}
def check_exporters(mentor_home):
for name, expected in EXPORTER_PROOF.items():
path = Path(mentor_home)/('wv/win32/bin' if name == 'edifExporter.exe' else 'iCDB/win32/bin')/name
if not path.is_file() or hash_file(path) != expected:
raise ValueError(f'Native identity exporter is not the proven EE7.9.5 binary: {path}')
def validate_export_output(kind, code, report, log):
text = Path(log).read_bytes().decode('mbcs', errors='strict')
if code != 0 or re.search(r'(?im)^\s*(?:#\s*)?(?:error|fatal)\b', text):
raise ValueError('Native identity exporter failed or reported an error.')
if kind == 'ascii':
if (not Path(report).is_file() or not Path(report).stat().st_size
or f'Report generation complete, report file is {report}' not in text):
raise ValueError('Native ASCII export lacks a complete nonempty report.')
elif kind == 'csv':
if 'iCDB to CSV complete' not in [line.strip() for line in text.splitlines()]:
raise ValueError('Native CSV export lacks its completion marker.')
csv_identity(report)
elif kind == 'edif':
if (not Path(report).is_file() or not Path(report).stat().st_size
or 'Done' not in [line.strip() for line in text.splitlines()]
or f'Dumping edif file {report} ...' not in text):
raise ValueError('Native EDIF export lacks a complete nonempty drawing report.')
else:
raise ValueError('Unsupported native export kind.')
def _process_snapshot():
from .owner_probe import query_process_snapshot
return query_process_snapshot(timeout_seconds=10)
def _database_released(project_root):
"""Exclusive reads plus absent addresses prove the copied native DBs idle."""
import win32file, win32con
from contextlib import ExitStack
root = Path(project_root)
if any(root.rglob('sAddress.adr')):
return False
with ExitStack() as stack:
for path in root.rglob('*'):
if path.is_file() and path.name.casefold() in ('icdb.dat', 'layoutdb.lyt'):
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, 0, None)
stack.callback(handle.Close)
return True
def _run_exports(project, root, mentor_home, timeout_seconds):
"""Observe exact exporter/descendant handles; never kill a database owner."""
import win32api, win32con, win32event, pywintypes
root = Path(root)
try:
_write_json(root/'export-launch.json', {'started': False})
except OSError as error:
return {'success': False, 'safe_to_continue': True, 'native_started': False,
'detail': str(error)}
diagnostic_warnings = []
try:
before = _process_snapshot()
except Exception as error:
return {'success': False, 'safe_to_continue': True, 'native_started': False,
'detail': str(error)}
from .backup_recovery import _native_scope_match
if any(p['name'].casefold() in _OWNER_NAMES and _native_scope_match(
p.get('command', ''), roots=(project.parent,)) is True for p in before):
return {'success': False, 'safe_to_continue': False, 'detail': 'An existing iCDB owner prevents isolated identity export.'}
if not _database_released(project.parent):
return {'success': False, 'safe_to_continue': False, 'detail': 'Analysis copy has unreleased native addresses or DB handles.'}
from .backup_recovery import _project_text
_, _, top = source_project(project)
database = (project.parent/re.findall(r'^KEY iCDBDir "([^"\r\n]+)"', _project_text(project), re.M)[0]).resolve()
commands = [
('ascii', [str(Path(mentor_home)/'iCDB/win32/bin/icdb2ascii.exe'),
f'-project={project}', f'-file={root/"design.rpt"}', f'-clog={root/"ascii.log"}',
'-f', '-h', '-c', '-t', '-nostrip'], root/'design.rpt', root/'ascii.log'),
('csv', [str(Path(mentor_home)/'iCDB/win32/bin/icdb2csv.exe'),
f'-project={project}', '-snap=DxD', '-file=identity', f'-output={root/"tables"}',
f'-clog={root/"csv.log"}', '-properties', '-nostrip'], root/'tables', root/'csv.log'),
('edif', [str(Path(mentor_home)/'wv/win32/bin/edifExporter.exe'), '-schematic',
'-icdb', str(database), '-isnap', 'DxD', '-top', top, '-o', str(root/'design.edf')],
root/'design.edf', root/'edif-stdout.txt'),
]
for kind, command, report, log in commands:
process = None
handles = {}
identities = {}
released = False
launch_attempted = False
record = {'command': command, 'kind': kind, 'success': False,
'safe_to_continue': False, 'native_started': False}
try:
deadline = time.monotonic()+float(timeout_seconds)
with (root/(kind+'-stdout.txt')).open('wb') as output:
_write_json(root/'export-launch.json', {'started': True})
launch_attempted = True
record['native_started'] = None
process = subprocess.Popen(command, stdout=output, stderr=subprocess.STDOUT,
creationflags=subprocess.CREATE_NO_WINDOW)
record['native_started'] = True
record['pid'] = process.pid
descendants = {process.pid}
_write_json(root/(kind+'-process.json'), record)
while time.monotonic() < deadline:
snapshot = _process_snapshot()
changed = True
while changed:
previous = len(descendants)
descendants.update(p['pid'] for p in snapshot if p['parent'] in descendants)
changed = len(descendants) != previous
owners = [p for p in snapshot if p['pid'] in descendants or (
p['name'].casefold() in _OWNER_NAMES and _native_scope_match(
p.get('command', ''), roots=(project.parent,)) is True)]
for owner in owners:
if owner['pid'] not in handles:
try: handles[owner['pid']] = win32api.OpenProcess(win32con.SYNCHRONIZE, False, owner['pid'])
except pywintypes.error as error:
if error.winerror != 87: raise
record['observed_pids'] = sorted(descendants | handles.keys())
identities.update({owner['pid']:
{key: owner.get(key, '') for key in ('pid', 'created', 'executable')}
for owner in owners})
record['process_identities'] = list(identities.values())
if (process.poll() is not None and not owners
and all(win32event.WaitForSingleObject(h, 0) == win32con.WAIT_OBJECT_0 for h in handles.values())):
released = _database_released(project.parent)
if released: break
time.sleep(.1)
record.update(exit_code=process.poll(), safe_to_continue=released)
if not released:
record['detail'] = 'TIMEOUT: native export owner or copied database release remains unconfirmed.'
return record
validate_export_output(kind, process.returncode, report, log)
record.update(success=True, detail='Native export complete and owners released.')
except Exception as error:
creation_rejected = (isinstance(error, (FileNotFoundError, PermissionError))
or getattr(error, 'winerror', None) in (2, 3, 5, 193, 206, 740))
if process is None and (not launch_attempted or creation_rejected):
# Only a known CreateProcess rejection proves that no native owner started.
released = True
record['native_started'] = False
_write_json(root/'export-launch.json', {'started': False})
record.update(detail=str(error), safe_to_continue=released)
return record
finally:
if process is not None and not released:
import json
owner_path = root/'export-owner.json'
try:
owner = json.loads(owner_path.read_text('utf-8')) if owner_path.is_file() else {}
except (ValueError, OSError):
owner = {} # Preserve unknown ownership; never lose the live handles.
_retained_exports.append((process, handles, {
'library': owner.get('library'), 'project': str(project), 'analysis_root': str(root)}))
else:
for handle in handles.values(): handle.Close()
try:
_write_json(root/(kind+'-process.json'), record)
except OSError as error:
if not released:
raise
warning = 'Export diagnostic write failed: '+str(error)
diagnostic_warnings.append(warning)
record['detail'] = (record.get('detail', '')+'\n'+warning).strip()
return {'success': True, 'safe_to_continue': True,
'detail': '\n'.join(['All three native exports completed and released.', *diagnostic_warnings])}
def capture_identity(source, evidence_root, *, expected_library, owner_library, mentor_home,
timeout_seconds=180):
"""Capture on a fresh project copy while an existing transaction owns its library."""
from .backup_recovery import _align_library
from .library_lock import LibraryLock, owned_snapshot
from .scoped_manifest import copy_verified
from .native_export_guard import begin_export_analysis, finish_export_analysis
import win32event, win32con
root = Path(evidence_root)
try:
root = root.absolute()
source, pcb, top = source_project(source)
library = Path(owner_library)
lease = LibraryLock(library)
if owned_snapshot(lease.path) is None:
raise ValueError('Native identity capture requires a current-thread transaction library lease.')
if (root.resolve().is_relative_to(source.parent) or source.parent.is_relative_to(root.resolve())
or root.resolve().is_relative_to(library.parent.resolve())):
raise ValueError('Native identity evidence must be independent of source and library.')
check_exporters(mentor_home)
root.mkdir(parents=True, exist_ok=False)
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
except Exception as error:
return IdentityOutcome(None, True, str(error), root)
acquired = False
owner_safe = True
outcome = IdentityOutcome(None, True, 'Identity capture did not start.', root)
try:
acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
if not acquired: raise RuntimeError('Another CBB operation owns the management mutex.')
with LibraryLock(library, safe_to_release=lambda: owner_safe):
assets = asset_identity(source, Path(expected_library))
original = copy_verified(source.parent, root/'project')
clone = root/'project'/source.name
_, clone_pcb, _ = source_project(clone)
_align_library(clone, clone_pcb, Path(expected_library))
if any((root/'project').rglob('sAddress.adr')):
raise ValueError('Analysis source contains an unresolved database address.')
export_token = begin_export_analysis(library, root, clone)
owner_safe = False
native = _run_exports(clone, root, mentor_home, timeout_seconds)
if native.get('safe_to_continue') is True:
finish_export_analysis(library, export_token,
native_not_started=native.get('native_started') is False)
owner_safe = True
_write_json(root/'native-outcome.json', native)
if not owner_safe or not native.get('success'):
outcome = IdentityOutcome(None, owner_safe, native.get('detail', 'Native export failed.'), root)
else:
ascii_bytes = normalize_ascii((root/'design.rpt').read_bytes(), top)
csv = csv_identity(root/'tables')
edif_bytes = normalize_edif((root/'design.edf').read_bytes(), top)
if build_manifest(source.parent) != original:
raise ValueError('Identity input changed while exporting its disposable copy.')
fingerprint = {**assets, 'coverage': COVERAGE, 'ascii_sha256': _digest(ascii_bytes),
'csv': csv, 'edif_sha256': _digest(edif_bytes)}
outcome = IdentityOutcome(fingerprint, True, 'Native logical exports and primary assets captured.', root)
except Exception as error:
outcome = IdentityOutcome(None, owner_safe, str(error), root)
finally:
if acquired: win32event.ReleaseMutex(mutex)
mutex.Close()
try:
_write_json(root/'identity.json', {'identity': outcome.identity, 'safe_to_continue': outcome.safe_to_continue,
'detail': outcome.detail, 'policy': POLICY})
except OSError as error:
outcome = IdentityOutcome(outcome.identity, outcome.safe_to_continue,
outcome.detail+'\nIdentity summary write failed: '+str(error), root)
return outcome
@@ -0,0 +1,158 @@
"""Export-copy ownership bound to the existing per-library lease checkpoint."""
from contextlib import contextmanager, ExitStack
import json
from pathlib import Path
from uuid import uuid4
from .management import _write_json
def assert_retained_exports_idle(library=None):
import win32con, win32event
from .native_engineering_identity import _retained_exports
from .library_lock import LibraryBusy
for entry in _retained_exports:
process, handles = entry[:2]
scope = entry[2] if len(entry) > 2 else {}
if (library is not None and scope.get('library')
and Path(scope['library']).resolve() != Path(library).resolve()):
continue
if process.poll() is None or any(win32event.WaitForSingleObject(handle, 0) != win32con.WAIT_OBJECT_0
for handle in handles.values()):
raise LibraryBusy('Native identity exporter or descendant has not released.')
def begin_export_analysis(library, root, project):
from .library_lock import _guard, blocker_path, checkpoint_record, LibraryBusy
from .management_transaction import current_lease
library, root, project = Path(library).resolve(), Path(root).resolve(), Path(project).resolve()
owner = current_lease(library)
if (project.parent != root/'project' or not project.is_file()
or root.is_relative_to(library.parent) or library.parent.is_relative_to(root)):
raise LibraryBusy('Export-copy ownership paths are not independent and exact.')
record = {'protocol': 'cbb-native-export-analysis', 'version': 1, 'token': uuid4().hex,
'library': str(library), 'lease_id': owner['lease_id'], 'supervisor_pid': owner['supervisor_pid'],
'analysis_root': str(root), 'project': str(project)}
with _guard:
marker = blocker_path(library)
checkpoint = checkpoint_record(marker)
if (checkpoint is None or checkpoint['lease_id'] != owner['lease_id']
or 'export_analysis' in checkpoint):
raise LibraryBusy('A prior export analysis is unresolved or the lease changed.')
_write_json(root/'export-owner.json', record)
_write_json(marker, {**checkpoint, 'export_analysis': [record]})
return record['token']
@contextmanager
def prove_export_copies_released(library, *, allow_unknown_checkpoint=False, unstarted_token=''):
"""Fresh process and exclusive-copy proof, including after interpreter exit."""
import win32file, win32con, pywintypes
from .library_lock import blocker_path, checkpoint_record, _supervisor_alive, LibraryBusy
from .native_engineering_identity import _process_snapshot, _OWNER_NAMES
from .scoped_manifest import scan_tree
library = Path(library).resolve()
assert_retained_exports_idle(library)
marker = blocker_path(library)
checkpoint = checkpoint_record(marker)
if marker.exists() and checkpoint is None:
if not allow_unknown_checkpoint:
raise LibraryBusy('Invalid library checkpoint cannot release export ownership.')
# Only the explicit release path supplies full-library/native proof and
# archives the unchanged metadata while its coordination handle is held.
assert_retained_exports_idle()
if any(p['name'].casefold() in _OWNER_NAMES for p in _process_snapshot()):
raise LibraryBusy('Unknown export checkpoint still has a possible native identity owner.')
yield []
return
if checkpoint is None or 'export_analysis' not in checkpoint:
yield []
return
records = checkpoint['export_analysis']
if not isinstance(records, list) or not records:
raise LibraryBusy('Invalid export-analysis ownership record.')
snapshot = None
copies = []
with ExitStack() as stack:
for record in records:
try:
root, project = Path(record['analysis_root']), Path(record['project'])
if (record.get('protocol') != 'cbb-native-export-analysis' or record.get('version') != 1
or not record.get('token') or record['lease_id'] != checkpoint['lease_id']
or record['supervisor_pid'] != checkpoint['pid']
or Path(record['library']).resolve() != library
or not root.is_absolute() or not project.is_absolute() or root.resolve() != root
or project.parent != root/'project' or not project.is_file()
or root.resolve().is_relative_to(library.parent)
or library.parent.is_relative_to(root.resolve())
or json.loads((root/'export-owner.json').read_text(encoding='utf-8')) != record):
raise ValueError('Export record does not match the exact library, lease and copy.')
processes = [root/(kind+'-process.json') for kind in ('ascii', 'csv', 'edif')
if (root/(kind+'-process.json')).exists()]
if not processes:
launch_path = root/'export-launch.json'
launch = json.loads(launch_path.read_text('utf-8')) if launch_path.exists() else None
unstarted_current_lease = False
if unstarted_token and record['token'] == unstarted_token:
# In-memory no-start proof may clear its own guard even
# when creating the first launch record failed.
from .management_transaction import current_lease
current = current_lease(library)
unstarted_current_lease = (record['lease_id'] == current['lease_id']
and record['supervisor_pid'] == current['supervisor_pid'])
if launch != {'started': False} and not (launch is None and unstarted_current_lease):
raise ValueError('Export launch has no confirmed process record.')
else:
if snapshot is None:
snapshot = _process_snapshot()
from .backup_recovery import _native_scope_match
if any(p['name'].casefold() in _OWNER_NAMES and _native_scope_match(
p.get('command', ''), roots=(project.parent,)) is True for p in snapshot):
raise LibraryBusy('A native identity owner is bound to this analysis copy.')
for path in processes:
process = json.loads(path.read_text(encoding='utf-8'))
if ('pid' not in process and process.get('safe_to_continue') is True
and process.get('native_started') is False
and json.loads((root/'export-launch.json').read_text('utf-8')) == {'started': False}):
continue # Failed CreateProcess: no native ownership was acquired.
pids = process.get('observed_pids', []) + [process['pid']]
if any(not isinstance(pid, int) or pid <= 0 for pid in pids):
raise ValueError('Invalid export process identity.')
identities = {p['pid']: p for p in process.get('process_identities', [])}
def original_alive(pid):
recorded = identities.get(pid, {})
current = next((p for p in snapshot if p['pid'] == pid), None)
if recorded.get('created') and current and current.get('created'):
return (recorded['created'] == current['created']
and recorded.get('executable') == current.get('executable'))
return any(p['pid'] == pid for p in snapshot) or _supervisor_alive(pid)
if any(original_alive(pid) for pid in pids):
raise LibraryBusy('A recorded export process or descendant remains alive.')
entries = scan_tree(root/'project')
if any(path.name.casefold() == 'saddress.adr' for path in entries):
raise LibraryBusy('The retained analysis copy still has a database address.')
databases = [path for path in entries if path.is_file()
and path.name.casefold() in ('icdb.dat', 'layoutdb.lyt')]
if not any(path.name.casefold() == 'icdb.dat' for path in databases):
raise ValueError('The recorded analysis database is missing.')
for path in databases:
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, 0, None)
stack.callback(handle.Close)
copies.append(str(root/'project'))
except (KeyError, TypeError, ValueError, OSError, pywintypes.error) as error:
raise LibraryBusy(f'Export analysis release is not proven: {error}') from error
yield copies
def finish_export_analysis(library, token, *, native_not_started=False):
from .library_lock import _guard, blocker_path, checkpoint_record, LibraryBusy
with _guard, prove_export_copies_released(library,
unstarted_token=token if native_not_started else ''):
marker = blocker_path(library)
checkpoint = checkpoint_record(marker)
records = checkpoint.get('export_analysis', []) if checkpoint else []
if len(records) != 1 or records[0].get('token') != token:
raise LibraryBusy('Export ownership changed before confirmed cleanup.')
del checkpoint['export_analysis']
_write_json(marker, checkpoint)
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,61 @@
"""Interpret the current Project Backup loading session, before any Repair."""
import ntpath
import re
def _same(left, right):
return ntpath.normcase(ntpath.normpath(str(left))) == ntpath.normcase(ntpath.normpath(str(right)))
def classify_inspection(project, database, output):
result = {'status': 'UNCONFIRMED', 'repair_required': False}
if not isinstance(output, str):
return result
loaded = re.findall(r'Loading project file \[([^\]\r\n]+)\]\.', output)
if len(loaded) != 1 or not _same(loaded[0], project):
return result
checking = 'Checking if project is in use.'
if checking not in output:
return result
current = output.rsplit(checking, 1)[1]
if re.search(r'\bProject is in use\b', current, re.I):
return {**result, 'status': 'IN_USE'}
if ("Project is not in use. Full iCDB Project Backup's functionality is available." not in current
or 'Backup information loaded correctly.' not in current):
return result
# This exact native error was captured from the isolated EE7.9.5 project.
# A generic 'try Repair' or an old error before the latest check is not proof.
inconsistency_pattern = (
r"Project database \[([^\]\r\n]+)\] is inconsistent\. It has been manually copied while the iCDB Server was running\. "
r"Please use iCDB Project Backup 'Repair project' functionality to fix this issue\.")
inconsistent = re.findall(inconsistency_pattern, current)
from .icdb_recovery import _session_losses
losses = list(_session_losses(current))
if (len(inconsistent) > 1 or any(not _same(path, database) for path in inconsistent)
or len(losses) > 1 or any(not lost.get('session') or lost.get('scope') != 'project'
or not _same(lost.get('database_path', ''), database) for lost in losses)):
return result
required = bool(inconsistent or losses)
remaining = re.sub(inconsistency_pattern, '', current)
if required:
remaining = remaining.replace('Please try to repair the project!', '')
if re.search(r'\berror\b|try to repair|inconsistent|corrupt', remaining, re.I):
return result
return {'status': 'NOT_IN_USE', 'repair_required': bool(required)}
def confirmed_inspection(target, record):
"""Only an exact, exited, inspection-only native process grants a verdict."""
if (not isinstance(record, dict) or record.get('inspection_only') is not True
or record.get('repair_requested') is not False
or type(record.get('native_pid')) is not int or record['native_pid'] <= 0
or record.get('native_exit_code') != 0
or record.get('release', {}).get('native_exited') is not True
or not _same(record.get('project', ''), target.project)
or not _same(record.get('database', ''), target.database)
or record.get('unknown_dialogs')):
return False
expected = classify_inspection(target.project, target.database, record.get('output'))
return (expected['status'] in ('NOT_IN_USE', 'IN_USE')
and record.get('status') == expected['status']
and record.get('repair_required') is expected['repair_required'])
+310
View File
@@ -0,0 +1,310 @@
"""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 工程')
if diagnosis.get('scope') != 'project':
raise ValueError('REPAIR_TARGET_UNCONFIRMED: 数据库所有权范围未知')
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 check_repair_access(target):
"""Preserve the former pre-copy ownership checks without copying data."""
import win32con, win32file, pywintypes
from .scoped_manifest import scan_tree
scan_tree(target.project.parent) # Reject links before native traversal.
try:
handle = win32file.CreateFile(str(target.database/'icdb.dat'), 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
handle.Close()
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_path': str(root),
'release': {'safe_to_continue': False}}
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)
native_status = record.get('status')
record['release'] = repair_release_state(request, target, record)
if native_status == 'REPAIRED' and record['release']['safe_to_continue'] is not True:
record.update(status='UNCONFIRMED', native_status=native_status,
detail='NATIVE_REPAIR_EVIDENCE_UNCONFIRMED: 原生成功或释放证据不完整')
record['evidence_path'] = str(root)
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 _native_identity_and_exit_confirmed(target, record):
if not isinstance(record, dict):
return False
release = record.get('release')
if (not isinstance(release, dict) or release.get('safe_to_continue') is not True
or release.get('native_exited') is not True
or not isinstance(release.get('addresses'), list) or release['addresses']
or type(record.get('native_pid')) is not int or record['native_pid'] <= 0
or not isinstance(record.get('unknown_dialogs', []), list)
or record.get('unknown_dialogs')):
return False
try:
for name, expected in (('project', target.project), ('database', target.database)):
path = record.get(name)
if (not isinstance(path, str) or not Path(path).is_absolute()
or Path(path).resolve(strict=True) != expected.resolve(strict=True)):
return False
except (OSError, ValueError):
return False
return True
def native_success_confirmed(target, record):
"""Validate the worker's complete, consistent success before any reopening."""
if not _native_identity_and_exit_confirmed(target, record) or record.get('status') != 'REPAIRED':
return False
evidence = record.get('evidence')
if (not isinstance(evidence, dict) or evidence.get('confirmed') is not True
or evidence.get('native_backup') is not True
or evidence.get('outcome') != 'UNCONFIRMED'
or evidence.get('failure_complete') is not False
or evidence.get('restore_complete') is not False
or evidence.get('restored_from_backup') != ''):
return False
fields = ('diagnostic_tail', 'database_tail', 'restore_tail', 'output_tail')
if any(not isinstance(evidence.get(field), str) for field in fields):
return False
if not evidence['diagnostic_tail'] or not evidence['database_tail']:
return False
from .native_repair_ui import classify_repair_evidence
return (classify_repair_evidence(*(evidence[field] for field in fields))['outcome'] == 'UNCONFIRMED'
and 'iCDB database restored from backup:' not in evidence['restore_tail'])
def repair_release_state(request, target, native_result):
"""Require normal exit, owner/address absence and exclusive database access."""
from .mentor_adapter import pcb_processes, _process_details
from .icdb_ownership import database_directories, unreleased_addresses
from .verify_runner import preflight
release = native_result.get('release') if isinstance(native_result, dict) else None
result = {**(release if isinstance(release, dict) else {}), 'safe_to_continue': False,
'database_exclusive': False}
try:
if (not _native_identity_and_exit_confirmed(target, native_result)
or (native_result.get('status') == 'REPAIRED'
and not native_success_confirmed(target, native_result))):
result['error'] = 'NATIVE_REPAIR_EVIDENCE_UNCONFIRMED'
return result
project, pcb = preflight(request)
owners = [int(r[0]) for r in pcb_processes()]
for name in ('LibraryManager.exe', 'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe'):
owners.extend(int(r[0]) for r in _process_details(name))
for pid, _exe, command, _parent in _process_details('cscript.exe'):
if (not command or str(project).casefold() in command.casefold()
or str(pcb).casefold() in command.casefold()):
owners.append(int(pid))
result.update(remaining_pids=sorted(set(owners)),
addresses=unreleased_addresses(request.lmc_file, project, pcb))
if (native_result.get('release', {}).get('safe_to_continue') is not True
or owners or result['addresses']):
return result
import win32con, win32file
files = [target.database/'icdb.dat']
files.extend(folder/'icdb.dat' for folder in database_directories(request.lmc_file, project, pcb)
if (folder/'icdb.dat').is_file())
result['exclusive_databases'] = []
for database_file in dict.fromkeys(files):
handle = win32file.CreateFile(str(database_file), win32con.GENERIC_READ,
0, None, win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
handle.Close()
result['exclusive_databases'].append(str(database_file))
result.update(database_exclusive=True, safe_to_continue=True)
except Exception as error:
result['error'] = str(error)
return result
def run_native_repair(target, root, *, mentor_bin='', timeout_seconds=300, progress=None,
maintenance_context=None, inspection_only=False, stop=None):
"""Supervise the GUI on its own desktop; a repair timeout never kills it."""
if stop is not None and stop.is_set():
return {'status': 'CANCELLED', 'native_started': False,
'detail': '原生操作启动前已取消', 'release': {'safe_to_continue': True}}
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,
'maintenance_context': maintenance_context, 'inspection_only': inspection_only},
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)
# Worker admission includes filesystem/ownership checks before the native
# timeout begins. Bound that preparation separately; never extend on polls.
deadline = time.monotonic()+60+max(1, float(timeout_seconds))+5
event_count = 0
cancelled = False
try:
while worker.poll() is None and time.monotonic()<deadline:
if not cancelled and stop is not None and stop.is_set():
worker.request_stop()
cancelled = True
deadline = min(deadline, time.monotonic()+5)
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': 'CANCELLED_UNRELEASED' if cancelled else 'TIMEOUT_UNRELEASED', 'worker_pid': worker.pid, 'desktop': desktop,
'release': {'safe_to_continue': False},
'detail': '原生修复尚未确认结束,保留操作并停止批次', 'evidence_path': str(root)}
result = json.loads(outcome.read_text('utf-8'))
if cancelled:
result.update(status='CANCELLED', repair_required=False)
if worker.returncode != 0 and result.get('status') in ('REPAIRED', 'NOT_IN_USE', 'IN_USE'):
result['status'] = 'UNCONFIRMED'
return {**result, 'evidence_path': str(root)}
finally:
worker.close()
+452
View File
@@ -0,0 +1,452 @@
"""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 shutil
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 classify_repair_evidence(diagnostic, database, restore, output):
"""Classify this invocation only; an error alone does not prove native idle."""
combined = '\n'.join((diagnostic, database, restore, output))
# This observed loading-progress line precedes the actual ownership verdict.
combined = re.sub(r'(?im)^\s*(?:\[[^\]\r\n]+\]\s*)?Checking if project is in use\.\s*$', '', combined)
terminal_error = bool(re.search(r'Repair project error\s*\[[^\r\n]+\]', output, re.I))
closed_error = ('Diagnostic: FINISH' in diagnostic and 'IC: Closing project' in database)
if re.search(r'project is in use|database.*(?:in use|busy)|other clients are connected', combined, re.I):
outcome = 'DATABASE_BUSY'
elif re.search(r'there is no backup of (?:missing )?iCDB|no (?:healthy|valid) backup', combined, re.I):
outcome = 'MISSING_HEALTHY_BACKUP'
elif re.search(r'\bERROR\s*:|not repaired|repair.*failed|Repair project error', combined, re.I):
outcome = 'NATIVE_REPAIR_FAILED'
else:
outcome = 'UNCONFIRMED'
return {'outcome': outcome, 'failure_complete': bool(
outcome != 'UNCONFIRMED' and (terminal_error or closed_error))}
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 win32api, 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))})
# Empty window lists are valid. pywin32 otherwise interprets a stale
# thread error (observed ERROR_FILE_NOT_FOUND) as an enum failure.
win32api.SetLastError(0)
win32gui.EnumChildWindows(hwnd, child, None)
windows.append({'hwnd': hwnd, 'title': win32gui.GetWindowText(hwnd),
'class': win32gui.GetClassName(hwnd), 'enabled': bool(win32gui.IsWindowEnabled(hwnd)),
'children': children})
win32api.SetLastError(0)
win32gui.EnumWindows(observe, None)
return windows
def _native_output(windows):
"""Read Output without UI activation; a hung control has a bounded deadline."""
user32 = ctypes.WinDLL('user32', use_last_error=True)
user32.SendMessageTimeoutW.argtypes = [wintypes.HWND, wintypes.UINT, wintypes.WPARAM,
wintypes.LPARAM, wintypes.UINT, wintypes.UINT, ctypes.POINTER(ctypes.c_size_t)]
user32.SendMessageTimeoutW.restype = wintypes.LPARAM
texts = []
for window in windows:
for child in window['children']:
if not child['class'].casefold().startswith('richedit'):
continue
buffer = ctypes.create_unicode_buffer(131072)
copied = ctypes.c_size_t()
if not user32.SendMessageTimeoutW(child['hwnd'], 0x000D, len(buffer),
ctypes.addressof(buffer), 0x0002, 200, ctypes.byref(copied)):
return None
if copied.value >= len(buffer)-1:
return None # A truncated prefix cannot establish the current operation.
texts.append(buffer.value)
return '\n'.join(texts) if texts else None
def _native_evidence(project, database, pid, started_ns, baseline, *, output_text=''):
"""Use only this native process's new diagnostic/close and backup evidence."""
log_paths = []
def read_logs(folder):
text = []
for path in (database/'cdbsvr'/folder).glob(f'*-{pid}/*.txt'):
if path.stat().st_mtime_ns >= started_ns:
log_paths.append(str(path))
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)
classification = classify_repair_evidence(diagnostic, db_log, restore_log, output_text)
valid = (classification['outcome'] == 'UNCONFIRMED' and not restored
and str(database).casefold() in db_log.casefold()
and repair_completed(diagnostic, db_log, native_backup=native_backup))
return {**classification, 'confirmed': bool(valid), 'native_backup': native_backup,
'output_tail': output_text[-8192:], 'log_paths': log_paths,
'backup_log_tail': text[-8192:],
'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 _inspect_project(job, process, emit):
"""Observe this process's native query; never send a Repair/menu command."""
import win32con, win32gui
from .native_occupancy import classify_inspection
project, database = Path(job['project']), Path(job['database'])
result = {'status': 'UNCONFIRMED', 'project': str(project), 'database': str(database),
'native_pid': process.pid, 'inspection_only': True, 'repair_requested': False,
'repair_required': False, 'output': ''}
deadline = time.monotonic() + max(1, float(job['timeout']))
closing = False
last_state = None
# Reserve a short cooperative-close grace after the inspection deadline.
while process.poll() is None and time.monotonic() < deadline + 3:
windows = [w for w in _windows(process.pid) if not (
w['title'] == '' and w['class'] in ('UAC_InputIndicatorOverlayWnd', 'UAC Input Indicator'))]
shells = [w for w in windows if w['class'].startswith('Afx:') and w['title'] == 'iCDB Project Backup']
exact = [w for w in windows if w['class'].startswith('Afx:')
and w['title'].casefold() == ('iCDB Project Backup - '+str(project)).casefold()]
# EE7.9 can keep the generic shell title while loading the requested PRJ.
# Its Output still binds the project; waiting only for the decorated title
# turns a valid session into a false timeout.
mains = exact or shells
main = mains[0] if len(mains) == 1 else None
unknown = [w for w in windows if w is not main and w not in shells]
if unknown:
result.update(status='UNCONFIRMED', unknown_dialogs=unknown)
break
current = _native_output(windows)
state = {'main_found': main is not None, 'output_readable': current is not None,
'windows': windows}
if state != last_state:
(Path(job['root'])/'inspection-state.json').write_text(
json.dumps(state, ensure_ascii=False, indent=2), encoding='utf-8')
emit(stage='native_occupancy_wait', main_found=state['main_found'], output_readable=state['output_readable'])
last_state = state
if current is not None:
result['output'] = current
cancelled = Path(job['cancel_signal']).exists()
expired = time.monotonic() >= deadline
verdict = classify_inspection(project, database, current)
if cancelled:
result.update(status='CANCELLED', repair_required=False)
if not closing and main and main['enabled'] and (cancelled or expired or verdict['status'] != 'UNCONFIRMED'):
if not cancelled and not expired: result.update(verdict)
emit(stage='native_occupancy', **result)
win32gui.PostMessage(main['hwnd'], win32con.WM_CLOSE, 0, 0)
closing = True
time.sleep(.2)
exited = process.poll() is not None
result['native_exit_code'] = process.poll()
result['release'] = {'native_exited': exited,
'addresses': [str(database/'cdbsvr/sAddress.adr')] if (database/'cdbsvr/sAddress.adr').exists() else [],
'safe_to_continue': exited and result['status'] == 'NOT_IN_USE'}
if not exited:
result.update(status='TIMEOUT_UNRELEASED', repair_required=False)
result['detail'] = ('原生检查窗口未返回 Output,未执行 Repair。'
if not result['output'] else '原生检查工具未退出,未执行 Repair。')
return result
class _CancellationFile:
def __init__(self, path):
self.path = Path(path)
self._next_poll = 0.0
self._cancelled = False
self.polls = 0
self.poll_seconds = 0.0
def is_set(self):
# scan_tree checks between every entry. Avoid issuing tens of
# thousands of filesystem requests just to observe one IPC flag.
# The direct checks before Popen/Repair remain immediate.
now = time.monotonic()
if not self._cancelled and now >= self._next_poll:
self._cancelled = self.path.exists()
finished = time.monotonic()
self.polls += 1
self.poll_seconds += finished-now
self._next_poll = finished + .1
return self._cancelled
def repair_worker_main(job_path):
import win32con, win32gui
from .native_repair import RepairTarget, check_repair_access
from .mentor_paths import discover_sdd_home
from .icdb_recovery import snapshot_log
job = json.loads(Path(job_path).read_text('utf-8'))
stop = _CancellationFile(job['cancel_signal'])
root = Path(job['root'])
project, database = Path(job['project']), Path(job['database'])
result = {'status': 'BLOCKED', 'native_started': False, 'project': str(project), 'database': str(database),
'release': {'safe_to_continue': False}}
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 = None if job.get('inspection_only') else _repair_command(executable)
from .mentor_adapter import pcb_processes, _process_details
if not job.get('inspection_only') and (pcb_processes() or _process_details('LibraryManager.exe')):
raise ValueError('REPAIR_DATABASE_IN_USE')
maintenance_context = job.get('maintenance_context')
if maintenance_context is not None:
from .maintenance_entry import maintenance_target_guard
from .verify_runner import VerifyRequest
maintenance_request = VerifyRequest(Path(maintenance_context['library']),
maintenance_context['block'], root, maintenance=True)
emit(stage='native_preflight', detail='正在核对本次原生工具的目标及占用')
if job.get('inspection_only'):
from .scoped_manifest import scan_tree
def check_cancelled():
if stop.is_set():
raise InterruptedError('检查已取消')
scan_tree(project.parent, check=check_cancelled)
else:
check_repair_access(RepairTarget(project, database))
emit(stage='backup_skipped', reason='manual_backup_policy',
detail='应用不自动备份;Mentor 原生修复仍可能生成自身备份。')
if Path(job['cancel_signal']).exists():
raise ValueError('REPAIR_CANCELLED_BEFORE_LAUNCH')
if maintenance_context is not None:
# Manual backup policy leaves no mutation between preparation and
# launch. Run the complete guard once here, retaining its identity,
# address and exclusive-access checks immediately before Popen.
with maintenance_target_guard(maintenance_request, maintenance_context, stop=stop) as checked:
if (checked['target'].project.resolve() != project.resolve()
or checked['target'].database.resolve() != database.resolve()):
raise ValueError('MAINTENANCE_TARGET_UNCONFIRMED')
emit(stage='native_preflight_complete', cancellation_polls=stop.polls,
cancellation_poll_seconds=round(stop.poll_seconds, 3))
if Path(job['cancel_signal']).exists():
raise ValueError('REPAIR_CANCELLED_BEFORE_LAUNCH')
baseline = snapshot_log(project.parent/'Log Files/ProjectBackupLog.txt')
started_ns = time.time_ns()
if Path(job['cancel_signal']).exists():
raise ValueError('REPAIR_CANCELLED_BEFORE_LAUNCH')
process = subprocess.Popen([str(executable), '-p', str(project)], cwd=str(project.parent))
result['native_started'] = True
result['native_pid'] = process.pid
emit(stage='native_started', pid=process.pid, project=str(project))
if job.get('inspection_only'):
result = _inspect_project(job, process, emit)
(root/'repair-result.json').write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding='utf-8')
return 0 if result['status'] in ('NOT_IN_USE', 'IN_USE') else 1
deadline = time.monotonic()+max(1, float(job['timeout']))
invoked = confirmed = closing = False
evidence = None
output_baseline = None
output = ''
while process.poll() is None and time.monotonic()<deadline:
windows = [w for w in _windows(process.pid) if not (
w['title'] == '' and w['class'] in (
'UAC_InputIndicatorOverlayWnd', 'UAC Input Indicator'))]
mains = [w for w in windows if w['class'].startswith('Afx:')
and w['title'].casefold() == ('iCDB Project Backup - '+str(project)).casefold()]
main = mains[0] if len(mains) == 1 else None
# The native Afx shell appears before it loads the requested PRJ.
# Only a unique, exact generic shell before Repair may wait here;
# it never authorizes a command or masks another target/window.
shells = [w for w in windows if not invoked and w['class'].startswith('Afx:')
and w['title'] == 'iCDB Project Backup']
starting = shells[0] if len(shells) == 1 and not mains else None
dialogs = [w for w in windows if w['class'] == '#32770']
unknown = [w for w in windows if w is not main and w is not starting and w not in dialogs]
current_output = _native_output(windows)
busy_before_start = (not invoked and current_output is not None
and classify_repair_evidence('', '', '', current_output)['outcome'] == 'DATABASE_BUSY')
if busy_before_start:
output = current_output
result.update(status='DATABASE_BUSY', detail='原生工具加载工程时报告占用;未请求 Repair')
maintenance_ready = (maintenance_context is None or isinstance(current_output, str)
and 'Project is not in use. Full iCDB Project Backup\'s functionality is available.' in current_output)
if (not invoked and isinstance(current_output, str) and not busy_before_start and maintenance_ready
and main and not dialogs and not unknown and main['enabled']):
if Path(job['cancel_signal']).exists():
raise ValueError('REPAIR_CANCELLED_BEFORE_START')
output_baseline = current_output
win32gui.PostMessage(main['hwnd'], win32con.WM_COMMAND, command_id, 0)
invoked = True
emit(stage='native_repair_requested', command=command_id)
if dialogs or unknown:
known = [d for d in dialogs if invoked and not confirmed and main
and confirmation_allowed(main['title'], project,
'\n'.join(c['text'] for c in d['children']))]
if unknown or len(dialogs) != 1 or len(known) != 1:
result.update(status='UNKNOWN_DIALOG', unknown_dialogs=[*unknown, *dialogs],
detail='未知原生弹窗;未发送操作,保留原生工具')
# Capture evidence below before stopping supervision.
else:
dialog = known[0]
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 (invoked and output_baseline is not None and current_output is not None
and current_output.startswith(output_baseline)):
output = current_output[len(output_baseline):]
evidence = _native_evidence(project, database, process.pid, started_ns, baseline,
output_text=output)
(root/'native-output.json').write_text(json.dumps({
'native_pid': process.pid, 'baseline': output_baseline, 'current': current_output,
'invocation_output': output}, ensure_ascii=False, indent=2), encoding='utf-8')
if result['status'] == 'UNKNOWN_DIALOG' or busy_before_start:
break
if confirmed and not closing and main and not dialogs and main['enabled']:
if (evidence['outcome'] != 'DATABASE_BUSY'
and not (database/'cdbsvr/sAddress.adr').exists() and (
evidence['failure_complete'] or evidence['confirmed'] or (evidence.get('restore_complete')
and evidence['native_backup']
and evidence['outcome'] == 'UNCONFIRMED'))):
win32gui.PostMessage(main['hwnd'], win32con.WM_CLOSE, 0, 0)
closing = True
emit(stage='native_repair_finished', **evidence)
time.sleep(.2)
if evidence:
result['evidence'] = evidence
for log_path in evidence['log_paths']:
source = Path(log_path)
destination = root/'native-logs'/source.relative_to(database/'cdbsvr')
destination.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(source, destination)
addresses = [str(database/'cdbsvr/sAddress.adr')] if (database/'cdbsvr/sAddress.adr').exists() else []
result['release'] = {'native_exited': process.poll() is not None, 'addresses': addresses,
'safe_to_continue': process.poll() is not None and not addresses}
if result['status'] == 'UNKNOWN_DIALOG':
pass
elif evidence and evidence['outcome'] != 'UNCONFIRMED':
result.update(status=evidence['outcome'], detail='原生 Repair 失败;详见本次日志和 Output')
elif (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='TIMEOUT_UNRELEASED' 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')
result['preflight_cancellation'] = {'polls': stop.polls,
'seconds': round(stop.poll_seconds, 3)}
# 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
+114 -16
View File
@@ -9,6 +9,20 @@ import ntpath
import os
from pathlib import Path
from typing import Protocol
from functools import wraps
from threading import RLock
from weakref import WeakValueDictionary
_retained_path_leases = {}
_live_path_leases = WeakValueDictionary()
_path_lease_guard = RLock()
def _lease_locked(method):
@wraps(method)
def locked(*args, **kwargs):
with _path_lease_guard: return method(*args, **kwargs)
return locked
class NetworkPathError(RuntimeError):
@@ -45,23 +59,35 @@ class WindowsWNetBackend:
def __init__(self) -> None:
self._mpr = ctypes.WinDLL("mpr", use_last_error=True)
self._kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
self._unavailable_drives = set()
def mapping(self, drive: str) -> str | None:
size = wintypes.DWORD(32768)
buffer = ctypes.create_unicode_buffer(size.value)
error = self._mpr.WNetGetConnectionW(drive, buffer, ctypes.byref(size))
if error == 0:
return buffer.value
if error == self.ERROR_NOT_CONNECTED:
return None
raise OSError(error, f"WNetGetConnectionW({drive})")
def mappings(self) -> dict[str, str]:
result: dict[str, str] = {}
self._unavailable_drives = set()
for code in range(ord("D"), ord("Z") + 1):
drive = f"{chr(code)}:"
size = wintypes.DWORD(32768)
buffer = ctypes.create_unicode_buffer(size.value)
error = self._mpr.WNetGetConnectionW(drive, buffer, ctypes.byref(size))
if error == 0:
result[drive] = buffer.value
elif error != self.ERROR_NOT_CONNECTED:
raise OSError(error, f"WNetGetConnectionW({drive})")
try:
remote = self.mapping(drive)
except OSError:
self._unavailable_drives.add(drive)
continue
if remote:
result[drive] = remote
return result
def used_drives(self) -> set[str]:
mask = int(self._kernel32.GetLogicalDrives())
return {
return getattr(self, '_unavailable_drives', set()) | {
f"{chr(ord('A') + index)}:"
for index in range(26)
if mask & (1 << index)
@@ -88,6 +114,14 @@ def _same_remote(left: str, right: str) -> bool:
return ntpath.normcase(ntpath.normpath(left)) == ntpath.normcase(ntpath.normpath(right))
def _mapping(backend, drive):
direct = getattr(backend, 'mapping', None)
if callable(direct):
return direct(drive)
return next((value for key, value in backend.mappings().items()
if str(key).upper().rstrip('\\/') == drive.upper()), None)
def ensure_mapped_drive_visible(drive: str, remote_root: str, *,
backend: WNetBackend | None = None) -> dict[str, object]:
"""Ensure a worker process can see the mapped drive used by Mentor.
@@ -108,13 +142,11 @@ def ensure_mapped_drive_visible(drive: str, remote_root: str, *,
normalized_drive = raw_drive.upper()
backend = backend or WindowsWNetBackend()
try:
mappings = backend.mappings()
current = _mapping(backend, normalized_drive)
except OSError as error:
raise NetworkPathError(
f"NETWORK_UNAVAILABLE: 无法读取网络盘映射 {normalized_drive}: {error}"
) from error
current = next((value for key, value in mappings.items()
if str(key).upper().rstrip('\\/') == normalized_drive), None)
if current:
if _same_remote(current, raw_remote):
return {'drive': normalized_drive, 'remote_root': current, 'created': False}
@@ -178,8 +210,13 @@ class LibraryPathLease:
created: bool = False
_backend: WNetBackend | None = None
_closed: bool = False
_retained_for_recovery: bool = False
def __post_init__(self):
with _path_lease_guard: _live_path_leases[id(self)] = self
@classmethod
@_lease_locked
def acquire(cls, path, *, backend: WNetBackend | None = None) -> "LibraryPathLease":
raw = _normalize_input_path(path)
if not raw.startswith("\\\\"):
@@ -188,8 +225,7 @@ class LibraryPathLease:
if drive:
try:
backend = backend or WindowsWNetBackend()
remote = next((value for key, value in backend.mappings().items()
if str(key).upper().rstrip('\\/') == drive.upper()), '')
remote = _mapping(backend, drive.upper()) or ''
except (OSError, AttributeError):
remote = ''
return cls(local, local, drive.upper(), remote, False, backend)
@@ -224,16 +260,61 @@ class LibraryPathLease:
f"NETWORK_UNAVAILABLE: 无法挂载中心库 {remote_root}: {error}"
) from error
@_lease_locked
def retain_for_recovery(self) -> None:
"""Keep the Mentor drive available to a retained native session."""
self._retained_for_recovery = True
_retained_path_leases[id(self)] = self
@_lease_locked
def release_after_recovery(self, proof) -> bool:
"""Restore normal mapping lifetime after this library's release proof."""
if not isinstance(proof, dict) or proof.get('status') != 'RELEASE_CONFIRMED':
return False
candidates = [str(path) for path in (self.display_path, self.mentor_path)
if str(path).casefold().endswith('.lmc')]
drive, tail = ntpath.splitdrive(str(self.mentor_path))
if (self.remote_root and drive.upper() == self.drive.upper()
and str(self.mentor_path).casefold().endswith('.lmc')):
candidates.append(self.remote_root + tail)
library = str(proof.get('library') or '')
if not any(_same_remote(library, candidate) for candidate in candidates):
return False
self._retained_for_recovery = False
_retained_path_leases.pop(id(self), None)
return True
@_lease_locked
def transfer_ownership(self, other) -> None:
"""Keep a shared mapping alive for the currently loaded library."""
if (isinstance(other, LibraryPathLease) and not other._closed
and self.created and self.drive.upper() == other.drive.upper()
and self.remote_root and _same_remote(self.remote_root, other.remote_root)):
other.created, other._backend = True, self._backend
self.created = False
@_lease_locked
def close(self) -> None:
if self._closed:
return
self._closed = True
if not self.created or self._backend is None or not self.drive:
if self._retained_for_recovery:
return
if not self.created or self._backend is None or not self.drive:
self._closed = True
return
for live in tuple(_live_path_leases.values()):
same_backend = (live._backend is self._backend or
isinstance(self._backend, WindowsWNetBackend) and isinstance(live._backend, WindowsWNetBackend))
if live is not self and not live._closed and same_backend:
self.transfer_ownership(live)
if not self.created:
self._closed = True
return
try:
current = self._backend.mappings().get(self.drive)
current = _mapping(self._backend, self.drive)
if current and _same_remote(current, self.remote_root):
self._backend.cancel_mapping(self.drive)
self._closed = True
except OSError as error:
raise NetworkPathError(
f"NETWORK_UNAVAILABLE: 释放临时盘符 {self.drive} 失败: {error}"
@@ -244,3 +325,20 @@ class LibraryPathLease:
def __exit__(self, exc_type, exc_value, traceback) -> None:
self.close()
def release_retained_path_leases(proof, *, current_lease=None) -> int:
"""Recover matching leases even after the UI dropped its old reference."""
released = 0
for lease in tuple(_retained_path_leases.values()):
if not lease.release_after_recovery(proof):
continue
if lease is not current_lease:
lease.transfer_ownership(current_lease)
try:
lease.close()
except NetworkPathError:
_retained_path_leases[id(lease)] = lease
raise
released += 1
return released
+44
View File
@@ -0,0 +1,44 @@
"""Cooperative FIFO admission for this application's native operations."""
from threading import Condition
class QueueCancelled(RuntimeError):
pass
class NativeQueue:
def __init__(self):
self.condition = Condition()
self.pending = []
self.active = False
def wake(self):
with self.condition: self.condition.notify_all()
def run(self, action, *, stop=None, waiting=None, ready=lambda: True):
ticket = object()
acquired, notified = False, False
with self.condition: self.pending.append((ticket, ready))
try:
while not acquired:
with self.condition:
if stop is not None and stop.is_set():
raise QueueCancelled('已取消排队,未启动原生操作。')
first = next((token for token, available in self.pending if available()), None)
if not self.active and first is ticket:
self.pending = [entry for entry in self.pending if entry[0] is not ticket]
self.active = acquired = True
else:
self.condition.wait(.1)
if not acquired and not notified and waiting is not None:
notified = True
try: waiting()
except Exception: pass
if stop is not None and stop.is_set():
raise QueueCancelled('已取消排队,未启动原生操作。')
return action()
finally:
with self.condition:
self.pending = [entry for entry in self.pending if entry[0] is not ticket]
if acquired: self.active = False
self.condition.notify_all()
+88
View File
@@ -0,0 +1,88 @@
"""Bound WMI enumeration in a read-only helper, never in the Qt thread."""
from pathlib import Path
import json
import re
import subprocess
import sys
import tempfile
def query_owners(names, *, timeout_seconds=10):
names = tuple(names)
if not names or any(not re.fullmatch(r'[\w.-]+\.exe', name, re.I) for name in names):
raise ValueError('OWNER_QUERY_INVALID')
return _query_processes(names, timeout_seconds=timeout_seconds)
def query_process_snapshot(*, timeout_seconds=10):
"""Bound a complete process tree; retain unknown executable descendants."""
return _query_processes(None, timeout_seconds=timeout_seconds)
def _query_processes(names, *, timeout_seconds):
full_snapshot = names is None
request = {'snapshot_version': 1} if full_snapshot else {'names': names}
with tempfile.TemporaryDirectory(prefix='cbb-owner-probe-') as directory:
job = Path(directory)/'request.json'
job.write_text(json.dumps(request), encoding='utf-8')
command = ([sys.executable] if getattr(sys, 'frozen', False) else
[sys.executable, '-m', 'cbb_refresh_verify']) + ['--owner-probe', str(job)]
try:
result = subprocess.run(command, timeout=max(.1, min(10, timeout_seconds)),
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
except subprocess.TimeoutExpired as error:
# This helper only enumerates processes; it never launches Mentor
# or acquires a native database session.
raise RuntimeError('OWNER_QUERY_TIMEOUT: 进程查询超时,占用状态无法确认') from error
try:
record = json.loads(job.with_name('result.json').read_text('utf-8'))
rows = record['owners']
identity_matches = (type(record.get('snapshot_version')) is int and record['snapshot_version'] == 1
if full_snapshot else record.get('names') == list(names))
if result.returncode != 0 or not identity_matches or not isinstance(rows, list):
raise ValueError('invalid result')
seen = set()
for row in rows:
if (type(row['pid']) is not int or row['pid'] < (0 if full_snapshot else 1)
or row['pid'] in seen or not isinstance(row['name'], str) or not row['name']
or not full_snapshot and row['name'].casefold() not in {n.casefold() for n in names}
or full_snapshot and not isinstance(row['created'], str)
or not isinstance(row['command'], str) or not isinstance(row['executable'], str)
or type(row['parent']) is not int or row['parent'] < 0):
raise ValueError('invalid owner')
seen.add(row['pid'])
return rows
except (OSError, ValueError, KeyError, TypeError, AttributeError) as error:
raise RuntimeError('OWNER_QUERY_UNCONFIRMED: 进程查询未返回有效证据') from error
def owner_probe_main(job):
import pythoncom
import win32com.client
job = Path(job)
request = json.loads(job.read_text('utf-8'))
full_snapshot = request == {'snapshot_version': 1} and type(request.get('snapshot_version')) is int
names = request.get('names')
if not full_snapshot:
if (not isinstance(names, list) or not names
or any(not isinstance(name, str) or not re.fullmatch(r'[\w.-]+\.exe', name, re.I) for name in names)):
return 1
pythoncom.CoInitialize()
try:
service = win32com.client.GetObject('winmgmts:')
query = ('SELECT ProcessId,Name,CommandLine,ExecutablePath,ParentProcessId' +
(',CreationDate' if full_snapshot else '') + ' FROM Win32_Process')
if not full_snapshot:
query += ' WHERE ' + ' OR '.join(f"Name='{name}'" for name in names)
rows = [{'pid': int(item.ProcessId), 'name': str(item.Name),
'command': str(item.CommandLine or ''), 'executable': str(item.ExecutablePath or ''),
'parent': int(item.ParentProcessId or 0),
**({'created': str(item.CreationDate or '')} if full_snapshot else {})}
for item in service.ExecQuery(query)]
service = None
response = {'snapshot_version': 1} if full_snapshot else {'names': names}
job.with_name('result.json').write_text(json.dumps({**response, 'owners': rows}), encoding='utf-8')
return 0
finally:
pythoncom.CoUninitialize()
+34 -15
View File
@@ -91,6 +91,35 @@ def require_document_identity(document, job):
return integration
class ProcessWatch:
"""Hold this task's native handles; repeated COM attach polls never run WMI."""
def __init__(self, pids):
self.pids = set(int(pid) for pid in pids if pid)
self.handles = None
def __enter__(self):
return self
def alive(self):
import pywintypes, win32api, win32con, win32event
if self.handles is None:
self.handles = []
try:
for pid in self.pids:
try:
self.handles.append(win32api.OpenProcess(win32con.SYNCHRONIZE, False, pid))
except pywintypes.error as error:
if error.winerror != 87: raise
except Exception:
self.__exit__(None, None, None)
raise
return any(win32event.WaitForSingleObject(h, 0) != win32con.WAIT_OBJECT_0 for h in self.handles)
def __exit__(self, *_):
for handle in self.handles or (): handle.Close()
self.handles = []
def wait_for_target_document(job, app_provider, *, process_alive, emit=lambda **event: None,
error_reader=None, sleep=time.sleep):
"""Wait for the exact launched document; the parent process owns timeout."""
@@ -103,6 +132,11 @@ def wait_for_target_document(job, app_provider, *, process_alive, emit=lambda **
try:
app = app_provider()
document = app.ActiveDocument
if not document:
observation = ('PCB_DOCUMENT_NOT_READY', 'COM 已连接,尚无目标文档')
if observation != last_observation:
emit(stage='pcb_document_wait', error_code=observation[0], detail=observation[1])
last_observation = observation
if document:
try:
integration = require_document_identity(document, job)
@@ -126,18 +160,3 @@ def wait_for_target_document(job, app_provider, *, process_alive, emit=lambda **
last_observation = observation
sleep(.25)
raise PcbBridgeError('PCB_EXITED_BEFORE_COM', 'PCB 在 COM 文档就绪前退出')
def execution_outcome(*, save_complete: bool, pcb_exited: bool,
fatal_error: str = '') -> dict[str, object]:
if fatal_error:
code, _, detail = str(fatal_error).partition(':')
return {'status': 'FAIL', 'error_code': code.strip() or 'FATAL_DIALOG',
'stderr': detail.strip() or str(fatal_error), 'safe_to_continue': True}
if not save_complete:
return {'status': 'FAIL', 'error_code': 'SAVE_NOT_CONFIRMED',
'stderr': '保存/关闭未完成', 'safe_to_continue': True}
if not pcb_exited:
return {'status': 'FAIL', 'error_code': 'PCB_EXIT_NOT_CONFIRMED',
'stderr': '保存后未确认 PCB 退出', 'safe_to_continue': True}
return {'status': 'PASS', 'stdout': 'Project Integration 已同步;保存、关闭和 PCB 退出均已确认。'}
@@ -0,0 +1,151 @@
"""Explicit user choice for the owned PCB's native historical-version prompt."""
from dataclasses import replace
import json
from pathlib import Path
from threading import Lock
import time
from .dialog_rules import pcb_version_choice
class RestoreChoice:
def __init__(self, block, library, candidates):
self.block, self.library = block, library
self.candidates = tuple(dict(c) for c in candidates)
self.decision = None
self._lock = Lock()
def choose(self, kind):
if kind != 'cancel' and not any(c['kind'] == kind and c['enabled'] for c in self.candidates):
raise ValueError('Unknown or disabled PCB restoration version')
with self._lock:
if self.decision is None:
self.decision = kind
def _candidate_key(candidates):
return tuple((c['kind'], c['control_id'], c['label'], c['date'], c['enabled']) for c in candidates)
def _choice(snapshot):
choice = pcb_version_choice(snapshot)
buttons = [c for c in snapshot.controls if c.class_name == 'Button']
if (choice is None or any(c.control_id not in (6212, 6213, 6206, 1, 2) for c in buttons)
or len([c for c in buttons if c.control_id == 1 and c.enabled and c.name == 'OK']) != 1):
raise ValueError('PCB_VERSION_PROMPT_CHANGED')
return choice
class RestoreController:
def __init__(self, job):
from .post_repair_consent import _validate_grant
self.job = job
self.grant = _validate_grant(job)
self.prompt = None
self.original = None
self.selection_sent = self.confirm_sent = self.failed = False
self.sent_at = 0.0
def handle(self, snapshot, snapshots, *, target_pid, launcher_pid, worker_pid, companion_pids, show, perform):
from . import post_repair_consent as consent
from .dialog_supervisor import DialogPollResult
from .management import _write_json
try:
choice = _choice(snapshot)
if sum(c['selected'] for c in choice['candidates']) > 1:
raise ValueError('PCB_VERSION_SELECTION_AMBIGUOUS')
if self.failed or snapshot.pid != target_pid or len(snapshots) != 1:
raise ValueError('PCB_VERSION_OWNER_OR_WINDOW_UNCONFIRMED')
if self.original is not None and (snapshot.hwnd != self.original.hwnd
or snapshot.pid != self.original.pid
or _candidate_key(choice['candidates']) != _candidate_key(self.prompt.candidates)):
raise ValueError('PCB_VERSION_CANDIDATES_CHANGED')
pre = json.loads((Path(self.job['root'])/'post-repair-prelaunch.json').read_text(encoding='utf-8'))
if (pre.get('nonce') != self.grant['nonce'] or pre.get('desktop') != self.job['desktop']
or pre.get('worker_pid') != worker_pid or pre.get('supervisor_pid') != self.job['supervisor_pid']
or pre.get('addresses') != []
or not all(consent._same(pre[key], self.grant[key]) for key in ('project', 'pcb', 'library'))):
raise ValueError('PCB_VERSION_PRELAUNCH_PROOF_INVALID')
consent._validate_current_processes(self.job, pre, target_pid, launcher_pid, worker_pid, companion_pids)
if self.prompt is None:
self.original = snapshot
self.prompt = RestoreChoice(self.job['block_name'], self.job['lmc_file'], choice['candidates'])
show(self.prompt)
if self.prompt.decision is None:
return DialogPollResult(activity=True, observed_snapshots=tuple(snapshots))
if self.prompt.decision == 'cancel':
raise ValueError('用户取消 PCB 版本选择;未确认恢复,保留原生现场。')
selected = next(c for c in choice['candidates'] if c['kind'] == self.prompt.decision)
if not selected['enabled']:
raise ValueError('PCB_VERSION_DISABLED')
if self.confirm_sent:
if time.monotonic()-self.sent_at < 2:
return DialogPollResult(activity=False, observed_snapshots=tuple(snapshots))
raise ValueError('PCB_VERSION_CONFIRMATION_NOT_COMPLETED')
if self.selection_sent and not selected['selected']:
if time.monotonic()-self.sent_at < 2:
return DialogPollResult(activity=False, observed_snapshots=tuple(snapshots))
raise ValueError('PCB_VERSION_SELECTION_NOT_CONFIRMED')
confirming = selected['selected'] and sum(c['selected'] for c in choice['candidates']) == 1
control = 1 if confirming else selected['control_id']
action = {'action': 'user_selected_pcb_version', 'channels': ['win32_button_click'],
'target': {'control_id': control}, 'desktop': self.job['desktop'], 'pid': target_pid,
'choice': selected['kind'], 'candidates': list(self.prompt.candidates)}
self.selection_sent = True
self.confirm_sent = confirming
self.sent_at = time.monotonic()
record = {'project': self.job['project'], 'pcb': self.job['pcb'], 'choice': selected['kind'],
'date': selected['date'], 'historical_restore': True, 'confirm_sent': confirming,
'snapshot': snapshot.to_record()}
_write_json(Path(self.job['root'])/'pcb-version-user-choice.json', record)
result = perform(snapshot, action, snapshot.phase)
if result.error_code or result.accepted_controls != (control,):
self.failed = True
return DialogPollResult(error_code=result.error_code or 'PCB_VERSION_ACTION_FAILED', detail=result.detail,
snapshot=snapshot, observed_snapshots=tuple(snapshots))
if confirming:
_write_json(Path(self.job['root'])/'pcb-version-restoration.json', record)
return DialogPollResult(activity=True, action_sent=True, snapshot=snapshot,
action=action['action'], channel=result.channel, accepted_controls=result.accepted_controls,
rule_id='explicit-user-pcb-version', observed_snapshots=tuple(snapshots))
except Exception as error:
self.failed = True
return DialogPollResult(error_code='PCB_VERSION_CHOICE_REQUIRED', detail=str(error),
snapshot=snapshot, observed_snapshots=tuple(snapshots))
def validate_action_window(snapshot, action):
"""Recheck the exact live window and radio selection on the private desktop."""
import win32gui, win32process
from .native_repair_ui import _current_desktop_name
from .dialog_models import ControlSnapshot
if (not str(action.get('desktop', '')).startswith('CbbVerify_')
or _current_desktop_name() != action.get('desktop') or snapshot.pid != action.get('pid')
or win32process.GetWindowThreadProcessId(snapshot.hwnd)[1] != snapshot.pid
or win32gui.GetWindowText(snapshot.hwnd) != snapshot.title
or win32gui.GetClassName(snapshot.hwnd) != snapshot.window_class
or not win32gui.IsWindowVisible(snapshot.hwnd)):
raise ValueError('PCB_VERSION_LIVE_WINDOW_MISMATCH')
children = []
win32gui.EnumChildWindows(snapshot.hwnd, lambda h, _: children.append(int(h)), None)
live = []
for h in children:
control_id = win32gui.GetDlgCtrlID(h) & 0xFFFF
checked = False
if control_id in (6213, 6206):
value = win32gui.SendMessageTimeout(h, 0x00F0, 0, 0, 2, 1000)
checked = (value[-1] if isinstance(value, tuple) else value) == 1
live.append(ControlSnapshot(h, control_id, win32gui.GetClassName(h), win32gui.GetWindowText(h),
enabled=bool(win32gui.IsWindowEnabled(h)), checked=checked))
choice = _choice(replace(snapshot, controls=tuple(live)))
if _candidate_key(choice['candidates']) != _candidate_key(action.get('candidates', [])):
raise ValueError('PCB_VERSION_LIVE_CANDIDATES_CHANGED')
selected = next((c for c in choice['candidates'] if c['kind'] == action.get('choice') and c['enabled']), None)
control_id = action.get('target', {}).get('control_id')
if selected is None or control_id not in (selected['control_id'], 1):
raise ValueError('PCB_VERSION_ACTION_MISMATCH')
if control_id == 1 and (not selected['selected'] or sum(c['selected'] for c in choice['candidates']) != 1):
raise ValueError('PCB_VERSION_LIVE_SELECTION_MISMATCH')
target = next(c for c in live if c.control_id == control_id)
if target.handle != next(c.handle for c in snapshot.controls if c.control_id == control_id):
raise ValueError('PCB_VERSION_CONTROL_CHANGED')
@@ -0,0 +1,286 @@
"""One-use, local-only read/write consent after proven explicit native Repair.
No normal Verify or declarative rule can enable this path. Database recovery
choices other than the captured read/write question remain unsupported.
"""
from contextlib import ExitStack
from dataclasses import dataclass
import json
import os
from pathlib import Path
import stat
import time
from uuid import uuid4
PROMPT_TEXT = ("If an XDS or ExpeditionPCB is running on this design, it's likely that\n"
"your file system and/or network system was too slow to determine\n"
"which product the design is open in within the 15 second timeout\nperiod.\n\n"
"Otherwise, the design may not have been closed properly due to\n"
"the XDS or ExpeditionPCB crashing in the last session.\n\n"
"Before continuing, please confirm that no other users have the\ndesign open.\n\n"
"Continue to open the design with read/write access permission?")
def _drive_type(path):
import win32file
return win32file.GetDriveType(str(Path(path).anchor))
def require_local_fixed(path):
from .network_path import absolute_preserving_drive
path = absolute_preserving_drive(path)
if path.drive.startswith('\\') or _drive_type(path) != 3:
raise ValueError('LOCAL_FIXED_REQUIRED: 修复后读写确认仅支持本地固定磁盘;UNC/网络盘不自动授权')
for item in (path, *path.parents):
if item.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
raise ValueError('LOCAL_FIXED_REQUIRED: 不允许重解析点、目录链接或挂载路径')
return path
def _same(a, b):
return Path(a).resolve() == Path(b).resolve()
def _process_records():
import win32com.client
names = ('ExpeditionPCB.exe', 'LibraryManager.exe', 'viewdraw.exe', 'XDS.exe',
'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe', 'CleanWGLib.exe',
'cscript.exe', 'wscript.exe', 'python.exe', 'pythonw.exe', 'CbbRefreshVerify.exe')
service = win32com.client.GetObject('winmgmts:')
rows = service.ExecQuery('SELECT ProcessId, Name, ExecutablePath, CommandLine, ParentProcessId '
'FROM Win32_Process WHERE ' + ' OR '.join(f"Name='{n}'" for n in names))
records = []
for item in rows:
name, command = str(item.Name), str(item.CommandLine or '')
if name.casefold() in ('python.exe', 'pythonw.exe', 'cbbrefreshverify.exe') and command and not any(
flag in command for flag in ('--verify-worker', '--repair-worker', '--management-worker', '--dialog-agent')):
continue
records.append((int(item.ProcessId), name, str(item.ExecutablePath or ''), command, int(item.ParentProcessId or 0)))
return records
@dataclass(frozen=True)
class PostRepairProof:
library: str
project: str
pcb: str
block: str
repair_project: str
repair_database: str
repair_json: str
nonce: str
@classmethod
def create(cls, request, target, recovery):
from .native_repair import native_success_confirmed
from .verify_runner import preflight
if request.maintenance is not True or not native_success_confirmed(target, recovery):
raise ValueError('POST_REPAIR_PROOF_REQUIRED: 必须是明确维护且严格确认的原生修复')
if request.mapped_remote_root:
raise ValueError('LOCAL_FIXED_REQUIRED: 网络映射库不自动确认修复后的读写访问')
project, pcb = preflight(request)
for path in (request.lmc_file, project, pcb, target.database/'icdb.dat', pcb.parent/'Layout/LayoutDB.lyt'):
require_local_fixed(path)
return cls(str(request.lmc_file), str(project), str(pcb), request.block_name,
str(target.project), str(target.database), json.dumps(recovery, ensure_ascii=False, default=str), uuid4().hex)
def for_job(self, job):
if (job.get('interactive_input') or job.get('native_lm_verify')
or not str(job.get('desktop', '')).startswith('CbbVerify_')
or job['block_name'] != self.block
or not all(_same(job[key], value) for key, value in (
('lmc_file', self.library), ('project', self.project), ('pcb', self.pcb)))):
raise ValueError('POST_REPAIR_TARGET_MISMATCH')
return {'nonce': self.nonce, 'intent': 'explicit_maintenance_after_confirmed_repair',
'library': self.library, 'project': self.project, 'pcb': self.pcb, 'block': self.block,
'repair_project': self.repair_project, 'repair_database': self.repair_database,
'repair': json.loads(self.repair_json), 'desktop': job['desktop'], 'root': job['root']}
def _validate_grant(job):
from .native_repair import RepairTarget, native_success_confirmed
grant = job.get('post_repair_consent')
if (not isinstance(grant, dict) or grant.get('intent') != 'explicit_maintenance_after_confirmed_repair'
or not isinstance(grant.get('nonce'), str) or len(grant['nonce']) != 32
or job.get('interactive_input') or job.get('native_lm_verify') or job.get('mapped_remote_root')
or grant.get('desktop') != job.get('desktop') or not str(job.get('desktop', '')).startswith('CbbVerify_')
or not _same(grant['root'], job['root']) or grant.get('block') != job.get('block_name')
or not all(_same(grant[key], job[field]) for key, field in (
('library', 'lmc_file'), ('project', 'project'), ('pcb', 'pcb')))):
raise ValueError('POST_REPAIR_PROOF_INVALID')
target = RepairTarget(Path(grant['repair_project']), Path(grant['repair_database']))
if not native_success_confirmed(target, grant['repair']):
raise ValueError('POST_REPAIR_PROOF_INVALID: 原生成功证据不完整')
return grant
def prepare_launch(job, command):
"""Called on the private worker immediately before direct PCB launch."""
import win32file, win32con
from .icdb_ownership import database_directories, unreleased_addresses
from .management import _write_json
grant = _validate_grant(job)
from .native_repair_ui import _current_desktop_name
if _current_desktop_name() != job['desktop']:
raise ValueError('POST_REPAIR_PRIVATE_DESKTOP_REQUIRED')
library, project, pcb = (Path(job[key]) for key in ('lmc_file', 'project', 'pcb'))
from .maintenance_entry import maintenance_project_files
for path in (library, pcb, *maintenance_project_files(project, pcb)):
require_local_fixed(path)
if len(command) != 3 or not _same(command[1], pcb) or command[2] != '-ReusableCircuit':
raise ValueError('POST_REPAIR_LAUNCH_MISMATCH')
def require_idle():
# Self is an expected automation worker, never a native owner.
others = [r for r in _process_records() if r[0] not in (os.getpid(), int(job['supervisor_pid']))
and not (r[1].casefold() in ('python.exe', 'pythonw.exe', 'cbbrefreshverify.exe')
and '--dialog-agent' in r[3] and r[4] == int(job['supervisor_pid']))]
if others: raise ValueError('POST_REPAIR_FOREIGN_OWNER: 存在其他原生进程或助手')
require_idle()
if unreleased_addresses(library, project, pcb): raise ValueError('POST_REPAIR_ADDRESS_REMAINS')
files = [library, pcb.parent/'Layout/LayoutDB.lyt']
files.extend(folder/'icdb.dat' for folder in database_directories(library, project, pcb) if (folder/'icdb.dat').is_file())
with ExitStack() as stack:
for path in dict.fromkeys(files):
require_local_fixed(path)
try:
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
except Exception as error:
raise ValueError(f'POST_REPAIR_EXCLUSIVE_ACCESS_REQUIRED: {path}: {error}') from error
stack.callback(handle.Close)
if unreleased_addresses(library, project, pcb): raise ValueError('POST_REPAIR_ADDRESS_CHANGED')
require_idle()
_write_json(Path(job['root'])/'post-repair-prelaunch.json', {
'nonce': grant['nonce'], 'desktop': job['desktop'], 'project': str(project), 'pcb': str(pcb),
'library': str(library), 'worker_pid': os.getpid(), 'supervisor_pid': job['supervisor_pid'],
'command': list(command), 'exclusive_files': [str(path) for path in dict.fromkeys(files)],
'addresses': [], 'monotonic': time.monotonic()})
def exact_prompt(snapshot):
from .dialog_models import DialogPhase
if (snapshot.phase != DialogPhase.PCB_STARTING or snapshot.process_name.casefold() != 'expeditionpcb.exe'
or snapshot.process_role != 'pcb' or snapshot.window_class != '#32770' or snapshot.title != 'Expedition PCB'):
return False
controls = []
for control in snapshot.controls:
self_window = (control.handle == snapshot.hwnd and control.control_id == 0
and control.class_name == snapshot.window_class and control.name == snapshot.title
and control.control_type == 'Window' and control.patterns == ('Window',))
uia_chrome = (control.handle == 0 and control.control_id == 0
and control.class_name == '' and control.automation_id == ''
and not control.selected and not control.checked and (
control.control_type == 'TitleBar' and control.name == '' and control.patterns == ('Value',)
or control.control_type == 'Button' and not control.enabled
and control.name in ('关闭', 'Close') and control.patterns == ('Invoke',)))
if not self_window and not uia_chrome:
controls.append(control)
buttons = [c for c in controls if c.class_name == 'Button']
static = [c for c in controls if c.class_name == 'Static' and c.name.strip()]
return (len(buttons) == 2 and {c.control_id for c in buttons} == {6, 7}
and all(c.enabled for c in buttons) and len(static) == 1 and static[0].control_id == 65535
and ' '.join(static[0].name.split()) == ' '.join(PROMPT_TEXT.split())
and all(c.class_name == 'Button' or c.class_name == 'Static' and c.control_id in (20, 65535)
for c in controls))
def _validate_current_processes(job, prelaunch, target_pid, launcher_pid, worker_pid, companion_pids):
from .mentor_adapter import is_reusable_circuit_pcb
rows = _process_records()
by_pid = {r[0]: r for r in rows}
if target_pid not in by_pid or launcher_pid not in by_pid:
raise ValueError('POST_REPAIR_PROCESS_UNCONFIRMED')
target, launcher = by_pid[target_pid], by_pid[launcher_pid]
executable = Path(prelaunch['command'][0])
expected_worker = executable.parents[3]/'wg/win32/bin/ExpeditionPCB.exe'
if (not _same(launcher[2], executable) or not _same(target[2], expected_worker)
or launcher[4] != worker_pid or target[4] != launcher_pid
or not is_reusable_circuit_pcb(target[2], target[3], job['pcb'])
or not is_reusable_circuit_pcb(launcher[2], launcher[3], job['pcb'])):
raise ValueError('POST_REPAIR_PROCESS_IDENTITY_MISMATCH')
allowed = {target_pid, launcher_pid, worker_pid, int(job['supervisor_pid']), *companion_pids}
foreign = [r for r in rows if r[0] not in allowed]
if foreign:
from .management import _write_json
_write_json(Path(job['root'])/'foreign-owners.json', {'allowed_pids': sorted(allowed),
'observed': [{'pid': r[0], 'name': r[1], 'executable': r[2], 'command': r[3], 'parent_pid': r[4]}
for r in foreign]})
raise ValueError(f'POST_REPAIR_FOREIGN_OWNER: {[(r[0], r[1]) for r in foreign]}')
class ConsentController:
def __init__(self, proof, job):
if not isinstance(proof, PostRepairProof): raise ValueError('POST_REPAIR_PROOF_REQUIRED')
self.grant = proof.for_job(job)
self.job = json.loads(json.dumps(job))
self.used = False
self.snapshot = None
self.sent_at = 0.0
def handle(self, snapshot, snapshots, *, target_pid, launcher_pid, worker_pid, companion_pids, perform):
from .dialog_supervisor import DialogPollResult
from .management import _write_json
try:
if not exact_prompt(snapshot) or snapshot.pid != target_pid:
raise ValueError('POST_REPAIR_PROMPT_MISMATCH')
if len(snapshots) != 1:
raise ValueError('POST_REPAIR_ADDITIONAL_DIALOG')
if self.used:
if (self.snapshot.hwnd == snapshot.hwnd and self.snapshot.signature == snapshot.signature
and time.monotonic() - self.sent_at < 2):
return DialogPollResult(activity=False, observed_snapshots=tuple(snapshots))
raise ValueError('POST_REPAIR_CONSENT_ALREADY_USED')
pre = json.loads((Path(self.job['root'])/'post-repair-prelaunch.json').read_text(encoding='utf-8'))
required = {Path(self.grant['library']).resolve(),
(Path(self.grant['pcb']).parent/'Layout/LayoutDB.lyt').resolve(),
(Path(self.grant['repair_database'])/'icdb.dat').resolve()}
if (pre.get('nonce') != self.grant['nonce'] or pre.get('desktop') != self.job['desktop']
or pre.get('worker_pid') != worker_pid or pre.get('addresses') != []
or pre.get('supervisor_pid') != self.job['supervisor_pid']
or not required.issubset({Path(p).resolve() for p in pre.get('exclusive_files', [])})
or not 0 <= time.monotonic() - pre.get('monotonic', 0) <= 180
or not all(_same(pre[key], self.grant[key]) for key in ('project', 'pcb', 'library'))):
raise ValueError('POST_REPAIR_PRELAUNCH_PROOF_INVALID')
for path in (self.grant['library'], self.grant['project'], self.grant['pcb']): require_local_fixed(path)
_validate_current_processes(self.job, pre, target_pid, launcher_pid, worker_pid, companion_pids)
payload = {'action': 'post_repair_local_read_write', 'channels': ['win32_button_click'],
'target': {'control_id': 6}, 'postcondition': 'window_gone',
'desktop': self.job['desktop'], 'pid': target_pid}
# Consume before messaging: failure/timeout cannot authorize another click.
self.used = True; self.snapshot = snapshot; self.sent_at = time.monotonic()
_write_json(Path(self.job['root'])/'post-repair-consent.json', {
'nonce': self.grant['nonce'], 'consumed': True, 'target_pid': target_pid,
'launcher_pid': launcher_pid, 'worker_pid': worker_pid, 'snapshot': snapshot.to_record()})
result = perform(snapshot, payload, snapshot.phase)
return DialogPollResult(activity=True, action_sent=bool(result.accepted_controls), snapshot=snapshot,
error_code=result.error_code, detail=result.detail, accepted_controls=result.accepted_controls,
action=payload['action'], channel=result.channel, rule_id='explicit-local-post-repair-consent',
observed_snapshots=tuple(snapshots))
except Exception as error:
return DialogPollResult(error_code='DATABASE_RECOVERY_REQUIRED', detail=str(error),
snapshot=snapshot, observed_snapshots=tuple(snapshots))
def validate_action_window(snapshot, action):
"""Final check on the agent's actual private desktop, immediately before Yes."""
import win32gui, win32process
from .native_repair_ui import _current_desktop_name
from .dialog_models import ControlSnapshot
if (not exact_prompt(snapshot) or snapshot.pid != action.get('pid')
or _current_desktop_name() != action.get('desktop')
or not str(action.get('desktop', '')).startswith('CbbVerify_')
or win32process.GetWindowThreadProcessId(snapshot.hwnd)[1] != snapshot.pid
or win32gui.GetClassName(snapshot.hwnd) != snapshot.window_class
or win32gui.GetWindowText(snapshot.hwnd) != snapshot.title or not win32gui.IsWindowVisible(snapshot.hwnd)):
raise ValueError('POST_REPAIR_LIVE_WINDOW_MISMATCH')
children = []
win32gui.EnumChildWindows(snapshot.hwnd, lambda hwnd, _: children.append(int(hwnd)), None)
live = tuple(ControlSnapshot(hwnd, win32gui.GetDlgCtrlID(hwnd) & 0xFFFF,
win32gui.GetClassName(hwnd), win32gui.GetWindowText(hwnd), enabled=bool(win32gui.IsWindowEnabled(hwnd)))
for hwnd in children)
from dataclasses import replace
if not exact_prompt(replace(snapshot, controls=live)):
raise ValueError('POST_REPAIR_LIVE_PROMPT_CHANGED')
yes = next(c for c in live if c.control_id == 6)
if yes.handle != next(c.handle for c in snapshot.controls if c.control_id == 6):
raise ValueError('POST_REPAIR_BUTTON_CHANGED')
@@ -0,0 +1,75 @@
"""Explicit copy-based recovery after failed maintenance; never auto-replay."""
from dataclasses import asdict
from pathlib import Path
from uuid import uuid4
def offers_reimport(result):
return (result.status == 'FAIL' and result.evidence_path is not None
and any(attempt.get('status') in {
'REPAIR_VALIDATION_FAILED', 'MISSING_HEALTHY_BACKUP', 'NATIVE_REPAIR_FAILED'}
for attempt in result.recovery_attempts))
def run_reimport_recovery(requests, *, previous_evidence, evidence_dir,
adapter=None, stop=None, progress=None):
from .management import ManagementResult, _write_json, source_project, run_management_batch
from .library_lock import release_retained_library
requests = tuple(requests)
if not requests or stop is not None and stop.is_set():
return []
library = requests[0].library.resolve()
evidence_dir = Path(evidence_dir).resolve()
if evidence_dir.is_relative_to(library.parent) or library.parent.is_relative_to(evidence_dir):
raise ValueError('恢复记录必须位于目标库之外。')
root = evidence_dir/('reimport-' + uuid4().hex)
root.mkdir(parents=True)
report = root/'recovery.json'
record = {'library': str(library), 'previous_evidence': previous_evidence,
'requests': [asdict(r) for r in requests], 'original_repair_succeeded': False}
stage = 'preflight'
def save(stage, **extra):
record.update(stage=stage, **extra)
_write_json(report, record)
def cancelled():
if stop is not None and stop.is_set():
save('cancelled', management_started=False)
return True
return False
try:
save(stage, management_started=False)
for request in requests:
if (request.operation != 'update' or request.library.resolve() != library
or not previous_evidence.get(request.name)):
raise ValueError('恢复目标与原失败项不一致。')
source, _, _ = source_project(request.source, request.top_level_block)
if (source.parent.is_relative_to(library.parent)
or library.parent.is_relative_to(source.parent)):
raise ValueError('请选择目标中心库之外的完整工程副本。')
if cancelled(): return []
stage = 'release_check'
save(stage)
if progress: progress({'stage': stage, 'detail': '正在检查原生会话释放,尚未替换条目'})
import inspect
block_name = requests[0].name if len(requests) == 1 else None
if 'block_name' in inspect.signature(release_retained_library).parameters:
proof = release_retained_library(library, root/'release', block_name=block_name)
else:
proof = release_retained_library(library, root/'release')
if proof.get('status') != 'RELEASE_CONFIRMED':
raise ValueError('原生会话释放未确认,未开始导入。')
save('released', release=proof)
if cancelled(): return []
stage = 'management'
save(stage, management_started=True)
results = run_management_batch(requests, adapter=adapter, stop=stop, progress=progress)
save('complete', results=[asdict(result) for result in results],
version_review_required=True)
return results
except Exception as error:
save('release_failed' if stage == 'release_check' else 'failed', detail=str(error))
guidance = ('请正常关闭提示中的原生程序;若提示数据库地址记录,请先对对应工程执行 ICDB 维护,再重试副本恢复。'
if stage == 'release_check' else '')
return [ManagementResult(r.operation, r.library, r.name, r.partition, r.source,
r.auto_verify, stage, 'BLOCKED' if stage != 'management' else 'RECOVERY_REQUIRED',
False, f'副本恢复未完成:{error}。{guidance}原修复失败记录仍保留。', report) for r in requests]
+5
View File
@@ -58,6 +58,11 @@ class RunTimings:
elif stage == 'identity_verified':
self.end('pcb_startup', now)
self.begin('integration', now)
elif stage == 'diagnostic_native_loaded_candidate':
self.end('pcb_startup', now)
self.begin('diagnostic_close', now)
elif stage == 'diagnostic_complete':
self.end('diagnostic_close', now)
elif stage == 'integration_action':
key = ACTION_KEYS.get(event.get('action'))
if key:
+31 -1
View File
@@ -1,12 +1,16 @@
Option Explicit
Dim app, doc, pi, licensing, token, expected, attempt, stable, measuredStart, operationOK
Dim app, doc, pi, licensing, token, expected, attempt, stable, measuredStart, operationOK, remaining
expected = WScript.Arguments(0)
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,15 +46,39 @@ 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
If Not operationOK Then WScript.Quit 6
WScript.Echo "CLOSE_OK"
Set pi = Nothing
Set doc = Nothing
Set licensing = Nothing
Set remaining = app.ActiveDocument
If Not remaining Is Nothing Then
Set remaining = Nothing
WScript.Echo "APP_RETAINED_OTHER_DOCUMENT"
WScript.Quit 10
End If
Set remaining = Nothing
measuredStart = Timer
app.Quit
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
+413
View File
@@ -0,0 +1,413 @@
"""Complete, metadata-verified snapshots with scoped semantic SHA256 manifests.
Unknown engineering files are primary. Only explicit runtime, history and
generated categories are ignored by semantic comparisons; they are still copied
and their membership/size/mtime must remain stable throughout the snapshot.
"""
from concurrent.futures import ThreadPoolExecutor
from contextlib import ExitStack
from dataclasses import asdict, dataclass
import hashlib
import os
from pathlib import Path
import shutil
import stat
MANIFEST_VERSION = 1
MANIFEST_RULE_VERSION = 1
_ROOT_RUNTIME_PREFIX = 'work.before-restore-'
_ROOT_RUNTIME_PATH = ('projectbackup', 'backups')
_NATIVE_RUNTIME_DIRECTORIES = ('log', 'dbcheck', 'dbrestore')
_NATIVE_SERVER_DIRECTORY = 'cdbsvr'
_PROJECT_PCB_DIRECTORY = 'pcb'
_PROJECT_DATABASE_PREFIXES = (('database',), (_PROJECT_PCB_DIRECTORY, 'database'))
_NONPRIMARY_FILENAMES = ('saddress.adr',)
_NONPRIMARY_FILENAME_PREFIXES = ('~$',)
_NONPRIMARY_DIRECTORIES = frozenset({
'log', 'logs', 'temp', 'tmp', '__pycache__', 'backup', 'backups',
'output', 'outputs', 'report', 'reports', 'gerber', 'gerbers', 'odb++',
'log files', 'logfiles',
})
_NONPRIMARY_SUFFIXES = frozenset({
'.log', '.tmp', '.temp', '.lck', '.lock', '.bak', '.backup', '.pdf',
})
def _root_runtime(directories):
"""Known runtime/history children of a library or project workspace root."""
return bool(directories and (
directories[0] in _NONPRIMARY_DIRECTORIES
or directories[0].startswith(_ROOT_RUNTIME_PREFIX)
or directories[:len(_ROOT_RUNTIME_PATH)] == _ROOT_RUNTIME_PATH))
def _native_runtime(directories, database_prefix):
runtime_prefix = database_prefix + (_NATIVE_SERVER_DIRECTORY,)
return (directories[:len(runtime_prefix)] == runtime_prefix
and len(directories) > len(runtime_prefix)
and directories[len(runtime_prefix)] in _NATIVE_RUNTIME_DIRECTORIES)
def _project_runtime(directories):
return (_root_runtime(directories)
or (directories[:1] == (_PROJECT_PCB_DIRECTORY,) and _root_runtime(directories[1:]))
or any(_native_runtime(directories, prefix) for prefix in _PROJECT_DATABASE_PREFIXES))
@dataclass(frozen=True)
class ManifestScope:
"""Project root by default; library selects one CBB and shared dependencies."""
kind: str = 'project'
block_name: str = ''
library_name: str = ''
def __post_init__(self):
if self.kind not in ('project', 'library'):
raise ValueError('Unknown manifest scope')
if self.kind == 'library':
for value in (self.block_name, self.library_name):
if not value or value in ('.', '..') or any(c in value for c in '/\\:'):
raise ValueError('Library scope requires single-component block/library names')
@classmethod
def library(cls, block_name, library_name):
return cls('library', block_name, library_name)
def includes_directory(self, relative):
parts = tuple(part.casefold() for part in Path(relative).parts)
if self._runtime_path(parts, directory=True):
return False
if self.kind == 'project' or not parts or parts[0] != 'reusableblockslp':
return True
return ((len(parts) < 2 or parts[1] == self.block_name.casefold())
and (len(parts) < 3 or parts[2] in ('work', 'cert')))
def _runtime_path(self, parts, *, directory=False):
"""Recognize runtime locations only in their structural context.
Generic names such as ``Logs`` are runtime when they are a project-root
or selected Work/Cert child. The same name deeper in an engineering
partition (or in shared SymbolLibs data) remains primary.
"""
directories = parts if directory else parts[:-1]
if not directory and (Path(parts[-1]).suffix in _NONPRIMARY_SUFFIXES
or parts[-1] in _NONPRIMARY_FILENAMES
or parts[-1].startswith(_NONPRIMARY_FILENAME_PREFIXES)):
return True
if self.kind == 'project':
return _project_runtime(directories)
if directories[:1] == ('reusableblockslp',):
# Identity and Work/Cert role components never act as runtime names.
if (len(directories) >= 3 and directories[1] == self.block_name.casefold()
and directories[2] in ('work', 'cert')):
return _project_runtime(directories[3:])
return False
if _root_runtime(directories):
return True
# Shared dependency names/partitions are engineering data. Only native
# server runtime subtrees within known DB positions are excluded.
if directories[:1] == ('symbollibs',) and len(directories) >= 2:
return _native_runtime(directories, directories[:2])
return bool(directories and _native_runtime(directories, directories[:1]))
def classify(self, relative):
"""Return a semantic scope label or None; paths are relative to the root."""
parts = tuple(part.casefold() for part in Path(relative).parts)
if self._runtime_path(parts):
return None
if self.kind == 'project':
return 'project'
if parts[0] == 'reusableblockslp':
if len(parts) < 4 or parts[1] != self.block_name.casefold():
return None
return {'work': 'target_work', 'cert': 'target_cert'}.get(parts[2])
if len(parts) == 1:
if Path(parts[0]).suffix == '.lmc' and parts[0] != self.library_name.casefold():
return None
return 'library_config'
# Shared DB/config/dependency trees are conservative: new dependency
# directory names remain primary without adding them to an allowlist.
return 'shared_dependency'
def comparison_rules(scope):
"""Describe semantic exclusions using the classifier's rule constants."""
project_positions = ['project root or its PCB child']
project_native = ' or '.join('/'.join(prefix + (_NATIVE_SERVER_DIRECTORY,))
for prefix in _PROJECT_DATABASE_PREFIXES)
native_positions = [project_native + ' under project root']
if scope.kind == 'library':
project_positions = ['library root', 'selected CBB Work/Cert root or its PCB child']
native_positions = [
project_native + ' under selected CBB Work/Cert',
'SymbolLibs/<partition>/' + _NATIVE_SERVER_DIRECTORY,
'<shared dependency>/' + _NATIVE_SERVER_DIRECTORY,
]
return {
'rule_version': MANIFEST_RULE_VERSION,
'excluded_categories': sorted(_NONPRIMARY_DIRECTORIES),
'excluded_suffixes': sorted(_NONPRIMARY_SUFFIXES),
'runtime_exclusions': {
'directory_name_positions': project_positions,
'directory_prefixes': [_ROOT_RUNTIME_PREFIX],
'relative_directories': ['/'.join(_ROOT_RUNTIME_PATH)],
'native_directory_names': sorted(_NATIVE_RUNTIME_DIRECTORIES),
'native_directory_positions': native_positions,
'file_names': list(_NONPRIMARY_FILENAMES),
'file_name_prefixes': list(_NONPRIMARY_FILENAME_PREFIXES),
'coordination_checkpoints': 'recognized CBB coordination checkpoints',
},
}
def hash_file(path):
digest = hashlib.sha256()
with Path(path).open('rb') as stream:
for data in iter(lambda: stream.read(1024 * 1024), b''):
digest.update(data)
return digest.hexdigest()
def _coordination_checkpoint(path):
from .library_lock import checkpoint_record
return checkpoint_record(path) is not None
def scan_tree(root, *, scope=None, exclude=None, check=None):
"""Refuse links/special files; optionally prune trees outside semantic scope.
Copies always call this without a scope, validating complete membership.
Later semantic scans avoid entering runtime or unrelated CBB directories.
"""
root = Path(root)
if root.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
raise ValueError(f'不支持通过目录链接恢复:{root}')
entries = {}
folders = [root]
while folders:
if check is not None: check()
with os.scandir(folders.pop()) as scanned:
for entry in scanned:
if check is not None: check()
path = Path(entry.path)
if exclude is not None and path.is_relative_to(exclude):
continue
if scope is not None:
relative = path.relative_to(root)
if entry.is_dir(follow_symlinks=False):
if not scope.includes_directory(relative):
continue
elif scope.classify(relative) is None or _coordination_checkpoint(path):
continue
metadata = entry.stat(follow_symlinks=False)
if metadata.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
raise ValueError(f'目录含文件或目录链接,停止恢复:{entry.path}')
if not (stat.S_ISDIR(metadata.st_mode) or stat.S_ISREG(metadata.st_mode)):
raise ValueError(f'不支持的特殊文件:{entry.path}')
entries[path] = metadata
if stat.S_ISDIR(metadata.st_mode):
folders.append(path)
return dict(sorted(entries.items()))
def _metadata_record(root, entries):
return {path.relative_to(root).as_posix():
('file', info.st_size, info.st_mtime_ns) if stat.S_ISREG(info.st_mode) else ('dir',)
for path, info in entries.items()}
def _manifest(scope, files):
return {'version': MANIFEST_VERSION, 'scope': asdict(scope), 'files': dict(sorted(files.items()))}
def _emit(progress, stage, hashed_files, hashed_bytes, **extra):
if progress:
progress({'stage': stage, 'hashed_files': hashed_files, 'hashed_bytes': hashed_bytes, **extra})
def build_manifest(root, *, scope=None, exclude=None, progress=None, hash_function=hash_file):
"""Hash primary files only. Excluded subtrees are for private incoming Work.
The returned dict is versioned, JSON-compatible and relocatable. Equality
compares primary path membership, size, hash and scope, never runtime mtimes.
"""
root = Path(root)
scope = scope or ManifestScope()
entries = scan_tree(root, scope=scope, exclude=exclude)
selected = {path: scope.classify(path.relative_to(root)) for path, info in entries.items()
if stat.S_ISREG(info.st_mode)}
selected = {path: label for path, label in selected.items() if label is not None}
def hashed(path):
digest = hash_function(path)
after = path.stat()
before = entries[path]
if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns):
raise OSError(f'计算哈希期间文件变化:{path}')
return path.relative_to(root).as_posix(), {
'size': before.st_size, 'sha256': digest, 'scope': selected[path]}
files = {}
hashed_bytes = 0
_emit(progress, 'hash', 0, 0, total_files=len(selected))
with ThreadPoolExecutor(max_workers=8) as pool:
for count, (relative, item) in enumerate(pool.map(hashed, selected), 1):
files[relative] = item
hashed_bytes += item['size']
if count % 256 == 0 or count == len(selected):
_emit(progress, 'hash', count, hashed_bytes, total_files=len(selected))
# Check primary membership and metadata again after every hash completed.
# Runtime files can change/add/disappear without a semantic conflict.
after = scan_tree(root, scope=scope, exclude=exclude)
before_primary = {p: entries[p] for p in selected}
after_primary = {p: info for p, info in after.items() if stat.S_ISREG(info.st_mode)
and (exclude is None or not p.is_relative_to(exclude))
and scope.classify(p.relative_to(root)) is not None}
if _metadata_record(root, before_primary) != _metadata_record(root, after_primary):
raise OSError(f'计算哈希期间主要文件变化:{root}')
return _manifest(scope, files)
def build_exclusive_library_manifest(root, *, scope, progress=None):
"""Check every native database is idle while hashing, without making a copy."""
import win32con, win32file, pywintypes
root = Path(root)
entries = scan_tree(root) # Preserve full-library link and ownership checks.
with ExitStack() as stack:
handles = {}
for path, metadata in entries.items():
if stat.S_ISREG(metadata.st_mode) and (path.suffix.casefold() == '.lmc'
or path.name.casefold() == 'icdb.dat'):
try:
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
except pywintypes.error as error:
raise OSError(f'LIBRARY_DATABASE_IN_USE: 无法独占读取 {path}:{error}') from error
handles[path] = handle
stack.callback(handle.Close)
def digest(path):
if path not in handles:
return hash_file(path)
value = hashlib.sha256()
while True:
try:
_, data = win32file.ReadFile(handles[path], 1024 * 1024)
except pywintypes.error as error:
if error.winerror == 38: # ERROR_HANDLE_EOF
break
raise
if not data:
break
value.update(data)
return value.hexdigest()
return build_manifest(root, scope=scope, progress=progress, hash_function=digest)
def copy_verified(source, destination, *, scope=None, progress=None, hash_function=hash_file):
"""Copy the whole tree, validate all metadata, SHA256 only scoped primary files.
Native icdb.dat/LMC files are held with exclusive read handles for the copy.
Their expected SHA256 comes from the source read stream, independently of
hashing destination bytes. Unlocked primary files are also hashed while
streaming the copy, then rehashed at source to detect even same-size/mtime
edits. Every primary destination is independently hashed. Failures retain
the partial destination evidence.
Progress receives one dict with stage, hashed_files/bytes and copied_files.
"""
import win32con
import win32file
source, destination = Path(source), Path(destination)
scope = scope or ManifestScope()
if destination.resolve().is_relative_to(source.resolve()):
raise ValueError('复制目标不能位于源目录内。')
entries = scan_tree(source)
expected_metadata = _metadata_record(source, entries)
destination.mkdir(parents=True, exist_ok=False)
files = [path for path, info in entries.items() if stat.S_ISREG(info.st_mode)]
from .library_lock import owned_snapshot
# Resolve ownership on the operation thread, before parallel copy workers.
owned = {path: data for path in files
if path.name.endswith('.cbb-upload.lock')
and (data := owned_snapshot(path)) is not None}
record = {}
hashed_count = hashed_bytes = 0
_emit(progress, 'copy', 0, 0, copied_files=0, total_files=len(files))
with ExitStack() as stack:
locks = {}
for path in files:
if 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
for path, info in entries.items():
if stat.S_ISDIR(info.st_mode):
(destination/path.relative_to(source)).mkdir(parents=True, exist_ok=True)
def copy_file(path):
relative = path.relative_to(source)
copied = destination/relative
copied.parent.mkdir(parents=True, exist_ok=True)
label = None if _coordination_checkpoint(path) else scope.classify(relative)
digest = None
if path in owned:
copied.write_bytes(owned[path])
shutil.copystat(path, copied)
if label is not None:
digest = hashlib.sha256(owned[path]).hexdigest()
elif path in locks:
stream_hash = hashlib.sha256() if label is not None else None
with copied.open('wb') as stream:
while True:
_, data = win32file.ReadFile(locks[path], 1024 * 1024)
if not data:
break
if stream_hash is not None:
stream_hash.update(data)
stream.write(data)
shutil.copystat(path, copied)
if stream_hash is not None:
digest = stream_hash.hexdigest()
elif label is not None:
stream_hash = hashlib.sha256()
with path.open('rb') as incoming, copied.open('wb') as outgoing:
for data in iter(lambda: incoming.read(1024 * 1024), b''):
stream_hash.update(data)
outgoing.write(data)
shutil.copystat(path, copied)
digest = stream_hash.hexdigest()
else:
shutil.copy2(path, copied)
before, after = entries[path], path.stat()
if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns):
raise OSError(f'复制期间文件变化:{path}')
return relative.as_posix(), digest, label
with ThreadPoolExecutor(max_workers=8) as pool:
for count, (relative, digest, label) in enumerate(pool.map(copy_file, files), 1):
if label is not None:
size = entries[source/relative].st_size
record[relative] = {'size': size, 'sha256': digest, 'scope': label}
hashed_count += 1
hashed_bytes += size
if count % 256 == 0 or count == len(files):
_emit(progress, 'copy', hashed_count, hashed_bytes,
copied_files=count, total_files=len(files))
def validate_bytes(relative):
item = record[relative]
path = source/relative
if path not in locks and hash_function(path) != item['sha256']:
raise OSError(f'复制期间主要文件内容变化:{path}')
if hash_function(destination/relative) != item['sha256']:
raise OSError(f'复制内容校验失败:{path}')
with ThreadPoolExecutor(max_workers=8) as pool:
list(pool.map(validate_bytes, record))
if _metadata_record(source, scan_tree(source)) != expected_metadata:
raise OSError(f'复制期间目录内容变化:{source}')
if _metadata_record(destination, scan_tree(destination)) != expected_metadata:
raise OSError(f'复制目标目录或文件元数据不一致:{destination}')
return _manifest(scope, record)
+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,5 @@
"""Shared wording for user-managed backups before write operations."""
MANUAL_BACKUP_NOTICE = (
'应用不会自动备份。请先手动备份中心库及相关工程,并确认备份可用于恢复。'
)
@@ -0,0 +1,157 @@
"""Small, asynchronous entry point for recovery from a healthy CBB project."""
from pathlib import Path
from threading import Event
from PySide6.QtCore import QObject, QThreadPool, Signal
from PySide6.QtWidgets import (QComboBox, QDialog, QFileDialog, QFormLayout,
QHBoxLayout, QLabel, QLineEdit, QPushButton, QMessageBox)
from .workers import ServiceWorker
from .backup_notice import MANUAL_BACKUP_NOTICE
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.native_queue = None
self.stop = Event()
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.cancel_queue_button = QPushButton('取消排队')
self.cancel_queue_button.setEnabled(False)
self.cancel_queue_button.clicked.connect(self.stop.set)
self.status_label = QLabel(MANUAL_BACKUP_NOTICE + ' 所选备份先在隔离库中验证;安装时旧 Work 仅改名保留。')
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.cancel_queue_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
if QMessageBox.question(self, '确认从备份恢复',
f'{MANUAL_BACKUP_NOTICE}\n\n目标库:{request.lmc_file}\nCBB:{name}\n来源:{source}'
'\n\n将创建用于校验的隔离库副本,校验通过后替换目标工程。确认继续?',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No) != QMessageBox.Yes:
return
self.busy = True
self.stop.clear()
self._set_enabled(False)
self.status_label.setText('正在准备恢复…')
self.started.emit(name)
def execute():
action = lambda: recoverer(request, source, progress=self.signals.progress.emit)
if self.native_queue is None: return action()
from ..operation_queue import QueueCancelled
def restore():
self.signals.progress.emit({'stage': 'queue_acquired'})
return action()
try:
return self.native_queue.run(restore, stop=self.stop, waiting=lambda: self.signals.progress.emit(
{'stage': 'waiting_native_slot', 'detail': '已排队,等待当前检查结束'}))
except QueueCancelled as error:
from ..verify_runner import VerifyResult
return VerifyResult('CANCELLED', stderr=str(error))
self.worker = ServiceWorker(execute)
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):
if event.get('stage') in ('waiting_native_slot', 'queue_acquired'):
self.cancel_queue_button.setEnabled(event['stage'] == 'waiting_native_slot')
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.cancel_queue_button.setEnabled(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)
@@ -0,0 +1,115 @@
"""A check batch owns its snapshot and yields the native queue after each CBB."""
from threading import Event
from PySide6.QtCore import QObject, QThreadPool, Signal
from .workers import ServiceWorker
from ..operation_queue import QueueCancelled
from ..verify_runner import VerifyResult, run_verify, write_batch_report
from ..icdb_maintenance import write_maintenance_report
class IcdbCheckTask(QObject):
event = Signal(object)
item_done = Signal(str, object)
finished = Signal(object)
def __init__(self, requests, queue, report_root, *, verifier=None, path_lease=None, parent=None):
super().__init__(parent)
self.requests = tuple(requests)
self.queue, self.report_root = queue, report_root
self.path_lease = path_lease
self.verifier = verifier or (lambda req: run_verify(req, progress=self.event.emit, stop=self.stop))
self.results = []
self.stop = Event()
self.active = False
self.paused = False
self.invalidated = set()
self.ready_names = set()
self.running = False
self.report = None
self.report_error = ''
self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1)
def start(self):
self.active = True
self._next()
def cancel(self):
self.stop.set(); self.queue.wake()
if not self.running and self.active: self._next()
def pause(self):
self.paused = True
def invalidate(self, names):
self.invalidated.update(names)
def update_statuses(self, statuses):
self.ready_names = (self.ready_names - statuses.keys()) | {
name for name, status in statuses.items() if status == 'READY'}
def resume(self):
self.paused = False; self.queue.wake()
if not self.running and self.active: self._next()
def _next(self):
if self.running or not self.active: return
if self.stop.is_set() or self.results and not self.results[-1].safe_to_continue:
self.results.extend(VerifyResult('SKIPPED', stderr='队列已停止,未操作此 CBB')
for _ in self.requests[len(self.results):])
if len(self.results) == len(self.requests):
self._report(); return
if self.paused: return
request = self.requests[len(self.results)]
def check():
try:
def execute():
if request.block_name in self.ready_names:
return VerifyResult('SKIPPED', stderr='工程已为 READY,跳过 ICDB 检查。')
if request.block_name in self.invalidated:
return VerifyResult('SKIPPED', stderr='目标已有后续管理操作,请重新检查。')
self.event.emit({'stage': 'icdb_check_start', 'block': request.block_name})
return self.verifier(request)
return self.queue.run(execute, stop=self.stop, ready=lambda: not self.paused,
waiting=lambda: self.event.emit({'stage': 'waiting_native_slot', 'block': request.block_name,
'detail': '已排队,等待当前原生操作结束'}))
except QueueCancelled as error:
return VerifyResult('CANCELLED', stderr=str(error))
except Exception as error:
return VerifyResult('FAIL', stderr=str(error), safe_to_continue=False,
error_category='ICDB_INSPECTION_UNCONFIRMED')
self.running = True
self.worker = ServiceWorker(check)
self.worker.signals.succeeded.connect(self._record)
self.worker.signals.finished.connect(self._item_finished)
self.pool.start(self.worker)
def _record(self, result):
name = self.requests[len(self.results)].block_name
self.results.append(result)
if result.status in ('CANCELLED', 'QUEUE_STOP'): self.stop.set()
self.item_done.emit(name, result)
def _item_finished(self):
self.running = False
self._next()
def _report(self):
self.running = True
def write():
try:
report = write_batch_report(self.requests, self.results, self.report_root)
write_maintenance_report(self.requests, self.results, report, ())
return report, ''
except Exception as error:
return None, str(error)
self.worker = ServiceWorker(write)
self.worker.signals.succeeded.connect(self._report_ready)
self.worker.signals.finished.connect(self._complete)
self.pool.start(self.worker)
def _report_ready(self, payload):
self.report, self.report_error = payload
def _complete(self):
self.running = self.active = False
self.finished.emit(self)
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,250 @@
"""Explicit preview and asynchronous, checkpointed CBB management batch."""
from dataclasses import replace
from pathlib import Path
from threading import Event
from PySide6.QtCore import QObject, QThreadPool, Signal, Qt
from PySide6.QtWidgets import (QCheckBox, QDialog, QFileDialog, QHBoxLayout, QLabel,
QMessageBox, QPushButton, QTableWidget, QTableWidgetItem, QTextEdit, QVBoxLayout)
from .workers import ServiceWorker
from .backup_notice import MANUAL_BACKUP_NOTICE
from ..management import run_management_batch, validate_name
RESULT_LABELS = {
'REMOVED': '已移除', 'UPLOADED': '已上传 / 未自动校验',
'UPLOADED_VERIFIED': '已上传且校验通过', 'UPLOADED_VERIFY_FAILED': '已上传但校验未通过',
'UPLOAD_FAILED': '上传失败', 'RECOVERY_REQUIRED': '需要人工恢复',
'BLOCKED': '操作被阻止', 'UNSUPPORTED': '当前环境不支持',
}
STAGE_LABELS = {
'prepare_identity': '正在核对来源工程内容',
'catalog_before': '正在核对原生目录', 'baseline': '正在记录中心库内容基线',
'stage_source': '正在复制并检查来源工程', 'native_remove': '正在移除',
'removed': '原条目已移除', 'native_add': '正在上传', 'uploaded': '上传已确认',
'verify': '正在校验上传结果', 'verified': '校验已返回', 'copy': '正在准备来源副本',
'hash': '正在校验主要文件',
'release_check': '正在检查工程是否被占用',
'previous_release_check': '正在复核历史占用',
'previous_release_confirmed': '历史会话已确认释放',
'previous_release_unconfirmed': '占用复核未通过',
}
class ManagementSignals(QObject):
progress = Signal(object)
class ManagementDialog(QDialog):
completed = Signal(object)
before_execute = Signal(object)
def __init__(self, requests, parent=None, *, adapter=None, runner=None, recovery_from=None):
super().__init__(parent)
self.templates = tuple(requests)
self.template = self.templates[0]
self.operation = self.template.operation
self.adapter = adapter
self.native_queue = None
self.recovery_from = dict(recovery_from or {})
self.runner = runner or run_management_batch
if self.recovery_from and runner is None:
from ..reimport_recovery import run_reimport_recovery
self.runner = lambda requests, **kwargs: run_reimport_recovery(requests,
previous_evidence=self.recovery_from,
evidence_dir=self.template.evidence_dir.parent/'reimport-recovery', **kwargs)
self.busy = False
self.executed = False
self.stop = Event()
self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1)
self.signals = ManagementSignals(self)
self.signals.progress.connect(self._progress)
self.setWindowTitle({'add': '新增 CBB', 'update': '同名更新 CBB', 'remove': '移除 CBB'}[self.operation])
self.resize(850, 450)
self.table = QTableWidget(0, 4)
self.table.setHorizontalHeaderLabels(['CBB 名称', '分区', '来源 PRJ(完整工程)', '顶层块(空白时读取工程)'])
self.table.horizontalHeader().setStretchLastSection(True)
self.table.setColumnWidth(2, 300)
self.sources_button = QPushButton('选择来源工程…')
self.sources_button.setVisible(self.operation != 'remove')
self.sources_button.clicked.connect(self._browse)
self.auto_verify = QCheckBox('本批次上传后自动校验')
self.auto_verify.setChecked(self.template.auto_verify)
self.auto_verify.setVisible(self.operation != 'remove')
self.status_label = QLabel(MANUAL_BACKUP_NOTICE + ' 更新会先移除再重新导入,失败时请使用手动备份恢复。')
self.status_label.setWordWrap(True)
self.output = QTextEdit(); self.output.setReadOnly(True)
self.output.document().setMaximumBlockCount(2000)
self.output.hide()
self.logs_button = QPushButton('查看日志')
self.logs_button.setCheckable(True)
self.logs_button.toggled.connect(self.output.setVisible)
if self.recovery_from:
self.setWindowTitle('从副本恢复 CBB')
self.status_label.setText('修复未完成。请选择完整工程副本(.prj)。所列 CBB 将替换为副本中的版本。\n'
+ MANUAL_BACKUP_NOTICE)
self.output.append('\n'.join(f'原失败记录 {name}:{path}' for name, path in self.recovery_from.items()))
self.execute_button = QPushButton('预览并确认执行…')
self.execute_button.clicked.connect(self._execute)
self.stop_button = QPushButton('当前项结束后停止'); self.stop_button.setEnabled(False)
self.stop_button.clicked.connect(self.stop.set)
self.close_button = QPushButton('关闭'); self.close_button.clicked.connect(self.reject)
layout = QVBoxLayout(self)
layout.addWidget(QLabel(f'目标库:{self.template.library}'))
layout.addWidget(self.table)
layout.addWidget(self.sources_button); layout.addWidget(self.auto_verify)
layout.addWidget(self.status_label); layout.addWidget(self.logs_button); layout.addWidget(self.output)
buttons = QHBoxLayout()
for widget in (self.execute_button, self.stop_button, self.close_button): buttons.addWidget(widget)
layout.addLayout(buttons)
for request in self.templates:
if request.name:
self._append(request)
def _append(self, request):
row = self.table.rowCount(); self.table.insertRow(row)
for column, value in enumerate((request.name, request.partition, str(request.source or ''), request.top_level_block)):
item = QTableWidgetItem(value)
if column == 1 or column == 0 and self.operation != 'add' or self.operation == 'remove':
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.table.setItem(row, column, item)
def add_sources(self, sources):
if self.operation == 'add':
for source in sources:
source = Path(source)
self._append(replace(self.template, name=source.stem, source=source))
elif self.operation == 'update' and sources:
row = max(0, self.table.currentRow())
self.table.item(row, 2).setText(str(sources[0]))
def _browse(self):
if self.operation == 'add':
paths, _ = QFileDialog.getOpenFileNames(self, '选择完整来源工程', '', '工程 (*.prj)')
else:
path, _ = QFileDialog.getOpenFileName(self, '为当前行选择同名更新来源', '', '工程 (*.prj)')
paths = [path] if path else []
self.add_sources(paths)
def requests(self):
result = []
for row in range(self.table.rowCount()):
name, partition, source, top = (self.table.item(row, i).text().strip() for i in range(4))
result.append(replace(self.template, name=name, partition=partition,
source=Path(source) if source else None, top_level_block=top,
auto_verify=self.operation != 'remove' and self.auto_verify.isChecked()))
return result
def _execute(self):
if self.busy or self.executed:
return
requests = self.requests()
try:
if not requests:
raise ValueError('请先选择来源工程。')
for request in requests:
validate_name(request.name)
if request.operation != 'remove' and (request.source is None or not request.source.is_file()):
raise ValueError(f'{request.name}:请选择完整来源 PRJ。')
if len({(r.partition.casefold(), r.name.casefold()) for r in requests}) != len(requests):
raise ValueError('批次包含重复目标名称。')
except ValueError as error:
self.status_label.setText(str(error)); return
preview = '\n'.join(f'{r.partition} / {r.name}' + (f' ← {r.source}' if r.source else '') for r in requests)
description = ('同名更新会原生移除并重新导入;导入失败需要使用手动备份恢复。' if self.operation == 'update'
else '将通过原生操作移除所列 CBB;恢复时需要使用手动备份。' if self.operation == 'remove'
else '新增同名冲突会拒绝覆盖,完整来源工程将先复制到暂存区。')
if self.recovery_from:
description = ('将用所选副本替换这些 CBB。操作会先移除原条目,再导入副本;'
'导入失败时需要用备份恢复。请确认副本版本。')
answer = QMessageBox.question(self, '确认管理操作',
f'{MANUAL_BACKUP_NOTICE}\n{description}\n\n目标库:{self.template.library}\n{preview}\n\n'
'确认继续执行?', QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if answer != QMessageBox.Yes:
return
self.busy = True; self.executed = True
self._enabled(False)
self.before_execute.emit([r.name for r in requests])
def execute():
action = lambda: self.runner(requests, adapter=self.adapter, stop=self.stop,
progress=self.signals.progress.emit)
if self.native_queue is None: return action()
from ..operation_queue import QueueCancelled
try:
return self.native_queue.run(action, stop=self.stop, waiting=lambda: self.signals.progress.emit(
{'stage': 'waiting_native_slot', 'detail': '已排队,等待当前检查结束'}))
except QueueCancelled as error:
from ..management import ManagementResult
return [ManagementResult(r.operation, r.library, r.name, r.partition, r.source, r.auto_verify,
'complete', 'BLOCKED', True, str(error)) for r in requests]
self.worker = ServiceWorker(execute)
self.worker.signals.succeeded.connect(self._result)
self.worker.signals.failed.connect(self._failed)
self.worker.signals.finished.connect(self._finished)
self.pool.start(self.worker)
def _enabled(self, enabled):
for widget in (self.table, self.sources_button, self.auto_verify, self.close_button):
widget.setEnabled(enabled)
self.execute_button.setEnabled(enabled and not self.executed)
self.stop_button.setEnabled(not enabled)
def _progress(self, event):
stage = str(event.get('stage', ''))
text = f'{event.get("block", "")} {STAGE_LABELS.get(stage, RESULT_LABELS.get(stage, "正在处理"))}'
if stage == 'waiting_native_slot': text = str(event.get('detail', '已排队,等待执行'))
self.output.append(str(event))
if 'copied_files' in event:
text += f' {event["copied_files"]}/{event.get("total_files", "?")}'
elif 'hashed_files' in event:
text += f' {event["hashed_files"]}/{event.get("total_files", "?")} · {event.get("hashed_bytes", 0)} 字节'
self.status_label.setText(text)
def _result(self, results):
lines, summaries = [], []
for result in results:
summary = f'{result.name}:{RESULT_LABELS.get(result.status, result.status)}'
text = f'{summary} — {result.detail}'
changes = getattr(result, 'change_report', None)
if changes:
if changes.get('status') == 'RECORDED':
text += (f'\n已比对的工程文件:新增 {len(changes["added"])}、删除 {len(changes["deleted"])}、'
f'修改 {len(changes["modified"])};范围仅限报告列出的工程文件。')
else:
summary += ',变更清单待核对'
text += '\n'+changes.get('detail', '变更清单未确认')
if getattr(result, 'release_proof', None):
text += '\n历史会话已释放;历史工程数据的恢复状态需另行核对。'
if not result.safe_to_continue:
summary += ',原生会话释放待确认'
if self.recovery_from and result.status == 'UPLOADED_VERIFIED':
summary += ',版本待核对。'
elif result.status not in ('UPLOADED', 'UPLOADED_VERIFIED', 'REMOVED'):
summary += ',详情请查看日志。'
summaries.append(summary)
if result.evidence_path:
text += f'\n记录:{result.evidence_path}'
lines.append(text)
message = '\n'.join(lines) if lines else '队列已取消,未执行任何项。'
self.status_label.setText('\n'.join(summaries) if summaries else message); self.output.append(message)
self.completed.emit(results)
def _failed(self, error):
from ..management import ManagementResult
request = self.template
self._result([ManagementResult(request.operation, request.library, request.name, request.partition,
request.source, request.auto_verify, 'complete', 'RECOVERY_REQUIRED', False, str(error))])
def _finished(self):
self.busy = False; self._enabled(True)
def reject(self):
if not self.busy:
super().reject()
def closeEvent(self, event):
if self.busy:
self.stop.set(); event.ignore()
else:
super().closeEvent(event)
@@ -0,0 +1,31 @@
"""Show the native version dates without preselecting a recovery version."""
from PySide6.QtWidgets import QMessageBox
class PcbRestoreDialog(QMessageBox):
def __init__(self, choice, parent=None):
super().__init__(parent)
self.choice = choice
self.setWindowTitle('选择 PCB 恢复版本')
self.setIcon(QMessageBox.Question)
candidates = {c['kind']: c for c in choice.candidates}
manual, auto = candidates['last_user_saved'], candidates['autosave']
self.setText(f'CBB:{choice.block}\n中心库:{choice.library}\n\n'
'原生程序检测到上次异常退出,需要选择 PCB 恢复版本。\n'
f'最后手动保存:{manual["date"]}\n自动保存:{auto["date"]}\n\n'
'选择历史版本可能丢失此版本之后的修改。选择后继续校验、保存和状态确认;恢复版本仍需核对。'
'\n取消将停止本项并保留原生现场,不自动选取版本。')
self.manual_button = self.addButton(f'最后手动保存({manual["date"]})', QMessageBox.ActionRole)
self.auto_button = self.addButton(f'自动保存({auto["date"]})', QMessageBox.ActionRole)
self.manual_button.setEnabled(manual['enabled'])
self.auto_button.setEnabled(auto['enabled'])
self.cancel_button = self.addButton(QMessageBox.Cancel)
self.setDefaultButton(self.cancel_button)
self.setEscapeButton(self.cancel_button)
self.buttonClicked.connect(self._chosen)
self.finished.connect(lambda _: choice.choose('cancel'))
self.setModal(True)
def _chosen(self, button):
self.choice.choose('last_user_saved' if button is self.manual_button else
'autosave' if button is self.auto_button else 'cancel')
@@ -7,6 +7,7 @@ once after cleanup if the worker was killed while a native file was open.
from pathlib import Path
import json
import os
import re
import stat
import tempfile
import subprocess
@@ -113,6 +114,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,13 +123,80 @@ 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, read_icdb_error
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)})
message = read_icdb_error(source, checkpoint)
if message:
_write_record(root/'icdb-error-content.json', {'native_message': message, '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'))
collect_native_failure_logs(job['pcb'], job['root'])
collect_native_client_error(job['root'])
return 0
def collect_native_client_error(evidence_root):
"""Read only this PCB PID's new iCDB manager log in the bounded log helper."""
root = Path(evidence_root)/'diagnostics'
try:
context = json.loads((root/'native-client-context.json').read_text('utf-8'))
pid, started = context['native_pid'], context['started_ns']
if type(pid) is not int or pid <= 0 or type(started) is not int:
return
target = str(context['database']).replace('/', '\\').casefold()
if not target:
return
from .icdb_recovery import decode_log
for directory in Path(context['client_log_root']).glob(f'*-{pid}'):
for source in directory.glob('*.iCDBManager.txt'):
with source.open('rb') as stream:
metadata = os.fstat(stream.fileno())
if (metadata.st_mtime_ns < started
or getattr(metadata, 'st_birthtime_ns', started) < started):
continue
header = stream.read(16*1024)
stream.seek(0, os.SEEK_END)
size = stream.tell()
stream.seek(max(0, size-NATIVE_LOG_MAX_BYTES))
tail = stream.read(NATIVE_LOG_MAX_BYTES)
if not re.search(rf'\bPID\s*\[{pid}\]', decode_log(header)):
continue
# The native iCDB logger supplies the domain; a pathname in a
# generic PCB error alone never establishes this identity.
lines = decode_log(tail).splitlines()
if size > NATIVE_LOG_MAX_BYTES:
lines = lines[1:] # The first bounded-tail line may start mid-message.
message = next((line for line in lines
if re.search(r'\bERROR\s*:', line, re.I)
and target in line.replace('/', '\\').casefold()), '')
if message:
target_file = root/'native-logs/current-icdb-manager.txt'
target_file.parent.mkdir(parents=True, exist_ok=True)
target_file.write_bytes(tail)
_write_record(root/'icdb-error-content.json', {'native_message': 'iCDB: '+message,
'source': str(source), 'native_pid': pid, 'started_ns': started,
'database': context['database'], 'evidence': str(target_file)})
return
except (OSError, ValueError, KeyError, TypeError):
pass # A missing/ambiguous native log must not replace the open failure.
def capture_failure_logs_with_timeout(request_path, *, timeout_seconds=8):
"""Post-cleanup retry in a killable helper, not a potentially stuck SMB thread."""
request_path = Path(request_path)
+474 -105
View File
@@ -14,6 +14,7 @@ native menu invocation happens on the worker's private desktop.
from dataclasses import asdict, dataclass, field, replace
from pathlib import Path
import json
import logging
import os
import platform
import re
@@ -32,6 +33,22 @@ ERROR_TEXT = re.compile(r'failed|error|cannot connect|bad data', re.IGNORECASE)
INVALID_NAME_CHARS = '\\/:*?"<>|'
def _notify_progress(callback, *args):
"""A failed observer cannot change native execution or release facts."""
if callback is not None:
try:
callback(*args)
except Exception:
logging.getLogger(__name__).warning('Progress notification failed', exc_info=True)
def _write_optional_evidence(path, value):
try:
path.write_text(json.dumps(value, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
except OSError:
logging.getLogger(__name__).warning('Could not write diagnostic evidence %s', path, exc_info=True)
@dataclass(frozen=True)
class VerifyRequest:
lmc_file: Path
@@ -56,12 +73,16 @@ class VerifyRequest:
# A reserved iCDB range is a host-wide prerequisite failure. Do not
# launch a PCB that is guaranteed to time out; batch orchestration will
# record this item and continue with the next one.
strict_port_check: bool = True
strict_port_check: bool = False
# A mapped drive can be invisible to an elevated/private worker on Win10.
# Preserve the parent session's mapping identity so the worker can restore
# it before launching Library Manager/PCB.
mapped_drive: str = ''
mapped_remote_root: str = ''
auto_repair: bool = False
maintenance: bool = False
post_repair_proof: object | None = field(default=None, repr=False, compare=False)
diagnostic_only: bool = False
@dataclass(frozen=True)
@@ -80,6 +101,8 @@ class VerifyResult:
bridge_attempts: tuple[dict, ...] = ()
timings_seconds: dict[str, float] = field(default_factory=dict)
incomplete_timing_phases: tuple[str, ...] = ()
recovery_attempts: tuple[dict, ...] = ()
release_proof: dict | None = None
def resolve_importer(mentor_bin: str | None = None) -> Path:
@@ -127,7 +150,11 @@ 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'
if SUCCESS_TEXT.search(output) and not ERROR_TEXT.search(output):
from .icdb_recovery import parse_session_loss
if parse_session_loss(output):
return 'FAIL'
diagnostic_text = re.sub(r'\b0\s+errors?\b', '', output, flags=re.I)
if exit_code == 0 and SUCCESS_TEXT.search(output) and not ERROR_TEXT.search(diagnostic_text):
return 'PASS'
if ERROR_TEXT.search(output):
return 'FAIL'
@@ -149,13 +176,22 @@ def preflight(request):
if len(projects) != 1:
raise ValueError(f'{name}: 缺少或无法唯一确定 Work 下的工程 PRJ')
project = absolute_preserving_drive(projects[0])
content = project.read_text(encoding='utf-8', errors='replace')
from .backup_recovery import _project_text
content = _project_text(project)
refs = re.findall(r'^KEY PCBDesignPath "([^"]+)"', content, re.M)
if not refs:
raise ValueError(f'{name}: 工程没有 PCBDesignPath')
pcb = absolute_preserving_drive(project.parent/refs[0])
if not pcb.is_relative_to(absolute_preserving_drive(work)):
raise ValueError(f'{name}: PCB 引用越出当前 CBB,停止操作: {pcb}')
real_work = work.resolve()
expected_work = library.parent.resolve() / 'ReusableBlocksLP' / name / 'Work'
if os.path.normcase(str(real_work)) != os.path.normcase(str(expected_work)):
raise ValueError(f'{name}: Work 路径通过链接指向其他工程,停止操作')
for candidate in (project, pcb, pcb.parent/'pcb.prj', pcb.parent/'Layout',
pcb.parent/'Layout'/'LayoutDB.lyt', work/'database', work/'CES'):
if not candidate.resolve().is_relative_to(real_work):
raise ValueError(f'{name}: 文件或目录链接越出当前 CBB,停止操作: {candidate}')
if not pcb.is_file() or not (pcb.parent/'Layout'/'LayoutDB.lyt').is_file():
raise ValueError(f'{name}: 缺少 PCB 或布局数据库: {pcb}')
return project, pcb
@@ -174,7 +210,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)
@@ -187,44 +223,34 @@ 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(['taskkill', '/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):
"""Best-effort worker tree termination that never masks the item result."""
"""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:
process.wait(timeout=timeout)
except Exception:
pass
try:
process.kill() # Automation clients only; never the native tree.
process.wait(timeout=5)
except Exception:
pass
try:
if hasattr(process, 'stop_automation_clients'):
process.stop_automation_clients()
return process.poll() is not None
except Exception:
return False
def _normalize_bridge_result(probe):
@@ -269,6 +295,20 @@ def read_library_flag_with_retry(reader, library, block_name, *, attempts=3,
def classify_failure_category(detail):
text = str(detail or '')
lower = text.casefold()
if 'pcb_version_choice_required' in lower:
return 'PCB_VERSION_CHOICE_REQUIRED'
from .icdb_recovery import ERROR_CODE, parse_session_loss
if ERROR_CODE.casefold() in lower or parse_session_loss(text):
return ERROR_CODE
if 'back annotation is not allowed on verified (or once verified) reusable blocks.' in lower:
# Preserve the native integration failure even when shutdown adds a
# secondary release warning. This category does not grant permission
# to reimport or change safe_to_continue.
return 'CBB_REIMPORT_REQUIRED'
if any(code in lower for code in (
'pcb_release_unconfirmed', 'icdb_release_unconfirmed',
'icdb_session_unconfirmed', 'pcb_session_active', 'database_recovery_required')):
return 'DATABASE_SAFETY_STOP'
if 'tf_floatinglangbar_wndtitle' in lower or 'cicerouiwndframe' in lower:
return 'TOOL_FALSE_DIALOG'
if 'could not load job preferences db' in lower or 'unable to create local cell library' in lower:
@@ -470,15 +510,9 @@ def native_lm_verify_enabled():
}
def _cleanup_session_processes(root, *, lm_pid, target_pid, pcb, pcb_baseline,
def _cleanup_session_processes(root, *, lm_pid, target_pid, pcb, pcb_baseline, launcher_pid=None,
progress=None):
"""Reap Mentor processes after the worker can no longer run its ``finally``.
The outer supervisor owns the worker lifetime. A timeout or an unknown
dialog may therefore terminate the worker while its child LMC/PCB processes
remain alive. Delegate the same target-filtered cleanup used by the worker
and persist its events before the batch advances.
"""
"""Record native release or retention after automation has stopped."""
from .mentor_adapter import cleanup_verify_processes
event_path = Path(root) / 'events.jsonl'
@@ -495,12 +529,12 @@ def _cleanup_session_processes(root, *, lm_pid, target_pid, pcb, pcb_baseline,
except OSError:
pass
if progress:
progress(event)
_notify_progress(progress, event)
cleanup_verify_processes(
return cleanup_verify_processes(
lm_pid,
target_pid,
None,
launcher_pid,
expected_pcb=pcb,
baseline_pids=pcb_baseline,
emit=emit,
@@ -508,12 +542,176 @@ def _cleanup_session_processes(root, *, lm_pid, target_pid, pcb, pcb_baseline,
def run_verify(request, *, progress=None, flag_reader=None, process_runner=None, port_check=None,
dialog_supervisor_factory=None):
dialog_supervisor_factory=None, version_prompt=None, stop=None):
# Cover contents checking, native work and final state reads with one
# session-wide mutex. The worker-stage lock below is reentrant on Windows.
import win32event, win32con
from .com_runtime import initialize_com, uninitialize_com
initialized = initialize_com()
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
acquired = False
library_lock = None
previous_release = None
release_confirmed = True
remaining_clients = ()
def clients_released():
if release_confirmed:
return True
from .library_lock import _supervisor_alive
return bool(remaining_clients) and not any(_supervisor_alive(pid) for pid in remaining_clients)
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=True, error_category='NATIVE_CHANNEL_BUSY')
if request.maintenance:
from .maintenance_entry import run_icdb_check
return run_icdb_check(request, progress=progress, stop=stop)
from .library_lock import LibraryLock, LibraryBusy, recheck_previous_release
import pywintypes
if Path(request.lmc_file).is_file():
try:
previous_release = recheck_previous_release(request.lmc_file,
Path(request.evidence_dir)/'previous-release', block_name=request.block_name, progress=progress)
library_lock = LibraryLock(request.lmc_file, checkpoint=False,
safe_to_release=clients_released)
library_lock.__enter__()
except LibraryBusy as error:
return VerifyResult('FAIL', stderr=str(error), error_category='LIBRARY_IN_USE')
except (OSError, ValueError, RuntimeError, pywintypes.error) as error:
return VerifyResult('FAIL', stderr=str(error), error_category='LIBRARY_ACCESS_FAILED')
release_confirmed = False
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, version_prompt=version_prompt, stop=stop)
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
snapshot = original.evidence_path.with_name('pre-repair-result.json')
snapshot.write_text(json.dumps(asdict(original), ensure_ascii=False, default=str, indent=2),
encoding='utf-8')
recovery = attempt_recovery(request, diagnosis, result.evidence_path.parent, progress=progress)
recovery = {**recovery, 'original_error': original.stderr,
'original_evidence': str(original.evidence_path),
'original_result_snapshot': str(snapshot),
'original_stage': original.error_stage,
'native_status': recovery.get('native_status', recovery.get('status')),
'validation_passed': False}
if recovery.get('status') == 'REPAIRED':
from .native_repair import native_success_confirmed, select_repair_target
try:
confirmed = native_success_confirmed(select_repair_target(request, diagnosis), recovery)
except (ValueError, OSError):
confirmed = False
if not confirmed:
release = recovery.get('release')
recovery.update(status='UNCONFIRMED',
release={**(release if isinstance(release, dict) else {}), 'safe_to_continue': False},
detail='NATIVE_REPAIR_EVIDENCE_UNCONFIRMED: 原生成功记录不完整或矛盾,未重试校验')
if (recovery.get('status') == 'REPAIRED'
and recovery.get('release', {}).get('safe_to_continue') is True):
result = replace(original, recovery_attempts=(recovery,))
recovery['status'] = 'REPAIR_VALIDATION_FAILED'
result = _run_verify_serialized(
replace(request, auto_repair=False, maintenance=False), progress=progress, flag_reader=flag_reader,
process_runner=process_runner, port_check=port_check,
dialog_supervisor_factory=dialog_supervisor_factory, version_prompt=version_prompt)
recovery['validation_evidence'] = str(result.evidence_path or '')
recovery['validation_passed'] = (result.status == 'PASS'
and result.library_flag == 'GREEN' and result.safe_to_continue)
if not recovery['validation_passed']:
recovery['status'] = 'REPAIR_VALIDATION_FAILED'
if result.status == 'PASS':
result = replace(result, status='FAIL',
stderr=(result.stderr+'\nREPAIR_VALIDATION_UNCONFIRMED: 未取得校验 GREEN').strip())
else:
recovery['status'] = 'REPAIRED'
else:
# A failed local database must not block unrelated CBBs once
# every owner is released. Re-check target ownership here so
# an incomplete repair record cannot authorize the queue.
safe = False
if (recovery.get('status') in {'MISSING_HEALTHY_BACKUP', 'NATIVE_REPAIR_FAILED'}
and recovery.get('evidence', {}).get('failure_complete') is True
and recovery.get('release', {}).get('safe_to_continue') is True):
from .native_repair import select_repair_target
try:
target = select_repair_target(request, diagnosis)
safe = (Path(recovery.get('project', '')).resolve() == target.project
and Path(recovery.get('database', '')).resolve() == target.database)
except (ValueError, OSError):
pass
result = replace(result, safe_to_continue=safe, stderr=(result.stderr + '\n'
+ str(recovery.get('status', 'REPAIR_UNCONFIRMED')) + ': '
+ str(recovery.get('detail', '原生 Repair 未完成恢复'))).strip())
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())
if result.evidence_path:
try:
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 OSError:
pass # Keep the native/repair errors even if evidence storage fails.
release_confirmed = result.safe_to_continue
if not release_confirmed and result.evidence_path:
try:
release = json.loads(result.evidence_path.with_name('session-release.json').read_text('utf-8'))
release_confirmed = (release.get('worker_exited') is True
and release.get('safe_to_continue') is True and release.get('block') == request.block_name
and Path(release['library']).resolve() == Path(request.lmc_file).resolve())
if (release.get('worker_exited') is True and not release.get('error')
and not release.get('close_errors') and not release.get('automation_release', {}).get('error')
and release.get('block') == request.block_name
and Path(release['library']).resolve() == Path(request.lmc_file).resolve()):
remaining_clients = tuple(pid for pid in release.get('remaining_pids', [])
if type(pid) is int and pid > 0)
except (OSError, ValueError, KeyError):
pass
if previous_release is not None:
result = replace(result, release_proof=previous_release)
if result.evidence_path:
_write_optional_evidence(result.evidence_path, {'block_name': request.block_name, **asdict(result)})
return result
finally:
try:
if library_lock is not None:
library_lock.__exit__(None, None, None)
finally:
if acquired:
win32event.ReleaseMutex(mutex)
mutex.Close()
uninitialize_com(initialized)
def _run_verify_serialized(request, *, progress=None, flag_reader=None, process_runner=None,
port_check=None, dialog_supervisor_factory=None, version_prompt=None, stop=None):
timing = RunTimings()
result = _run_verify(request, timing=timing, progress=progress, flag_reader=flag_reader,
process_runner=process_runner, port_check=port_check,
dialog_supervisor_factory=dialog_supervisor_factory)
if result.status not in {'PASS', 'SKIPPED', 'QUEUE_STOP'} and result.evidence_path:
dialog_supervisor_factory=dialog_supervisor_factory, version_prompt=version_prompt, stop=stop)
if not request.auto_repair and result.evidence_path:
try:
release = json.loads(result.evidence_path.with_name('session-release.json').read_text('utf-8'))
if (release.get('block') == request.block_name
and Path(release['library']).resolve() == Path(request.lmc_file).resolve()):
released = release.get('worker_exited') is True and release.get('safe_to_continue') is True
result = replace(result, safe_to_continue=released)
if not released and result.status == 'PASS':
result = replace(result, status='FAIL', stderr='原生会话或自动化客户端尚未退出。')
except (OSError, ValueError, KeyError):
pass
if result.status not in {'PASS', 'SKIPPED', 'QUEUE_STOP', 'CANCELLED'} and result.evidence_path:
job_path = result.evidence_path.with_name('request.json')
if job_path.is_file():
timing.begin('failure_diagnostics')
@@ -525,6 +723,30 @@ def run_verify(request, *, progress=None, flag_reader=None, process_runner=None,
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, 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)
@@ -532,28 +754,29 @@ def run_verify(request, *, progress=None, flag_reader=None, process_runner=None,
error_stage=(result.error_stage or (unfinished[-1] if unfinished else 'execution')
if result.status not in {"PASS", "SKIPPED"} else ""))
if result.evidence_path:
result.evidence_path.write_text(json.dumps(
{'block_name': request.block_name, **asdict(result)},
ensure_ascii=False, default=str, indent=2), encoding='utf-8')
result.evidence_path.with_name('performance.json').write_text(json.dumps({
_write_optional_evidence(result.evidence_path, {'block_name': request.block_name, **asdict(result)})
_write_optional_evidence(result.evidence_path.with_name('performance.json'), {
'block_name': request.block_name, 'status': result.status,
'unit': 'seconds', 'timings_seconds': durations,
'incomplete_timing_phases': unfinished,
'clock': 'monotonic; save helper subphases: VBScript Timer (midnight adjusted)',
'notes': 'phase totals overlap action/call subphases; skipped phases are absent',
}, ensure_ascii=False, indent=2), encoding='utf-8')
})
if progress:
progress({'stage': 'performance', 'block': request.block_name,
_notify_progress(progress, {'stage': 'performance', 'block': request.block_name,
'timings_seconds': durations, 'incomplete_timing_phases': unfinished,
'detail': ' '.join(f'{key}={value:.3f}s' for key, value in durations.items())})
if request.logging_context:
request.logging_context.logger.info('operation=cbb_verify block=%s status=%s flag=%s evidence=%s error=%s timings_seconds=%s',
request.block_name, result.status, result.library_flag, result.evidence_path, result.stderr, durations)
try:
request.logging_context.logger.info('operation=cbb_verify block=%s status=%s flag=%s evidence=%s error=%s timings_seconds=%s',
request.block_name, result.status, result.library_flag, result.evidence_path, result.stderr, durations)
except Exception:
logging.getLogger(__name__).warning('Operation logging failed', exc_info=True)
return result
def _run_verify(request, *, timing, progress=None, flag_reader=None, process_runner=None, port_check=None,
dialog_supervisor_factory=None):
dialog_supervisor_factory=None, version_prompt=None, stop=None):
"""Refresh one CBB and record its evidence.
``flag_reader`` is a read-only probe returning an authoritative ``BridgeResult``.
@@ -562,28 +785,33 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
not depend on the host's port reservations.
"""
root = Path(request.evidence_dir).resolve()/('verify-' + uuid4().hex[:12])
root.mkdir(parents=True, exist_ok=False)
try:
root.mkdir(parents=True, exist_ok=False)
except OSError as error:
return VerifyResult('FAIL', stderr=f'无法创建操作记录目录:{error}')
fingerprint = runtime_fingerprint(request.mentor_bin)
(root/'runtime.json').write_text(
json.dumps(fingerprint, ensure_ascii=False, indent=2), encoding='utf-8')
_write_optional_evidence(root/'runtime.json', fingerprint)
if progress:
progress({'stage': 'runtime_fingerprint', 'block': request.block_name,
_notify_progress(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):
# Backups are transient protection for the active worker. Keep the
# small, actionable evidence files but reclaim the copied CBB tree so
# large libraries do not accumulate tens of megabytes per item.
# Only reclaim auxiliary backups after confirmed success. Failed runs
# retain every available original file for incident investigation.
try:
from .mentor_adapter import cleanup_evidence_backup
cleanup_evidence_backup(root)
if result.status == 'PASS' and result.safe_to_continue:
cleanup_evidence_backup(root)
except Exception:
# Cleanup must never hide or change the verification result.
pass
return replace(result, evidence_path=result_path)
if stop is not None and stop.is_set():
return finish(VerifyResult('CANCELLED', stderr='已取消,未启动校验。'))
timing.begin('preflight')
try:
project, pcb = preflight(request)
@@ -592,7 +820,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
finally:
timing.end('preflight')
content_check_enabled = bool(str(request.libspec).strip() and str(request.dms_login_config).strip())
content_check_enabled = not request.diagnostic_only and bool(str(request.libspec).strip() and str(request.dms_login_config).strip())
if content_check_enabled:
try:
executable = resolve_importer(request.mentor_bin)
@@ -600,7 +828,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
return finish(VerifyResult('BLOCKED', stderr=str(error)))
command = build_content_check_command(request, executable)
if progress:
progress({'stage': 'content_check_start', 'block': request.block_name,
_notify_progress(progress, {'stage': 'content_check_start', 'block': request.block_name,
'detail': ' '.join(command)})
timing.begin('content_check')
try:
@@ -619,22 +847,24 @@ 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'})
_notify_progress(progress, {'stage': 'content_check_done', 'block': request.block_name, 'status': 'PASS'})
# The design server needs a port in 10000-10100; a system reservation there
# blocks every item, so fail fast with the fix instead of timing out.
# Sampling cannot establish that the whole native port range is unusable.
from .mentor_adapter import icdb_ports_bindable
check_ports = port_check or icdb_ports_bindable
ports_ok, ports_detail = check_ports()
if not ports_ok:
if progress:
progress({'stage': 'port_warning', 'block': request.block_name, 'detail': ports_detail})
_notify_progress(progress, {'stage': 'port_warning', 'block': request.block_name, 'detail': ports_detail})
if request.strict_port_check:
return finish(VerifyResult('BLOCKED', stderr=ports_detail))
job = {'lmc_file': str(absolute_preserving_drive(request.lmc_file)), 'block_name': request.block_name,
'diagnostic_only': request.diagnostic_only,
'supervisor_pid': os.getpid(),
'project': str(project), 'pcb': str(pcb), 'root': str(root), 'timeout': request.timeout_seconds,
'mentor_bin': str(request.mentor_bin or ''),
'mapped_drive': str(request.mapped_drive or ''),
@@ -642,12 +872,24 @@ 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')}
consent = None
job_path = root/'request.json'
job_path.write_text(json.dumps(job, ensure_ascii=False), encoding='utf-8')
try:
if request.post_repair_proof is not None:
from .post_repair_consent import PostRepairProof, ConsentController, exact_prompt
if not isinstance(request.post_repair_proof, PostRepairProof):
return finish(VerifyResult('BLOCKED', stderr='POST_REPAIR_PROOF_REQUIRED'))
job['post_repair_consent'] = request.post_repair_proof.for_job(job)
consent = ConsentController(request.post_repair_proof, job)
job_path.write_text(json.dumps(job, ensure_ascii=False), encoding='utf-8')
except Exception as error:
return finish(VerifyResult('FAIL', stderr=str(error)))
events = root/'events.jsonl'
offset = 0
target_pid = None
launcher_pid = None
lm_pid = None
verify_invoked = False
invoke_returned = False
@@ -663,27 +905,34 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
lock_status = win32event.WaitForSingleObject(mutex, 0)
if lock_status not in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED):
mutex.Close()
return finish(VerifyResult('BLOCKED', stderr='已有 CBB 校验任务运行,请等待结束。', safe_to_continue=False))
return finish(VerifyResult('BLOCKED', stderr='已有 CBB 校验任务运行;本次未启动。',
safe_to_continue=True, error_category='NATIVE_CHANNEL_BUSY'))
worker_launch_attempted = False
try:
timing.begin('worker_setup')
with (root/'worker.log').open('w', encoding='utf-8') as log:
worker_launch_attempted = True
if request.interactive_input:
process = DesktopWorker(
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
restore_controller = None
dialog_agent = None
latest_snapshots = ()
if dialog_supervisor_factory is None:
if hasattr(process, 'start_companion'):
from .dialog_agent import DialogAgentClient
from .dialog_rules import default_rules_path, load_rules
dialog_agent = DialogAgentClient.start(process, root/'dialog-agent')
dialog_agent = DialogAgentClient.start(process, root/'dialog-agent', stop=stop)
dialog_supervisor = DialogSupervisor(
AgentDialogBackend(dialog_agent),
AgentDialogBackend(dialog_agent, pids=lambda: {
int(pid) for pid in (target_pid, lm_pid, launcher_pid) if pid}),
rules=load_rules(default_rules_path()),
)
else:
@@ -696,8 +945,14 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
desktop=process.desktop,
pids=lambda: ({value for value in (target_pid, lm_pid) if value is not None}),
)
if stop is not None and stop.is_set():
raise InterruptedError('VERIFY_CANCELLED: 启动已取消,未启动 PCB')
Path(job['start_gate']).touch()
while process.poll() is None:
if stop is not None and stop.is_set():
_stop_worker(process)
return finish(VerifyResult('CANCELLED', stderr='已取消当前校验。',
safe_to_continue=False, error_stage=phase.value))
if events.exists():
with events.open(encoding='utf-8') as stream:
stream.seek(offset)
@@ -708,6 +963,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
break
timing.record(event)
if event.get('pcb_pid'): target_pid = event['pcb_pid']
if event.get('launcher_pid'): launcher_pid = event['launcher_pid']
if event.get('lm_pid'): lm_pid = event['lm_pid']
stage = event.get('stage')
if stage == 'verify_invoke': verify_invoked = True
@@ -731,7 +987,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
0.1, float(request.timeout_seconds))
deadline.touch()
last_activity_key = activity_key
if progress: progress(event)
if progress: _notify_progress(progress, event)
offset = stream.tell()
if verify_invoked and target_pid is None and time.monotonic() - last_observation >= .5:
from .post_verify_diagnostics import observe_post_verify
@@ -759,6 +1015,27 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
dialog_result = dialog_supervisor.poll()
else:
dialog_result = dialog_supervisor.poll()
if (consent is not None and dialog_agent is not None
and dialog_result.error_code == 'DATABASE_RECOVERY_REQUIRED'
and dialog_result.snapshot is not None and exact_prompt(dialog_result.snapshot)):
consent_snapshot = dialog_result.snapshot
if consent_snapshot.hwnd in {int(h) for h in process.desktop.EnumDesktopWindows()}:
dialog_result = consent.handle(consent_snapshot, dialog_result.observed_snapshots,
target_pid=target_pid, launcher_pid=launcher_pid, worker_pid=process.pid,
companion_pids=tuple(process.companion_pids), perform=dialog_supervisor.backend.perform)
if dialog_result.error_code == 'PCB_VERSION_CHOICE_REQUIRED' and dialog_result.snapshot is not None:
from .dialog_rules import archive_version_choice
choice_path = archive_version_choice(dialog_result.snapshot, root)
dialog_result = replace(dialog_result, detail=dialog_result.detail + f'\n版本候选与原生窗口证据:{choice_path}')
if (version_prompt is not None and consent is not None and dialog_agent is not None
and dialog_result.snapshot.hwnd in {int(h) for h in process.desktop.EnumDesktopWindows()}):
from .pcb_restore_prompt import RestoreController
if restore_controller is None:
restore_controller = RestoreController(job)
dialog_result = restore_controller.handle(dialog_result.snapshot,
dialog_result.observed_snapshots, target_pid=target_pid, launcher_pid=launcher_pid,
worker_pid=process.pid, companion_pids=tuple(process.companion_pids),
show=version_prompt, perform=dialog_supervisor.backend.perform)
# Normal progress stays in memory. Only actions/errors and the
# last failure snapshots are persisted, not every elapsed tick.
latest_snapshots = dialog_result.observed_snapshots
@@ -784,16 +1061,19 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
if dialog_result.error_code:
_write_failure_windows(root, latest_snapshots)
_write_process_tree(root, process, target_pid)
_stop_worker(process)
# A failed database load has no document to close. Give the
# worker time to normally close its owned empty PCB before
# recovery checks for remaining native database clients.
_stop_worker(process, timeout=40)
return finish(VerifyResult(
'FAIL',
stderr=f'{dialog_result.error_code}: {dialog_result.detail}',
error_stage=phase.value,
safe_to_continue=True,
safe_to_continue=False,
))
if deadline.expired():
_write_failure_windows(root, latest_snapshots)
# Kills the worker's whole job: worker, PCB and cscript helper.
# Stop automation without killing PCB/iCDB during a write.
_write_process_tree(root, process, target_pid)
if last_post_verify_observation:
(root/'post_verify_observations.jsonl').write_text(json.dumps({
@@ -811,14 +1091,14 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
if dispatch_failure is not None:
status, detail = dispatch_failure
if progress:
progress({
_notify_progress(progress, {
'stage': 'verify_dispatch_failed',
'block': request.block_name,
'detail': detail,
'observation': last_post_verify_observation,
})
return finish(VerifyResult(status, stderr=detail, safe_to_continue=True))
return finish(VerifyResult('TIMEOUT', stderr='操作超时;已记录现场,跳过当前 CBB。', error_stage=phase.value, safe_to_continue=True))
return finish(VerifyResult(status, stderr=detail, safe_to_continue=False))
return finish(VerifyResult('TIMEOUT', stderr='操作超时,当前项未完成。', error_stage=phase.value, safe_to_continue=False))
time.sleep(.2)
worker_result = root/'outcome.json'
if not worker_result.exists():
@@ -830,26 +1110,104 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
except Exception as error:
if 'process' in locals() and process.poll() is None:
_stop_worker(process)
return finish(VerifyResult('FAIL', stderr=str(error), safe_to_continue=False))
launch_release = getattr(error, 'worker_launch_release', None) if 'process' not in locals() else None
if not worker_launch_attempted:
launch_release = {'process_created': False, 'worker_exited': True,
'safe_to_continue': True, 'remaining_pids': []}
no_launch = (isinstance(launch_release, dict)
and launch_release.get('process_created') is False
and launch_release.get('worker_exited') is True
and launch_release.get('safe_to_continue') is True
and launch_release.get('remaining_pids') == [])
if no_launch:
_write_optional_evidence(root/'session-release.json', {
**launch_release, 'block': request.block_name, 'library': str(request.lmc_file),
'worker_pid': None})
status = 'CANCELLED' if stop is not None and stop.is_set() else 'FAIL'
return finish(VerifyResult(status, stderr=str(error), safe_to_continue=no_launch))
finally:
close_errors = []
worker_exited = False
automation_release = {'safe_to_continue': False}
if 'dialog_agent' in locals() and dialog_agent is not None:
dialog_agent.close()
if 'process' in locals(): process.close()
try:
dialog_agent.close()
except Exception as error:
close_errors.append(str(error))
if 'process' in locals():
try:
_cleanup_session_processes(
worker_exited = process.poll() is not None
if not worker_exited:
worker_exited = _stop_worker(process)
if hasattr(process, 'automation_release_state'):
automation_release = process.automation_release_state()
else:
automation_release = {'safe_to_continue': worker_exited, 'remaining_pids': []}
process.close()
except Exception as error:
close_errors.append(str(error))
if 'process' in locals():
try:
if events.is_file():
with events.open(encoding='utf-8') as stream:
stream.seek(offset)
for line in stream:
try:
event = json.loads(line)
timing.record(event)
if event.get('pcb_pid'): target_pid = event['pcb_pid']
if event.get('launcher_pid'): launcher_pid = event['launcher_pid']
if event.get('lm_pid'): lm_pid = event['lm_pid']
if event.get('stage') == 'pcb_baseline': pcb_baseline = set(event.get('pids', ()))
except (json.JSONDecodeError, ValueError):
continue
offset = stream.tell()
release_result = _cleanup_session_processes(
root,
lm_pid=lm_pid,
target_pid=target_pid,
launcher_pid=launcher_pid,
pcb=pcb,
pcb_baseline=pcb_baseline,
progress=progress,
)
except Exception:
# Cleanup is best effort; the original Verify result remains
# authoritative and the evidence directory records everything
# that was successfully reaped.
except Exception as error:
release_result = {'safe_to_continue': False, 'error': str(error)}
try:
from .icdb_ownership import unreleased_addresses
addresses = unreleased_addresses(request.lmc_file, project, pcb)
if addresses:
release_result = {**(release_result or {}), 'icdb_addresses': addresses}
except OSError as error:
close_errors.append(str(error))
if close_errors:
release_result = {**(release_result or {}), 'safe_to_continue': False,
'close_errors': close_errors}
if not worker_exited or not automation_release.get('safe_to_continue'):
release_result = {**(release_result or {}), 'safe_to_continue': False,
'automation_release': automation_release, 'worker_exited': worker_exited}
release_result['remaining_pids'] = sorted(set(release_result.get('remaining_pids', []))
| set(automation_release.get('remaining_pids', [])))
try:
(root/'session-release.json').write_text(json.dumps({
**(release_result or {}), 'block': request.block_name,
'library': str(request.lmc_file), 'worker_exited': worker_exited,
'worker_pid': getattr(process, 'pid', None)},
ensure_ascii=False, default=str, indent=2), encoding='utf-8')
except OSError:
pass
if not release_result or not release_result.get('safe_to_continue'):
if 'result' in locals():
result = replace(result, status='FAIL' if result.status == 'PASS' else result.status, safe_to_continue=False,
stderr=(result.stderr + '\nPCB_RELEASE_UNCONFIRMED: 未确认原生会话退出').strip())
recovery = {'desktop': job['desktop'], 'project': str(project),
'pcb': str(pcb), 'release': release_result,
'action': '停止批次;检查原生会话及数据库;不要删除锁文件或自动恢复。'}
try:
(root/'recovery-required.json').write_text(
json.dumps(recovery, ensure_ascii=False, indent=2), encoding='utf-8')
except OSError:
pass # Evidence failure must not prevent mutex release.
# Drain the timing tail even when the worker exited before a poll.
# This is optional telemetry: an unreadable log must not mask failure
# or prevent releasing the serial-operation mutex.
@@ -868,22 +1226,22 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
win32event.ReleaseMutex(mutex)
mutex.Close()
if result.status == 'PASS':
if result.status == 'PASS' and not request.diagnostic_only:
timing.begin('library_flag')
bridge_records = []
def record_attempt(record):
bridge_records.append(record)
if progress:
progress({'stage': 'library_flag_probe', 'block': request.block_name, **record})
_notify_progress(progress, {'stage': 'library_flag_probe', 'block': request.block_name, **record})
try:
probe = read_library_flag_with_retry(
flag_reader or read_library_flag_if_available, Path(request.lmc_file),
request.block_name, on_attempt=record_attempt)
result = apply_post_verify_status(result, probe)
result = replace(result, bridge_attempts=tuple(bridge_records))
(root/'bridge-status.json').write_text(json.dumps(bridge_records, ensure_ascii=False, indent=2), encoding='utf-8')
_write_optional_evidence(root/'bridge-status.json', bridge_records)
if progress:
progress({'stage': 'library_flag', 'block': request.block_name,
_notify_progress(progress, {'stage': 'library_flag', 'block': request.block_name,
'library_flag': result.library_flag, 'detail': result.library_flag_detail})
finally:
timing.end('library_flag')
@@ -891,7 +1249,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
def run_batch(requests, max_workers=1, verifier=None, *, stop=None, progress=None):
"""Run CBBs serially; one item's failure never aborts the queue."""
"""Run serially and stop when database/session safety is unconfirmed."""
if max_workers != 1:
raise ValueError('Only serial Verify is supported for the shared Library Manager session')
if verifier is None:
@@ -905,15 +1263,14 @@ def run_batch(requests, max_workers=1, verifier=None, *, stop=None, progress=Non
try:
result = verifier(request)
except Exception as error:
# An unexpected worker exception is a failed item, not a batch abort.
# An unexpected exception cannot establish database safety.
result = VerifyResult('FAIL', stderr=str(error), safe_to_continue=False)
results.append(result)
# Failure status and safe_to_continue describe this item, not the batch;
# the queue is skipped only after an explicit stop signal.
queue_stop = queue_stop or result.status == 'QUEUE_STOP'
if result.status == 'QUEUE_STOP' and stop is not None:
# Never start another writer after an unconfirmed native shutdown.
queue_stop = queue_stop or result.status in {'QUEUE_STOP', 'CANCELLED'} or not result.safe_to_continue
if queue_stop and stop is not None:
stop.set()
if progress: progress(request.block_name, result)
if progress: _notify_progress(progress, request.block_name, result)
return results
@@ -934,11 +1291,21 @@ def write_failure_report(requests, results, root, *, path=None):
root = Path(root); root.mkdir(parents=True, exist_ok=True)
path = Path(path) if path else root/('failures-' + time.strftime('%Y%m%d-%H%M%S') + '-' + uuid4().hex[:6] + '.log')
failed = [(req, result) for req, result in zip(requests, results)
if result.status not in {'PASS', 'SKIPPED', 'QUEUE_STOP'}]
if result.status not in {'PASS', 'SKIPPED', 'QUEUE_STOP'}
and not (result.status in {'CHECKED', 'REPAIRED'} and result.safe_to_continue)]
passed = sum(result.status == 'PASS' for result in results)
skipped = len(results)-passed-len(failed)
lines = ['CBB Verify 失败清单', f'总数: {len(results)} 成功: {passed} 失败: {len(failed)} 未执行: {skipped}',
checked = sum(result.status == 'CHECKED' and result.safe_to_continue for result in results)
repaired = sum(result.status == 'REPAIRED' and result.safe_to_continue for result in results)
skipped = len(results)-passed-len(failed)-checked-repaired
lines = ['CBB Verify 失败清单', f'总数: {len(results)} 成功: {passed} 失败: {len(failed)} 未执行: {skipped} 仅检查未修复: {checked} ICDB已修复待校验: {repaired}',
'CBB\t状态\t错误分类\t失败阶段\t桥状态\t原始错误\t证据\t实际耗时(秒)']
if requests and all(req.maintenance for req in requests):
from .icdb_maintenance import maintenance_counts
counts = maintenance_counts(results)
lines[:2] = ['ICDB 检查异常清单',
f'总数: {len(results)} 未发现异常: {checked} 发现问题: {counts["issues_found"]} '
f'占用: {counts["in_use"]} 无法确认: {counts["unconfirmed"]} '
f'取消: {counts["cancelled"]} 未执行: {counts["skipped"]}']
for req, result in failed:
timings = ' '.join(f'{key}={value:.3f}s' +
('(unfinished)' if key in result.incomplete_timing_phases else '')
@@ -959,6 +1326,8 @@ def write_batch_report(requests, results, root):
path = root/('batch-' + time.strftime('%Y%m%d-%H%M%S') + '-' + uuid4().hex[:6] + '.log')
lines = ['CBB Verify 批量结果',
'流程: LMC 原生 Verify / ReusableCircuit PCB -> Project Integration -> Save/Close -> IsVerifiedReuseBlock READY(金标准)']
if requests and all(req.maintenance for req in requests):
lines = ['ICDB 批量检查结果', '流程: 原生 PCB 打开检查;不执行 Repair、Restore 或 CBB 校验。']
for req, result in zip(requests, results):
detail = _report_field(result.stderr or result.stdout.strip()[:200])
seconds = ' '.join(f'{key}={value:.3f}s' +
+23
View File
@@ -0,0 +1,23 @@
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'
$root = Split-Path $PSScriptRoot -Parent
Import-Module (Join-Path $root 'CBBRefresh.Core.psm1') -Force
$scratch = Join-Path $root ('build\content-check-exit-' + [guid]::NewGuid().ToString('N'))
New-Item -ItemType Directory -Path $scratch | Out-Null
$exe = Join-Path $scratch 'ReuseBlockImporter.exe'
Add-Type -TypeDefinition @'
using System;
public class FakeImporter {
public static int Main(string[] args) {
Console.WriteLine("content checking completed successfully");
return 7;
}
}
'@ -OutputAssembly $exe -OutputType ConsoleApplication
$library = Join-Path $scratch 'test.lmc'
[IO.File]::WriteAllText($library, '')
$result = Invoke-CbbReuseBlockContentCheck -LmcFile $library -BlockName 'CBB' -LibSpec 'test' -DmsLoginConfig 'test' -MentorBin $scratch
if ($result.result -ne 'fail' -or $result.exitCode -ne 7) {
throw 'A nonzero native exit must not pass, even when stdout claims success.'
}
Write-Output 'Content-check exit-code regression passed (no Mentor data opened).'
@@ -0,0 +1,26 @@
{
"source": "Frozen b90a9bb native startup capture: no-history-repair/repair-result.json; HWNDs sanitized. Auxiliary classes/empty titles from coordinator's readback of the same owned native process.",
"startup_shell": {
"hwnd": 100,
"title": "iCDB Project Backup",
"class": "Afx:00400000:b:00010003:00000006:5F991B0D",
"enabled": true,
"children": [
{"hwnd": 401, "text": "", "class": "BCGPSlider:400000:8:10003:10", "id": -1, "enabled": true},
{"hwnd": 402, "text": "Output ", "class": "BCGPControlBar:400000:8:10003:10", "id": 313, "enabled": true},
{"hwnd": 403, "text": "", "class": "#32770", "id": 0, "enabled": true},
{"hwnd": 400, "text": "", "class": "RichEdit20A", "id": 1002, "enabled": true},
{"hwnd": 404, "text": "", "class": "BCGPStatusBar:400000:8:10003:10", "id": 59393, "enabled": true},
{"hwnd": 405, "text": "", "class": "BCGPDockBar:400000:8:10003:10", "id": 59419, "enabled": true},
{"hwnd": 406, "text": "Standard", "class": "BCGPToolBar:400000:8:10003:10", "id": 59392, "enabled": true},
{"hwnd": 407, "text": "Menu Bar", "class": "BCGPToolBar:400000:8:10003:10", "id": 59398, "enabled": true},
{"hwnd": 408, "text": "", "class": "#32770", "id": 59648, "enabled": true}
]
},
"auxiliary_windows": [
{"hwnd": 500, "title": "", "class": "UAC_InputIndicatorOverlayWnd", "enabled": true, "children": []},
{"hwnd": 501, "title": "", "class": "UAC Input Indicator", "enabled": true, "children": []}
],
"loaded_title_prefix": "iCDB Project Backup - ",
"loaded_output": "Checking if project is in use.\r\nProject is not in use. Full iCDB Project Backup's functionality is available.\r\n"
}
+30
View File
@@ -0,0 +1,30 @@
{
"source": "Issue 2 data.zip, verify-86f90ffba911; selected fields only; paths and process identities sanitized",
"limitations": "Logs only. No field database, executable fault reproduction or recovery claim.",
"block": "1GPHY_8211",
"diagnosis": {
"error_code": "ICDB_REPAIR_REQUIRED",
"scope": "project",
"machine": "FIELD-PC",
"session": "2026-10-20 14.03.54-18212",
"database_relative": "Work/database"
},
"native_error": "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:[FIELD-PC] Path:[<library>/ReusableBlocksLP/1GPHY_8211/Work/database] session:[2026-10-20 14.03.54-18212])",
"observed_events": [
{"stage": "pcb_launch", "strategy": "reusable_circuit_direct"},
{"stage": "pcb_launcher_started", "launcher_pid": 11},
{"stage": "pcb_worker_started", "pcb_pid": 12, "binding": "commandline"},
{"stage": "native_failure_logs"},
{"stage": "process_retained", "safe_to_continue": false},
{"stage": "failed", "error": "VERIFY_CANCELLED: stop and normally close target document"}
],
"dialog": {
"pid": 12,
"phase": "PCB_STARTING",
"action": "acknowledge_fatal",
"error_code": "MENTOR_DATABASE_LOAD_FAILED",
"text": "Problem encountered while opening one of the database files. See PCBLogFile.txt for details. Loading of the job has failed. Do you wish to view the log file now?"
},
"original_result": {"status": "FAIL", "error_category": "ICDB_REPAIR_REQUIRED", "error_stage": "PCB_STARTING"},
"original_repair": {"status": "BLOCKED", "detail": "REPAIR_DATABASE_IN_USE"}
}
+183
View File
@@ -0,0 +1,183 @@
{
"hwnd": 100,
"pid": 20,
"process_name": "ExpeditionPCB.exe",
"process_role": "pcb",
"window_class": "#32770",
"title": "Database Restoration",
"phase": "PCB_STARTING",
"controls": [
{
"handle": 101,
"control_id": 65535,
"class_name": "Static",
"name": "",
"automation_id": "65535",
"control_type": "Image",
"enabled": true,
"selected": false,
"checked": false,
"patterns": []
},
{
"handle": 102,
"control_id": 6208,
"class_name": "Static",
"name": "The system has detected this design abnormally terminated the last time it was used. The user has to decide what database (if any) to associate with the design.",
"automation_id": "6208",
"control_type": "Text",
"enabled": true,
"selected": false,
"checked": false,
"patterns": []
},
{
"handle": 103,
"control_id": 6212,
"class_name": "Button",
"name": "Restore Database",
"automation_id": "6212",
"control_type": "Group",
"enabled": true,
"selected": false,
"checked": false,
"patterns": []
},
{
"handle": 104,
"control_id": 6213,
"class_name": "Button",
"name": "Load the last user saved database dated 2026/9/24 23:06.",
"automation_id": "6213",
"control_type": "RadioButton",
"enabled": true,
"selected": false,
"checked": false,
"patterns": [
"Invoke",
"SelectionItem"
]
},
{
"handle": 105,
"control_id": 6206,
"class_name": "Button",
"name": "Load the autosave database dated 2026/9/24 23:06.",
"automation_id": "6206",
"control_type": "RadioButton",
"enabled": true,
"selected": true,
"checked": true,
"patterns": [
"Invoke",
"SelectionItem"
]
},
{
"handle": 106,
"control_id": 6207,
"class_name": "Static",
"name": "This will restore the design to the last autosave state.",
"automation_id": "6207",
"control_type": "Text",
"enabled": true,
"selected": false,
"checked": false,
"patterns": []
},
{
"handle": 107,
"control_id": 6209,
"class_name": "Static",
"name": "This will restore the design to the data from the last user save.",
"automation_id": "6209",
"control_type": "Text",
"enabled": true,
"selected": false,
"checked": false,
"patterns": []
},
{
"handle": 108,
"control_id": 6210,
"class_name": "Static",
"name": "Autosaved changes will be lost.",
"automation_id": "6210",
"control_type": "Text",
"enabled": true,
"selected": false,
"checked": false,
"patterns": []
},
{
"handle": 109,
"control_id": 6211,
"class_name": "Static",
"name": "* Cancelling will load no design.",
"automation_id": "6211",
"control_type": "Text",
"enabled": true,
"selected": false,
"checked": false,
"patterns": []
},
{
"handle": 110,
"control_id": 1,
"class_name": "Button",
"name": "OK",
"automation_id": "1",
"control_type": "Button",
"enabled": true,
"selected": false,
"checked": false,
"patterns": [
"Invoke"
]
},
{
"handle": 111,
"control_id": 2,
"class_name": "Button",
"name": "Cancel",
"automation_id": "2",
"control_type": "Button",
"enabled": true,
"selected": false,
"checked": false,
"patterns": [
"Invoke"
]
},
{
"handle": 100,
"control_id": 0,
"class_name": "#32770",
"name": "Database Restoration",
"automation_id": "",
"control_type": "Window",
"enabled": true,
"selected": false,
"checked": false,
"patterns": [
"Window"
]
},
{
"handle": 0,
"control_id": 0,
"class_name": "",
"name": "",
"automation_id": "",
"control_type": "TitleBar",
"enabled": true,
"selected": false,
"checked": false,
"patterns": [
"Value"
]
}
],
"owner_hwnd": 90,
"diagnostics": []
}
+111
View File
@@ -0,0 +1,111 @@
"""Fault injection at native boundaries; real Windows supervisor-loss check."""
import json
from pathlib import Path
from types import SimpleNamespace
import pytest
from cbb_refresh_verify import mentor_adapter as adapter
from test_verify_worker_stability import exercise_worker
FULL_SAVE = 'LICENSE_OK\nSAVE_OK\nIS_SAVED\nPOST_SAVE_SYNCHRONIZED\nCLOSE_OK\nQUIT_OK\n'
@pytest.mark.parametrize('stage,log,exit_code', [
('startup', '', 0),
('integration', '', 0),
('save', '', 1),
('save', 'LICENSE_OK\nSAVE_START\n', 1),
('save', FULL_SAVE, 7),
('save', FULL_SAVE.replace('CLOSE_OK\n', ''), 0),
('save', FULL_SAVE.replace('IS_SAVED\n', ''), 0),
])
def test_native_disconnect_or_interrupted_save_never_completes(tmp_path, monkeypatch, stage, log, exit_code):
job, _, _ = exercise_worker(tmp_path, monkeypatch,
integration_error='RPC_E_DISCONNECTED: PCB closed during integration' if stage == 'integration' else None)
if stage == 'startup':
from cbb_refresh_verify.pcb_bridge import PcbBridgeError
def disconnected(*a, **k):
raise PcbBridgeError('PCB_EXITED_BEFORE_COM', 'PCB exited before COM was ready')
monkeypatch.setattr('cbb_refresh_verify.pcb_bridge.wait_for_target_document', disconnected)
if stage == 'save':
def interrupted_helper(command, **kwargs):
kwargs['stdout'].write(log)
kwargs['stdout'].flush()
return SimpleNamespace(pid=3, poll=lambda: exit_code, returncode=exit_code)
monkeypatch.setattr(adapter.subprocess, 'Popen', interrupted_helper)
root = Path(job['root'])
request = root/'request.json'
request.write_text(json.dumps(job), encoding='utf-8')
assert adapter.worker_main(request) == 1
result = json.loads((root/'outcome.json').read_text(encoding='utf-8'))
assert result['status'] == 'FAIL'
assert result['safe_to_continue'] is False
events = [json.loads(line) for line in (root/'events.jsonl').read_text(encoding='utf-8').splitlines()]
assert not any(event['stage'] in ('complete', 'saved_and_closed') for event in events)
if stage != 'save':
assert not (root/'save.log').exists()
@pytest.mark.parametrize('outcome', [None, {'status': 'PASS'}])
def test_crashed_worker_cannot_pass_even_with_pass_file(tmp_path, monkeypatch, outcome):
from test_verify_runner import fixture, request
from cbb_refresh_verify.verify_runner import run_verify
fixture(tmp_path)
class CrashedWorker:
desktop = None
returncode = 7
def __init__(self, command, *_args, **_kwargs):
if outcome:
Path(command[-1]).with_name('outcome.json').write_text(json.dumps(outcome))
def poll(self): return 7
def close(self): pass
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', CrashedWorker)
monkeypatch.setattr('cbb_refresh_verify.verify_runner._cleanup_session_processes',
lambda *a, **k: {'safe_to_continue': True, 'remaining_pids': []})
monkeypatch.setattr('cbb_refresh_verify.verify_diagnostics.capture_failure_logs_with_timeout', lambda *a: None)
def must_not_query(*a):
pytest.fail('A crashed writer must not become PASS via a pre-existing READY flag')
result = run_verify(request(tmp_path), port_check=lambda: (True, ''), flag_reader=must_not_query)
assert result.status == 'FAIL'
assert result.safe_to_continue is True # Proven release permits another item; crash stays FAIL.
def test_supervisor_crash_stops_registered_save_helper_but_not_native(tmp_path):
import subprocess, sys, time
import win32api, win32con, win32process, win32event
supervisor = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(30)'])
ready = tmp_path/'processes.json'
script = tmp_path/'worker.py'
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})\n'
'native = subprocess.Popen([sys.executable,"-c","import time; time.sleep(30)"])\n'
'helper = launch_save_helper([sys.executable,"-c","import time; time.sleep(30)"])\n'
f'Path({str(ready)!r}).write_text(json.dumps([native.pid,helper.pid]))\n'
'time.sleep(30)\n', encoding='utf-8')
worker = subprocess.Popen([sys.executable, str(script)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
handles = []
try:
deadline = time.monotonic()+6
while not ready.exists() and worker.poll() is None and time.monotonic()<deadline:
time.sleep(.05)
assert ready.exists()
for pid in json.loads(ready.read_text()):
handles.append(win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION |
win32con.PROCESS_TERMINATE | win32con.SYNCHRONIZE, False, pid))
supervisor.terminate()
supervisor.wait(5)
assert worker.wait(8) == 75
assert win32event.WaitForSingleObject(handles[1], 3000) == win32con.WAIT_OBJECT_0
assert win32process.GetExitCodeProcess(handles[0]) == 259
finally:
for process in (supervisor, worker):
if process.poll() is None: process.terminate()
process.wait(5)
for handle in handles:
if win32process.GetExitCodeProcess(handle) == 259:
win32process.TerminateProcess(handle, 0)
handle.Close()
+75
View File
@@ -0,0 +1,75 @@
from threading import Event, Thread
import time
def test_native_queue_is_fifo_and_waiting_cancel_never_runs_action():
from cbb_refresh_verify.operation_queue import NativeQueue, QueueCancelled
queue = NativeQueue()
holding, release, waiting, cancelled = Event(), Event(), Event(), Event()
order = []
first = Thread(target=lambda: queue.run(lambda: (holding.set(), release.wait(3), order.append('first'))))
first.start(); assert holding.wait(1)
def second():
try: queue.run(lambda: order.append('cancelled'), stop=cancelled, waiting=waiting.set)
except QueueCancelled: pass
second_thread = Thread(target=second); second_thread.start(); assert waiting.wait(1)
cancelled.set(); second_thread.join(1); assert not second_thread.is_alive()
third = Thread(target=lambda: queue.run(lambda: order.append('third')))
third.start(); release.set(); first.join(2); third.join(2)
assert order == ['first', 'third']
def test_background_scan_keeps_ui_usable_and_yields_between_projects(qtbot, tmp_path, monkeypatch):
from test_ui_filters import load_window
from cbb_refresh_verify.verify_runner import VerifyResult
started, release = Event(), Event()
order = []
def verify(request):
order.append(request.block_name)
if request.block_name == 'Beta':
started.set(); release.wait(3)
return VerifyResult('CHECKED')
window = load_window(qtbot, tmp_path, monkeypatch, verifier=verify)
window._run(['Beta', 'Gamma'], maintenance=True)
try:
qtbot.waitUntil(started.is_set)
assert not window.busy and window.search_edit.isEnabled() and window.load_button.isEnabled()
window.search_edit.setText('Gamma')
assert [r.name for r in window.visible_records()] == ['Gamma']
window._start(lambda: order.append('foreground'), lambda _: None)
qtbot.wait(30)
assert order == ['Beta']
release.set()
qtbot.waitUntil(lambda: not window.icdb_task.active and not window.busy)
assert order == ['Beta', 'foreground', 'Gamma']
assert window.search_edit.text() == 'Gamma'
assert window.icdb_repair_button.isEnabled()
finally:
release.set()
def test_unconfirmed_open_is_amber_and_does_not_claim_icdb_damage(qtbot, tmp_path, monkeypatch):
from test_ui_filters import load_window
from cbb_refresh_verify.verify_runner import VerifyResult
window = load_window(qtbot, tmp_path, monkeypatch, verifier=lambda _: VerifyResult('FAIL',
error_category='DATABASE_SAFETY_STOP', stderr='Continue to open read/write?'))
window._run(['Beta'], maintenance=True)
qtbot.waitUntil(lambda: not window.icdb_task.active)
cell = window.cbb_table.item(window._row_by_name['Beta'], 3)
assert '未确认' in cell.text() and 'ICDB 错误' not in cell.text()
assert cell.background().color().name() == '#fff8e1'
def test_later_management_invalidates_old_recovery_offer(qtbot, tmp_path, monkeypatch):
from test_ui_filters import load_window
from test_reimport_recovery import failed_repair
window = load_window(qtbot, tmp_path, monkeypatch,
verifier=lambda _: failed_repair(tmp_path/'old/result.json', safe=True))
window._run(['Beta'], maintenance=True)
qtbot.waitUntil(lambda: not window._icdb_active())
action = next(b for b in window.icdb_summary.buttons() if '副本' in b.text())
assert action.isEnabled()
window._invalidate_check_targets('test.lmc', ['Beta'])
assert not action.isEnabled() and not window._reimport_offers
+122
View File
@@ -0,0 +1,122 @@
"""Background check and foreground queue interaction regressions."""
from threading import Event
import pytest
from test_ui_filters import load_window
from cbb_refresh_verify.verify_runner import VerifyResult
def background(window, qtbot):
started, release = Event(), Event()
calls=[]
def verify(request):
calls.append(request.block_name)
if request.block_name=='Beta':
started.set()
assert release.wait(5)
return VerifyResult('CHECKED')
window.verifier=verify
window._run(['Beta','Gamma'],maintenance=True)
qtbot.waitUntil(started.is_set)
return release,calls
def finish(window, qtbot, release):
release.set()
window.icdb_task.resume()
qtbot.waitUntil(lambda:not window._icdb_active() and not window.busy)
qtbot.waitUntil(lambda:window.pool.activeThreadCount()==0)
def test_stop_whole_queue_does_not_resume_background_checks(qtbot,tmp_path,monkeypatch):
window=load_window(qtbot,tmp_path,monkeypatch)
release,calls=background(window,qtbot)
try:
window._start(lambda:None,lambda _:None)
qtbot.waitUntil(lambda:bool(window.native_queue.pending))
window.stop_button.click()
release.set()
qtbot.waitUntil(lambda:not window._icdb_active() and not window.busy)
assert calls==['Beta'],f'Cancelled queue still ran: {calls}'
finally:finish(window,qtbot,release)
def test_check_progress_survives_queued_verify(qtbot,tmp_path,monkeypatch):
window=load_window(qtbot,tmp_path,monkeypatch,
status_refresher=lambda names,path:{name:'PENDING' for name in names})
release,calls=background(window,qtbot)
try:
assert not window.icdb_progress.isHidden()
window._run(['Gamma'])
assert not window.icdb_progress.isHidden(),'Queued verify hid the active check progress'
finally:finish(window,qtbot,release)
def test_release_failure_is_not_labelled_as_read_write_prompt(qtbot,tmp_path,monkeypatch):
window=load_window(qtbot,tmp_path,monkeypatch,verifier=lambda request:VerifyResult(
'FAIL',error_category='DATABASE_SAFETY_STOP',safe_to_continue=False,
stderr='PCB_RELEASE_UNCONFIRMED: launcher still running'))
window._run(['Beta'],maintenance=True)
qtbot.waitUntil(lambda:not window._icdb_active())
cell=window.cbb_table.item(window._row_by_name['Beta'],3)
assert '读写确认' not in cell.text(),cell.text()
def test_pending_check_skips_a_target_that_has_become_ready(qtbot,tmp_path,monkeypatch):
window=load_window(qtbot,tmp_path,monkeypatch)
release,calls=background(window,qtbot)
try:
window.icdb_task.pause()
release.set()
qtbot.waitUntil(lambda:len(window.icdb_task.results)==1 and not window.icdb_task.running)
window._apply_refreshed_records((('Gamma',),{'Gamma':'READY'},{},''))
assert 'Gamma' in window.ready_names
window.icdb_task.resume()
qtbot.waitUntil(lambda:not window._icdb_active())
assert calls==['Beta'],f'Already READY target was opened again: {calls}'
finally:finish(window,qtbot,release)
def test_worker_refresh_excludes_ready_before_any_gui_result_callback(qtbot,tmp_path,monkeypatch):
window=load_window(qtbot,tmp_path,monkeypatch,
status_refresher=lambda names,path:{name:'READY' for name in names})
release,calls=background(window,qtbot)
try:
window._start(lambda:window._read_affected_records(('Gamma',)),lambda payload:None)
qtbot.waitUntil(lambda:bool(window.native_queue.pending))
release.set()
qtbot.waitUntil(lambda:not window._icdb_active() and not window.busy)
assert window._records_by_name['Gamma'].status=='UNKNOWN'
assert calls==['Beta']
assert window.icdb_task.results[1].status=='SKIPPED'
assert 'READY' in window.icdb_task.results[1].stderr
finally:finish(window,qtbot,release)
def test_another_library_ready_status_cannot_skip_this_library_target(qtbot,tmp_path,monkeypatch):
window=load_window(qtbot,tmp_path,monkeypatch)
release,calls=background(window,qtbot)
try:
window._publish_check_statuses('other.lmc',{'Gamma':'READY'})
release.set()
qtbot.waitUntil(lambda:not window._icdb_active())
assert calls==['Beta','Gamma']
finally:finish(window,qtbot,release)
@pytest.mark.parametrize('detail,safe,expected',[
('Continue to open the design with read/write access permission?',True,'读写确认'),
('PCB_RELEASE_UNCONFIRMED: launcher still running',False,'释放未确认'),
('ICDB_RELEASE_UNCONFIRMED: database still occupied',False,'释放未确认'),
('PCB_SESSION_ACTIVE: target already open',True,'会话或数据库状态待确认'),
])
def test_safety_stop_label_tracks_actual_reason(qtbot,tmp_path,monkeypatch,detail,safe,expected):
window=load_window(qtbot,tmp_path,monkeypatch,verifier=lambda request:VerifyResult(
'FAIL',error_category='DATABASE_SAFETY_STOP',safe_to_continue=safe,stderr=detail))
window._run(['Beta'],maintenance=True)
qtbot.waitUntil(lambda:not window._icdb_active())
cell=window.cbb_table.item(window._row_by_name['Beta'],3)
assert expected in cell.text()
assert cell.toolTip()==detail
assert cell.background().color().name()=='#fff8e1'
+390
View File
@@ -0,0 +1,390 @@
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 not list(request.evidence_dir.rglob('library-before'))
assert not list(request.evidence_dir.rglob('source-before'))
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())
from cbb_refresh_verify import owner_probe
import subprocess
monkeypatch.setattr(owner_probe.subprocess, 'run', lambda command, **kw:
subprocess.CompletedProcess(command, owner_probe.owner_probe_main(command[-1])))
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
assert any("Name='viewdraw.exe'" in query for query in queries)
def test_idle_guard_ignores_unrelated_project_and_prefix_sibling(recovery_files, monkeypatch):
from cbb_refresh_verify.backup_recovery import _idle_check
from cbb_refresh_verify import mentor_adapter
request, original, _ = recovery_files
unrelated = original.parent.with_name(original.parent.name+'Old')/'PCB/A.pcb'
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [(123, '', str(unrelated))])
monkeypatch.setattr(mentor_adapter, '_process_details', lambda name:
[(123, 'ExpeditionPCB.exe', f'ExpeditionPCB.exe "{unrelated}" -ReusableCircuit', 0)]
if name == 'ExpeditionPCB.exe' else [])
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
def test_idle_guard_rejects_exact_target_process(recovery_files, monkeypatch):
from cbb_refresh_verify.backup_recovery import _idle_check
from cbb_refresh_verify import mentor_adapter
request, original, _ = recovery_files
target = original.parent/'PCB/A.pcb'
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
monkeypatch.setattr(mentor_adapter, '_process_details', lambda name:
[(123, 'ExpeditionPCB.exe', f'ExpeditionPCB.exe "{target}" -ReusableCircuit', 0)]
if name == 'ExpeditionPCB.exe' else [])
with pytest.raises(ValueError, match='TARGET_NATIVE_OWNER_ACTIVE'):
_idle_check(request.lmc_file, original, target)
def test_prelaunch_recovery_rejection_has_no_unreleased_session(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, _, source = recovery_files
def reject(*args): raise ValueError('target unavailable before launch')
result = recover_from_backup(request, source, idle_check=reject,
verifier=lambda *a, **k: pytest.fail('prelaunch rejection must not start native'))
assert result.status == 'BLOCKED'
assert result.safe_to_continue
def test_report_write_failure_does_not_lose_prelaunch_release_fact(recovery_files, monkeypatch):
from cbb_refresh_verify.backup_recovery import recover_from_backup
import win32event
from uuid import uuid4
create_mutex = win32event.CreateMutex
monkeypatch.setattr(win32event, 'CreateMutex', lambda security, owned, name:
create_mutex(security, owned, name+'-test-'+uuid4().hex))
request, _, source = recovery_files
original_write = Path.write_text
def write(path, *args, **kwargs):
if path.name == 'recovery-result.json': raise OSError('report disk unavailable')
return original_write(path, *args, **kwargs)
monkeypatch.setattr(Path, 'write_text', write)
def reject(*args): raise ValueError('prelaunch unavailable')
result = recover_from_backup(request, source, idle_check=reject)
assert result.status == 'BLOCKED' and result.safe_to_continue
assert 'report disk unavailable' in result.stderr
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
def test_logs_and_unrelated_cbb_changes_after_snapshot_do_not_block_install(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
(source.parent/'session.log').write_bytes(b'snapshot log')
other = project(request.lmc_file.parent/'ReusableBlocksLP/B/Work', 'B', b'unrelated')
calls = []
def verify(req, **kwargs):
calls.append(req)
if len(calls) == 1:
(source.parent/'session.log').write_bytes(b'updated source log')
(original.parent/'new.log').write_bytes(b'new target log')
(other.parent/'database/icdb.dat').write_bytes(b'unrelated update')
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 (original.parent/'database/icdb.dat').read_bytes() == b'healthy'
assert (other.parent/'database/icdb.dat').read_bytes() == b'unrelated update'
staged = calls[0].lmc_file.parent/'ReusableBlocksLP/A/Work'
assert (staged/'session.log').read_bytes() == b'snapshot log'
@pytest.mark.parametrize('location,change', [
('source', 'edit'), ('source', 'delete'), ('source', 'add'),
('target', 'delete'), ('target', 'add'), ('cert', 'edit'), ('shared', 'edit'),
])
def test_primary_conflicts_preserve_target_and_validation_evidence(recovery_files, location, change):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
if location == 'source':
conflict = source.parent/'database/icdb.dat'
elif location == 'target':
conflict = original.parent/'PCB/Layout/LayoutDB.lyt'
elif location == 'cert':
conflict = original.parent.parent/'Cert/A.prj'
else:
conflict = request.lmc_file.parent/'SymbolLibs/__ReusableBlocksSymb/icdb.dat'
conflict.parent.mkdir(parents=True, exist_ok=True)
if location in ('cert', 'shared'):
conflict.write_bytes(b'before')
calls = []
def verify(*args, **kwargs):
calls.append(args)
if change == 'delete':
conflict.unlink()
elif change == 'add':
(conflict.parent/'new-engineering.bin').write_bytes(b'new')
else:
conflict.write_bytes(b'concurrent edit')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert len(calls) == 1
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
assert not list(original.parent.parent.glob('Work.before-restore-*'))
assert list(request.evidence_dir.rglob('library-baseline-manifest.json'))
assert list(request.evidence_dir.rglob('source-manifest.json'))
assert calls[0][0].lmc_file.is_file()
assert not list(request.evidence_dir.rglob('library-before'))
def test_source_conflict_while_preparing_incoming_work_blocks_install(recovery_files, monkeypatch):
from cbb_refresh_verify import backup_recovery as recovery
request, original, source = recovery_files
copy = recovery._copy_verified
def copy_then_change_source(src, dst, **kwargs):
result = copy(src, dst, **kwargs)
if dst.name.startswith('Work.restore-'):
(source.parent/'database/icdb.dat').write_bytes(b'late concurrent change')
return result
monkeypatch.setattr(recovery, '_copy_verified', copy_then_change_source)
result = recovery.recover_from_backup(request, source,
verifier=lambda *a, **k: VerifyResult('PASS', library_flag='GREEN'), idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_source_address_record_is_rechecked_after_validation(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
address = source.parent/'database/cdbsvr/sAddress.adr'
def idle(library, project, pcb):
if project == source and address.exists():
raise ValueError('Source database ownership is still active')
def verify(*args, **kwargs):
address.parent.mkdir(parents=True, exist_ok=True)
address.write_bytes(b'live owner')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=idle)
assert result.status == 'BLOCKED'
assert 'ownership' in result.stderr
assert address.read_bytes() == b'live owner'
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
@pytest.mark.parametrize('name', ['Logs', 'tEmP', 'bAcKuP', 'Output'])
@pytest.mark.parametrize('role', ['Work', 'Cert'])
def test_cbb_names_matching_runtime_labels_do_not_hide_target_conflicts(tmp_path, monkeypatch, name, role):
from cbb_refresh_verify.backup_recovery import recover_from_backup
monkeypatch.setattr(Path, 'home', lambda: tmp_path/'profile')
library = tmp_path/'target/target.lmc'
original = project(library.parent/f'ReusableBlocksLP/{name}/Work', name, b'damaged')
library.write_bytes(b'library')
source = project(tmp_path/'backup/Work', name, b'healthy')
request = VerifyRequest(library, name, tmp_path/'evidence')
conflict = original.parent.parent/role/'database/icdb.dat'
conflict.parent.mkdir(parents=True, exist_ok=True)
if role == 'Cert':
conflict.write_bytes(b'cert before')
calls = []
def verify(*args, **kwargs):
calls.append(args)
conflict.write_bytes(b'concurrent target edit')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert len(calls) == 1
assert conflict.read_bytes() == b'concurrent target edit'
assert not list(original.parent.parent.glob('Work.before-restore-*'))
@pytest.mark.parametrize('relative', ['SymbolLibs/temp/icdb.dat', 'SymbolLibs/Temp_a/device.sym',
'SharedDependency/hdl/Logs/design.v'])
def test_shared_partition_engineering_conflicts_block_install(recovery_files, relative):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
conflict = request.lmc_file.parent/relative
conflict.parent.mkdir(parents=True, exist_ok=True)
conflict.write_bytes(b'shared before')
calls = []
def verify(*args, **kwargs):
calls.append(args)
conflict.write_bytes(b'concurrent shared edit')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert len(calls) == 1
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
assert conflict.read_bytes() == b'concurrent shared edit'
+98
View File
@@ -0,0 +1,98 @@
from pathlib import Path
from threading import Event
from cbb_refresh_verify.verify_runner import VerifyRequest, VerifyResult
import pytest
@pytest.fixture(autouse=True)
def accept_manual_backup_reminder(monkeypatch):
from PySide6.QtWidgets import QMessageBox
monkeypatch.setattr(QMessageBox, 'question', lambda *a, **k: QMessageBox.Yes)
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_non_ready_dialog_and_failure_retains_ready_untargeted(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,
status_refresher=lambda names, _: {name: 'UNKNOWN' for name in names})
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() == 'B'
dialog.started.emit('B')
assert window.busy
assert 'A' in window.ready_names
dialog.completed.emit('B', VerifyResult('FAIL', stderr='无法确认', safe_to_continue=False))
assert window.cbb_table.item(1, 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
+258
View File
@@ -0,0 +1,258 @@
"""Only live clients stop a batch; native writes are replaced by fixtures."""
import json
from pathlib import Path
from threading import Event
import pytest
from cbb_refresh_verify import verify_runner as runner
from test_verify_runner import fixture, request, PORTS_OK
@pytest.mark.parametrize('status,detail', [('FAIL', 'UNKNOWN_DIALOG: native prompt'),
('TIMEOUT', 'native operation timed out')])
@pytest.mark.parametrize('released', [True, False])
def test_batch_continuation_follows_actual_release(tmp_path, monkeypatch, status, detail, released):
fixture(tmp_path)
launches = []
class Worker:
desktop = None
returncode = 1
def __init__(self, command, *_a, **_k):
launches.append(command)
Path(command[-1]).with_name('outcome.json').write_text(json.dumps({
'status': status, 'stderr': detail, 'safe_to_continue': False}))
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': released, 'remaining_pids': [] if released else [123]})
monkeypatch.setattr('cbb_refresh_verify.verify_diagnostics.capture_failure_logs_with_timeout', lambda *_: None)
req = request(tmp_path)
try:
results = runner.run_batch([req, req], verifier=lambda r: runner.run_verify(r, port_check=PORTS_OK))
assert results[0].status == status and results[0].safe_to_continue is released
assert len(launches) == (2 if released else 1)
assert results[1].status == (status if released else 'SKIPPED')
finally:
from cbb_refresh_verify import library_lock as locks
with locks._guard:
owner = locks._owners.pop(locks.LibraryLock(req.lmc_file).key, None)
if owner: owner['handle'].Close()
def test_item_failure_with_confirmed_release_does_not_stop_unrelated_items(tmp_path):
from cbb_refresh_verify.verify_runner import VerifyRequest, VerifyResult
library = tmp_path/'library.lmc'; library.touch()
requests = [VerifyRequest(library, name, tmp_path/'evidence') for name in ('A', 'B')]
calls = []
def verify(request):
calls.append(request.block_name)
return VerifyResult('FAIL' if request.block_name == 'A' else 'PASS',
stderr='单项失败但会话已释放' if request.block_name == 'A' else '',
safe_to_continue=True)
results = runner.run_batch(requests, verifier=verify)
assert calls == ['A', 'B']
assert [result.status for result in results] == ['FAIL', 'PASS']
def test_stop_worker_escalates_only_after_cooperative_deadline():
calls = []
class Worker:
stopped = False
def request_stop(self): calls.append('cancel')
def wait(self, timeout=5):
calls.append('wait')
if not self.stopped: raise TimeoutError()
def kill(self): calls.append('client_stop'); self.stopped = True
def poll(self): return 1 if self.stopped else None
assert runner._stop_worker(Worker(), timeout=.1) is True
assert calls == ['cancel', 'wait', 'client_stop', 'wait']
def test_cancel_reaches_current_supervised_worker(tmp_path, monkeypatch):
fixture(tmp_path)
stop = Event()
cancelled = []
class Worker:
desktop = None
returncode = None
def __init__(self, command, *_a, **_k):
self.job = json.loads(Path(command[-1]).read_text('utf-8'))
stop.set()
def bind_cancellation(self, path): self.cancel = Path(path)
def request_stop(self):
self.cancel.touch(); cancelled.append(self.cancel)
self.returncode = 1
def wait(self, **_k): return 1
def poll(self): return self.returncode
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', lambda *_: None)
result = runner.run_verify(request(tmp_path), stop=stop, port_check=PORTS_OK)
assert result.status == 'CANCELLED' and result.safe_to_continue
assert len(cancelled) == 1 and cancelled[0].is_file()
@pytest.mark.parametrize('text,expected', [
('content checking completed successfully! 0 errors, 0 warnings', 'PASS'),
('content checking completed successfully! 10 errors', 'FAIL'),
('content checking completed successfully! error: missing symbol', 'FAIL'),
('content checking completed successfully! 0 errors\nERROR: cannot connect', 'FAIL'),
])
def test_zero_error_count_does_not_block_content_check(text, expected):
assert runner.classify_output(0, text) == expected
@pytest.mark.parametrize('codec', ['utf-16', 'utf-8-sig', 'mbcs'])
def test_preflight_reads_native_project_encodings(tmp_path, codec):
work = fixture(tmp_path)
(work/'CBB1.prj').write_bytes(('# 中文工程\nKEY PCBDesignPath "PCB\\actual.pcb"\n').encode(codec))
project, pcb = runner.preflight(request(tmp_path))
assert pcb == work/'PCB/actual.pcb'
def test_unrelated_pcb_does_not_block_target_before_launch(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)
monkeypatch.setattr(adapter, 'pcb_processes', lambda: ((999, 'ExpeditionPCB.exe', '"ExpeditionPCB.exe" "C:\\other\\board.pcb"'),))
assert execute()['status'] == 'PASS'
assert any(e['stage'] == 'pcb_launch' for e in events)
def test_sampling_ports_only_warn_by_default(tmp_path, monkeypatch):
fixture(tmp_path)
launches, warnings = [], []
class Worker:
desktop = None
returncode = 0
def __init__(self, command, *_a, **_k):
launches.append(command)
Path(command[-1]).with_name('outcome.json').write_text('{"status":"PASS"}')
def poll(self): return 0
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})
result = runner.run_verify(request(tmp_path), port_check=lambda: (False, 'sample unavailable'),
flag_reader=lambda *_: __import__('cbb_refresh_verify.status_bridge', fromlist=['BridgeResult']).BridgeResult('READY', 'IsVerifiedReuseBlock', 1),
progress=warnings.append)
assert launches and result.status == 'PASS'
assert any(e['stage'] == 'port_warning' for e in warnings)
def test_cleanup_includes_late_native_descendant_without_pcb_argument(monkeypatch):
from cbb_refresh_verify import mentor_adapter as adapter
rows = [(10, 'ExpeditionPCB.exe', '', 1), (11, 'ExpeditionPCB.exe', '', 10),
(99, 'ExpeditionPCB.exe', '', 77)]
monkeypatch.setattr(adapter, '_process_details', lambda name: rows if name == 'ExpeditionPCB.exe' else [])
result = adapter.cleanup_verify_processes(None, None, 10, baseline_pids={99})
assert not result['safe_to_continue'] and result['remaining_pids'] == [10, 11]
def test_save_client_without_worker_still_prevents_continuation(tmp_path, monkeypatch):
fixture(tmp_path)
class Worker:
desktop = None
returncode = 1
def __init__(self, command, *_a, **_k):
Path(command[-1]).with_name('outcome.json').write_text('{"status":"FAIL"}')
def poll(self): return 1
def close(self): pass
def automation_release_state(self): return {'safe_to_continue': False, 'remaining_pids': [333]}
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', lambda *_: None)
req = request(tmp_path)
try:
result = runner.run_verify(req, port_check=PORTS_OK)
assert not result.safe_to_continue
proof = json.loads(result.evidence_path.with_name('session-release.json').read_text('utf-8'))
assert proof['worker_exited'] is True
assert proof['automation_release']['remaining_pids'] == [333]
assert proof['remaining_pids'] == [333]
finally:
from cbb_refresh_verify import library_lock as locks
with locks._guard:
owner = locks._owners.pop(locks.LibraryLock(req.lmc_file).key, None)
if owner: owner['handle'].Close()
def test_closed_desktop_worker_keeps_exit_status_without_using_closed_handle(monkeypatch):
from types import SimpleNamespace
from cbb_refresh_verify import desktop_worker as desktop
worker = desktop.DesktopWorker.__new__(desktop.DesktopWorker)
handle = SimpleNamespace(closed=False)
def close(): handle.closed = True
handle.Close = close
worker.handle = handle
worker.job = SimpleNamespace(Close=lambda: None)
worker.desktop = None; worker.companions = []; worker.companion_pids = []
def code(h):
assert not h.closed, 'Read from a closed Win32 process handle'
return 1
monkeypatch.setattr(desktop.win32process, 'GetExitCodeProcess', code)
worker.close()
assert worker.poll() == 1
worker.close() # Idempotent cleanup.
def test_native_process_queries_use_bounded_shared_helper(monkeypatch):
from cbb_refresh_verify import mentor_adapter as adapter
calls = []
def query(names):
calls.append(names)
return [{'pid': 12, 'executable': 'ExpeditionPCB.exe', 'command': 'native', 'parent': 11}]
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', query)
assert adapter._process_details('ExpeditionPCB.exe') == [(12, 'ExpeditionPCB.exe', 'native', 11)]
assert calls == [('ExpeditionPCB.exe',)]
@pytest.mark.parametrize('script', ['save_verified_block.vbs', 'close_failed_block.vbs'])
def test_save_and_failure_close_clients_are_both_tracked(script, monkeypatch):
from cbb_refresh_verify import desktop_worker as desktop
worker = desktop.DesktopWorker.__new__(desktop.DesktopWorker)
worker.pid = 11; worker._closed = True; worker._exit_code = 1
command = f'cscript.exe //nologo "{Path(desktop.__file__).with_name(script)}" "C:\\fixture\\design.prj"'
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda *_a, **_k: [
{'pid': 22, 'parent': 11, 'command': command},
{'pid': 33, 'parent': 99, 'command': command},
{'pid': 44, 'parent': 11, 'command': 'cscript.exe unrelated.vbs'}])
proof = worker.automation_release_state()
assert proof['safe_to_continue'] is False and proof['remaining_pids'] == [22]
def test_watchdog_with_cancel_signal_stops_clients_after_supervisor_exit(tmp_path):
import subprocess, sys, time
import win32api, win32con, win32process
supervisor = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(30)'])
script = tmp_path/'watchdog.py'; ready = tmp_path/'ready.json'; cancel = tmp_path/'cancel.signal'
script.write_text(
'import sys, subprocess, 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}, stop_clients=True)\n'
'native = subprocess.Popen([sys.executable,"-c","import time; time.sleep(30)"])\n'
'client = launch_save_helper([sys.executable,"-c","import time; time.sleep(30)"])\n'
f'Path({str(ready)!r}).write_text(json.dumps([native.pid,client.pid]))\n'
'time.sleep(30)\n', encoding='utf-8')
worker = subprocess.Popen([sys.executable, str(script)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
handles = []
try:
deadline = time.monotonic()+10
while not ready.exists() and worker.poll() is None and time.monotonic()<deadline:
time.sleep(.05)
assert ready.exists()
for pid in json.loads(ready.read_text()):
handles.append(win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_TERMINATE, False, pid))
supervisor.terminate(); supervisor.wait(5)
assert worker.wait(10) == 75 and cancel.is_file()
assert win32process.GetExitCodeProcess(handles[0]) == 259
assert win32process.GetExitCodeProcess(handles[1]) != 259
finally:
for p in (supervisor, worker):
if p.poll() is None: p.terminate()
p.wait(5)
for h in handles:
if win32process.GetExitCodeProcess(h) == 259: win32process.TerminateProcess(h, 0)
h.Close()
+45 -3
View File
@@ -84,11 +84,30 @@ def test_scan_reuses_checkpoint_and_queries_only_missing(tmp_path):
encoding="utf-8",
)
bridge = FakeBridge()
records = BatchStatusSession(bridge).scan(["A", "B"], lmc, checkpoint)
records = BatchStatusSession(bridge).scan(["A", "B"], lmc, checkpoint, resume=True)
assert bridge.requests == ["B"]
assert {record.block_name for record in records} == {"A", "B"}
def test_default_scan_refreshes_cached_ready_after_payload_change(tmp_path):
lmc = tmp_path/'library.lmc'; lmc.write_bytes(b'library')
checkpoint = tmp_path/'scan.jsonl'
BatchStatusSession(FakeBridge()).scan(['A'], lmc, checkpoint)
# The lightweight fingerprint cannot prove payload status is unchanged.
fingerprint = fingerprint_library(lmc)
(tmp_path/'payload.pcb').write_bytes(b'native edit without LMC change')
assert fingerprint_library(lmc) == fingerprint
class PendingBridge(FakeBridge):
def query(self, *args, **kwargs):
self.requests.append(args[1])
return BridgeResult('PENDING', 'fake')
bridge = PendingBridge()
records = BatchStatusSession(bridge).scan(['A'], lmc, checkpoint)
assert [record.status for record in records] == ['PENDING']
assert bridge.requests == ['A']
assert len(checkpoint.read_text('utf-8').splitlines()) == 1
def test_timeout_isolated_and_later_item_continues(tmp_path):
lmc = tmp_path / "mentor_lib.lmc"
lmc.write_bytes(b"library")
@@ -99,7 +118,7 @@ def test_timeout_isolated_and_later_item_continues(tmp_path):
assert records[1].status == "PENDING"
def test_protocol_path_mismatch_stops_repeating_same_global_failure(tmp_path):
def test_protocol_path_mismatch_records_each_queried_item(tmp_path):
class BrokenProtocolBridge:
def __init__(self):
self.requests = []
@@ -116,7 +135,7 @@ def test_protocol_path_mismatch_stops_repeating_same_global_failure(tmp_path):
['A', 'B', 'C'], lmc, tmp_path / 'scan.jsonl'
)
assert bridge.requests == ['A']
assert bridge.requests == ['A', 'B', 'C']
assert [record.status for record in records] == ['MALFORMED'] * 3
@@ -172,3 +191,26 @@ def test_authoritative_status_map_never_reuses_previous_scan_status(tmp_path, mo
assert first == {'A': 'PENDING'}
assert second == {'A': 'READY'}
assert calls == ['A', 'A']
def test_retry_rechecks_failed_scan_without_library_changes(tmp_path):
lmc = tmp_path/'library.lmc'; lmc.write_bytes(b'library')
checkpoint = tmp_path/'scan.jsonl'
first = BatchStatusSession(FakeBridge(timeout_name='A')).scan(['A', 'B'], lmc, checkpoint)
assert first[0].status == 'TIMEOUT'
bridge = FakeBridge()
second = BatchStatusSession(bridge).scan(['A', 'B'], lmc, checkpoint, resume=True)
assert bridge.requests == ['A']
assert second[0].status == 'READY'
def test_missing_x86_runtime_does_not_restart_for_every_cbb(tmp_path):
class BrokenBridge(FakeBridge):
def query(self, library, name, **kwargs):
self.requests.append(name)
raise BridgeResponseError('状态桥进程失败: -1073741515')
lmc = tmp_path/'library.lmc'; lmc.write_bytes(b'library')
bridge = BrokenBridge()
result = BatchStatusSession(bridge).scan(['A', 'B', 'C'], lmc, tmp_path/'scan.jsonl')
assert bridge.requests == ['A']
assert [row.status for row in result] == ['UNAVAILABLE'] * 3
+1 -1
View File
@@ -82,5 +82,5 @@ def test_fingerprint_change_does_not_reuse_checkpoint(tmp_path):
from cbb_refresh_verify.status_bridge import BridgeResult
return BridgeResult("PENDING", "fake")
bridge = Bridge()
BatchStatusSession(bridge).scan(["A"], lmc, checkpoint)
BatchStatusSession(bridge).scan(["A"], lmc, checkpoint, resume=True)
assert bridge.requests == ["A"]
+207
View File
@@ -0,0 +1,207 @@
import pytest
@pytest.mark.parametrize('failure, expected', [
('desktop', []),
('job', ['desktop']),
('process', ['job', 'desktop']),
('thread', ['thread', 'terminate', 'process', 'job', 'desktop']),
])
def test_constructor_rolls_back_allocated_resources(monkeypatch, failure, expected):
import cbb_refresh_verify.desktop_worker as module
closed = []
error = RuntimeError(failure + ' failed')
class FakeJob:
def Close(self):
closed.append('job')
class FakeDesktop:
def CloseDesktop(self):
closed.append('desktop')
class FakeProcess:
def Close(self):
closed.append('process')
class FakeThread:
def Close(self):
closed.append('thread')
raise error
def allocate(stage, value):
if failure == stage:
raise error
return value
process = FakeProcess()
monkeypatch.setattr(module.win32service, 'CreateDesktop',
lambda *args: allocate('desktop', FakeDesktop()))
monkeypatch.setattr(module.win32job, 'CreateJobObject',
lambda *args: allocate('job', FakeJob()))
monkeypatch.setattr(module.win32process, 'STARTUPINFO', lambda: type('Startup', (), {})())
monkeypatch.setattr(module.win32process, 'CreateProcess',
lambda *args: allocate('process', (process, FakeThread(), 321, 1)))
def terminate(handle, code):
assert handle is process
closed.append('terminate')
monkeypatch.setattr(module.win32process, 'TerminateProcess', terminate)
with pytest.raises(RuntimeError) as caught:
module.DesktopWorker(['worker.exe'], 'PrivateDesk')
assert caught.value is error
assert closed == expected
def test_library_flag_loads_ui_dependencies_before_creating_private_desktop(monkeypatch, tmp_path):
import builtins
import win32service
import cbb_refresh_verify.mentor_adapter as module
created = []
original_import = builtins.__import__
executable = tmp_path / 'LibraryManager.exe'
executable.touch()
def deny_pywinauto(name, *args, **kwargs):
if name == 'pywinauto' or name.startswith('pywinauto.'):
raise ImportError('pywinauto unavailable')
return original_import(name, *args, **kwargs)
monkeypatch.setattr(builtins, '__import__', deny_pywinauto)
monkeypatch.setattr(module, 'library_manager_path', lambda: executable)
monkeypatch.setattr(win32service, 'CreateDesktop',
lambda *args: created.append(args))
with pytest.raises(ImportError, match='pywinauto unavailable'):
module.read_library_flag('library.lmc', 'Block')
assert created == []
@pytest.mark.parametrize('reader', ['read_library_flag', 'read_library_tree_image_map'])
def test_reader_does_not_create_desktop_before_preparation_finishes(monkeypatch, tmp_path, reader):
import win32service
import cbb_refresh_verify.mentor_adapter as module
closed = []
class FakeDesktop:
def CloseDesktop(self):
closed.append('closed')
class InvalidLibrary:
def __fspath__(self):
raise ValueError('invalid library path')
executable = tmp_path / 'LibraryManager.exe'
executable.touch()
monkeypatch.setattr(module, 'library_manager_path', lambda: executable)
monkeypatch.setattr(win32service, 'CreateDesktop',
lambda *args: closed.append('created') or FakeDesktop())
with pytest.raises(ValueError, match='invalid library path'):
getattr(module, reader)(InvalidLibrary(), 'Block')
assert closed == []
@pytest.mark.parametrize('reader', ['read_library_flag', 'read_library_tree_image_map'])
def test_reader_closes_desktop_when_process_launch_fails(monkeypatch, tmp_path, reader):
import win32service
import win32process
import cbb_refresh_verify.mentor_adapter as module
closed = []
class FakeDesktop:
def CloseDesktop(self):
closed.append('desktop')
def fail(*args):
raise RuntimeError('launch failed')
executable = tmp_path / 'LibraryManager.exe'
executable.touch()
monkeypatch.setattr(module, 'library_manager_path', lambda: executable)
monkeypatch.setattr(win32service, 'CreateDesktop', lambda *args: FakeDesktop())
monkeypatch.setattr(win32process, 'CreateProcess', fail)
if reader == 'read_library_flag':
flag, detail = module.read_library_flag(tmp_path / 'library.lmc', 'Block')
assert flag == module.FLAG_UNKNOWN
assert 'launch failed' in detail
else:
with pytest.raises(RuntimeError, match='launch failed'):
module.read_library_tree_image_map(tmp_path / 'library.lmc', ['Block'])
assert closed == ['desktop']
def test_constructor_releases_private_desktop_when_process_launch_fails(monkeypatch):
import cbb_refresh_verify.desktop_worker as module
class Handle:
def __init__(self):
self.closed = False
def Close(self):
self.closed = True
def CloseDesktop(self):
self.closed = True
desktop = Handle()
job = Handle()
monkeypatch.setattr(module.win32service, 'CreateDesktop', lambda *args: desktop)
monkeypatch.setattr(module.win32job, 'CreateJobObject', lambda *args: job)
monkeypatch.setattr(module.win32process, 'STARTUPINFO', lambda: type('Startup', (), {})())
monkeypatch.setattr(module.win32process, 'CreateProcess',
lambda *args: (_ for _ in ()).throw(RuntimeError('launch failed')))
with pytest.raises(RuntimeError, match='launch failed') as caught:
module.DesktopWorker(['worker.exe'], 'PrivateDesk')
assert desktop.closed is True
assert job.closed is True
assert caught.value.worker_launch_release == {
'process_created': False, 'safe_to_continue': True, 'worker_exited': True, 'remaining_pids': []}
def test_partial_launch_cleanup_never_claims_native_descendants_released(monkeypatch):
import cbb_refresh_verify.desktop_worker as module
class Handle:
def Close(self): pass
def CloseDesktop(self): pass
class Thread:
def Close(self): raise OSError('thread handle cleanup failed')
monkeypatch.setattr(module.win32service, 'CreateDesktop', lambda *args: Handle())
monkeypatch.setattr(module.win32job, 'CreateJobObject', lambda *args: Handle())
monkeypatch.setattr(module.win32process, 'STARTUPINFO', lambda: type('Startup', (), {})())
monkeypatch.setattr(module.win32process, 'CreateProcess', lambda *args: (Handle(), Thread(), 123, 456))
terminated = []
monkeypatch.setattr(module.win32process, 'TerminateProcess', lambda *args: terminated.append(args))
with pytest.raises(OSError, match='thread handle cleanup failed') as caught:
module.DesktopWorker(['worker.exe'], 'PrivateDesk')
assert caught.value.worker_launch_release == {
'process_created': True, 'safe_to_continue': False, 'worker_exited': False, 'remaining_pids': [123]}
assert len(terminated) == 1
def test_release_probe_allows_measured_owner_helper_startup_time(monkeypatch):
import cbb_refresh_verify.desktop_worker as module
from cbb_refresh_verify import owner_probe
worker = module.DesktopWorker.__new__(module.DesktopWorker)
worker.pid = 123
worker._closed = True
worker._exit_code = 1
def query(names, *, timeout_seconds):
# Real helper measured ~4.75s including interpreter + COM startup.
if timeout_seconds < 5:
raise RuntimeError('OWNER_QUERY_TIMEOUT')
return []
monkeypatch.setattr(owner_probe, 'query_owners', query)
assert worker.automation_release_state() == {'safe_to_continue': True, 'remaining_pids': []}
Loaded 100 of 170 files, more files were not shown because too many files have changed in this diff. Show more