diff --git a/README.md b/README.md index 7cbf311..2f5fd34 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,17 @@ # 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)。下方日期记录描述历史版本,以本补丁说明为准。 +当前临时分支的备份策略(2026-11-03):应用不再自动备份中心库或 CBB 工程。新增、替换、移除、校验、ICDB 维护和恢复在执行前提示手动备份;请自行保留可用副本。导入暂存、恢复用隔离验证库和轻量操作证据仍会生成,Mentor 原生 Repair 自身的备份行为保持不变。详见[自动备份检查与调整](docs/releases/2026-11-03-manual-backup.md)。此条优先于下方历史版本的备份说明。 + +当前开发版本:**[v0.2.4-beta.1](docs/releases/v0.2.4-beta.1.md)(待评审、待现场验收)**。ICDB 批量检查在后台逐项运行,普通校验、管理和恢复可排队;READY 工程在实际执行前再次排除。检查不自动 Repair、Restore 或选择历史版本,也不代表中心库 READY。 + +自动流程不强杀原生会话;释放入口默认正常关闭。另有单独确认的“强制结束客户端”操作,仅限属于当前 Windows 用户和会话、归属及进程身份已确认的 PCB、Library Manager、DxDesigner/viewdraw、iCDB Project Backup 客户端。**ICDB 数据库服务器、后台导入器和归属未知的进程不允许强制结束**,即使命令指向当前库也不例外。客户端中其他已打开工程可能一并退出、未保存更改可能丢失;必须先记录确认名单,结束后重新证明库已释放,不能宣称数据库已修复。详见 [操作规程](SOP.md) 与 [版本说明](docs/releases/v0.2.4-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 入口时停止并要求人工处理。 +当前应用入口仅检查工程打开情况,不自动 Repair。需要修复或回退时由用户在原生版本与备份界面选择,操作前请手动备份;共享符号库故障不得通过修复无关的 CBB 工程替代。 ## 功能边界 @@ -203,7 +205,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/`:历史版本的辅助文件副本;当前分支不再生成,所有路径记录 `backup_skipped / manual_backup_policy`。已有历史副本不由本轮改动清理。 +- `backup/`:历史版本的辅助文件副本;当前分支不再生成,所有路径记录 `backup_skipped / manual_backup_policy`。已有历史副本不由本轮改动清理。 超时采用无进展计时:界面和批量请求默认 600 秒无进展超时;它不是整个 CBB 的固定总时限,而是连续 600 秒没有可观察进展时才终止。PCB/COM 阶段切换、Project Integration 状态变化、保存标记变化和弹窗处理都会刷新计时器;重复的状态轮询不算进展。需要更快失败时仍可在界面将单项预算调低,但 30 秒只适合已确认 PCB 启动稳定的环境。 diff --git a/SOP.md b/SOP.md index fd7a084..a38e1b3 100644 --- a/SOP.md +++ b/SOP.md @@ -1,4 +1,32 @@ -# CBB 中心库上传后校验操作规程 +# CBB 检查、校验、管理与残留释放操作规程 + +适用开发版本:0.2.4b1。未完成现场验收,不自动发布或关闭工单。以下为当前规程,下方旧上传校验检查表保留为历史参考。 + +## 当前操作与队列 + +选择中心库 `.lmc`,核对 CBB 名称、分区及完整 PRJ/PCB 工程。写操作和人工修复前由操作员保存可用一致备份;应用不自动备份整个中心库,隔离验证/暂存副本不代替人工备份。 + +普通校验完成原生打开、身份确认、Project Integration、保存和关闭后,必须由权威状态 READY/raw=1 确认成功。ICDB 检查仅尝试打开并检查本次错误,不自动 Repair、Restore 或选择版本,CHECKED 不等于 READY。排队期间变成 READY 的工程在执行前跳过。 + +原生任务串行排队,检查每项结束后让出机会;缓存筛选保持可用。失败项确认释放后继续独立项目;实际未释放时停止后续原生操作。“停止检查”只取消检查,“取消当前任务并停止队列”同时取消前台任务及后续后台检查,已进行的写入等待安全结束,不强杀代替取消。 + +新增拒绝同名冲突;更新先原生移除再导入,失败可能需要人工备份恢复;移除后重新读取目录确认。版本回退由操作员在原生界面选择,核对工程内容后单独校验。 + +## 默认释放与单独确认的强制客户端操作 + +1. 停止新任务,预览当前库的工程、程序、PID 和历史记录。默认“确认释放”仅正常关闭作用域及当前身份已确认的客户端。未保存更改由操作员选择保存、放弃或保留;未知提示保持现场。 +2. 数据库服务器可能服务同库其他用户。本工具不允许强制结束服务器,命令行指向本库也不构成独占授权;由库管理员核对用户和服务器状态。 +3. “强制结束客户端”是另行确认的异常处理,只允许属于当前 Windows 用户和会话、已确认作用域和精确进程身份的 Expedition PCB、Library Manager、viewdraw、iCDB Project Backup 客户端。后台导入器、脚本宿主和归属未知的进程同样不在强制名单。 +4. 警告明确告知客户端中其他已打开工程可能一并退出、未保存更改会丢失、写入中的工程可能需要恢复。执行前持久保存库外 `consent.json`,包含目标库、名单、创建身份和排除项;写入失败不执行。派发与最终进程句柄两处重新核对,PID 复用、用户/Windows 会话或范围变化时拒绝。 +5. 客户端退出仅证明进程结束,不表示修复成功或 READY。服务器仍活跃或库状态未知时保留 PARTIAL、检查点和映射。只有完整的独立释放证明才解除匹配的历史记录;空进程列表本身不是释放证明。 + +## 失败、证据和回退 + +保留原生错误、操作员、Mentor 版本、库/工程身份和证据目录;原生日志上传前脱敏。不得删除原生地址/锁文件或修改 LMC 伪造状态。强制客户端退出不可撤销;工程恢复依靠人工一致备份或原生历史版本,不自动回退共享库或重放写操作。 + +程序回退须先关闭当前客户端,再运行此前候选包;它不恢复丢失更改或被中断的原生事务。工程恢复另行在隔离副本验证,保留前后证据并重新校验。Windows 10、共享库跨机器并发和现场服务器失联恢复仍待验收,fake 测试和文件头损坏试验不代替现场验收。 + +## 历史上传校验检查表 ## 1. 输入与证据 diff --git a/docs/ICDB-MANUAL-REPAIR-AND-UPDATE.md b/docs/ICDB-MANUAL-REPAIR-AND-UPDATE.md index 5594030..f927f48 100644 --- a/docs/ICDB-MANUAL-REPAIR-AND-UPDATE.md +++ b/docs/ICDB-MANUAL-REPAIR-AND-UPDATE.md @@ -8,6 +8,14 @@ 操作前正常关闭使用相同库的 PCB、Library Manager、原理图/符号编辑客户端,核对原服务器会话已结束,保留包含数据库、原备份和日志的完整一致副本。以下写入先在副本上进行。 +## 残留客户端与共享服务器 + +0.2.4b1 的默认检查、校验、取消和释放流程不会强杀原生会话。操作员可以在独立确认界面强制结束属于当前 Windows 用户和会话、名单中的受支持客户端;这会影响该客户端内其他已打开工程,未保存更改可能丢失,属于异常退出处理,不能替代 Repair。 + +ICDB 数据库服务器即使命令行指向当前中心库,也可能服务其他用户,**本工具不允许强制结束服务器**。归属未知的进程、后台导入器和脚本宿主同样不允许强制结束;由库管理员核对用户和服务器状态后处理。 + +强制客户端动作必须先在库外证据目录持久写入确认名单、库和进程创建身份,再核对当前进程句柄、用户 SID 和 Windows 会话;记录失败或身份变化时不执行。客户端结束后仍需独立证明库已释放,重新打开工程并核对版本,必要时从人工一致备份或原生历史版本恢复。不能把“进程已结束”解释为“ICDB 已修复”。具体步骤见 [操作规程](../SOP.md)。 + ## 原生工程数据库 Repair 1. 启动本机的 iCDB Project Backup,并打开实际报错工程对应的 `.prj`。本机可用 PowerShell 命令形式如下,工程路径需替换为自己的隔离副本: diff --git a/docs/releases/2026-11-05-pr249-review-validation.json b/docs/releases/2026-11-05-pr249-review-validation.json new file mode 100644 index 0000000..0ebdf75 --- /dev/null +++ b/docs/releases/2026-11-05-pr249-review-validation.json @@ -0,0 +1,90 @@ +{ + "review_comment": "https://git.simgreek.com/Skyworth_Digital_Hardware/cbb-refresh-verify-795/pulls/3#issuecomment-249", + "version": "0.2.4b1", + "base_main": "a56fd17b60d9f67997d7f48c862f3367d4502f84", + "tests": { + "infrastructure": { + "tests": 491, + "errors": 0, + "failures": 0, + "skipped": 0, + "xml_sha256": "12c2cd40542cb01d4fa374e98908c8a77a8deb83f95d0833645b1666ea5574e9", + "xml_file": "codex-review-infrastructure-pytest.xml", + "seconds": 52.986 + }, + "native_backend": { + "tests": 1376, + "errors": 0, + "failures": 0, + "skipped": 0, + "xml_sha256": "8db65d11dd918d2a1b141d72627654a990ea903b68e20511e982dfb927d6be58", + "xml_file": "codex-review-native-backend-pytest.xml", + "seconds": 275.957 + }, + "ui_integration": { + "tests": 1545, + "errors": 0, + "failures": 0, + "skipped": 0, + "xml_sha256": "5a3e6d58d611240c6e34cc9bd2350a8bf605516ef453240333836c1f88233af6", + "xml_file": "codex-review-ui-integration-pytest.xml", + "seconds": 325.065 + }, + "final_stack": { + "tests": 1601, + "errors": 0, + "failures": 0, + "skipped": 0, + "xml_sha256": "bab74328facfbf512416b62a074fb5cb65ea39b04f0039d42083f96b5349c351", + "xml_file": "codex-review-residual-release-pytest.xml", + "seconds": 246.75 + }, + "umbrella": { + "tests": 1601, + "errors": 0, + "failures": 0, + "skipped": 0, + "xml_sha256": "566f50b4ba537d4e54939946a5b48cad9ed6dbd8fb69c5ffbabcc5da0fbaf507", + "xml_file": "r10-pr-pytest.xml", + "seconds": 313.479 + }, + "force_boundary": { + "tests": 43, + "errors": 0, + "failures": 0, + "skipped": 0, + "xml_sha256": "832425306b5fea3a150cc2188e00c97a771bb6d953e54b69c091d36e8062dca9", + "xml_file": "pr249-force-focused.xml", + "seconds": 3.231 + } + }, + "compileall": "passed", + "git_diff_check": "passed", + "final_content": { + "file_count": 195, + "sha256": "2784b81ff0ae4d47f85ac8ea4b217292bbd9a1e716667e729863bfd4a6a372cd", + "umbrella_equals_stack": true + }, + "post_test_formatting": "MainWindow line endings aligned with UI review base (AST equality asserted); unchanged README lines retain main line endings", + "regression_red": { + "baseline": "e4266ae", + "selected_new_ownership_tests": 3, + "expected_failures": 3, + "method": "in-memory baseline module; no production files or native processes modified" + }, + "force_contract": { + "clients_only": true, + "same_user_sid_and_windows_session": true, + "servers_never_terminated": true, + "durable_consent_before_action": true, + "independent_library_release_proof_required": true + }, + "not_validated": [ + "field server-session loss recovery", + "Windows 10", + "cross-machine shared-library concurrency", + "actual Mentor force termination", + "new frozen package" + ], + "delivery_policy": "Draft review only; no merge, publish, automatic issue closure or native production-library operation" +} diff --git a/docs/releases/v0.2.4-beta.1.md b/docs/releases/v0.2.4-beta.1.md new file mode 100644 index 0000000..8dfa640 --- /dev/null +++ b/docs/releases/v0.2.4-beta.1.md @@ -0,0 +1,31 @@ +# v0.2.4-beta.1(0.2.4b1)开发候选说明 + +状态:待评审、待现场验收。不是自动发布指令,工单保持开放。 + +## 用户可见变化 + +- 检验、ICDB 维护、中心库管理为独立入口。ICDB 检查在后台逐项运行,其他原生任务可排队,搜索/筛选保持可用。 +- 检查以当前 PCB 打开情况和本次原生错误为依据,只有明确 ICDB 错误才标记问题;不自动 Repair、Restore 或选择版本,CHECKED 不等于 READY。 +- 停止队列同时停止后续后台检查;执行前再次排除 READY,校验排队不隐藏检查进度;释放失败显示实际原因。 +- 原生新增、同名替换、移除和备份恢复继续要求确认及人工备份,失败结果和未完成任务逐项保留。 +- 默认残留释放为正常关闭。单独确认的强制结束仅允许属于当前 Windows 用户和会话、已确认作用域和精确身份的受支持文档客户端;服务器、后台导入器和未知进程不可强制结束。 + +## 强制客户端操作的契约 + +支持 Expedition PCB、Library Manager、viewdraw 和 iCDB Project Backup。操作员须知晓客户端中其他工程可能一并退出、未保存更改可能丢失、写入中的工程可能需要恢复。确认名单先持久记录为库外 `consent.json`,失败则不执行;派发与进程句柄两处复核,PID 复用、用户或 Windows 会话变化时拒绝。 + +数据库服务器可能服务同库其他用户,命令行归属不构成独占授权。本工具不会强制结束任何 ICDB 服务器;它仍活跃或库状态未知时保留 PARTIAL,不能通过结束客户端伪造释放或修复成功。 + +## 安全状态和回退 + +单项失败且本任务确已释放时可继续独立项;未释放时保留现场、检查点、映射和证据。客户端强制结束不可撤销,恢复使用人工一致备份或原生历史版本;不会自动重新导入、回退共享库或重放未完成写操作。 + +程序回退:先关闭正在使用的客户端,再使用此前候选包;程序回退不恢复原生事务或丢失更改。工程恢复:保留故障现场、选择确认过的备份,在隔离副本验证后恢复并重新校验。 + +## 验证与限制 + +PR #3 comment 249 的修复通过服务器排除、确认记录失败、PID 复用、客户端/服务器混合名单等 fake 边界回归;没有为了验证本功能终止真实 Mentor 客户端或服务器。 + +此前 r10 的原生隔离检查与界面排队证据只证明该候选包已记录的打开/释放行为,不能当成新强制客户端功能的现场验收。现场服务器失联恢复、ICDB 自动修复、Windows 10 和共享库跨机器并发仍未验收。 + +规范:[SOP](../../SOP.md)、[ICDB 手动修复手册](../ICDB-MANUAL-REPAIR-AND-UPDATE.md)。依赖和拆分顺序见 PR #3 的独立审查链。 diff --git a/docs/reviews/2026-11-05-infrastructure.md b/docs/reviews/2026-11-05-infrastructure.md new file mode 100644 index 0000000..5d0e721 --- /dev/null +++ b/docs/reviews/2026-11-05-infrastructure.md @@ -0,0 +1,13 @@ +# 独立审查 1:只读进程探测与原生任务准入队列 + +基于 main `a56fd17`,不叠加 PR #3 的历史提交。 + +**行为变化:** 增加有界、版本化、只读 owner-probe helper 和可取消的 FIFO 原生任务队列。应用仅新增隐藏的只读 helper 分派;现有 UI、验证和原生写操作保持原来的入口。 + +**失败安全:** 查询超时或协议/身份异常返回未确认;暂停或取消的队列票据不会运行其动作,也不阻止后面的可执行任务。不启动或终止 Mentor 进程。 + +**回滚方式:** 尚未合入下游时撤销本提交即可;下游接入后须按依赖从上层向下回退。 + +完整回归:491 passed,1 条既有 pywinauto STA 提示。编译和 diff 检查通过。 + +与原评论建议的差别:`management_transaction` 直接导入管理模型和库锁;`scoped_manifest` 的协调记录与独占快照依赖库锁协议。这两者在后端审查中一起交付,避免构造导入不完整的“纯工具”基线。 diff --git a/docs/reviews/2026-11-05-native-backend.md b/docs/reviews/2026-11-05-native-backend.md new file mode 100644 index 0000000..da20c81 --- /dev/null +++ b/docs/reviews/2026-11-05-native-backend.md @@ -0,0 +1,11 @@ +# Native backend review unit + +Base: codex/review-infrastructure. This unit integrates ICDB open diagnostics, scoped content manifests, native CBB transactions and the library-release protocol; it does not expose the new UI or residual termination action. Verification and ICDB checks remain separate, READY items are excluded from maintenance, and a released single-item failure can continue independent targets. + +Failure safety: no automatic Repair/version choice, no server termination, no direct LMC edits or native lock-file deletion. Native writes are serialized, uncertain ownership retains evidence and mappings, and unfinished writes are shown without replay. + +Dependency rationale: library release imports native engineering identity and retained management workers; engineering identity imports management source models and scoped manifests. Separating these into nominally independent utilities would leave runtime imports unresolved. This PR therefore keeps the backend dependency closure together; UI and user-confirmed termination remain separate later PRs. + +Rollback: before dependents are merged, revert this commit. After merging dependents, revert in reverse order or use the previous candidate package after closing the current app. Code rollback does not undo a native transaction; use a consistent manual backup or explicitly selected native history on an isolated copy. + +Validation: full Python suite 1,376 passed (one existing pywinauto COM-threading warning); compileall and git diff --check passed. Native field recovery, Windows 10 and cross-machine shared-library acceptance remain pending. diff --git a/docs/reviews/2026-11-05-residual-release.md b/docs/reviews/2026-11-05-residual-release.md new file mode 100644 index 0000000..53dd043 --- /dev/null +++ b/docs/reviews/2026-11-05-residual-release.md @@ -0,0 +1,9 @@ +# Residual release contract review unit + +Base: codex/review-ui-integration. Behavior: expose the residual-session preview and cooperative close entry, plus a separately confirmed force action limited to recognized document clients of the current Windows user and session. Database servers, importers, unknown scope and unverified identities cannot be force ended. Version becomes 0.2.4b1, with README, SOP, manual and rollback notes aligned. + +Failure safety: persist the exact allowed/excluded confirmation list before any native action, recheck scope/creation/executable/user/session at dispatch and the held handle, and require independent library-release proof after exit. Unreadable owner metadata disables force only. A terminated client is not a repaired/READY project; partial release retains evidence and mappings. + +Rollback: reverse the dependent commits before reverting the backend, or close the current app and use the earlier candidate. Process termination cannot be undone, and code rollback does not restore native transactions or unsaved data. Use a consistent manual backup or an explicitly chosen native history version on a copy. + +Validation: 1,601 passed for this final stack, 1,601 passed for the umbrella, and 43 focused release tests passed after the final UI wording change. Compileall, diff checks and byte-level final implementation equality passed. Detailed XML counts/hashes and content digest are recorded in ../releases/2026-11-05-pr249-review-validation.json. No real Mentor client/server was terminated for these checks. Field recovery, Windows 10, shared-library concurrency and the new frozen package remain unverified. diff --git a/docs/reviews/2026-11-05-ui-integration.md b/docs/reviews/2026-11-05-ui-integration.md new file mode 100644 index 0000000..bbe49b2 --- /dev/null +++ b/docs/reviews/2026-11-05-ui-integration.md @@ -0,0 +1,9 @@ +# Application integration review unit + +Base: codex/review-native-backend. Behavior: verification, ICDB batch checking and CBB management have separate tabs; background checks yield between items, keep browsing responsive and let other native tasks queue. READY targets are excluded at execution, status refresh is scoped, and manual version/copy decisions remain explicit. + +Failure safety: a released item failure can continue independent targets; uncertain native ownership retains evidence and mappings. There is no residual-session release backend in this review stage: its button and result actions are hidden, and its callback is inert. The next PR restores the complete release entry together with its tested backend, rather than exposing a button with a missing import. No automatic Repair or native version selection is added. + +Rollback: revert this UI commit before its dependent release PR; after dependents, revert in reverse order or close the current program and use the prior candidate. This does not roll back library writes. + +Validation: 1,545 passed (one existing pywinauto COM-threading warning), compileall and diff checks passed. Release-specific tests are introduced in the dependent PR, never discarded from the final tree. Windows 10, real shared-library concurrency and field ICDB recovery remain pending. diff --git a/docs/superpowers/plans/2026-11-05-pr249-review-followup.md b/docs/superpowers/plans/2026-11-05-pr249-review-followup.md index 40f7d7c..2c24a49 100644 --- a/docs/superpowers/plans/2026-11-05-pr249-review-followup.md +++ b/docs/superpowers/plans/2026-11-05-pr249-review-followup.md @@ -4,7 +4,7 @@ **Authorization:** The user requested implementation of comment 249. Earlier user decisions retain explicit user-confirmed residual release, manual backups and no release/issue closure before field acceptance. These decisions take precedence over changing Draft status merely to make a merge button available. -**Architecture:** Keep automatic verification and checking cooperative. A separate explicit force action can end supported document clients only after scope and exact process identity are checked. Native database servers and unknown processes remain observable and cannot be force terminated. Every force request must persist consent intent before any termination and still obtain independent library-release proof afterward. +**Architecture:** Keep automatic verification and checking cooperative. A separate explicit force action can end supported document clients only after scope, exact process identity, current user SID and Windows session are checked. Native database servers and unknown processes remain observable and cannot be force terminated. Every force request must persist consent intent before any termination and still obtain independent library-release proof afterward. **Review split:** Preserve #3 as an unmerged umbrella. Create a dependent review chain: (1) read-only owner probing and cooperative queue; (2) native backend, manifests, library coordination and transactions; (3) background checks and application UI integration; (4) residual-session release, its explicit contract, version and documentation. `management_transaction` imports management and lock APIs, and semantic manifests depend on recognized coordination checkpoints; they belong with the backend rather than pretending to be standalone read-only utilities. The existing #5 remains a prerequisite document review, not an automatically merged change. @@ -20,25 +20,25 @@ Files: `residual_sessions.py`, `ui/residual_release_dialog.py`, `tests/test_residual_sessions.py`, `tests/test_residual_release_dialog.py`. -- [ ] Add failing tests: a scoped iCDB server cannot reach `_force_close`; direct force requests against server/unsupported names never obtain a terminate-capable handle; missing consent evidence causes zero termination calls; mixed client/server previews list only supported clients in the confirmation; rejected/reused process identities remain unchanged. -- [ ] Define one shared force-eligibility function allowing only recognized document clients with confirmed scope and matching captured executable identity. Enforce it again at dispatch and at the exact handle boundary. -- [ ] Persist `consent.json` with target library, exact preview identities and allowed/excluded targets before processing a force request. A write failure returns before native actions. -- [ ] Keep excluded servers in the release result and require the existing independent release proof; process exit never means repaired/READY. -- [ ] Run focused regressions and the complete suite with an isolated test mutex. +- [x] Add failing tests: a scoped iCDB server cannot reach `_force_close`; direct force requests against server/unsupported names never obtain a terminate-capable handle; missing consent evidence causes zero termination calls; mixed client/server previews list only supported clients in the confirmation; rejected/reused process identities remain unchanged. +- [x] Define one shared force-eligibility function allowing only recognized document clients with confirmed scope and matching captured executable identity. Enforce it again at dispatch and at the exact handle boundary. +- [x] Persist `consent.json` with target library, exact preview identities and allowed/excluded targets before processing a force request. A write failure returns before native actions. +- [x] Keep excluded servers in the release result and require the existing independent release proof; process exit never means repaired/READY. +- [x] Run focused regressions and the complete suite with an isolated test mutex. ## Task 2: Version and operating contract -Files: `pyproject.toml`, `README.md`, `SOP-CBB-Refresh-After-Upload.md` (if present; otherwise the repository's actual SOP path), `docs/ICDB-MANUAL-REPAIR-AND-UPDATE.md`, `docs/releases/v0.2.4-beta.1.md`. +Files: `pyproject.toml`, `README.md`, `SOP.md`, `docs/ICDB-MANUAL-REPAIR-AND-UPDATE.md`, `docs/releases/v0.2.4-beta.1.md`. -- [ ] Identify the actual tracked SOP before editing; update README, SOP and manual together. -- [ ] Set `0.2.4b1` and document the user-confirmed client-only exception to the automatic no-force contract. Explain server handling, evidence, failure states, manual recovery and rollback. -- [ ] Keep field ICDB recovery, Win10 and multiuser shared-library acceptance explicitly unverified. +- [x] Identify the actual tracked SOP before editing; update README, SOP and manual together. +- [x] Set `0.2.4b1` and document the user-confirmed client-only exception to the automatic no-force contract. Explain server handling, evidence, failure states, manual recovery and rollback. +- [x] Keep field ICDB recovery, Win10 and multiuser shared-library acceptance explicitly unverified. ## Task 3: Review branches -- [ ] Inventory final files against main and assign each file to the smallest dependency-closed review stage. Keep UI/release hooks unavailable until their backend exists; do not publish branches with broken normal operation. -- [ ] Create ordered branches with one concrete feature commit per review unit, no rewriting the existing umbrella history. -- [ ] Test each review stage using appropriate unit/full checks; preserve all final regressions and verify the final source tree against the umbrella snapshot. +- [x] Inventory final files against main and assign each file to the smallest dependency-closed review stage. Keep UI/release hooks unavailable until their backend exists; do not publish branches with broken normal operation. +- [x] Create ordered branches with one concrete feature commit per review unit, no rewriting the existing umbrella history. +- [x] Test each review stage using appropriate unit/full checks; preserve all final regressions and verify the final source tree against the umbrella snapshot. - [ ] Push branches without force and create draft PRs with explicit base dependencies. Link them from #3 and record the splitting rationale. ## Task 4: Delivery diff --git a/pyproject.toml b/pyproject.toml index 6cf2d52..b9fb7da 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -3,7 +3,7 @@ requires = ["setuptools>=84.1.0"] build-backend = "setuptools.build_meta" [project] name = "cbb-refresh-verify" -version = "0.2.3b1" +version = "0.2.4b1" requires-python = ">=3.12,<3.13" dependencies = ["PySide6>=6.7,<7", "pywin32>=306", "pywinauto>=0.6.9,<0.7", "Pillow>=13.0.0,<14"] diff --git a/src/cbb_refresh_verify/__init__.py b/src/cbb_refresh_verify/__init__.py index ce03381..00c5fe6 100644 --- a/src/cbb_refresh_verify/__init__.py +++ b/src/cbb_refresh_verify/__init__.py @@ -1 +1 @@ -__version__ = "0.2.3b1" +__version__ = "0.2.4b1" diff --git a/src/cbb_refresh_verify/residual_sessions.py b/src/cbb_refresh_verify/residual_sessions.py index b1e8d95..adce74e 100644 --- a/src/cbb_refresh_verify/residual_sessions.py +++ b/src/cbb_refresh_verify/residual_sessions.py @@ -15,6 +15,23 @@ _NAMES = {'expeditionpcb.exe', 'librarymanager.exe', 'icdbprojectbackup.exe', 'reuseblockimporter.exe', 'cleanwglib.exe', 'cscript.exe', 'wscript.exe'} | _OWNER_NAMES _WORKER_NAMES = {'python.exe', 'pythonw.exe', 'cbbrefreshverify.exe'} _WORKER_FLAGS = ('--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker') +_FORCE_CLIENT_NAMES = {'expeditionpcb.exe', 'librarymanager.exe', 'viewdraw.exe', 'icdbprojectbackup.exe'} + + +def force_block_reason(row): + """A library path proves scope, never exclusive ownership of a server.""" + if row.get('scope_confirmed') is not True: + return '进程归属未确认,不允许强制结束' + name = str(row.get('name', '')).casefold() + if name not in _FORCE_CLIENT_NAMES: + return '服务器或其他受保护进程仅供观察,不允许强制结束' + if (not row.get('created_handle') or not row.get('image') + or Path(row['image']).name.casefold() != name): + return '客户端身份未确认,不允许强制结束' + if (row.get('force_user_confirmed') is not True or not row.get('owner_sid') + or not isinstance(row.get('session_id'), int)): + return '未确认属于当前用户和 Windows 会话,不允许强制结束' + return '' @contextmanager @@ -45,7 +62,30 @@ def _handle_identity(handle): def _process_identity(row): with _process_handle(row['pid']) as handle: - return _handle_identity(handle) + identity = _handle_identity(handle) + try: + identity.update(_force_ownership(handle, row['pid'])) + except Exception as error: + identity.update(force_user_confirmed=False, owner_error=str(error)) + return identity + + +def _force_ownership(handle, pid): + import win32api, win32con, win32process, win32security, win32ts + if win32process.GetProcessId(handle) != pid: + raise ValueError('进程身份已变化') + def owner(process): + token = win32security.OpenProcessToken(process, win32con.TOKEN_QUERY) + try: + return win32security.ConvertSidToStringSid( + win32security.GetTokenInformation(token, win32security.TokenUser)[0]) + finally: + token.Close() + sid = owner(handle) + session = win32ts.ProcessIdToSessionId(pid) + return {'owner_sid': sid, 'session_id': session, 'force_user_confirmed': + sid == owner(win32api.GetCurrentProcess()) + and session == win32ts.ProcessIdToSessionId(os.getpid())} def _process_windows(pids): @@ -191,6 +231,10 @@ def inspect_residual_sessions(library, *, block_names=()): item.update(can_close=False, detail=f'进程已变化或暂时无法确认:{error}') item['project'] = _project_name(row, library) if row['scope_confirmed'] else '归属未确认' item['prompt'] = _save_question(windows.get(row['pid'], [])) if row['scope_confirmed'] else None + item['force_block_reason'] = force_block_reason(item) + item['force_allowed'] = not item['force_block_reason'] + if item['force_block_reason']: + item['detail'] += ';'+item['force_block_reason'] sessions.append(item) previous = [] marker = blocker_path(library) @@ -253,15 +297,21 @@ def _force_close(row, *, stop=None): import win32api, win32con, win32event if stop is not None and stop.is_set(): return {'release_status': 'CANCELLED', 'detail': '已停止释放'} + if reason := force_block_reason(row): + return {'release_status': 'WAITING', 'detail': reason} with _process_handle(row['pid'], terminate=True) as handle: if win32event.WaitForSingleObject(handle, 0) == win32con.WAIT_OBJECT_0: return {'release_status': 'RELEASED', 'detail': '已退出'} if _handle_identity(handle) != {k: row.get(k) for k in ('created_handle', 'image')}: return {'release_status': 'IDENTITY_CHANGED', 'detail': '进程身份已变化,未结束'} + ownership = _force_ownership(handle, row['pid']) + if (not ownership['force_user_confirmed'] or + any(ownership[k] != row.get(k) for k in ('owner_sid', 'session_id'))): + return {'release_status': 'IDENTITY_CHANGED', 'detail': '用户或 Windows 会话已变化,未结束'} win32api.TerminateProcess(handle, 1) exited = win32event.WaitForSingleObject(handle, 3000) == win32con.WAIT_OBJECT_0 return {'release_status': 'RELEASED' if exited else 'WAITING', - 'detail': '已强制结束,工程需重新检查' if exited else '已请求结束,等待退出'} + 'detail': '已强制结束客户端,工程待检查,未执行修复' if exited else '已请求结束客户端,等待退出'} def _finish_library_release(library, evidence): @@ -277,6 +327,16 @@ def _release_residual_sessions(plan, evidence_dir, *, stop=None, force=False): root.mkdir(parents=True) result = {'status': 'PARTIAL', 'library': str(library), 'sessions': [], 'force': force, 'evidence_path': str(root/'result.json'), 'previous_records': plan.get('previous_records', [])} + if force: + consent_path = root/'consent.json' + consent = {'version': 1, 'mode': 'force_document_clients', 'library': str(library), + 'time_ns': time.time_ns(), 'sessions': [ + {**row, 'force_allowed': not force_block_reason(row), + 'force_block_reason': force_block_reason(row)} for row in plan['sessions']]} + with consent_path.open('x', encoding='utf-8') as stream: + json.dump(consent, stream, ensure_ascii=False, indent=2) + stream.flush(); os.fsync(stream.fileno()) + result['consent_path'] = str(consent_path) fresh = {r['pid']: r for r in query_process_snapshot()} # Close native children first, so their supervisors can finish and drop leases. ordered = sorted(plan['sessions'], key=lambda r: r['name'].casefold() in _WORKER_NAMES) @@ -292,6 +352,8 @@ def _release_residual_sessions(plan, evidence_dir, *, stop=None, force=False): outcome = {'release_status': 'WAITING', 'detail': '未在确认名单中证明属于当前库,未关闭;请重新检查'} elif any(current.get(key) != original.get(key) for key in ('created', 'executable', 'command', 'name')): outcome = {'release_status': 'IDENTITY_CHANGED', 'detail': '确认后进程身份已变化,未关闭'} + elif force and (reason := force_block_reason(original)): + outcome = {'release_status': 'WAITING', 'detail': reason, 'force_allowed': False} else: try: outcome = (_force_close if force else _request_close)(original, stop=stop) except Exception as error: diff --git a/src/cbb_refresh_verify/ui/main_window.py b/src/cbb_refresh_verify/ui/main_window.py index ac20dbb..f32cce2 100644 --- a/src/cbb_refresh_verify/ui/main_window.py +++ b/src/cbb_refresh_verify/ui/main_window.py @@ -1,1584 +1,1584 @@ -from pathlib import Path -from threading import Event -import os -import ntpath -import time -from collections import Counter -from dataclasses import replace - -from PySide6.QtCore import QObject, QThreadPool, Signal, Qt, QTimer -from PySide6.QtGui import QColor, QIcon -from PySide6.QtWidgets import (QWidget, QLineEdit, QPushButton, QFormLayout, - QTextEdit, QFileDialog, QHBoxLayout, QLabel, QSpinBox, QMessageBox, QToolButton, - QTableWidget, QTableWidgetItem, QHeaderView, QCheckBox, QVBoxLayout, QProgressBar, QComboBox, - QTabBar, QStackedWidget, QSizePolicy) -from PySide6.QtWidgets import QStyle - - -def _path_key(value): - """Compare local and unavailable UNC paths without touching the network.""" - raw = str(value or '') - if not raw: - return '' - return os.path.normcase(os.path.normpath(os.path.abspath(raw))) - - -def _library_path_keys(value, lease=None): - """Use known mapping aliases without resolving unavailable network paths.""" - if not value: - return set() - keys = {_path_key(value)} - mentor = getattr(lease, 'mentor_path', None) - display = getattr(lease, 'display_path', None) - if mentor and display: - for source, alias in ((mentor, display), (display, mentor)): - if _path_key(value) == _path_key(source): - keys.add(_path_key(alias)) - elif _path_key(Path(value).parent) == _path_key(source): - keys.add(_path_key(Path(alias)/Path(value).name)) - drive, tail = ntpath.splitdrive(str(value)) - if (getattr(lease, 'remote_root', '') and drive - and drive.upper() == getattr(lease, 'drive', '').upper()): - keys.add(_path_key(lease.remote_root + tail)) - return keys -try: - from dx_productivity.trial_task_center.ui.workers import ServiceWorker -except ImportError: - from cbb_refresh_verify.ui.workers import ServiceWorker -from cbb_refresh_verify.library_reader import read_library_fast, scan_open_library_status -from cbb_refresh_verify.batch_status import authoritative_status_map -from cbb_refresh_verify.defaults import DEFAULT_TIMEOUT_SECONDS -from cbb_refresh_verify.network_path import LibraryPathLease, select_library_file -from cbb_refresh_verify.verify_runner import (VerifyRequest, preflight_skip_reason, run_verify, - run_batch, write_batch_report, failure_report_path, - native_lm_verify_enabled) - - -class ProgressSignals(QObject): - event = Signal(object) - version_choice = Signal(object) - - -STATUS_LABELS = { - 'READY': '绿色 / Ready', - 'PENDING': '待校验', - 'UNKNOWN': '未知 / 需确认', - 'UNAVAILABLE': '状态桥不可用', - 'ERROR': '状态读取失败', - 'TIMEOUT': '状态读取超时', - 'MALFORMED': '状态桥协议错误', - 'CRASHED': '状态桥崩溃', -} - - -def application_icon_path(): - return Path(__file__).resolve().parents[1] / 'assets' / 'cbb_refresh_verify.ico' - - -class MainWindow(QWidget): - def __init__(self, reader=None, verifier=None, logging_context=None, data_root=None, - authoritative_status=True, path_lease_factory=None, status_refresher=None, - management_adapter=None, native_backup_launcher=None): - super().__init__() - self.setWindowTitle('CBB 刷新校验') - icon_path = application_icon_path() - if icon_path.is_file(): - self.setWindowIcon(QIcon(str(icon_path))) - self.resize(850, 560) - self.verifier = verifier - self.logging_context = logging_context - self.path_lease_factory = path_lease_factory or LibraryPathLease.acquire - self.library_lease = None - self.mentor_lmc_path = None - self.data_root = Path(data_root or (logging_context.root if logging_context else Path(os.environ.get('LOCALAPPDATA', '.'))/'CbbRefreshVerify')) - from cbb_refresh_verify.native_management import NativeManagementAdapter - self.management_adapter = management_adapter or NativeManagementAdapter() - self.management_capabilities = self.management_adapter.capabilities() - self._management_unsafe = False - self._management_unsafe_library = None - self._management_unsafe_libraries = set() - self._management_operation_library = None - self._maintenance_recovery_view = False - self._reload_after_maintenance = False - self._reimport_offers = () - self._batch_requests = () - self._batch_records = {} - self._reimport_summary_action = None - self.native_backup_launcher = native_backup_launcher - self._native_backup_session = None - self.native_backup_timer = QTimer(self) - self.native_backup_timer.setInterval(400) - self.native_backup_timer.timeout.connect(self._poll_native_backup) - if reader is not None: - self.reader = reader - elif authoritative_status and os.environ.get('CBB_STATUS_BRIDGE_MODE', 'authoritative').casefold() != 'legacy': - self.reader = lambda path: read_library_fast( - path, - status_reader=lambda p, names: authoritative_status_map( - names, p, self.data_root / 'status-scan.jsonl'), - ) - else: - # Legacy icon/filesystem reader remains opt-in until the bridge is - # accepted on the target Mentor installation. It cannot override - # the authoritative path when that path is enabled explicitly. - self.reader = lambda path: read_library_fast( - path, - status_reader=lambda p, names: scan_open_library_status( - p, names, mapping_store=self.data_root/'image-status-map.json'), - ) - self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1) - self._lease_pending = 0 - self._lease_workers = set() - self._mapping_busy = 0 - self._mapping_auto_idle = False - self._mapping_finish_waiters = [] - self._closing = self._close_ready = False - from cbb_refresh_verify.operation_queue import NativeQueue - self.native_queue = NativeQueue() - self.icdb_task = None - self.icdb_tasks = [] - self.busy = False; self.loaded_path = None; self.stop = Event(); self.ready_names = set() - self._row_by_name = {} - self._records_by_name = {} - self.status_refresher = status_refresher or (lambda names, path: authoritative_status_map( - names, path, self.data_root / 'status-refresh.jsonl')) - self.skipped_names = set(); self.skip_reasons = {} - self._global_icdb_run = False - self._icdb_completed = 0 - self.signals = ProgressSignals(self); self.signals.event.connect(self._progress) - self.signals.version_choice.connect(self._show_version_choice) - self.version_dialog = None - self.lmc_edit = QLineEdit() - self.libspec_edit = QLineEdit(os.environ.get('CBB_LIBSPEC', 'EE7.9')) - self.dms_edit = QLineEdit(os.environ.get('CBB_DMS_LOGIN_CONFIG', '')) - self.mentor_bin_edit = QLineEdit(os.environ.get('SDD_LM_BIN', '')) - self.native_lm_verify_check = QCheckBox('使用 Library Manager 原生 Verify(Win10 兼容测试)') - self.native_lm_verify_check.setChecked(native_lm_verify_enabled()) - self.native_lm_verify_check.setToolTip( - '仅在 Win10 兼容测试时启用;默认仍使用已验证的 ReusableCircuit 直接流程。') - self.advanced_toggle = QToolButton(); self.advanced_toggle.setText('高级设置') - self.advanced_toggle.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_TitleBarUnshadeButton)) - self.advanced_toggle.setCheckable(True); self.advanced_toggle.setChecked(False) - self.advanced_panel = QWidget() - advanced_layout = QFormLayout(self.advanced_panel) - advanced_layout.addRow('LibSpec', self.libspec_edit) - advanced_layout.addRow('DMS 登录配置', self.dms_edit) - advanced_layout.addRow('Mentor bin', self.mentor_bin_edit) - advanced_layout.addRow('触发方式', self.native_lm_verify_check) - self.advanced_panel.setVisible(False) - self.advanced_toggle.toggled.connect(self.advanced_panel.setVisible) - self.cbb_table = QTableWidget(0, 4) - self.cbb_table.setHorizontalHeaderLabels(['CBB 名称', '分区', '状态', '备注']) - self.cbb_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch) - self.cbb_table.horizontalHeader().setSectionResizeMode(3, QHeaderView.Stretch) - for column in (1, 2): - self.cbb_table.horizontalHeader().setSectionResizeMode(column, QHeaderView.ResizeToContents) - self.cbb_table.setSelectionBehavior(QTableWidget.SelectRows) - self.cbb_table.setMinimumHeight(150) - self.cbb_table.itemChanged.connect(lambda _item: self._update()) - self.search_edit = QLineEdit() - self.search_edit.setPlaceholderText('按 CBB 名称或分区搜索') - self.status_filter = QComboBox() - for label, key in (('全部', 'all'), ('READY', 'ready'), ('非 READY(含未确认)', 'non_ready'), - ('PENDING', 'pending'), ('未知 / 读取异常', 'errors'), ('缺少工程', 'missing')): - self.status_filter.addItem(label, key) - self.counts_label = QLabel() - self.select_visible_button = QPushButton('选择可见项') - self.clear_selection_button = QPushButton('清空选择') - self.select_visible_button.clicked.connect(lambda: self._check_visible(Qt.Checked)) - self.clear_selection_button.clicked.connect(lambda: self._check_visible(Qt.Unchecked)) - self.search_edit.textChanged.connect(self._apply_filters) - self.status_filter.currentIndexChanged.connect(self._apply_filters) - self.timeout_spin = QSpinBox(); self.timeout_spin.setRange(30, 1800); self.timeout_spin.setValue(DEFAULT_TIMEOUT_SECONDS); self.timeout_spin.setSuffix(' 秒 / 无进展') - self.load_button = QPushButton('读取 CBB'); self.load_button.clicked.connect(self.load_library) - self.browse_button = QPushButton('选择'); self.browse_button.clicked.connect(self.choose_library) - self.selected_batch_button = QPushButton('批量校验已选'); self.selected_batch_button.clicked.connect(self.verify_selected) - self.batch_button = QPushButton('校验可见非 READY'); self.batch_button.clicked.connect(self.verify_all) - self.icdb_repair_button = QPushButton('ICDB 批量检查'); self.icdb_repair_button.clicked.connect(self.repair_icdb_all) - self.icdb_repair_button.setToolTip('检查可见的非 READY 工程;有勾选时仅检查勾选项。') - self.backup_restore_button = QPushButton('从备份恢复 CBB…') - self.backup_restore_button.clicked.connect(self.restore_backup) - self.reimport_button = QPushButton('选择工程副本恢复失败项…') - self.reimport_button.clicked.connect(self.reimport_failed) - self.reimport_button.hide() - self.stop_button = QPushButton('当前项完成后停止'); self.stop_button.clicked.connect(self.request_stop) - self.logs_button = QPushButton('打开日志目录'); self.logs_button.clicked.connect(self.open_logs) - self.recovery_button = QPushButton('打开异常证据'); self.recovery_button.setEnabled(False) - style = self.style() - self.load_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_BrowserReload)) - self.browse_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_DirOpenIcon)) - self.selected_batch_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_ArrowRight)) - self.batch_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaPlay)) - self.icdb_repair_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_BrowserReload)) - self.stop_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaStop)) - self.logs_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_DirOpenIcon)) - self.recovery_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MessageBoxWarning)) - self.recovery_button.setToolTip('打开当前异常 CBB 的证据目录,不切换 Windows 桌面。') - self.recovery_button.clicked.connect(self.recover) - self.recovery_path = None - self.status_label = QLabel('请选择并读取中心库。校验期间可以使用其他前台应用。') - self.status_label.setWordWrap(True) - self.status_label.setMinimumHeight(self.status_label.fontMetrics().lineSpacing()*2) - self.status_label.setMaximumHeight(self.status_label.fontMetrics().lineSpacing()*3 + 4) - self.status_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) - self.output = QTextEdit(); self.output.setReadOnly(True) - # Integration emits repeated status snapshots. Keep the visible - # diagnostic buffer bounded so a 3,000-CBB run cannot grow the GUI - # document without limit. - self.output.document().setMaximumBlockCount(2000) - self.output.setMaximumHeight(180) - layout = QVBoxLayout(self) - row = QHBoxLayout(); row.addWidget(QLabel('中心库')); row.addWidget(self.lmc_edit) - row.addWidget(self.browse_button); row.addWidget(self.load_button) - layout.addLayout(row) - self.library_notice = QLabel() - self.library_notice.setWordWrap(True) - self.library_notice.setTextFormat(Qt.PlainText) - self.library_notice.setStyleSheet('QLabel { color: #8a4b08; background: #fff3d6; padding: 6px; }') - self.library_notice.hide() - layout.addWidget(self.library_notice) - self.section_tabs = QTabBar() - self.section_tabs.setExpanding(True) - for name in ('检验', 'ICDB 维护', '中心库管理'): - self.section_tabs.addTab(name) - layout.addWidget(self.section_tabs) - filters = QHBoxLayout() - for widget in (self.search_edit, self.status_filter, self.select_visible_button, self.clear_selection_button): - filters.addWidget(widget) - layout.addLayout(filters) - layout.addWidget(self.counts_label) - layout.addWidget(self.cbb_table, 1) - self.section_stack = QStackedWidget() - self.section_stack.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) - self.section_tabs.currentChanged.connect(self.section_stack.setCurrentIndex) - verify_page = QWidget() - verify_layout = QVBoxLayout(verify_page); verify_layout.setContentsMargins(0, 0, 0, 0) - controls = QHBoxLayout() - for widget in (self.selected_batch_button, self.batch_button): controls.addWidget(widget) - controls.addStretch(); controls.addWidget(QLabel('超时')); controls.addWidget(self.timeout_spin) - controls.addWidget(self.advanced_toggle) - verify_layout.addLayout(controls); verify_layout.addWidget(self.advanced_panel) - self.section_stack.addWidget(verify_page) - maintenance = QWidget() - maintenance_layout = QVBoxLayout(maintenance) - maintenance_layout.setContentsMargins(0, 0, 0, 0) - self.native_backup_button = QPushButton('版本历史与备份…') - self.native_backup_button.setToolTip('勾选一个非 READY CBB,打开原生备份列表并选择回退版本。') - self.native_backup_button.clicked.connect(self.open_native_backup) - maintenance_layout.addWidget(self.native_backup_button) - maintenance_row = QHBoxLayout() - maintenance_row.addWidget(self.icdb_repair_button) - self.icdb_stop_button = QPushButton('停止检查') - self.icdb_stop_button.clicked.connect(self._stop_icdb_check) - maintenance_row.addWidget(self.icdb_stop_button) - maintenance_row.addWidget(self.backup_restore_button) - maintenance_row.addWidget(self.reimport_button) - maintenance_layout.addLayout(maintenance_row) - self.icdb_progress = QProgressBar() - self.icdb_progress.setVisible(False) - self.icdb_phase = QLabel('') - self.icdb_phase.setWordWrap(True) - self.icdb_phase.setVisible(False) - maintenance_layout.addWidget(self.icdb_progress) - maintenance_layout.addWidget(self.icdb_phase) - self.section_stack.addWidget(maintenance) - management = QWidget() - management_layout = QVBoxLayout(management) - management_layout.setContentsMargins(0, 0, 0, 0) - management_buttons = QHBoxLayout() - self.add_button = QPushButton('新增 CBB…') - self.update_button = QPushButton('用工程替换已选 CBB…') - self.remove_button = QPushButton('移除已选…') - for operation, widget in (('add', self.add_button), ('update', self.update_button), ('remove', self.remove_button)): - widget.clicked.connect(lambda _=False, op=operation: self.manage_cbb(op)) - widget.setToolTip(self.management_capabilities[operation].reason) - management_buttons.addWidget(widget) - management_layout.addLayout(management_buttons) - self.management_capability_label = QLabel() - self.management_capability_label.setWordWrap(True) - management_layout.insertWidget(0, self.management_capability_label) - self.unfinished_label = QLabel(); self.unfinished_label.setWordWrap(True) - management_layout.addWidget(self.unfinished_label) - self.release_library_button = QPushButton('释放残留会话…') - self.release_library_button.clicked.connect(self.check_library_release) - management_buttons.addWidget(self.release_library_button) - self.section_stack.addWidget(management) - layout.addWidget(self.section_stack) - layout.addWidget(self.status_label) - self.runtime_log_toggle = QToolButton(); self.runtime_log_toggle.setText('查看运行日志') - self.runtime_log_toggle.setCheckable(True) - self.runtime_log_toggle.toggled.connect(self.output.setVisible) - self.output.hide() - footer = QHBoxLayout() - for widget in (self.stop_button, self.runtime_log_toggle, self.logs_button, self.recovery_button): - footer.addWidget(widget) - layout.addLayout(footer); layout.addWidget(self.output) - self.lmc_edit.textChanged.connect(self._invalidate) - for field in (self.libspec_edit, self.dms_edit, self.mentor_bin_edit): - field.textChanged.connect(lambda _text: self._update()) - self.native_lm_verify_check.toggled.connect(lambda _checked: self._update()) - self._show_unfinished_management() - self._update() - - def _invalidate(self): - self._reimport_offers = () - if self.loaded_path is not None and self.lmc_edit.text() != self.loaded_path: - self._release_library_lease() - self.loaded_path = None; self.mentor_lmc_path = None; self.cbb_table.setRowCount(0); self._row_by_name = {} - self._records_by_name = {} - self.ready_names = set(); self.skipped_names = set(); self.skip_reasons = {}; self._update() - self._global_icdb_run = False - if not self._icdb_active(): - self.icdb_progress.hide(); self.icdb_phase.hide() - - def _release_library_lease(self): - lease, self.library_lease = self.library_lease, None - if self._native_backup_session is not None and self._native_backup_session.path_lease is lease: - return # The visible native session still needs this mapping. - if self._icdb_active() and self.icdb_task.path_lease is lease: - return # This background task still uses its captured mapping. - if lease is None: - return - try: - self._close_path_lease(lease) - except Exception as error: - if self.logging_context: - self.logging_context.logger.warning('library_lease_release_failed error=%s', error) - - def _close_path_lease(self, lease): - self._lease_action(lease.close, hold_busy=self.busy) - - def _retain_path_lease(self, lease, *, hold_busy=False): - if lease is not None: - self._lease_action(lease.retain_for_recovery, hold_busy=hold_busy) - - def _lease_action(self, action, completed=None, failed=None, *, hold_busy=False): - # The serial pool orders retain before every subsequent close. - self._lease_pending += 1 - if hold_busy: - if not self._mapping_busy and not self.busy: - self._mapping_auto_idle = True - self._mapping_busy += 1 - self.busy = True - self._update() - worker = ServiceWorker(action) - self._lease_workers.add(worker) - if completed is not None: worker.signals.succeeded.connect(completed) - worker.signals.failed.connect(failed or self._display_error) - def finished(): - self._lease_workers.discard(worker) - self._lease_pending -= 1 - if hold_busy: self._mapping_busy -= 1 - if not self._mapping_busy: - callbacks, self._mapping_finish_waiters = self._mapping_finish_waiters, [] - auto_idle, self._mapping_auto_idle = self._mapping_auto_idle, False - for callback in callbacks: callback() - if auto_idle and not callbacks: self._finished() - self._update() - worker.signals.finished.connect(finished) - self.pool.start(worker) - - def _defer_mapping_finish(self, callback): - if not self._mapping_busy: return False - if callback not in self._mapping_finish_waiters: - self._mapping_finish_waiters.append(callback) - return True - - def _update(self): - # The refresh flow needs only the library and a CBB; LibSpec/DMS config - # are optional and only enable the extra contents check. - ready = not self.busy and self.loaded_path == self.lmc_edit.text() and self.cbb_table.rowCount() > 0 - selected = self.selected_records() - native_target = self._native_backup_target() - self.native_backup_button.setEnabled(ready and self._native_backup_session is None - and native_target is not None) - ready = ready and not self._native_backup_same_library() - self.batch_button.setEnabled(ready and bool(self._eligible_names())) - self.selected_batch_button.setEnabled(ready and bool(self._eligible_names(checked_only=True))) - self.icdb_repair_button.setEnabled(ready and not self._icdb_active() and bool(self._maintenance_names())) - self.icdb_stop_button.setEnabled(self._icdb_active() and not self.icdb_task.stop.is_set()) - self.backup_restore_button.setEnabled(ready and bool( - self._eligible_names(checked_only=bool(self.selected_records())))) - self.release_library_button.setEnabled(not self.busy and bool(self.lmc_edit.text().strip())) - reasons = [] - for operation, widget in (('add', self.add_button), ('update', self.update_button), ('remove', self.remove_button)): - reason = self._management_block_reason(operation) - widget.setEnabled(not reason) - widget.setToolTip(reason or self.management_capabilities[operation].reason) - if reason: - reasons.append(reason) - self.management_capability_label.setText('\n'.join(dict.fromkeys(reasons))) - current_library = _path_key(self.mentor_lmc_path or self.lmc_edit.text()) if self.lmc_edit.text().strip() else None - notice = ('上次操作结果待复查,执行前将重新检查占用。' - if self._management_library_unsafe(current_library) else '') - self.library_notice.setText(notice) - self.library_notice.setVisible(bool(notice)) - for widget in (self.lmc_edit, self.browse_button, self.load_button, - self.timeout_spin, self.advanced_toggle, self.advanced_panel): - widget.setEnabled(not self.busy) - counts = self.visible_counts() - self.counts_label.setText(f'可见 {counts["visible"]} / {len(self._records_by_name)} · ' - f'READY {counts["ready"]} · 异常/待确认 {counts["error"]}') - self.stop_button.setEnabled((self.busy and self.loaded_path is not None and not self.stop.is_set()) - or self._icdb_active() and not self.icdb_task.stop.is_set()) - self.stop_button.setText('取消当前任务并停止队列') - available = bool(self._reimport_offers) and not self.busy and self.management_capabilities['update'].supported - self.reimport_button.setVisible(bool(self._reimport_offers)) - self.reimport_button.setEnabled(available) - self.reimport_button.setToolTip(self.management_capabilities['update'].reason) - if self._reimport_summary_action is not None: - self._reimport_summary_action.setEnabled(available) - if getattr(self, '_residual_release_action', None) is not None: - self._residual_release_action.setEnabled(not self.busy) - if getattr(self, '_resume_batch_action', None) is not None: - pending = getattr(self, '_resume_batch', None) - same = bool(pending and _library_path_keys(pending['library'], self.library_lease) - & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)) - self._resume_batch_action.setEnabled(not self.busy and same and pending['released']) - - def _show_unfinished_management(self): - from cbb_refresh_verify.management import unfinished_operations - unfinished = unfinished_operations(self.data_root/'management') - self.unfinished_label.setText(f'发现 {len(unfinished)} 项未完成或需恢复的管理任务;只显示记录,不自动重放。' - if unfinished else '') - for item in unfinished: - self.output.append(f'未完成:{item.get("name", "")} {item.get("status", "")} ' - f'{item.get("stage", "")}\n{item["evidence_path"]}') - - def check_library_release(self): - if self.busy or not self.lmc_edit.text().strip(): - return - from .residual_release_dialog import ResidualReleaseDialog - library = Path(self.mentor_lmc_path or self.lmc_edit.text().strip()) - self.release_dialog = ResidualReleaseDialog(library, self.data_root/'release-checks', self) - self.release_dialog.native_queue = self.native_queue - self.release_dialog.before_release.connect(self._stop_icdb_check) - self.release_dialog.released.connect(lambda result: self._complete_library_release(self.release_dialog.library, result)) - self.release_dialog.finished.connect(self._release_dialog_finished) - self.busy = True; self._update() - self.release_dialog.show() - - def _release_dialog_finished(self, _=None): - if self._defer_mapping_finish(self._release_dialog_finished): return - self._finished() - pending = getattr(self, '_resume_batch', None) - if pending and pending['released']: - self.summary.setText('会话已释放,可以继续未执行项。') - self.summary.show() - - def _complete_library_release(self, library, result): - from cbb_refresh_verify.network_path import release_retained_path_leases - try: - if (not isinstance(result, dict) or result.get('status') != 'RELEASE_CONFIRMED' - or not (_library_path_keys(result.get('library'), self.library_lease) - & _library_path_keys(library, self.library_lease))): - raise ValueError('RELEASE_PROOF_UNCONFIRMED: 释放证明未确认或不属于当前中心库。') - except Exception as error: - self._failed(error) - return - lease = self.library_lease - def release(): - try: - release_retained_path_leases(result, current_lease=lease) - except Exception: - if lease is not None: lease.retain_for_recovery() - raise - self._lease_action(release, lambda _: self._library_release_ready(library, result), - self._display_error, hold_busy=True) - - def _library_release_ready(self, library, result): - current_library = _path_key(self.mentor_lmc_path or self.lmc_edit.text().strip()) - if current_library == _path_key(library): - self._management_unsafe = False - self._management_unsafe_library = None - self._management_unsafe_libraries.discard(_path_key(library)) - session = self._native_backup_session - if self._native_backup_matches_library(library) and session.process.poll() is not None: - self._release_native_backup_session(session) - pending = getattr(self, '_resume_batch', None) - if pending and (_library_path_keys(pending['library'], self.library_lease) - & _library_path_keys(library, self.library_lease)): - pending['released'] = True - message = f'相关会话已释放,可以重试未完成的项目。\n{result["evidence_path"]}' - self.status_label.setText(message); self.output.append(message) - - def _resume_released_batch(self): - pending = getattr(self, '_resume_batch', None) - if self.busy or not pending or not pending['released']: return - if not (_library_path_keys(pending['library'], self.library_lease) - & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): - return - self._resume_batch = None - self._run(pending['names'], maintenance=pending['maintenance']) - - def _management_library_unsafe(self, library): - if self._management_unsafe and self._management_unsafe_library is not None: - self._management_unsafe_libraries.add(_path_key(self._management_unsafe_library)) - return _path_key(library) in self._management_unsafe_libraries - - def _management_block_reason(self, operation): - if self.busy: - return '当前任务尚未结束,请等待后再执行库管理操作。' - if self._native_backup_same_library(): - return '该库的版本与备份窗口仍在使用,关闭后可执行写入操作。' - capability = self.management_capabilities[operation] - if not capability.supported: - return capability.reason - if not self.loaded_path or self.loaded_path != self.lmc_edit.text(): - return '请先选择并读取中心库。' - if operation != 'add' and not self.selected_records(): - return '替换和移除需要先勾选当前可见的 CBB。' - return '' - - def manage_cbb(self, operation): - reason = self._management_block_reason(operation) - if reason: - self.status_label.setText(reason) - return - from cbb_refresh_verify.management import ManagementRequest - records = self.selected_records() - if operation != 'add' and not records: - return - def request(name, partition): - return ManagementRequest(operation, Path(self.mentor_lmc_path or self.loaded_path), name, - partition, evidence_dir=self.data_root/'management', timeout_seconds=self.timeout_spin.value(), - mapped_drive=getattr(self.library_lease, 'drive', ''), - mapped_remote_root=getattr(self.library_lease, 'remote_root', '')) - requests = ([request('', 'Logical-Physical')] if operation == 'add' else - [request(record.name, 'Logical-Physical' if record.logical_type == 'LP' - and record.partition_name in ('Reusable Blocks', 'LP') else record.partition_name) - for record in records]) - self._open_management_dialog(requests) - - def _open_management_dialog(self, requests, *, recovery_from=None): - from .management_dialog import ManagementDialog - self._global_icdb_run = False - self.stop.clear() - self._management_is_recovery = bool(recovery_from) - self._management_operation_library = _path_key(requests[0].library) if requests else None - requests = [replace(request, check_previous_release=True) if self._management_library_unsafe(request.library) - else request for request in requests] - self.management_dialog = ManagementDialog(requests, self, adapter=self.management_adapter, - recovery_from=recovery_from) - self.management_dialog.native_queue = self.native_queue - self.management_dialog.before_execute.connect(lambda names: self._invalidate_check_targets(requests[0].library, names)) - self._management_results = [] - self.management_dialog.completed.connect(self._management_completed) - self.management_dialog.finished.connect(self._management_closed) - self.busy = True; self._update() - self.management_dialog.show() - - def reimport_failed(self): - if self.busy or not self._reimport_offers or not self.management_capabilities['update'].supported: - return - from cbb_refresh_verify.management import ManagementRequest - requests, previous = [], {} - library = Path(self.mentor_lmc_path or self.loaded_path) - for req, record, result in self._reimport_offers: - if req.lmc_file != library: - return - partition = ('Logical-Physical' if record.logical_type == 'LP' - and record.partition_name in ('Reusable Blocks', 'LP') else record.partition_name) - requests.append(ManagementRequest('update', library, record.name, partition, - evidence_dir=self.data_root/'management', timeout_seconds=self.timeout_spin.value(), - mapped_drive=getattr(self.library_lease, 'drive', ''), - mapped_remote_root=getattr(self.library_lease, 'remote_root', ''))) - previous[record.name] = str(result.evidence_path) - self._reload_after_maintenance = False - if getattr(self, 'summary', None): self.summary.close() - self._open_management_dialog(requests, recovery_from=previous) - - def _management_completed(self, results): - self._management_results = results - proofs = [result.release_proof for result in results if isinstance(getattr(result, 'release_proof', None), dict) - and result.release_proof.get('status') == 'RELEASE_CONFIRMED' - and bool(_library_path_keys(result.release_proof.get('library'), self.library_lease) - & _library_path_keys(self._management_operation_library, self.library_lease)) - ] - safe = all(result.safe_to_continue for result in results) - lease = self.library_lease - if proofs and safe: - from cbb_refresh_verify.network_path import release_retained_path_leases - def release(): - try: - release_retained_path_leases(proofs[-1], current_lease=lease) - except Exception: - if lease is not None: lease.retain_for_recovery() - raise - def failed(error): - self._management_unsafe = True - self._management_unsafe_library = self._management_operation_library - self._management_unsafe_libraries.add(_path_key(self._management_operation_library)) - self._display_error(error) - self._management_results_ready(results, proofs, False) - self._lease_action(release, lambda _: self._management_results_ready(results, proofs, True), - failed, hold_busy=True) - elif not safe and lease is not None: - self._lease_action(lease.retain_for_recovery, - lambda _: self._management_results_ready(results, proofs, True), - lambda error: (self._display_error(error), self._management_results_ready(results, proofs, False)), - hold_busy=True) - else: - self._management_results_ready(results, proofs, True) - - def _management_results_ready(self, results, proofs, mapping_released): - if (mapping_released and (getattr(self, '_management_is_recovery', False) or proofs) and results - and all(result.safe_to_continue for result in results)): - self._management_unsafe_libraries.discard(_path_key(self._management_operation_library)) - self._management_unsafe = False - self._management_unsafe_library = None - self._maintenance_recovery_view = False - restored = {result.name for result in results if result.status == 'UPLOADED_VERIFIED'} - self._reimport_offers = tuple(offer for offer in self._reimport_offers if offer[1].name not in restored) - from .management_dialog import RESULT_LABELS - for result in results: - self.output.append(f'{result.name}:{RESULT_LABELS.get(result.status, result.status)} ' - f'{result.detail}\n{result.evidence_path or ""}') - if self.logging_context: - self.logging_context.logger.info('management_result operation=%s block=%s status=%s safe=%s evidence=%s detail=%s', - result.operation, result.name, result.status, result.safe_to_continue, result.evidence_path, result.detail) - if getattr(self, '_management_is_recovery', False) and result.status == 'UPLOADED_VERIFIED': - self.output.append('副本恢复校验通过,版本待核对。') - if any(not result.safe_to_continue for result in results): - self._management_unsafe = True - self._management_unsafe_library = self._management_operation_library - self._management_unsafe_libraries.add(_path_key(self._management_operation_library)) - self.status_label.setText('管理操作需要人工确认恢复/释放;已停止写入,未再次读取原生目录。') - self._show_unfinished_management() - - def _management_closed(self, *_): - if self._defer_mapping_finish(self._management_closed): return - from PySide6.QtCore import QTimer - self.busy = False; self._update() - changed = any(result.status in {'REMOVED', 'UPLOADED', 'UPLOADED_VERIFIED', 'UPLOADED_VERIFY_FAILED', 'RECOVERY_REQUIRED'} - for result in self._management_results) - if changed and not self._management_library_unsafe(self.mentor_lmc_path or self.loaded_path): - # Whole catalog reload is necessary for inserted/deleted identities; - # existing local search/filter controls are intentionally retained. - QTimer.singleShot(0, self.load_library) - - def visible_records(self): - """Cached records in table order, restricted to the current local view.""" - return tuple(record for name, record in self._records_by_name.items() - if not self.cbb_table.isRowHidden(self._row_by_name[name])) - - def selected_records(self): - """Visible checked management records, including READY/missing projects.""" - return tuple(record for record in self.visible_records() - if self.cbb_table.item(self._row_by_name[record.name], 0).checkState() == Qt.Checked) - - def visible_counts(self): - records = self.visible_records() - return {'visible': len(records), 'ready': sum(r.status == 'READY' for r in records), - 'error': sum(r.status not in {'READY', 'PENDING'} or r.name in self.skipped_names - for r in records)} - - def _eligible_names(self, *, checked_only=False): - records = self.selected_records() if checked_only else self.visible_records() - return [r.name for r in records if r.status != 'READY' and r.name not in self.skipped_names] - - def _maintenance_names(self): - records = self.selected_records() or self.visible_records() - return [record.name for record in records - if record.status != 'READY' and record.name not in self.skipped_names] - - def _native_backup_target(self): - selected = self.selected_records() - if selected: - return selected[0] if len(selected) == 1 and selected[0].status != 'READY' else None - row = self.cbb_table.currentRow() - if row < 0 or self.cbb_table.isRowHidden(row): - return None - item = self.cbb_table.item(row, 0) - record = self._records_by_name.get(item.text()) if item is not None else None - return record if record is not None and record.status != 'READY' else None - - def _check_visible(self, state): - self.cbb_table.blockSignals(True) - try: - for record in self.visible_records(): - self.cbb_table.item(self._row_by_name[record.name], 0).setCheckState(state) - finally: - self.cbb_table.blockSignals(False) - self._update() - - def _apply_filters(self, *_): - keyword = self.search_edit.text().strip().casefold() - mode = self.status_filter.currentData() - self.cbb_table.blockSignals(True) - self.cbb_table.setUpdatesEnabled(False) - try: - for name, record in self._records_by_name.items(): - matches = (not keyword or keyword in record.name.casefold() - or keyword in record.partition_name.casefold()) - matches = matches and (mode == 'all' - or mode == 'ready' and record.status == 'READY' - or mode == 'non_ready' and record.status != 'READY' - or mode == 'pending' and record.status == 'PENDING' - or mode == 'errors' and record.status not in {'READY', 'PENDING'} - or mode == 'missing' and name in self.skipped_names) - row = self._row_by_name[name] - if not matches: - self.cbb_table.item(row, 0).setCheckState(Qt.Unchecked) - self.cbb_table.setRowHidden(row, not matches) - finally: - self.cbb_table.setUpdatesEnabled(True) - self.cbb_table.blockSignals(False) - self._update() - - def choose_library(self): - path = QFileDialog.getOpenFileName(self, '选择中心库', '', 'LMC (*.lmc)')[0] - if path: self.lmc_edit.setText(path); self.load_library() - - def _start(self, action, callback): - self.stop.clear() - self.busy = True; self._update() - self.worker = ServiceWorker(self._queued_action(action)) - self.worker.signals.succeeded.connect(callback) - self.worker.signals.failed.connect(self._failed) - self.worker.signals.finished.connect(self._finished) - self.pool.start(self.worker) - - def _queued_action(self, action): - return lambda: self.native_queue.run(action, stop=self.stop, - waiting=lambda: self.signals.event.emit({'stage': 'waiting_native_slot', - 'detail': '已排队,等待当前原生操作结束'})) - - def _icdb_active(self): - return self.icdb_task is not None and self.icdb_task.active - - def _check_matches_library(self, library): - return self._icdb_active() and bool(_library_path_keys(library, self.library_lease) - & _library_path_keys(self.icdb_task.requests[0].lmc_file, self.icdb_task.path_lease)) - - def _invalidate_check_targets(self, library, names): - names = set(names) - for task in self.icdb_tasks: - if not (_library_path_keys(library, self.library_lease) - & _library_path_keys(task.requests[0].lmc_file, task.path_lease)): continue - task.invalidate(names) - if hasattr(task, 'summary'): - prefix = '已更新的工程:'+', '.join(sorted(task.invalidated))+'。下列为此前检查记录。\n' - task.summary.setDetailedText(prefix+task.summary.detailedText()) - if names & getattr(task, 'recovery_names', set()): - task.recovery_action.setEnabled(False) - task.recovery_action.setToolTip('工程已有后续管理操作,请重新检查。') - self._reimport_offers = tuple(offer for offer in self._reimport_offers if offer[0].block_name not in names - or not (_library_path_keys(library, self.library_lease) & _library_path_keys(offer[0].lmc_file))) - - def _stop_icdb_check(self): - if self._icdb_active(): - self.icdb_task.cancel() - self.icdb_phase.setText('正在停止检查,等待本项退出…') - self._update() - - def _publish_check_statuses(self, library, statuses, lease=None): - for task in tuple(self.icdb_tasks): - if task.active and (_library_path_keys(library, lease or self.library_lease) - & _library_path_keys(task.requests[0].lmc_file, task.path_lease)): - task.update_statuses(statuses) - - def _start_icdb_check(self, names): - if self.busy or self._icdb_active() or not self.loaded_path or self._native_backup_same_library(): return - eligible = set(self._maintenance_names()) - names = [name for name in names if name in eligible] - if not names: return - from .icdb_check_task import IcdbCheckTask - requests = tuple(replace(self._request(name), maintenance=True, auto_repair=False) for name in names) - task = IcdbCheckTask(requests, self.native_queue, self.data_root/'reports', - verifier=self.verifier, path_lease=self.library_lease, parent=self) - task.records = {name: self._records_by_name[name] for name in names} - self.icdb_task = task - self.icdb_tasks.append(task) - task.event.connect(lambda event: self._icdb_event(task, event)) - task.item_done.connect(lambda name, result: self._icdb_item_done(task, name, result)) - task.finished.connect(self._icdb_done) - self.icdb_progress.setVisible(True); self.icdb_phase.setVisible(True) - self.icdb_progress.setRange(0, len(requests)); self.icdb_progress.setValue(0) - self.icdb_progress.setFormat('已处理 %v / %m 个 CBB') - self.icdb_phase.setText('准备后台检查…') - task.start(); self._update() - - def _icdb_event(self, task, event): - name, stage = str(event.get('block', '')), str(event.get('stage', '')) - detail = str(event.get('detail') or stage) - self.icdb_phase.setText(f'{name} · '+({'icdb_check_start': '正在检查', - 'icdb_startup_check': '正在打开工程', 'waiting_native_slot': '已排队,等待执行'}.get(stage, detail))) - if not self.busy: self.status_label.setText('后台 ICDB 检查:'+self.icdb_phase.text()) - if self.logging_context: - self.logging_context.logger.info('icdb_background block=%s stage=%s detail=%s', name, stage, detail) - - def _icdb_item_done(self, task, name, result): - self.icdb_progress.setValue(len(task.results)) - if not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) - & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): - return - row = self._row_by_name.get(name) - if row is None: return - if not result.safe_to_continue: self._defer_status_refresh([name]) - if name in task.invalidated: - text = '内容已更新,待重新检查' - elif result.status == 'CHECKED': text = '未发现 ICDB 错误' - elif result.error_category == 'ICDB_REPAIR_REQUIRED': text = '发现 ICDB 错误' - elif result.status == 'CANCELLED': text = '检查已取消' - elif result.status == 'SKIPPED': - text = '已为 READY,跳过检查' if name in task.ready_names else '未检查' - elif result.error_category == 'DATABASE_SAFETY_STOP': - if 'read/write access permission' in result.stderr.casefold(): - text = '未确认:需处理读写确认' - elif not result.safe_to_continue: - text = '未确认:会话释放未确认' - else: - text = '未确认:会话或数据库状态待确认' - elif result.error_category == 'PCB_VERSION_CHOICE_REQUIRED': text = '未确认:需选择工程版本' - else: text = '未确认:'+(result.stderr.splitlines()[0][:120] if result.stderr else result.status) - cell = self.cbb_table.item(row, 3) - cell.setText(text); cell.setToolTip(result.stderr or result.stdout) - cell.setBackground(QColor('#E8F5E9' if result.status == 'CHECKED' and name not in task.invalidated - else '#FFEBEE' if result.error_category == 'ICDB_REPAIR_REQUIRED' else '#FFF8E1')) - - def _icdb_done(self, task): - from cbb_refresh_verify.icdb_maintenance import maintenance_counts - counts = maintenance_counts(task.results) - lease = task.path_lease - if lease is not None: - if any(not result.safe_to_continue for result in task.results): self._retain_path_lease(lease) - held_by_native = self._native_backup_session is not None and self._native_backup_session.path_lease is lease - if lease is not self.library_lease and not held_by_native: - self._close_path_lease(lease) - for request, result in zip(task.requests, task.results): - if result.status == 'SKIPPED': self._icdb_item_done(task, request.block_name, result) - text = (f'ICDB 检查结束:未发现异常 {counts["checked_without_repair"]},发现问题 {counts["issues_found"]},' - f'占用 {counts["in_use"]},无法确认 {counts["unconfirmed"]},取消 {counts["cancelled"]},未执行 {counts["skipped"]}') - from cbb_refresh_verify.reimport_recovery import offers_reimport - offers = tuple((req, task.records[req.block_name], result) for req, result in zip(task.requests, task.results) - if req.block_name not in task.invalidated and offers_reimport(result)) - same_library = bool(_library_path_keys(task.requests[0].lmc_file, task.path_lease) - & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)) - if offers: text += '\n可选择工程副本恢复。' - if same_library and not self.busy: self._reimport_offers = offers - self.icdb_phase.setText(text) - if not self.busy: self.status_label.setText(text) - self.output.append(text+'\n'+str(task.report or task.report_error)) - summary = QMessageBox(self); self.icdb_summary = summary - task.summary = summary - if not self.busy: self.summary = summary - summary.setWindowTitle('ICDB 批量检查结果'); summary.setText(text) - summary.setDetailedText(str(task.report or task.report_error)+'\n'+'\n'.join( - req.block_name+':'+('内容已更新,以下为旧检查结果:' if req.block_name in task.invalidated else '') - +(result.stderr or result.stdout or result.status) - for req, result in zip(task.requests, task.results))) - summary.setTextFormat(Qt.PlainText); summary.setAttribute(Qt.WA_ShowWithoutActivating) - if any(not result.safe_to_continue for result in task.results): - def release_task(): - if not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) - & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): - self.status_label.setText(f'请切回 {task.requests[0].lmc_file} 后释放该检查的残留。') - return - self.check_library_release() - summary.addButton('查看残留并释放…', QMessageBox.ActionRole).clicked.connect(release_task) - if offers: - action = summary.addButton('选择副本恢复…', QMessageBox.ActionRole) - task.recovery_action = action - task.recovery_names = {req.block_name for req, _, _ in offers} - def recover(): - if task.recovery_names & task.invalidated: return - if self.busy or not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) - & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): return - self._reimport_offers = offers - self.reimport_failed() - action.clicked.connect(recover) - summary.show(); self._update() - - def load_library(self): - if self.busy or not self.lmc_edit.text(): return - self._maintenance_recovery_view = False - self._global_icdb_run = False - if self._management_unsafe_library is not None: - self._management_library_unsafe(self._management_unsafe_library) - requested_library = _path_key(self.lmc_edit.text()) - if requested_library != _path_key(self._management_unsafe_library): - self._management_unsafe = False - self._management_unsafe_library = None - if not self._icdb_active(): - self.icdb_progress.hide(); self.icdb_phase.hide() - self._release_library_lease() - self.loaded_path = None; self.cbb_table.setRowCount(0); self._row_by_name = {}; self.ready_names = set() - self._records_by_name = {} - self.skipped_names = set(); self.skip_reasons = {} - path = self.lmc_edit.text() - self.status_label.setText('正在读取中心库…') - def read(): - import pythoncom - started = time.monotonic() - if self.logging_context: - self.logging_context.logger.info('library_load_start path=%s', path) - pythoncom.CoInitialize() - try: - lease = self.path_lease_factory(Path(path)) - mentor_path = (select_library_file(lease.mentor_path) - if lease.mentor_path.is_dir() else lease.mentor_path) - if isinstance(lease, LibraryPathLease): - lease.mentor_path = mentor_path - if self.logging_context: - self.logging_context.logger.info( - 'library_path_lease display=%s mentor=%s drive=%s remote=%s created=%s', - lease.display_path, mentor_path, lease.drive or '-', - lease.remote_root or '-', lease.created) - recovery_view = False - result = self.reader(mentor_path) - if not result.error: - self._publish_check_statuses(mentor_path, - {record.name: record.status for record in result.records}, lease) - if self.logging_context: - statuses = Counter(record.status for record in result.records) - unknown = [record.name for record in result.records if record.status in {'UNKNOWN', 'UNAVAILABLE'}] - self.logging_context.logger.info( - 'library_scan_result records=%s elapsed_ms=%s statuses=%s unknown_sample=%s', - len(result.records), int((time.monotonic() - started) * 1000), - dict(statuses), unknown[:20]) - skip_reasons = {} - if not result.error: - for record in result.records: - reason = preflight_skip_reason(mentor_path, record.name) - if reason: - skip_reasons[record.name] = reason - return result, skip_reasons, lease, mentor_path, recovery_view - except Exception: - if 'lease' in locals(): - lease.close() - raise - finally: pythoncom.CoUninitialize() - def loaded(payload): - result, skip_reasons, lease, mentor_path, recovery_view = payload - if path != self.lmc_edit.text(): - self._close_path_lease(lease) - return - if result.error: - self._close_path_lease(lease) - self.status_label.setText(result.error); return - self.library_lease = lease - self._maintenance_recovery_view = recovery_view - self.mentor_lmc_path = mentor_path - self.loaded_path = path - self.cbb_table.setRowCount(0) - self.ready_names = {r.name for r in result.records if r.status == 'READY' and r.name not in skip_reasons} - self.skip_reasons = dict(skip_reasons) - self.skipped_names = set(skip_reasons) - self._records_by_name = {record.name: record for record in result.records} - # Populating a large library emits itemChanged for every cell. - # Block those signals and refresh controls once after the batch; - # otherwise _update() repeatedly scans the growing table (O(n^2)). - self.cbb_table.blockSignals(True) - self.cbb_table.setUpdatesEnabled(False) - try: - self.cbb_table.setRowCount(len(result.records)) - for row, record in enumerate(result.records): - self._row_by_name[record.name] = row - item = QTableWidgetItem(record.name) - # Management selection includes READY and missing projects; - # operation queues independently enforce eligibility. - item.setFlags(item.flags() | Qt.ItemIsUserCheckable) - item.setCheckState(Qt.Unchecked) - self.cbb_table.setItem(row, 0, item) - self.cbb_table.setItem(row, 1, QTableWidgetItem(record.partition_name)) - status_text = STATUS_LABELS.get(record.status, record.status) - if record.name in self.skipped_names: - status_text += ' · 缺少工程/PCB' - self.cbb_table.setItem(row, 2, QTableWidgetItem(status_text)) - # Preflight touches each CBB's project and was previously run - # synchronously in this GUI callback, making large libraries - # appear frozen. The verify worker performs it when queued. - self.cbb_table.setItem(row, 3, QTableWidgetItem('未检查')) - if record.status == 'READY' and record.name not in self.skipped_names: - self._mark_row_ready(row) - elif record.name in self.skipped_names: - self.cbb_table.item(row, 0).setToolTip(self.skip_reasons[record.name]) - self.cbb_table.item(row, 2).setToolTip(self.skip_reasons[record.name]) - self.cbb_table.item(row, 3).setText('跳过') - for column in range(self.cbb_table.columnCount()): - cell = self.cbb_table.item(row, column) - if cell is not None: - cell.setBackground(QColor('#FFF8E1')) - finally: - self.cbb_table.setUpdatesEnabled(True) - self.cbb_table.blockSignals(False) - ready_count = len(self.ready_names) - unavailable_count = sum(record.status == 'UNAVAILABLE' for record in result.records) - read_error_count = sum(record.status in {'ERROR', 'TIMEOUT', 'MALFORMED', 'CRASHED'} - for record in result.records) - suffix = '' - if unavailable_count: - suffix += f' 状态桥不可用 {unavailable_count} 个。' - if read_error_count: - suffix += f' 状态读取失败 {read_error_count} 个。' - self.status_label.setText( - f'已读取 {len(result.records)} 个 CBB,其中 Ready {ready_count} 个,' - f'缺文件跳过 {len(self.skipped_names)} 个。{suffix}') - if recovery_view: - self.status_label.setText('协调阻止恢复视图:仅按目录显示工程,状态未确认(UNKNOWN),不代表损坏。' - '仅可明确执行 ICDB 维护或释放检查,其他写入与原生状态读取已禁用。') - self._apply_filters() - self._start(read, loaded) - - def _request(self, name): - return VerifyRequest(Path(self.mentor_lmc_path or self.loaded_path), name, self.data_root/'evidence', - libspec=self.libspec_edit.text().strip(), - dms_login_config=self.dms_edit.text().strip(), - mentor_bin=self.mentor_bin_edit.text().strip(), - mapped_drive=getattr(self.library_lease, 'drive', ''), - mapped_remote_root=getattr(self.library_lease, 'remote_root', ''), - timeout_seconds=self.timeout_spin.value(), logging_context=self.logging_context, - native_lm_verify=self.native_lm_verify_check.isChecked()) - - def _selected_names(self): - return [record.name for record in self.selected_records()] - - def verify_selected(self): - self._confirm_verify(self._eligible_names(checked_only=True)) - - def verify_all(self): - self._confirm_verify(self._eligible_names()) - - def _confirm_verify(self, names): - from .backup_notice import MANUAL_BACKUP_NOTICE - if self.busy or not self.loaded_path or self._native_backup_same_library() or not names: - return - if QMessageBox.question(self, '确认批量校验', - f'{MANUAL_BACKUP_NOTICE}\n\n目标库:{self.loaded_path}\n' - f'将校验 {len(names)} 个可见非 READY CBB 并保存结果。确认继续?', - QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == QMessageBox.Yes: - self._run(names) - - def repair_icdb_all(self): - if self.busy or not self.loaded_path: return - names = self._maintenance_names() - if not names: return - answer = QMessageBox.question(self, 'ICDB 批量检查', - f'当前中心库:{self.loaded_path}\n\n' - f'将检查 {len(names)} 个可见非 READY CBB' - f'{"(仅勾选项)" if self.selected_records() else ""}。\n' - '仅检查 ICDB 状态,不执行修复或回退。\n\n是否开始?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No) - if answer == QMessageBox.Yes: - self._run(names, maintenance=True) - - def _native_backup_same_library(self): - return self._native_backup_matches_library(self.mentor_lmc_path or self.lmc_edit.text()) - - def _native_backup_matches_library(self, library, lease=None): - session = self._native_backup_session - return session is not None and bool( - _library_path_keys(library, lease or self.library_lease) - & _library_path_keys(session.library, getattr(session, 'path_lease', None))) - - def open_native_backup(self): - if self.busy or not self.loaded_path or self._native_backup_session is not None: - return - target = self._native_backup_target() - if target is None: - self.status_label.setText('请勾选一个非 READY CBB。') - return - from cbb_refresh_verify.native_backup import launch_native_backup - request = self._request(target.name) - launcher = self.native_backup_launcher or launch_native_backup - self._global_icdb_run = False - self._reimport_offers = () - self.status_label.setText(f'正在打开 {request.block_name} 的版本与备份…') - paused_check = self.icdb_task if self._check_matches_library(request.lmc_file) else None - if paused_check is not None: - paused_check.pause(); paused_check.invalidate([request.block_name]) - def opened(session): - session.path_lease = self.library_lease - self._native_backup_session = session - self.native_backup_timer.start() - self.status_label.setText(f'正在打开 {session.block} 的原生备份窗口,请在其中选择版本。') - self.output.append(f'{session.block} · 原生版本与备份\n{session.job}') - self.busy = True; self._update() - self.stop.clear() - self.worker = ServiceWorker(self._queued_action(lambda: launcher(request))) - self.worker.signals.succeeded.connect(opened) - def failed(error): - self.status_label.setText(f'无法打开版本与备份:{error}') - if paused_check is not None: paused_check.resume() - self.worker.signals.failed.connect(failed) - self.worker.signals.finished.connect(self._finished) - self.pool.start(self.worker) - - def _release_native_backup_session(self, session): - self._native_backup_session = None - if session.path_lease is not None and session.path_lease is not self.library_lease: - self._close_path_lease(session.path_lease) - if self._icdb_active(): self.icdb_task.resume() - - def _poll_native_backup(self): - session = self._native_backup_session - if session is None or self.busy or session.process.poll() is None: - return - self.native_backup_timer.stop() - same_library = self._native_backup_same_library() - def read_result(): - import json - result = json.loads(session.job.with_name('result.json').read_text('utf-8')) - if (not self._native_backup_matches_library(result['library'], getattr(session, 'path_lease', None)) - or result['block'] != session.block): - raise ValueError('原生会话返回的工程身份不一致。') - refresh = (self._read_affected_records((session.block,)) - if result.get('safe_to_continue') is True and same_library else None) - return result, refresh - def completed(payload): - result, refresh = payload - if result.get('safe_to_continue') is not True: - unconfirmed(result.get('detail', '未取得会话释放结果。')) - return - self._release_native_backup_session(session) - if refresh is not None: - self._apply_refreshed_records(refresh) - message = ('原生备份窗口已关闭。需要时可单独运行校验。' if result.get('status') == 'CLOSED' - else '原生备份操作未结束:' + result.get('detail', '请检查原生窗口。')) - self.status_label.setText(message) - self.output.append(f'{session.block} · {message}\n{session.job.with_name("result.json")}') - if same_library and session.block in self._row_by_name: - self.cbb_table.item(self._row_by_name[session.block], 3).setText(message) - def unconfirmed(error): - self.status_label.setText('原生窗口退出尚未确认,请关闭窗口后检查释放。') - self.output.append(f'{session.block} · 退出尚未确认:{error}\n{session.job}') - self.busy = True; self._update() - self.stop.clear() - self.worker = ServiceWorker(self._queued_action(read_result)) - self.worker.signals.succeeded.connect(completed) - self.worker.signals.failed.connect(unconfirmed) - self.worker.signals.finished.connect(self._finished) - self.pool.start(self.worker) - - def restore_backup(self): - if self.busy or not self.loaded_path or self._native_backup_same_library(): - return - from .backup_recovery_dialog import BackupRecoveryDialog - names = self._eligible_names(checked_only=bool(self.selected_records())) - if not names: - return - self.backup_dialog = BackupRecoveryDialog(names, self._backup_request, self) - self.backup_dialog.native_queue = self.native_queue - row = self.cbb_table.currentRow() - if row >= 0 and self.cbb_table.item(row, 0).text() in names: - self.backup_dialog.block_combo.setCurrentText(self.cbb_table.item(row, 0).text()) - self.backup_dialog.started.connect(self._backup_started) - self.backup_dialog.completed.connect(self._backup_completed) - self.backup_dialog.finished.connect(lambda _code: self._backup_dialog_closed()) - self.backup_dialog.setModal(True) - self.backup_dialog.show() - - def _backup_request(self, name): - # A still-open dialog must recheck a target after an earlier recovery - # or an authoritative refresh changed its eligibility. - if self.busy or self._native_backup_same_library() or name not in self._eligible_names(checked_only=bool(self.selected_records())): - raise ValueError('目标需为当前可见、可用的非 READY CBB;请重新选择。') - return self._request(name) - - def _backup_started(self, name): - self._invalidate_check_targets(self.mentor_lmc_path or self.loaded_path, [name]) - self.busy = True - self._global_icdb_run = False - self.ready_names.discard(name) - if name in self._records_by_name: - self._records_by_name[name] = replace(self._records_by_name[name], status='UNKNOWN') - row = self._row_by_name.get(name) - if row is not None: - self.cbb_table.item(row, 2).setText('恢复中 / 需确认') - self.cbb_table.item(row, 0).setFlags( - self.cbb_table.item(row, 0).flags() | Qt.ItemIsUserCheckable) - for column in range(self.cbb_table.columnCount()): - self.cbb_table.item(row, column).setBackground(QColor('#FFF8E1')) - self._update() - self.stop_button.setEnabled(False) - - def _backup_completed(self, name, result): - if not result.safe_to_continue and self.library_lease is not None: - self._retain_path_lease(self.library_lease, hold_busy=True) - row = self._row_by_name.get(name) - if row is not None and result.status != 'PASS': - self.cbb_table.item(row, 2).setText('未知 / 需确认') - self._progress({'block': name, 'stage': result.status, 'detail': result.stderr, - 'evidence': str(result.evidence_path or '')}) - if result.safe_to_continue: - self.busy = False - self.refresh_affected_records([name]) - else: - self._defer_status_refresh([name]) - - def _backup_dialog_closed(self): - if not getattr(self, '_refreshing_records', False): - self._finished() - - def _run(self, names, *, maintenance=False): - if maintenance: return self._start_icdb_check(names) - if self.busy or not self.loaded_path: return - if self._native_backup_same_library(): - self.status_label.setText('请先关闭该库的版本与备份窗口。') - return - eligible = set(self._maintenance_names() if maintenance else self._eligible_names()) - names = [name for name in names if name in eligible] - if not names: - self.status_label.setText('当前可见选择中没有可校验的非 READY CBB。') - self._update() - return - requests = [replace(self._request(name), maintenance=maintenance, auto_repair=False) for name in names] - self._batch_requests = tuple(requests) - self._batch_records = {name: self._records_by_name[name] for name in names} - self._reimport_offers = () - self._global_icdb_run = maintenance - self._icdb_completed = 0 - self.icdb_progress.setVisible(maintenance or self._icdb_active()) - self.icdb_phase.setVisible(maintenance or self._icdb_active()) - if maintenance: - self.icdb_progress.setRange(0, len(requests)) - self.icdb_progress.setValue(0) - self.icdb_progress.setFormat('已处理 %v / %m 个 CBB') - self.icdb_phase.setText('准备检查…') - self.stop.clear(); self.recovery_path = None; self.recovery_button.setEnabled(False) - self.output.clear(); self.status_label.setText( - f'正在 ICDB 批量检查:共 {len(names)} 个 CBB' if maintenance - else f'正在校验:共 {len(names)} 个 CBB') - def action(): - from cbb_refresh_verify.verify_runner import read_library_flag_if_available, run_verify - verify = self.verifier or (lambda req: run_verify( - req, progress=lambda e: self.signals.event.emit(e), - flag_reader=read_library_flag_if_available, - version_prompt=self.signals.version_choice.emit, stop=self.stop)) - def verifier(req): - if maintenance: - self.signals.event.emit({'block': req.block_name, 'stage': 'icdb_check_start'}) - return verify(req) - results = run_batch(requests, verifier=verifier, stop=self.stop, - progress=lambda name, result: self.signals.event.emit({'block': name, 'stage': result.status, - 'error_category': result.error_category, 'evidence': str(result.evidence_path or ''), - 'detail': result.stderr or result.stdout})) - report = None - try: - report = write_batch_report(requests, results, self.data_root/'reports') - if maintenance: - from cbb_refresh_verify.icdb_maintenance import write_maintenance_report - write_maintenance_report(requests, results, report, ()) - except Exception as error: - self.signals.event.emit({'stage': 'report_failed', 'detail': str(error)}) - affected = [req.block_name for req, result in zip(requests, results) if result.status != 'SKIPPED'] - safe = all(result.safe_to_continue for result in results) - refresh = self._read_affected_records(affected) if safe else None - return results, report, affected, refresh - self._start(action, self._batch_done) - - def _read_affected_records(self, names): - """Worker-only read; never derive library state from action outcomes.""" - import pythoncom - pythoncom.CoInitialize() - try: - path = Path(self.mentor_lmc_path or self.loaded_path) - try: - statuses = self.status_refresher(tuple(names), path) - # Publish before yielding the native queue, ahead of Qt callbacks. - self._publish_check_statuses(path, statuses) - reasons = {name: reason for name in names - if (reason := preflight_skip_reason(path, name))} - return tuple(names), statuses, reasons, '' - except Exception as error: - return tuple(names), {}, None, str(error) - finally: - pythoncom.CoUninitialize() - - def _apply_refreshed_records(self, payload): - names, statuses, reasons, error = payload - self._publish_check_statuses(self.mentor_lmc_path or self.loaded_path, - {name: statuses.get(name, 'UNKNOWN') for name in names}) - self.cbb_table.blockSignals(True) - try: - for name in names: - if name not in self._records_by_name: - continue - status = statuses.get(name, 'UNKNOWN') - if status not in STATUS_LABELS: - status = 'UNKNOWN' - self._records_by_name[name] = replace(self._records_by_name[name], status=status) - self.ready_names.discard(name) - if reasons is not None: - self.skip_reasons.pop(name, None) - if name in reasons: - self.skip_reasons[name] = reasons[name] - self.skipped_names = set(self.skip_reasons) - row = self._row_by_name[name] - text = STATUS_LABELS[status] - if name in self.skipped_names: - text += ' · 缺少工程/PCB' - self.cbb_table.item(row, 2).setText(text) - self.cbb_table.item(row, 2).setToolTip(error or self.skip_reasons.get(name, '')) - if status == 'READY' and name not in self.skipped_names: - self.ready_names.add(name) - # A status transition invalidates a maintenance target; - # clear its old check so the repeatable diagnostic entry - # point does not become disabled merely because the user - # selected the row for the previous run. - self.cbb_table.item(row, 0).setCheckState(Qt.Unchecked) - self._mark_row_ready(row) - else: - for column in range(self.cbb_table.columnCount()): - self.cbb_table.item(row, column).setBackground(QColor('#FFF8E1')) - finally: - self.cbb_table.blockSignals(False) - if error: - self.output.append(f'状态复核未完成 / 需确认:{error}') - self._apply_filters() - return tuple(self._records_by_name[name] for name in names if name in self._records_by_name) - - def _defer_status_refresh(self, names): - self._apply_refreshed_records((tuple(names), {}, None, - '会话或数据库安全未确认;暂缓原生状态复核,请确认释放后重新读取。')) - - def refresh_affected_records(self, names, callback=None): - """Start an affected-only authoritative refresh once native owners release. - - Return True if scheduled, False if busy/unloaded/empty. Callback receives - tuple[CbbRecord, ...] on the GUI thread after applying refreshed statuses - (UNKNOWN on read failure). It runs before the worker's finished signal. - Search, filter, original logical_type and action-result cells are retained. - """ - if self.busy or not self.loaded_path or self._native_backup_same_library(): - return False - targets = tuple(dict.fromkeys(name for name in names if name in self._records_by_name)) - if not targets: - return False - self._refreshing_records = True - def refreshed(payload): - records = self._apply_refreshed_records(payload) - self._refreshing_records = False - if callback: - callback(records) - self._start(lambda: self._read_affected_records(targets), refreshed) - return True - - def _progress(self, event): - line = f"{event.get('block', '')} | {event.get('stage', '')}" - for key in ('detail', 'error', 'action', 'statuses', 'evidence'): - if event.get(key): line += f' | {event[key]}' - self.output.append(line) - block = event.get('block'); stage = event.get('stage') - if self._global_icdb_run: - if stage in {'PASS', 'FAIL', 'BLOCKED', 'TIMEOUT', 'SKIPPED', 'QUEUE_STOP', 'CHECKED', 'CANCELLED', 'REPAIRED'}: - self._icdb_completed += 1 - self.icdb_progress.setValue(self._icdb_completed) - phases = {'icdb_check_start': '检查工程数据库与校验状态', - 'icdb_startup_check': '正在尝试打开工程', - 'icdb_ownership_check': '正在打开原生检查工具', - 'native_started': '等待原生工具加载工程', - 'native_occupancy_wait': '等待原生检查结果', - 'native_repair_complete': '原生修复完成,待单独校验', - 'native_repair_start': '核对占用并准备原生修复', - 'native_repair_requested': '正在原生修复', - 'native_repair_confirmed': '正在原生修复', - 'native_repair_finished': '原生修复已结束,正在核对结果'} - if stage in phases: - self.icdb_phase.setText(f'{block or ""} · {phases[stage]}') - if block and stage in {'PASS', 'FAIL', 'BLOCKED', 'TIMEOUT', 'SKIPPED', 'CHECKED', 'REPAIRED', 'CANCELLED'}: - row = self._row_by_name.get(block) - if row is not None: - detail = str(event.get('detail') or event.get('error') or '').strip() - if event.get('error_category') == 'ICDB_REPAIR_REQUIRED' and detail: - detail = 'ICDB 问题:' + detail - label = str(stage) if not detail else f'{stage}: {detail[:96]}' - self.cbb_table.item(row, 3).setText(label) - self.cbb_table.item(row, 3).setToolTip(detail) - if self.logging_context: self.logging_context.logger.info('cbb_progress %s', line) - - def _mark_row_ready(self, row): - """Color authoritative READY rows while retaining management selection.""" - name_item = self.cbb_table.item(row, 0) - if name_item is None: - return - name_item.setFlags(name_item.flags() | Qt.ItemIsUserCheckable) - for column in range(self.cbb_table.columnCount()): - cell = self.cbb_table.item(row, column) - if cell is not None: - cell.setBackground(QColor('#E8F5E9')) - - def _batch_done(self, outcome): - results, report = outcome[:2] - failure_report = failure_report_path(report) if report is not None else '未写入' - report = report if report is not None else '未写入' - from cbb_refresh_verify.reimport_recovery import offers_reimport - self._reimport_offers = tuple((req, self._batch_records[req.block_name], result) - for req, result in zip(self._batch_requests, results) - if req.maintenance and req.block_name in self._batch_records and offers_reimport(result)) - if len(outcome) > 2: - _, _, affected, refresh = outcome - if refresh is None: - self._defer_status_refresh(affected) - else: - self._apply_refreshed_records(refresh) - if self.library_lease is not None and any(not result.safe_to_continue for result in results): - self._retain_path_lease(self.library_lease, hold_busy=True) - for result in results: - if not result.safe_to_continue and result.evidence_path: - self.recovery_path = result.evidence_path.parent - self.recovery_button.setEnabled(self.recovery_path.is_dir()) - passed = sum(r.status == 'PASS' for r in results) - skipped = sum(r.status == 'SKIPPED' for r in results) - checked = sum(r.status == 'CHECKED' for r in results) - repaired = sum(r.status == 'REPAIRED' for r in results) - failed = len(results)-passed-skipped-checked-repaired - text = (f'已结束:成功 {passed},失败 {failed},预检跳过 {len(self.skipped_names)},' - f'队列未执行 {skipped}。\n完整日志:{report}\n仅失败日志:{failure_report}') - if self._global_icdb_run: - from cbb_refresh_verify.icdb_maintenance import maintenance_counts - counts = maintenance_counts(results) - text = ('ICDB 批量检查已结束\n' - f'未发现异常 {counts["checked_without_repair"]},发现问题 {counts["issues_found"]},' - f'占用 {counts["in_use"]},无法确认 {counts["unconfirmed"]},' - f'取消 {counts["cancelled"]},队列未执行 {skipped}\n' - f'完整日志:{report}\n仅失败日志:{failure_report}') - self.icdb_phase.setText('批量检查已结束') - if any(not result.safe_to_continue for result in results): - text += '\n未确认数据库或会话安全,已停止剩余校验。请查看恢复现场。' - status_text = (f'已结束:通过 {passed},失败/受阻 {failed},' - f'仅检查 {checked},未执行 {skipped + len(self.skipped_names)}。') - if self._global_icdb_run: - status_text = (f'检查结束:未发现异常 {counts["checked_without_repair"]},' - f'发现问题 {counts["issues_found"]},占用 {counts["in_use"]},' - f'无法确认 {counts["unconfirmed"]},取消 {counts["cancelled"]},未执行 {skipped}。') - if repaired and not self._global_icdb_run: - status_text += f'\n原生 ICDB 修复完成 {repaired},待单独校验。' - first_failure = next((result.stderr for result in results - if result.status not in ('PASS', 'SKIPPED', 'CHECKED', 'REPAIRED') and result.stderr), '') - if first_failure: - text += '\n首个未完成原因:' + first_failure - if any(result.error_category == 'CBB_REIMPORT_REQUIRED' for result in results): - status_text += '\nMentor 不允许对此已验证过的 CBB 反标注,校验未通过。' - else: - status_text += '\n部分项目未完成,请查看详情。' - if any(not result.safe_to_continue for result in results): - status_text += '\n后续操作已暂停。' - if self._reimport_offers: - guidance = '\n修复未完成,可选择工程副本恢复。' - text += guidance - status_text += guidance - self.status_label.setText(status_text.replace('\n', ' ')); self.output.append(text) - self.summary = QMessageBox(self) - self.summary.setWindowTitle('ICDB 批量检查结果' if self._global_icdb_run else 'CBB 校验结果') - self.summary.setText(status_text) - self.summary.setDetailedText(text) - self.summary.setIcon(QMessageBox.Warning if failed else QMessageBox.Information) - self._reimport_summary_action = None - self._residual_release_action = None - self._resume_batch_action = None - self._resume_batch = None - if any(not result.safe_to_continue for result in results): - self._residual_release_action = self.summary.addButton('查看残留并释放…', QMessageBox.ActionRole) - self._residual_release_action.clicked.connect(self.check_library_release) - self._residual_release_action.setEnabled(False) - names = [req.block_name for req, result in zip(self._batch_requests, results) - if result.status == 'SKIPPED'] - if names: - self._resume_batch = {'library': self._batch_requests[0].lmc_file, 'names': names, - 'maintenance': self._global_icdb_run, 'released': False} - self._resume_batch_action = self.summary.addButton('继续未执行项', QMessageBox.ActionRole) - self._resume_batch_action.clicked.connect(self._resume_released_batch) - self._resume_batch_action.setEnabled(False) - if self._reimport_offers: - self.summary.setStandardButtons(QMessageBox.Close) - self._reimport_summary_action = self.summary.addButton('选择副本恢复…', QMessageBox.ActionRole) - self._reimport_summary_action.clicked.connect(self.reimport_failed) - self._reimport_summary_action.setEnabled(False) # Enabled after the worker finishes. - # Modeless notification: do not force activation or steal keyboard focus. - from PySide6.QtCore import Qt - self.summary.setTextFormat(Qt.PlainText) - self.summary.setAttribute(Qt.WA_ShowWithoutActivating) - self.summary.show() - - def _show_version_choice(self, choice): - from .pcb_restore_dialog import PcbRestoreDialog - if not self.busy or self.stop.is_set(): - choice.choose('cancel') - return - self.version_dialog = PcbRestoreDialog(choice, self) - self.status_label.setText(f'{choice.block}:等待选择 PCB 恢复版本。') - self.icdb_phase.setText(f'{choice.block} · 等待选择 PCB 恢复版本') - self.version_dialog.show() - - def request_stop(self): - if self._icdb_active(): - self._stop_icdb_check() - if not self.busy: return - if self.version_dialog is not None: - self.version_dialog.reject() - management = getattr(self, 'management_dialog', None) - if management is not None and management.isVisible(): - management.stop.set() - self.stop.set(); self.status_label.setText('已请求取消 ICDB 检查。' if self._global_icdb_run else - '已请求取消;检查将停止,原生写入只等待安全结束,不强制终止。'); self._update() - - def _failed(self, error): - from cbb_refresh_verify.operation_queue import QueueCancelled - if self.library_lease is not None and not isinstance(error, QueueCancelled): - self._retain_path_lease(self.library_lease, hold_busy=True) - self._display_error(error) - - def _display_error(self, error): - self.status_label.setText(str(error)); self.output.append(str(error)) - if self.logging_context: self.logging_context.logger.error('cbb_worker_failed %s', error) - - def _finished(self): - if self._defer_mapping_finish(self._finished): return - if self.version_dialog is not None: - self.version_dialog.reject() - self.version_dialog = None - self.busy = False; self._update() - if self._reload_after_maintenance: - from PySide6.QtCore import QTimer - self._reload_after_maintenance = False - QTimer.singleShot(0, self.load_library) - - def open_logs(self): - self.data_root.mkdir(parents=True, exist_ok=True); os.startfile(str(self.data_root)) - - def recover(self): - if not self.recovery_path: return - try: os.startfile(str(self.recovery_path)) - except Exception as error: self._display_error(error) - - def closeEvent(self, event): - if self._close_ready: - event.accept() - elif self._closing: - event.ignore() - elif self._icdb_active(): - self._stop_icdb_check(); event.ignore() - elif self.busy: - self.request_stop(); event.ignore() - else: - self._closing = True - self.busy = True; self._update() - retained = None - if self._native_backup_session is not None: - self.native_backup_timer.stop() - retained = self._native_backup_session.path_lease - lease, self.library_lease = self.library_lease, None - def release(): - if retained is not None: retained.retain_for_recovery() - if lease is not None and lease is not retained: lease.close() - self._lease_action(release) - self._close_when_idle() - event.ignore() - - def _close_when_idle(self): - owners = [self, *self.icdb_tasks] - for name in ('management_dialog', 'backup_dialog', 'release_dialog'): - owners.append(getattr(self, name, None)) - active = False - for owner in owners: - try: - pool = getattr(owner, 'pool', None) - active = active or bool(pool is not None and pool.activeThreadCount()) - except RuntimeError: - pass # Qt may already have deleted a closed dialog's pool. - if self._lease_pending or active: - QTimer.singleShot(20, self._close_when_idle) - return - self._close_ready = True - self.close() +from pathlib import Path +from threading import Event +import os +import ntpath +import time +from collections import Counter +from dataclasses import replace + +from PySide6.QtCore import QObject, QThreadPool, Signal, Qt, QTimer +from PySide6.QtGui import QColor, QIcon +from PySide6.QtWidgets import (QWidget, QLineEdit, QPushButton, QFormLayout, + QTextEdit, QFileDialog, QHBoxLayout, QLabel, QSpinBox, QMessageBox, QToolButton, + QTableWidget, QTableWidgetItem, QHeaderView, QCheckBox, QVBoxLayout, QProgressBar, QComboBox, + QTabBar, QStackedWidget, QSizePolicy) +from PySide6.QtWidgets import QStyle + + +def _path_key(value): + """Compare local and unavailable UNC paths without touching the network.""" + raw = str(value or '') + if not raw: + return '' + return os.path.normcase(os.path.normpath(os.path.abspath(raw))) + + +def _library_path_keys(value, lease=None): + """Use known mapping aliases without resolving unavailable network paths.""" + if not value: + return set() + keys = {_path_key(value)} + mentor = getattr(lease, 'mentor_path', None) + display = getattr(lease, 'display_path', None) + if mentor and display: + for source, alias in ((mentor, display), (display, mentor)): + if _path_key(value) == _path_key(source): + keys.add(_path_key(alias)) + elif _path_key(Path(value).parent) == _path_key(source): + keys.add(_path_key(Path(alias)/Path(value).name)) + drive, tail = ntpath.splitdrive(str(value)) + if (getattr(lease, 'remote_root', '') and drive + and drive.upper() == getattr(lease, 'drive', '').upper()): + keys.add(_path_key(lease.remote_root + tail)) + return keys +try: + from dx_productivity.trial_task_center.ui.workers import ServiceWorker +except ImportError: + from cbb_refresh_verify.ui.workers import ServiceWorker +from cbb_refresh_verify.library_reader import read_library_fast, scan_open_library_status +from cbb_refresh_verify.batch_status import authoritative_status_map +from cbb_refresh_verify.defaults import DEFAULT_TIMEOUT_SECONDS +from cbb_refresh_verify.network_path import LibraryPathLease, select_library_file +from cbb_refresh_verify.verify_runner import (VerifyRequest, preflight_skip_reason, run_verify, + run_batch, write_batch_report, failure_report_path, + native_lm_verify_enabled) + + +class ProgressSignals(QObject): + event = Signal(object) + version_choice = Signal(object) + + +STATUS_LABELS = { + 'READY': '绿色 / Ready', + 'PENDING': '待校验', + 'UNKNOWN': '未知 / 需确认', + 'UNAVAILABLE': '状态桥不可用', + 'ERROR': '状态读取失败', + 'TIMEOUT': '状态读取超时', + 'MALFORMED': '状态桥协议错误', + 'CRASHED': '状态桥崩溃', +} + + +def application_icon_path(): + return Path(__file__).resolve().parents[1] / 'assets' / 'cbb_refresh_verify.ico' + + +class MainWindow(QWidget): + def __init__(self, reader=None, verifier=None, logging_context=None, data_root=None, + authoritative_status=True, path_lease_factory=None, status_refresher=None, + management_adapter=None, native_backup_launcher=None): + super().__init__() + self.setWindowTitle('CBB 刷新校验') + icon_path = application_icon_path() + if icon_path.is_file(): + self.setWindowIcon(QIcon(str(icon_path))) + self.resize(850, 560) + self.verifier = verifier + self.logging_context = logging_context + self.path_lease_factory = path_lease_factory or LibraryPathLease.acquire + self.library_lease = None + self.mentor_lmc_path = None + self.data_root = Path(data_root or (logging_context.root if logging_context else Path(os.environ.get('LOCALAPPDATA', '.'))/'CbbRefreshVerify')) + from cbb_refresh_verify.native_management import NativeManagementAdapter + self.management_adapter = management_adapter or NativeManagementAdapter() + self.management_capabilities = self.management_adapter.capabilities() + self._management_unsafe = False + self._management_unsafe_library = None + self._management_unsafe_libraries = set() + self._management_operation_library = None + self._maintenance_recovery_view = False + self._reload_after_maintenance = False + self._reimport_offers = () + self._batch_requests = () + self._batch_records = {} + self._reimport_summary_action = None + self.native_backup_launcher = native_backup_launcher + self._native_backup_session = None + self.native_backup_timer = QTimer(self) + self.native_backup_timer.setInterval(400) + self.native_backup_timer.timeout.connect(self._poll_native_backup) + if reader is not None: + self.reader = reader + elif authoritative_status and os.environ.get('CBB_STATUS_BRIDGE_MODE', 'authoritative').casefold() != 'legacy': + self.reader = lambda path: read_library_fast( + path, + status_reader=lambda p, names: authoritative_status_map( + names, p, self.data_root / 'status-scan.jsonl'), + ) + else: + # Legacy icon/filesystem reader remains opt-in until the bridge is + # accepted on the target Mentor installation. It cannot override + # the authoritative path when that path is enabled explicitly. + self.reader = lambda path: read_library_fast( + path, + status_reader=lambda p, names: scan_open_library_status( + p, names, mapping_store=self.data_root/'image-status-map.json'), + ) + self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1) + self._lease_pending = 0 + self._lease_workers = set() + self._mapping_busy = 0 + self._mapping_auto_idle = False + self._mapping_finish_waiters = [] + self._closing = self._close_ready = False + from cbb_refresh_verify.operation_queue import NativeQueue + self.native_queue = NativeQueue() + self.icdb_task = None + self.icdb_tasks = [] + self.busy = False; self.loaded_path = None; self.stop = Event(); self.ready_names = set() + self._row_by_name = {} + self._records_by_name = {} + self.status_refresher = status_refresher or (lambda names, path: authoritative_status_map( + names, path, self.data_root / 'status-refresh.jsonl')) + self.skipped_names = set(); self.skip_reasons = {} + self._global_icdb_run = False + self._icdb_completed = 0 + self.signals = ProgressSignals(self); self.signals.event.connect(self._progress) + self.signals.version_choice.connect(self._show_version_choice) + self.version_dialog = None + self.lmc_edit = QLineEdit() + self.libspec_edit = QLineEdit(os.environ.get('CBB_LIBSPEC', 'EE7.9')) + self.dms_edit = QLineEdit(os.environ.get('CBB_DMS_LOGIN_CONFIG', '')) + self.mentor_bin_edit = QLineEdit(os.environ.get('SDD_LM_BIN', '')) + self.native_lm_verify_check = QCheckBox('使用 Library Manager 原生 Verify(Win10 兼容测试)') + self.native_lm_verify_check.setChecked(native_lm_verify_enabled()) + self.native_lm_verify_check.setToolTip( + '仅在 Win10 兼容测试时启用;默认仍使用已验证的 ReusableCircuit 直接流程。') + self.advanced_toggle = QToolButton(); self.advanced_toggle.setText('高级设置') + self.advanced_toggle.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_TitleBarUnshadeButton)) + self.advanced_toggle.setCheckable(True); self.advanced_toggle.setChecked(False) + self.advanced_panel = QWidget() + advanced_layout = QFormLayout(self.advanced_panel) + advanced_layout.addRow('LibSpec', self.libspec_edit) + advanced_layout.addRow('DMS 登录配置', self.dms_edit) + advanced_layout.addRow('Mentor bin', self.mentor_bin_edit) + advanced_layout.addRow('触发方式', self.native_lm_verify_check) + self.advanced_panel.setVisible(False) + self.advanced_toggle.toggled.connect(self.advanced_panel.setVisible) + self.cbb_table = QTableWidget(0, 4) + self.cbb_table.setHorizontalHeaderLabels(['CBB 名称', '分区', '状态', '备注']) + self.cbb_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch) + self.cbb_table.horizontalHeader().setSectionResizeMode(3, QHeaderView.Stretch) + for column in (1, 2): + self.cbb_table.horizontalHeader().setSectionResizeMode(column, QHeaderView.ResizeToContents) + self.cbb_table.setSelectionBehavior(QTableWidget.SelectRows) + self.cbb_table.setMinimumHeight(150) + self.cbb_table.itemChanged.connect(lambda _item: self._update()) + self.search_edit = QLineEdit() + self.search_edit.setPlaceholderText('按 CBB 名称或分区搜索') + self.status_filter = QComboBox() + for label, key in (('全部', 'all'), ('READY', 'ready'), ('非 READY(含未确认)', 'non_ready'), + ('PENDING', 'pending'), ('未知 / 读取异常', 'errors'), ('缺少工程', 'missing')): + self.status_filter.addItem(label, key) + self.counts_label = QLabel() + self.select_visible_button = QPushButton('选择可见项') + self.clear_selection_button = QPushButton('清空选择') + self.select_visible_button.clicked.connect(lambda: self._check_visible(Qt.Checked)) + self.clear_selection_button.clicked.connect(lambda: self._check_visible(Qt.Unchecked)) + self.search_edit.textChanged.connect(self._apply_filters) + self.status_filter.currentIndexChanged.connect(self._apply_filters) + self.timeout_spin = QSpinBox(); self.timeout_spin.setRange(30, 1800); self.timeout_spin.setValue(DEFAULT_TIMEOUT_SECONDS); self.timeout_spin.setSuffix(' 秒 / 无进展') + self.load_button = QPushButton('读取 CBB'); self.load_button.clicked.connect(self.load_library) + self.browse_button = QPushButton('选择'); self.browse_button.clicked.connect(self.choose_library) + self.selected_batch_button = QPushButton('批量校验已选'); self.selected_batch_button.clicked.connect(self.verify_selected) + self.batch_button = QPushButton('校验可见非 READY'); self.batch_button.clicked.connect(self.verify_all) + self.icdb_repair_button = QPushButton('ICDB 批量检查'); self.icdb_repair_button.clicked.connect(self.repair_icdb_all) + self.icdb_repair_button.setToolTip('检查可见的非 READY 工程;有勾选时仅检查勾选项。') + self.backup_restore_button = QPushButton('从备份恢复 CBB…') + self.backup_restore_button.clicked.connect(self.restore_backup) + self.reimport_button = QPushButton('选择工程副本恢复失败项…') + self.reimport_button.clicked.connect(self.reimport_failed) + self.reimport_button.hide() + self.stop_button = QPushButton('当前项完成后停止'); self.stop_button.clicked.connect(self.request_stop) + self.logs_button = QPushButton('打开日志目录'); self.logs_button.clicked.connect(self.open_logs) + self.recovery_button = QPushButton('打开异常证据'); self.recovery_button.setEnabled(False) + style = self.style() + self.load_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_BrowserReload)) + self.browse_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_DirOpenIcon)) + self.selected_batch_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_ArrowRight)) + self.batch_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaPlay)) + self.icdb_repair_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_BrowserReload)) + self.stop_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MediaStop)) + self.logs_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_DirOpenIcon)) + self.recovery_button.setIcon(style.standardIcon(QStyle.StandardPixmap.SP_MessageBoxWarning)) + self.recovery_button.setToolTip('打开当前异常 CBB 的证据目录,不切换 Windows 桌面。') + self.recovery_button.clicked.connect(self.recover) + self.recovery_path = None + self.status_label = QLabel('请选择并读取中心库。校验期间可以使用其他前台应用。') + self.status_label.setWordWrap(True) + self.status_label.setMinimumHeight(self.status_label.fontMetrics().lineSpacing()*2) + self.status_label.setMaximumHeight(self.status_label.fontMetrics().lineSpacing()*3 + 4) + self.status_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) + self.output = QTextEdit(); self.output.setReadOnly(True) + # Integration emits repeated status snapshots. Keep the visible + # diagnostic buffer bounded so a 3,000-CBB run cannot grow the GUI + # document without limit. + self.output.document().setMaximumBlockCount(2000) + self.output.setMaximumHeight(180) + layout = QVBoxLayout(self) + row = QHBoxLayout(); row.addWidget(QLabel('中心库')); row.addWidget(self.lmc_edit) + row.addWidget(self.browse_button); row.addWidget(self.load_button) + layout.addLayout(row) + self.library_notice = QLabel() + self.library_notice.setWordWrap(True) + self.library_notice.setTextFormat(Qt.PlainText) + self.library_notice.setStyleSheet('QLabel { color: #8a4b08; background: #fff3d6; padding: 6px; }') + self.library_notice.hide() + layout.addWidget(self.library_notice) + self.section_tabs = QTabBar() + self.section_tabs.setExpanding(True) + for name in ('检验', 'ICDB 维护', '中心库管理'): + self.section_tabs.addTab(name) + layout.addWidget(self.section_tabs) + filters = QHBoxLayout() + for widget in (self.search_edit, self.status_filter, self.select_visible_button, self.clear_selection_button): + filters.addWidget(widget) + layout.addLayout(filters) + layout.addWidget(self.counts_label) + layout.addWidget(self.cbb_table, 1) + self.section_stack = QStackedWidget() + self.section_stack.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) + self.section_tabs.currentChanged.connect(self.section_stack.setCurrentIndex) + verify_page = QWidget() + verify_layout = QVBoxLayout(verify_page); verify_layout.setContentsMargins(0, 0, 0, 0) + controls = QHBoxLayout() + for widget in (self.selected_batch_button, self.batch_button): controls.addWidget(widget) + controls.addStretch(); controls.addWidget(QLabel('超时')); controls.addWidget(self.timeout_spin) + controls.addWidget(self.advanced_toggle) + verify_layout.addLayout(controls); verify_layout.addWidget(self.advanced_panel) + self.section_stack.addWidget(verify_page) + maintenance = QWidget() + maintenance_layout = QVBoxLayout(maintenance) + maintenance_layout.setContentsMargins(0, 0, 0, 0) + self.native_backup_button = QPushButton('版本历史与备份…') + self.native_backup_button.setToolTip('勾选一个非 READY CBB,打开原生备份列表并选择回退版本。') + self.native_backup_button.clicked.connect(self.open_native_backup) + maintenance_layout.addWidget(self.native_backup_button) + maintenance_row = QHBoxLayout() + maintenance_row.addWidget(self.icdb_repair_button) + self.icdb_stop_button = QPushButton('停止检查') + self.icdb_stop_button.clicked.connect(self._stop_icdb_check) + maintenance_row.addWidget(self.icdb_stop_button) + maintenance_row.addWidget(self.backup_restore_button) + maintenance_row.addWidget(self.reimport_button) + maintenance_layout.addLayout(maintenance_row) + self.icdb_progress = QProgressBar() + self.icdb_progress.setVisible(False) + self.icdb_phase = QLabel('') + self.icdb_phase.setWordWrap(True) + self.icdb_phase.setVisible(False) + maintenance_layout.addWidget(self.icdb_progress) + maintenance_layout.addWidget(self.icdb_phase) + self.section_stack.addWidget(maintenance) + management = QWidget() + management_layout = QVBoxLayout(management) + management_layout.setContentsMargins(0, 0, 0, 0) + management_buttons = QHBoxLayout() + self.add_button = QPushButton('新增 CBB…') + self.update_button = QPushButton('用工程替换已选 CBB…') + self.remove_button = QPushButton('移除已选…') + for operation, widget in (('add', self.add_button), ('update', self.update_button), ('remove', self.remove_button)): + widget.clicked.connect(lambda _=False, op=operation: self.manage_cbb(op)) + widget.setToolTip(self.management_capabilities[operation].reason) + management_buttons.addWidget(widget) + management_layout.addLayout(management_buttons) + self.management_capability_label = QLabel() + self.management_capability_label.setWordWrap(True) + management_layout.insertWidget(0, self.management_capability_label) + self.unfinished_label = QLabel(); self.unfinished_label.setWordWrap(True) + management_layout.addWidget(self.unfinished_label) + self.release_library_button = QPushButton('释放残留会话…') + self.release_library_button.clicked.connect(self.check_library_release) + management_buttons.addWidget(self.release_library_button) + self.section_stack.addWidget(management) + layout.addWidget(self.section_stack) + layout.addWidget(self.status_label) + self.runtime_log_toggle = QToolButton(); self.runtime_log_toggle.setText('查看运行日志') + self.runtime_log_toggle.setCheckable(True) + self.runtime_log_toggle.toggled.connect(self.output.setVisible) + self.output.hide() + footer = QHBoxLayout() + for widget in (self.stop_button, self.runtime_log_toggle, self.logs_button, self.recovery_button): + footer.addWidget(widget) + layout.addLayout(footer); layout.addWidget(self.output) + self.lmc_edit.textChanged.connect(self._invalidate) + for field in (self.libspec_edit, self.dms_edit, self.mentor_bin_edit): + field.textChanged.connect(lambda _text: self._update()) + self.native_lm_verify_check.toggled.connect(lambda _checked: self._update()) + self._show_unfinished_management() + self._update() + + def _invalidate(self): + self._reimport_offers = () + if self.loaded_path is not None and self.lmc_edit.text() != self.loaded_path: + self._release_library_lease() + self.loaded_path = None; self.mentor_lmc_path = None; self.cbb_table.setRowCount(0); self._row_by_name = {} + self._records_by_name = {} + self.ready_names = set(); self.skipped_names = set(); self.skip_reasons = {}; self._update() + self._global_icdb_run = False + if not self._icdb_active(): + self.icdb_progress.hide(); self.icdb_phase.hide() + + def _release_library_lease(self): + lease, self.library_lease = self.library_lease, None + if self._native_backup_session is not None and self._native_backup_session.path_lease is lease: + return # The visible native session still needs this mapping. + if self._icdb_active() and self.icdb_task.path_lease is lease: + return # This background task still uses its captured mapping. + if lease is None: + return + try: + self._close_path_lease(lease) + except Exception as error: + if self.logging_context: + self.logging_context.logger.warning('library_lease_release_failed error=%s', error) + + def _close_path_lease(self, lease): + self._lease_action(lease.close, hold_busy=self.busy) + + def _retain_path_lease(self, lease, *, hold_busy=False): + if lease is not None: + self._lease_action(lease.retain_for_recovery, hold_busy=hold_busy) + + def _lease_action(self, action, completed=None, failed=None, *, hold_busy=False): + # The serial pool orders retain before every subsequent close. + self._lease_pending += 1 + if hold_busy: + if not self._mapping_busy and not self.busy: + self._mapping_auto_idle = True + self._mapping_busy += 1 + self.busy = True + self._update() + worker = ServiceWorker(action) + self._lease_workers.add(worker) + if completed is not None: worker.signals.succeeded.connect(completed) + worker.signals.failed.connect(failed or self._display_error) + def finished(): + self._lease_workers.discard(worker) + self._lease_pending -= 1 + if hold_busy: self._mapping_busy -= 1 + if not self._mapping_busy: + callbacks, self._mapping_finish_waiters = self._mapping_finish_waiters, [] + auto_idle, self._mapping_auto_idle = self._mapping_auto_idle, False + for callback in callbacks: callback() + if auto_idle and not callbacks: self._finished() + self._update() + worker.signals.finished.connect(finished) + self.pool.start(worker) + + def _defer_mapping_finish(self, callback): + if not self._mapping_busy: return False + if callback not in self._mapping_finish_waiters: + self._mapping_finish_waiters.append(callback) + return True + + def _update(self): + # The refresh flow needs only the library and a CBB; LibSpec/DMS config + # are optional and only enable the extra contents check. + ready = not self.busy and self.loaded_path == self.lmc_edit.text() and self.cbb_table.rowCount() > 0 + selected = self.selected_records() + native_target = self._native_backup_target() + self.native_backup_button.setEnabled(ready and self._native_backup_session is None + and native_target is not None) + ready = ready and not self._native_backup_same_library() + self.batch_button.setEnabled(ready and bool(self._eligible_names())) + self.selected_batch_button.setEnabled(ready and bool(self._eligible_names(checked_only=True))) + self.icdb_repair_button.setEnabled(ready and not self._icdb_active() and bool(self._maintenance_names())) + self.icdb_stop_button.setEnabled(self._icdb_active() and not self.icdb_task.stop.is_set()) + self.backup_restore_button.setEnabled(ready and bool( + self._eligible_names(checked_only=bool(self.selected_records())))) + self.release_library_button.setEnabled(not self.busy and bool(self.lmc_edit.text().strip())) + reasons = [] + for operation, widget in (('add', self.add_button), ('update', self.update_button), ('remove', self.remove_button)): + reason = self._management_block_reason(operation) + widget.setEnabled(not reason) + widget.setToolTip(reason or self.management_capabilities[operation].reason) + if reason: + reasons.append(reason) + self.management_capability_label.setText('\n'.join(dict.fromkeys(reasons))) + current_library = _path_key(self.mentor_lmc_path or self.lmc_edit.text()) if self.lmc_edit.text().strip() else None + notice = ('上次操作结果待复查,执行前将重新检查占用。' + if self._management_library_unsafe(current_library) else '') + self.library_notice.setText(notice) + self.library_notice.setVisible(bool(notice)) + for widget in (self.lmc_edit, self.browse_button, self.load_button, + self.timeout_spin, self.advanced_toggle, self.advanced_panel): + widget.setEnabled(not self.busy) + counts = self.visible_counts() + self.counts_label.setText(f'可见 {counts["visible"]} / {len(self._records_by_name)} · ' + f'READY {counts["ready"]} · 异常/待确认 {counts["error"]}') + self.stop_button.setEnabled((self.busy and self.loaded_path is not None and not self.stop.is_set()) + or self._icdb_active() and not self.icdb_task.stop.is_set()) + self.stop_button.setText('取消当前任务并停止队列') + available = bool(self._reimport_offers) and not self.busy and self.management_capabilities['update'].supported + self.reimport_button.setVisible(bool(self._reimport_offers)) + self.reimport_button.setEnabled(available) + self.reimport_button.setToolTip(self.management_capabilities['update'].reason) + if self._reimport_summary_action is not None: + self._reimport_summary_action.setEnabled(available) + if getattr(self, '_residual_release_action', None) is not None: + self._residual_release_action.setEnabled(not self.busy) + if getattr(self, '_resume_batch_action', None) is not None: + pending = getattr(self, '_resume_batch', None) + same = bool(pending and _library_path_keys(pending['library'], self.library_lease) + & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)) + self._resume_batch_action.setEnabled(not self.busy and same and pending['released']) + + def _show_unfinished_management(self): + from cbb_refresh_verify.management import unfinished_operations + unfinished = unfinished_operations(self.data_root/'management') + self.unfinished_label.setText(f'发现 {len(unfinished)} 项未完成或需恢复的管理任务;只显示记录,不自动重放。' + if unfinished else '') + for item in unfinished: + self.output.append(f'未完成:{item.get("name", "")} {item.get("status", "")} ' + f'{item.get("stage", "")}\n{item["evidence_path"]}') + + def check_library_release(self): + if self.busy or not self.lmc_edit.text().strip(): + return + from .residual_release_dialog import ResidualReleaseDialog + library = Path(self.mentor_lmc_path or self.lmc_edit.text().strip()) + self.release_dialog = ResidualReleaseDialog(library, self.data_root/'release-checks', self) + self.release_dialog.native_queue = self.native_queue + self.release_dialog.before_release.connect(self._stop_icdb_check) + self.release_dialog.released.connect(lambda result: self._complete_library_release(self.release_dialog.library, result)) + self.release_dialog.finished.connect(self._release_dialog_finished) + self.busy = True; self._update() + self.release_dialog.show() + + def _release_dialog_finished(self, _=None): + if self._defer_mapping_finish(self._release_dialog_finished): return + self._finished() + pending = getattr(self, '_resume_batch', None) + if pending and pending['released']: + self.summary.setText('会话已释放,可以继续未执行项。') + self.summary.show() + + def _complete_library_release(self, library, result): + from cbb_refresh_verify.network_path import release_retained_path_leases + try: + if (not isinstance(result, dict) or result.get('status') != 'RELEASE_CONFIRMED' + or not (_library_path_keys(result.get('library'), self.library_lease) + & _library_path_keys(library, self.library_lease))): + raise ValueError('RELEASE_PROOF_UNCONFIRMED: 释放证明未确认或不属于当前中心库。') + except Exception as error: + self._failed(error) + return + lease = self.library_lease + def release(): + try: + release_retained_path_leases(result, current_lease=lease) + except Exception: + if lease is not None: lease.retain_for_recovery() + raise + self._lease_action(release, lambda _: self._library_release_ready(library, result), + self._display_error, hold_busy=True) + + def _library_release_ready(self, library, result): + current_library = _path_key(self.mentor_lmc_path or self.lmc_edit.text().strip()) + if current_library == _path_key(library): + self._management_unsafe = False + self._management_unsafe_library = None + self._management_unsafe_libraries.discard(_path_key(library)) + session = self._native_backup_session + if self._native_backup_matches_library(library) and session.process.poll() is not None: + self._release_native_backup_session(session) + pending = getattr(self, '_resume_batch', None) + if pending and (_library_path_keys(pending['library'], self.library_lease) + & _library_path_keys(library, self.library_lease)): + pending['released'] = True + message = f'相关会话已释放,可以重试未完成的项目。\n{result["evidence_path"]}' + self.status_label.setText(message); self.output.append(message) + + def _resume_released_batch(self): + pending = getattr(self, '_resume_batch', None) + if self.busy or not pending or not pending['released']: return + if not (_library_path_keys(pending['library'], self.library_lease) + & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): + return + self._resume_batch = None + self._run(pending['names'], maintenance=pending['maintenance']) + + def _management_library_unsafe(self, library): + if self._management_unsafe and self._management_unsafe_library is not None: + self._management_unsafe_libraries.add(_path_key(self._management_unsafe_library)) + return _path_key(library) in self._management_unsafe_libraries + + def _management_block_reason(self, operation): + if self.busy: + return '当前任务尚未结束,请等待后再执行库管理操作。' + if self._native_backup_same_library(): + return '该库的版本与备份窗口仍在使用,关闭后可执行写入操作。' + capability = self.management_capabilities[operation] + if not capability.supported: + return capability.reason + if not self.loaded_path or self.loaded_path != self.lmc_edit.text(): + return '请先选择并读取中心库。' + if operation != 'add' and not self.selected_records(): + return '替换和移除需要先勾选当前可见的 CBB。' + return '' + + def manage_cbb(self, operation): + reason = self._management_block_reason(operation) + if reason: + self.status_label.setText(reason) + return + from cbb_refresh_verify.management import ManagementRequest + records = self.selected_records() + if operation != 'add' and not records: + return + def request(name, partition): + return ManagementRequest(operation, Path(self.mentor_lmc_path or self.loaded_path), name, + partition, evidence_dir=self.data_root/'management', timeout_seconds=self.timeout_spin.value(), + mapped_drive=getattr(self.library_lease, 'drive', ''), + mapped_remote_root=getattr(self.library_lease, 'remote_root', '')) + requests = ([request('', 'Logical-Physical')] if operation == 'add' else + [request(record.name, 'Logical-Physical' if record.logical_type == 'LP' + and record.partition_name in ('Reusable Blocks', 'LP') else record.partition_name) + for record in records]) + self._open_management_dialog(requests) + + def _open_management_dialog(self, requests, *, recovery_from=None): + from .management_dialog import ManagementDialog + self._global_icdb_run = False + self.stop.clear() + self._management_is_recovery = bool(recovery_from) + self._management_operation_library = _path_key(requests[0].library) if requests else None + requests = [replace(request, check_previous_release=True) if self._management_library_unsafe(request.library) + else request for request in requests] + self.management_dialog = ManagementDialog(requests, self, adapter=self.management_adapter, + recovery_from=recovery_from) + self.management_dialog.native_queue = self.native_queue + self.management_dialog.before_execute.connect(lambda names: self._invalidate_check_targets(requests[0].library, names)) + self._management_results = [] + self.management_dialog.completed.connect(self._management_completed) + self.management_dialog.finished.connect(self._management_closed) + self.busy = True; self._update() + self.management_dialog.show() + + def reimport_failed(self): + if self.busy or not self._reimport_offers or not self.management_capabilities['update'].supported: + return + from cbb_refresh_verify.management import ManagementRequest + requests, previous = [], {} + library = Path(self.mentor_lmc_path or self.loaded_path) + for req, record, result in self._reimport_offers: + if req.lmc_file != library: + return + partition = ('Logical-Physical' if record.logical_type == 'LP' + and record.partition_name in ('Reusable Blocks', 'LP') else record.partition_name) + requests.append(ManagementRequest('update', library, record.name, partition, + evidence_dir=self.data_root/'management', timeout_seconds=self.timeout_spin.value(), + mapped_drive=getattr(self.library_lease, 'drive', ''), + mapped_remote_root=getattr(self.library_lease, 'remote_root', ''))) + previous[record.name] = str(result.evidence_path) + self._reload_after_maintenance = False + if getattr(self, 'summary', None): self.summary.close() + self._open_management_dialog(requests, recovery_from=previous) + + def _management_completed(self, results): + self._management_results = results + proofs = [result.release_proof for result in results if isinstance(getattr(result, 'release_proof', None), dict) + and result.release_proof.get('status') == 'RELEASE_CONFIRMED' + and bool(_library_path_keys(result.release_proof.get('library'), self.library_lease) + & _library_path_keys(self._management_operation_library, self.library_lease)) + ] + safe = all(result.safe_to_continue for result in results) + lease = self.library_lease + if proofs and safe: + from cbb_refresh_verify.network_path import release_retained_path_leases + def release(): + try: + release_retained_path_leases(proofs[-1], current_lease=lease) + except Exception: + if lease is not None: lease.retain_for_recovery() + raise + def failed(error): + self._management_unsafe = True + self._management_unsafe_library = self._management_operation_library + self._management_unsafe_libraries.add(_path_key(self._management_operation_library)) + self._display_error(error) + self._management_results_ready(results, proofs, False) + self._lease_action(release, lambda _: self._management_results_ready(results, proofs, True), + failed, hold_busy=True) + elif not safe and lease is not None: + self._lease_action(lease.retain_for_recovery, + lambda _: self._management_results_ready(results, proofs, True), + lambda error: (self._display_error(error), self._management_results_ready(results, proofs, False)), + hold_busy=True) + else: + self._management_results_ready(results, proofs, True) + + def _management_results_ready(self, results, proofs, mapping_released): + if (mapping_released and (getattr(self, '_management_is_recovery', False) or proofs) and results + and all(result.safe_to_continue for result in results)): + self._management_unsafe_libraries.discard(_path_key(self._management_operation_library)) + self._management_unsafe = False + self._management_unsafe_library = None + self._maintenance_recovery_view = False + restored = {result.name for result in results if result.status == 'UPLOADED_VERIFIED'} + self._reimport_offers = tuple(offer for offer in self._reimport_offers if offer[1].name not in restored) + from .management_dialog import RESULT_LABELS + for result in results: + self.output.append(f'{result.name}:{RESULT_LABELS.get(result.status, result.status)} ' + f'{result.detail}\n{result.evidence_path or ""}') + if self.logging_context: + self.logging_context.logger.info('management_result operation=%s block=%s status=%s safe=%s evidence=%s detail=%s', + result.operation, result.name, result.status, result.safe_to_continue, result.evidence_path, result.detail) + if getattr(self, '_management_is_recovery', False) and result.status == 'UPLOADED_VERIFIED': + self.output.append('副本恢复校验通过,版本待核对。') + if any(not result.safe_to_continue for result in results): + self._management_unsafe = True + self._management_unsafe_library = self._management_operation_library + self._management_unsafe_libraries.add(_path_key(self._management_operation_library)) + self.status_label.setText('管理操作需要人工确认恢复/释放;已停止写入,未再次读取原生目录。') + self._show_unfinished_management() + + def _management_closed(self, *_): + if self._defer_mapping_finish(self._management_closed): return + from PySide6.QtCore import QTimer + self.busy = False; self._update() + changed = any(result.status in {'REMOVED', 'UPLOADED', 'UPLOADED_VERIFIED', 'UPLOADED_VERIFY_FAILED', 'RECOVERY_REQUIRED'} + for result in self._management_results) + if changed and not self._management_library_unsafe(self.mentor_lmc_path or self.loaded_path): + # Whole catalog reload is necessary for inserted/deleted identities; + # existing local search/filter controls are intentionally retained. + QTimer.singleShot(0, self.load_library) + + def visible_records(self): + """Cached records in table order, restricted to the current local view.""" + return tuple(record for name, record in self._records_by_name.items() + if not self.cbb_table.isRowHidden(self._row_by_name[name])) + + def selected_records(self): + """Visible checked management records, including READY/missing projects.""" + return tuple(record for record in self.visible_records() + if self.cbb_table.item(self._row_by_name[record.name], 0).checkState() == Qt.Checked) + + def visible_counts(self): + records = self.visible_records() + return {'visible': len(records), 'ready': sum(r.status == 'READY' for r in records), + 'error': sum(r.status not in {'READY', 'PENDING'} or r.name in self.skipped_names + for r in records)} + + def _eligible_names(self, *, checked_only=False): + records = self.selected_records() if checked_only else self.visible_records() + return [r.name for r in records if r.status != 'READY' and r.name not in self.skipped_names] + + def _maintenance_names(self): + records = self.selected_records() or self.visible_records() + return [record.name for record in records + if record.status != 'READY' and record.name not in self.skipped_names] + + def _native_backup_target(self): + selected = self.selected_records() + if selected: + return selected[0] if len(selected) == 1 and selected[0].status != 'READY' else None + row = self.cbb_table.currentRow() + if row < 0 or self.cbb_table.isRowHidden(row): + return None + item = self.cbb_table.item(row, 0) + record = self._records_by_name.get(item.text()) if item is not None else None + return record if record is not None and record.status != 'READY' else None + + def _check_visible(self, state): + self.cbb_table.blockSignals(True) + try: + for record in self.visible_records(): + self.cbb_table.item(self._row_by_name[record.name], 0).setCheckState(state) + finally: + self.cbb_table.blockSignals(False) + self._update() + + def _apply_filters(self, *_): + keyword = self.search_edit.text().strip().casefold() + mode = self.status_filter.currentData() + self.cbb_table.blockSignals(True) + self.cbb_table.setUpdatesEnabled(False) + try: + for name, record in self._records_by_name.items(): + matches = (not keyword or keyword in record.name.casefold() + or keyword in record.partition_name.casefold()) + matches = matches and (mode == 'all' + or mode == 'ready' and record.status == 'READY' + or mode == 'non_ready' and record.status != 'READY' + or mode == 'pending' and record.status == 'PENDING' + or mode == 'errors' and record.status not in {'READY', 'PENDING'} + or mode == 'missing' and name in self.skipped_names) + row = self._row_by_name[name] + if not matches: + self.cbb_table.item(row, 0).setCheckState(Qt.Unchecked) + self.cbb_table.setRowHidden(row, not matches) + finally: + self.cbb_table.setUpdatesEnabled(True) + self.cbb_table.blockSignals(False) + self._update() + + def choose_library(self): + path = QFileDialog.getOpenFileName(self, '选择中心库', '', 'LMC (*.lmc)')[0] + if path: self.lmc_edit.setText(path); self.load_library() + + def _start(self, action, callback): + self.stop.clear() + self.busy = True; self._update() + self.worker = ServiceWorker(self._queued_action(action)) + self.worker.signals.succeeded.connect(callback) + self.worker.signals.failed.connect(self._failed) + self.worker.signals.finished.connect(self._finished) + self.pool.start(self.worker) + + def _queued_action(self, action): + return lambda: self.native_queue.run(action, stop=self.stop, + waiting=lambda: self.signals.event.emit({'stage': 'waiting_native_slot', + 'detail': '已排队,等待当前原生操作结束'})) + + def _icdb_active(self): + return self.icdb_task is not None and self.icdb_task.active + + def _check_matches_library(self, library): + return self._icdb_active() and bool(_library_path_keys(library, self.library_lease) + & _library_path_keys(self.icdb_task.requests[0].lmc_file, self.icdb_task.path_lease)) + + def _invalidate_check_targets(self, library, names): + names = set(names) + for task in self.icdb_tasks: + if not (_library_path_keys(library, self.library_lease) + & _library_path_keys(task.requests[0].lmc_file, task.path_lease)): continue + task.invalidate(names) + if hasattr(task, 'summary'): + prefix = '已更新的工程:'+', '.join(sorted(task.invalidated))+'。下列为此前检查记录。\n' + task.summary.setDetailedText(prefix+task.summary.detailedText()) + if names & getattr(task, 'recovery_names', set()): + task.recovery_action.setEnabled(False) + task.recovery_action.setToolTip('工程已有后续管理操作,请重新检查。') + self._reimport_offers = tuple(offer for offer in self._reimport_offers if offer[0].block_name not in names + or not (_library_path_keys(library, self.library_lease) & _library_path_keys(offer[0].lmc_file))) + + def _stop_icdb_check(self): + if self._icdb_active(): + self.icdb_task.cancel() + self.icdb_phase.setText('正在停止检查,等待本项退出…') + self._update() + + def _publish_check_statuses(self, library, statuses, lease=None): + for task in tuple(self.icdb_tasks): + if task.active and (_library_path_keys(library, lease or self.library_lease) + & _library_path_keys(task.requests[0].lmc_file, task.path_lease)): + task.update_statuses(statuses) + + def _start_icdb_check(self, names): + if self.busy or self._icdb_active() or not self.loaded_path or self._native_backup_same_library(): return + eligible = set(self._maintenance_names()) + names = [name for name in names if name in eligible] + if not names: return + from .icdb_check_task import IcdbCheckTask + requests = tuple(replace(self._request(name), maintenance=True, auto_repair=False) for name in names) + task = IcdbCheckTask(requests, self.native_queue, self.data_root/'reports', + verifier=self.verifier, path_lease=self.library_lease, parent=self) + task.records = {name: self._records_by_name[name] for name in names} + self.icdb_task = task + self.icdb_tasks.append(task) + task.event.connect(lambda event: self._icdb_event(task, event)) + task.item_done.connect(lambda name, result: self._icdb_item_done(task, name, result)) + task.finished.connect(self._icdb_done) + self.icdb_progress.setVisible(True); self.icdb_phase.setVisible(True) + self.icdb_progress.setRange(0, len(requests)); self.icdb_progress.setValue(0) + self.icdb_progress.setFormat('已处理 %v / %m 个 CBB') + self.icdb_phase.setText('准备后台检查…') + task.start(); self._update() + + def _icdb_event(self, task, event): + name, stage = str(event.get('block', '')), str(event.get('stage', '')) + detail = str(event.get('detail') or stage) + self.icdb_phase.setText(f'{name} · '+({'icdb_check_start': '正在检查', + 'icdb_startup_check': '正在打开工程', 'waiting_native_slot': '已排队,等待执行'}.get(stage, detail))) + if not self.busy: self.status_label.setText('后台 ICDB 检查:'+self.icdb_phase.text()) + if self.logging_context: + self.logging_context.logger.info('icdb_background block=%s stage=%s detail=%s', name, stage, detail) + + def _icdb_item_done(self, task, name, result): + self.icdb_progress.setValue(len(task.results)) + if not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) + & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): + return + row = self._row_by_name.get(name) + if row is None: return + if not result.safe_to_continue: self._defer_status_refresh([name]) + if name in task.invalidated: + text = '内容已更新,待重新检查' + elif result.status == 'CHECKED': text = '未发现 ICDB 错误' + elif result.error_category == 'ICDB_REPAIR_REQUIRED': text = '发现 ICDB 错误' + elif result.status == 'CANCELLED': text = '检查已取消' + elif result.status == 'SKIPPED': + text = '已为 READY,跳过检查' if name in task.ready_names else '未检查' + elif result.error_category == 'DATABASE_SAFETY_STOP': + if 'read/write access permission' in result.stderr.casefold(): + text = '未确认:需处理读写确认' + elif not result.safe_to_continue: + text = '未确认:会话释放未确认' + else: + text = '未确认:会话或数据库状态待确认' + elif result.error_category == 'PCB_VERSION_CHOICE_REQUIRED': text = '未确认:需选择工程版本' + else: text = '未确认:'+(result.stderr.splitlines()[0][:120] if result.stderr else result.status) + cell = self.cbb_table.item(row, 3) + cell.setText(text); cell.setToolTip(result.stderr or result.stdout) + cell.setBackground(QColor('#E8F5E9' if result.status == 'CHECKED' and name not in task.invalidated + else '#FFEBEE' if result.error_category == 'ICDB_REPAIR_REQUIRED' else '#FFF8E1')) + + def _icdb_done(self, task): + from cbb_refresh_verify.icdb_maintenance import maintenance_counts + counts = maintenance_counts(task.results) + lease = task.path_lease + if lease is not None: + if any(not result.safe_to_continue for result in task.results): self._retain_path_lease(lease) + held_by_native = self._native_backup_session is not None and self._native_backup_session.path_lease is lease + if lease is not self.library_lease and not held_by_native: + self._close_path_lease(lease) + for request, result in zip(task.requests, task.results): + if result.status == 'SKIPPED': self._icdb_item_done(task, request.block_name, result) + text = (f'ICDB 检查结束:未发现异常 {counts["checked_without_repair"]},发现问题 {counts["issues_found"]},' + f'占用 {counts["in_use"]},无法确认 {counts["unconfirmed"]},取消 {counts["cancelled"]},未执行 {counts["skipped"]}') + from cbb_refresh_verify.reimport_recovery import offers_reimport + offers = tuple((req, task.records[req.block_name], result) for req, result in zip(task.requests, task.results) + if req.block_name not in task.invalidated and offers_reimport(result)) + same_library = bool(_library_path_keys(task.requests[0].lmc_file, task.path_lease) + & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)) + if offers: text += '\n可选择工程副本恢复。' + if same_library and not self.busy: self._reimport_offers = offers + self.icdb_phase.setText(text) + if not self.busy: self.status_label.setText(text) + self.output.append(text+'\n'+str(task.report or task.report_error)) + summary = QMessageBox(self); self.icdb_summary = summary + task.summary = summary + if not self.busy: self.summary = summary + summary.setWindowTitle('ICDB 批量检查结果'); summary.setText(text) + summary.setDetailedText(str(task.report or task.report_error)+'\n'+'\n'.join( + req.block_name+':'+('内容已更新,以下为旧检查结果:' if req.block_name in task.invalidated else '') + +(result.stderr or result.stdout or result.status) + for req, result in zip(task.requests, task.results))) + summary.setTextFormat(Qt.PlainText); summary.setAttribute(Qt.WA_ShowWithoutActivating) + if any(not result.safe_to_continue for result in task.results): + def release_task(): + if not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) + & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): + self.status_label.setText(f'请切回 {task.requests[0].lmc_file} 后释放该检查的残留。') + return + self.check_library_release() + summary.addButton('查看残留并释放…', QMessageBox.ActionRole).clicked.connect(release_task) + if offers: + action = summary.addButton('选择副本恢复…', QMessageBox.ActionRole) + task.recovery_action = action + task.recovery_names = {req.block_name for req, _, _ in offers} + def recover(): + if task.recovery_names & task.invalidated: return + if self.busy or not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) + & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): return + self._reimport_offers = offers + self.reimport_failed() + action.clicked.connect(recover) + summary.show(); self._update() + + def load_library(self): + if self.busy or not self.lmc_edit.text(): return + self._maintenance_recovery_view = False + self._global_icdb_run = False + if self._management_unsafe_library is not None: + self._management_library_unsafe(self._management_unsafe_library) + requested_library = _path_key(self.lmc_edit.text()) + if requested_library != _path_key(self._management_unsafe_library): + self._management_unsafe = False + self._management_unsafe_library = None + if not self._icdb_active(): + self.icdb_progress.hide(); self.icdb_phase.hide() + self._release_library_lease() + self.loaded_path = None; self.cbb_table.setRowCount(0); self._row_by_name = {}; self.ready_names = set() + self._records_by_name = {} + self.skipped_names = set(); self.skip_reasons = {} + path = self.lmc_edit.text() + self.status_label.setText('正在读取中心库…') + def read(): + import pythoncom + started = time.monotonic() + if self.logging_context: + self.logging_context.logger.info('library_load_start path=%s', path) + pythoncom.CoInitialize() + try: + lease = self.path_lease_factory(Path(path)) + mentor_path = (select_library_file(lease.mentor_path) + if lease.mentor_path.is_dir() else lease.mentor_path) + if isinstance(lease, LibraryPathLease): + lease.mentor_path = mentor_path + if self.logging_context: + self.logging_context.logger.info( + 'library_path_lease display=%s mentor=%s drive=%s remote=%s created=%s', + lease.display_path, mentor_path, lease.drive or '-', + lease.remote_root or '-', lease.created) + recovery_view = False + result = self.reader(mentor_path) + if not result.error: + self._publish_check_statuses(mentor_path, + {record.name: record.status for record in result.records}, lease) + if self.logging_context: + statuses = Counter(record.status for record in result.records) + unknown = [record.name for record in result.records if record.status in {'UNKNOWN', 'UNAVAILABLE'}] + self.logging_context.logger.info( + 'library_scan_result records=%s elapsed_ms=%s statuses=%s unknown_sample=%s', + len(result.records), int((time.monotonic() - started) * 1000), + dict(statuses), unknown[:20]) + skip_reasons = {} + if not result.error: + for record in result.records: + reason = preflight_skip_reason(mentor_path, record.name) + if reason: + skip_reasons[record.name] = reason + return result, skip_reasons, lease, mentor_path, recovery_view + except Exception: + if 'lease' in locals(): + lease.close() + raise + finally: pythoncom.CoUninitialize() + def loaded(payload): + result, skip_reasons, lease, mentor_path, recovery_view = payload + if path != self.lmc_edit.text(): + self._close_path_lease(lease) + return + if result.error: + self._close_path_lease(lease) + self.status_label.setText(result.error); return + self.library_lease = lease + self._maintenance_recovery_view = recovery_view + self.mentor_lmc_path = mentor_path + self.loaded_path = path + self.cbb_table.setRowCount(0) + self.ready_names = {r.name for r in result.records if r.status == 'READY' and r.name not in skip_reasons} + self.skip_reasons = dict(skip_reasons) + self.skipped_names = set(skip_reasons) + self._records_by_name = {record.name: record for record in result.records} + # Populating a large library emits itemChanged for every cell. + # Block those signals and refresh controls once after the batch; + # otherwise _update() repeatedly scans the growing table (O(n^2)). + self.cbb_table.blockSignals(True) + self.cbb_table.setUpdatesEnabled(False) + try: + self.cbb_table.setRowCount(len(result.records)) + for row, record in enumerate(result.records): + self._row_by_name[record.name] = row + item = QTableWidgetItem(record.name) + # Management selection includes READY and missing projects; + # operation queues independently enforce eligibility. + item.setFlags(item.flags() | Qt.ItemIsUserCheckable) + item.setCheckState(Qt.Unchecked) + self.cbb_table.setItem(row, 0, item) + self.cbb_table.setItem(row, 1, QTableWidgetItem(record.partition_name)) + status_text = STATUS_LABELS.get(record.status, record.status) + if record.name in self.skipped_names: + status_text += ' · 缺少工程/PCB' + self.cbb_table.setItem(row, 2, QTableWidgetItem(status_text)) + # Preflight touches each CBB's project and was previously run + # synchronously in this GUI callback, making large libraries + # appear frozen. The verify worker performs it when queued. + self.cbb_table.setItem(row, 3, QTableWidgetItem('未检查')) + if record.status == 'READY' and record.name not in self.skipped_names: + self._mark_row_ready(row) + elif record.name in self.skipped_names: + self.cbb_table.item(row, 0).setToolTip(self.skip_reasons[record.name]) + self.cbb_table.item(row, 2).setToolTip(self.skip_reasons[record.name]) + self.cbb_table.item(row, 3).setText('跳过') + for column in range(self.cbb_table.columnCount()): + cell = self.cbb_table.item(row, column) + if cell is not None: + cell.setBackground(QColor('#FFF8E1')) + finally: + self.cbb_table.setUpdatesEnabled(True) + self.cbb_table.blockSignals(False) + ready_count = len(self.ready_names) + unavailable_count = sum(record.status == 'UNAVAILABLE' for record in result.records) + read_error_count = sum(record.status in {'ERROR', 'TIMEOUT', 'MALFORMED', 'CRASHED'} + for record in result.records) + suffix = '' + if unavailable_count: + suffix += f' 状态桥不可用 {unavailable_count} 个。' + if read_error_count: + suffix += f' 状态读取失败 {read_error_count} 个。' + self.status_label.setText( + f'已读取 {len(result.records)} 个 CBB,其中 Ready {ready_count} 个,' + f'缺文件跳过 {len(self.skipped_names)} 个。{suffix}') + if recovery_view: + self.status_label.setText('协调阻止恢复视图:仅按目录显示工程,状态未确认(UNKNOWN),不代表损坏。' + '仅可明确执行 ICDB 维护或释放检查,其他写入与原生状态读取已禁用。') + self._apply_filters() + self._start(read, loaded) + + def _request(self, name): + return VerifyRequest(Path(self.mentor_lmc_path or self.loaded_path), name, self.data_root/'evidence', + libspec=self.libspec_edit.text().strip(), + dms_login_config=self.dms_edit.text().strip(), + mentor_bin=self.mentor_bin_edit.text().strip(), + mapped_drive=getattr(self.library_lease, 'drive', ''), + mapped_remote_root=getattr(self.library_lease, 'remote_root', ''), + timeout_seconds=self.timeout_spin.value(), logging_context=self.logging_context, + native_lm_verify=self.native_lm_verify_check.isChecked()) + + def _selected_names(self): + return [record.name for record in self.selected_records()] + + def verify_selected(self): + self._confirm_verify(self._eligible_names(checked_only=True)) + + def verify_all(self): + self._confirm_verify(self._eligible_names()) + + def _confirm_verify(self, names): + from .backup_notice import MANUAL_BACKUP_NOTICE + if self.busy or not self.loaded_path or self._native_backup_same_library() or not names: + return + if QMessageBox.question(self, '确认批量校验', + f'{MANUAL_BACKUP_NOTICE}\n\n目标库:{self.loaded_path}\n' + f'将校验 {len(names)} 个可见非 READY CBB 并保存结果。确认继续?', + QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == QMessageBox.Yes: + self._run(names) + + def repair_icdb_all(self): + if self.busy or not self.loaded_path: return + names = self._maintenance_names() + if not names: return + answer = QMessageBox.question(self, 'ICDB 批量检查', + f'当前中心库:{self.loaded_path}\n\n' + f'将检查 {len(names)} 个可见非 READY CBB' + f'{"(仅勾选项)" if self.selected_records() else ""}。\n' + '仅检查 ICDB 状态,不执行修复或回退。\n\n是否开始?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No) + if answer == QMessageBox.Yes: + self._run(names, maintenance=True) + + def _native_backup_same_library(self): + return self._native_backup_matches_library(self.mentor_lmc_path or self.lmc_edit.text()) + + def _native_backup_matches_library(self, library, lease=None): + session = self._native_backup_session + return session is not None and bool( + _library_path_keys(library, lease or self.library_lease) + & _library_path_keys(session.library, getattr(session, 'path_lease', None))) + + def open_native_backup(self): + if self.busy or not self.loaded_path or self._native_backup_session is not None: + return + target = self._native_backup_target() + if target is None: + self.status_label.setText('请勾选一个非 READY CBB。') + return + from cbb_refresh_verify.native_backup import launch_native_backup + request = self._request(target.name) + launcher = self.native_backup_launcher or launch_native_backup + self._global_icdb_run = False + self._reimport_offers = () + self.status_label.setText(f'正在打开 {request.block_name} 的版本与备份…') + paused_check = self.icdb_task if self._check_matches_library(request.lmc_file) else None + if paused_check is not None: + paused_check.pause(); paused_check.invalidate([request.block_name]) + def opened(session): + session.path_lease = self.library_lease + self._native_backup_session = session + self.native_backup_timer.start() + self.status_label.setText(f'正在打开 {session.block} 的原生备份窗口,请在其中选择版本。') + self.output.append(f'{session.block} · 原生版本与备份\n{session.job}') + self.busy = True; self._update() + self.stop.clear() + self.worker = ServiceWorker(self._queued_action(lambda: launcher(request))) + self.worker.signals.succeeded.connect(opened) + def failed(error): + self.status_label.setText(f'无法打开版本与备份:{error}') + if paused_check is not None: paused_check.resume() + self.worker.signals.failed.connect(failed) + self.worker.signals.finished.connect(self._finished) + self.pool.start(self.worker) + + def _release_native_backup_session(self, session): + self._native_backup_session = None + if session.path_lease is not None and session.path_lease is not self.library_lease: + self._close_path_lease(session.path_lease) + if self._icdb_active(): self.icdb_task.resume() + + def _poll_native_backup(self): + session = self._native_backup_session + if session is None or self.busy or session.process.poll() is None: + return + self.native_backup_timer.stop() + same_library = self._native_backup_same_library() + def read_result(): + import json + result = json.loads(session.job.with_name('result.json').read_text('utf-8')) + if (not self._native_backup_matches_library(result['library'], getattr(session, 'path_lease', None)) + or result['block'] != session.block): + raise ValueError('原生会话返回的工程身份不一致。') + refresh = (self._read_affected_records((session.block,)) + if result.get('safe_to_continue') is True and same_library else None) + return result, refresh + def completed(payload): + result, refresh = payload + if result.get('safe_to_continue') is not True: + unconfirmed(result.get('detail', '未取得会话释放结果。')) + return + self._release_native_backup_session(session) + if refresh is not None: + self._apply_refreshed_records(refresh) + message = ('原生备份窗口已关闭。需要时可单独运行校验。' if result.get('status') == 'CLOSED' + else '原生备份操作未结束:' + result.get('detail', '请检查原生窗口。')) + self.status_label.setText(message) + self.output.append(f'{session.block} · {message}\n{session.job.with_name("result.json")}') + if same_library and session.block in self._row_by_name: + self.cbb_table.item(self._row_by_name[session.block], 3).setText(message) + def unconfirmed(error): + self.status_label.setText('原生窗口退出尚未确认,请关闭窗口后检查释放。') + self.output.append(f'{session.block} · 退出尚未确认:{error}\n{session.job}') + self.busy = True; self._update() + self.stop.clear() + self.worker = ServiceWorker(self._queued_action(read_result)) + self.worker.signals.succeeded.connect(completed) + self.worker.signals.failed.connect(unconfirmed) + self.worker.signals.finished.connect(self._finished) + self.pool.start(self.worker) + + def restore_backup(self): + if self.busy or not self.loaded_path or self._native_backup_same_library(): + return + from .backup_recovery_dialog import BackupRecoveryDialog + names = self._eligible_names(checked_only=bool(self.selected_records())) + if not names: + return + self.backup_dialog = BackupRecoveryDialog(names, self._backup_request, self) + self.backup_dialog.native_queue = self.native_queue + row = self.cbb_table.currentRow() + if row >= 0 and self.cbb_table.item(row, 0).text() in names: + self.backup_dialog.block_combo.setCurrentText(self.cbb_table.item(row, 0).text()) + self.backup_dialog.started.connect(self._backup_started) + self.backup_dialog.completed.connect(self._backup_completed) + self.backup_dialog.finished.connect(lambda _code: self._backup_dialog_closed()) + self.backup_dialog.setModal(True) + self.backup_dialog.show() + + def _backup_request(self, name): + # A still-open dialog must recheck a target after an earlier recovery + # or an authoritative refresh changed its eligibility. + if self.busy or self._native_backup_same_library() or name not in self._eligible_names(checked_only=bool(self.selected_records())): + raise ValueError('目标需为当前可见、可用的非 READY CBB;请重新选择。') + return self._request(name) + + def _backup_started(self, name): + self._invalidate_check_targets(self.mentor_lmc_path or self.loaded_path, [name]) + self.busy = True + self._global_icdb_run = False + self.ready_names.discard(name) + if name in self._records_by_name: + self._records_by_name[name] = replace(self._records_by_name[name], status='UNKNOWN') + row = self._row_by_name.get(name) + if row is not None: + self.cbb_table.item(row, 2).setText('恢复中 / 需确认') + self.cbb_table.item(row, 0).setFlags( + self.cbb_table.item(row, 0).flags() | Qt.ItemIsUserCheckable) + for column in range(self.cbb_table.columnCount()): + self.cbb_table.item(row, column).setBackground(QColor('#FFF8E1')) + self._update() + self.stop_button.setEnabled(False) + + def _backup_completed(self, name, result): + if not result.safe_to_continue and self.library_lease is not None: + self._retain_path_lease(self.library_lease, hold_busy=True) + row = self._row_by_name.get(name) + if row is not None and result.status != 'PASS': + self.cbb_table.item(row, 2).setText('未知 / 需确认') + self._progress({'block': name, 'stage': result.status, 'detail': result.stderr, + 'evidence': str(result.evidence_path or '')}) + if result.safe_to_continue: + self.busy = False + self.refresh_affected_records([name]) + else: + self._defer_status_refresh([name]) + + def _backup_dialog_closed(self): + if not getattr(self, '_refreshing_records', False): + self._finished() + + def _run(self, names, *, maintenance=False): + if maintenance: return self._start_icdb_check(names) + if self.busy or not self.loaded_path: return + if self._native_backup_same_library(): + self.status_label.setText('请先关闭该库的版本与备份窗口。') + return + eligible = set(self._maintenance_names() if maintenance else self._eligible_names()) + names = [name for name in names if name in eligible] + if not names: + self.status_label.setText('当前可见选择中没有可校验的非 READY CBB。') + self._update() + return + requests = [replace(self._request(name), maintenance=maintenance, auto_repair=False) for name in names] + self._batch_requests = tuple(requests) + self._batch_records = {name: self._records_by_name[name] for name in names} + self._reimport_offers = () + self._global_icdb_run = maintenance + self._icdb_completed = 0 + self.icdb_progress.setVisible(maintenance or self._icdb_active()) + self.icdb_phase.setVisible(maintenance or self._icdb_active()) + if maintenance: + self.icdb_progress.setRange(0, len(requests)) + self.icdb_progress.setValue(0) + self.icdb_progress.setFormat('已处理 %v / %m 个 CBB') + self.icdb_phase.setText('准备检查…') + self.stop.clear(); self.recovery_path = None; self.recovery_button.setEnabled(False) + self.output.clear(); self.status_label.setText( + f'正在 ICDB 批量检查:共 {len(names)} 个 CBB' if maintenance + else f'正在校验:共 {len(names)} 个 CBB') + def action(): + from cbb_refresh_verify.verify_runner import read_library_flag_if_available, run_verify + verify = self.verifier or (lambda req: run_verify( + req, progress=lambda e: self.signals.event.emit(e), + flag_reader=read_library_flag_if_available, + version_prompt=self.signals.version_choice.emit, stop=self.stop)) + def verifier(req): + if maintenance: + self.signals.event.emit({'block': req.block_name, 'stage': 'icdb_check_start'}) + return verify(req) + results = run_batch(requests, verifier=verifier, stop=self.stop, + progress=lambda name, result: self.signals.event.emit({'block': name, 'stage': result.status, + 'error_category': result.error_category, 'evidence': str(result.evidence_path or ''), + 'detail': result.stderr or result.stdout})) + report = None + try: + report = write_batch_report(requests, results, self.data_root/'reports') + if maintenance: + from cbb_refresh_verify.icdb_maintenance import write_maintenance_report + write_maintenance_report(requests, results, report, ()) + except Exception as error: + self.signals.event.emit({'stage': 'report_failed', 'detail': str(error)}) + affected = [req.block_name for req, result in zip(requests, results) if result.status != 'SKIPPED'] + safe = all(result.safe_to_continue for result in results) + refresh = self._read_affected_records(affected) if safe else None + return results, report, affected, refresh + self._start(action, self._batch_done) + + def _read_affected_records(self, names): + """Worker-only read; never derive library state from action outcomes.""" + import pythoncom + pythoncom.CoInitialize() + try: + path = Path(self.mentor_lmc_path or self.loaded_path) + try: + statuses = self.status_refresher(tuple(names), path) + # Publish before yielding the native queue, ahead of Qt callbacks. + self._publish_check_statuses(path, statuses) + reasons = {name: reason for name in names + if (reason := preflight_skip_reason(path, name))} + return tuple(names), statuses, reasons, '' + except Exception as error: + return tuple(names), {}, None, str(error) + finally: + pythoncom.CoUninitialize() + + def _apply_refreshed_records(self, payload): + names, statuses, reasons, error = payload + self._publish_check_statuses(self.mentor_lmc_path or self.loaded_path, + {name: statuses.get(name, 'UNKNOWN') for name in names}) + self.cbb_table.blockSignals(True) + try: + for name in names: + if name not in self._records_by_name: + continue + status = statuses.get(name, 'UNKNOWN') + if status not in STATUS_LABELS: + status = 'UNKNOWN' + self._records_by_name[name] = replace(self._records_by_name[name], status=status) + self.ready_names.discard(name) + if reasons is not None: + self.skip_reasons.pop(name, None) + if name in reasons: + self.skip_reasons[name] = reasons[name] + self.skipped_names = set(self.skip_reasons) + row = self._row_by_name[name] + text = STATUS_LABELS[status] + if name in self.skipped_names: + text += ' · 缺少工程/PCB' + self.cbb_table.item(row, 2).setText(text) + self.cbb_table.item(row, 2).setToolTip(error or self.skip_reasons.get(name, '')) + if status == 'READY' and name not in self.skipped_names: + self.ready_names.add(name) + # A status transition invalidates a maintenance target; + # clear its old check so the repeatable diagnostic entry + # point does not become disabled merely because the user + # selected the row for the previous run. + self.cbb_table.item(row, 0).setCheckState(Qt.Unchecked) + self._mark_row_ready(row) + else: + for column in range(self.cbb_table.columnCount()): + self.cbb_table.item(row, column).setBackground(QColor('#FFF8E1')) + finally: + self.cbb_table.blockSignals(False) + if error: + self.output.append(f'状态复核未完成 / 需确认:{error}') + self._apply_filters() + return tuple(self._records_by_name[name] for name in names if name in self._records_by_name) + + def _defer_status_refresh(self, names): + self._apply_refreshed_records((tuple(names), {}, None, + '会话或数据库安全未确认;暂缓原生状态复核,请确认释放后重新读取。')) + + def refresh_affected_records(self, names, callback=None): + """Start an affected-only authoritative refresh once native owners release. + + Return True if scheduled, False if busy/unloaded/empty. Callback receives + tuple[CbbRecord, ...] on the GUI thread after applying refreshed statuses + (UNKNOWN on read failure). It runs before the worker's finished signal. + Search, filter, original logical_type and action-result cells are retained. + """ + if self.busy or not self.loaded_path or self._native_backup_same_library(): + return False + targets = tuple(dict.fromkeys(name for name in names if name in self._records_by_name)) + if not targets: + return False + self._refreshing_records = True + def refreshed(payload): + records = self._apply_refreshed_records(payload) + self._refreshing_records = False + if callback: + callback(records) + self._start(lambda: self._read_affected_records(targets), refreshed) + return True + + def _progress(self, event): + line = f"{event.get('block', '')} | {event.get('stage', '')}" + for key in ('detail', 'error', 'action', 'statuses', 'evidence'): + if event.get(key): line += f' | {event[key]}' + self.output.append(line) + block = event.get('block'); stage = event.get('stage') + if self._global_icdb_run: + if stage in {'PASS', 'FAIL', 'BLOCKED', 'TIMEOUT', 'SKIPPED', 'QUEUE_STOP', 'CHECKED', 'CANCELLED', 'REPAIRED'}: + self._icdb_completed += 1 + self.icdb_progress.setValue(self._icdb_completed) + phases = {'icdb_check_start': '检查工程数据库与校验状态', + 'icdb_startup_check': '正在尝试打开工程', + 'icdb_ownership_check': '正在打开原生检查工具', + 'native_started': '等待原生工具加载工程', + 'native_occupancy_wait': '等待原生检查结果', + 'native_repair_complete': '原生修复完成,待单独校验', + 'native_repair_start': '核对占用并准备原生修复', + 'native_repair_requested': '正在原生修复', + 'native_repair_confirmed': '正在原生修复', + 'native_repair_finished': '原生修复已结束,正在核对结果'} + if stage in phases: + self.icdb_phase.setText(f'{block or ""} · {phases[stage]}') + if block and stage in {'PASS', 'FAIL', 'BLOCKED', 'TIMEOUT', 'SKIPPED', 'CHECKED', 'REPAIRED', 'CANCELLED'}: + row = self._row_by_name.get(block) + if row is not None: + detail = str(event.get('detail') or event.get('error') or '').strip() + if event.get('error_category') == 'ICDB_REPAIR_REQUIRED' and detail: + detail = 'ICDB 问题:' + detail + label = str(stage) if not detail else f'{stage}: {detail[:96]}' + self.cbb_table.item(row, 3).setText(label) + self.cbb_table.item(row, 3).setToolTip(detail) + if self.logging_context: self.logging_context.logger.info('cbb_progress %s', line) + + def _mark_row_ready(self, row): + """Color authoritative READY rows while retaining management selection.""" + name_item = self.cbb_table.item(row, 0) + if name_item is None: + return + name_item.setFlags(name_item.flags() | Qt.ItemIsUserCheckable) + for column in range(self.cbb_table.columnCount()): + cell = self.cbb_table.item(row, column) + if cell is not None: + cell.setBackground(QColor('#E8F5E9')) + + def _batch_done(self, outcome): + results, report = outcome[:2] + failure_report = failure_report_path(report) if report is not None else '未写入' + report = report if report is not None else '未写入' + from cbb_refresh_verify.reimport_recovery import offers_reimport + self._reimport_offers = tuple((req, self._batch_records[req.block_name], result) + for req, result in zip(self._batch_requests, results) + if req.maintenance and req.block_name in self._batch_records and offers_reimport(result)) + if len(outcome) > 2: + _, _, affected, refresh = outcome + if refresh is None: + self._defer_status_refresh(affected) + else: + self._apply_refreshed_records(refresh) + if self.library_lease is not None and any(not result.safe_to_continue for result in results): + self._retain_path_lease(self.library_lease, hold_busy=True) + for result in results: + if not result.safe_to_continue and result.evidence_path: + self.recovery_path = result.evidence_path.parent + self.recovery_button.setEnabled(self.recovery_path.is_dir()) + passed = sum(r.status == 'PASS' for r in results) + skipped = sum(r.status == 'SKIPPED' for r in results) + checked = sum(r.status == 'CHECKED' for r in results) + repaired = sum(r.status == 'REPAIRED' for r in results) + failed = len(results)-passed-skipped-checked-repaired + text = (f'已结束:成功 {passed},失败 {failed},预检跳过 {len(self.skipped_names)},' + f'队列未执行 {skipped}。\n完整日志:{report}\n仅失败日志:{failure_report}') + if self._global_icdb_run: + from cbb_refresh_verify.icdb_maintenance import maintenance_counts + counts = maintenance_counts(results) + text = ('ICDB 批量检查已结束\n' + f'未发现异常 {counts["checked_without_repair"]},发现问题 {counts["issues_found"]},' + f'占用 {counts["in_use"]},无法确认 {counts["unconfirmed"]},' + f'取消 {counts["cancelled"]},队列未执行 {skipped}\n' + f'完整日志:{report}\n仅失败日志:{failure_report}') + self.icdb_phase.setText('批量检查已结束') + if any(not result.safe_to_continue for result in results): + text += '\n未确认数据库或会话安全,已停止剩余校验。请查看恢复现场。' + status_text = (f'已结束:通过 {passed},失败/受阻 {failed},' + f'仅检查 {checked},未执行 {skipped + len(self.skipped_names)}。') + if self._global_icdb_run: + status_text = (f'检查结束:未发现异常 {counts["checked_without_repair"]},' + f'发现问题 {counts["issues_found"]},占用 {counts["in_use"]},' + f'无法确认 {counts["unconfirmed"]},取消 {counts["cancelled"]},未执行 {skipped}。') + if repaired and not self._global_icdb_run: + status_text += f'\n原生 ICDB 修复完成 {repaired},待单独校验。' + first_failure = next((result.stderr for result in results + if result.status not in ('PASS', 'SKIPPED', 'CHECKED', 'REPAIRED') and result.stderr), '') + if first_failure: + text += '\n首个未完成原因:' + first_failure + if any(result.error_category == 'CBB_REIMPORT_REQUIRED' for result in results): + status_text += '\nMentor 不允许对此已验证过的 CBB 反标注,校验未通过。' + else: + status_text += '\n部分项目未完成,请查看详情。' + if any(not result.safe_to_continue for result in results): + status_text += '\n后续操作已暂停。' + if self._reimport_offers: + guidance = '\n修复未完成,可选择工程副本恢复。' + text += guidance + status_text += guidance + self.status_label.setText(status_text.replace('\n', ' ')); self.output.append(text) + self.summary = QMessageBox(self) + self.summary.setWindowTitle('ICDB 批量检查结果' if self._global_icdb_run else 'CBB 校验结果') + self.summary.setText(status_text) + self.summary.setDetailedText(text) + self.summary.setIcon(QMessageBox.Warning if failed else QMessageBox.Information) + self._reimport_summary_action = None + self._residual_release_action = None + self._resume_batch_action = None + self._resume_batch = None + if any(not result.safe_to_continue for result in results): + self._residual_release_action = self.summary.addButton('查看残留并释放…', QMessageBox.ActionRole) + self._residual_release_action.clicked.connect(self.check_library_release) + self._residual_release_action.setEnabled(False) + names = [req.block_name for req, result in zip(self._batch_requests, results) + if result.status == 'SKIPPED'] + if names: + self._resume_batch = {'library': self._batch_requests[0].lmc_file, 'names': names, + 'maintenance': self._global_icdb_run, 'released': False} + self._resume_batch_action = self.summary.addButton('继续未执行项', QMessageBox.ActionRole) + self._resume_batch_action.clicked.connect(self._resume_released_batch) + self._resume_batch_action.setEnabled(False) + if self._reimport_offers: + self.summary.setStandardButtons(QMessageBox.Close) + self._reimport_summary_action = self.summary.addButton('选择副本恢复…', QMessageBox.ActionRole) + self._reimport_summary_action.clicked.connect(self.reimport_failed) + self._reimport_summary_action.setEnabled(False) # Enabled after the worker finishes. + # Modeless notification: do not force activation or steal keyboard focus. + from PySide6.QtCore import Qt + self.summary.setTextFormat(Qt.PlainText) + self.summary.setAttribute(Qt.WA_ShowWithoutActivating) + self.summary.show() + + def _show_version_choice(self, choice): + from .pcb_restore_dialog import PcbRestoreDialog + if not self.busy or self.stop.is_set(): + choice.choose('cancel') + return + self.version_dialog = PcbRestoreDialog(choice, self) + self.status_label.setText(f'{choice.block}:等待选择 PCB 恢复版本。') + self.icdb_phase.setText(f'{choice.block} · 等待选择 PCB 恢复版本') + self.version_dialog.show() + + def request_stop(self): + if self._icdb_active(): + self._stop_icdb_check() + if not self.busy: return + if self.version_dialog is not None: + self.version_dialog.reject() + management = getattr(self, 'management_dialog', None) + if management is not None and management.isVisible(): + management.stop.set() + self.stop.set(); self.status_label.setText('已请求取消 ICDB 检查。' if self._global_icdb_run else + '已请求取消;检查将停止,原生写入只等待安全结束,不强制终止。'); self._update() + + def _failed(self, error): + from cbb_refresh_verify.operation_queue import QueueCancelled + if self.library_lease is not None and not isinstance(error, QueueCancelled): + self._retain_path_lease(self.library_lease, hold_busy=True) + self._display_error(error) + + def _display_error(self, error): + self.status_label.setText(str(error)); self.output.append(str(error)) + if self.logging_context: self.logging_context.logger.error('cbb_worker_failed %s', error) + + def _finished(self): + if self._defer_mapping_finish(self._finished): return + if self.version_dialog is not None: + self.version_dialog.reject() + self.version_dialog = None + self.busy = False; self._update() + if self._reload_after_maintenance: + from PySide6.QtCore import QTimer + self._reload_after_maintenance = False + QTimer.singleShot(0, self.load_library) + + def open_logs(self): + self.data_root.mkdir(parents=True, exist_ok=True); os.startfile(str(self.data_root)) + + def recover(self): + if not self.recovery_path: return + try: os.startfile(str(self.recovery_path)) + except Exception as error: self._display_error(error) + + def closeEvent(self, event): + if self._close_ready: + event.accept() + elif self._closing: + event.ignore() + elif self._icdb_active(): + self._stop_icdb_check(); event.ignore() + elif self.busy: + self.request_stop(); event.ignore() + else: + self._closing = True + self.busy = True; self._update() + retained = None + if self._native_backup_session is not None: + self.native_backup_timer.stop() + retained = self._native_backup_session.path_lease + lease, self.library_lease = self.library_lease, None + def release(): + if retained is not None: retained.retain_for_recovery() + if lease is not None and lease is not retained: lease.close() + self._lease_action(release) + self._close_when_idle() + event.ignore() + + def _close_when_idle(self): + owners = [self, *self.icdb_tasks] + for name in ('management_dialog', 'backup_dialog', 'release_dialog'): + owners.append(getattr(self, name, None)) + active = False + for owner in owners: + try: + pool = getattr(owner, 'pool', None) + active = active or bool(pool is not None and pool.activeThreadCount()) + except RuntimeError: + pass # Qt may already have deleted a closed dialog's pool. + if self._lease_pending or active: + QTimer.singleShot(20, self._close_when_idle) + return + self._close_ready = True + self.close() diff --git a/src/cbb_refresh_verify/ui/residual_release_dialog.py b/src/cbb_refresh_verify/ui/residual_release_dialog.py index 8d5899f..5b489eb 100644 --- a/src/cbb_refresh_verify/ui/residual_release_dialog.py +++ b/src/cbb_refresh_verify/ui/residual_release_dialog.py @@ -7,6 +7,7 @@ from PySide6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushB QTableWidget, QTableWidgetItem, QHeaderView, QMessageBox) from .workers import ServiceWorker +from ..residual_sessions import force_block_reason class ResidualReleaseDialog(QDialog): @@ -39,7 +40,7 @@ class ResidualReleaseDialog(QDialog): self.refresh_button = QPushButton('重新检查') self.confirm_button = QPushButton('确认释放') self.prompt_button = QPushButton('处理保存提示…') - self.force_button = QPushButton('强制结束所列会话…') + self.force_button = QPushButton('强制结束客户端…') self.force_button.setEnabled(False) self.prompt_button.setEnabled(False) self.close_button = QPushButton('关闭') @@ -71,7 +72,7 @@ class ResidualReleaseDialog(QDialog): self.refresh_button.setEnabled(True) self.confirm_button.setEnabled(self.plan is not None) self.force_button.setEnabled(bool(self.plan and any( - r.get('scope_confirmed', True) for r in self.plan['sessions']))) + not force_block_reason(r) for r in self.plan['sessions']))) self.close_button.setText('关闭') self._update_prompt() if self._refresh_after: @@ -132,11 +133,12 @@ class ResidualReleaseDialog(QDialog): def force_release(self): if self.busy or not self.plan or not self.plan['sessions']: return - targets = [r for r in self.plan['sessions'] if r.get('scope_confirmed', True)] + targets = [r for r in self.plan['sessions'] if not force_block_reason(r)] if not targets: return names = '\n'.join(f'{r.get("project", "")} — {r["name"]} (PID {r["pid"]})' for r in targets) - answer = QMessageBox.warning(self, '强制结束会话', - '将强制结束以下进程,未保存的更改会丢失,正在写入的工程可能需要恢复。\n\n'+names+ + answer = QMessageBox.warning(self, '强制结束客户端', + '仅强制结束以下客户端。客户端中其他已打开工程也会退出;未保存的更改会丢失,正在写入的工程可能需要恢复。' + '\n数据库服务器和归属未知的进程不会被强制结束。\n\n'+names+ '\n\n仍要结束这些进程吗?', QMessageBox.Yes | QMessageBox.Cancel, QMessageBox.Cancel) if answer == QMessageBox.Yes: self.confirm_release(force=True) diff --git a/tests/test_operation_queue.py b/tests/test_operation_queue.py new file mode 100644 index 0000000..c83f5fa --- /dev/null +++ b/tests/test_operation_queue.py @@ -0,0 +1,42 @@ +from threading import Event, Thread + +from cbb_refresh_verify.operation_queue import NativeQueue, QueueCancelled + + +def test_paused_ticket_yields_to_a_ready_native_task(): + queue=NativeQueue() + ready, waiting, complete=Event(),Event(),Event() + order=[] + thread=Thread(target=lambda:queue.run(lambda:(order.append('resumed'),complete.set()), + ready=ready.is_set,waiting=waiting.set)) + thread.start() + try: + assert waiting.wait(2) + queue.run(lambda:order.append('ready')) + assert order==['ready'] + ready.set();queue.wake() + assert complete.wait(2) + assert order==['ready','resumed'] + finally: + ready.set();queue.wake();thread.join(2) + assert not thread.is_alive() + + +def test_cancelled_paused_ticket_does_not_hold_later_work(): + queue=NativeQueue() + waiting,stop=Event(),Event() + outcome=[] + def wait(): + try: + queue.run(lambda:outcome.append('unexpected'),ready=lambda:False, + waiting=waiting.set,stop=stop) + except QueueCancelled:outcome.append('cancelled') + thread=Thread(target=wait);thread.start() + try: + assert waiting.wait(2) + stop.set();queue.wake();thread.join(2) + assert not thread.is_alive() + queue.run(lambda:outcome.append('next')) + assert outcome==['cancelled','next'] + finally: + stop.set();queue.wake();thread.join(2) diff --git a/tests/test_residual_release_dialog.py b/tests/test_residual_release_dialog.py index e5cd1b2..d0301b6 100644 --- a/tests/test_residual_release_dialog.py +++ b/tests/test_residual_release_dialog.py @@ -81,7 +81,8 @@ def test_force_close_is_explicit_and_cancel_does_not_release(qtbot, tmp_path, mo from cbb_refresh_verify import library_lock from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog plan = {'library': str(tmp_path/'lib.lmc'), 'sessions': [ - {'project': 'A', 'name': 'ExpeditionPCB.exe', 'pid': 10, 'detail': '窗口无响应'}]} + {'project': 'A', 'name': 'ExpeditionPCB.exe', 'pid': 10, 'detail': '窗口无响应', + 'scope_confirmed': True, 'owner_sid': 'S-1-current', 'session_id': 1, 'force_user_confirmed': True, 'image': 'C:/Mentor/ExpeditionPCB.exe', 'created_handle': 'creation'}]} monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda *_: plan) calls = [] def release(actual, *a, **kw): @@ -100,6 +101,31 @@ def test_force_close_is_explicit_and_cancel_does_not_release(qtbot, tmp_path, mo assert calls == [True] +def test_force_confirmation_excludes_shared_servers(qtbot, tmp_path, monkeypatch): + from PySide6.QtWidgets import QMessageBox + from cbb_refresh_verify import library_lock + from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog + rows = [{'project': 'A', 'name': name, 'pid': pid, 'scope_confirmed': True, 'owner_sid': 'S-1-current', 'session_id': 1, 'force_user_confirmed': True, + 'image': 'C:/Mentor/'+name, 'created_handle': str(pid), 'detail': 'waiting'} + for name, pid in [('icdbserver.exe', 10), ('ExpeditionPCB.exe', 20)]] + monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda *_: { + 'library': str(tmp_path/'lib.lmc'), 'sessions': rows}) + dialog = ResidualReleaseDialog(tmp_path/'lib.lmc', tmp_path/'evidence') + qtbot.addWidget(dialog) + qtbot.waitUntil(lambda: not dialog.busy) + messages = [] + monkeypatch.setattr(QMessageBox, 'warning', lambda parent, title, text, *args: + messages.append(text) or QMessageBox.Cancel) + dialog.force_button.click() + assert len(messages) == 1 + assert 'ExpeditionPCB.exe' in messages[0] + assert 'icdbserver.exe' not in messages[0] + assert '服务器' in messages[0] + dialog.plan['sessions'] = [rows[0]] + dialog._finished() + assert not dialog.force_button.isEnabled() + + def test_released_batch_can_resume_only_its_unexecuted_items(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window from cbb_refresh_verify.verify_runner import VerifyResult diff --git a/tests/test_residual_sessions.py b/tests/test_residual_sessions.py index ceadb17..c542975 100644 --- a/tests/test_residual_sessions.py +++ b/tests/test_residual_sessions.py @@ -4,6 +4,9 @@ from types import SimpleNamespace import pytest +OWNERSHIP = {"owner_sid": "S-1-current", "session_id": 1, "force_user_confirmed": True} + + def api(): from cbb_refresh_verify import library_lock inspect = getattr(library_lock, 'inspect_residual_sessions', None) @@ -24,7 +27,7 @@ def test_preview_limits_to_selected_projects_and_keeps_process_identity(tmp_path a = library.parent/'ReusableBlocksLP/A/Work/A.prj' b = library.parent/'ReusableBlocksLP/B/Work/B.prj' monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [row(10, a), row(20, b)]) - monkeypatch.setattr(sessions, '_process_identity', lambda r: {'created_handle': r['created'], 'image': r['executable']}) + monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': r['created'], 'image': r['executable']}) monkeypatch.setattr(sessions, '_process_windows', lambda pids: {p: [] for p in pids}) result = inspect(library, block_names=('A',)) assert [r['pid'] for r in result['sessions']] == [10] @@ -38,7 +41,7 @@ def test_unknown_scope_is_visible_but_never_closed_even_with_force(tmp_path, mon process['name'] = 'LibraryManager.exe' monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process]) monkeypatch.setattr(sessions, '_process_windows', lambda _: {}) - monkeypatch.setattr(sessions, '_process_identity', lambda r: {'created_handle': 'old', 'image': r['executable']}) + monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']}) plan = sessions.inspect_residual_sessions(library) assert plan['sessions'] and plan['sessions'][0]['scope_confirmed'] is False monkeypatch.setattr(sessions, '_request_close', lambda *a, **kw: pytest.fail('closed unknown scope')) @@ -74,7 +77,7 @@ def test_confirmation_rechecks_pid_reuse_and_never_posts_to_replacement(tmp_path library = tmp_path/'lib.lmc'; library.touch() process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj') monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()]) - monkeypatch.setattr(sessions, '_process_identity', lambda r: {'created_handle': 'old', 'image': r['executable']}) + monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']}) monkeypatch.setattr(sessions, '_process_windows', lambda _: {10: []}) plan = inspect(library) process['created'] = 'replacement' @@ -91,7 +94,7 @@ def test_close_requests_cover_whole_preview_and_failures_remain_per_item(tmp_pat library = tmp_path/'lib.lmc'; library.touch() rows = [row(p, tmp_path/f'ReusableBlocksLP/{p}/Work/{p}.prj') for p in (10, 20)] monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: rows) - monkeypatch.setattr(sessions, '_process_identity', lambda r: {'created_handle': r['created'], 'image': r['executable']}) + monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': r['created'], 'image': r['executable']}) monkeypatch.setattr(sessions, '_process_windows', lambda _: {}) calls = [] monkeypatch.setattr(sessions, '_request_close', lambda r, *_, **kw: calls.append(r['pid']) or @@ -146,7 +149,7 @@ def test_force_requires_separate_explicit_argument_and_rechecks_identity(tmp_pat library = tmp_path/'lib.lmc'; library.touch() process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj') monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()]) - monkeypatch.setattr(sessions, '_process_identity', lambda r: {'created_handle': 'old', 'image': r['executable']}) + monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']}) monkeypatch.setattr(sessions, '_process_windows', lambda _: {}) monkeypatch.setattr(sessions, '_request_close', lambda *a, **k: {'release_status': 'WAITING', 'detail': 'hung'}) forced = [] @@ -163,14 +166,125 @@ def test_force_requires_separate_explicit_argument_and_rechecks_identity(tmp_pat assert forced == [10] +@pytest.mark.parametrize('name', ['icdbnetserver.exe', 'icdbserver.exe', + 'ReuseBlockImporter.exe', 'wscript.exe']) +def test_force_preserves_servers_and_unsupported_processes_even_with_confirmed_scope(tmp_path, monkeypatch, name): + from cbb_refresh_verify import residual_sessions as sessions + library = tmp_path/'lib.lmc'; library.touch() + process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj', name=name) + monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()]) + monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']}) + monkeypatch.setattr(sessions, '_process_windows', lambda _: {}) + monkeypatch.setattr(sessions, '_force_close', lambda *a, **kw: pytest.fail('protected process was force terminated')) + plan = sessions.inspect_residual_sessions(library) + assert plan['sessions'][0]['scope_confirmed'] + result = sessions.release_residual_sessions(plan, tmp_path.parent/'release-evidence'/tmp_path.name, force=True) + assert result['status'] == 'PARTIAL' + assert result['sessions'][0]['release_status'] == 'WAITING' + assert result['sessions'][0]['force_allowed'] is False + + +@pytest.mark.parametrize('name', ['icdbserver.exe', 'cdbsvr.exe', 'python.exe']) +def test_direct_force_cannot_request_a_terminate_handle_for_database_server(monkeypatch, name): + from cbb_refresh_verify import residual_sessions as sessions + process = {'pid': 10, 'name': name, 'scope_confirmed': True, + 'image': 'C:/Mentor/'+name, 'created_handle': 'creation'} + monkeypatch.setattr(sessions, '_process_handle', lambda *a, **kw: pytest.fail('opened terminate-capable server handle')) + assert sessions._force_close(process)['release_status'] == 'WAITING' + + +def test_force_writes_exact_consent_before_any_native_action(tmp_path, monkeypatch): + import json + from cbb_refresh_verify import residual_sessions as sessions + library = tmp_path/'lib.lmc'; library.touch() + process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj', name='ExpeditionPCB.exe') + monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()]) + monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']}) + monkeypatch.setattr(sessions, '_process_windows', lambda _: {}) + evidence = tmp_path.parent/'release-evidence'/tmp_path.name + def force(actual, **kwargs): + consent = json.loads(next(evidence.glob('sessions-*/consent.json')).read_text(encoding='utf-8')) + assert consent['library'] == str(library.resolve()) + assert consent['mode'] == 'force_document_clients' + assert consent['sessions'][0]['pid'] == actual['pid'] + assert consent['sessions'][0]['created_handle'] == actual['created_handle'] + return {'release_status': 'WAITING', 'detail': 'not exited'} + monkeypatch.setattr(sessions, '_force_close', force) + plan = sessions.inspect_residual_sessions(library) + result = sessions.release_residual_sessions(plan, evidence, force=True) + assert Path(result['consent_path']).is_file() + assert result['status'] == 'PARTIAL' + + +def test_unwritable_force_consent_prevents_all_native_actions(tmp_path, monkeypatch): + from cbb_refresh_verify import residual_sessions as sessions + library = tmp_path/'lib.lmc'; library.touch() + process = row(10, tmp_path/'ReusableBlocksLP/A/Work/A.prj', name='ExpeditionPCB.exe') + monkeypatch.setattr(sessions, 'query_process_snapshot', lambda: [process.copy()]) + monkeypatch.setattr(sessions, '_process_identity', lambda r: {**OWNERSHIP, 'created_handle': 'old', 'image': r['executable']}) + monkeypatch.setattr(sessions, '_process_windows', lambda _: {}) + plan = sessions.inspect_residual_sessions(library) + original = Path.open + def deny(path, *args, **kwargs): + if path.name == 'consent.json': raise PermissionError('cannot record consent') + return original(path, *args, **kwargs) + monkeypatch.setattr(Path, 'open', deny) + monkeypatch.setattr(sessions, '_force_close', lambda *a, **kw: pytest.fail('termination preceded durable consent')) + with pytest.raises(PermissionError, match='cannot record consent'): + sessions.release_residual_sessions(plan, tmp_path.parent/'release-evidence'/tmp_path.name, force=True) + + def test_current_process_handle_identity_uses_real_windows_api(): import os from cbb_refresh_verify.residual_sessions import _process_identity identity = _process_identity({'pid': os.getpid()}) assert identity['created_handle'] and Path(identity['image']).is_file() + assert identity['owner_sid'].startswith('S-1-') + assert isinstance(identity['session_id'], int) + assert identity['force_user_confirmed'] is True -def test_force_checks_exact_handle_before_ending_owned_test_helper(): +@pytest.mark.parametrize('ownership', [{}, {'owner_sid': 'S-1-other', 'session_id': 1, + 'force_user_confirmed': False}]) +def test_force_never_opens_terminate_handle_without_current_user_and_session(monkeypatch, ownership): + from cbb_refresh_verify import residual_sessions as sessions + process = {'pid': 10, 'name': 'ExpeditionPCB.exe', 'scope_confirmed': True, + 'created_handle': 'creation', 'image': 'C:/Mentor/ExpeditionPCB.exe', **ownership} + monkeypatch.setattr(sessions, '_process_handle', lambda *a, **kw: pytest.fail('opened unowned process')) + assert sessions._force_close(process)['release_status'] == 'WAITING' + + +@pytest.mark.parametrize('other_user,other_session', [(True, False), (False, True), (False, False)]) +def test_force_ownership_checks_user_sid_and_windows_session(monkeypatch, other_user, other_session): + import os + import win32api, win32process, win32security, win32ts + from cbb_refresh_verify import residual_sessions as sessions + closed = [] + monkeypatch.setattr(win32process, 'GetProcessId', lambda _: 10) + monkeypatch.setattr(win32api, 'GetCurrentProcess', lambda: 999) + monkeypatch.setattr(win32security, 'OpenProcessToken', lambda process, access: + SimpleNamespace(process=process, Close=lambda: closed.append(process))) + monkeypatch.setattr(win32security, 'GetTokenInformation', lambda token, kind: + ('other' if other_user and token.process == 123 else 'current', 0)) + monkeypatch.setattr(win32security, 'ConvertSidToStringSid', lambda sid: 'S-1-'+sid) + monkeypatch.setattr(win32ts, 'ProcessIdToSessionId', lambda pid: + 2 if other_session and pid != os.getpid() else 1) + assert sessions._force_ownership(123, 10)['force_user_confirmed'] is (not other_user and not other_session) + assert closed == [123, 999] + + +def test_unreadable_force_ownership_does_not_hide_cooperative_identity(monkeypatch): + from contextlib import nullcontext + from cbb_refresh_verify import residual_sessions as sessions + monkeypatch.setattr(sessions, '_process_handle', lambda _: nullcontext(123)) + monkeypatch.setattr(sessions, '_handle_identity', lambda _: {'created_handle': 'creation', 'image': 'pcb.exe'}) + def denied(*args): raise PermissionError('token inaccessible') + monkeypatch.setattr(sessions, '_force_ownership', denied) + identity = sessions._process_identity({'pid': 10}) + assert identity['created_handle'] == 'creation' and identity['force_user_confirmed'] is False + + +def test_force_refuses_actual_unsupported_test_helper(): import subprocess import sys from cbb_refresh_verify.residual_sessions import _process_identity, _force_close @@ -178,16 +292,36 @@ def test_force_checks_exact_handle_before_ending_owned_test_helper(): creationflags=subprocess.CREATE_NO_WINDOW) try: process = {'pid': child.pid, **_process_identity({'pid': child.pid})} - changed = {**process, 'created_handle': 'different process'} - assert _force_close(changed)['release_status'] == 'IDENTITY_CHANGED' + assert _force_close(process)['release_status'] == 'WAITING' assert child.poll() is None - assert _force_close(process)['release_status'] == 'RELEASED' - assert child.wait(3) == 1 finally: if child.poll() is None: child.terminate(); child.wait(3) # This test's sleep-only helper. +def test_supported_force_revalidates_exact_handle_before_termination(monkeypatch): + from contextlib import nullcontext + import win32api, win32con, win32event + from cbb_refresh_verify import residual_sessions as sessions + process = {'pid': 10, 'name': 'ExpeditionPCB.exe', 'scope_confirmed': True, + 'created_handle': 'creation', 'image': 'C:/Mentor/ExpeditionPCB.exe', **OWNERSHIP} + monkeypatch.setattr(sessions, '_process_handle', lambda *a, **kw: nullcontext(123)) + monkeypatch.setattr(sessions, '_handle_identity', lambda _: { + 'created_handle': 'creation', 'image': 'C:/Mentor/ExpeditionPCB.exe'}) + monkeypatch.setattr(win32event, 'WaitForSingleObject', lambda handle, timeout: + win32con.WAIT_OBJECT_0 if timeout else win32con.WAIT_TIMEOUT) + monkeypatch.setattr(sessions, '_force_ownership', lambda *args: dict(OWNERSHIP)) + calls = [] + monkeypatch.setattr(win32api, 'TerminateProcess', lambda handle, code: calls.append((handle, code))) + assert sessions._force_close({**process, 'created_handle': 'reused'})['release_status'] == 'IDENTITY_CHANGED' + assert not calls + assert sessions._force_close({**process, 'session_id': 2})['release_status'] == 'IDENTITY_CHANGED' + assert sessions._force_close({**process, 'owner_sid': 'S-1-other'})['release_status'] == 'IDENTITY_CHANGED' + assert not calls + assert sessions._force_close(process)['release_status'] == 'RELEASED' + assert calls == [(123, 1)] + + def test_partial_desktop_enumeration_never_offers_normal_close(monkeypatch): import win32gui, win32service from cbb_refresh_verify.residual_sessions import _process_windows, close_target