Compare commits
67
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
6327ad10a2 | ||
|
|
1acfbd6374 | ||
|
|
aea6192ef9 | ||
|
|
53118bae19 | ||
|
|
beb2b06fdf | ||
|
|
4ebe098ef0 | ||
|
|
00db1cf5f2 | ||
|
|
477a5a46e3 | ||
|
|
2587d33c5a | ||
|
|
223655fe00 | ||
|
|
29959e2988 | ||
|
|
e14a864b37 | ||
|
|
cb1326688b | ||
|
|
ef652f3ada | ||
|
|
8180a8a302 | ||
|
|
c902ffbe9a | ||
|
|
de952a68d6 | ||
|
|
c85696080d | ||
|
|
7527800128 | ||
|
|
d36b6bcad0 | ||
|
|
5eac654c36 | ||
|
|
b26e2f2f62 | ||
|
|
9ac2f91dde | ||
|
|
e915aaa865 | ||
|
|
f21781f170 | ||
|
|
55a82fdc5f | ||
|
|
89500cbb5f | ||
|
|
63f3417f19 | ||
|
|
ca84bce24f | ||
|
|
b97556dcc1 | ||
|
|
07a9c1eaaf | ||
|
|
f8f2dd53aa | ||
|
|
2085ec770f | ||
|
|
d76475a1d7 | ||
|
|
99a708b40c | ||
|
|
9806ef8f66 | ||
|
|
aa6684b588 | ||
|
|
5a758ee3b6 | ||
|
|
b635432cff | ||
|
|
4cbca0b5a6 | ||
|
|
e39dc63ded | ||
|
|
4f741cd176 | ||
|
|
122bafcc7a | ||
|
|
8e486c1097 | ||
|
|
bb98fe66dd | ||
|
|
1f69480ed8 | ||
|
|
ffa7e84d43 | ||
|
|
46c3e72364 | ||
|
|
dd1fcea7e2 | ||
|
|
797a79c30e | ||
|
|
3415e010ff | ||
|
|
29c154d2ca | ||
|
|
877e3b4c76 | ||
|
|
b90a9bbfab | ||
|
|
747ce1add2 | ||
|
|
c823a4b92d | ||
|
|
aa760c2839 | ||
|
|
44b808b8e2 | ||
|
|
ec78dd722c | ||
|
|
39985f7cfd | ||
|
|
ac9836a2d5 | ||
|
|
cdb8a6a28b | ||
|
|
a851e47eca | ||
|
|
9cd4968a97 | ||
|
|
2490067b2d | ||
|
|
8a517d6f38 | ||
|
|
a11eb3c766 |
No files matched your search
@@ -28,6 +28,7 @@ venv/
|
||||
/dist/
|
||||
/dist-*/
|
||||
/*.zip
|
||||
/*.zip.sha256
|
||||
/*.rar
|
||||
|
||||
# Native compiler intermediates; retain the two verified x86 runtime bridges
|
||||
|
||||
@@ -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') {
|
||||
|
||||
@@ -1,7 +1,16 @@
|
||||
# CBB 中心库上传后校验工具
|
||||
|
||||
当前临时分支的备份策略(2026-11-03):应用不再自动备份中心库或 CBB 工程。新增、替换、移除、校验、ICDB 维护和恢复在执行前提示手动备份;请自行保留可用副本。导入暂存、恢复用隔离验证库和轻量操作证据仍会生成,Mentor 原生 Repair 自身的备份行为保持不变。详见[自动备份检查与调整](docs/releases/2026-11-03-manual-backup.md)。此条优先于下方历史版本的备份说明。
|
||||
|
||||
当前补丁:**[v0.2.3-beta.1](docs/releases/v0.2.3-beta.1.md)(Beta 预发布,待现场验收)**,替代 0.2.2-beta.1。数据库所有权或关闭状态不确定时停止批次、保留现场;不自动移走地址文件、接管带锁设计或强杀 PCB 进程树。新增全库 ICDB 维护、同名 CBB 完整备份恢复弹窗及严格的原生复核流程。详见 [v0.2.3-beta.1 发布说明](docs/releases/v0.2.3-beta.1.md)。下方日期记录描述历史版本,以本补丁说明为准。
|
||||
|
||||
本目录是独立的 CBB 中心库上传后校验工具,不属于 Part Replacement,也不负责 CBB 工程复制或中心库上传。
|
||||
|
||||
针对 `The last server session ... lost the connection to the database`,修复分支增加
|
||||
`ICDB_REPAIR_REQUIRED` 专项识别、共享符号库路径诊断及停止批次处理。现场原生修复步骤及实现边界见
|
||||
[iCDB 旧服务器会话失联分析](docs/diagnostics/2026-10-27-icdb-lost-server-session.md)。
|
||||
当前分支会在目标明确、所有权释放和独占访问证据齐全时尝试一次同版本原生 Repair;操作前请手动备份,共享符号库没有 PRJ 入口时停止并要求人工处理。
|
||||
|
||||
## 功能边界
|
||||
|
||||
| 工具 | 处理对象 | 核心动作 | 结果 |
|
||||
@@ -10,9 +19,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 +142,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 +170,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 +203,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/`:历史版本的辅助文件副本;当前分支不再生成,所有路径记录 `backup_skipped / manual_backup_policy`。已有历史副本不由本轮改动清理。
|
||||
|
||||
超时采用无进展计时:界面和批量请求默认 600 秒无进展超时;它不是整个 CBB 的固定总时限,而是连续 600 秒没有可观察进展时才终止。PCB/COM 阶段切换、Project Integration 状态变化、保存标记变化和弹窗处理都会刷新计时器;重复的状态轮询不算进展。需要更快失败时仍可在界面将单项预算调低,但 30 秒只适合已确认 PCB 启动稳定的环境。
|
||||
|
||||
|
||||
@@ -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,65 @@
|
||||
# ICDB 持续失败:公开资料与实际入口核对
|
||||
|
||||
调查日期:2026-11-03。当前源码 `c856960`。本轮是网上资料检索及只读诊断,没有修改库、服务器设置或产品代码,不能作为修复验收。
|
||||
|
||||
## 本机确定的缺口
|
||||
|
||||
目前找到最近一次实际失败为隔离完整库 IP101GR 的 2026-11-03 16:19(北京时间)记录:
|
||||
|
||||
`diagnostics/feedback-final-ui/evidence/verify-85fd17bc6ed2/result.json`
|
||||
|
||||
错误为 `DATABASE_RECOVERY_REQUIRED`,阶段为 `PCB_STARTING`。原生提示询问:
|
||||
|
||||
> Continue to open the design with read/write access permission?
|
||||
|
||||
提示说明可能是文件系统/网络在 15 秒内未确定谁打开了设计,也可能是上一会话异常退出;要求确认没有其他用户正在使用。它没有证明数据库内容已损坏,也不是本轮原生 Repair 的失败结果。
|
||||
|
||||
代码及只读复核证据 `diagnostics/icdb-web-research-20261103/routing-evidence.json`:
|
||||
|
||||
1. `maintenance_entry.maintenance_needed` 仅在存在库阻止检查点或数据库地址记录时返回真。
|
||||
2. 当前 IP101GR 没有地址记录、没有阻止检查点,尽管请求 `maintenance=True`,仍返回 `routes_to_native_repair=false`。
|
||||
3. `select_maintenance_target` 额外要求恰好一个地址记录;无地址时返回 `需要唯一工程地址记录`,因此只改外层判断也不能打通流程。
|
||||
4. `verify_runner` 的自动补救仅针对 `ICDB_REPAIR_REQUIRED`;当前读写确认错误归入 `DATABASE_SAFETY_STOP`,不会触发该分支。
|
||||
5. 修复后一次性读写确认已有 `PostRepairProof` 机制,但只有本轮原生修复成功且释放已核实时才授权。当前入口绕过 Repair,自然没有这份证明。
|
||||
|
||||
因此,明确维护不能以“没有 sAddress.adr”推断无需维护。地址记录用于定位/占用判断,不应成为识别异常关闭状态的唯一依据。
|
||||
|
||||
## 网上资料:已读取原文
|
||||
|
||||
### 原生 Project Repair
|
||||
|
||||
[Mentor XP 如何修复文件](https://blog.csdn.net/qq_53931654/article/details/147240707)
|
||||
|
||||
原文步骤为打开 iCDB Project Backup,指定损坏工程路径,执行 `Project → Repair`。与本机已经接入的官方工具入口一致。本文是用户经验文章,没有证明当前完整自动链路或 CBB 校验限制已经解决。
|
||||
|
||||
本轮首次访问返回脚本验证页,后续正常请求取得正文;正文与截图链接保存在 `native-repair.json` / `native-repair.html`。
|
||||
|
||||
### 工程备份恢复
|
||||
|
||||
[“Unable to open iCDB connection”的解决方案](https://blog.csdn.net/zhangyang125/article/details/136188112)
|
||||
|
||||
原文建议从工程 `ProjectBackup/backups` 选择备份,恢复对应文件后重新打开。文章把复制/转移时文件丢失或损坏列为可能原因。该方案会回退版本,不等于保留最新内容的无损 Repair;仍需用户选择可接受版本,恢复后做工程身份与校验确认。
|
||||
|
||||
### 连接/监听地址
|
||||
|
||||
[Xpedition 2409 Designer 无法打开 iCDB 连接](https://blog.csdn.net/kkisscj/article/details/144323677)
|
||||
|
||||
原文描述在工作目录的 iCDB Server 配置中设置 `Network/Address` 为本机地址,并引用 VX2.8 管理文档。这说明“无法连接 iCDB”也可能是监听配置问题,不能一律解释为损坏。
|
||||
|
||||
但文章环境是 Xpedition 2409,本机是 EE7.9.5。现有日志未证实本机出现同类监听失败;本轮没有修改 Server 配置、服务或端口。
|
||||
|
||||
### 检索限制和排除项
|
||||
|
||||
英文 Google/DuckDuckGo 请求连接超时;Bing 多个精确错误查询无结果或结果无关,360 搜索提供了可进一步核对的中文线索。没有取得可直接适用于 EE7.9.5 当前弹窗的 Siemens 官方支持答复。检索及抓取原文保存在 `diagnostics/icdb-web-research-20261103/`。
|
||||
|
||||
标题/推荐摘要中含 “iCDB Server Monitor” 的另一页面,正文实际讨论 Android Studio Monitor,已排除,未把无关搜索结果当作技术依据。本机已有帮助文件检索也未找到能补足该弹窗处理条件的准确段落。
|
||||
|
||||
## 建议的修正与验证次序
|
||||
|
||||
1. 明确维护入口支持“无地址记录但需要检查”的工程:通过用户所选 CBB、唯一 PRJ/PCB 关系和明确数据库映射绑定目标;多个候选数据库必须明确区分,不能猜测共享库或另一个工程。
|
||||
2. 在本任务 PCB/启动器正常退出、库锁与数据库独占访问确认后,执行一次原生 Project Repair。不要因为看不到地址文件就直接退回打开 PCB。
|
||||
3. 仅在原生成功、目标一致、进程与地址释放确认后,使用已有修复后读写授权重新打开。未知或外部占用仍停止,不能把同意读写弹窗作为一般重试策略。
|
||||
4. 如要求选择 PCB 历史版本,明确记录选择及版本回退;随后验证集成、保存、关闭和权威 READY。
|
||||
5. 如果数据库检查通过,但仍被“已验证 CBB 不允许重新执行 BackAnnotate”阻止,应作为独立的 CBB 注册/校验状态问题处理。此前完整依赖库中“原生重新导入 → 自动校验 → READY”已通过,但不能把重新导入偷偷塞进 Repair 或称为无损修复。
|
||||
|
||||
此处已定位入口缺口和可验证的修正方向;尚未实现并完成“无地址记录”维护路径的真实自动链路验收。
|
||||
@@ -0,0 +1,37 @@
|
||||
# 普通校验阻塞修正
|
||||
|
||||
基准 `477a5a4`。按用户最新指示暂停 ICDB 自动修复研究,本轮只修普通校验的入口、单项失败后的继续条件、取消和退出,以及状态桥部署/重试。没有对原库运行新的校验、Repair、恢复或移除;遗留的 Project Backup 进程未被终止。
|
||||
|
||||
## 修改依据与最终行为
|
||||
|
||||
| 阻塞来源 | 修改 |
|
||||
| --- | --- |
|
||||
| 原生进程已退出,但单项失败仍使整批跳过 | 统一使用本轮、同库、同 CBB 的释放记录判断继续资格。FAIL/TIMEOUT/未知弹窗保持原失败状态和备注;自动化工作进程、保存/失败关闭助手及本任务原生进程全部确认退出后可继续下一项。失败不会变成 PASS。 |
|
||||
| 保存或失败关闭助手漏检;工作进程已关闭句柄后再查询退出状态 | 停止和检查两类精确脚本路径、精确父 PID 的助手。退出状态在关闭句柄前读取并缓存,清理可重复调用;助手和原生 PID 合并记录。任何查询异常或客户端仍活着都不解除执行锁。 |
|
||||
| 超时只写取消文件,客户端可能继续 Save/Close | 先请求协作取消,宽限到期后仅停止本任务自动化工作进程及已识别的自动化助手。保留原生 PCB/iCDB,不终止进程树。普通校验的取消事件已传入监督循环。监督程序丢失后,Verify 看门狗也限时停止已登记客户端。 |
|
||||
| 启动器和迟到子进程未完整纳入清理 | 监督器清理前重读剩余事件中的目标/启动器 PID;追踪这些已确认原生进程的新后代,排除任务开始前的无关会话。 |
|
||||
| 任意 PCB 已打开就禁止校验 | 精确命令参数指向同一 PCB 时才阻止启动;其他工程保留。实际 COM 文档身份和保存助手身份检查仍必须通过。保存关闭后存在其他文档时,不调用该应用的 Quit。 |
|
||||
| WMI 占用查询可能无限等待 | 普通校验的进程查询统一复用已有隔离查询助手,最多等待 10 秒。超时表示无法确认,保留具体原因;不在 GUI 线程做 WMI。 |
|
||||
| 端口少量抽样被当作整个原生端口区间不可用 | 默认仅发出警告并执行真实原生调用。保留内部显式严格诊断参数,不作为默认入口条件。 |
|
||||
| `0 errors` 被错误关键字命中;原生工程编码误判 | 仅忽略完整的零错误计数,仍拒绝非零错误、明确错误或坏退出码;复用现有 UTF-8 BOM / UTF-16 / Windows ACP 工程读取器。 |
|
||||
| 状态桥 x86 MFC 运行库缺失;加载失败对每项重复启动 | 打包时验证并携带 x86 MFC/VC 运行库到桥的独立目录,避免误用 x64 Qt DLL。识别明确的 Windows DLL 缺失/架构错误,只记录一次全局桥故障并为余项保留状态;不因此禁用维护或管理入口。 |
|
||||
| 状态查询重试复用旧 TIMEOUT/ERROR | 断点读取仅复用 READY/PENDING;失败状态下次重查,不要求修改库文件才能重新查询。普通界面读取仍使用本轮权威状态。 |
|
||||
|
||||
执行互斥只用于实际仍运行/释放未确认的客户端;历史诊断和 CBB 内容问题不应变成跨功能永久禁用。处于原生操作中的未知弹窗不会被盲目确认:当前项失败并留证,是否继续仍取决于该操作是否实际结束。
|
||||
|
||||
## 验证
|
||||
|
||||
新回归先复现单项已释放仍停批、取消未传递、零错误误判、编码与端口拦截等问题,再验证修改。还覆盖原生迟到子进程、保存/失败关闭助手保留,以及已关闭 Win32 句柄不再被读取。
|
||||
|
||||
使用真实 Windows 子进程验证监督程序退出后的客户端停止和原生模拟进程保留;VBS 在真正的 32 位 cscript 中使用伪 COM 对象验证 Save/Close、取消及剩余文档不被 Quit。它们没有加载现场工程,也不等于 Mentor 实机验收。
|
||||
|
||||
最终完整 Python 回归、冻结模块一致性、程序启动/正常退出、桥 JSON 编解码及实际加载 app-local x86 DLL 的结果记录在 `diagnostics/batch-blockers-20261104/`。现场日志和原始证据不随代码提交。
|
||||
|
||||
- 最终完整回归:**1,244 passed**,退出码 0,222.90 秒;1 条既有 pywinauto STA 警告。`pytest-final.log` / `pytest-final-result.json`。
|
||||
- PyInstaller 构建、编译和差异检查通过。10 个关键 Python 模块及两个 VBS 脚本与冻结程序一致,启动及正常退出冒烟返回 0。
|
||||
- 桥的 Unicode/UNC 编解码返回 0。通过真实进程模块枚举确认 `mfc140.dll`、`MSVCP140.dll`、`VCRUNTIME140.dll` 均从包内桥目录加载;不是仅检查文件名存在。系统 PATH 缩为 Windows System32,本检查没有加载 Mentor 数据库。
|
||||
- 独立审查发现并修正失败关闭助手漏检;复审无剩余必要 P1/P2。构建记录保留 `icdb_automatic_repair_acceptance=false`、`release_ready=false`。
|
||||
|
||||
## 仍待验证
|
||||
|
||||
没有把本次阻塞修正称为 ICDB 自动修复成功。Project Backup 挂起问题保持暂停;Windows 10 干净系统、其他 Mentor 环境、两个真实 PCB 同时打开的 COM 注册行为、跨机并发写库、3000 项网络库完整耗时仍需实机验证。状态桥无法读取时仍不能宣称 READY;本轮补齐了已确认的 x86 部署依赖,没有伪造状态,也未加入新的全功能禁用入口。
|
||||
@@ -0,0 +1,40 @@
|
||||
# ICDB 批量检查
|
||||
|
||||
## 当前行为
|
||||
|
||||
应用原“非 READY ICDB 检查与修复”入口改为“ICDB 批量检查”。检查可见非 READY 工程,有勾选时仅处理可见勾选项,READY 即使被勾选也排除。普通 CBB 校验、中心库管理和手动“版本历史与备份…”继续使用各自入口。
|
||||
|
||||
检查通过原生 Project Backup 加载所选工程,收集本次 Output 和占用结论,不启动 PCB,不调用 Repair、Restore 或版本选择。检查入口即使收到旧请求的 `auto_repair=True` 也只执行检查;其原生请求始终携带 `inspection_only=True`。内部显式恢复辅助 API 及其既有测试保留,应用批量检查不再调用它们。
|
||||
|
||||
结果分为:
|
||||
|
||||
- 未发现异常:返回 CHECKED,仅表示本次原生检查未发现已识别的 ICDB 异常,不推定 CBB READY。
|
||||
- 发现 ICDB 问题:保留 FAIL 和明确的 ICDB 故障分类,不执行修复。
|
||||
- 工程占用:记录占用,不把它解释成数据库损坏。
|
||||
- 无法确认:缺少有效工程、输出不完整、目标不符、未知错误等均保留原始证据,不显示健康。
|
||||
|
||||
本项检查的原生进程确认退出后,发现问题、占用或未知结果可继续下一项;本次检查尚未退出或缺少退出证据时停止剩余批次,不强制终止原生进程。用户取消也停止队列。需要修复或回退时,由用户通过原生备份窗口选择操作。
|
||||
|
||||
## 去除检查路径的修复限制
|
||||
|
||||
目标绑定复用手动原生入口的唯一主 PRJ 和明确的工程内 `iCDBDir`。检查不要求 PCB、Layout 或 `icdb.dat` 预先存在,也不借用 Repair 的地址记录唯一性和多个数据库候选排除规则。缺失或损坏由原生加载检查给出结论;无法识别的结果保留为未知。
|
||||
|
||||
原生 worker 的检查模式不再因本机存在其他 PCB/Library Manager 而直接拒绝,也不执行 Repair 专用的数据库独占准入;它仍在启动前检查所选工程的文件链接,目标是否占用由原生 Output 判定。
|
||||
|
||||
检查使用实际库协调锁,忽略历史协调检查点,不自动归档旧记录或删除地址文件。释放必须有明确的原生退出证据,或 worker 明确报告“尚未启动原生进程”;结果字段/PID 缺失不推定释放。该调整只覆盖新检查路径,不能据此宣称维护/管理/释放检查中的所有过宽条件均已解决。
|
||||
|
||||
## 界面及报告
|
||||
|
||||
批量检查不再显示手动备份要求、自动修复承诺或“修复并校验通过”计数。确认清单、进度、备注、汇总及完整/异常/JSON 报告均按检查目标和检查分类输出。占用和未知备注不加“ICDB 问题”标签。默认副本恢复仍排除缺少 PCB 的工程,检查候选可以包含它们。
|
||||
|
||||
## 验证边界
|
||||
|
||||
本轮先以失败测试确认旧入口会打开 PCB、可进入 Repair、使用修复准入及误标未知结果,再修改入口。测试覆盖健康、明确故障、占用、未知、异常修复返回、缺少退出证据、明确未启动、取消、队列继续、缺 PCB/Layout/icdb、多数据库、READY 排除、仅检查汇总和报告。
|
||||
|
||||
全量测试、冻结模块一致性、启动冒烟及隔离库实际按钮记录保存在 `diagnostics/icdb-batch-check-20261104/`;最终包的 `BUILD.json` 记录实际结果。隔离验证只执行新批量检查,不在原库运行 Repair/Restore。
|
||||
|
||||
最终全量 **1304 passed**,270.79 秒,退出码 0,1 条既有 pywinauto STA 警告;编译和差异检查通过。冻结的 14 个关键 Python 模块及两个 VBS 与源码一致,启动/退出、Unicode/UNC 协议及包内 x86 运行库加载通过。独立审查发现的修复准入误用和缺字段推定释放均以先失败后通过的回归修正,复审无剩余必要 P1/P2。
|
||||
|
||||
最终冻结包通过真实按钮在自有隔离库的 PENDING `IP101GR` 上检查,原生返回数据库不一致且未占用,应用记录 `ICDB_REPAIR_REQUIRED`、`safe_to_continue=true`,汇总“发现问题 1”。原生请求为 `inspection_only=true`,返回 `repair_requested=false`,没有 PCB 请求或恢复尝试。原生及应用均正常退出,中心库 LMC 和工程 PRJ、DXP、icdb.dat、PCB、LayoutDB 六个文件的 SHA-256 前后一致。
|
||||
|
||||
原生加载检查不能保证 PCB 实际打开一定正常,也不能替代普通 CBB 校验。现场自动修复问题不作成功结论;工单和 WIP PR 保持开放。
|
||||
@@ -0,0 +1,47 @@
|
||||
# 工单 #4 与独立操作复核
|
||||
|
||||
复核基准:最新工单 [#4](https://git.simgreek.com/Skyworth_Digital_Hardware/cbb-refresh-verify-795/issues/4)(更新于 2026-11-04 15:20),当前代码起点 `2587d33`,用户随后要求校验与 ICDB 维护独立执行。原工单基准为 `29959e2`,下表按当前源码重新核对,不能照搬原报告的测试数或认定全部已修复。
|
||||
|
||||
后续用户要求暂停 ICDB 自动修复、先修阻塞。新的修改和最终 1,244 项完整回归见 [普通校验阻塞修正](2026-11-04-batch-blockers.md);下表保留首次复核状态,不能作为最新未修项数量使用。
|
||||
|
||||
## 本次用户失败的实际链路
|
||||
|
||||
最新测试程序的日志位于 `dist/issue2-tabs-release-candidate/CbbRefreshVerify-Background/data/`。北京时间 17:41:55 开始维护 `1GPHY_8212`,17:42:24 进入原生检查,17:43:17 启动 Project Backup,17:43:50 报 `TIMEOUT_UNRELEASED`。本轮没有发出 Repair,8 个后续条目被跳过。17:44:54 再运行另一工程,遗留 PID 60000 被全局进程检查拦截。
|
||||
|
||||
只读打开对应私有桌面后确认:原生主窗口及 RichEdit Output 控件均存在,但主窗口和 Output 连 WM_NULL 都返回 1460(超时)。不是已经取得 ICDB 损坏结论后修复失败,而是原生检查本身无响应,且本应用没有提供足够的阶段证据。没有向该原库发出新的 Repair、恢复、删除地址文件或强制结束操作。
|
||||
|
||||
原有逻辑还把“存在历史检查点”直接解释为整个库只能维护,普通校验默认自动 Repair,并把地址记录存在直接解释为会话未释放。这些产品耦合与用户最新要求冲突。
|
||||
|
||||
## 12 项仍需修改或验收
|
||||
|
||||
| 工单项 | 当前结论 | 后续工作及验收 |
|
||||
| --- | --- | --- |
|
||||
| K2-1 状态桥前置检查 | 仍缺少批次级能力诊断;在原生刷新后才检查权威 READY | 批次开始只诊断一次并明确说明状态不可读取;不能因此封锁 ICDB 和库管理。不能把原生调用完成当作 READY。 |
|
||||
| K2-1b x86 运行库部署 | 发布候选中的桥为 x86,导入 `mfc140.dll/MSVCP140.dll/VCRUNTIME140.dll`,未随包提供 x86 MFC | 选择静态链接或正式部署 x86 运行库;干净 Windows 实机验证。x64 Python/Qt 的同名 DLL 不能替代。 |
|
||||
| K2-2 未知弹窗分级 | 输入法误报已有过滤;真正未知交互弹窗仍使当前项失败并停批 | 区分无交互辅助窗口与实际模态提示;后者记录具体原因,正常释放后才继续独立项,不能盲点未知确认按钮。 |
|
||||
| K2-3 取消与超时 | 协作式取消已存在;看门狗和 `_stop_worker` 仍可能返回时客户端活着 | 检查当前 automation client/保存客户端是否实际退出,防止迟到 Save/Close;不得以删除历史记录代替停止仍在写入的任务。 |
|
||||
| K2-6 ICDB 自动维护 | 隔离副本曾成功执行 Repair;本次原库原生检查无响应,不能验收 | 当前修复:独立维护、独立校验、缩小检查范围、记录原生等待阶段。仍需一致副本上的真实按钮验收;原生窗口挂起成因待查。 |
|
||||
| K2-4 跨机共享库并发 | sidecar 排他句柄只协调遵守协议的工具,Mentor 不参与 | 明确共享库操作协议,基于实际原生文件占用处理冲突;两台机器同时写同一工程的验证尚未完成。 |
|
||||
| K2-5 地址记录及全局 PCB 拦截 | 地址文件和历史记录的普通校验硬拦截在本次拆除;“任意 PCB 已开即拒绝”仍存在 | 改为按工程身份判断占用;独立 CBB 不应相互禁用;跨会话 COM 绑定需实际验证后调整。 |
|
||||
| K2-7 Windows 10 | 当前没有 Win10 实机完成证据 | 在 Win10 + EE7.9.5 验证私有桌面、启动、保存、释放及 READY;不能以 Win11 回归替代。 |
|
||||
| K2-8 内容文本与 PRJ 编码 | 探针确认成功文本含 `0 errors` 仍返回 FAIL;preflight 仍按 UTF-8 读取 | 复用已有工程编码读取器,区分零错误计数与真实错误;补 UTF-16、ACP 和真正失败样本。 |
|
||||
| K2-9 CentralLibrary 改写与说明 | 写入前已有原始 `pcb.prj` 证据副本和原子替换;旧“没有直接改写”说明不准确 | 核对异常回退与说明,按用户要求提示手动备份,不能重新加上自动整库备份。 |
|
||||
| K3-1 初次扫描规模 | 状态指纹与逐项 preflight 仍有全库开销;本次只缩小了维护检查范围 | 首屏增量读取、扫描进度和取消;381/3000 项及网络盘测量仍需做。 |
|
||||
| K3-2 队列恢复 | 已有状态/管理检查点,但没有完整校验队列的确认续跑 | 保存目标、已完成项和具体结果,重启后由用户决定继续;管理写操作不得自动重放。 |
|
||||
|
||||
共 12 项:5 项 P0、7 项原工单 P1/规模化条目。它们不等于 12 个已复现的代码错误:包含明确缺陷、部分修复、部署风险及缺少实机验收。优先处理操作解耦、原生检查无响应、桥部署、取消后仍存活的客户端;其余独立提交,不混在一次维护修复中。
|
||||
|
||||
## 本次实现与验证范围
|
||||
|
||||
普通校验默认不调用 Repair;历史检查点不再切换清单读取方式或禁用普通校验。合作式库锁跟随实际客户端释放,不为普通校验创建新的永久诊断阻止记录;已有历史记录保留。已退出的只读原生检查不会因为旧地址记录而锁住管理入口。实际仍存活或尚未确认退出的客户端继续保有执行锁;监督工作进程已经退出、只剩已记录的原生 PID 时,重试会检查这些 PID 是否实际退出,校验和维护均可直接重试,不要求先运行另一个功能。工作进程仍在运行时不采用这一简化判定。
|
||||
|
||||
维护成功报告 `REPAIRED / UNKNOWN` 和“待单独校验”,不自动重开 PCB、不执行反标注、不标为 READY。历史备份恢复仍需核对版本。维护预检查只扫描当前 Work、相关共享符号数据库及中心库定义,并保持链接、文件集合变化和独占句柄检查。扫描真实原库的 5,218 项用时 14.109 秒(只读,未启动原生工具);原用户流程的两层预检查合计约 76 秒,不能把这两个口径直接当作完整维护耗时对比。
|
||||
|
||||
验证证据在 `diagnostics/independent-operations-20261104/`(原始现场记录不提交):
|
||||
|
||||
- 操作拆分后的相关回归 509 项通过;审查发现并补正真实客户端仍在写入时的执行锁保留,以及直接重试维护的入口问题。
|
||||
- 执行锁、维护、占用、校验、导出保护和恢复等相关回归 **214 passed**,退出码 0;最后“无需修复”展示与独立入口回归 **37 passed**,退出码 0。不是对最终源码重新跑完整 Python 套件的声明。
|
||||
- 独立静态审查的必要问题已修正。编译及差异检查通过。
|
||||
- 冻结包核对 10 个关键模块与当前源码一致,并运行无原生写入的启动/正常退出冒烟。构建元数据明确保留 `native_acceptance=false`、`release_ready=false`。
|
||||
|
||||
本轮没有重启现场挂起的原生进程、强制结束该进程、在原库执行新的自动修复,或将单元测试当成 ICDB 实机验收。原生窗口长时间无响应的具体内部原因仍未查明;此文档不能作为原生自动修复已验收的证明。
|
||||
@@ -0,0 +1,31 @@
|
||||
# 原生版本历史、备份与回退入口
|
||||
|
||||
## 用户操作
|
||||
|
||||
在“ICDB 维护”页勾选一个非 READY CBB,点击“版本历史与备份…”。应用将所选工程的唯一 PRJ 传给已安装的 `iCDBProjectBackup.exe -p`,打开可见的原生窗口。当前 Layout 数据缺失但 PRJ 仍在时也可以进入。
|
||||
|
||||
版本列表、备份详情、操作日志和 Restore backup 由原生窗口提供。选择版本、手动保存/自动保存分支以及恢复确认均由用户操作;应用不代点 Restore、Repair、删除或清理菜单。用户已报告手工回退能够走通,本轮接入该原生入口,不把手工成功当作自动 Repair 验收通过。
|
||||
|
||||
原生窗口正常关闭后重新读取受影响 CBB 的权威状态。窗口关闭仅记为 `CLOSED`,始终记录 `restore_confirmed=false`,不自动执行校验,不伪造 PASS/READY。需要验证恢复后的工程时,单独使用“检验”页。
|
||||
|
||||
## 会话与独立操作
|
||||
|
||||
- 可见原生窗口由独立辅助进程启动和监督;Qt 线程不等待原生会话,清单搜索、筛选、横向页面和库切换保持可用。
|
||||
- 使用 Windows Job 跟踪本次原生进程及后代,根进程退出但后代仍在时继续等待。Job 不设置 kill-on-close;关闭本应用不强制关闭原生窗口。
|
||||
- 实际会话持有现有中心库协调锁,同库写入等待该会话关闭;其他库不因这个窗口禁用。没有新增历史 ICDB 失败标记作为普通校验前置条件。
|
||||
- 状态或结果文件写入失败不结束原生监督。辅助进程退出后,只有返回身份一致且 `safe_to_continue=true` 才清除应用内会话和路径租约;缺失、损坏或释放未确认时保留同库冲突,可通过已有“检查占用…”取得新的释放证明。
|
||||
- 切换到同一共享上的其他库时,旧会话结束会把临时盘符所有权交给当前租约,避免断开当前路径。关闭应用时为仍打开的原生窗口保留所需盘符。
|
||||
|
||||
## 本机验证
|
||||
|
||||
证据目录:`diagnostics/native-backup-ui-20261104/`(本地诊断目录,不包含原库发布副本)。
|
||||
|
||||
源码实际按钮验证使用自有隔离库 `C:/Temp/CbbTabsRelease20261104/library/mentor_lib.lmc` 的 `1GPHY_8212`,由测试夹具提供 PENDING 清单状态,确认原生 Output 加载同一 PRJ、报告工程未使用、完成备份目录加载,再向该原生空闲窗口发送正常关闭。未点击 Restore/Repair,也未操作原库。详见 `source-acceptance.json`。
|
||||
|
||||
冻结候选包读取真实权威清单时,`1GPHY_8212` 为 READY,其维护入口按规则禁用。随后选择同一隔离库中实际 PENDING 的 `IP101GR`,验证真实 Qt 按钮、原生备份列表加载、正常关闭和应用状态刷新;最终仍为“待校验”,应用正常退出。原生 Output 明确报告该隔离副本的数据库不一致,本轮只验证入口,不点击 Repair/Restore,也不将此报错当作自动修复已通过。记录在 `frozen-acceptance.json`。
|
||||
|
||||
相关功能回归 88 项通过;最终全量回归 **1260 passed**,188.94 秒,退出码 0,1 条既有 pywinauto STA 警告。冻结的 13 个关键 Python 模块及两个 VBS 与源码一致,冻结启动/退出冒烟、Unicode/UNC 协议和包内 x86 运行库加载通过。全量回归、冻结模块一致性和启动冒烟结果分别保存在 `pytest-final.log`、`frozen-result.json`;最终构建记录随包保存到 `BUILD.json`。一次按系统 GBK 模式运行的全量测试因既有测试未指定 UTF-8 读取原生日志而失败,保留 `pytest-locale-failure.log`,最终回归使用 `python -X utf8 -m pytest -q`。
|
||||
|
||||
## 验收边界
|
||||
|
||||
本轮覆盖“应用入口 → 原生备份列表加载 → 用户可操作窗口 → 正常关闭 → 状态刷新”。不自动回退数据,不以本轮打开/关闭试验代替恢复后的保存关闭与 READY 验收。现场失联故障的完整自动修复、Win10 干净系统和跨机共享库并发仍未验收;ICDB 自动修复研究按用户要求暂停。工单和 WIP PR 保持开放。
|
||||
@@ -0,0 +1,32 @@
|
||||
# 按本次工程启动错误决定 ICDB 维护
|
||||
|
||||
## 问题
|
||||
|
||||
旧的显式维护入口对 `maintenance=True` 恒定返回“需要维护”,所有可见非 READY 候选都先进入 Project Backup 检查。虽然 Repair 仍要求原生检查明确报告故障,这一流程没有先确认 PCB 是否实际打不开,也会让健康工程进入维护环境和占用检查。
|
||||
|
||||
非 READY 表示未通过 CBB 校验,不能作为 ICDB 损坏证据;普通服务器、授权、COM、路径及内容错误也不能据此转换成 ICDB 修复。
|
||||
|
||||
## 调整后的流程
|
||||
|
||||
1. 维护按钮保持针对可见非 READY 候选。每项先通过既有 `diagnostic_only` 路径实际打开所选 PCB:核对工程/中心库身份,不改工程路径、不执行集成、不保存、不提交 Cert、不运行普通 CBB 校验。
|
||||
2. 同一工程正常打开并确认会话释放后返回 CHECKED,备注为“无需 ICDB 修复”,不启动 Project Backup,不推定 READY。
|
||||
3. 普通失败保留原状态和原始错误。没有完整 ICDB 原生失联特征、数据库路径或会话信息时,不进入维护。历史地址、协调检查点或旧诊断文件不代替本轮启动证据。
|
||||
4. 仅本轮诊断 FAIL、会话已释放,且失联报错数据库属于当前工程时进入原生维护。共享库、其他工程、未知目标、超时及取消结果不自动修复当前 CBB。
|
||||
5. 原生维护取得锁及工程证明后,再核对目标必须与本次报错数据库相同。原生检查仍需确认空闲且明确要求修复,才调用既有单次 Repair 路径。目标不一致时不启动原生工具,不因已释放的单项错误阻塞其他独立 CBB。
|
||||
6. 诊断在文档身份确认后和关闭完成后各复查本轮日志,避免延迟写入的启动错误被误判为健康。日志沿用启动前基线和增量判定,不从历史日志猜测故障。
|
||||
|
||||
普通“检验”按钮继续独立执行,不要求先通过 ICDB 维护;手动“版本历史与备份…”继续直接进入可见原生窗口,由用户选择版本。此修改只调整维护触发条件,不宣称修复了原生 Repair 内部失败。
|
||||
|
||||
## 测试与边界
|
||||
|
||||
先新增回归测试,在旧代码上验证健康工程及普通错误仍会进入 Project Backup 的失败,再实现入口修正。测试覆盖完整失联特征、无会话/只含错误码、共享库/其他工程、目标变化、正常打开、未释放、超时、取消、旧诊断文件、日志写入失败和延迟启动错误。
|
||||
|
||||
关联回归 151 项通过,后续新增的报告失败及等价路径用例纳入最终回归;维护入口专项最终 21 项通过。最终全量 **1283 passed**,643.89 秒,退出码 0,1 条既有 pywinauto STA 警告。编译和差异检查通过,冻结的 13 个关键 Python 模块及两个 VBS 与源码一致,启动/正常退出、Unicode/UNC 编解码和包内 x86 运行库加载通过。
|
||||
|
||||
独立静态审查发现目标的字面路径比较可能误拒绝映射盘与 UNC 身份,已改为比较两边解析后的工程及数据库路径,实际原生启动路径保持不变;等价路径回归先失败后通过。真实网络共享与 Win10 验收仍保留。复审无剩余必要 P1/P2。
|
||||
|
||||
关联回归、全量回归、构建与冻结检查保存在 `diagnostics/icdb-startup-gate-20261104/`,最终测试包的 `BUILD.json` 记录实际执行结果及源码哈希。
|
||||
|
||||
最终冻结包通过实际按钮在自有隔离库的 PENDING `IP101GR` 上再次打开手动备份列表、正常关闭并刷新为“待校验”,应用正常退出。没有点击 Repair/Restore;该试验用于确认手动入口独立性,不作为新的启动诊断或自动修复实机验收。
|
||||
|
||||
本轮不对原中心库执行 Repair/Restore,不以模拟诊断或隔离副本备份窗口打开成功代替现场自动修复验收。ICDB 自动修复内部问题仍未验收,工单及 WIP PR 保持开放。
|
||||
@@ -0,0 +1,26 @@
|
||||
# 阻塞范围收紧记录
|
||||
|
||||
本轮处理的是“一个 CBB 出问题后把整批和其他库一起停掉”的误阻塞。
|
||||
|
||||
## 已收紧
|
||||
|
||||
- 批次继续条件保持按实际释放证据判断。单项 FAIL、ICDB 检查发现问题或普通内容错误,只要本次原生/自动化客户端已经退出并返回 `safe_to_continue=true`,下一项继续;只有进程仍存活、退出状态无法确认或共享写入安全无法证明时才停止后续写操作。
|
||||
- 管理失败状态现在绑定实际中心库。切换到另一个中心库会清除旧库的 `_management_unsafe`,不会把库 A 的失败带到库 B;释放检查完成回调也只清除同一库的状态。
|
||||
- 显式维护的原生占用检查按目标 PRJ 命令行过滤无关 PCB/Library Manager。旧的零参数占用探针仍兼容,目标路径可用时不再被其他 CBB 阻塞。
|
||||
- 释放证明支持目标 CBB 范围。提供目标名称时,只检查该 Work 工程的地址记录、主要数据库文件和命令行包含该工程的原生客户端;其他 CBB 的 `sAddress.adr` 不再阻塞当前恢复。无目标范围的全库释放检查继续保守处理。
|
||||
- 释放接口新增参数保持旧调用兼容;旧插件或测试没有 `block_name` 参数时继续走全库证明路径。
|
||||
- UI 比较中心库身份不再对不可达 UNC 路径调用会访问网络的 `Path.resolve()`。网络共享暂时不可达时保持可用状态和错误提示,不在界面刷新中抛异常。
|
||||
|
||||
## 仍然必须停止的情况
|
||||
|
||||
- 当前项的 PCB、Project Backup、保存助手、Importer 或管理工作进程仍在运行。
|
||||
- 进程查询失败、原生窗口身份不明、退出状态缺失,或库锁/共享写入归属无法确认。
|
||||
- 用户明确点击取消,当前批次停止后续项目。
|
||||
|
||||
这些停止条件保护共享数据库和原生写入现场;移除它们会把一个仍在写入的工程与下一个 CBB 并行运行,可能造成更大范围的数据损坏。
|
||||
|
||||
## 验证
|
||||
|
||||
新增回归覆盖单项已释放失败继续批次、切库清除管理阻塞、目标 CBB 过滤无关进程/地址、旧释放接口兼容和不可达 UNC 路径。最终全量回归 **1309 passed**,1 条既有 pywinauto STA 警告;`compileall` 与 `git diff --check` 通过。
|
||||
|
||||
本轮没有修改图标等其他工作区文件,也没有对现场中心库执行写入、Repair 或 Restore。
|
||||
@@ -0,0 +1,36 @@
|
||||
# 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` 之前。
|
||||
|
||||
## 解决方案
|
||||
|
||||
- 在 `DesktopWorker` 构造开始时初始化资源字段,并把 Desktop、Job、worker 创建放入同一异常边界。
|
||||
- 构造失败时按 worker、Job、Desktop 顺序回滚;已启动的 worker 先终止,避免留下无父级的原生进程。
|
||||
- 在状态读取创建 Desktop 前完成 UI 依赖加载,确保依赖异常不会产生未受保护的 Desktop。
|
||||
- 增加回归测试,模拟 worker 启动失败并断言 Desktop、Job 均已关闭。
|
||||
|
||||
## 影响范围
|
||||
|
||||
- 只影响原生 worker 启动失败和状态读取依赖加载失败时的清理路径。
|
||||
- 正常任务的私有桌面、Job Object、进程树和数据库释放策略不变。
|
||||
- 不会切换用户输入桌面,也不会改变中心库写入策略。
|
||||
|
||||
## 验证
|
||||
|
||||
- `python -m pytest -q tests/test_desktop_worker.py tests/test_dialog_agent.py tests/test_native_inspection_release_regressions.py tests/test_verify_diagnostics.py`:33 passed。
|
||||
- `python -m compileall -q src tests`:通过。
|
||||
- `git diff --check`:通过。
|
||||
|
||||
## 分支
|
||||
|
||||
`codex/desktop-leak-pr`
|
||||
@@ -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,95 @@
|
||||
# CBB 管理候选实现(Issue #2 Task 4)
|
||||
|
||||
本次在当前应用增加新增、同名更新和移除入口、逐项检查点、库外完整备份、
|
||||
来源工程暂存和明确的结果状态。READY 条目可以勾选用于管理;原有校验和恢复
|
||||
仍仅处理当前可见的非 READY 合格条目。
|
||||
|
||||
## 原生能力边界
|
||||
|
||||
移除路线来自 EE 7.9.5 随附 Tcl 的 `CleanWGLib <lmc> F4 <list>`,输入为
|
||||
`REUSE_BLOCK\tLogical-Physical\t<name>`。协调端已在独立库副本完成真实移除
|
||||
和原生目录缺失复读。运行时核对已验证的 LibraryManager、CleanWGLib、
|
||||
LMCDLL70 和 LMCDocAddin70 文件 SHA256;仅允许匹配版本、DxDesigner 流程、
|
||||
Logical-Physical 分区及 ASCII 名称。输出必须包含对应名称/分区的 Removed
|
||||
消息且不含 Warning/Error,之后重新打开原生目录确认条目缺失。
|
||||
|
||||
新增和同名更新默认禁用,界面说明缺少哪项隔离验证。已发现原生新增对话框
|
||||
不等于完成库注册;不能仅凭返回值或出现目录启用。通用引擎已实现新增冲突
|
||||
拒绝、暂存来源、名称/分区/工程内容复读、可选自动校验,以及明确更新时的
|
||||
原生移除后重新导入。更新必须同时有两个原生路线和同名端到端验证才可启用。
|
||||
移除后重新导入失败会报告 `RECOVERY_REQUIRED`,停止队列,不自动回滚或重放。
|
||||
|
||||
## 操作与恢复证据
|
||||
|
||||
每项结果包含 operation、library、name、partition、source、auto_verify、stage、
|
||||
status、safe_to_continue 和 evidence_path。`management/management-<id>/`
|
||||
保存原子更新的 `checkpoint.json`、完整 `library-before`、主数据清单、来源
|
||||
暂存副本、原生请求/输出和后续校验记录。结果区区分:
|
||||
|
||||
- `UPLOAD_FAILED`:上传失败;不能解释为已上传。
|
||||
- `UPLOADED`:原生注册与工程身份已确认,本批次未自动校验。
|
||||
- `UPLOADED_VERIFY_FAILED`:已上传,但自动校验没有达到 PASS/GREEN。
|
||||
- `UPLOADED_VERIFIED`:已上传且自动校验达到 PASS/GREEN 并确认释放。
|
||||
- `REMOVED`:原生移除且重新读取目录确认缺失。
|
||||
- `RECOVERY_REQUIRED`:原生写入可能发生,或更新已移除但重新导入未完成;
|
||||
保留完整库备份和所有中间状态,需要人工审查。
|
||||
|
||||
启动时显示未完成和释放不确定的检查点,不自动执行。存在同一库的未完成
|
||||
检查点时,新的管理任务被阻止。先由管理员检查原生进程、目标目录和备份,
|
||||
按现场恢复流程处理;确认恢复完毕后把已审查的操作证据目录移至独立归档位置,
|
||||
再重新读取库。不要删除锁文件,不要强制结束持有数据库的原生程序。
|
||||
|
||||
## 并发和来源保护
|
||||
|
||||
管理、校验和备份恢复共享 `Local\CbbRefreshVerify795` 及原上传工具兼容的
|
||||
`.<LMC stem>.cbb-upload.lock` 独占句柄。只有相同线程持有的相同库锁允许嵌套;
|
||||
完整备份通过已经持有的句柄读取锁内容,不重新打开或删除独占锁。
|
||||
管理任务不能确认原生所有者释放时,在本应用进程内保留该独占句柄,阻止旧上传
|
||||
工具抢入;不会仅因自动化线程返回或超时而释放锁。
|
||||
直接校验与备份恢复也保留释放不明确的锁。库旁保存
|
||||
`.<stem>.cbb-upload.blocked.json`,本应用重启后拒绝写入和原生读取。
|
||||
该记录在取得库锁后、原生调用前写入,正常确认释放才清除。只有精确保留文件名、
|
||||
协议版本和所有权字段匹配的记录被归类为运行时元数据;完整副本仍保留其字节,
|
||||
主数据比较忽略其生命周期变化。同名普通文件或损坏记录保持原样并阻止自动解除。
|
||||
“检查会话释放并解除协调阻止”入口先确认管理工作进程已返回、相关原生进程
|
||||
均已退出、库内不存在 sAddress.adr,且能同时以独占只读句柄打开所有 LMC、
|
||||
icdb.dat 和 LayoutDB.lyt。全部通过才归档阻止记录并关闭本应用保留的句柄;
|
||||
不会删除上传锁文件,也不把会话释放解释为数据恢复成功。
|
||||
|
||||
进程崩溃会使 Windows 释放其句柄;旧上传工具不认识新增阻止记录,因此本方案
|
||||
不能保证本应用崩溃后旧上传工具仍被排除。崩溃后应先正常结束原生会话,并通过
|
||||
上述释放检查和未完成任务审查,再使用本工具或旧上传工具继续写入。
|
||||
|
||||
备份与来源不能置于目标库内部,来源必须是完整且引用位于工程内的 PRJ/PCB。
|
||||
来源工程根目录和目标库根目录也不能相互包含或相同,避免操作嵌套库时改变原始来源。
|
||||
链接、外部数据库引用、源文件变化、备份失败和同名新增冲突均会阻止写入。
|
||||
来源先完整复制;工程身份比较使用顶层块、原理图数据库和布局数据库内容指纹,
|
||||
原生规范化若改变数据库字节则保守拒绝确认,需要进一步语义验证,不能声称等价。
|
||||
|
||||
原生管理在私有 Windows 桌面运行,不移动鼠标或占用前台输入。只操作当前
|
||||
已识别原生进程。读取目录遇到旧库升级或 Select flow type 对话框时取消并报错,
|
||||
绝不将升级作为只读读取的一部分。超时保留原生所有者和证据,不强杀数据库进程;
|
||||
确认前不继续下一项,不启动最终 Verify。
|
||||
通过网络盘租约选择的盘符路径在原生 OpenLibrary、CLI、暂存工程库引用和后续
|
||||
Verify 中保持原样;规范化路径仅用于身份、包含关系和锁键比较。工作进程按原
|
||||
租约的盘符/共享目录上下文确认映射,不把原生盘符路径改回 UNC。
|
||||
|
||||
## 独立新增诊断
|
||||
|
||||
`python tools/validate_native_management.py SOURCE.prj NEW_OUTPUT_DIRECTORY NAME`
|
||||
只接受不存在的新目录,先完整复制来源,再由私有工作进程调用原生
|
||||
`CreateLibrary(..., kFLOW_DX=1)` 创建固定的新库。随后使用已验证的
|
||||
Reusable Blocks / UIA Logical - Physical 页签和 New 按钮、1103 对话框字段。
|
||||
诊断会记录原生消息、关闭后的重新打开清单、工程内容比较和原始来源不变检查。
|
||||
它不接收生产库参数,不存在跳过生产能力门禁的开关,也不自动修改能力门禁。
|
||||
可加 `--replacement-source OTHER.prj` 在同一个新建隔离库中验证同名更新:
|
||||
先备份完整旧库,再原生移除并检查缺失,然后重新导入替换工程。重新导入必须
|
||||
匹配本次 CreateLibrary 记录的固定路径和随机所有权令牌,不能指向外部库。
|
||||
监督进程先创建新的空 fixture 目录并持有库锁,原生工作进程核对准备令牌、
|
||||
检查点协议和监督 PID 后才创建 LMC。初次创建、所有复读和替换阶段均按生产
|
||||
操作的释放规则持锁;超时或释放异常保留独占句柄和重启阻止记录,必须重新
|
||||
通过会话释放检查才能解除。
|
||||
|
||||
本阶段单元测试通过注入文件模拟的原生边界执行,不启动 Mentor、不操作实际库。
|
||||
候选冻结包、最终 Windows 11 原生场景由协调端单独验收。Windows 10 和真实
|
||||
现场失联样本仍未验证;文件头损坏与模拟故障不能替代这些验收。
|
||||
@@ -0,0 +1,77 @@
|
||||
# 工单 #2 候选包验收记录
|
||||
|
||||
分支:`codex/temp-issue-2-icdb-recovery`。本记录区分软件回归、隔离原生试验和现场验收;未合并、发布或关闭工单。
|
||||
|
||||
最终候选程序源码提交:`8e486c1`。新增和同名更新保持禁用;原生新增虽已成功注册并复读,但原理图数据库被原生工具重写,尚未证明内容等价。移除已在新建隔离库通过完整管理流程验证。
|
||||
|
||||
最终全量回归:`python -m pytest -q` 在 `122bafc` 上 **887 passed,1 个已有 pywinauto STA 模式警告,68.62 秒**。`122bafc` 只调整安全测试,`src` 和 `packaging` 的 Git 树与打包提交 `8e486c1` 完全一致。编译检查及 `git diff --check` 通过;整分支审查和后续修正复审均无未处理问题。
|
||||
日志:`build/issue2-final-tests-122bafc.log`。安全测试明确保留工程文件、上传锁以及损坏/外来检查点,只有本工具拥有且验证通过的运行时检查点允许清理。
|
||||
|
||||
## 已实现范围
|
||||
|
||||
- ICDB 启动失败后,仅在任务进程、工程路径、私有桌面、空闲窗口及地址释放可确认时正常关闭 PCB;同时等待启动器退出。Repair 区分缺少健康备份、原生失败、占用、未知窗口和释放超时。最终重新打开、校验及 READY 状态共同决定修复成功。
|
||||
- 名称/分区搜索和状态筛选使用已加载数据;隐藏条目清除勾选。READY 可以用于管理,不能进入默认校验、维护和恢复队列。受影响条目刷新后重新判断资格。
|
||||
- 完整备份保留全部文件;版本化清单对主要工程文件和库依赖计算 SHA-256,复制时同时核对文件集合、大小和时间。日志及其他运行时变化不再等同于工程内容变化。
|
||||
- 管理请求、逐项结果、完整旧库备份、检查点、来源暂存、共享锁和安全释放入口已集成。新增/更新未达到原生验收门槛时禁用。重启只展示未完成任务,不自动重放写操作。
|
||||
|
||||
## 原生证据与边界
|
||||
|
||||
| 场景 | 实际观察 | 限制 |
|
||||
| --- | --- | --- |
|
||||
| 最终冻结程序启动失败退出 | `8e486c1` 的 PCB 和启动器自动正常退出、无数据库地址;`startup-close.json` 为 CLOSED,safe_to_continue=true | 人工损坏副本,不是现场服务器失联 |
|
||||
| 最终冻结程序 Repair 缺少健康备份 | `8e486c1` 返回 MISSING_HEALTHY_BACKUP,原生工具自动退出、地址为空、允许安全继续 | 验证明确失败和释放,不代表修复成功 |
|
||||
| 官方原生移除 | 独立副本中 CleanWGLib/F4 返回 0,之后原生目录重新读取为空 | 旧库升级存在告警;生产读取遇到升级必须拒绝 |
|
||||
| 隔离新增首次完整探测 | 新建库后打开编辑器失败,尚未提交新增;来源保持不变,保留失败证据及协调阻止记录 | 不启用新增或同名更新,不作为成功验收 |
|
||||
| 最终移除适配器命令 | 实际捕获 `# Note: Removed REUSE_BLOCK 'IP101GR' from partition 'Logical-Physical'.`,释放确认成功,来源清单未变 | 随后的旧库复读拒绝 Select flow type;不能宣称该库完整自动移除验收通过 |
|
||||
| 新建隔离库完整移除 | 管理引擎完成原生读取、完整旧库备份、原生删除、重新读取确认缺失;最终 REMOVED,safe_to_continue=true | 仅代表此安装版本、库流程和 Logical-Physical 分区 |
|
||||
| 新建隔离库原生新增 | 收到成功消息,正常关闭、重新打开仍有正确名称/分区,原始来源不变;布局哈希一致 | 原理图数据库哈希改变,identity_matches=false;新增/更新不启用,未执行同名更新和重新导入恢复验收 |
|
||||
|
||||
原始证据位于 `diagnostics/issue2-frozen-20261102/`、
|
||||
`diagnostics/issue2-management-native-20261102/` 和
|
||||
`C:/Users/ABS_Windows/.cbb-management-e2e-20261102-a/`。
|
||||
首次新增失败后,仅向已确认的隔离 Library Manager 主窗口发送正常 WM_CLOSE;
|
||||
随后进程查询为空,没有强制终止数据库所有者。
|
||||
|
||||
第二次新增探测的 `dispatch-diagnostics.jsonl` 在加载 pywinauto 前记录方法
|
||||
DISPID 17/26/6,加载后全部返回 `CO_E_OBJNOTCONNECTED`(-2147220995)。
|
||||
这证明失效发生在 UI 自动化依赖初始化边界,尚未提交新增;来源未变。
|
||||
第二次隔离会话同样正常关闭。移除适配器及旧库拒绝证据保存在
|
||||
`diagnostics/issue2-remove-adapter-20261102/`;旧库拒绝流程后出现的
|
||||
“Unable to determine flow type”通知由协调端确认后正常退出,不能记为无人值守释放通过。
|
||||
|
||||
`ffa7e84` 冻结包的 GUI 冒烟通过,但真实批处理在启动 Mentor 前报
|
||||
`No module named 'win32timezone'`。此包不能作为最终可用包交付;必须补齐打包依赖并重建验证。
|
||||
`1f69480` 补齐依赖后运行了真实 PCB 流程;`8e486c1` 又收紧了隐藏基础设施窗口的精确识别条件,最终冻结测试自动通过退出分支。
|
||||
|
||||
最终证据:
|
||||
|
||||
- `diagnostics/issue2-frozen-20261102/full-8e486c1-startup/evidence/verify-97173dae8a21/startup-close.json`
|
||||
- `diagnostics/issue2-frozen-20261102/full-8e486c1-nohistory/repair-result.json`
|
||||
- `diagnostics/issue2-management-final-20261102/probe-result.json`
|
||||
- `diagnostics/issue2-management-final-20261102/full-remove-result.json`
|
||||
- 移除前完整旧库保留在 `C:/Users/ABS_Windows/.cbb-management-e2e-20261102-e/full-remove/management-e90d69ad7f624fb18f5401119b96856d/library-before/`。
|
||||
|
||||
冻结启动失败试验的批处理退出码为 2,因为输入是损坏工程;通过项是自动安全退出,而不是工程校验成功。缺少健康备份的 Repair 同样是已验证的明确失败分支。
|
||||
|
||||
## 仍需现场验收
|
||||
|
||||
工单附件只有日志,没有现场 `1GPHY_8211` 故障工程及其必要共享库的一致副本。
|
||||
因此现场服务器会话失联尚未复现,也没有完成该现场故障经应用实际维护按钮触发的完整自动链路验收。
|
||||
必须取得副本、记录来源/工程身份/主要文件哈希,在隔离环境记录失败、退出、Repair 调用、重新打开、保存关闭和 READY 查询的完整证据,并核对来源未改变。
|
||||
复制后不能复现时应记录“未复现”,不能用数据库文件头损坏试验替代。
|
||||
|
||||
Windows 10 尚未验证。现有原生试验环境为 Windows 11 / Mentor EE 7.9.5。
|
||||
历史备份恢复保持“已恢复,版本待核对”,不宣称无损修复。
|
||||
|
||||
## 候选包
|
||||
|
||||
`dist/issue2-repair-candidate-877e3b4.zip` 保留独立修复候选包及构建清单。
|
||||
完整候选程序位于 `dist/issue2-full-candidate-8e486c1/`,由 `git archive 8e486c1` 的不可变源码构建。构建与 GUI 冒烟通过,真实冻结原生证据见上。
|
||||
分发压缩包:`dist/issue2-full-candidate-8e486c1.zip`。解压后运行 `CbbRefreshVerify-Background/CbbRefreshVerify.exe`;包根目录保留构建清单、本文及关键验证证据。
|
||||
`dist/issue2-full-candidate/` 和 `dist/issue2-full-candidate-1f69480/` 是被后续修正取代的中间试验构建,不作为交付包。
|
||||
|
||||
## 后续验收顺序
|
||||
|
||||
1. 取得现场故障工程及必要共享库一致副本,优先完成实际维护按钮触发的完整自动链路验收。
|
||||
2. 针对原生导入会重写 ICDB 的行为,使用经过验证的 Mentor 语义读取/导出建立工程内容等价证据;不能只放松哈希检查。之后才能启用新增,并验证重复冲突、同名更新、部分失败及备份重新导入。
|
||||
3. 在 Windows 10 / EE 7.9.5 重跑冻结关键路径,并在具备网络测试环境时验证真实断网、取消和恢复场景。现有模拟测试不能替代这些环境验收。
|
||||
@@ -0,0 +1,182 @@
|
||||
# Issue #2: release the PCB launched by a failed database open
|
||||
|
||||
Branch: `codex/temp-issue-2-icdb-recovery`.
|
||||
|
||||
## Field failure
|
||||
|
||||
The issue attachment records an iCDB lost-server-session error while opening
|
||||
`1GPHY_8211`. The supervisor declined the database log viewer and cancelled the
|
||||
worker. Because document identity had not been established, the existing
|
||||
document-close helper was never called. PCB and its launcher remained alive;
|
||||
the subsequent Repair attempt returned `REPAIR_DATABASE_IN_USE` and the other
|
||||
380 queued entries were skipped. There is no evidence of native Repair actually
|
||||
running on that field database.
|
||||
|
||||
## Change
|
||||
|
||||
The worker now has a separate startup-failure close path. It requires a current
|
||||
iCDB diagnosis or a database-load-failure dialog belonging to this PCB during
|
||||
startup. It checks the private desktop, excludes pre-existing process IDs, and
|
||||
matches the complete PCB path and ReusableCircuit argument. Only an enabled
|
||||
empty PCB main window, without modal dialogs, MDI documents or database address
|
||||
records, receives a cooperative `WM_CLOSE`. A requested close is not treated as
|
||||
success until process exit is observed. Ambiguous or busy sessions are retained.
|
||||
|
||||
The supervisor allows up to 40 seconds for fatal-error cleanup so that the
|
||||
worker's 20-second startup-close window can complete before recovery begins.
|
||||
The existing repair preconditions, backups and success checks remain in force.
|
||||
Each attempt writes `startup-close.json` and close-request/result events.
|
||||
|
||||
## Verification
|
||||
|
||||
Regression tests cover the missing pre-identity cleanup route, real observed
|
||||
empty-window titles, exact path matching, pre-existing processes, another
|
||||
desktop, live address records, modal and MDI windows, disabled windows, unrelated
|
||||
failure records and a close request that does not result in exit.
|
||||
Delayed dialog/address release and delayed process exit are also covered.
|
||||
Validation: `python -m pytest -q` — 491 passed, one existing pywinauto COM-mode
|
||||
warning; `python -m compileall -q src tests` and `git diff --check` passed.
|
||||
|
||||
A new isolated local library was created with the existing
|
||||
`tools/validate_icdb_open_repair_reopen.py` tool, output
|
||||
`diagnostics/issue2-startup-20261102`. No production library was changed.
|
||||
The test damages only the new copy's database header; it does not reproduce the
|
||||
field server-session-loss condition.
|
||||
|
||||
The real Mentor opening run produced `MENTOR_DATABASE_LOAD_FAILED`, then:
|
||||
|
||||
- `startup_close_requested` for the launched PCB PID 6532;
|
||||
- `startup_close_result: CLOSED`;
|
||||
- worker and supervisor both recorded `process_exit_confirmed`, with no
|
||||
remaining PCB processes.
|
||||
|
||||
The subsequent separate native Repair run was able to start and completed as
|
||||
`RESTORED_REVIEW_REQUIRED`, using the fixture's historical backup. This proves
|
||||
the failed-open session no longer blocks the next repair operation in this
|
||||
fixture. It does not prove automatic recovery of the field database or establish
|
||||
that an older backup contains the desired design revision.
|
||||
|
||||
The separate `open-after` run on the same restored fixture completed native
|
||||
integration, Save/IsSaved/Close/Quit, confirmed process release and returned
|
||||
`PASS`, `safe_to_continue=True`, `READY (IsVerifiedReuseBlock, raw=1)`.
|
||||
The `compare` phase passed all seven checks, including absence of the original
|
||||
opening error and unchanged source-fixture database SHA-256. Its
|
||||
`server_session_loss_reproduced` field is explicitly `false`.
|
||||
|
||||
Reproduction commands (set `PYTHONPATH=src`; setup requires a new output name):
|
||||
|
||||
```powershell
|
||||
python tools/validate_icdb_open_repair_reopen.py setup --output issue2-startup-20261102
|
||||
python tools/validate_icdb_open_repair_reopen.py open-before --output issue2-startup-20261102
|
||||
python tools/validate_icdb_open_repair_reopen.py repair --output issue2-startup-20261102
|
||||
python tools/validate_icdb_open_repair_reopen.py open-after --output issue2-startup-20261102
|
||||
python tools/validate_icdb_open_repair_reopen.py compare --output issue2-startup-20261102
|
||||
```
|
||||
|
||||
The stages are deliberately separate: the test fixture has a format-corruption
|
||||
error and historical-backup recovery, not the field lost-session auto-repair
|
||||
trigger. The test does not change production handling of old-backup recovery.
|
||||
|
||||
READY filtering, hash-scope changes and CBB CRUD are outside this focused fix.
|
||||
|
||||
## Approved Task 1 follow-up: lifecycle and repair outcomes
|
||||
|
||||
The empty-PCB close path now receives the launcher process handle and waits for
|
||||
its normal exit after PCB exits. It checks database addresses again during that
|
||||
wait, so a late address record prevents a false `CLOSED` result. The startup
|
||||
record includes PCB, launcher and address release state. A connected COM server
|
||||
with no active document emits `pcb_document_wait`; it remains in startup and
|
||||
continues reading the current native failure rather than implying identity.
|
||||
|
||||
Native Repair reads bounded Output text and records only the text appended after
|
||||
this run's Repair invocation as operation evidence. Database logs are restricted
|
||||
to the current native PID and start time. Output, native log copies, the complete
|
||||
backup, native result and attempt record remain available under `native-repair`.
|
||||
Detailed native evidence is preserved separately from its directory path.
|
||||
|
||||
The result distinguishes `MISSING_HEALTHY_BACKUP`, `NATIVE_REPAIR_FAILED`,
|
||||
`DATABASE_BUSY`, `UNKNOWN_DIALOG`, and `TIMEOUT_UNRELEASED`. A failed tool receives
|
||||
cooperative close only after a terminal native error, an enabled exact-project
|
||||
main window, no other windows/prompts and no target database address. The worker
|
||||
then waits for normal process exit. Unknown/custom prompts and incomplete native
|
||||
operations receive no close action. A failure classification can coexist with
|
||||
unreleased state; that state always stops the queue. Terminal `DATABASE_BUSY`
|
||||
errors also retain the native tool without close, reopen or queue continuation.
|
||||
Unreadable, absent, hung or truncated initial Output waits within the deadline
|
||||
and retains the tool without requesting Repair; a readable empty string is a
|
||||
valid invocation baseline. A busy-project message in
|
||||
this fresh native process's initial loading Output prevents Repair invocation
|
||||
entirely; it is not hidden by the later invocation baseline.
|
||||
|
||||
Before reopening or continuing, the parent independently checks relevant PCB,
|
||||
Library Manager, Repair, importer and close-helper processes, all known project/
|
||||
PCB/shared-library addresses, and exclusive read access to every existing known
|
||||
database. Process-observation errors and exclusive-access failures block reuse.
|
||||
Only a conclusively failed, released, independently revalidated project-local
|
||||
target may allow the next CBB. Shared or unknown scope, busy owners, timeouts,
|
||||
unknown prompts and historical restores stop for review.
|
||||
|
||||
Before accepting native success, the parent validates native process identity
|
||||
and true exit, exact project/database, empty address state, confirmed backup/
|
||||
repair evidence and absence of restore/failure/unknown-prompt contradictions.
|
||||
Missing or wrong-typed fields fail closed. Independent process, address and
|
||||
database-handle probes remain additional requirements.
|
||||
|
||||
Native `REPAIRED` is retained as `native_status`; summaries count a repair only
|
||||
after the same request reopens, completes Verify and returns authoritative
|
||||
`PASS/GREEN` with confirmed release. A failed reopen becomes
|
||||
`REPAIR_VALIDATION_FAILED`; incomplete or contradictory native success/release
|
||||
becomes `UNCONFIRMED` and prevents reopening.
|
||||
Historical restoration remains `RESTORED_REVIEW_REQUIRED`. The original error,
|
||||
stage and evidence references, a `pre-repair-result.json` snapshot, native
|
||||
evidence and validation evidence remain attached even if the retry raises.
|
||||
|
||||
`tests/fixtures/issue2-lost-session-sanitized.json` contains selected fields from
|
||||
the actual issue attachment, with paths, machine and process identities
|
||||
sanitized. Replay asserts `PCB_STARTING`, the selected PRJ/database, normal PCB
|
||||
and launcher release before native Repair, and exactly one automatic repair and
|
||||
one reopen even if the opening error repeats. Separate replays cover the actual
|
||||
2026-10-28 missing-backup Output, delayed exits/addresses, unknown custom prompts,
|
||||
successful native repair and historical restoration. These are nonnative tests.
|
||||
|
||||
The attachment contains logs only. No matching `1GPHY_8211` faulty project was
|
||||
found in the sibling `Skyworth_CBB_Lib` collection. This host runs Windows 11;
|
||||
Windows 10 behavior and recovery of the real field database remain unverified.
|
||||
The coordinator's prepared `diagnostics/issue2-frozen-20261102` fixture damages a
|
||||
copied database header; it does not reproduce field lost-server-session loss.
|
||||
Candidate packaging and frozen/native tests remain coordinator work after review.
|
||||
|
||||
Task 1 checks: full suite once, 532 passed with the existing pywinauto COM warning;
|
||||
after the final initial-busy gate regression, the related final suite passed all
|
||||
234 tests. Compileall and `git diff --check` passed. The coordinator will run
|
||||
candidate/frozen validation against the final implementation.
|
||||
|
||||
Task 1 review fix round: 259 related tests passed (17.86s); compileall and
|
||||
`git diff --check` passed. These checks include busy retention, real readback
|
||||
failure branches, 30 malformed-success variants at both release and reopen/
|
||||
counting boundaries, and a complete actual worker-result replay control.
|
||||
|
||||
Runtime fix round 2 adds `iCDBProjectBackup.exe` and `ReuseBlockImporter.exe` to
|
||||
the process helper's fixed query whitelist. Without these entries, the real
|
||||
parent release probe rejected its own required queries and always denied safe
|
||||
release. New tests keep the release validator and process helper real and stub
|
||||
only WMI: no owners permits release, either native owner prevents it, and
|
||||
arbitrary query names remain rejected. Focused validation: 172 passed. Candidate
|
||||
`c823a4b` must be rebuilt with this correction before frozen/native validation;
|
||||
field recovery remains unverified.
|
||||
|
||||
Runtime fix round 3 uses the actual frozen-worker window capture. A single Afx
|
||||
shell titled exactly `iCDB Project Backup` now waits, before invocation only,
|
||||
for the exact project title within the existing deadline. Two owned-process
|
||||
input-indicator classes (`UAC_InputIndicatorOverlayWnd`, `UAC Input Indicator`)
|
||||
are ignored only with empty titles. Wrong/duplicate target windows, ambiguous
|
||||
shells, named/lookalike auxiliary windows, unknown prompts, missing Output and
|
||||
busy verdicts still retain the tool without unsafe commands. The native loading
|
||||
line `Checking if project is in use.` is excluded from busy evidence; the actual
|
||||
ownership verdict continues to control the busy gate.
|
||||
|
||||
Sanitized recorded-shape replay includes real shell children, RichEdit Output
|
||||
readback, startup-to-loaded transition and both input indicators before and
|
||||
after load. Focused validation: 189 passed (12.40s); compile and scoped diff
|
||||
checks passed. New source/frozen native validation and rebuilding the candidate
|
||||
remain coordinator work; these replay results do not establish field recovery.
|
||||
@@ -0,0 +1,251 @@
|
||||
# Scoped recovery manifests and complete verified backups
|
||||
|
||||
Status: implemented; review finding P1 addressed with focused validation. Started on b90a9bb; paused at
|
||||
the RED checkpoint for the coordinator's native startup-window repair fix and
|
||||
resumed on 877e3b4. No native UI/process/live-library actions were performed by
|
||||
this implementer. Original untracked review.diff was preserved and not staged.
|
||||
|
||||
## Result and scope
|
||||
|
||||
Complete backup trees are still copied and retained. SHA256 and semantic
|
||||
before/after comparisons now cover only primary design/project/database/
|
||||
constraint files and required central-library dependencies. Runtime changes
|
||||
after a successful snapshot do not stop install. Primary content changes,
|
||||
additions and deletions do stop install, with copies retained as evidence.
|
||||
|
||||
The validate-copy -> conflict checks -> retain original Work -> install ->
|
||||
reopen/native verification flow is preserved. Source equality now runs after
|
||||
incoming Work preparation, immediately before target equality, closing the old
|
||||
late-source-change window. Source idle/address ownership is rechecked there as
|
||||
well: excluding address bytes from semantic hashes does not bypass idle checks.
|
||||
|
||||
Initial implementation: 29c154d. The review correction is described below.
|
||||
Durable documentation lives here; an ignored review copy remains at
|
||||
.superpowers/sdd/2026-11-02-issue-2-management/task-3-report.md.
|
||||
|
||||
Scoped production files: backup_recovery.py and new scoped_manifest.py. Scoped
|
||||
tests: test_backup_recovery.py and new test_scoped_manifest.py. No Verify public
|
||||
types, Task 2 helpers/READY logic, native repair classifiers/process whitelist,
|
||||
or library binary contents were changed.
|
||||
|
||||
## Exact classification rules
|
||||
|
||||
Project scope retains every unclassified file as primary. This includes PRJ,
|
||||
PCB, DXP, icdb.dat, Layout databases, schematic/logic/symbol assets, CES/config,
|
||||
unknown binary/engineering formats, and text files outside explicit excluded
|
||||
categories. Rules are case-insensitive; manifests preserve relative path case.
|
||||
|
||||
Explicit semantic exclusions, still copied and metadata-validated:
|
||||
|
||||
- Runtime/history child directories **at a project workspace root**, its PCB
|
||||
workspace root, a selected Work/Cert root, or the library root: log, logs,
|
||||
temp, tmp, __pycache__, backup, backups, output, outputs, report, reports,
|
||||
gerber, gerbers, odb++, Log Files, LogFiles, and Work.before-restore-*.
|
||||
- ProjectBackup/backups only at those workspace roots. Other ProjectBackup
|
||||
content remains conservative primary data.
|
||||
- Known native runtime below database/cdbsvr and PCB/database/cdbsvr: log,
|
||||
dbcheck and dbrestore subtrees. In shared library databases, those same
|
||||
subtrees below SymbolLibs/<partition>/cdbsvr or <shared-root>/cdbsvr. Other
|
||||
unknown files below cdbsvr remain primary; the directory is not dropped.
|
||||
- File suffixes: .log, .tmp, .temp, .lck, .lock, .bak, .backup, .pdf.
|
||||
- File names: sAddress.adr and editor files starting with ~$.
|
||||
|
||||
Directory exclusions are contextual rather than arbitrary ancestor matching.
|
||||
ReusableBlocksLP/<selected-block>/Work and Cert are structural identity
|
||||
components, never runtime labels. CBB names Logs, Temp, Backup, Output, Report,
|
||||
Log Files, ProjectBackup and Work.before-restore-engineering remain valid and
|
||||
their primary files are hashed in both semantic manifests and complete-copy
|
||||
validation. Case variants have the same protection.
|
||||
|
||||
Shared dependency partitions and nested engineering folders keep their names:
|
||||
SymbolLibs/temp/icdb.dat, SymbolLibs/Temp_a/device.sym,
|
||||
SymbolLibs/Backup/device.sym, hdl/Logs/design.v and hdl/Backup/design.v are
|
||||
primary. Runtime directory labels apply at the known roots above, not inside
|
||||
arbitrary engineering/dependency hierarchies. File suffix/name exclusions are
|
||||
applied to files, not to engineering directories with matching suffixes.
|
||||
|
||||
The uploader-compatible .<stem>.cbb-upload.lock falls under .lock, so it is
|
||||
runtime and never primary. It is **not** silently removed from complete copies.
|
||||
|
||||
Central-library scope includes only target ReusableBlocksLP/<block>/Work and
|
||||
Cert, root configuration files (the selected .lmc, other root config files),
|
||||
and shared/configuration dependency directories outside ReusableBlocksLP. Known
|
||||
examples include SymbolLibs/__ReusableBlocksSymb, CellDB and PartDB; new unknown
|
||||
dependency directory names remain primary conservatively. Other root .lmc files,
|
||||
other ReusableBlocksLP CBBs, target historical/non-Work/non-Cert trees and the
|
||||
explicit runtime/generated categories above do not enter semantic equality.
|
||||
Those unrelated files still enter the complete copy and its metadata checks.
|
||||
|
||||
Later semantic scans prune ignored/runtime/unrelated CBB directories before
|
||||
entering them, so transient/unavailable runtime or unrelated trees cannot
|
||||
interfere with the post-snapshot content check.
|
||||
|
||||
## Reusable API contract for Task 4
|
||||
|
||||
Import from cbb_refresh_verify.scoped_manifest:
|
||||
|
||||
```python
|
||||
scope = ManifestScope.library(block_name, selected_lmc.name)
|
||||
before = copy_verified(library_root, private_backup, scope=scope, progress=callback)
|
||||
current = build_manifest(library_root, scope=scope, exclude=private_incoming)
|
||||
if current != before:
|
||||
# stop install; retain evidence
|
||||
...
|
||||
```
|
||||
|
||||
- `ManifestScope()` is project scope. `ManifestScope.library(block_name,
|
||||
library_name)` requires nonempty single-component names; no path traversal.
|
||||
- `build_manifest(root, *, scope=None, exclude=None, progress=None,
|
||||
hash_function=hash_file)` returns a semantic manifest. `exclude` is an optional
|
||||
private incoming subtree, **not** a copy exclusion. Hash injection is a test
|
||||
hook; normal callers use the default.
|
||||
- `copy_verified(source, destination, *, scope=None, progress=None,
|
||||
hash_function=hash_file)` requires a fresh destination outside source. Copies
|
||||
all files/directories, returns the same semantic schema, retains partial
|
||||
destination on failure, and raises ValueError/OSError for unsafe/changed data.
|
||||
- `scan_tree(root)` scans complete membership and refuses links/junctions and
|
||||
special files. Its optional scope/exclude is used by semantic scans only;
|
||||
complete copies always scan without filters.
|
||||
- `hash_file(path)` streams SHA256 in 1 MiB chunks. Files are processed with up
|
||||
to eight workers, retaining the existing concurrency bound.
|
||||
- Progress callback accepts **one dict**, not the old private `(count,total)`
|
||||
pair: `stage` (`copy` or `hash`), `hashed_files`, `hashed_bytes`, `total_files`,
|
||||
plus `copied_files` for copy. Hash counts/bytes count unique primary snapshot
|
||||
files/logical bytes, not aggregate disk IO. `total_files` counts all files for
|
||||
copies and primary files for standalone manifest generation. Initial zero and
|
||||
each 256/final-file event are emitted. Recovery keeps existing public progress
|
||||
stage/message keys and adds `manifest_stage` and these counters.
|
||||
|
||||
Version 1 JSON-compatible output (relative paths are POSIX, no machine-specific
|
||||
absolute paths or mtimes in equality):
|
||||
|
||||
```json
|
||||
{
|
||||
"version": 1,
|
||||
"scope": {"kind": "library", "block_name": "A", "library_name": "target.lmc"},
|
||||
"files": {
|
||||
"ReusableBlocksLP/A/Work/A.prj": {
|
||||
"size": 123, "sha256": "<sha256>", "scope": "target_work"
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Entry scope labels are project, target_work, target_cert, library_config and
|
||||
shared_dependency. Default project's descriptor uses empty block/library names.
|
||||
Recovery persists both library-before-manifest.json and
|
||||
source-before-manifest.json. The shape changed only for private backup helpers;
|
||||
VerifyRequest/VerifyResult contracts are unchanged. There is no old-manifest
|
||||
loader or destructive migration: existing historical evidence remains intact.
|
||||
|
||||
## Copy integrity and old strict equality compatibility
|
||||
|
||||
Copy validation remains strict for the **entire** snapshot: before/after source
|
||||
file/directory membership, file type, size and nanosecond mtime must agree;
|
||||
destination membership/type/size/mtime must match too. Primary regular source
|
||||
files are SHA256 read before copy and again for validation; destination hashes
|
||||
must match. All native icdb.dat and .lmc files retain exclusive read handles
|
||||
during copying. For scoped primary native files, the expected digest is built
|
||||
from the source ReadFile stream independently of destination SHA256. Identical
|
||||
size/mtime destination corruption is therefore rejected, including locked DBs.
|
||||
Unrelated native DBs are still locked/copied; their bytes are not SHA256 hashed.
|
||||
|
||||
The old final `_manifest(source) == complete_copy_record` was an all-file hash
|
||||
comparison that rehashed every runtime and unrelated project file. It is
|
||||
replaced by full-tree copy metadata validation and primary byte verification at
|
||||
snapshot time. Later equality compares version/scope and primary relative
|
||||
path/size/hash/scope only. Thus log-only additions/changes/deletions after a
|
||||
successful copy are accepted, while primary keyset/content changes remain real
|
||||
conflicts. No conflict tests were weakened or deleted; additional source,
|
||||
target, Cert, shared dependency, late-source and active-address regressions were
|
||||
added. Empty directory metadata is intentionally not part of semantic equality.
|
||||
|
||||
## RED/GREEN and verification evidence
|
||||
|
||||
The original full-suite evidence below belongs to initial commit 29c154d. The
|
||||
P1 review correction has fresh focused validation, and has **not** rerun the
|
||||
full suite; the coordinator requested focused tests only for this fix.
|
||||
|
||||
1. Initial RED, before production edits:
|
||||
`python -m pytest tests/test_scoped_manifest.py tests/test_backup_recovery.py -q`
|
||||
-> **29 failed, 26 passed in 7.89s**. Failures demonstrated missing versioned
|
||||
manifest/schema/progress and post-snapshot runtime/unrelated tolerance.
|
||||
Copy/conflict protections already present continued passing.
|
||||
2. Initial GREEN -> **55 passed in 11.93s**.
|
||||
3. Additional RED for semantic traversal of an unavailable ignored/unrelated
|
||||
tree -> **1 failed, 36 passed in 2.79s**; fixed by pruning semantic scans.
|
||||
4. Additional RED for source mutation during incoming Work preparation and
|
||||
source address reappearance -> **2 failed, 20 deselected in 1.56s**; both had
|
||||
incorrectly installed before the final-source-check changes.
|
||||
5. Final focused:
|
||||
`python -m pytest tests/test_scoped_manifest.py tests/test_backup_recovery.py tests/test_backup_recovery_dialog.py -q`
|
||||
-> **64 passed in 9.93s**.
|
||||
6. Coordinator was notified **before** the full suite and explicitly confirmed
|
||||
no native owner/mutex and paused all native probes. Exactly one final suite:
|
||||
`python -m pytest -q` -> **693 passed, 1 warning in 47.99s**. Warning:
|
||||
pywinauto's existing "Revert to STA COM threading mode" warning in
|
||||
test_library_reader.py::test_status_log_records_unseen_id_inference.
|
||||
7. `git diff --check` passed. Review confirmed no unrelated/native-helper edits.
|
||||
|
||||
Coverage includes every primary category, unknown engineering formats,
|
||||
runtime/history/generated exclusions with complete-copy retention, hash-path
|
||||
scope, relocatability, source changed/deleted/added during copy/validation,
|
||||
target changes/deletions/additions, Cert/shared-library conflicts, unrelated
|
||||
CBB tolerance, copied corruption with preserved metadata, locked stream bytes,
|
||||
source content changes with preserved metadata, complete copy membership and
|
||||
nonprimary size consistency, idle/address rechecks, retained copies on failure,
|
||||
and unchanged native reopen/retained-Work recovery behavior.
|
||||
|
||||
## Review correction: contextual runtime directory classification
|
||||
|
||||
Review found that the initial unconditional directory ancestor rules could
|
||||
classify valid selected CBB names (Logs/Temp/Backup) or real SymbolLibs/temp
|
||||
engineering partitions as runtime. That removed primary paths from both the
|
||||
baseline manifest and later conflict comparison, and from copy byte checks.
|
||||
|
||||
The classifier now resolves the structural role first and only applies the
|
||||
runtime directory rules at documented workspace/native DB locations. Semantic
|
||||
directory traversal and complete-copy byte classification share that rule.
|
||||
Complete tree copy/metadata validation remains unchanged. This also protects
|
||||
nested engineering folders with names Logs/Backup, and avoids broad dropping
|
||||
of unknown cdbsvr files.
|
||||
|
||||
Independent regressions cover Work and Cert under 11 colliding CBB names/case
|
||||
variants, real SymbolLibs/temp and Temp_a partitions, arbitrary nested
|
||||
engineering folders, source and destination corruption with unchanged size/
|
||||
mtime, independent locked database destination corruption, and end-to-end
|
||||
recovery conflicts that previously overwrote concurrent target/shared edits.
|
||||
Known native Log Files, ProjectBackup/backups and DB server log/dbcheck/
|
||||
dbrestore data remain semantically ignored and completely copied.
|
||||
|
||||
Review-fix RED:
|
||||
`python -m pytest tests/test_scoped_manifest.py tests/test_backup_recovery.py -q --tb=short`
|
||||
-> **47 failed, 74 passed in 18.41s**, before production changes. The failures
|
||||
included silently accepted primary corruption and installs over concurrent
|
||||
target/shared edits. Additional conservative-boundary regressions prevented
|
||||
reintroducing the same bug through Log Files/ProjectBackup/retained-Work names
|
||||
or broad cdbsvr directory exclusion.
|
||||
|
||||
Final review-fix focused GREEN:
|
||||
`python -m pytest tests/test_scoped_manifest.py tests/test_backup_recovery.py tests/test_backup_recovery_dialog.py -q --tb=short`
|
||||
-> **141 passed in 18.28s**. No native UI/process actions, live-library mutation,
|
||||
or full-suite run was performed during this fix round.
|
||||
|
||||
## Limitations / follow-up boundary
|
||||
|
||||
- No real field lost-session reproduction, native GUI success reproduction, or
|
||||
Windows 10 run was performed for this task; file-based tests do not substitute
|
||||
for those required native/field validations.
|
||||
- Task 4 must adapt complete-copy access to a live uploader lock **only when the
|
||||
operation actually owns that coordination lock**. The current helper copies
|
||||
readable locks and fails closed on unreadable/live exclusively owned files;
|
||||
it does not delete locks or broadly drop engineering data.
|
||||
- Native idle guards and later coordination locks remain necessary. Final
|
||||
equality and filesystem rename are not one cross-process atomic transaction
|
||||
against arbitrary noncooperating external writers.
|
||||
- Nonprimary byte hashes are intentionally absent. Their copy integrity uses
|
||||
complete membership and size/mtime checks, as specified; same-size,
|
||||
timestamp-preserving nonprimary corruption is outside the semantic guarantee.
|
||||
- All snapshots must be stable while copied, including runtime files. This
|
||||
deliberately differs from post-snapshot semantic checks, which tolerate
|
||||
runtime changes. Original and partial recovery evidence is retained on failure.
|
||||
@@ -0,0 +1,122 @@
|
||||
# 既存地址记录下的明确 ICDB 维护入口
|
||||
|
||||
2026-11-03 的现场报告显示,点击“非 READY ICDB 检查与修复”后,IP101GR 在
|
||||
0.172 秒内返回 BLOCKED,没有启动官方 Repair。原先维护按钮和普通校验使用
|
||||
相同请求;普通校验对任何 sAddress.adr 的阻止条件也挡住了明确维护入口。
|
||||
随后保留的库协调检查点使重新读取与维护都无法继续。
|
||||
|
||||
本次为用户明确确认的维护增加独立入口。普通校验遇到地址记录仍停止,不依据
|
||||
文件日期、TCP 不通或本机无 PCB 进程判断地址失效,不删除、移动或隔离地址。
|
||||
没有地址阻止时,维护继续沿用原有校验及本轮失联后的自动修复流程。
|
||||
|
||||
存在地址记录时,明确维护需要唯一可确认的工程 PRJ/database 映射。共享符号库
|
||||
地址、所选工程内多个地址、外部引用、歧义目标、不完整工程均会阻止执行。
|
||||
其他独立 CBB 的 Work 数据库地址不纳入当前修复目标,原文件保持不变。工具检查相关
|
||||
原生程序和保留工作进程,并同时独占读取库中的原生数据库文件;记录目标工程
|
||||
引用指纹和地址字节哈希,检查期间及完整备份后重新核对。完整工程备份保留
|
||||
原地址文件,再由官方 iCDB Project Backup 打开工程。只有其实际 Output 明确
|
||||
报告 `Project is not in use. Full iCDB Project Backup's functionality is available.`,
|
||||
且没有占用或未知窗口时才请求 Repair。
|
||||
|
||||
库旁已有协调检查点时,明确维护可以接续有效的同库记录,条件是原监督进程
|
||||
已退出,或当前进程确实持有已闲置的保留锁。相关所有者和目标独占访问检查
|
||||
必须先全部通过,再原样归档旧检查点并建立本次检查点;库 sidecar 和全局 mutex
|
||||
期间始终持有。未知、损坏、其他库的记录或仍存活的外部监督进程不会被接管。
|
||||
普通释放检查的地址要求没有放宽,上传锁文件不删除。
|
||||
|
||||
重启后有有效同库检查点时,界面仅按工程目录显示 UNKNOWN 状态,明确标注
|
||||
“状态未确认,不代表损坏”。此视图不调用原生状态读取,只允许明确维护或严格
|
||||
释放检查;普通校验、上传/更新/移除及备份恢复均禁用。安全完成维护后再重新
|
||||
读取权威状态,保留当前搜索条件。
|
||||
|
||||
Repair、原生退出、地址消失和最终校验仍是不同的判据。只有完整原生修复证据、
|
||||
所有者与地址释放及同一工程后验 PASS/GREEN 全部成立才计为修复通过。缺健康
|
||||
备份、恢复旧版本、占用、超时或不完整证据不会提升为成功,也不会盲目重试。
|
||||
|
||||
协调端在保留旧地址字节的用户工程副本上观察到:官方工具报告数据库曾在服务器
|
||||
运行时被复制、工程当前未使用,随后官方 Repair 自行清除副本地址并返回成功。
|
||||
这证明了明确维护入口的必要性;原始用户库没有由本次开发或测试修改。实际按钮、
|
||||
冻结包及最终全套回归的实际验收结果见下。
|
||||
|
||||
## 修复后的本地读写访问提示
|
||||
|
||||
实际副本验证发现,原理图 iCDB Repair 成功并清除地址后,PCB 仍可能显示上次
|
||||
异常退出后的读写访问确认。这与选择恢复旧数据库不同。明确维护确认现在说明:
|
||||
仅在本地固定磁盘、严格确认修复后,工具可对本次启动的这一完整提示确认一次。
|
||||
|
||||
该授权不能由普通 Verify 或通用对话框规则开启。维护代码先验证完整原生修复
|
||||
证据,生成绑定原库、PRJ、PCB 的内部凭据。实际 PCB 启动前,重新确认地址缺失、
|
||||
无其他原生所有者,并同时独占读取 LMC、相关 icdb.dat 和选中 LayoutDB.lyt,
|
||||
在本次私有桌面生成短时有效的启动证据。出现提示时再核对当前 PCB 与启动器的
|
||||
实际 PID、父子关系、安装路径和完整设计参数,以及其他所有者缺失。
|
||||
|
||||
只接受原始完整英文提示正文(仅忽略空白差异)、精确窗口类型/标题和唯一可用
|
||||
Yes6/No7 按钮。专用代理在自己的私有桌面再次读取实际窗口和控件;先消耗授权,
|
||||
再发送一次按钮消息。没有证据、提示变更、重复提示、额外弹窗或身份不符均停止,
|
||||
不使用鼠标、前台输入或通用 Yes 回退。后续文档身份、保存关闭和 READY 判据不变。
|
||||
|
||||
路径必须经 GetDriveType 确认为 LOCAL_FIXED,且没有重解析点祖先。UNC、网络
|
||||
映射盘、可移动盘和链接路径不自动确认。该检查不宣称具备跨主机分布式排他能力;
|
||||
数据库只读句柄在交给官方 PCB 启动前释放,任意非协作外部写入者之间仍不存在
|
||||
跨进程原子事务保证。普通校验及其他数据库恢复选择继续保持硬性阻断。
|
||||
|
||||
## PCB 恢复版本待用户决定
|
||||
|
||||
后续实际副本已完成 iCDB Repair 和一次本地读写确认,但 PCB 又要求在“最后
|
||||
用户保存数据库”和“自动保存数据库”之间选择恢复版本。本次两项显示的日期
|
||||
均为 `2026/9/24 23:06`;同日期不代表内容相同,工具没有自动选择任何版本。
|
||||
|
||||
这类结果单独标识为 `PCB_VERSION_CHOICE_REQUIRED`,展示候选日期,并在
|
||||
`pcb-version-choice.json` 保存完整窗口和候选状态。维护摘要显示“ICDB 已修复 /
|
||||
PCB 版本待选”,原生状态仍为 REPAIRED,但整项保持未完成、需人工决定,不能
|
||||
计为 PASS/GREEN。工具也不会因为显示了某个默认选中项就认可该版本。
|
||||
|
||||
## 最终验证(2026-11-03)
|
||||
|
||||
程序源码提交 `d76475a`:全量 `python -m pytest -q` **969 passed,1 条已有
|
||||
pywinauto STA 模式警告,107.69 秒**;编译、diff 检查和代码复审通过。
|
||||
由不可变 `git archive d76475a` 构建的 EXE 通过 GUI 冒烟。
|
||||
|
||||
在第二份完整隔离库上,通过打包 EXE 的实际“非 READY ICDB 检查与修复”按钮
|
||||
确认并运行 IP101GR:有效旧阻止记录接续、旧地址完整备份、官方 Repair 成功并
|
||||
正常释放、一次受约束的读写确认均实际执行。之后准确停在原生 PCB 版本选择,
|
||||
显示 `version_choice_required=1`、`repair_unconfirmed=0`、`repaired=0`。
|
||||
这是维护入口和结果分类通过验收,不代表未经用户选版本就达到 READY。
|
||||
|
||||
原始证据:
|
||||
|
||||
- 用户最初 0.172 秒失败:`diagnostics/issue2-user-maintenance-20261103/user-reports/`。
|
||||
- 冻结 EXE 实际按钮:`diagnostics/issue2-user-maintenance-20261103/actual-button-frozen-d76475a/outcome.json`。
|
||||
- 原生版本选项:上述目录的 `data/evidence/verify-8fa461b6d6fe/pcb-version-choice.json`。
|
||||
- 全量测试:`build/issue2-maintenance-final-tests-d76475a.log`。
|
||||
|
||||
### 用户明确选择最后手动保存版本后的副本验证
|
||||
|
||||
用户选择“用最后手动保存版本继续验证”,授权范围仅为隔离副本。诊断续跑使用
|
||||
真实校验器、原生工作进程、对话框代理及权威状态读取;只为这次用户决定提供
|
||||
版本动作:先点击 6213,重新观察其已选中且 6206 未选中,再确认 OK 1。
|
||||
选择前保留完整工程副本;没有改变程序的默认版本选择规则。
|
||||
|
||||
工程成功打开并核对身份,但在原长路径下两次 Project Integration 均产生本轮
|
||||
JobPrefsDB.jpf / local Cell Library 加载错误。原文件、临时目录及备份中的 JPF/CEL
|
||||
可读且哈希一致,日志前缀与时间证明是本轮错误,不能断言二进制数据已损坏。
|
||||
|
||||
随后保持同一工程数据,通过临时本地 `T:` 短路径进行对照,完成原生 Integration、
|
||||
保存关闭、进程释放及权威状态查询,结果为 **PASS / GREEN / READY
|
||||
(IsVerifiedReuseBlock, raw=1),safe_to_continue=true**。所有原生进程退出后已移除
|
||||
该临时盘符。此结果说明短路径试验可通过,尚不能证明确切路径长度限制或永久
|
||||
解决原长路径下的 JobPrefs/Cell Library 兼容问题;产品没有自动增加短路径映射。
|
||||
|
||||
这是**用户指定历史版本后的恢复与验证**,不是无人值守或无损自动修复验收。
|
||||
验证后的完整库副本保留在 `diagnostics/issue2-user-maintenance-20261103/frozen-library/`,
|
||||
原用户库没有被替换。结果和选择证据分别位于:
|
||||
|
||||
- `user-authorized-last-saved-r2/user-selection-events.jsonl`(实际 6213 → 复读 → OK 1)。
|
||||
- `user-authorized-last-saved-short-path/result.json`(最终 PASS/GREEN)。
|
||||
- `short-path-trial.json`(临时盘符及正常退出后清理记录)。
|
||||
- `source-unchanged-after-user-choice.json`(全部试验后原库 21,013 个主要文件清单仍一致,原地址字节哈希未变)。
|
||||
|
||||
以上相对路径均位于 `diagnostics/issue2-user-maintenance-20261103/`。
|
||||
现场原工单其他工程、网络共享读写确认和 Windows 10 仍不能由此验收代替。
|
||||
|
||||
交付候选包为 `dist/issue2-maintenance-20261103-d76475a.zip`。不合并发布、不自动关闭工单。
|
||||
@@ -0,0 +1,46 @@
|
||||
# 工单 #2:用户实测失败后的修订记录
|
||||
|
||||
分支 `codex/temp-issue-2-icdb-recovery`。本轮修订不能视为现场验收通过;未合并、发布或关闭工单。
|
||||
|
||||
## 用户失败的实际原因
|
||||
|
||||
用户运行 `b26e2f2` 冻结包。真实日志位于程序旁的 `data` 目录。中心库存在有效的未释放会话检查点,应用进入文件系统恢复视图,因此管理按钮被禁用;旧界面没有清楚显示原因,禁用外观也像可用按钮。该次没有启动增删改操作。
|
||||
|
||||
ICDB 批次的首项 `1GPHY_8212` 在预检查报 `MAINTENANCE_TARGET_UNCONFIRMED`,原生 Repair 没有执行。旧检查硬性要求 `PCB/pcb.prj`,但该工程的 PCB 明确反向引用主 `1GPHY_8212.prj`。主 PRJ 指向 `database`;存在的 `PCB/template.prj` 不能当作活动工程猜测使用。后续八项被跳过。
|
||||
|
||||
## 修订
|
||||
|
||||
- 只有 PCB 唯一、精确反向引用主 PRJ 时,允许缺少辅助 `pcb.prj`。预检查、Repair 后重新打开、管理来源身份及库引用核对使用一致规则。`template.prj` 保持原样并参与资产哈希。
|
||||
- 显示库会话阻止横幅、管理禁用原因、灰色禁用按钮及首项具体失败阶段。
|
||||
- 集成校验跳过原生明确禁止调用、且已同步的动作;仍要求四项最终全部同步。必需动作被禁止或原生拒绝时继续判失败,不伪造通过。
|
||||
- 识别原生 EDIF 中数字开头的精确标识符,例如 `&1GPHY_8212`;不放松设计内容比较。
|
||||
- 私有桌面上的原生库编辑器若提示其他已确认缺少 PCB 的条目,只确认准确匹配的已知通知。当前目标、未知弹窗或身份不符的窗口不自动确认。
|
||||
- 原生新增共享明确截止时间;父进程超时发出取消信号。阻塞调用返回后,以及所有日志和证据 I/O 完成、提交 OK 之前,重新检查监督进程、取消状态及期限,防止超时后迟到写入。
|
||||
|
||||
## 隔离原生证据及限制
|
||||
|
||||
证据根目录为 `diagnostics/issue2-user-feedback-20261103/`。
|
||||
|
||||
完整现场库副本保留原生地址和所有工程文件,共 38,954 个文件。原用户库始终不参与写入,完整恢复新增结束后 `source-final-recheck.json` 再次确认 25,214 个主要文件与试验前完全一致。
|
||||
|
||||
`d36b6bc` 冻结程序的实际维护按钮已在该副本完成完整备份、官方 Repair、数据库地址释放及同一 PCB 重新打开。随后原生要求选择历史 PCB 数据,应用返回 `PCB_VERSION_CHOICE_REQUIRED`,没有显示修复完成。
|
||||
|
||||
用户选择最后手动保存版本(2026/9/24 15:15)后,在确切所属的隔离会话中继续。SynchCES 和 LoadCES 成功,但原生 BackAnnotate 仍报已验证工程不允许执行。未保存、未达到 READY,失败 PCB 已正常关闭。这段人工续接不算无人值守自动修复通过。
|
||||
|
||||
空隔离库中的重新导入及工程身份核对通过,但自动校验因目标缺少 PartsDB 分区失败,不能算完整校验通过。完整依赖库中的首次同名替换完成原生移除后,新增被其他条目缺少 PCB 的提示阻塞而超时;该部分失败的检查点及完整旧库备份保留在 `diagnostics/full-update-events/`,没有自动重放。
|
||||
|
||||
完整隔离库中 IP101GR 的旧数据库地址通过官方 Repair 释放,证据为 `dependency-ip101gr-native-only/result.json`。这只是依赖数据库的原生修复诊断,没有重新打开或 READY 验收。
|
||||
|
||||
修订后对缺失的 `1GPHY_8212` 显式执行恢复新增,启用自动校验;独立证据目录为 `diagnostics/full-recovery-events/`。结果为 `UPLOADED_VERIFIED`,`safe_to_continue=true`。已知的其他缺 PCB 条目提示被自动准确确认;新增后独立重读库、三种原生逻辑导出及主要资产比较通过。随后自动执行 ForwardAnnotate、SynchCES、LoadCES、BackAnnotate,四项最终均同步,保存、关闭和进程退出确认完成,权威 `IsVerifiedReuseBlock` 返回 `raw=1 / READY`。自动校验链路耗时 126.422 秒(不含完整备份和新增身份检查)。
|
||||
|
||||
最终结果为 `full-recovery-add-result.json`,完整检查点为 `diagnostics/full-recovery-events/management-03a9dbc537f84e0faaea2ad5a2a732c2/checkpoint.json`。此结果证明修订后**重新导入加校验**的恢复路径有效,不能替代直接 ICDB Repair 后仍被原生 BackAnnotate 拒绝的失败结论,也不把用户选择历史数据后的工程称为无损修复。
|
||||
|
||||
## 尚未满足的门槛
|
||||
|
||||
服务器会话失联经实际按钮触发、自动 Repair、重新打开、保存关闭及权威 READY 的完整链路仍需通过。历史数据选择及重新导入均可能改变恢复版本,不能宣称无损恢复。Windows 10 尚未验证;当前实机为 Windows 11 / Mentor EE7.9.5。
|
||||
|
||||
## 自动化验证
|
||||
|
||||
修订代码全量 `python -X utf8 -m pytest -q`:**1095 passed,171.09 秒**。保留一条已有 pywinauto STA COM 线程模式警告。`compileall`、`git diff --check` 通过。取消发生在日志证据 I/O 中的回归先复现错误提交,再验证修复;相关集中测试 108 项通过。独立审查已复核全部代码修订,最后一项取消时序 P2 已解决,没有剩余实质问题。
|
||||
|
||||
候选包按提交归档构建。最终冻结按钮冒烟结果及构建、压缩包校验记录分别保存在证据目录的 `final-frozen-buttons/result.json`、`build-result.json`、`package-result.json`;按钮冒烟只证明界面响应,不等于现场 ICDB 自动修复验收。
|
||||
@@ -0,0 +1,46 @@
|
||||
# 无地址 ICDB 维护及 PCB 版本选择
|
||||
|
||||
沿用 `codex/temp-issue-2-icdb-recovery` 临时分支。依据实际错误日志与公开资料修正入口,用户明确授权在需要时弹窗选择版本。应用自动备份仍取消,操作前保留手动备份提醒;未修改原用户库。
|
||||
|
||||
## 本次行为
|
||||
|
||||
- 明确发起 ICDB 维护时,不再因为没有 `sAddress.adr` 或协调检查点而跳过原生检查。
|
||||
- 无地址时,所选 PCB 必须唯一反向引用主 PRJ,工程内数据库映射必须唯一。多数据库、共享地址、路径身份不符、原生进程/脚本占用及无法独占读取仍停止。
|
||||
- 原生 Repair 成功并确认释放后,沿同一任务重新打开。若原生要求选择历史 PCB 版本,主应用显示实际候选时间和“最后手动保存 / 自动保存 / 取消”。不默认选择任一历史版本。
|
||||
- 用户选择后,私有桌面代理重新核对窗口、进程、候选时间及单选状态,再确认恢复。选择过期、窗口变化或执行失败不重试确认。等待期间应用保持响应;取消停止当前项并保留原生现场。
|
||||
- 最终仍要求集成校验、保存关闭、进程退出及权威 READY。使用了历史 PCB 版本时,即便校验通过,也记录 `RESTORED_REVIEW_REQUIRED`(已恢复,版本待核对),不标记为无损 Repair。
|
||||
- 未提供交互入口的调用保留待选择结果,不自动选版本;普通 Verify 不获得修复后授权。
|
||||
|
||||
## 过程证据
|
||||
|
||||
无地址隔离工程 IP101GR 经实际应用维护按钮完成原生 Repair,地址为空且进程退出。之后严格的修复后授权通过读写确认,继续到 PCB 历史版本选择。证据为 `diagnostics/noaddr-ui/evidence/maintenance-c05e9c4b06b2/result.json`。
|
||||
|
||||
用户此前已选择最后手动保存版本(2026/9/24 23:06)。首次诊断续接沿用该选择,完成校验、保存关闭,`IsVerifiedReuseBlock` 返回 READY/raw=1;记录在 `diagnostics/icdb-addressless-20261103/authorized-last-manual/result.json`。该次还通过诊断操作确认了保存弹窗,不能记为完整自动链路通过,因此继续实现上述应用内选择流程。
|
||||
|
||||
后续应用内选择试验两次在原生修复前被其他脚本占用阻止。进一步日志显示来自另一工具的并行 `run_bridge.vbs` 测试;没有强制结束或忽略该进程。失败记录保留在 `source-choice-button/`、`source-choice-button-retry/`。
|
||||
|
||||
## 验证边界
|
||||
|
||||
集中回归覆盖无地址选目标、地址变化、共享/多个数据库、修复后授权、选择/取消、版本日期改变、重复确认、原生动作失败、错 PID/桌面、真实单选状态复读和历史恢复归类。独立代码审查无剩余实质问题。
|
||||
|
||||
最终全量测试、冻结构建及实际按钮结果统一记录在 `diagnostics/icdb-addressless-20261103/`。本文件不将历史版本恢复视为无损修复,也不将模拟测试或人工续接替代最终冻结链路结果。
|
||||
|
||||
## 最终冻结包结果
|
||||
|
||||
程序源码提交 `de952a6`。全量 **1135 passed,228.63 秒**,一条已有 pywinauto STA COM 线程模式警告;编译、diff 检查及独立审查通过。候选程序从该提交的不可变归档构建。
|
||||
|
||||
最终试验使用原有完整隔离副本。先由官方 Repair 做独立准备,释放旧地址且不打开 PCB;这只用于构造此前真实遇到的无地址状态,不作为验收。启动最终冻结程序前确认:**地址为空、协调阻止检查点不存在**。
|
||||
|
||||
随后通过应用真实维护按钮执行,没有替换原生适配器或直接调用分阶段校验:
|
||||
|
||||
1. 原生检查确认未占用,执行 Repair,记录本轮原生日志并确认退出/释放。
|
||||
2. 同一工程重新打开,应用弹窗显示手动保存和自动保存日期均为 `2026/9/24 23:06`。
|
||||
3. 在应用弹窗选择用户此前已批准的最后手动保存版本。私有桌面代理完成单选复读及原生确认。
|
||||
4. 原有监督器自动处理保存 Reusable Block cell 提示,完成校验、保存、关闭及进程退出,无诊断脚本手动点击原生窗口。
|
||||
5. 权威 `IsVerifiedReuseBlock` 返回 `READY / raw=1`。最终 `PASS / GREEN / safe_to_continue=true`,恢复结果为 `RESTORED_REVIEW_REQUIRED`。
|
||||
|
||||
证据:`frozen-choice-button-retry/result.json`、`version-choice.png`,以及
|
||||
`diagnostics/choice-frozen-ui-retry/evidence/verify-7b0cd3fb8608/result.json`。
|
||||
之前被其他任务脚本阻止的各次试验均保留,没有计入成功。用户授权关闭并行测试时,该测试已经自行退出,因此没有终止 Mentor 进程或外来测试进程。
|
||||
|
||||
该结果证明本机 Windows 11 / EE7.9.5 上 IP101GR 的无地址维护、应用内用户选择和后续完整链路可执行;恢复采用历史手动保存版本,不证明无损保留了该版本之后的修改。未据此合并发布或关闭工单。
|
||||
@@ -0,0 +1,53 @@
|
||||
# 自动备份检查与调整
|
||||
|
||||
按用户 2026-11-03 最新要求:取消应用操作前自动备份,改为弹窗提示手动备份。本要求覆盖早期计划中的“必须完整备份后执行”。仍在 `codex/temp-issue-2-icdb-recovery` 临时分支,未合并或发布。
|
||||
|
||||
## 检查结果与调整范围
|
||||
|
||||
| 操作 | 检查到的旧行为 | 当前调整 |
|
||||
| --- | --- | --- |
|
||||
| 新增 CBB | 每项复制整个中心库,即使没有旧同名工程 | 取消,记录只读内容基线 |
|
||||
| 同名替换 | 每项复制整个中心库,再移除并导入 | 取消,保留逐项阶段及失败记录;失败时使用手动备份恢复 |
|
||||
| 移除 | 每项复制整个中心库 | 取消,原生移除后重新读库确认缺失 |
|
||||
| 普通校验 | 本地工程辅助备份,网络路径跳过 | 统一取消,记录 `manual_backup_policy` |
|
||||
| ICDB 修复 | 应用复制完整工程,原生工具另外备份 | 取消应用复制,保留独占访问、原生自身备份及成功证据要求 |
|
||||
| 从备份恢复 | 整库回退备份,再从中复制验证库;额外保留来源副本 | 去掉回退备份和重复来源副本,直接生成一份隔离验证库 |
|
||||
| 读取、搜索、筛选 | 无自动备份 | 保持只读 |
|
||||
|
||||
## 仍需生成的数据
|
||||
|
||||
- 新增/替换的来源暂存及原生内容导出副本:防止原生工具直接改写用户提供的源工程。
|
||||
- 恢复的隔离验证库:用于在安装前完成实际校验,会占用磁盘并花费复制时间,不能等同于未经修改的整库备份。
|
||||
- 恢复安装时保留旧 Work:仅同卷目录改名,不复制数据,用于安装失败时还原目录交换。
|
||||
- 工程库引用修正前的单个 PRJ 原文、日志、清单及检查点:属于轻量变更证据,不是工程或中心库备份。
|
||||
- Mentor 原生 Repair 自身生成的备份:属于原生修复流程,应用没有绕过。
|
||||
|
||||
独立研究探针中显式创建的实验备份及现存历史备份未删除。桌面生产路径不再触发上述旧的自动工程/整库备份辅助函数。
|
||||
|
||||
## 用户交互和约束
|
||||
|
||||
管理操作沿用原确认窗口,增加“应用不会自动备份,请先手动备份中心库及相关工程”。普通校验、维护、恢复同样在启动前提示;每批一次,取消不启动后台任务。应用不检查也不声称用户已经创建了手动备份。
|
||||
|
||||
取消备份不会取消串行任务、库锁、数据库独占检查、目标变更检查、来源身份核对、重新读库验证或未完成任务检查点。替换仍是移除后重新导入,非原子操作;部分失败必须使用手动备份及检查点恢复,不自动重放。
|
||||
|
||||
直接 ICDB Repair 的现场完整验收缺口仍保留,本次备份策略调整不代表该故障已解决。
|
||||
|
||||
## 隔离原生验证
|
||||
|
||||
在既有独立实验库 `diagnostics/reimport-8212/native-add/fixture/mentor_lib.lmc` 通过正式管理引擎实测:
|
||||
|
||||
- 原生移除 `1GPHY_8212` 后复读确认缺失,结果 `REMOVED`,安全释放,耗时 39.391 秒。
|
||||
- 随后原生重新导入同一独立来源,复读名称/分区、原生逻辑导出及主要资产身份确认通过,结果 `UPLOADED`,安全释放,耗时 101.359 秒。
|
||||
- 两项操作均没有生成 `library-before` 整库备份,来源主要文件清单未变。测试未启用自动校验,不将上传成功解释为 READY。
|
||||
|
||||
证据:`diagnostics/manual-backup-20261103/native-cycle-result.json`、`native-cycle-accepted.json` 和 `diagnostics/mb-events/`。上述耗时包含原生启动、复读和内容检查,不能当作与旧版同环境对照的提速比例。
|
||||
|
||||
开始实测前发现上一版应用在完整隔离库 IP101GR 上保留了“继续以读写方式打开”提示。仅向已核对进程命令和私有桌面的该提示发送“否”,两个 PCB 进程正常退出;没有强杀、保存或删除原生地址。原失败证据与取消记录保留在 `previous-test-cancel.json`。随后通过正式释放检查解除小实验库旧阻止记录,未绕过库锁。
|
||||
|
||||
## 代码验证
|
||||
|
||||
最终全量 Python 回归:**1111 passed,192.49 秒**,一条已有 pywinauto STA COM 线程模式警告。集中回归 297 项通过;占用检查修订后相关 151 项通过。编译及 diff 检查通过,独立复审无剩余实质问题。
|
||||
|
||||
审查发现取消整库复制时一并丢失了全库数据库独占检查,已改为不复制数据的 `build_exclusive_library_manifest`:记录基线和写入前检查均同时持有所有 `.lmc` / `icdb.dat` 的独占读取句柄。回归覆盖主库、共享库、其他 CBB 数据库仍被共享读取句柄占用的情况,确认未进入原生写入。
|
||||
|
||||
候选包从提交归档构建。最终冻结程序手动备份提示及取消测试记录位于 `diagnostics/manual-backup-20261103/frozen-prompts/result.json`,构建和交付信息保存在同一证据目录。
|
||||
@@ -0,0 +1,77 @@
|
||||
# 原生 CBB 增删改查接入与候选包验证
|
||||
|
||||
程序源码提交:`b26e2f2f6232c22a94ee1269bd4449fe0fe06623`。
|
||||
分支:`codex/temp-issue-2-icdb-recovery`。本地候选包,未合并、未发布、未关闭工单。
|
||||
|
||||
## 已接入的操作
|
||||
|
||||
| 操作 | 原生入口与验收条件 |
|
||||
| --- | --- |
|
||||
| 读取 | `LibraryManager.Application.OpenLibrary`、`Partitions(7)`;核对库身份、分区和条目,正常关闭会话。 |
|
||||
| 新增 CBB | `OnReusableBlocksEditor` → Logical-Physical → New;私有桌面 UIA 和有时限的控件消息提交完整 PRJ,确认成功提示后关闭重开库,再核对工程内容。重名拒绝覆盖。 |
|
||||
| 用工程替换已选 CBB | 完整工程及中心库备份 → 原生移除 → 原生重新导入 → 重新读库和内容核对。失败保留恢复证据并停止后续写操作。 |
|
||||
| 移除已选 | 安装脚本确认的 `CleanWGLib.exe <lmc> F4 <list>`,输入为 `REUSE_BLOCK`;先完整备份,要求明确 Removed 输出,再重新读库确认不存在。 |
|
||||
|
||||
“用工程替换已选 CBB…(原生重新导入)”与已有“从备份恢复 CBB…”是不同操作。前者更新中心库注册条目,采用移除后重新导入,**不是原子替换**;后者沿用备份 Work 的副本验证与安装恢复流程。
|
||||
|
||||
新增和替换默认继续自动校验,允许批次开始前取消。结果分别显示上传失败、上传成功但校验失败、上传并校验通过;取消自动校验时明确显示“已上传 / 未自动校验”。
|
||||
|
||||
## 支持范围与保护
|
||||
|
||||
- 已验证本机 Mentor EE7.9.5、DxDesigner、Logical-Physical、ASCII CBB 名称。原生核心组件和三种内容导出程序均核对固定 SHA-256;接口或版本不符时禁用并显示原因。
|
||||
- 所有写操作使用串行任务、共享互斥和上传工具兼容的库锁;暂存来源、完整备份、目标身份、事务随机标识、监督进程及实际独占句柄必须相互匹配。
|
||||
- 不直接修改 LMC 二进制,不依赖独立上传工具安装目录,不退回前台鼠标。遇到中心库升级或流程选择提示拒绝自动迁移。
|
||||
- 原生导入会改写 ICDB 存储字节。内容身份采用官方 ASCII、CSV 和 EDIF 原理图导出,加上 Layout、约束及其他主要资产的 SHA-256。只规范化已实测的报告时间和路径字段;未知工程文件继续参与比较。
|
||||
- 原生复制可能留下不正确的 PCB 库相对引用。仅在本任务导入、会话释放及库锁持有得到确认后校正已导入副本,再复读目录与内容。原始来源不改写。
|
||||
- 导出副本所有权随库检查点持久保存;超时、重启、地址记录仍存在或进程、独占访问无法确认时,不能解除库锁或接续维护。
|
||||
- 完整来源和预计目标路径达到 260 个 UTF-16 单元时,在原生写入前拒绝;同名替换在移除旧条目前检查。保留所有文件,提示缩短操作数据或目标库路径,不宣称已实现原生长路径支持。
|
||||
- 本轮已确认的原生复制失败即时记录。只正常确认本任务进程的已验证错误对话框;未知提示不自动点击,会话释放不明确时保留阻止状态。
|
||||
|
||||
## 实际验证
|
||||
|
||||
环境:Windows 11,版本 `10.0.26200`;Mentor EE7.9.5。
|
||||
|
||||
### 原生完整管理引擎
|
||||
|
||||
真实新建隔离库完成:新增 A、拒绝重复名称、替换为 B、备份后移除、将独立备份工程重新导入。各项会话均安全释放。B 的 Layout 哈希与 A 不同,并与来源 B 一致。原始来源主要文件清单未变。
|
||||
|
||||
证据:`diagnostics/issue2-native-crud-20261103/engine-e2e/cycle-result.json`。
|
||||
|
||||
### 最终冻结程序公开界面
|
||||
|
||||
从应用真实按钮、来源文件选择器和确认清单执行,没有替换原生适配器或绕过能力检查。
|
||||
|
||||
| 试验 | 结果 |
|
||||
| --- | --- |
|
||||
| 275 字符暂存路径 | `UPLOAD_FAILED`,明确 `NATIVE_PATH_TOO_LONG`,`safe_to_continue=true`;未启动内容导出或原生 Add。 |
|
||||
| 正常路径新增 A | `UPLOADED`,重新读库与工程内容核对通过。 |
|
||||
| 同名替换为 B | `UPLOADED`,实际 Layout 匹配 B 且不同于 A。 |
|
||||
| 原生移除 | `REMOVED`,重新读库确认不存在。 |
|
||||
| 最终退出与来源检查 | 原生进程已退出;两份来源的 153/147 个主要文件哈希及 541/506 个文件的大小、修改时间保持一致。 |
|
||||
|
||||
证据位于 `diagnostics/issue2-native-crud-20261103/`:
|
||||
|
||||
- `frozen-public-ui-path-block/result.json`:写入前长路径拒绝。
|
||||
- `frozen-public-ui/result.json`:最终冻结程序完整按钮流程及截图。
|
||||
- `final-source-baselines.json`、`final-acceptance.json`:来源和会话释放证据。
|
||||
- `build-result.json`、`validation.json`、`package-result.json`:源码、测试、构建和包校验记录。
|
||||
|
||||
本轮 CRUD 原生及冻结界面试验均在批次开始前取消自动校验,**上传成功不等于 READY**。这些结果不能代替上传后完整 Verify/Save/Close 或现场 ICDB 失联修复验收。
|
||||
|
||||
### 实测发现并修正的长路径问题
|
||||
|
||||
初版冻结程序在 264 字符暂存文件路径下弹出“系统找不到指定的路径”,日志记录 `Cannot copy iCDB base of Reusable Block project`,旧逻辑只检查成功提示,直到超时才返回。该失败未计入通过。
|
||||
|
||||
对同一文件,旧式 32 位 Win32 CopyFile 复现错误码 3;保持同一冻结程序、测试库、完整来源和空描述,仅缩短暂存路径后,原生新增和内容核对通过。最终修订增加完整路径预检和本轮失败识别,并在新冻结包实测提前拒绝。没有删减长路径中的日志或其他文件来绕过问题。
|
||||
|
||||
保留原始失败、正常关闭及库锁重新核验记录:`frozen-public-ui-longpath-failed/`、`longpath-failure-release/`、`longpath-failure-catalog/`、`path-copy-probe/`、`frozen-public-ui-shortpath-control/`。
|
||||
|
||||
## 自动化验证与交付
|
||||
|
||||
- 全量 `python -m pytest -q`:**1071 passed**,90.98 秒,1 条已有 pywinauto COM 线程模式警告。
|
||||
- `python -m compileall -q src tests`、`git diff --check`:通过。
|
||||
- 独立整体代码审查及长路径修订复审:无未解决的实质问题。
|
||||
- 从提交归档构建冻结程序,启动与退出冒烟测试通过;上述公开界面验收使用同一构建。
|
||||
- 候选包:`dist/issue2-native-crud-20261103-b26e2f2.zip`,旁附 SHA-256;包内含使用说明及验证摘要。
|
||||
|
||||
尚未完成 Windows 10 实机验证,也未将本轮 CRUD 试验视作现场服务器会话失联修复通过。旧版库迁移、其他 Mentor 版本、非 Logical-Physical 分区及原生长路径支持不在已验证范围。原用户库不参与本轮写入试验。
|
||||
@@ -0,0 +1,24 @@
|
||||
# ICDB 失败后的副本恢复入口
|
||||
|
||||
原生修复失败、缺少有效备份,或 Repair 后完整校验失败时,结果窗口提供“选择副本恢复…”;主窗口保留“选择工程副本恢复失败项…”,允许关闭结果窗口后继续。单纯占用、未知诊断、仅检查或成功结果不提示替换。
|
||||
|
||||
入口固定使用本次失败任务的库、名称和分区,不使用用户后来勾选的其他条目。切换中心库使旧入口失效。选择的是库外完整工程的 PRJ 文件,相关 PCB、数据库和依赖资料仍由现有来源检查验证。
|
||||
|
||||
点击入口只打开来源选择窗口。用户明确确认手动备份、目标库、目标条目及副本后,才在后台检查释放,并复用现有原生移除/导入流程;不自动备份整个库,不自动删除目录代替原生操作。自动校验默认开启。
|
||||
|
||||
释放检查继续要求原生所有者退出、数据库地址记录处理完毕及独占可读。WMI 查询通过最多 10 秒的只读助手执行,超时不当作空闲;同时检查脚本与校验/修复工作进程。检查不通过显示具体原因、保留阻止记录和恢复入口。未完成的管理写入仍不自动重放。
|
||||
|
||||
原维护失败记录保持原样。副本恢复建立独立 `reimport-recovery/*/recovery.json`,关联原证据、来源、释放检查和管理结果。上传成功但校验失败继续显示失败;上传并取得 READY 后显示“副本恢复校验通过,版本待核对”,不改称原 ICDB 无损修复成功。
|
||||
|
||||
按用户要求精简界面:默认只展示目标、副本选择、备份确认和操作结果。开发流程说明已移除,诊断细节和证据路径放入默认收起的日志。恢复执行前仍明确说明先移除原条目再导入副本。
|
||||
|
||||
## 验收边界
|
||||
|
||||
- 核心流程专项测试 57 项通过;随后新增的两项主窗口取消/退出复核回归均先复现失败再通过。
|
||||
- 完整回归记录为 **1,194 passed / 1 failed**(1,013.66 秒)。该运行启动后用户要求精简 UI,已收集的测试仍断言旧文案“尚未修复成功”,运行时加载的界面已使用“修复未完成”,因此失败。未把该次结果标成全量通过。
|
||||
- 最终界面与更新后的测试重新验证 **77 passed**(43.00 秒),包含该失败用例及新增的日志默认收起检查。其余产品逻辑未在此期间修改。
|
||||
- 编译、差异检查、独立审查通过。最终冻结构建及启动/正常退出、占用辅助进程冒烟通过,EXE 内 5 个关键模块与当前源码一致。记录在 `diagnostics/copy-reimport-20261104/`。
|
||||
|
||||
本次验证覆盖 Qt 真实事件循环中的按钮、取消、来源确认、后台等待及故障分支,原生写入边界使用替身,不把这些测试当作 Mentor 修复验收。
|
||||
|
||||
既有隔离副本仍有 `IP101GR/Work/database/cdbsvr/sAddress.adr`,因此完整库释放条件目前不满足。该情况不能通过忽略地址或强制清除检查点解决,需要先处理对应工程。此前 `1GPHY_8212` 的原始 Repair 后 BackAnnotate 失败结论保持不变,工单未关闭。
|
||||
@@ -0,0 +1,29 @@
|
||||
# ICDB 维护审查修正(候选)
|
||||
|
||||
替代 `8180a8a` 的诊断实现。该旧候选曾把完整校验当作诊断,且存在缺失证据后直接进入 Repair 的分支,不应继续用于原库。
|
||||
|
||||
## 行为
|
||||
|
||||
- READY 始终不进入维护或默认备份恢复队列,即使被勾选。混合选择只处理可见的、可用的非 READY 项;全部 READY 时没有可执行目标,不回退到处理 READY。
|
||||
- 先取得上传工具兼容的库锁,验证检查点、工程身份、进程和数据库独占访问,再启动诊断。
|
||||
- 独立的 `diagnostic_only` 模式只打开并确认目标,随后通过原生 `Close(False)` 关闭。不执行 Project Integration、保存、原生 LM Verify 菜单、工程库路径改写或 READY 校验。Mentor 启动本身仍可能生成运行日志/地址记录,因此不宣称整个原生过程绝对只读。
|
||||
- 诊断拒绝配置中指向其他中心库的引用,包含缩进/制表符格式。不会为了检查而改写引用。
|
||||
- 原生关闭助手最多调用一次。关闭返回后最多观察 30 秒的进程/地址释放;超时保留现场并停止。
|
||||
- Repair 只接受本次独立证据目录中的结构化 `ICDB_REPAIR_REQUIRED` 记录,要求工程级范围、会话身份和精确匹配的数据库路径。修复前再次确认目标及释放状态。
|
||||
- 删除通过 Python 函数名、模块名判断可信度的逻辑,以及吞掉断言/pytest 失败后直接修复的分支。缺少证据、通用数据库安全错误、其他工程或历史轮次证据均不能授权 Repair。
|
||||
- 诊断通过在报告中单列“启动检查通过、未修复”,不冒充修复完成或 READY。只有修复后完整校验取得权威 GREEN/READY 才算修复验证通过;历史恢复仍需核对版本。
|
||||
|
||||
## 验证范围
|
||||
|
||||
- 最终从 `ef652f3` 导出的固定源码运行完整回归:`python -X utf8 -m pytest -q --tb=short`,**1,151 passed,375.48 秒**;仅既有 pywinauto STA 警告。
|
||||
- 此前的专项覆盖包括库锁、证据缺失/其他工程/历史轮次、无集成保存、关闭失败、路径格式、READY 选择范围和延迟退出。最终源码副本与构建输入哈希已核对。
|
||||
- `compileall` 与 `git diff --check` 通过。
|
||||
- 独立审查发现并修正重复关闭和路径格式遗漏;冻结构建和启动结果另存于 `diagnostics/icdb-review-20261104/`。
|
||||
- 冻结启动/退出检查返回 0;EXE 内 5 个变更模块与固定源码编译结果一致;ZIP CRC 校验通过。
|
||||
- 最终候选:`dist/issue2-icdb-reviewed-ef652f3.zip`,50,871,172 字节;SHA-256:`f4565f1696caf620522d621bd8555817a6d7d5d6ed4193cf87f2b53758a5d8c7`。构建和测试证据对应代码提交 `ef652f3ada0b9b8422e49f2ebc5b18305204d8ab`。
|
||||
|
||||
## 保留的限制
|
||||
|
||||
本轮不在原库执行原生操作,未重新完成现场失联故障的端到端验收。仅有 `sAddress.adr`、历史版本选择提示或一般数据库错误不足以认定 ICDB 损坏;这些情况会停止并保留证据,不自动 Repair。若原生启动后会话未释放,也不会继续修复或处理下一项。
|
||||
|
||||
本候选不推送、不合并发布、不关闭工单。测试中的模拟边界用于验证队列和安全条件,不代替现场 Mentor 验收。
|
||||
@@ -0,0 +1,52 @@
|
||||
# 原生占用检查候选:完整修复验收失败
|
||||
|
||||
本记录更新此前 `2026-11-04-icdb-review-fixes.md` 的维护入口说明。工单 #2 保持未解决;本候选不合并、不发布正式版、不关闭工单。
|
||||
|
||||
## 本轮改动
|
||||
|
||||
- 维护入口先调用原生 iCDB Project Backup 的工程加载/占用检查,不先打开 PCB。旧 `sAddress.adr` 只是待核实证据,不再单凭它阻断检查,也不删除或改写该文件。
|
||||
- 仅本轮 Output 明确绑定目标工程、目标数据库,确认未占用且要求 Repair,原生检查正常退出,并再次通过工程身份和占用检查,才调用一次 Repair。其他工程、共享库、未知错误或未释放会话均阻止后续操作。
|
||||
- WMI 占用查询在独立只读辅助进程执行,最多 10 秒;超时是未知,不是空闲。文件扫描在后台运行并支持取消。原生准备阶段预算 60 秒,另加原生操作超时及 5 秒监督余量;取消后再次核对,避免迟到启动。
|
||||
- 停止请求传入维护流程,原生写入不强杀;释放未确认时停止后续批次。仅检查结果使用 `CHECKED`,不计入修复成功。READY 即使已勾选也不进入维护。
|
||||
- 精确的 verified/once-verified Reusable Block BackAnnotate 拒绝归类为 `CBB_REIMPORT_REQUIRED`,不再被后续释放告警掩盖。该分类不会执行重导入,也不改变 `safe_to_continue`;原生错误及释放错误都保留在报告中。
|
||||
- 历史版本选择继续通过应用弹窗;只有完整校验及权威 READY 通过才允许成功。历史恢复仍标记版本待核对。
|
||||
|
||||
## 隔离环境实测
|
||||
|
||||
证据根目录:`diagnostics/native-occupancy-20261104/`(含本机路径和原生日志,不纳入 Git)。测试通过实际应用维护按钮和版本选择弹窗完成,没有以手工分阶段调用替代验收。
|
||||
|
||||
一致副本包含 38,954 个文件、1,220,129,120 字节。复制期间源文件集合/大小/修改时间一致,253 个主要文件 SHA-256 核对通过;追加目标 PRJ/PCB 后,最终再次核对原库的 255 个已记录文件,全部未变化。原库未执行写操作。
|
||||
|
||||
最终尝试 `source-ui-fourth`,目标 `1GPHY_8212`:
|
||||
|
||||
1. 原生检查明确返回未占用,并指出当前数据库不一致、要求 Repair。
|
||||
2. 原生 Repair 创建自身备份,完成数据库检查、整理和关闭,返回 `Project should now be fixed.`,并确认退出释放。
|
||||
3. 应用弹窗选择用户已授权的最后手动保存版本(2026/9/24 15:15),重新打开同一工程。
|
||||
4. SynchCES、LoadCES 通过;BackAnnotation 为 Required,实际调用被 Mentor 拒绝:`Back Annotation is not allowed on verified (or once verified) Reusable Blocks.`
|
||||
5. 未完成保存与 READY 校验。最终 **FAIL / UNKNOWN / REPAIR_VALIDATION_FAILED**,`validation_passed=false`、`safe_to_continue=false`。原生 Repair 完成不等于整体修复成功。
|
||||
6. 失败关闭助手记录 Close/Quit 成功,但最终释放检查仍看到 PID 21968,因此保留检查点并停止批次。后续只读复查该原生进程已消失;这不追溯修改原失败结果。测试应用关闭结果对话框后正常退出。
|
||||
|
||||
实测界面响应记录:614 次 WM_NULL 检查,200 毫秒超时 0 次,最大约 78 毫秒。这只证明本次运行的界面响应,不保证任意网络故障下所有系统调用可立即取消。
|
||||
|
||||
关键证据:
|
||||
|
||||
- `source-ui-fourth/acceptance.json`:`accepted=false`。
|
||||
- `source-ui-fourth/evidence/maintenance-43479c21aa59/result.json`:完整维护结果。
|
||||
- `source-ui-fourth/evidence/maintenance-43479c21aa59/native-repair/repair-result.json`:原生 Repair 证据。
|
||||
- `source-ui-fourth/evidence/verify-99a675e0399c/`:重新打开、集成拒绝、正常关闭及释放未确认记录。
|
||||
- `source-ui-fourth/ui-responsiveness.json`、`version-choice.png`、`finished.png`。
|
||||
- `source-final-check.json`:原库 255 个哈希均保持不变。
|
||||
|
||||
## 代码与冻结候选验证
|
||||
|
||||
- `python -X utf8 -m pytest -q --tb=short`:**1,176 passed**,302.56 秒;1 条既有 pywinauto STA 警告。
|
||||
- `compileall`、`git diff --check`、独立只读代码审查通过。
|
||||
- PyInstaller 构建通过;冻结程序创建主窗口及正常退出通过,新 `--owner-probe` 在冻结程序中返回有效结果。
|
||||
- EXE 内 11 个变更模块与当前源码编译结果一致。验证脚本及结果在证据根目录的 `check_candidate.py`、`frozen-result.json`。
|
||||
- 本地候选目录:`dist/issue2-native-occupancy-candidate/`。冻结包完整故障修复链路未执行,不能称为已验收的修复包。
|
||||
|
||||
## 尚未解决
|
||||
|
||||
已验证或曾验证的 CBB 注册状态限制仍阻止 BackAnnotate。不能跳过 Required 操作、强行设置 READY 或把移除/重导入偷偷加入 ICDB Repair。此前隔离试验的独立重导入路径见 `2026-11-03-field-feedback.md`,其行为涉及库条目更新,不能据此宣称本次无损修复通过。
|
||||
|
||||
本轮没有完成 Windows 10/11 双系统验收;冻结包的完整现场故障链路仍需验证。程序测试和启动冒烟均不能代替上述失败的实际验收。
|
||||
@@ -0,0 +1,45 @@
|
||||
# 三页界面与原生检查、退出修正
|
||||
|
||||
界面按“检验 / ICDB 维护 / 中心库管理”横向切换,共用中心库、清单、搜索和选择状态。默认收起运行日志,长状态信息限制高度,避免纵向堆叠操作区或报错撑长窗口。1000×620 布局预览保存在本轮诊断目录中。
|
||||
|
||||
## 本轮现场日志定位
|
||||
|
||||
用户运行的是 `29959e2` 冻结包。2026-11-04 14:21(北京时间)的维护在原生检查启动后报 `(2, 'EnumWindows', '系统找不到指定的文件。')`,并没有调用 Repair。随后手动释放检查发现 `1GPHY_8212`、`IP101GR` 的地址记录仍存在;它们不能直接当作已释放或直接删除。第二次在准备检查时取消,助手没有及时结束文件扫描。
|
||||
|
||||
## 修正
|
||||
|
||||
- 在实际空私有桌面复现了 Win32 旧错误码问题:先 `SetLastError(2)` 再枚举空桌面,pywin32 会报与现场相同的错误。现在枚举前清零旧错误;真实枚举异常继续上报,不把未知错误当作空闲。
|
||||
- 将取消信号传入修复助手的文件扫描。文件标记最多每 100 毫秒读取一次,取消后锁存;原生启动、Repair 命令和确认前仍立即读取取消信号。冻结实测曾因逐文件读取取消标记而在启动前超时,节流后已推进至实际原生检查和 Repair。
|
||||
- 手动备份模式下,助手只在启动前执行一次完整目标保护,移除原先自动备份取消后留下的重复检查。同一保护内复用初始完整扫描作地址和文件选择,取得全部独占读句柄后再做第二次完整扫描;地址变化或原生文件集合增删均停止。没有复用跨操作的旧快照。
|
||||
- 发出唯一正常关闭请求前仍严格确认任务进程、工程、私有桌面、空闲窗口和地址状态。关闭后只等待进程、启动器及地址释放,不再因退出途中 WMI 暂时缺少命令行而提前报身份未确认,也不再次关闭窗口。未实际退出仍保留未释放状态。
|
||||
|
||||
## 已有验证记录
|
||||
|
||||
本轮证据目录为 `diagnostics/tabs-release-20261104/`,含本机路径,不提交原始数据。
|
||||
|
||||
- 初轮完整回归 1,200 项通过,2 项旧测试替身未接收取消参数;同步接口后维护模块 48 项通过。
|
||||
- 扫描优化后的维护、原生修复等相关测试 225 项通过;随后退出等待等 91 项通过。包含实际私有桌面的 Win32 回归,而不只是窗口模拟。
|
||||
- 冻结程序取消试验 `frozen-cancel-local`:预检查中取消约 0.61 秒返回,未启动原生 Repair,应用正常退出。
|
||||
- 源码实际入口 `source-optimized`:原生确认未占用并要求修复,Repair 成功,按用户授权恢复最后手动保存版本;最终因 verified/once-verified CBB 禁止 BackAnnotate 失败。PCB 正常关闭,没有附加 PCB 释放未确认错误。
|
||||
- 冻结实际入口 `frozen-polling`:原生检查及 Repair 已完成,取消标记只读取 214 次、耗时 0.313 秒。随后 PCB 因数据库服务器启动晚于客户端截止时间而加载失败。服务器日志显示它后来实际启动并自行关闭,不据此宣称完整修复通过。
|
||||
- 同一次失败退出中,先记录了 `startup_close_requested`,随后 WMI 缺少进程信息导致 `STARTUP_PROCESS_UNCONFIRMED`,下一秒却已确认进程退出;该具体时序已转为回归测试。
|
||||
|
||||
最终完整回归:**1,207 passed**,588.26 秒,仅既有 pywinauto STA 警告;记录在 `pytest-final.log` / `pytest-final-result.json`。最终冻结构建、启动退出冒烟和 6 个关键模块的源码一致性检查通过。独立审查未发现剩余必要缺陷。
|
||||
|
||||
最终冻结实际入口为 `frozen-local-final`,使用 `C:\Temp\CbbTabsRelease20261104\library` 的独立副本:原生 `NOT_IN_USE` 且明确要求修复 → Repair 完成并释放 → 重新打开同一 PCB → 用户已授权的最后手动保存版本(2026/9/24 15:15)→ SynchCES / LoadCES → BackAnnotate 被原生拒绝。最终 **FAIL / UNKNOWN / REPAIR_VALIDATION_FAILED**,未取得 READY;退出记录确认进程结束,没有附加 `PCB_RELEASE_UNCONFIRMED`。应用正常退出返回 0。此前服务器迟启动的失败记录保留,不能从一次对照断定其全部成因。
|
||||
|
||||
原库 255 个已记录主要文件哈希复核全部未变,见 `source-final-check.json`。
|
||||
|
||||
最终包的 `frozen-cancel-final` 再次验证取消:约 1.16 秒返回,检查助手报告 `CANCELLED`,批次保持 `BLOCKED`,未启动 Repair,应用正常退出。取消只证明操作已停止,不计作修复成功。
|
||||
|
||||
## 验收限制
|
||||
|
||||
原库未执行本轮自动化写入。第一套 F 盘测试副本出现目录枚举属性与直接读取属性不一致,被链接检查阻止,未绕过检查。测试随后迁移到独立本机目录;`C:\Users` 目录会被 Mentor 转成共享路径,因此最终试验选择独立的 `C:\Temp` 路径,并保留前序失败记录。
|
||||
|
||||
完整 ICDB 修复仍必须取得权威 READY;原生 Repair 成功、能够取消、正常关闭或界面测试通过都不能替代该验收。未合并发布,工单保持未解决。
|
||||
|
||||
## 结果展示收尾
|
||||
|
||||
实际冻结运行截图还暴露了结果弹窗包含长路径和 COM 异常、错误列挤压 CBB 名称的问题。结果正文改为简短计数、用户可理解的失败原因和副本恢复入口;原始异常、统计明细及日志路径保留在可展开详情和日志中。名称与结果列共同分配可用宽度,长内容不再把表格撑出窗口。历史备份待核对和待选 PCB 版本仍直接提示。
|
||||
|
||||
该收尾只调整展示,不改变占用检查、关闭、Repair、校验或恢复行为。以已保存的真实失败结果回放检查布局,未额外写入原生库。相关界面、筛选和副本恢复回归 84 项通过;记录为 `pytest-presentation.log` / `pytest-presentation-result.json`。原先完整回归 1,207 项及冻结原生流程的失败结论仍分别保留,不能把展示回放当作新增原生验收。
|
||||
@@ -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)。
|
||||
@@ -0,0 +1,27 @@
|
||||
# CBB Verify v0.2.3-beta.1
|
||||
|
||||
**Beta 预发布,供隔离副本和小范围现场验收使用。**
|
||||
|
||||
版本标识:`0.2.3b1`;Git 标签:`v0.2.3-beta.1`。
|
||||
|
||||
## 本版内容
|
||||
|
||||
- 增加“全库 ICDB 检查与修复”维护入口,包含 Ready 项、串行进度、结果统计和维护报告。
|
||||
- 增加“从备份恢复 CBB…”弹窗:选择同名 CBB 的完整工程 `.prj` 备份,先在独立短路径副本中验证,再保留原 Work、恢复目标并重新打开校验。
|
||||
- 恢复只有在原生打开、集成、保存关闭、进程释放和权威 `READY / raw=1` 全部满足时才报告成功;失败保留回退副本并清除旧绿色状态。
|
||||
- 加强 ICDB 会话所有权、原生修复备份恢复状态、目录链接/外部路径检查和异常 worker 的安全处理。
|
||||
- 补充真实损坏工程恢复记录、无历史备份边界说明、手动原生修复文档和自动化验证脚本。
|
||||
|
||||
## 验证记录
|
||||
|
||||
- `python -m pytest -q`:471 passed,1 条既有 pywinauto STA 提示。
|
||||
- `tests/CBBRefresh.Core.Tests.ps1`:通过。
|
||||
- `tests/ContentCheck.ExitCode.Tests.ps1`:通过。
|
||||
- EE7.9.5 隔离实测:破坏 ICDB 文件头后实际打开失败;通过恢复弹窗恢复同名完整备份;同一目标重新打开达到 `PASS / GREEN / READY (raw=1)`。
|
||||
- PyInstaller 构建和冻结程序 smoke 检查通过。
|
||||
|
||||
## 范围限制
|
||||
|
||||
恢复功能支持已有同名 CBB 的完整工程备份,不自动删除旧库条目,不实现跨库重导入或共享符号数据库重建。共享库损坏、外部路径引用、不完整备份和未释放原生会话会停止操作。恢复采用用户选择的备份版本,发布前请在隔离副本和现场版本上复核。
|
||||
|
||||
详细实机记录:[2026-10-28-cbb-backup-dialog-validation.md](2026-10-28-cbb-backup-dialog-validation.md)。
|
||||
@@ -0,0 +1,42 @@
|
||||
# iCDB failure lifecycle and recovery implementation plan
|
||||
|
||||
**Goal:** Prevent failed verification from aborting iCDB owners, close owned idle failed documents normally, and attempt native recovery only against a validated idle target with a complete backup.
|
||||
|
||||
**Context:** User confirmed the incident used r4 or earlier. r4 enables `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, calls `TerminateJobObject` and `taskkill /T /F` on failures and native owners. a11eb3c removed those PCB paths, but content-check timeout still kills a process tree. Failed worker exceptions currently release COM references without requesting normal document closure.
|
||||
|
||||
**Architecture:** Keep native transactions alive through timeouts. Signal cooperative cancellation to the worker; let blocking native calls return before closing a document. A separate recovery module owns target checks, backup and the official GUI repair transaction; failed or ambiguous repair remains failed. Work and central-library database ownership are checked separately.
|
||||
|
||||
**Tech stack:** Python 3.12, Windows process handles/private desktops, x86 cscript and Mentor EE7.9.5 native tools. Continue on `codex/icdb-lost-session-diagnostics`.
|
||||
|
||||
## Task 1 — Retain native owners on content timeout
|
||||
|
||||
- [x] Add a regression that starts a harmless importer with a harmless child, times out, and checks both survive until normal exit or test cleanup.
|
||||
- [x] Add a content-timeout batch regression proving the second item does not start.
|
||||
- [x] Remove tree/client termination from `_run_process` timeout; retain/drain the process in a background observer, record PID/command/release in evidence, and return TIMEOUT with `safe_to_continue=False`.
|
||||
- [x] Verify targeted tests and the existing content-check tests.
|
||||
|
||||
## Task 2 — Normal close of failed owned sessions
|
||||
|
||||
- [x] Add x86 cscript harness tests for failed Save and close-only operation, checking `Close(False)`, reference release and Quit, with failure status preserved and mismatched identity untouched.
|
||||
- [x] Implement an identity-checked close helper and call it only after the worker has returned from its native call and released Python references. Retain busy helpers instead of terminating them.
|
||||
- [x] Add cooperative cancellation at Python/VBS native-operation boundaries; a supervisor timeout/crash must not terminate a pending native Save.
|
||||
- [x] Add targeted tests for cancel before Save, cancel after a pending call returns, supervisor loss and blocked native-call retention.
|
||||
- [x] Check shared `SymbolLibs/__ReusableBlocksSymb` ownership as well as Work/PCB database ownership before writing and before declaring release.
|
||||
- [x] Give the status reader an EOF shutdown grace period before any fallback termination.
|
||||
|
||||
## Task 3 — Attempt official native recovery
|
||||
|
||||
- [x] Probe native UI on new isolated copies only; record accepted project/database identity, exact command, backup creation and completion signals. Do not invent CLI Repair flags or manipulate native ownership metadata.
|
||||
- [x] Add recovery-policy tests: reject foreign/unresolved targets, active clients, inconsistent backups and repeat repair; preserve the original error; at most one recovery attempt.
|
||||
- [x] Implement the supported native repair route with a complete backup and exact target checks. If the installed native tool cannot accept a shared symbol database, retain that explicit blocked result instead of repairing an unrelated Work project.
|
||||
- [x] Retry opening/verifying only after native success and confirmed release; authoritative READY remains the success criterion.
|
||||
|
||||
## Validation and delivery
|
||||
|
||||
- [x] Run full Python and PowerShell regressions, compilation and whitespace checks, plus independent code review.
|
||||
- [x] Verify a successful native run and a controlled failed integration/close on an isolated library, and source fingerprints afterward.
|
||||
- [x] Record precisely which recovery target types were actually exercised and any remaining field-only limitations; commit changes on the current branch.
|
||||
|
||||
## Execution evidence
|
||||
|
||||
Completed on 2026-10-27. See `docs/releases/2026-10-27-icdb-failure-lifecycle-and-recovery.md` for 448 passing Python regressions, PowerShell and x86 harness checks, real failed-session close, real native Repair, the synthetic-error/real-repair/real-retry chain, frozen EXE Repair validation, and trial-package scope. Shared symbol databases without a supported PRJ entry remain explicitly unsupported; no field database was repaired.
|
||||
@@ -0,0 +1,55 @@
|
||||
# 从健康 CBB 来源恢复的增量设计
|
||||
|
||||
状态:同名 CBB 完整工程备份恢复弹窗已实现,并通过真实损坏打开失败 → 弹窗恢复 → 同一目标重新打开 PASS/READY 的闭环验证。471 项回归通过;原生跨库重新导入替换闭环仍未验证。
|
||||
|
||||
实机记录:`docs/releases/2026-10-28-cbb-backup-dialog-validation.md`。
|
||||
|
||||
## 本轮确定的实现范围
|
||||
|
||||
采用简单弹窗:目标 CBB、完整备份工程 PRJ、“恢复并校验”和“关闭”。选择的工程名和顶层块必须与目标一致,必须保留完整 Work 数据,不能仅选择单个数据库文件。
|
||||
|
||||
后台先保存完整目标库快照及 SHA256 清单,复制来源工程,在另一份目标库副本中恢复来源并通过原生 PCB 打开、集成、保存、关闭及权威 Ready 检查。通过后再次检查来源/目标内容及会话释放状态,保留原 Work 为同级 `Work.before-restore-*`,安装已验证的工程副本,再实际打开目标校验。只有 PASS、GREEN 和已释放的结果视为成功。失败保留回退库、来源快照、旧 Work 和原生日志,不自动覆盖共享数据库回退。
|
||||
|
||||
验证副本放在用户目录 `.cbb-restore/<编号>`,记录其实际路径。避开深层日志目录及 MSIX 对 AppData 的长路径重定向;本机短路径原生复核已通过 Ready 检查。目标原生操作保留映射盘/别名,文件快照和 Work 替换使用实际路径。原本已指向目标库的等价相对引用不重写,保留工程字节和日期。
|
||||
|
||||
该功能恢复现有条目的工程数据;不删除库条目,不宣称已完成原生跨库重新导入或共享符号库重建。原生导入探测已在新建的隔离库通过“Reusable Blocks / New Reusable Block”从 PRJ 创建 IP101GR,但替换损坏条目和依赖完整性尚未形成完整验证闭环,因此本轮不开放自动先删后导入。
|
||||
|
||||
真实验证脚本:`tools/validate_backup_recovery_dialog.py`,分 setup、open-before、restore、compare 四阶段。测试目标移除历史备份并破坏数据库文件头,使用独立健康来源;restore 阶段点击实际主窗口按钮及弹窗“恢复并校验”,使用生产后端。
|
||||
|
||||
目标:原生 Repair 无法恢复时,允许选择其他目录或库中的健康 CBB 作为恢复来源,重建目标 CBB 的可用状态,并保留完整回退材料。
|
||||
|
||||
## 已确认的原生行为
|
||||
|
||||
安装自带 `SDD_HOME/lm/win32/lib/upc_utils.tcl` 提供以下依据:
|
||||
|
||||
- `runReuseBlockLoader` 使用 DMS 的 `com.mentor.dms.rbloader.jar` 执行 `copyout`,下载/恢复 CBB。
|
||||
- `processReuseBlockChunk` 在下载 CBB 和相关 Cell 后调用 `runReuseBlockImporter ... move`,同步 CBB 在共享 iCDB 中的符号。
|
||||
- `removeReuseBlocks` 经 CleanWGLib 处理 CBB 移除;注释明确说明 Cell 和 iCDB 符号也由原生清理处理。
|
||||
- `ReuseBlockImporter` 因此不能仅凭名字被当成通用完整 CBB 备份导入程序。任意本地目录/压缩包的完整原生导入方式仍需验证。
|
||||
|
||||
## 两种故障分开处理
|
||||
|
||||
1. 单个 CBB 的 Work 数据库损坏、目标中心库及共享符号库可用:可验证恢复该 CBB,并通过原生流程重新建立元数据、Cell 和符号关联。
|
||||
2. `SymbolLibs/__ReusableBlocksSymb` 等共享数据库损坏:在同一损坏目标中删除或导入 CBB 都可能因无法访问共享库失败。应先恢复共享库,或评估建立健康新库并迁移 CBB 及依赖;该迁移路线尚未实测。
|
||||
|
||||
不将删除日志、地址文件、锁文件或修改私有数据库会话字段作为恢复方法。
|
||||
|
||||
## 建议操作流程
|
||||
|
||||
1. 选择健康来源:完整工程/可导入的 CBB 包、来源库或受支持的 DMS 版本。核对 CBB 类型、名称、分区、软件版本、来源时间及符号/Cell/零件依赖;名称相同不证明内容等价。
|
||||
2. 在来源副本上验证可以打开,保留原始来源不被校验保存修改。
|
||||
3. 在隔离目标副本中验证原生导入/恢复路径。目标中心库必须可访问,错误类别和数据库路径必须明确。
|
||||
4. 通过原生流程替换/移除旧条目并恢复健康 CBB,确认 .lmc 元数据、CBB 工程、Cell 和共享符号关联一致。先验证是否支持原生替换;不盲目采用先删后导入,也不假定导入具备原子回退。
|
||||
5. 实际打开恢复的工程,完成集成、保存、关闭和权威 Verify 状态确认。失败保留原始工程、恢复来源、原生日志和完整备份;不将失败结果改为绿色。
|
||||
|
||||
## 对现有按钮的建议升级
|
||||
|
||||
维护入口展示原生修复结果;受阻项目可选择“从健康 CBB 恢复”。启动前显示来源与目标、覆盖范围和版本差异;结果区分别报告“原位修复”“从备份恢复”“重新导入恢复”“共享库阻断”和“未确认”。
|
||||
|
||||
程序可以负责来源核对、隔离验证、备份、原生操作编排和复核。若本机版本只能使用 GUI 导入,先提供原生窗口及操作指引;没有可靠的原生命令/界面路径之前,不声称支持自动重新导入。
|
||||
|
||||
## 后续验证门槛
|
||||
|
||||
- 确定一个完整、可打开的来源 CBB,并在独立副本上复现目标报错。
|
||||
- 记录本机原生本地导入/跨库复制/受支持 DMS 恢复的确切入口、替换策略、冲突提示和日志。
|
||||
- 对照恢复前后的实际工程打开结果与依赖完整性,包含导入失败、来源版本不匹配、目标共享库不可用的停止行为。
|
||||
@@ -0,0 +1,24 @@
|
||||
# ICDB Global Check and Repair Implementation Plan
|
||||
|
||||
**Goal:** Provide a separate full-library action that checks each available CBB and invokes the existing evidence-bound iCDB recovery when appropriate.
|
||||
|
||||
**Architecture:** Reuse the serial verification queue, including Ready rows, and the existing backup, ownership, native repair and retry safeguards. Confirm the full-library write scope before starting; stop on unconfirmed ownership and retain existing reports and evidence. Shared symbol database repair remains unsupported.
|
||||
|
||||
**Tech Stack:** Python 3.12, PySide6, pytest, Windows native Mentor tools.
|
||||
|
||||
1. Add UI tests for confirmation, Ready-row inclusion, skipped projects, busy state and cancellation.
|
||||
2. Add the button and route the full set of eligible rows through the existing queue without changing ordinary Verify behavior.
|
||||
3. Run focused and full regression tests. On a new isolated project copy, attempt a reproducible native session failure and run the repair; retain evidence and explicitly report whether actual corruption and recovery were demonstrated.
|
||||
|
||||
## Button design and acceptance (2026-10-28)
|
||||
|
||||
- [x] Put the action in a separate database maintenance panel with the supported scope beside it.
|
||||
- [x] Confirmation displays the exact library, eligible count, Ready count and missing-project count, and explains that verification saves projects.
|
||||
- [x] Show item progress and separate checking, backup and native repair phases; allow stopping after the current item.
|
||||
- [x] Report verified items, native repairs, restored backups requiring review, unconfirmed repairs and unexecuted items separately. Save a JSON maintenance report with original error and repair evidence.
|
||||
- [x] Detect native restoration from an existing backup without treating it as an automatic repair success or retrying verification. Close only after restoration/diagnostics complete, the native main window is idle and the database address has been released.
|
||||
- [x] Exercise the actual Qt button on a fresh local library copy using the production reader and verifier, capture screenshots and check source fingerprints afterwards.
|
||||
- [x] Repeat the real header-corruption/native-repair probe with a 180-second native deadline and verify the restoration-review result and normal process exit.
|
||||
- [x] Run the full regression suite and record the supported scope and practical limits in a release validation note.
|
||||
|
||||
Results: `docs/releases/2026-10-28-icdb-maintenance-button-validation.md`. Actual button run PASS/READY raw=1 on IP101GR; all 21,029 source file hashes unchanged. Real header corruption led to native restoration of an older backup and RESTORED_REVIEW_REQUIRED, without automatic retry. Full regression: 455 passed. Final Windows EXE smoke: clean exit 0.
|
||||
@@ -0,0 +1,104 @@
|
||||
# Issue #2 implementation plan
|
||||
|
||||
Approved by user on 2026-11-02. Continue branch codex/temp-issue-2-icdb-recovery,
|
||||
baseline ec78dd7 (491 tests). Do not merge, publish or close the issue. Preserve
|
||||
untracked review.diff. Python 3.12, PySide6, Mentor EE7.9.5, private desktop by
|
||||
default. No force termination of native database owners, deleting locks,
|
||||
guessing native write interfaces, or editing LMC binary contents.
|
||||
|
||||
Each task uses regression tests, focused validation and a separate commit.
|
||||
Real field lost-session reproduction and Windows 10 validation must be reported
|
||||
as unverified when unavailable; header corruption is not a substitute.
|
||||
|
||||
## Task 1: ICDB failure lifecycle and repair outcomes
|
||||
|
||||
Extend the existing owned-empty-PCB close path to wait for its launcher as well.
|
||||
Cover COM connected without a document, delayed dialogs/addresses/process exit.
|
||||
Native Repair must report missing healthy backup, native repair failure, database
|
||||
busy, unknown dialogs and timeout/unreleased distinctly using this run's native
|
||||
logs and Output. Safely close an idle, conclusively failed native repair tool;
|
||||
never act on unrecognized prompts or active native operations.
|
||||
Preserve original error, original evidence and all repair evidence. Record release
|
||||
state. Repair success in summaries means original native repair succeeded AND
|
||||
same-project reopening, verification and authoritative GREEN succeeded. Historical
|
||||
backup restoration remains RESTORED_REVIEW_REQUIRED. A conclusively failed repair
|
||||
may continue independent CBB items only if all relevant processes and addresses
|
||||
are released and scope is project-local; shared-library/unknown ownership stops.
|
||||
Add sanitized replay of issue2 lost-session/open-failure events with asserted target,
|
||||
stage and invocation order; one automatic repair maximum, no repeated PCB loop.
|
||||
Maintain VerifyRequest/VerifyResult compatibility. Files primarily failed_session,
|
||||
pcb_bridge, mentor_adapter, native_repair[_ui], verify_runner, icdb_maintenance and
|
||||
their tests. Update release evidence. No native live operations without coordinator
|
||||
agreement (only one native operation at a time). Coordinator builds candidate and
|
||||
runs frozen tests after review. Field fault sample is not in the attachment (logs
|
||||
only); do not claim field recovery.
|
||||
|
||||
## Task 2: Search, filtering, selection and non-READY maintenance
|
||||
|
||||
Implement local name/partition keyword search and filters: all, READY, non-READY,
|
||||
PENDING, unknown/read errors, missing project. Non-READY includes unconfirmed states
|
||||
without calling them corrupt. Show visible/READY/error counts; no Mentor rereads on
|
||||
filtering. Management selection permits READY; verify/maintenance/default backup
|
||||
recovery exclude READY. Operations target current visible checked rows; hiding a row
|
||||
clears its checkbox. Provide select visible/clear selection. Maintenance entry,
|
||||
confirmation, progress and report agree on non-READY target set. Existing verify-all
|
||||
means visible eligible rows, maintenance defaults visible eligible rows with checked
|
||||
subset if any. Refresh affected authoritative statuses after operations, retain search
|
||||
and filter. No premature integration of CRUD; expose selected records for Task4.
|
||||
Maintain CbbRecord compatibility and explicit status separate from action result.
|
||||
Tests include mixed READY/PENDING/errors/missing, filtering after state transitions,
|
||||
selection scope and 381/3000 row responsiveness. Files UI main_window, small focused
|
||||
filter helper if useful, backup dialog and maintenance report + tests. Avoid unrelated
|
||||
UI overhaul. Commit and report focused tests plus full suite once.
|
||||
|
||||
## Task 3: Scoped primary-file hashes and verified backups
|
||||
|
||||
Copy and retain complete backup trees. Restrict SHA256 and semantic before/after
|
||||
comparison to primary project/design/database/constraint files and required library
|
||||
dependencies: PRJ/PCB/DXP, icdb.dat, Layout, schematic/logic/symbol assets, CES/config,
|
||||
target LMC and shared database dependencies. Explicitly exclude runtime logs/temp/
|
||||
locks/address records, historical backups, PDF/generated output from content hashes;
|
||||
address files still participate in idle checks. Treat unclassified engineering data
|
||||
conservatively as primary rather than accidentally excluding it. For central-library
|
||||
manifest, only target CBB Work/Cert plus active library configuration/shared library
|
||||
dependency trees; do not hash unrelated CBB projects.
|
||||
During copy validate tree membership and file size/mtime before/after; primary files
|
||||
also source/destination SHA256, including locked database stream bytes. Logs changing
|
||||
after successful snapshot must not invalidate subsequent semantic comparison, while
|
||||
primary changes/additions/deletions must block install. Manifest is versioned and
|
||||
contains relative paths, size, hash and scope; progress gives hashed files/bytes/stage.
|
||||
Keep existing validate-copy -> target conflict check -> retain Work -> install ->
|
||||
reopen verification. Preserve old backups and evidence on failure. Add tests for logs
|
||||
only, all primary categories, changed/deleted sources, target concurrency, copied byte
|
||||
corruption and preserved recovery copies. Files backup_recovery and new focused
|
||||
manifest helper + tests. Reuse helper in management Task4 without changing old public
|
||||
Verify contracts. Document explicit rules/compatibility, commit after tests.
|
||||
|
||||
## Task 4: Native CBB management and delivery
|
||||
|
||||
Integrate add, same-name update, remove in current application. Input complete PRJ/PCB
|
||||
projects, no Packager/PDF/part replacement/rename/partition move. Add conflicts never
|
||||
overwrite. Update matches existing name/partition and backs up complete old project
|
||||
and library recovery snapshot. Remove backs up then uses verified Mentor native
|
||||
operation; reread confirms absence. Never fake removal by deleting directories.
|
||||
Add/update reread identity, default auto-verify optional per batch, distinguish upload
|
||||
failed, uploaded-but-verification-failed, uploaded-and-verified. Preserve source files.
|
||||
Use isolated native adapter: capability detection by installed version/interface plus
|
||||
isolated validation. Prefer proven COM/command; verified private desktop controls only
|
||||
fallback, never foreground input. Unsupported operations disabled with exact reason.
|
||||
Use cbb-upload-795 as research only, no external runtime dependency. Native API research
|
||||
comes from coordinator. No fabricated operation parameters. Snapshot/readback result
|
||||
must correspond to actual library entry and source engineering identity.
|
||||
Requests/results contain operation, library, CBB, partition, source, auto_verify,
|
||||
stage/status, safe_to_continue and evidence path. Serialize all writes with existing
|
||||
verification mutex and a library-level lock compatible with original uploader; apply
|
||||
coordination to verify/recovery too. Stop when native release uncertain. Persist item
|
||||
checkpoints and show unfinished tasks on restart, never replay automatically.
|
||||
Provide safe preview/confirmation for destructive operations; backups outside target.
|
||||
Test isolated add/conflict/update/remove/reimport, cancellation, timeout/network errors,
|
||||
partial successes, no-op/lying native response, busy library, restart checkpoints.
|
||||
Implement capabilities conservatively: if actual native operation cannot be proven,
|
||||
its UI remains disabled with actionable explanation and validation gap is explicit.
|
||||
Full Python/compile/diff checks, candidate frozen smoke, Windows11 native scenario;
|
||||
Windows10 and real field sample explicitly unverified if inaccessible. Coordinator
|
||||
provides final review and source/frozen deliverables without merging/publishing.
|
||||
@@ -0,0 +1,12 @@
|
||||
# 无地址 ICDB 维护与 PCB 版本选择
|
||||
|
||||
用户要求按已确认的入口分析修复,并明确允许需要时弹窗让用户选择。沿用临时分支,不恢复应用自动备份,不改原库。
|
||||
|
||||
- [x] 无地址记录的明确维护也进入原生 Repair;仅允许唯一数据库与 PCB/PRJ 反向引用绑定,保留全库独占检查。新增回归先失败,集中 250 项通过,独立审查通过。
|
||||
- [x] 实际应用按钮在无地址 IP101GR 副本完成原生 Repair,随后需要 PCB 版本选择;沿用用户此前确认的手动保存版本,诊断续接已保存关闭并读取 READY。人工续接不算完整自动链路验收。
|
||||
- [x] 在主应用显示候选时间和手动保存/自动保存/取消按钮。没有 UI 选择入口的调用保持待选择,不自动选版本;每个原生窗口只问一次,等待期间继续观察会话。
|
||||
- [x] 原生动作仍由私有桌面代理执行,核对修复证明、进程、窗口和候选版本;先选择单选项并复读,再确认 OK;取消或窗口变化不确认恢复。
|
||||
- [x] 用户选择后沿原校验链路继续,原生保存提示仍由已有监督器处理。最终 READY 保持原有门槛;使用历史 PCB 版本记录“已恢复,版本待核对”,不标记无损修复。
|
||||
- [x] 测试 UI 取消、手动/自动选择、选择失效、重复弹窗、错 PID/桌面、原生失败和 READY 区分;独立审查、全量回归、冻结实际按钮验证并交付候选。1135 项通过;de952a6 冻结实际按钮达到 PASS/GREEN/READY,历史版本仍标记待核对。
|
||||
|
||||
采用独立版本选择控制器与 Qt 对话框,复用原生代理及现有进度信号;不引入前台鼠标或自动重导入。界面只要求选择已有候选版本,不替用户推断应采用哪个版本。
|
||||
@@ -0,0 +1,36 @@
|
||||
# Manual Backup Implementation Plan
|
||||
|
||||
**Goal:** 按用户最新要求取消应用操作前的自动备份,改为提示手动备份,减少整库复制和重复哈希耗时。
|
||||
|
||||
**Architecture:** 管理操作使用只读内容基线、暂存来源、原生身份核对和现有库锁。备份责任转为用户;应用不验证或声称手动备份已存在。恢复操作只创建用于隔离校验的库副本,不再额外复制完整回退库。原生 Repair 自身备份保持原生行为。
|
||||
|
||||
**Tech Stack:** Python 3.12 / PySide6 / Mentor EE7.9.5。
|
||||
|
||||
用户已明确指定取消自动备份并提示手动备份,本计划直接执行。沿用临时分支,不合并发布、不修改原用户库。保留既有 `review.diff`。
|
||||
|
||||
## 范围与检查结果
|
||||
|
||||
| 操作 | 旧行为 | 新行为 |
|
||||
| --- | --- | --- |
|
||||
| 新增、替换、移除 | 每项完整中心库备份 | 手动备份提示;只读基线、检查点及来源暂存 |
|
||||
| 普通校验 | 本地 CBB 辅助备份,网络跳过 | 所有路径统一取消应用辅助备份 |
|
||||
| ICDB Repair | 应用完整工程备份,加原生自身备份 | 取消应用复制,保留独占读取/身份检查及原生自身行为 |
|
||||
| 从备份恢复 | 整库回退备份再复制验证库;额外来源副本 | 直接复制一次隔离验证库,来源直接暂存到验证工程 |
|
||||
| 读取/搜索/筛选 | 无备份 | 保持只读 |
|
||||
|
||||
验证工程副本和来源暂存是任务输入,不能删除后直接改原始来源。恢复安装中的旧 Work 改名保留是目录交换保护,不复制数据,继续保留。历史证据与备份不清理。独立研究工具的显式备份不属于桌面自动操作。
|
||||
|
||||
## Tasks
|
||||
|
||||
- [ ] 管理:先增加不复制整库及基线变化阻止写入的回归;移除事务授权对备份目录的依赖,绑定基线清单,保留身份、监督进程、活跃库锁和检查点验证;更新对应测试。
|
||||
- [ ] 校验/Repair/恢复:先写不调用自动备份、保持独占检查及单一验证库副本的回归;改调用路径和进度说明,测试取消/占用/来源及目标变化继续阻止操作。
|
||||
- [ ] 界面:将手动备份提示加入管理、校验、维护、恢复执行确认;取消不启动任务,每批一次,不伪称备份已完成。移除自动备份承诺。
|
||||
- [ ] 验证:集中测试、全量 Python 测试、编译与 diff 检查、独立代码审查;隔离原生移除验证不创建整库备份;新冻结包验证提示和取消反馈。更新验证记录,提交并构建候选。
|
||||
|
||||
## Review Focus
|
||||
|
||||
- 没有备份目录仍能通过真实管理事务校验;错库、过期锁、来源变化、基线记录篡改仍拒绝。
|
||||
- 替换移除成功但新增失败必须保留部分失败检查点,明确使用用户手动备份恢复。
|
||||
- 删除备份调用不能同时删掉数据库独占和取消检查。
|
||||
- 恢复仍隔离验证,并保留来源/目标变更检查与失败安装回退。
|
||||
- UI 取消确认无写入;逐项自动校验不重复弹窗;没有目标时不弹无意义提示。
|
||||
@@ -0,0 +1,32 @@
|
||||
# 原生 CBB 管理接入续作
|
||||
|
||||
沿用用户已批准的工单 #2 管理范围与临时分支。此次用户要求找到并尝试接入库的增删改查原生接口。
|
||||
不直接修改 LMC 二进制,不采用前台鼠标,不强制结束持有数据库的原生进程;原用户库不参与写入试验。
|
||||
|
||||
## 已确认接口
|
||||
|
||||
- 查询:LibraryManager.Application.OpenLibrary → Partitions(7) → 名称、分区,核对库身份并正常退出。
|
||||
- 新增:OnReusableBlocksEditor → 原生 Logical-Physical 页签 → New → 源 PRJ、名称、顶层块,提交原生对话框。字段使用有时限的窗口消息复读,提交后确认成功消息,再关闭重开目录。
|
||||
- 移除:安装脚本确认的 CleanWGLib/F4/REUSE_BLOCK,必须完整备份且重新读库确认缺失。
|
||||
- 同名替换:复用经过验证的移除与新增;它不是原子更新,删除后导入失败时保留恢复检查点并停止队列。与仅替换 Work 的“从备份恢复”明确区分。
|
||||
|
||||
## 接入步骤
|
||||
|
||||
1. 共享原生新增适配层,保留私有桌面、二进制版本、同库租约、监督进程、来源暂存及完整备份的验证。生产能力未通过时只有带隔离库所有权证据的研究入口可写。
|
||||
2. 原生 ICDB 导入会重写存储。用安装版本锁定的 ASCII、CSV 和 EDIF 原理图导出建立内容指纹,并保留布局及其他工程资产的字节哈希。不能把注册成功或名称相同等同于工程内容一致。
|
||||
3. 导出仅使用新建的完整工程副本。严格确认退出、有效输出与原生完成标记;仅规范化已经实际证明会变化的报告时间/路径字段。布局、坐标、连接、属性及未知工程文件变化一律阻止接受。
|
||||
4. 新增后原生程序可能未正确重定位 PCB 配置的 CentralLibrary。仅在本任务注册成功、原生释放和租约持有时修正该已导入工程的库引用,再重新打开核对目录与内容。原始输入工程不改动。
|
||||
5. 在实际新建隔离库运行新增、同名冲突、不同版本同名替换、备份后移除、从备份重新导入;逐项保存证据,验证源文件未变。随后才提升对应生产能力。
|
||||
6. 运行相关回归、独立审查、全量测试与冻结包实际管理入口验证。缺少原生证据的能力继续禁用并准确说明原因。
|
||||
|
||||
## 已完成的内容指纹取证
|
||||
|
||||
`diagnostics/issue2-native-crud-20261103/` 保存真实导出对照:
|
||||
|
||||
- ASCII:层次与展开连接、组件、端口和属性,3,531 行;只差生成时间和数据库目录三行报告元数据。
|
||||
- CSV:14 个表格文件;只差信息表的 System_Date 字段。
|
||||
- EDIF `-schematic`:约 580 KB,包含坐标、图形、连线、旋转、文本位置及属性;只差根级 status/written/timestamp。
|
||||
- 139 个主要工程资产一致;其余变化为 ICDB 数据文件、其运行时记录及两处 PCB CentralLibrary 引用。
|
||||
|
||||
以上为已验证格式的内容身份合同,不声称任意未知版本、任意外部工具私有元数据都可无差别转换。
|
||||
导出格式、安装版本、必需文件或引用不符合时拒绝操作。
|
||||
@@ -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'}
|
||||
|
||||
@@ -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
@@ -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 @@
|
||||
__version__ = "0.1.0"
|
||||
__version__ = "0.2.3b1"
|
||||
@@ -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
|
||||
|
||||
@@ -46,6 +49,10 @@ def resolve_data_root(cli_value: Path | None) -> Path:
|
||||
def main(argv: Sequence[str] | None = None) -> int:
|
||||
parser = argparse.ArgumentParser(prog="CbbRefreshVerify")
|
||||
parser.add_argument('--verify-worker', type=Path, help=argparse.SUPPRESS)
|
||||
parser.add_argument('--repair-worker', type=Path, help=argparse.SUPPRESS)
|
||||
parser.add_argument('--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)
|
||||
@@ -55,6 +62,18 @@ def main(argv: Sequence[str] | None = None) -> int:
|
||||
parser.add_argument('--mentor-bin', default='', help=argparse.SUPPRESS)
|
||||
parser.add_argument("--smoke-test", action="store_true", help=argparse.SUPPRESS); parser.add_argument("--data-root", type=Path, help=argparse.SUPPRESS)
|
||||
args = parser.parse_args(list(argv) if argv is not None else None)
|
||||
if args.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)
|
||||
@@ -98,7 +117,13 @@ 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)
|
||||
try:
|
||||
results = run_batch(requests)
|
||||
except Exception:
|
||||
lease.retain_for_recovery()
|
||||
raise
|
||||
if any(not result.safe_to_continue for result in results):
|
||||
lease.retain_for_recovery()
|
||||
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",
|
||||
|
||||
@@ -0,0 +1,251 @@
|
||||
"""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 pcb_processes, _process_details
|
||||
from .icdb_ownership import unreleased_addresses
|
||||
if pcb_processes() or any(_process_details(name) for name in (
|
||||
'LibraryManager.exe', 'viewdraw.exe')):
|
||||
raise ValueError('请先正常关闭 PCB、Library Manager 和原理图编辑器,再恢复备份。')
|
||||
addresses = unreleased_addresses(library, project, pcb)
|
||||
if addresses:
|
||||
raise ValueError(f'数据库会话尚未释放,停止恢复:{addresses}')
|
||||
|
||||
|
||||
def _project_text(path):
|
||||
data = path.read_bytes()
|
||||
if data.startswith((b'\xff\xfe', b'\xfe\xff')):
|
||||
return data.decode('utf-16')
|
||||
try:
|
||||
return data.decode('utf-8-sig')
|
||||
except UnicodeDecodeError:
|
||||
return data.decode('mbcs')
|
||||
|
||||
|
||||
def _source_check(source, name, original):
|
||||
if not source.is_file() or source.suffix.casefold() != '.prj':
|
||||
raise ValueError('请选择完整健康备份中的工程 .prj。')
|
||||
_paths(source.parent)
|
||||
text = _project_text(source)
|
||||
roots = re.findall(r'^KEY RootBlock "([^"]+)"', text, re.M)
|
||||
if (source.name.casefold() != original.name.casefold() or not roots
|
||||
or any(root.casefold() != name.casefold() for root in roots)):
|
||||
raise ValueError('当前仅支持同名 CBB 的完整工程备份,工程名和顶层块必须与目标一致。')
|
||||
refs = re.findall(r'^KEY PCBDesignPath "([^"]+)"', text, re.M)
|
||||
if len(refs) != 1:
|
||||
raise ValueError('备份工程必须包含唯一的 PCBDesignPath。')
|
||||
def require_relative(value):
|
||||
if Path(value).drive or Path(value).root:
|
||||
raise ValueError('备份工程、PCB 和数据库必须使用工程内的相对路径,不能指向原备份位置。')
|
||||
require_relative(refs[0])
|
||||
pcb = (source.parent / refs[0]).resolve()
|
||||
if not pcb.is_relative_to(source.parent.resolve()):
|
||||
raise ValueError('备份 PCB 引用越出工程目录。')
|
||||
if not all(path.is_file() for path in (pcb, pcb.parent/'Layout/LayoutDB.lyt',
|
||||
pcb.parent/'pcb.prj', source.parent/'database/icdb.dat')):
|
||||
raise ValueError('备份不完整:需要原理图数据库、PCB、布局数据库和 PCB 工程文件。')
|
||||
project_refs = re.findall(r'^KEY ProjectFile "([^"]+)"', _project_text(pcb), re.M)
|
||||
for value in project_refs:
|
||||
require_relative(value)
|
||||
if len(project_refs) != 1 or (pcb.parent/project_refs[0]).resolve() != source.resolve():
|
||||
raise ValueError('备份 PCB 必须引用所选工程,不能引用其他位置的工程。')
|
||||
for project in (source, pcb.parent/'pcb.prj'):
|
||||
data = _project_text(project)
|
||||
for value in re.findall(r'^KEY iCDBDir "([^"]+)"', data, re.M):
|
||||
require_relative(value)
|
||||
if not (project.parent/value).resolve().is_relative_to(source.parent.resolve()):
|
||||
raise ValueError('备份数据库引用越出工程目录。')
|
||||
return pcb
|
||||
|
||||
|
||||
def _align_library(project, pcb, library):
|
||||
from .mentor_adapter import ensure_project_central_library
|
||||
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)})
|
||||
root.mkdir(parents=True, exist_ok=True)
|
||||
report = root/'recovery-result.json'
|
||||
report.write_text(json.dumps(record, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
|
||||
return replace(result, evidence_path=report)
|
||||
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=False))
|
||||
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)
|
||||
@@ -211,7 +211,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):
|
||||
results.append(previous)
|
||||
continue
|
||||
try:
|
||||
@@ -231,7 +232,9 @@ class BatchStatusSession:
|
||||
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)
|
||||
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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,52 @@ 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
|
||||
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:
|
||||
# Kill-through-job is a cleanup guarantee, not a launch requirement.
|
||||
self.job_bound = False
|
||||
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 +145,97 @@ 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 = []
|
||||
for row in query_owners(('cscript.exe',), timeout_seconds=3):
|
||||
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()
|
||||
@@ -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":
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -351,6 +351,11 @@ def classify_dialog(snapshot: DialogSnapshot) -> DialogDecision:
|
||||
joined = " ".join(snapshot.texts).casefold()
|
||||
combined = f"{title} {joined}"
|
||||
|
||||
from .icdb_recovery import ERROR_CODE, parse_session_loss
|
||||
if parse_session_loss(combined):
|
||||
return DialogDecision(error_code=ERROR_CODE,
|
||||
detail=' | '.join(snapshot.texts) or snapshot.title)
|
||||
|
||||
if ("problem encountered while opening one of the database files" in combined
|
||||
and "loading of the job has failed" in combined):
|
||||
return DialogDecision(action="decline_database_log",
|
||||
@@ -370,14 +375,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")
|
||||
|
||||
|
||||
@@ -0,0 +1,178 @@
|
||||
"""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 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: there is no document, and the global ROT can name another
|
||||
session. Unknown windows, live database addresses and other desktops are
|
||||
retained. WM_CLOSE is cooperative; no save prompt is accepted or killed.
|
||||
"""
|
||||
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:
|
||||
diagnosed = False
|
||||
diagnosis_path = root/'diagnostics/icdb-recovery.json'
|
||||
if diagnosis_path.is_file():
|
||||
diagnosis = json.loads(diagnosis_path.read_text('utf-8'))
|
||||
diagnosed = diagnosis.get('error_code') == 'ICDB_REPAIR_REQUIRED'
|
||||
dialogs_path = root/'dialogs.jsonl'
|
||||
if not diagnosed and dialogs_path.is_file():
|
||||
for line in dialogs_path.read_text('utf-8').splitlines():
|
||||
try:
|
||||
dialog = json.loads(line)
|
||||
except ValueError:
|
||||
continue
|
||||
if (dialog.get('pid') == pcb_pid and dialog.get('phase') == 'PCB_STARTING'
|
||||
and dialog.get('error_code') == 'MENTOR_DATABASE_LOAD_FAILED'):
|
||||
diagnosed = True
|
||||
if not diagnosed:
|
||||
raise ValueError('STARTUP_FAILURE_UNCONFIRMED')
|
||||
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
|
||||
while True:
|
||||
records = [r for r in _process_details('ExpeditionPCB.exe') if r[0] == pcb_pid]
|
||||
if not records:
|
||||
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 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)
|
||||
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 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 ('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
|
||||
@@ -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()]
|
||||
@@ -0,0 +1,144 @@
|
||||
"""Recognize native iCDB recovery requests without changing database state."""
|
||||
import hashlib
|
||||
import ntpath
|
||||
from pathlib import Path
|
||||
import re
|
||||
|
||||
|
||||
ERROR_CODE = 'ICDB_REPAIR_REQUIRED'
|
||||
LOG_LIMIT = 128 * 1024
|
||||
RECOVERY_ACTION = (
|
||||
'停止批次并确认原服务器及其他客户端已正常关闭;保留完整一致副本后,'
|
||||
"使用同版本 iCDB Project Backup 的 Repair project 检查并修复正确目标。"
|
||||
'共享符号库问题需核对中心库,不能只修复单个 CBB 的 Work 工程。'
|
||||
'不要删除 sAddress.adr/锁文件;修复后重新打开、校验并确认权威 READY。'
|
||||
)
|
||||
_SESSION_LOSS = re.compile(
|
||||
r'\bthe\s+last\s+server\s+session\s+on\s+different\s+server\s+machine\s+'
|
||||
r'lost\s+the\s+connection\s+to\s+the\s+database\b', re.IGNORECASE)
|
||||
|
||||
|
||||
def parse_session_loss(text):
|
||||
"""Keep the native target verbatim; never infer a local repair target."""
|
||||
text = str(text or '')
|
||||
match = _SESSION_LOSS.search(text)
|
||||
if match is None:
|
||||
return None
|
||||
# A log may contain several sessions. Use the identity following this
|
||||
# error, never an unrelated Machine/Path header earlier in the log.
|
||||
message = text[match.start():]
|
||||
next_error = _SESSION_LOSS.search(message, 1)
|
||||
if next_error:
|
||||
message = message[:next_error.start()]
|
||||
record = {'error_code': ERROR_CODE, 'native_message': message,
|
||||
'machine': '', 'database_path': '', 'session': '', 'scope': 'unknown'}
|
||||
for native_key, key in (('machine', 'machine'), ('path', 'database_path'),
|
||||
('session', 'session')):
|
||||
field = re.search(
|
||||
rf'\b{native_key}\s*:\s*(?:\[([^\]]*)\]|([^\r\n]*?)(?=\s+\b(?:machine|path|session)\s*:|[\r\n]|$))',
|
||||
message, re.IGNORECASE)
|
||||
if field:
|
||||
record[key] = (field.group(1) if field.group(1) is not None else field.group(2)).strip()
|
||||
parts = ntpath.normpath(record['database_path']).casefold().split('\\')
|
||||
if 'symbollibs' in parts:
|
||||
record['scope'] = 'central_library'
|
||||
elif 'work' in parts and parts[-1] == 'database':
|
||||
record['scope'] = 'project'
|
||||
return record
|
||||
|
||||
|
||||
def recovery_detail(record):
|
||||
target = ('中心库共享符号数据库' if record['scope'] == 'central_library' else
|
||||
'工程数据库' if record['scope'] == 'project' else '报错中指定的数据库')
|
||||
return (
|
||||
f"{ERROR_CODE}: {target}的上次服务器会话失联。\n"
|
||||
f"{record['native_message']}\n"
|
||||
f'{RECOVERY_ACTION}'
|
||||
)
|
||||
|
||||
|
||||
def snapshot_log(path):
|
||||
"""Fingerprint a bounded tail before launch, including a missing log."""
|
||||
try:
|
||||
with Path(path).open('rb') as stream:
|
||||
stream.seek(0, 2)
|
||||
size = stream.tell()
|
||||
stream.seek(max(0, size-LOG_LIMIT))
|
||||
tail = stream.read(LOG_LIMIT)
|
||||
losses = [_session_identity(record) for record in _session_losses(decode_log(tail))]
|
||||
return {'size': size, 'tail_sha256': hashlib.sha256(tail).hexdigest(),
|
||||
'truncated': size > LOG_LIMIT,
|
||||
'session_losses': losses}
|
||||
except FileNotFoundError:
|
||||
return {'size': 0, 'tail_sha256': hashlib.sha256(b'').hexdigest()}
|
||||
except OSError as error:
|
||||
return {'error': str(error)}
|
||||
|
||||
|
||||
def _read_log_delta(path, baseline):
|
||||
"""Read new bytes, detecting truncate/rewrite as well as append.
|
||||
|
||||
Unknown baselines cannot prove freshness. At most two bounded tails are
|
||||
read, even when a native log is large or located on a network share.
|
||||
"""
|
||||
if not baseline or 'error' in baseline:
|
||||
return b'', False
|
||||
old_size = int(baseline['size'])
|
||||
try:
|
||||
with Path(path).open('rb') as stream:
|
||||
stream.seek(0, 2)
|
||||
size = stream.tell()
|
||||
offset = 0
|
||||
appended = False
|
||||
if size >= old_size:
|
||||
stream.seek(max(0, old_size-LOG_LIMIT))
|
||||
old_tail = stream.read(min(old_size, LOG_LIMIT))
|
||||
if hashlib.sha256(old_tail).hexdigest() == baseline['tail_sha256']:
|
||||
offset = old_size
|
||||
appended = True
|
||||
stream.seek(max(offset, size-LOG_LIMIT))
|
||||
return stream.read(LOG_LIMIT), appended
|
||||
except OSError:
|
||||
return b'', False
|
||||
|
||||
|
||||
def _session_losses(text):
|
||||
matches = list(_SESSION_LOSS.finditer(text))
|
||||
for index, match in enumerate(matches):
|
||||
end = matches[index+1].start() if index+1 < len(matches) else len(text)
|
||||
yield parse_session_loss(text[match.start():end])
|
||||
|
||||
|
||||
def _session_identity(record):
|
||||
return [record[key] for key in ('machine', 'database_path', 'session')]
|
||||
|
||||
|
||||
def read_log_failure(path, baseline):
|
||||
"""Return new log text and a recovery request with evidence of freshness.
|
||||
|
||||
A rewritten header does not prove that a retained old session failed
|
||||
again. In that ambiguous case keep the generic failure; a verified append
|
||||
can report even the same old session as a current native error.
|
||||
"""
|
||||
data, appended = _read_log_delta(path, baseline)
|
||||
text = decode_log(data)
|
||||
if not appended and baseline and baseline.get('truncated'):
|
||||
# A rewrite may expose an old error outside our bounded baseline.
|
||||
# Without positive append evidence its age cannot be established.
|
||||
return text, None
|
||||
historical = baseline.get('session_losses', []) if baseline else []
|
||||
recovery = next((record for record in _session_losses(text)
|
||||
if appended or _session_identity(record) not in historical), None)
|
||||
return text, recovery
|
||||
|
||||
|
||||
def decode_log(data):
|
||||
if data.startswith((b'\xff\xfe', b'\xfe\xff')):
|
||||
return data.decode('utf-16', errors='replace')
|
||||
# Appended UTF-16 bytes and bounded tails no longer contain a BOM.
|
||||
sample = data[:200]
|
||||
if sample[1::2].count(0) > len(sample)//8:
|
||||
return data.decode('utf-16-le', errors='replace')
|
||||
if sample[::2].count(0) > len(sample)//8:
|
||||
return data.decode('utf-16-be', errors='replace')
|
||||
return data.decode('utf-8', errors='replace')
|
||||
@@ -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')
|
||||
|
||||
@@ -0,0 +1,438 @@
|
||||
"""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 _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)
|
||||
if path.with_suffix('.pending').exists():
|
||||
return True
|
||||
if not path.exists():
|
||||
return False
|
||||
record = checkpoint_record(path)
|
||||
# Complete snapshots retain every file, including their source lease
|
||||
# checkpoint. Only a valid relocated snapshot record can be ignored.
|
||||
return record is None or _key(record['library']) == _key(library)
|
||||
|
||||
|
||||
def _persist_blocker(library, status='OWNER_RELEASE_UNCONFIRMED', *, lease_id):
|
||||
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 {})
|
||||
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,
|
||||
'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):
|
||||
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.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:
|
||||
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:
|
||||
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)
|
||||
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,
|
||||
'release_probe': self.safe_to_release if not self.checkpoint else None}
|
||||
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 _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 _supervisor_alive(record['pid']):
|
||||
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
|
||||
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}
|
||||
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):
|
||||
"""Hold all native database read handles during explicit lease release."""
|
||||
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
|
||||
assert_retained_exports_idle()
|
||||
if any(worker.poll() is None 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
|
||||
def check_owners():
|
||||
owners = []
|
||||
for item in query_owners(names):
|
||||
if item['pid'] == os.getpid():
|
||||
continue
|
||||
if scope_root is not None and item.get('command'):
|
||||
command = str(item['command']).casefold().replace('/', '\\')
|
||||
if str(scope_root).casefold().replace('/', '\\') not in command:
|
||||
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')):
|
||||
owners.append(item)
|
||||
if owners:
|
||||
raise LibraryBusy(f'原生进程仍存在,不能解除协调阻止:{owners}')
|
||||
return owners
|
||||
check_owners()
|
||||
entries = scan_tree(Path(library).parent)
|
||||
addresses = [str(path) for path in entries if path.name.casefold() == 'saddress.adr'
|
||||
and (scope_root is None or path.resolve().is_relative_to(scope_root))]
|
||||
if addresses:
|
||||
raise LibraryBusy(f'库中仍有数据库地址记录,不能自动解除:{addresses}')
|
||||
native = [path for path in entries if path.is_file() and (
|
||||
path.suffix.casefold() == '.lmc'
|
||||
or (path.name.casefold() in ('icdb.dat', 'layoutdb.lyt')
|
||||
and (scope_root is None or path.resolve().is_relative_to(scope_root))))]
|
||||
if Path(library).resolve() not in native:
|
||||
raise LibraryBusy('目标库身份缺失,不能解除协调阻止。')
|
||||
with ExitStack() as stack:
|
||||
export_copies = stack.enter_context(prove_export_copies_released(library))
|
||||
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,
|
||||
'exclusive_files': [str(path) for path in native]}
|
||||
finally:
|
||||
uninitialize_com(initialized)
|
||||
|
||||
|
||||
def release_retained_library(library, evidence_dir, *, block_name=None):
|
||||
"""Explicit user-requested release, 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:
|
||||
raise LibraryBusy('其他进程仍持有库锁,不能解除。') from error
|
||||
proof_context = (_prove_library_released(library, block_name=block_name)
|
||||
if block_name else _prove_library_released(library))
|
||||
with proof_context as proof:
|
||||
marker = blocker_path(library)
|
||||
checkpoints = (marker, marker.with_suffix('.pending'))
|
||||
if any(path.exists() and checkpoint_record(path) is None for path in checkpoints):
|
||||
raise LibraryBusy('协调检查点格式不明或已损坏,保留原文件供人工审查。')
|
||||
root = evidence/('release-' + uuid4().hex)
|
||||
root.mkdir(parents=True, exist_ok=False)
|
||||
record = {'library': str(library), 'status': 'RELEASE_CONFIRMED', **proof,
|
||||
'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
|
||||
@@ -0,0 +1,454 @@
|
||||
"""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 .failed_session import _command_args
|
||||
from .native_management import _retained_workers
|
||||
from .native_export_guard import assert_retained_exports_idle
|
||||
from .native_engineering_identity import _OWNER_NAMES
|
||||
assert_retained_exports_idle()
|
||||
if any(worker.poll() is None 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')):
|
||||
owners.append(item)
|
||||
if target is not None:
|
||||
expected = os.path.normcase(os.path.abspath(str(target.project)))
|
||||
scoped = []
|
||||
for item in owners:
|
||||
command = str(item.get('command') or '')
|
||||
if not command:
|
||||
scoped.append(item)
|
||||
elif expected in [os.path.normcase(os.path.abspath(arg)) for arg in _command_args(command)[1:]]:
|
||||
scoped.append(item)
|
||||
owners = scoped
|
||||
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):
|
||||
"""Inspect through Project Backup; never launch PCB, Repair or Restore."""
|
||||
from .verify_runner import VerifyResult
|
||||
from .library_lock import LibraryLock, LibraryBusy
|
||||
from .native_repair import run_native_repair, RepairTarget
|
||||
from .native_backup import native_backup_project
|
||||
from .backup_recovery import _project_text
|
||||
from .native_occupancy import confirmed_inspection
|
||||
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}
|
||||
released = True
|
||||
def check():
|
||||
if stop is not None and stop.is_set():
|
||||
raise InterruptedError('已取消检查。')
|
||||
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:
|
||||
check()
|
||||
root.mkdir(parents=True, exist_ok=False)
|
||||
with LibraryLock(request.lmc_file, checkpoint=False, safe_to_release=lambda: released):
|
||||
project = native_backup_project(request.lmc_file, request.block_name)
|
||||
values = re.findall(r'^KEY iCDBDir "([^"\r\n]*)"', _project_text(project), re.M)
|
||||
if (len(values) != 1 or not values[0] or PureWindowsPath(values[0]).drive
|
||||
or PureWindowsPath(values[0]).root
|
||||
or (project.parent/values[0]).resolve() != (project.parent/'database').resolve()):
|
||||
raise ValueError('无法确认工程的 ICDB 数据库路径。')
|
||||
target = RepairTarget(project, project.parent/'database')
|
||||
record['target'] = asdict(target)
|
||||
check()
|
||||
if progress:
|
||||
progress({'stage': 'icdb_ownership_check', 'block': request.block_name,
|
||||
'detail': '正在检查 ICDB 状态'})
|
||||
released = False
|
||||
inspection = run_native_repair(target, root/'native-inspection',
|
||||
mentor_bin=request.mentor_bin, timeout_seconds=min(30, request.timeout_seconds),
|
||||
progress=progress, inspection_only=True, stop=stop)
|
||||
record['native_inspection'] = inspection
|
||||
released = (inspection.get('release', {}).get('native_exited') is True
|
||||
or inspection.get('native_started') is False
|
||||
and inspection.get('native_pid') is None and inspection.get('worker_pid') is None)
|
||||
if ((stop is not None and stop.is_set())
|
||||
or inspection.get('status') in ('CANCELLED', 'CANCELLED_UNRELEASED')):
|
||||
return save(VerifyResult('CANCELLED', safe_to_continue=released, stderr='已取消 ICDB 检查。'))
|
||||
if not confirmed_inspection(target, inspection):
|
||||
return save(VerifyResult('FAIL', safe_to_continue=released,
|
||||
error_category='ICDB_INSPECTION_UNCONFIRMED',
|
||||
stderr='无法确认 ICDB 状态。' + str(inspection.get('detail', ''))))
|
||||
if inspection['status'] == 'IN_USE':
|
||||
return save(VerifyResult('BLOCKED', safe_to_continue=released,
|
||||
error_category='ICDB_DATABASE_IN_USE', stderr='工程正在使用,暂未完成 ICDB 检查。'))
|
||||
if inspection['repair_required']:
|
||||
return save(VerifyResult('FAIL', safe_to_continue=released,
|
||||
error_category='ICDB_REPAIR_REQUIRED', stderr='发现 ICDB 问题,未执行修复。'))
|
||||
return save(VerifyResult('CHECKED', safe_to_continue=released,
|
||||
stdout='ICDB 检查未发现异常,无需修复。'))
|
||||
except InterruptedError:
|
||||
return save(VerifyResult('CANCELLED', safe_to_continue=released, stderr='已取消 ICDB 检查。'))
|
||||
except LibraryBusy as error:
|
||||
return save(VerifyResult('BLOCKED', safe_to_continue=False,
|
||||
error_category='LIBRARY_IN_USE', stderr=str(error)))
|
||||
except Exception as error:
|
||||
return save(VerifyResult('FAIL', safe_to_continue=released,
|
||||
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']))
|
||||
@@ -0,0 +1,365 @@
|
||||
"""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,
|
||||
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 = ''
|
||||
|
||||
|
||||
@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
|
||||
|
||||
|
||||
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:
|
||||
results.append({**record, 'evidence_path': str(path)})
|
||||
except (OSError, ValueError):
|
||||
results.append({'status': 'CHECKPOINT_UNREADABLE', 'evidence_path': str(path)})
|
||||
return results
|
||||
|
||||
|
||||
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
|
||||
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):
|
||||
result = ManagementResult(request.operation, request.library, request.name, request.partition,
|
||||
request.source, request.auto_verify, 'complete', status, safe, detail, report)
|
||||
if report:
|
||||
_write_json(report, {**asdict(result), 'history': history, 'backup_policy': 'manual'})
|
||||
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)
|
||||
for unfinished in unfinished_operations(evidence):
|
||||
if unfinished.get('library') and Path(unfinished['library']).resolve() == canonical_library:
|
||||
return finish('BLOCKED', f'存在未完成/需恢复任务,禁止自动重放:{unfinished["evidence_path"]}', False)
|
||||
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('来源工程、目标库与操作证据必须使用独立目录。')
|
||||
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 校验/管理/恢复任务运行。', False)
|
||||
if hasattr(adapter, 'bind_library_mapping'):
|
||||
adapter.bind_library_mapping(request.mapped_drive, request.mapped_remote_root)
|
||||
with LibraryLock(library, safe_to_release=lambda: owner_safe):
|
||||
root = evidence/('management-' + uuid4().hex)
|
||||
root.mkdir(parents=True, exist_ok=False)
|
||||
report = root/'checkpoint.json'
|
||||
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 = 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 = 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, False)
|
||||
owner_safe = False
|
||||
idle_check(library, target_project, target_pcb)
|
||||
owner_safe = False
|
||||
after = 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', '原生移除后目录未确认目标缺失。', False)
|
||||
removed = True
|
||||
checkpoint('removed')
|
||||
if request.operation == 'remove':
|
||||
return finish('REMOVED', '已由原生操作移除,重新读取目录确认不存在;应用未创建备份。')
|
||||
checkpoint('native_add')
|
||||
mutated = True; owner_safe = False
|
||||
native = 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 and not removed)
|
||||
owner_safe = False
|
||||
idle_check(library, target_project, target_pcb)
|
||||
after = 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', '原生新增后名称、分区或来源工程内容未确认一致。', False)
|
||||
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), False)
|
||||
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'
|
||||
return finish(status, str(error), not mutated and owner_safe and not isinstance(error, LibraryBusy))
|
||||
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
|
||||
@@ -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):
|
||||
@@ -338,8 +359,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 +605,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,10 +632,8 @@ def execute_job(job, emit):
|
||||
evidence=str(root/'diagnostics/preflight.json'))
|
||||
cert_project = block_root/'Cert'/Path(job['project']).name
|
||||
pcb_log = Path(job['pcb']).parent/'LogFiles'/'PCBLogFile.txt'
|
||||
try:
|
||||
pcb_log_offset = pcb_log.stat().st_size
|
||||
except OSError:
|
||||
pcb_log_offset = 0
|
||||
from .icdb_recovery import snapshot_log
|
||||
pcb_log_offset = snapshot_log(pcb_log)
|
||||
integration_log_dir = Path(job['pcb']).parent / 'LogFiles'
|
||||
integration_offsets = {}
|
||||
for name in ('ForwardAnnotation.txt', 'MsgBoxResponse.log', 'PartPkg.log'):
|
||||
@@ -633,7 +647,28 @@ 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)
|
||||
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 +676,29 @@ 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}')
|
||||
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))
|
||||
@@ -673,6 +723,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 +734,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,
|
||||
@@ -704,8 +759,36 @@ def execute_job(job, emit):
|
||||
process_alive=lambda: any(candidate_pid in {lm_pid, worker_pid, worker_parent_pid}
|
||||
for candidate_pid, _, _ in pcb_processes()),
|
||||
emit=emit,
|
||||
error_reader=lambda: pcb_log_reports_missing_server(job['pcb'], offset=pcb_log_offset),
|
||||
error_reader=native_error,
|
||||
)
|
||||
identity_verified = True
|
||||
if job.get('diagnostic_only'):
|
||||
# The diagnostic opens only to establish current native evidence.
|
||||
# Do not refresh integration, save/commit Cert, or edit PRJ paths.
|
||||
if detail := native_error():
|
||||
raise RuntimeError(detail)
|
||||
pi = doc = app = None
|
||||
gc.collect()
|
||||
from .failed_session import close_failed_document
|
||||
diagnostic_close_attempted = True
|
||||
closed = close_failed_document(job, emit=emit)
|
||||
if closed.get('status') != 'CLOSED':
|
||||
raise RuntimeError(f'DIAGNOSTIC_CLOSE_UNCONFIRMED: {closed}')
|
||||
release_deadline = time.monotonic() + 30
|
||||
while True:
|
||||
released = cleanup_verify_processes(lm_pid, worker_pid, worker_parent_pid,
|
||||
expected_pcb=job['pcb'], baseline_pids=pcb_before, emit=emit)
|
||||
if (released and released.get('safe_to_continue')
|
||||
and not unreleased_addresses(job['lmc_file'], job['project'], job['pcb'])):
|
||||
break
|
||||
if time.monotonic() >= release_deadline:
|
||||
raise RuntimeError('DIAGNOSTIC_CLOSE_UNCONFIRMED: 原生会话或数据库仍占用')
|
||||
time.sleep(.2)
|
||||
if detail := native_error():
|
||||
raise RuntimeError(detail)
|
||||
completed = True
|
||||
emit(stage='diagnostic_complete', status='PASS')
|
||||
return {'status': 'PASS', 'stdout': 'ICDB 启动检查通过;未执行集成或保存,已关闭工程。'}
|
||||
# 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 +798,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 +846,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 +863,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 +875,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:
|
||||
# A timed-out close helper may still own an in-flight native Close.
|
||||
# Observe release below, but never start a second close helper.
|
||||
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 +905,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 +924,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 +966,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 +976,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,6 +989,9 @@ 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
|
||||
@@ -914,10 +1002,8 @@ def worker_main(request_path):
|
||||
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 +1072,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 +1094,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 +1111,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 +1125,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 +1160,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 +1169,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 +1212,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 +1415,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.
|
||||
|
||||
@@ -1325,11 +1449,12 @@ def read_library_flag(library, name, *, timeout_seconds=90, log_path=None):
|
||||
if not executable.is_file():
|
||||
return FLAG_UNKNOWN, f'找不到 Library Manager: {executable}'
|
||||
|
||||
from pywinauto import Desktop
|
||||
from pywinauto.controls.common_controls import TreeViewWrapper
|
||||
|
||||
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
|
||||
|
||||
handle = None
|
||||
pid = None
|
||||
@@ -1372,13 +1497,7 @@ 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()
|
||||
@@ -1389,6 +1508,9 @@ def read_library_flag(library, name, *, timeout_seconds=90, log_path=None):
|
||||
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.
|
||||
@@ -1463,13 +1585,7 @@ 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()
|
||||
@@ -1480,6 +1596,9 @@ def read_library_tree_image_map(library, names, *, timeout_seconds=45, log_path=
|
||||
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)
|
||||
@@ -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,428 @@
|
||||
"""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():
|
||||
import win32com.client
|
||||
service = win32com.client.GetObject('winmgmts:')
|
||||
try:
|
||||
return [{'pid': int(p.ProcessId), 'parent': int(p.ParentProcessId or 0),
|
||||
'name': str(p.Name), 'executable': str(p.ExecutablePath or '')}
|
||||
for p in service.ExecQuery('SELECT ProcessId, ParentProcessId, Name, ExecutablePath FROM Win32_Process')]
|
||||
finally:
|
||||
service = None
|
||||
|
||||
|
||||
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)
|
||||
_write_json(root/'export-launch.json', {'started': False})
|
||||
before = _process_snapshot()
|
||||
if any(p['name'].casefold() in _OWNER_NAMES 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 = {}
|
||||
released = False
|
||||
record = {'command': command, 'kind': kind, 'success': False, 'safe_to_continue': 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})
|
||||
process = subprocess.Popen(command, stdout=output, stderr=subprocess.STDOUT,
|
||||
creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
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]
|
||||
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())
|
||||
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:
|
||||
record.update(detail=str(error), safe_to_continue=released)
|
||||
return record
|
||||
finally:
|
||||
if process is not None and not released:
|
||||
_retained_exports.append((process, handles))
|
||||
else:
|
||||
for handle in handles.values(): handle.Close()
|
||||
_write_json(root/(kind+'-process.json'), record)
|
||||
return {'success': True, 'safe_to_continue': True, 'detail': 'All three native exports completed and released.'}
|
||||
|
||||
|
||||
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
|
||||
source, pcb, top = source_project(source)
|
||||
root = Path(evidence_root).absolute()
|
||||
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')
|
||||
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)
|
||||
_write_json(root/'native-outcome.json', native)
|
||||
if native.get('safe_to_continue') is True:
|
||||
finish_export_analysis(library, export_token)
|
||||
owner_safe = True
|
||||
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()
|
||||
_write_json(root/'identity.json', {'identity': outcome.identity, 'safe_to_continue': outcome.safe_to_continue,
|
||||
'detail': outcome.detail, 'policy': POLICY})
|
||||
return outcome
|
||||
@@ -0,0 +1,117 @@
|
||||
"""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():
|
||||
import win32con, win32event
|
||||
from .native_engineering_identity import _retained_exports
|
||||
from .library_lock import LibraryBusy
|
||||
for process, handles in _retained_exports:
|
||||
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):
|
||||
"""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
|
||||
assert_retained_exports_idle()
|
||||
library = Path(library).resolve()
|
||||
marker = blocker_path(library)
|
||||
checkpoint = checkpoint_record(marker)
|
||||
if marker.exists() and checkpoint is None:
|
||||
raise LibraryBusy('Invalid library checkpoint cannot release export ownership.')
|
||||
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.')
|
||||
owners = [p for p in _process_snapshot() if p['name'].casefold() in _OWNER_NAMES]
|
||||
if owners: raise LibraryBusy(f'Native identity owners remain active: {owners}')
|
||||
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 = json.loads((root/'export-launch.json').read_text(encoding='utf-8'))
|
||||
if launch != {'started': False}:
|
||||
raise ValueError('Export launch has no confirmed process record.')
|
||||
for path in processes:
|
||||
process = json.loads(path.read_text(encoding='utf-8'))
|
||||
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.')
|
||||
if any(_supervisor_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):
|
||||
from .library_lock import _guard, blocker_path, checkpoint_record, LibraryBusy
|
||||
with _guard, prove_export_copies_released(library):
|
||||
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'])
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -178,6 +178,7 @@ class LibraryPathLease:
|
||||
created: bool = False
|
||||
_backend: WNetBackend | None = None
|
||||
_closed: bool = False
|
||||
_retained_for_recovery: bool = False
|
||||
|
||||
@classmethod
|
||||
def acquire(cls, path, *, backend: WNetBackend | None = None) -> "LibraryPathLease":
|
||||
@@ -224,11 +225,23 @@ class LibraryPathLease:
|
||||
f"NETWORK_UNAVAILABLE: 无法挂载中心库 {remote_root}: {error}"
|
||||
) from error
|
||||
|
||||
def retain_for_recovery(self) -> None:
|
||||
"""Keep the Mentor drive available to a retained native session."""
|
||||
self._retained_for_recovery = True
|
||||
|
||||
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
|
||||
|
||||
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 or not self.created or self._backend is None or not self.drive:
|
||||
return
|
||||
try:
|
||||
current = self._backend.mappings().get(self.drive)
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
"""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')
|
||||
with tempfile.TemporaryDirectory(prefix='cbb-owner-probe-') as directory:
|
||||
job = Path(directory)/'request.json'
|
||||
job.write_text(json.dumps({'names': names}), 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']
|
||||
if result.returncode != 0 or record['names'] != list(names) or not isinstance(rows, list):
|
||||
raise ValueError('invalid result')
|
||||
for row in rows:
|
||||
if (type(row['pid']) is not int or row['pid'] <= 0 or row['name'].casefold() not in {n.casefold() for n in names}
|
||||
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')
|
||||
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)
|
||||
names = json.loads(job.read_text('utf-8'))['names']
|
||||
if not names or any(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 FROM Win32_Process 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)} for item in service.ExecQuery(query)]
|
||||
service = None
|
||||
job.with_name('result.json').write_text(json.dumps({'names': names, 'owners': rows}), encoding='utf-8')
|
||||
return 0
|
||||
finally:
|
||||
pythoncom.CoUninitialize()
|
||||
@@ -103,6 +103,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)
|
||||
|
||||
@@ -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]
|
||||
@@ -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
|
||||
|
||||
@@ -0,0 +1,365 @@
|
||||
"""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
|
||||
_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('work.before-restore-')
|
||||
or directories[:2] == ('projectbackup', 'backups')))
|
||||
|
||||
|
||||
def _native_runtime(directories, database_prefix):
|
||||
runtime_prefix = database_prefix + ('cdbsvr',)
|
||||
return (directories[:len(runtime_prefix)] == runtime_prefix
|
||||
and len(directories) > len(runtime_prefix)
|
||||
and directories[len(runtime_prefix)] in ('log', 'dbcheck', 'dbrestore'))
|
||||
|
||||
|
||||
def _project_runtime(directories):
|
||||
return (_root_runtime(directories)
|
||||
or (directories[:1] == ('pcb',) and _root_runtime(directories[1:]))
|
||||
or _native_runtime(directories, ('database',))
|
||||
or _native_runtime(directories, ('pcb', 'database')))
|
||||
|
||||
|
||||
@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] == 'saddress.adr' or parts[-1].startswith('~$')):
|
||||
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 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. 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()
|
||||
else:
|
||||
if label is not None:
|
||||
digest = hash_function(path)
|
||||
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)
|
||||
@@ -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,134 @@
|
||||
"""Small, asynchronous entry point for recovery from a healthy CBB project."""
|
||||
from pathlib import Path
|
||||
|
||||
from PySide6.QtCore import QObject, QThreadPool, Signal
|
||||
from PySide6.QtWidgets import (QComboBox, QDialog, QFileDialog, QFormLayout,
|
||||
QHBoxLayout, QLabel, QLineEdit, QPushButton, 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.busy = False
|
||||
self.pool = QThreadPool(self)
|
||||
self.pool.setMaxThreadCount(1)
|
||||
self.signals = RecoverySignals(self)
|
||||
self.signals.progress.connect(self._progress)
|
||||
self.block_combo = QComboBox()
|
||||
self.block_combo.addItems(list(names))
|
||||
self.source_edit = QLineEdit()
|
||||
self.source_edit.setPlaceholderText('选择同名 CBB 完整备份中的工程 .prj')
|
||||
self.browse_button = QPushButton('选择…')
|
||||
self.browse_button.clicked.connect(self._browse)
|
||||
self.restore_button = QPushButton('恢复并校验')
|
||||
self.restore_button.clicked.connect(self._restore)
|
||||
self.close_button = QPushButton('关闭')
|
||||
self.close_button.clicked.connect(self.reject)
|
||||
self.status_label = QLabel(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.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._set_enabled(False)
|
||||
self.status_label.setText('正在准备恢复…')
|
||||
self.started.emit(name)
|
||||
self.worker = ServiceWorker(lambda: recoverer(
|
||||
request, source, progress=self.signals.progress.emit))
|
||||
self.worker.signals.succeeded.connect(lambda result: self._result(name, result))
|
||||
self.worker.signals.failed.connect(lambda error: self._failed(name, error))
|
||||
self.worker.signals.finished.connect(self._finished)
|
||||
self.pool.start(self.worker)
|
||||
|
||||
def _set_enabled(self, enabled):
|
||||
for widget in (self.block_combo, self.source_edit, self.browse_button,
|
||||
self.restore_button, self.close_button):
|
||||
widget.setEnabled(enabled)
|
||||
|
||||
def _progress(self, event):
|
||||
if isinstance(event, dict):
|
||||
message = event.get('message') or event.get('detail')
|
||||
if message:
|
||||
self.status_label.setText(str(message))
|
||||
|
||||
def _result(self, name, result):
|
||||
if result.status == 'PASS':
|
||||
message = '恢复完成,工程打开与校验通过。'
|
||||
else:
|
||||
message = f'恢复未通过:{result.stderr or result.stdout or result.status}'
|
||||
if result.evidence_path:
|
||||
message += f'\n记录:{result.evidence_path}'
|
||||
self.status_label.setText(message)
|
||||
self.completed.emit(name, result)
|
||||
|
||||
def _failed(self, name, error):
|
||||
from cbb_refresh_verify.verify_runner import VerifyResult
|
||||
self._result(name, VerifyResult('FAIL', stderr=f'恢复未完成:{error}', safe_to_continue=False))
|
||||
|
||||
def _finished(self):
|
||||
self.busy = False
|
||||
self._set_enabled(True)
|
||||
|
||||
def reject(self):
|
||||
if not self.busy:
|
||||
super().reject()
|
||||
|
||||
def closeEvent(self, event):
|
||||
if self.busy:
|
||||
event.ignore()
|
||||
else:
|
||||
super().closeEvent(event)
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,220 @@
|
||||
"""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': '正在检查工程是否被占用',
|
||||
}
|
||||
|
||||
|
||||
class ManagementSignals(QObject):
|
||||
progress = Signal(object)
|
||||
|
||||
|
||||
class ManagementDialog(QDialog):
|
||||
completed = 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.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.worker = ServiceWorker(lambda: self.runner(requests, adapter=self.adapter, stop=self.stop,
|
||||
progress=self.signals.progress.emit))
|
||||
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, "正在处理"))}'
|
||||
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}'
|
||||
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')
|
||||
@@ -113,6 +113,8 @@ def collect_native_failure_logs(pcb_path, evidence_root, *, max_bytes=NATIVE_LOG
|
||||
target = destination/(label+'-'+source.name)
|
||||
target.write_bytes(data)
|
||||
item.update(evidence=str(target), copied_bytes=len(data))
|
||||
if label == 'pcb-logfiles' and source.name != 'ReusableBlock.txt':
|
||||
_collect_icdb_recovery(source, evidence_root)
|
||||
except FileNotFoundError:
|
||||
item['exists'] = False
|
||||
except OSError as error:
|
||||
@@ -120,6 +122,23 @@ def collect_native_failure_logs(pcb_path, evidence_root, *, max_bytes=NATIVE_LOG
|
||||
return _write_record(destination.parent/'native-logs.json', record)
|
||||
|
||||
|
||||
def _collect_icdb_recovery(source, evidence_root):
|
||||
"""Only promote a native error whose log changed after this launch."""
|
||||
from .icdb_recovery import read_log_failure
|
||||
root = Path(evidence_root)/'diagnostics'
|
||||
try:
|
||||
baseline = json.loads((root/'startup-log-baseline.json').read_text('utf-8'))
|
||||
checkpoint = (baseline['baseline'] if baseline['source'] == str(source) else
|
||||
baseline.get('integration_logs', {}).get(str(source)))
|
||||
if checkpoint is None:
|
||||
return
|
||||
_, recovery = read_log_failure(source, checkpoint)
|
||||
if recovery:
|
||||
_write_record(root/'icdb-recovery.json', {**recovery, 'source': str(source)})
|
||||
except (OSError, ValueError, KeyError, TypeError):
|
||||
pass # Unknown freshness must not replace the original failure.
|
||||
|
||||
|
||||
|
||||
def failure_logs_main(request_path):
|
||||
job = json.loads(Path(request_path).read_text(encoding='utf-8'))
|
||||
|
||||
@@ -56,12 +56,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 +84,7 @@ class VerifyResult:
|
||||
bridge_attempts: tuple[dict, ...] = ()
|
||||
timings_seconds: dict[str, float] = field(default_factory=dict)
|
||||
incomplete_timing_phases: tuple[str, ...] = ()
|
||||
recovery_attempts: tuple[dict, ...] = ()
|
||||
|
||||
|
||||
def resolve_importer(mentor_bin: str | None = None) -> Path:
|
||||
@@ -127,7 +132,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 +158,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 +192,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 +205,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 +277,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 +492,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'
|
||||
@@ -497,10 +513,10 @@ def _cleanup_session_processes(root, *, lm_pid, target_pid, pcb, pcb_baseline,
|
||||
if 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 +524,166 @@ 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
|
||||
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=False)
|
||||
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
|
||||
if Path(request.lmc_file).is_file():
|
||||
try:
|
||||
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')
|
||||
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
|
||||
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 +695,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)
|
||||
@@ -553,7 +747,7 @@ def run_verify(request, *, progress=None, flag_reader=None, process_runner=None,
|
||||
|
||||
|
||||
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``.
|
||||
@@ -570,20 +764,23 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
progress({'stage': 'runtime_fingerprint', 'block': request.block_name,
|
||||
**fingerprint})
|
||||
result_path = root/'result.json'
|
||||
runner = process_runner or _run_process
|
||||
runner = process_runner or (lambda command, timeout, cwd:
|
||||
_run_process(command, timeout, cwd, evidence_root=root))
|
||||
|
||||
def finish(result):
|
||||
# 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 +789,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)
|
||||
@@ -619,12 +816,12 @@ 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'})
|
||||
|
||||
# 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()
|
||||
@@ -635,6 +832,8 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
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 +841,21 @@ 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
|
||||
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', safe_to_continue=False))
|
||||
job['post_repair_consent'] = request.post_repair_proof.for_job(job)
|
||||
consent = ConsentController(request.post_repair_proof, job)
|
||||
job_path = root/'request.json'
|
||||
job_path.write_text(json.dumps(job, ensure_ascii=False), encoding='utf-8')
|
||||
events = root/'events.jsonl'
|
||||
offset = 0
|
||||
target_pid = None
|
||||
launcher_pid = None
|
||||
lm_pid = None
|
||||
verify_invoked = False
|
||||
invoke_returned = False
|
||||
@@ -672,9 +880,12 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
worker_command(job_path), None, interactive_input=True)
|
||||
else:
|
||||
process = DesktopWorker(worker_command(job_path), job['desktop'])
|
||||
if hasattr(process, 'bind_cancellation'):
|
||||
process.bind_cancellation(job['cancel_signal'])
|
||||
deadline = ActivityDeadline(request.timeout_seconds)
|
||||
last_activity_key = None
|
||||
phase = DialogPhase.PCB_STARTING
|
||||
restore_controller = None
|
||||
dialog_agent = None
|
||||
latest_snapshots = ()
|
||||
if dialog_supervisor_factory is None:
|
||||
@@ -698,6 +909,10 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
)
|
||||
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 +923,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
|
||||
@@ -759,6 +975,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 +1021,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({
|
||||
@@ -817,8 +1057,8 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
'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():
|
||||
@@ -832,24 +1072,88 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
_stop_worker(process)
|
||||
return finish(VerifyResult('FAIL', stderr=str(error), safe_to_continue=False))
|
||||
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,7 +1172,7 @@ 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):
|
||||
@@ -891,7 +1195,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,13 +1209,12 @@ 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)
|
||||
return results
|
||||
@@ -934,11 +1237,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 +1272,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 批量检查结果', '流程: 原生 Project Backup 加载检查;不执行 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' +
|
||||
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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
@@ -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": []
|
||||
}
|
||||
@@ -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()
|
||||
@@ -0,0 +1,336 @@
|
||||
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_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'
|
||||
Loaded 100 of 157 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user