From 466f400514acc8531a219db8e75641be35304a3f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Thu, 12 Nov 2026 16:02:53 +0800 Subject: [PATCH] fix: scope release proofs and bind PCB opening consent --- docs/releases/2026-11-12-blockers-and-flow.md | 233 ++++++++++++++++++ ...1-12-misclassification-and-optimization.md | 71 ++++++ .../2026-11-12-process-origin-audit.md | 39 +++ .../2026-11-12-scoped-release-validation.json | 61 +++++ .../2026-11-12-scoped-release-validation.md | 52 ++++ ...6-11-12-scoped-release-and-user-consent.md | 13 + src/cbb_refresh_verify/backup_recovery.py | 7 +- src/cbb_refresh_verify/dialog_agent.py | 8 + src/cbb_refresh_verify/library_lock.py | 42 +++- src/cbb_refresh_verify/management.py | 22 +- .../native_engineering_identity.py | 70 +++++- src/cbb_refresh_verify/native_export_guard.py | 30 ++- src/cbb_refresh_verify/operation_lifecycle.py | 46 ++++ src/cbb_refresh_verify/pcb_open_consent.py | 154 ++++++++++++ src/cbb_refresh_verify/pcb_restore_prompt.py | 32 ++- src/cbb_refresh_verify/residual_sessions.py | 14 +- src/cbb_refresh_verify/session_record.py | 11 +- .../ui/backup_recovery_dialog.py | 6 +- src/cbb_refresh_verify/ui/icdb_check_task.py | 6 +- src/cbb_refresh_verify/ui/main_window.py | 23 +- .../ui/management_dialog.py | 14 ++ src/cbb_refresh_verify/ui/pcb_open_dialog.py | 21 ++ .../ui/residual_release_dialog.py | 12 +- src/cbb_refresh_verify/verify_runner.py | 33 ++- tests/test_batch_item_yield.py | 100 ++++++++ tests/test_external_owner_release.py | 54 ++++ tests/test_late_release_continuation.py | 28 +++ tests/test_library_lock.py | 25 +- tests/test_native_engineering_identity.py | 42 ++++ tests/test_native_export_guard.py | 23 ++ tests/test_pcb_open_consent.py | 114 +++++++++ tests/test_residual_sessions.py | 3 +- tests/test_session_record.py | 10 + 33 files changed, 1358 insertions(+), 61 deletions(-) create mode 100644 docs/releases/2026-11-12-blockers-and-flow.md create mode 100644 docs/releases/2026-11-12-misclassification-and-optimization.md create mode 100644 docs/releases/2026-11-12-process-origin-audit.md create mode 100644 docs/releases/2026-11-12-scoped-release-validation.json create mode 100644 docs/releases/2026-11-12-scoped-release-validation.md create mode 100644 docs/superpowers/plans/2026-11-12-scoped-release-and-user-consent.md create mode 100644 src/cbb_refresh_verify/pcb_open_consent.py create mode 100644 src/cbb_refresh_verify/ui/pcb_open_dialog.py create mode 100644 tests/test_batch_item_yield.py create mode 100644 tests/test_external_owner_release.py create mode 100644 tests/test_late_release_continuation.py create mode 100644 tests/test_pcb_open_consent.py diff --git a/docs/releases/2026-11-12-blockers-and-flow.md b/docs/releases/2026-11-12-blockers-and-flow.md new file mode 100644 index 0000000..d4b7bfd --- /dev/null +++ b/docs/releases/2026-11-12-blockers-and-flow.md @@ -0,0 +1,233 @@ +# 当前程序流程、阻塞点与错误节点 + +> 这是修改前 `42d0ceb` 的流程快照。后续修复及真实复测见 [占用范围验证](2026-11-12-scoped-release-validation.md)。 + +依据提交 `42d0cebc54191681b53dcecb120f53236c1963bb` 的代码及 2026-11-12 冻结程序原生验收记录。本文件只分析当前行为,没有实施下面建议的调整,也没有新增原生验收。 + +后续只读核查已用外部软件自身日志确认 E01 的两个未知阻塞进程来自 DxPartReplace 测试,创建时间、父进程和私有桌面交叉匹配;外部工程引用原库,本次 CBB 验收使用隔离库。详见 [进程来源核查](2026-11-12-process-origin-audit.md)。这进一步确认了并行软件触发本程序范围判定漏洞,不能将其解释成本程序自身客户端未退出。 + +红色 E 节点表示真实验收已经发生、仍未解决的问题;橙色 B 节点表示代码中确实存在的等待、拒绝或失败分支,但不表示每个条件都已复现;绿色 F 表示本轮修复并复测通过的位置。各入口在 UI 中独立,底层原生调用仍共享串行通道。 + +## 一、最需要处理的阻塞链 + +```mermaid +flowchart LR + A[单个 CBB 失败或被停止] --> B[PCB 或助手未确认退出] + B --> C[safe_to_continue 为 false] + C --> D[B02 同库后续项被跳过] + C --> E[B01 后续任务等待库可用] + E --> F[用户打开释放窗口] + F --> G[正常关闭本工具 PCB] + G --> H[E01 其他任务的未知会话也被纳入必须退出的集合] + H --> I[整库释放仍为 PARTIAL] + I --> E + classDef error fill:#fee2e2,stroke:#dc2626,color:#7f1d1d + classDef risk fill:#fff3cd,stroke:#d97706,color:#78350f + class H,I error + class D,E risk +``` + +这条链中的核心缺陷是:**当前项是否失败、当前项是否留下占用、整个库能否继续、其他工具是否正在运行,没有彻底分开。** 某项失败但 `safe_to_continue=true` 时,当前代码会继续处理下一项,真实多来源新增已验证这一点;`false` 则会阻止同库后续项,不能称为“所有失败都不会影响整批”。 + +## 二、阻塞与失败清单 + +| 标记 | 发生位置与触发条件 | 当前后果、影响范围 | 证据与处理方向 | +| --- | --- | --- | --- | +| **E01 已复现、未修复** | 释放集合包含 scope_confirmed=false 的其他任务进程;释放函数要求全部观察项 RELEASED;底层证明也把没有目标路径的进程作为可能占用 | 本工具 PCB 已退出,整库仍 PARTIAL;保留状态无法清除,同库后续任务继续等或被跳过 | R7 的 PCB 21856/21248 均退出;其他任务 viewdraw 29832 为 WAITING。必须区分观察项与本库目标,并用目标资源证明决定能否继续,不能直接结束其他任务 | +| **E02 已复现、未走通** | PCB 启动出现原生“确认无其他用户,以读写权限继续”提示 | 当前打开判为 DATABASE_SAFETY_STOP;普通校验未 READY,ICDB 检查无法确认,备份副本不安装。关闭成功时本项失败仍可安全继续 | 该正文不直接证明 ICDB 损坏。代码有受限的修复后授权分支,但不是普通打开时通用的用户确认入口 | +| **E03 已复现、未修复** | A/B 来源工程的原生 EDIF 导出器退出 0xC0000005 | 本项上传失败;退出及资源释放证明成功后下一项继续,不能跳过身份比对报告成功 | 相同批次 C 能新增成功。需进一步定位原生导出与输入兼容性 | +| **B01 可长期排队** | NativeQueue 没有排队总超时;等待 active=false 且本库 library_available=true | UI 线程保持运行,但普通校验、管理、刷新等任务可能一直显示等待;可取消排队。活动任务未返回时,即使不同库也不能使用同一个原生通道 | 属于后台任务等待,不等于界面卡死;不同库且条件满足的票据可以越过暂不可用票据。需要展示等待对象、阶段及下一步,而不是单一“忙” | +| **B02 失败传播到同库** | run_batch、run_management_batch、IcdbCheckTask 遇 safe_to_continue=false;未知异常也可能保守置 false | 同库后续项 SKIPPED;其他库不因这个集合被跳过;CANCELLED/QUEUE_STOP 或用户停止会停止余下队列 | 现有规则确实仍会让单项占用影响本库整批。后续需分辨仅此工程占用与共享库占用,不能盲目把 false 改 true | +| **B03 执行互斥与协调锁** | Windows 会话级 Local/CbbRefreshVerify795 被占用;库协调锁被持有;历史 blocked/pending 记录存在或身份不符 | 直接拒绝本次操作,或先复核旧记录;未确认时保留本库协调锁/记录 | 多个应用实例、独立上传工具、崩溃遗留均可能触发。历史记录本身不是仍在写库的证明 | +| **B04 地址、数据库、在途调用** | 存在 sAddress.adr;数据库/LMC/Layout 独占读失败;仍有本库原生写入或导出副本所有者 | 当前操作或释放证明失败;真实在途写入应继续保护。陈旧地址和不完整日志也可能导致无法确认 | 当前主要哈希排除地址文件,但占用判断仍会使用它们;不能用“哈希忽略了”推断“占用也已忽略” | +| **B05 原生调用未返回** | Add/Remove/COM 调用或原生进程超过监督时限 | 有些监督入口返回超时并保留真实 worker;真实写入继续观测;CleanWGLib 超时后仍等待其自然退出,不能把超时当释放 | 可能同时占着执行通道、库锁或保留状态。需要区分取消未开始项、请求原生取消、仍在写入、可以关闭的客户端 | +| **B06 原生版本窗口仍打开** | iCDB Project Backup 原生窗口尚未关闭,或关闭结果未确认 | 同库校验/恢复受到限制;同库 ICDB 后台检查会暂停,关闭并确认后恢复;不是自动修复失败 | 这是实际原生编辑会话的互斥。不能通过关闭应用或删除记录假装窗口已关闭 | +| **B07 格式、能力与来源校验** | 缺失/越界引用、不支持的版本或接口、目标分区不唯一、来源同名不匹配、未完成变更记录仍需恢复 | 本项拒绝;新增遇同名冲突明确失败;未完成写操作不会在重启后自动重放 | 这些多数属于输入/恢复边界;要给出具体原因和可纠正入口,不能混成 ICDB 问题 | +| **B08 来源/目标内容变化** | 暂存复制前后文件集合或主要哈希变化;基线后中心库更新;恢复前来源或目标变化 | 停止当前写入或恢复。更新已 Remove 但尚未 Add 成功时可能 RECOVERY_REQUIRED | 应保留阶段、原 Work 或人工备份路径;不能把部分成功视为整体成功 | +| **B09 权威状态与工程身份** | 保存/关闭失败;注册内容不符;中心库复读失败;校验后不是 GREEN/READY | 当前项不通过;是否影响后续取决于释放事实。上传成功可为 UPLOADED,但不等于 UPLOADED_VERIFIED | 不能仅以 PCB 窗口打开、COM 返回或文件目录存在判成功 | +| **B10 IO、路径与证据存储** | 网络盘不可见、路径映射失败、证据目录不可写、检查点变化、空间不足 | 读取/当前任务失败;关键写前检查点保存失败时不开始写入;某些辅助诊断写入失败只记录警告 | 网络/磁盘与原生数据库错误要分开报告;恢复需先复制验证库,因此有实际容量和耗时 | +| **B11 程序关闭等待** | 关闭时检查仍活动、当前任务仍忙、线程池或路径租约操作仍未结束 | 首次关闭可能只请求停止;进入关闭流程后等线程池/租约结束,代码没有统一关闭总超时 | R7 正常退出通过,不代表 COM 永久不返回场景也能退出;需要单独验收这一条件 | +| **F01 已修复复测** | 原生私有桌面 GetThreadDesktop 拒绝访问;重新 OpenDesktop 后 HWND 不可读 | 之前误报窗口归属变化,无法正常释放 | 已改为有界桌面枚举、映射窗口后再核对 PID,真实 PCB 正常取消退出通过 | +| **F02 已修复复测** | 状态刷新期间结果窗口的释放按钮仍可点击,函数因 busy 直接返回 | 之前按钮点击无窗口 | 已跟随 busy/排队目标更新,R7 先禁用后可用,点击能打开释放窗口;不等于 E01 已解决 | + +另有 **P2 结果展示错误**:释放数量包含自然退出且未允许操作的观察项,因此出现“已释放 4 个,确认允许 2 个”。这是统计问题,不是解除占用的证明。 + +## 三、完整业务流程总图 + +下图按实际任务边界展开:所有菜单可以独立提交请求;排队串行的是 Mentor 原生操作。为保持图可读,把共享的 PCB 子流程和释放子流程放在后两张展开图中,节点 V、R 在各图中指向同一过程。 + +```mermaid +flowchart TD + START[启动桌面应用] --> INIT[配置日志、加载原生能力、异步发现未完成任务] + INIT --> LIB[选择中心库并建立路径映射 B10] + LIB --> READ[读取 CBB、工程文件及权威状态 B07 B09] + READ --> LIST[搜索、筛选、可见项勾选] + LIST --> OP{选择独立操作入口} + + OP --> VERIFY[检验:只取可见非 READY 项] + OP --> CHECK[ICDB 批量检查:只取可见非 READY 项] + OP --> HISTORY[版本历史与备份:单个非 READY 项] + OP --> RECOVER[从完整工程备份恢复:非 READY 项] + OP --> MANAGE[中心库管理:READY 可更新或移除] + OP --> R[释放残留:进入释放子流程] + + VERIFY --> CONFIRM[显示目标与确认;写操作提示人工备份] + CHECK --> CONFIRM + HISTORY --> ADMIT + RECOVER --> CONFIRM + MANAGE --> CONFIRM + CONFIRM --> ADMIT[原生队列准入 B01:可取消;按目标库保留状态判断] + ADMIT --> DISPATCH{任务类型} + DISPATCH -->|普通校验| V[共享 PCB 打开、弹窗、校验、关闭子流程 E02] + DISPATCH -->|检查| CITEM[每项重新判断 READY 和内容是否更新] + CITEM -->|应跳过| RESULT + CITEM -->|应检查| CV[调用 V;仅诊断打开,不保存校验、不 Repair] + CV --> CLASSIFY{本次错误正文含 ICDB 特征吗} + CLASSIFY -->|正常打开并关闭| CLEAN[CHECKED;不等于 READY] + CLASSIFY -->|含有特征| ICERR[报告 ICDB 问题;不执行自动修复] + CLASSIFY -->|其他弹窗或无法打开| UNCERTAIN[无法确认;保留原错误 E02] + CLEAN --> RESULT + ICERR --> RESULT + UNCERTAIN --> RESULT + + DISPATCH -->|版本管理| HOPEN[绑定工程后打开原生备份窗口 B06] + HOPEN --> HUSER[用户查看、创建备份或选择版本回退] + HUSER --> HCLOSE[等待窗口正常关闭、释放结果及状态复读 B06 B09] + HCLOSE --> RESULT + + DISPATCH -->|备份恢复| BVALID[来源身份、路径、文件、空间检查 B07 B10] + BVALID --> BCOPY[复制隔离验证库与备份工程 B08] + BCOPY --> BV[调用 V:在副本校验 E02] + BV --> BOK{PASS、GREEN 且安全释放} + BOK -->|否| BUNCHANGED[恢复失败;目标不安装] + BOK -->|是| BCOMPARE[复核来源和目标未变化 B08] + BCOMPARE --> INSTALL[旧 Work 改名保留,再安装副本 B08 B10] + INSTALL --> TV[调用 V:重新打开实际目标 B09] + TV --> RESULT + BUNCHANGED --> RESULT + + DISPATCH -->|管理| MPRE[原生能力、来源、历史任务、库锁检查 B03 B07] + MPRE --> MCAT[原生目录复读并核对名称和分区 B09] + MCAT --> MBASE[记录内容基线;来源工程复制暂存 B08] + MBASE --> MOP{新增、更新或移除} + MOP -->|新增或更新| EXPORT[原生 ASCII、CSV、EDIF 身份导出 E03] + EXPORT --> MWRITE[新增 Add;更新 Remove 后 Add B05 B08] + MOP -->|移除| REMOVE[原生 Remove B05] + MWRITE --> MREAD[目录复读、内容身份及释放核对 B09] + REMOVE --> MREAD + MREAD --> AUTO{新增或更新启用自动校验吗} + AUTO -->|是| MV[调用 V 进行校验;上传成功与校验成功分别记录] + AUTO -->|否或移除| RESULT + MV --> RESULT + + V --> RESULT[逐项记录结果、阶段、证据与释放事实] + RESULT --> SAFE{safe_to_continue} + SAFE -->|true| NEXT[继续下一项;ICDB 检查在每项之间让出原生队列] + SAFE -->|false| RETAIN[B02 保留本库会话状态;同库余项跳过] + RETAIN --> R + NEXT --> MORE{还有任务且未停止吗} + MORE -->|是| ADMIT + MORE -->|否| REFRESH[刷新受影响条目的权威状态 B09;生成报告 B10] + REFRESH --> LIST + R -->|证明成功| RESUME[清理本库保留状态;必要时用户继续未执行项] + R -->|未确认 E01| RETAIN + RESUME --> LIST + LIST -->|关闭应用| EXIT[停止当前任务并等待线程池、租约结束 B11] + EXIT --> END[程序退出] + + classDef error fill:#fee2e2,stroke:#dc2626,color:#7f1d1d + classDef risk fill:#fff3cd,stroke:#d97706,color:#78350f + classDef good fill:#dcfce7,stroke:#16a34a,color:#14532d + class V,CV,UNCERTAIN,BV,EXPORT,R error + class LIB,READ,ADMIT,HOPEN,HCLOSE,BVALID,BCOPY,BCOMPARE,INSTALL,TV,MPRE,MCAT,MBASE,MWRITE,REMOVE,MREAD,RETAIN,REFRESH,EXIT risk + class CLEAN,RESUME good +``` + +图中的“回到队列”是下一次任务准入的概览:当前普通校验和管理批次在批次外围占用队列;ICDB 检查每完成一个 CBB 才释放并重新排队,不能理解为三种批次都已经逐项让出通道。读取/状态刷新也会使用原生队列,纯内存搜索与筛选不启动 Mentor。 + +## 四、共享 PCB 任务展开图 V + +```mermaid +flowchart TD + V[开始:普通校验、检查或恢复副本校验] --> GATE[取得会话互斥、复核历史释放、取得库锁 B03 B04] + GATE --> PRE[检查 PRJ、PCB、依赖和证据目录 B07 B10] + PRE --> CONTENT{普通校验且配置了额外内容检查吗} + CONTENT -->|是| EXTRA[Importer 内容检查;失败结束本项] + CONTENT -->|否| LAUNCH + EXTRA -->|通过| LAUNCH[创建私有桌面与监督 worker;启动 PCB B05] + EXTRA -->|失败| FAILURE + LAUNCH --> OPEN{原生打开结果} + OPEN -->|读写确认提示| PERMISSION[E02 普通入口缺少通用授权交互;当前安全停止] + OPEN -->|可识别版本选择| VERSION[用户选最后手动保存、自动保存或取消;适用入口才提供] + OPEN -->|其他错误或未知弹窗| FAILURE[本项失败,记录实际文本或超时 B05] + OPEN -->|打开完成| MODE{仅诊断打开吗} + VERSION -->|可继续| OPEN + VERSION -->|取消| FAILURE + MODE -->|是| DIAG[证明目标已打开;请求关闭,不执行保存校验] + MODE -->|否| VERIFY[实际原生校验、保存、关闭 B05 B09] + VERIFY --> READY[中心库权威复读:必须 GREEN/READY B09] + PERMISSION --> CLOSE + FAILURE --> CLOSE + DIAG --> CLOSE[正常关闭、取消已知启动弹窗、释放 COM 和自动化助手] + READY --> CLOSE + CLOSE --> OWNERS[确认 worker、PCB、启动器和目标资源已释放 B04;桌面访问 F01 已修复] + OWNERS -->|成功| OUT[返回本项业务结果,safe_to_continue=true] + OWNERS -->|失败或无法确认| RETAIN[保留证据与会话,safe_to_continue=false,触发 B02] + classDef error fill:#fee2e2,stroke:#dc2626,color:#7f1d1d + classDef risk fill:#fff3cd,stroke:#d97706,color:#78350f + class PERMISSION error + class GATE,PRE,LAUNCH,FAILURE,VERIFY,READY,OWNERS,RETAIN risk +``` + +普通校验和检查都不默认启动自动 Repair。仓库中仍保留修复与修复后授权代码,但当前桌面批量检查路径明确关闭自动修复,不能把存在函数等同于产品入口已接通。 + +## 五、释放任务展开图 R + +```mermaid +flowchart TD + R[主窗口或结果窗口点击释放] --> UI[校验当前目标与按钮可用状态 F02 已修复] + UI --> SCAN[异步枚举进程、线程桌面、窗口、历史会话] + SCAN --> GROUP{能证明属于本库吗} + GROUP -->|是| TARGET[可确认的目标客户端] + GROUP -->|否| OBSERVE[归属未知,只允许观察] + TARGET --> CONSENT[用户确认正常关闭;可查看原生提示] + CONSENT --> ACTION[重新核对 PID、创建时间、映像、窗口后正常关闭 F01 已修复] + ACTION --> PROMPT{还有原生提示吗} + PROMPT -->|保存提示| SAVE[用户保存、放弃或保留;真实分支尚未完整验收] + PROMPT -->|支持取消的活动窗口| CANCEL[确认后请求原生 Cancel;不当成取消已完成] + PROMPT -->|无| EXITCHECK + SAVE --> EXITCHECK[观察真实进程是否退出] + CANCEL --> EXITCHECK + EXITCHECK --> ALL{当前代码:所有观察项都 RELEASED 吗} + OBSERVE --> ALL + ALL -->|否| ERROR[E01 未归属本库的其他任务也会让整体 PARTIAL] + ALL -->|是| PROOF[持有证明句柄检查本库、共享库、地址、导出副本和在途调用 B04] + PROOF --> UNKNOWN[E01 底层仍可能把路径未知进程当候选占用] + UNKNOWN -->|不能证明| ERROR + UNKNOWN -->|证明成功| RECORD[归档匹配的历史记录,清理对应保留状态及映射] + RECORD --> RELEASED[RELEASE_CONFIRMED;允许重新尝试] + ERROR --> WAIT[B01 队列仍等或 B02 本库余项已跳过;显示残留原因] + WAIT -->|用户重新检查| SCAN + classDef error fill:#fee2e2,stroke:#dc2626,color:#7f1d1d + classDef risk fill:#fff3cd,stroke:#d97706,color:#78350f + classDef fixed fill:#dcfce7,stroke:#16a34a,color:#14532d + class ALL,ERROR,UNKNOWN error + class PROOF,WAIT,SAVE,CANCEL risk + class UI,ACTION,RELEASED fixed +``` + +强制结束是另一个需要确认的分支:只针对已确认归属、符合条件的客户端,不能结束数据库服务器或归属未知进程;本轮真实操作只验收了打开确认后取消,没有执行强制终止。它不会消除 E01,不能作为释放判断错误的替代方案。 + +## 六、代码位置与四层协调机制 + +| 机制 | 位置 | 控制范围 | +| --- | --- | --- | +| 原生队列 | `operation_queue.py:18`、`ui/main_window.py:844`、`ui/management_dialog.py:174` | 应用内一次执行一个原生任务;按库保留状态允许其他可运行票据越过等待项 | +| Windows 会话互斥 | `verify_runner.py:547`、`management.py:172`、`backup_recovery.py:145` | 同一 Windows 会话中的本工具原生调用;不是每工程独立互斥 | +| 库协调锁与历史阻止记录 | `library_lock.py:129`、`:443`、`:523` | 按中心库控制写入与释放;历史记录需复核,不能直接删除当成功 | +| 运行时保留状态 | `session_record.py:25`、`:236`、`:354`、`:443` | 原生队列准入、助手与客户端身份观测;日志阶段不等于真实进程状态 | +| 导出副本所有权 | `native_export_guard.py:10`、`native_engineering_identity.py:288` | 防止原生导出器仍持有分析副本时释放相关操作 | + +关键传播代码:`verify_runner.py:1294`、`management.py:430`、`ui/icdb_check_task.py:55`。E01 的双重判定:`residual_sessions.py` 中 `_release_residual_sessions` 的全部行 RELEASED 条件,以及 `library_lock.py:443` 的 `_prove_library_released`。E02:`dialog_rules.py:222`、`verify_runner.py:895`。E03:`native_engineering_identity.py:288`。退出等待:`ui/main_window.py:1709`。 + +建议处理顺序:**E01 的本库释放判定 → B02 的工程/共享库影响范围 → E02 的明确用户确认路径 → B01/B05/B11 的等待及停止结果 → E03 输入兼容性与剩余条件按钮原生验收**。这些是后续工作建议,未在本次流程整理中实施。 diff --git a/docs/releases/2026-11-12-misclassification-and-optimization.md b/docs/releases/2026-11-12-misclassification-and-optimization.md new file mode 100644 index 0000000..db3662e --- /dev/null +++ b/docs/releases/2026-11-12-misclassification-and-optimization.md @@ -0,0 +1,71 @@ +# 误判复核与优化顺序 + +> 这是当天早期的复核与建议;后续实施结果见 [占用范围验证](2026-11-12-scoped-release-validation.md),不将早期未通过项追记为成功。 + +依据 `42d0ceb` 的六处修复记录、真实冻结程序验收,以及 13:44–13:46 的外部进程归属交叉核对。本轮只做分类和优化建议,没有修改业务代码。统计单位是已知问题根因,不能据此估算整个程序的缺陷率。 + +## 已修复的六处问题 + +| 问题 | 复核分类 | 依据 | +| --- | --- | --- | +| 导出器退出期间 OpenProcess 返回 5,立即认为释放失败 | 误判/过早得出失败结论 | 原生退出竞争;需要继续观察新快照与目标文件,而不是只看一次权限错误。已修复并有真实导入/更新复测 | +| 无工程参数的外部 viewdraw 阻止备份入口 | 跨工程占用误判 | 未证明目标被占用;恢复入口已改为结合路径、地址与目标文件实际探测 | +| 历史 sAddress_.adr 不一致导致报告工程内容不同 | 内容校验范围误判 | 地址元数据不等于工程内容;完整复制保留,但主要内容哈希排除 | +| 旧工程没有辅助 PCB/pcb.prj 被报告备份不完整 | 工程格式误判 | PCB 唯一关联主 PRJ 的旧格式本身可用;已复用同一身份检查并真实进入副本校验 | +| 私有桌面窗口不可读,不能正常取消 PCB | 真实 Windows 接入缺陷 | 正常进程查询权限不等于可读外部桌面 HWND;已修复并真实关闭客户端 | +| 释放按钮可点击但 busy 导致处理函数直接返回 | 真实 UI 状态缺陷 | R6 原包实际点击无窗口,R7 新包先禁用再可用,实际打开窗口 | + +六处中四类属于误判/过严判断,两类属于真实功能缺陷。这里“误判”仍然是程序需要修复的缺陷,不表示可以撤销失败记录或补记验收成功。 + +## 当前剩余五类问题 + +| 类别 | 判定 | 是否仍需修改 | +| --- | --- | --- | +| 外部未知会话导致整库释放 PARTIAL | **已确认占用范围误判,1 个根因至少影响两道释放门禁** | 是,最高优先级;操作集合全退出判断与底层资源证明必须一起修正 | +| 显示释放 4 个,但确认允许操作只有 2 个 | **统计归因错误** | 是;区分本次请求关闭、实际退出、原已退出、外部只读观察,不混成主动释放数量 | +| PCB 读写确认挡住校验与备份恢复 | **原生提示真实发生,普通流程缺少相应确认路径;当前停止不等于检测错** | 是;明确用户授权、目标身份和实际占用核查;不能当 ICDB 损坏,也不能直接自动同意 | +| A/B 的原生 EDIF 导出崩溃 | **真实导出失败,输入/原生兼容性根因未定** | 是;保留错误码、输入及导出证据,独立复现,不绕过内容身份校验 | +| 条件按钮、现场失联副本、Win10 等未完成 | **验收缺口,不能记为已发生漏洞或误判** | 补真实覆盖;测试后再决定需要何种修改 | + +此前“本程序遗留会话导致释放不了”的描述需细化:本程序在停止启动过程中确实留下过两个 PCB 客户端,属于真实清理问题;正常关闭后,继续挡住整库确认的是外部软件。不能用后半段的误判抹去前半段实际残留,也不能把两者当成同一种“锁”。 + +## 优化顺序与验收条件 + +### P1:统一占用归属和资源范围 + +当前备份入口与整库释放入口使用不同的判断强度;一处已经按目标资源探测,另一处仍能因未知进程直接停止。应复用统一的“来源、目标范围、活动阶段、资源证据”判断,避免每个入口再次发明一套锁规则。 + +- 来源记录:创建时保存 PID、创建时间、映像、任务号、私有桌面、目标工程/库和父子关系;重启后按身份核对,不能仅凭 PID。 +- 范围判定:区分同工程、同库共享依赖、明确其他库、未知。由谁拉起与是否占用本库分别保存。 +- 观察项不自动变成阻止项。明确属于其他库的进程不要求退出;未知项展示不确定原因,继续取本库在途调用、目标文件/数据库、地址、必要原生读取等证据。证据不足不能猜测安全。 +- 不能只把 `scope is not False` 改成 `scope is True`,也不能只改“所有行退出”条件;否则可能放过真实打开同库的外部会话,或仍被底层第二道门禁挡住。 +- 目标文件独占打开只是证据之一,不单独保证原生接口、共享依赖和检查期间的状态均安全。后续写入前还需重新核对。 + +验收至少包括:其他软件开其他库且持续运行时,本库能正常完成操作;其他软件确实持有本库数据库时,本库拒绝相关写入;外部进程来源不明但目标文件无占用时,不能单凭进程名永久阻止;PID 被复用时不得操作新进程。 + +### P1:把单项失败与批次停止分开 + +现有一个 `safe_to_continue` 同时承载多种情况:当前项失败、当前工程占用、共享库写入未结束、释放证据不足。因此某个工程的问题容易扩大为整库不可用。 + +逐项保留业务结果,再明确能否继续及影响范围:仅当前工程、整个共享库、原生执行通道、用户主动停止。安全释放的失败项继续下一项;仅当前工程问题是否可绕过,需要以共享资源证据决定;共享写入未返回则继续保护。不要全局放开 false 或直接删历史记录。 + +验收要使用同一批次“坏工程 → 好工程”以及“共享库真实占用 → 后续写入不得开始”两个方向。现有真实多来源新增已通过前一方向的一种安全失败场景,不代表所有占用场景都通过。 + +### P1/P2:接通原生读写提示与非阻塞操作 + +普通校验、检查、恢复副本按操作目的决定是否允许读写授权,不复用只适用于修复后的隐式授权。识别精确提示后展示目标和选项,用户可继续、跳过、取消;等待用户决定时保持 UI 可用,并明确后续任务是否仍需等当前原生会话。检查流程不能因用户点击而悄悄变成自动修复。 + +队列、原生执行和关闭分别展示等待对象与阶段。取消排队立即生效;已进入原生写入时说明是否正在等待返回或支持原生取消。普通校验/管理当前在批次外层持有队列,评估能否在完整单项事务结束后让出通道,不在 Remove→Add 中间插入另一写任务。 + +### P2:结果和性能 + +- UI 使用“检测结果、操作结果、释放状态”分别表达,避免将“待用户确认”写成工程损坏,或将“上传成功”写成 READY。 +- 修正释放数字归因,报告观察项不增加本次主动释放数量。 +- 来源、版本、依赖等便宜的输入检查先做;只复查本次受影响工程和实际依赖。避免每个按钮都全局扫描并读取无关窗口。 +- 原生 EDIF 单独诊断;保存失败输入和退出码,让独立 CBB 继续,不能降低身份校验来消除报错。 + +### P2:真实并行与异常操作回归 + +保留其他软件测试作为并行验收条件,覆盖:外部独立工程持续打开、外部共享同库、检查中排队再取消、停止后立即释放、刷新时连续点击、版本窗口开关、断网、源文件变化、主程序关闭与重启后的 PID 复用。分别核查目标变更、真实进程退出、权威状态和剩余任务,而不是只看按钮恢复可用或 Python 测试通过。 + +当前最有价值的改动是修 E01 的作用范围与证据链,而不是继续增加更多全局拒绝条件。最终验收仍要求实际完整校验与恢复到 READY;本次分类没有补齐这一缺口。 diff --git a/docs/releases/2026-11-12-process-origin-audit.md b/docs/releases/2026-11-12-process-origin-audit.md new file mode 100644 index 0000000..a708d55 --- /dev/null +++ b/docs/releases/2026-11-12-process-origin-audit.md @@ -0,0 +1,39 @@ +# 阻塞进程来源核查 + +> 本文保留当时的只读归属结论;后续代码修改及试验见 [占用范围验证](2026-11-12-scoped-release-validation.md)。 + +2026-11-12 13:44–13:46 进行了只读核查。结论:此前阻止整库释放的两个未知会话来自 `dxdesigner-part-replacement` 测试,不是本 CBB 程序拉起;其他软件并行测试暴露了本程序的归属和释放判定漏洞。本次没有修改业务代码或关闭进程。 + +| 历史进程 | 归属证据 | 结论 | +| --- | --- | --- | +| viewdraw.exe,PID 29832,父进程 5940 | 外部工具 lifecycle.jsonl 记录 worker_started PID 5940;其 private-desktop.json 记录 cad_pid 29832、创建时间 2026-11-12 03:17:21.099 UTC、桌面 dx-f2b2947f8ab144e19760e4599fda3249,均与 CBB 残留快照一致;窗口工程位于外部工具 outputs 目录 | 外部工具创建的 DxDesigner | +| cscript.exe,PID 8652,父进程 5940 | 命令行运行外部工具 QuickPartReplace.vbs;对应任务 project-checkpoint.json 的工程和 cad_pid 29832 与窗口匹配 | 同一外部测试批次的脚本 | +| ExpeditionPCB.exe,PID 21856 / 21248 | 命令行明确为 CBB 隔离库 1GPHY_8212 的 PCB;父子链 30552 → 21856 → 21248;CBB 验收释放记录确认两项均 RELEASED | 本程序的客户端,已正常退出 | + +外部工程 CentralLibrary 指向 `F:/Sync Tool Skyworth/Work Maps/Skyworth_CBB_Lib/Mentor_lib_EE7.9/mentor_lib.lmc`。CBB 验收目标为 `F:/CbbAccept-20261112/library/native-add/fixture/mentor_lib.lmc`,二者不同。 + +13:44 的实时快照中,历史 PID 29832、8652 均已不存在,没有把新进程当成旧残留。当前另有真实父子链:DxPartReplace.exe 29436 → DxPartReplace.exe 16540 → cscript.exe 21364;父进程创建时间均早于子进程,映像和脚本均位于外部工具目录。此快照仅代表当时状态,PID 不能作为长期身份。 + +13:46 对本次隔离库的 LMC、icdb.dat、LayoutDB.lyt 共 12 个实际文件同时执行 GENERIC_READ、共享模式 0、OPEN_EXISTING 的只读独占打开,全部成功并关闭句柄;库内未发现 sAddress.adr。这证明当时这些目标文件没有阻止独占读的占用,不能倒推 11:28 的全部句柄状态。 + +## 逻辑漏洞所在 + +1. `library_lock._owner_matches_scope` 主要读取命令行中的 PRJ/PCB/LMC/数据库引用。裸 viewdraw.exe 和外部 QuickPartReplace.vbs 命令没有这些路径,均返回 None(UNKNOWN)。它没有在这里利用父进程批次记录、私有桌面或窗口工程身份进一步归属。 +2. `residual_sessions.inspect_residual_sessions` 的 `scope is not False` 将这两项 UNKNOWN 加入当前库残留观察列表;`scope_confirmed=false` 正确阻止关闭它们。 +3. `_release_residual_sessions` 又要求列表中全部行均为 RELEASED。这使“不能确认归属、不能操作的观察项”成为“当前库必须退出的对象”,结果一直 PARTIAL。 +4. 即使绕过上一层,`library_lock._prove_library_released` 仍将范围为 UNKNOWN 的候选进程加入 owners,可能在目标文件独占打开之前直接拒绝证明。 + +以历史真实命令行回放当前归属函数,两项均得到 UNKNOWN,和真实残留列表一致。不是用户并行测试不合规,而是程序把“未知来源”升级成了“目标库占用”。 + +修复需要分别保存**进程来源**和**资源范围**:本程序创建的进程未必仍占目标;其他软件创建的进程也可能实际打开同一个库。因此不能只按进程名、父 PID 或软件目录粗暴排除外部进程,最终应结合创建时间绑定的身份、实际工程/库引用、本库在途调用、目标资源与地址探测决定是否阻止。外部归属只读展示,不自动结束;真实共享目标占用仍需保护。 + +## 证据 + +- 本机完整核查:`F:\CbbAccept-20261112\process-origin-audit.json`。 +- 身份交叉核对、外部证据 SHA-256、分类回放及只读资源探测:`F:\CbbAccept-20261112\process-origin-confirmed.json`。 +- 外部工具自身记录根目录:`F:\Sync Tool Skyworth\Work Maps\dxdesigner-part-replacement\outputs\frozen-random-final-20261112-r4`。 +- 父 worker 记录:`data/batch-resources/28182d59cb9d4e0087fa312baf11d804/lifecycle.jsonl` 第 2 行。 +- 原生进程创建身份:该批次 `generation-1/private-desktop.json`。 +- 对应工程:`data/tasks/4f49b13e-3603-4578-b7f2-c9fe88bca864/quick-run/project-checkpoint.json`。 + +这里只完成核查和归因,没有声称跨软件阻塞已修复。 diff --git a/docs/releases/2026-11-12-scoped-release-validation.json b/docs/releases/2026-11-12-scoped-release-validation.json new file mode 100644 index 0000000..92fe467 --- /dev/null +++ b/docs/releases/2026-11-12-scoped-release-validation.json @@ -0,0 +1,61 @@ +{ + "schema_version": 1, + "time": "2026-11-12T16:00:50.172809+08:00", + "bundle": { + "module_count": 64, + "source_and_frozen_code_equal": true, + "source_sha256_checked": true, + "packaged_assets_equal": true, + "exe_icon_images_equal": true, + "executable_sha256": "85ec649c18fefcf50d8b4caf0a66005f108713e7d5f170d1aecc82e3c5fcfe33" + }, + "tests": { + "passed": 1880, + "failures": 0, + "errors": 0, + "xml": "F:\\CbbAccept-20261112\\full-scoped-final10.xml" + }, + "recovery": { + "path": "F:\\CbbAccept-20261112\\scoped10-data\\evidence\\backup-restore-5f9b134ab83c\\recovery-result.json", + "installed": true, + "source_status": "PASS", + "target_status": "PASS", + "library_flag": "GREEN", + "safe_to_continue": true, + "retained_work": "F:\\CbbAccept-20261112\\field-lib-recovery\\ReusableBlocksLP\\1GPHY_8212\\Work.before-restore-5f9b134ab83c" + }, + "release": { + "path": "F:\\CbbAccept-20261112\\scoped10-data\\release-checks\\sessions-fc23a2a2024f\\result.json", + "status": "RELEASE_CONFIRMED" + }, + "original_integrity": { + "time": "2026-11-12T16:00:19", + "results": [ + { + "scope": "A", + "source": "F:\\Sync Tool Skyworth\\Work Maps\\Skyworth_CBB_Lib\\CBB\\1GPHY_RTL8211F", + "checked": 187, + "changes": [] + }, + { + "scope": "B", + "source": "F:\\Sync Tool Skyworth\\Work Maps\\Skyworth_CBB_Lib\\CBB\\1GPHY_RTL8211F_A", + "checked": 185, + "changes": [] + }, + { + "scope": "field-library-originals", + "source": "F:\\Sync Tool Skyworth\\Work Maps\\Skyworth_CBB_Lib\\Mentor_lib_EE7.9", + "checked": 26887, + "changes": [] + } + ], + "originals_unchanged": true + }, + "interaction_log": "F:\\CbbAccept-20261112\\scoped10-accept.log", + "known_limits": [ + "Native shared-symbol server sometimes cannot remove its own address file after STOP; not bypassed.", + "Actual field server-session-loss recovery and Windows 10 acceptance remain unverified.", + "Automatic ICDB Repair remains disabled. No merge, release or issue closure." + ] +} diff --git a/docs/releases/2026-11-12-scoped-release-validation.md b/docs/releases/2026-11-12-scoped-release-validation.md new file mode 100644 index 0000000..aa4d8df --- /dev/null +++ b/docs/releases/2026-11-12-scoped-release-validation.md @@ -0,0 +1,52 @@ +# 占用范围、单项队列及原生确认验证 + +本次基于 `42d0ceb`,沿用 `codex/runtime-lifecycle-safety`。当天较早的进程归属、误判分析和完整流程图是修改前快照;本记录描述后续实现及验收,不追溯改写先前失败。 + +## 修改 + +- 未确认归属的外部客户端只作观察,不要求其退出、不发送关闭,也不增加主动释放数量。释放仍检查本库在途调用、目标数据库地址和实际独占只读文件句柄;自身请求身份缺失、共享写入未返回时继续保护。 +- 旧 NATIVE_CALL/CLOSING/UNCONFIRMED 日志结合进程创建身份核实;已退出或 PID 被复用不会仅因日志阶段被认定仍在写入,读取失败保留未确认。 +- 单项失败后只对绑定任务取得新的释放证明;证明成功才允许后续项,原业务失败和原证据保留。校验和管理在完整单项事务结束后让出原生队列,不在移除与重新导入之间穿插其他任务。排队取消保留已完成项和汇总。 +- 普通校验、上传后的校验、备份副本/目标校验接通精确 PCB 读写提示和历史版本选择。用户可以继续、跳过、取消;绑定本任务 PCB 的创建身份、启动链、工程和私有桌面,临近点击重新检查。ICDB 诊断检查不借此执行 Repair 或隐式取得写入授权。 +- 实测新增修复:同名更新自动校验不再把自己当前的事务当成历史未释放事务。仅允许同线程、同 lease、同 PID、同目标及无待处理导出/检查点的嵌套调用。取消批次后不再把刷新排进已经取消的队列而丢失结果。 +- 第二轮真实试验暴露导出器进程链误判:CSV 导出器 PID 16068 创建于 14:56:19,却收录了 12:57:45 已创建的 OneDrive 服务 PID 23804。运行时追踪改为排除原有进程、绑定原生进程句柄创建时间、拒绝早于父进程的子进程及 PID 复用后的新进程链。旧记录复核也排除出生时间证明不可能属于导出任务的条目;仍需原生范围及分析副本数据库的全套释放证明,未发送退出请求给 OneDrive。 +- 失败释放复核包含在单项原生队列内部,完成后才让出通道,避免下一项开始时前一项又来争取管理互斥。新增两项回归先失败后通过,相关 46 项通过。 +- 普通读写确认比较真实控件的句柄、ID、类和正文,允许 UIA 后续增加已识别的标题栏辅助节点、重排控件及省略按钮快捷键标记;替换真实按钮仍拒绝。实际快照显示 Win32 的“是(&Y)”变成 UIA 的“是(Y)”,进程及窗口/按钮句柄均未变化;不能据此认定工程或窗口被替换。来自恢复副本真实失败的回归先失败后通过,相关 52 项通过。 + +## 冻结包和真实试验 + +当前候选程序:`F:\CbbAccept-20261112\candidate-scoped10\dist\CbbRefreshVerify-Background\CbbRefreshVerify.exe`。 + +SHA-256:`85ec649c18fefcf50d8b4caf0a66005f108713e7d5f170d1aecc82e3c5fcfe33`。64 个冻结模块逐个与当前源码编译结果一致,资源及 PE 图标一致;检查记录 `candidate-scoped10/bundle-verification.json`。较早的 scoped5 为 `4cf682130923c4534d3193a8b967ffc83d0cc519e580f6739a4861daed4f36c3`,scoped7 为 `e37b2601bb3851e9170ab8d552800547004b1a5b9882211f1180693dde76957c`,scoped9 为 `a59488dcbad72bdd7159772aabdb33b6411dea972babec33e64412a3406f810f`;各次动作日志绑定实际运行包哈希,不能混为同一版本。 + +原生写操作仅在 `F:\CbbAccept-20261112` 隔离库及工具生成的 `C:\Users\ABS_Windows\.cbb-restore` 校验副本中进行,环境为 Windows 11 build 26200、Mentor EE7.9.5 及私有桌面。操作驱动使用真实程序按钮和后台窗口消息,没有前台鼠标抢占、强杀原生客户端或手删地址文件。 + +| 试验 | 事实与证据 | +| --- | --- | +| 外部脚本持续存在,目标真实句柄被占用 | `scoped3-accept.log`:持有 LMC 的 Windows 独占句柄时拒绝释放,错误 32;外部脚本仍存活 | +| 目标句柄关闭,外部脚本继续运行 | 同一日志:RELEASE_CONFIRMED,主动释放 0、授权 0;外部行为保持 OBSERVED,脚本最后自行退出 | +| 同名更新并自动校验 | `management-38fdf8365d834a13ba7dca67111861ff/checkpoint.json`:UPLOADED_VERIFIED、safe=true;真实选择继续打开和最后手动保存版本;校验 InSynch、Save/IsSaved/Close、PCB EXITED,IsVerifiedReuseBlock=1/READY。校验约 91.6 秒 | +| 重复更新发现地址残留 | `management-0cee6b12e93b45918caf18101c603dc5/checkpoint.json`:RECOVERY_REQUIRED;原生移除已发生,重新导入未开始,不能记为成功 | +| 地址残留的原生证据 | 共享符号库服务器 PID 17344 日志记录 Database closed、defragmentation completed、Could not remove server address file、S: STOP;之后没有该服务器进程。`address-native-probe/result.json`:原生目录可复读,地址仍在、端点不可达;未将不可达视作无占用证明 | +| 早期空白库试验 | 读写和手动版本选择成功,但原生 PartPkg 报缺 PartsDB 分区;不作为校验成功 | +| 早期自动校验试验 | `management-cb85cb2b564d4778912df7accf85c109` 上传完成,校验被自身事务锁拒绝;已补回归后由上述真实完整成功试验复核 | +| 导出器错误收录 OneDrive | `scoped6-data/management/management-498258fe1e1541e9a135ca4117cb7344/source-identity/csv-process.json`:CSV 日志已完成、分析副本无地址,但历史父 PID 关联扩大至外部进程;后来进程查询超时,本次无原生移除/新增,不计上传成功。`scoped6-active-handle-attribution.json` 为只读 Windows 句柄归属诊断;新增失败回归 `export-lineage-red.xml`、`export-history-red.xml`,修复后两组 73 项通过 | +| 旧误判记录解除及更新重试 | scoped7 真实点击释放:RELEASE_CONFIRMED、主动关闭 0;保留旧证据。随后 `scoped7-data/management/management-d4017aaae47041b08dae6445858a7419/checkpoint.json` 完成原生更新及工程身份复读,UPLOADED、safe=true,关闭了本批次自动校验 | +| 恢复确认窗口误判 | scoped7 的 `evidence/backup-restore-f52ee9adc188/recovery-result.json` 和 scoped9 的 `evidence/backup-restore-22512e81160b/recovery-result.json` 都在副本阶段失败,installed=false。先处理控件辅助节点后,第二次实际差分又明确了快捷键标记差异;未将两次失败记为通过 | +| 快捷键表示差异的原生定位 | `open-identity-real-diff.json` 捕获同一 PID/创建时间、HWND、真实按钮句柄下的 Win32/UIA 差异。修正后 `identity-debug/verify-f34d9f72d4aa/result.json` 实际 PASS、GREEN/READY=1、Save COMMITTED、Close CLOSED、PCB EXITED、资源 RELEASED。这是定位与复测,不能替代完整恢复按钮验收 | +| 立即停止后的残留 | scoped7 的 `evidence/icdb-check-73cdeda6d163/pcb-open/verify-bb3bdc393b0b/result.json`:CANCELLED、safe=false;本任务启动器 12408、PCB 344 在扫描时尚无可关闭窗口。未以队列取消成功冒充原生退出成功 | +| 残留后的再次释放 | 后续读取发现原生 Tip of the Day;在精确绑定的私有桌面正常关闭此帮助窗口后,PCB 完成打开。scoped9 实际“确认释放”正常关闭 3 项并 RELEASE_CONFIRMED,应用正常退出。`cleanup-scoped7-stop*/startup-close.json` 保留早期未确认记录;未强杀进程、未把帮助窗口关闭本身记成数据库释放 | + +| 最终包验收 | 事实与证据 | +| --- | --- | +| 最终包完整恢复按钮 | scoped10 真实执行空来源校验、取消确认、重新确认、运行期间重复点击,随后完成副本校验、目标变更检查、保留旧 Work、安装、目标再次原生校验。`scoped10-data/evidence/backup-restore-5f9b134ab83c/recovery-result.json`:installed=true,source_validation 和 result 都为 PASS、GREEN/READY=1、safe=true,Save COMMITTED、Close CLOSED、PCB/助手 EXITED、资源 RELEASED | +| 最终状态及退出 | scoped10 原生状态刷新后可见 READY 1;READY 项检查及恢复入口禁用。最终释放为 RELEASE_CONFIRMED,主动关闭 0/允许 0,主程序正常退出 0;未修改旧失败记录 | +| 原始文件复核 | 16:00:19 对 A/B 来源及原始中心库共 27,259 个文件重新检查大小、SHA-256,无变化;`originals-rechecked.json`。先前失败校验副本归档到 F 盘以保留证据并腾出系统盘空间,映射见 `archived-validation-copies/map.json` | + +最终源码全量测试 **1,880 passed**(1 条既有 pywinauto STA 警告),记录 `F:\CbbAccept-20261112\full-scoped-final10.xml`;compileall、diff-check 通过。冻结代码和图标一致性、完整恢复、释放及原始文件复核的机器摘要见同目录 [验证 JSON](2026-11-12-scoped-release-validation.json)。历史版本是按此前选择偏好使用最后手动保存版本,READY 不表示已经人工核对版本内容或无数据回退。 + +## 保留限制 + +自动 ICDB Repair 继续关闭。现场服务器会话失联的一致故障副本、Windows 10、跨机共享库掉线尚未验收;不会自动合并、发布或关闭工单。共享符号数据库地址若原生工具自身无法删除,不能通过本程序删除文件或仅凭无进程放行。此前 A/B 输入 EDIF 导出崩溃与空白依赖库有关与否仍需独立复现,不绕过工程身份校验。 + +立即停止时的晚到窗口仍需要正常处理:本次 Tip of the Day 是在精确绑定的私有桌面关闭后才由应用完成会话释放,不能将此试验写成自动退出无缺口。未知/损坏检查点、尚未返回的真实共享写入继续保留未确认状态。 diff --git a/docs/superpowers/plans/2026-11-12-scoped-release-and-user-consent.md b/docs/superpowers/plans/2026-11-12-scoped-release-and-user-consent.md new file mode 100644 index 0000000..1860f43 --- /dev/null +++ b/docs/superpowers/plans/2026-11-12-scoped-release-and-user-consent.md @@ -0,0 +1,13 @@ +# 占用范围、释放及原生确认实施计划 + +按用户已确认的误判复核方案执行,沿用隔离分支 codex/runtime-lifecycle-safety;原工作区和其他软件会话不改动。 + +1. 先以真实外部命令回放补充失败测试:未知外部观察项不接收关闭请求,目标独占资源证明成功后不阻止本库释放;真实本库进程、在途助手、数据库句柄或地址仍阻止。统一库证明与维护入口的进程候选判断,保留观测证据。 +2. 修正释放结果:观察项与可操作目标分开,未允许且自然退出不计主动释放;对绑定身份已退出的旧 UNCONFIRMED 日志不再认定调用仍在执行。覆盖 PID 复用和读取失败。 +3. 单项失败后,先尝试本库/本工程新鲜释放证明;证明完成才解除相应保留状态并继续,无法证明的共享占用仍停止相关写入。普通校验/管理在完整单项事务结束后让出队列,支持等待及取消。 +4. 普通 PCB 打开接通精确读写提示的用户确认;复用现有异步选择模型,绑定 PID、工程、私有桌面、当前提示,取消/跳过不自动写入。自动 Repair 保持关闭;恢复副本也传递用户选择。识别未知提示不猜测点击。 +5. 每项先红后绿;全量回归、编译、冻结代码/图标一致性;其他软件独立工程持续运行、真实目标句柄占用、停止后重试、提示确认/取消、真实校验与备份恢复。EDIF 崩溃单独保留原生失败证据,不跳过身份校验。尚未达到 READY 不宣称验收通过。 + +主要代码:library_lock.py、residual_sessions.py、session_record.py、verify_runner.py、management.py、ui/icdb_check_task.py、ui/management_dialog.py、ui/main_window.py、ui/residual_release_dialog.py、backup_recovery.py;原生确认按现有 pcb_restore_prompt 和 dialog_agent 模式实现。 + +验证记录写入 docs/releases,原始运行证据放 F 盘独立验收目录。开发与原生验收串行执行,所有原生操作局限隔离副本。 diff --git a/src/cbb_refresh_verify/backup_recovery.py b/src/cbb_refresh_verify/backup_recovery.py index 9b3d35b..49b3ce4 100644 --- a/src/cbb_refresh_verify/backup_recovery.py +++ b/src/cbb_refresh_verify/backup_recovery.py @@ -142,7 +142,7 @@ def _align_library(project, pcb, library): ensure_project_central_library(path, library) -def recover_from_backup(request, source, *, progress=None, verifier=None, idle_check=None): +def recover_from_backup(request, source, *, progress=None, verifier=None, idle_check=None, version_prompt=None): """Validate in copies before changing Work; preserve all recovery evidence.""" import pythoncom, win32con, win32event from .network_path import absolute_preserving_drive @@ -241,7 +241,8 @@ def recover_from_backup(request, source, *, progress=None, verifier=None, idle_c preflight(validation) emit('validate_source', '正在副本中打开备份工程并执行原生校验…') release_confirmed = False - source_result = verifier(validation, progress=progress, flag_reader=read_library_flag_if_available) + choice_options = {'version_prompt': version_prompt} if version_prompt is not None else {} + source_result = verifier(validation, progress=progress, flag_reader=read_library_flag_if_available, **choice_options) release_confirmed = source_result.safe_to_continue record['source_validation'] = asdict(source_result) if (source_result.status != 'PASS' or source_result.library_flag != 'GREEN' @@ -275,7 +276,7 @@ def recover_from_backup(request, source, *, progress=None, verifier=None, idle_c release_confirmed = False final = verifier(replace(request, lmc_file=library, evidence_dir=root/'target-verify', auto_repair=False, native_lm_verify=False, interactive_input=False), - progress=progress, flag_reader=read_library_flag_if_available) + progress=progress, flag_reader=read_library_flag_if_available, **choice_options) release_confirmed = final.safe_to_continue if final.status == 'PASS' and (final.library_flag != 'GREEN' or not final.safe_to_continue): final = replace(final, status='FAIL', stderr='目标工程恢复后的 Ready 状态未确认。') diff --git a/src/cbb_refresh_verify/dialog_agent.py b/src/cbb_refresh_verify/dialog_agent.py index 602f006..b17d57d 100644 --- a/src/cbb_refresh_verify/dialog_agent.py +++ b/src/cbb_refresh_verify/dialog_agent.py @@ -236,6 +236,14 @@ class DialogActionExecutor: def perform(self, snapshot: WindowSnapshot, action: dict) -> ActionResult: channels = tuple(action.get("channels", ())) action_name = action.get("action") + if action_name == 'user_confirmed_pcb_open': + try: + from .pcb_open_consent import validate_action_window + if channels != ('win32_button_click',): + raise ValueError('PCB_OPEN_ACTION_CHANNEL_CHANGED') + validate_action_window(snapshot, action) + except Exception as error: + return ActionResult(error_code='DATABASE_RECOVERY_REQUIRED', detail=str(error)) if action_name == 'user_selected_pcb_version': try: from .pcb_restore_prompt import validate_action_window diff --git a/src/cbb_refresh_verify/library_lock.py b/src/cbb_refresh_verify/library_lock.py index 8d0929c..2e3d7ab 100644 --- a/src/cbb_refresh_verify/library_lock.py +++ b/src/cbb_refresh_verify/library_lock.py @@ -84,6 +84,19 @@ def has_retained_library(library): def recheck_previous_release(library, evidence_dir, *, block_name=None, required=False, progress=None): """Historical records trigger fresh proof, never process termination or repair.""" + if not required: + with _guard: + owner = _owners.get(LibraryLock(library).key) + marker = blocker_path(library) + record = checkpoint_record(marker) + if (owner and owner['thread'] == threading.get_ident() and owner['depth'] > 0 + and not owner['retained'] and not marker.with_suffix('.pending').exists() + and record and record['lease_id'] == owner['lease_id'] + and record['pid'] == os.getpid() and record['status'] == 'OPERATION_IN_PROGRESS' + and record.get('block_name') == owner.get('block_name') + and owner.get('block_name') in (None, block_name) + and 'export_analysis' not in record): + return None # Nested Verify belongs to this live transaction, not a past crash. if not (required or has_blocker(library) or has_retained_library(library)): return None def notify(stage, **details): @@ -362,6 +375,23 @@ def _owner_matches_scope(item, library, roots): return False if candidates else None +def _owner_is_blocking(item, library, roots): + """Unknown external clients need resource proof, not a global exit rule.""" + scope = _owner_matches_scope(item, library, roots) + if scope is not None: + return scope + command = str(item.get('command') or '').casefold() + flags = ('--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker') + if any(flag in command for flag in flags): + return True # An unreadable in-flight request is not proof of another library. + from .failed_session import _command_args + try: + return any(Path(arg).name.casefold() in ('close_failed_block.vbs', 'save_verified_block.vbs') + for arg in _command_args(command)[1:]) + except (OSError, ValueError): + return False + + def _enter_maintenance(lease): """Transfer only a valid known lease, after project admission under lock.""" import win32con, win32event, win32file @@ -466,14 +496,21 @@ def _prove_library_released(library, block_name=None, *, allow_unknown_checkpoin shared_root = Path(library).resolve().parent/'SymbolLibs' if allow_unknown_checkpoint and scope_root is not None: raise LibraryBusy('未知检查点必须执行完整库释放证明。') + observed = [] def check_owners(): owners = [] + observed.clear() + from .session_record import active_write_records + if active_write_records(library): + raise LibraryBusy('本库原生调用或助手尚未确认返回,请等待当前操作结束。') for item in query_owners(names): if item['pid'] == os.getpid(): continue if not allow_unknown_checkpoint: roots = (scope_root, shared_root) if scope_root is not None else (Path(library).parent,) - if _owner_matches_scope(item, library, roots) is False: + if not _owner_is_blocking(item, library, roots): + if _owner_matches_scope(item, library, roots) is None: + observed.append(item) continue automation = item['name'].casefold() in ('python.exe', 'pythonw.exe', 'cbbrefreshverify.exe') command = item['command'].casefold() @@ -513,7 +550,8 @@ def _prove_library_released(library, block_name=None, *, allow_unknown_checkpoin win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None) stack.callback(handle.Close) owners = check_owners() - yield {'native_owners': owners, 'addresses': addresses, 'export_copies': export_copies, + yield {'native_owners': owners, 'observed_owners': list(observed), + 'addresses': addresses, 'export_copies': export_copies, 'unknown_checkpoint_recovery': allow_unknown_checkpoint, 'exclusive_files': [str(path) for path in native]} finally: diff --git a/src/cbb_refresh_verify/management.py b/src/cbb_refresh_verify/management.py index 80c4682..5747d88 100644 --- a/src/cbb_refresh_verify/management.py +++ b/src/cbb_refresh_verify/management.py @@ -169,7 +169,7 @@ def _may_have_mutated(record): or any(not isinstance(item, dict) or item.get('stage') not in prewrite for item in history)) -def run_management(request, *, adapter=None, verifier=None, idle_check=None, progress=None, stop=None): +def run_management(request, *, adapter=None, verifier=None, idle_check=None, progress=None, stop=None, version_prompt=None): from .verify_runner import VerifyRequest, run_verify from .backup_recovery import _idle_check import win32con, win32event @@ -402,8 +402,10 @@ def run_management(request, *, adapter=None, verifier=None, idle_check=None, pro # Adapter catalog cannot return until its exact native owner exits. checkpoint('verify') owner_safe = False + options = {'version_prompt': version_prompt} if version_prompt is not None else {} verified = verifier(VerifyRequest(library, request.name, root/'verify', - mapped_drive=request.mapped_drive, mapped_remote_root=request.mapped_remote_root), progress=progress, stop=stop) + mapped_drive=request.mapped_drive, mapped_remote_root=request.mapped_remote_root), + progress=progress, stop=stop, **options) owner_safe = verified.safe_to_continue checkpoint('verified', verification=asdict(verified)) good = verified.status == 'PASS' and verified.library_flag == 'GREEN' and owner_safe @@ -427,7 +429,7 @@ def run_management(request, *, adapter=None, verifier=None, idle_check=None, pro uninitialize_com(initialized) -def run_management_batch(requests, *, stop=None, progress=None, **kwargs): +def run_management_batch(requests, *, stop=None, progress=None, item_executor=None, **kwargs): results = [] retained_libraries = set() for request in requests: @@ -442,7 +444,19 @@ def run_management_batch(requests, *, stop=None, progress=None, **kwargs): if progress: progress({'stage': result.status, 'block': result.name, 'detail': result.detail}) continue - result = run_management(request, progress=progress, stop=stop, **kwargs) + def action(): + result = run_management(request, progress=progress, stop=stop, **kwargs) + if not result.safe_to_continue: + from .operation_lifecycle import recheck_failed_release + result = recheck_failed_release(request.library, request.name, result) + return result + from .operation_queue import QueueCancelled + try: + result = item_executor(request, action) if item_executor is not None else action() + except QueueCancelled as error: + results.append(ManagementResult(request.operation, request.library, request.name, request.partition, + request.source, request.auto_verify, 'complete', 'CANCELLED', True, str(error))) + break results.append(result) if progress: progress({'stage': result.status, 'block': result.name, 'detail': result.detail, diff --git a/src/cbb_refresh_verify/native_engineering_identity.py b/src/cbb_refresh_verify/native_engineering_identity.py index e027ca8..567c3b3 100644 --- a/src/cbb_refresh_verify/native_engineering_identity.py +++ b/src/cbb_refresh_verify/native_engineering_identity.py @@ -285,9 +285,54 @@ def _database_released(project_root): return True +def _process_birth(value): + from datetime import datetime, timezone, timedelta + if not value: + return None + if isinstance(value, datetime): + return value.astimezone(timezone.utc) + if re.fullmatch(r'\d{14}\.\d{6}[+-]\d{3}', value): + zone = timezone(timedelta(minutes=int(value[21:]))) + return datetime.strptime(value[:21], '%Y%m%d%H%M%S.%f').replace(tzinfo=zone).astimezone(timezone.utc) + try: + parsed = datetime.fromisoformat(value) + if parsed.tzinfo is not None: + return parsed.astimezone(timezone.utc) + except ValueError: + pass + return value + + +def _export_descendants(snapshot, tracked, existing): + """A historical parent PID is not evidence of current parentage.""" + from datetime import datetime + rows = {row['pid']: row for row in snapshot} + def matches(row): + birth = _process_birth(row.get('created')) + return tracked[row['pid']] is None or birth is None or tracked[row['pid']] == birth + changed = True + while changed: + changed = False + for row in snapshot: + if row['pid'] in tracked or row['parent'] not in tracked: + continue + birth = _process_birth(row.get('created')) + if (row['pid'], birth) in existing: + continue + parent = rows.get(row['parent']) + parent_birth = tracked[row['parent']] + if parent is not None and not matches(parent): + continue + if isinstance(birth, datetime) and isinstance(parent_birth, datetime) and birth < parent_birth: + continue + tracked[row['pid']] = birth + changed = True + return [row for row in snapshot if row['pid'] in tracked and matches(row)] + + def _run_exports(project, root, mentor_home, timeout_seconds): """Observe exact exporter/descendant handles; never kill a database owner.""" - import win32api, win32con, win32event, pywintypes + import win32api, win32con, win32event, win32process, pywintypes root = Path(root) try: _write_json(root/'export-launch.json', {'started': False}) @@ -338,16 +383,17 @@ def _run_exports(project, root, mentor_home, timeout_seconds): creationflags=subprocess.CREATE_NO_WINDOW) record['native_started'] = True record['pid'] = process.pid - descendants = {process.pid} + handle = getattr(process, '_handle', None) + birth = _process_birth(win32process.GetProcessTimes(handle)['CreationTime']) if handle is not None else None + descendants = {process.pid: birth} + existing = {(p['pid'], _process_birth(p.get('created'))) for p in before} + if birth is not None: + record['root_created'] = birth.isoformat() _write_json(root/(kind+'-process.json'), record) while time.monotonic() < deadline: snapshot = _process_snapshot() - changed = True - while changed: - previous = len(descendants) - descendants.update(p['pid'] for p in snapshot if p['parent'] in descendants) - changed = len(descendants) != previous - owners = [p for p in snapshot if p['pid'] in descendants or ( + owned = {p['pid'] for p in _export_descendants(snapshot, descendants, existing)} + owners = [p for p in snapshot if p['pid'] in owned or ( p['name'].casefold() in _OWNER_NAMES and _native_scope_match( p.get('command', ''), roots=(project.parent,)) is True)] for owner in owners: @@ -359,10 +405,10 @@ def _run_exports(project, root, mentor_home, timeout_seconds): # owners until a fresh snapshot proves it absent. record.setdefault('process_observation_errors', {})[str(owner['pid'])] = { 'winerror': error.winerror, 'detail': str(error)} - record['observed_pids'] = sorted(descendants | handles.keys()) - identities.update({owner['pid']: - {key: owner.get(key, '') for key in ('pid', 'created', 'executable')} - for owner in owners}) + record['observed_pids'] = sorted(descendants.keys() | handles.keys()) + for owner in owners: + identities.setdefault(owner['pid'], + {key: owner.get(key, '') for key in ('pid', 'created', 'executable')}) record['process_identities'] = list(identities.values()) if (process.poll() is not None and not owners and all(win32event.WaitForSingleObject(h, 0) == win32con.WAIT_OBJECT_0 for h in handles.values())): diff --git a/src/cbb_refresh_verify/native_export_guard.py b/src/cbb_refresh_verify/native_export_guard.py index 8b2a0e8..0fc31e7 100644 --- a/src/cbb_refresh_verify/native_export_guard.py +++ b/src/cbb_refresh_verify/native_export_guard.py @@ -7,6 +7,19 @@ from uuid import uuid4 from .management import _write_json +def _preexisting_export_pids(record): + from datetime import datetime + from .native_engineering_identity import _process_birth + identities = record.get('process_identities', []) + root = next((p for p in identities if p.get('pid') == record.get('pid')), {}) + birth = _process_birth(record.get('root_created') or root.get('created')) + if not isinstance(birth, datetime): + return set() + return {p['pid'] for p in identities if p.get('pid') != record.get('pid') + and isinstance(_process_birth(p.get('created')), datetime) + and _process_birth(p['created']) < birth} + + def assert_retained_exports_idle(library=None): import win32con, win32event from .native_engineering_identity import _retained_exports @@ -17,8 +30,18 @@ def assert_retained_exports_idle(library=None): if (library is not None and scope.get('library') and Path(scope['library']).resolve() != Path(library).resolve()): continue - if process.poll() is None or any(win32event.WaitForSingleObject(handle, 0) != win32con.WAIT_OBJECT_0 - for handle in handles.values()): + excluded = set() + if scope.get('analysis_root') and getattr(process, 'pid', None): + try: + for path in Path(scope['analysis_root']).glob('*-process.json'): + record = json.loads(path.read_text('utf-8')) + if record.get('pid') == process.pid: + excluded.update(_preexisting_export_pids(record)) + except (OSError, ValueError, KeyError, TypeError): + excluded.clear() + if process.poll() is None or any(pid not in excluded + and win32event.WaitForSingleObject(handle, 0) != win32con.WAIT_OBJECT_0 + for pid, handle in handles.items()): raise LibraryBusy('Native identity exporter or descendant has not released.') @@ -119,7 +142,10 @@ def prove_export_copies_released(library, *, allow_unknown_checkpoint=False, uns if any(not isinstance(pid, int) or pid <= 0 for pid in pids): raise ValueError('Invalid export process identity.') identities = {p['pid']: p for p in process.get('process_identities', [])} + excluded = _preexisting_export_pids(process) def original_alive(pid): + if pid in excluded: + return False recorded = identities.get(pid, {}) current = next((p for p in snapshot if p['pid'] == pid), None) if recorded.get('created') and current and current.get('created'): diff --git a/src/cbb_refresh_verify/operation_lifecycle.py b/src/cbb_refresh_verify/operation_lifecycle.py index ab85e62..105e87c 100644 --- a/src/cbb_refresh_verify/operation_lifecycle.py +++ b/src/cbb_refresh_verify/operation_lifecycle.py @@ -2,6 +2,52 @@ from collections.abc import Sequence +def recheck_failed_release(library, block, result): + """Refresh resource facts after a late exit; keep the original business failure.""" + if result.safe_to_continue or not result.evidence_path: + return result + from pathlib import Path + from dataclasses import replace + import json + from .session_record import read_session_record, inspect_session_record + from .library_lock import release_retained_library + evidence = Path(result.evidence_path) + try: + session = Path(getattr(result, 'session_record_path', None) or evidence.with_name('session.json')) + if session.is_file(): + record = read_session_record(session, evidence_root=evidence.parent) + if record.get('block') != block or Path(record.get('library', '')).resolve() != Path(library).resolve(): + return result + if inspect_session_record(session, evidence_root=evidence.parent).get('status') == 'ACTIVE': + return result + else: + record = json.loads(evidence.read_text('utf-8')) + if (record.get('name') != block or record.get('operation') not in ('add', 'update', 'remove') + or Path(record.get('library', '')).resolve() != Path(library).resolve()): + return result + bound = [] + for phase in ('before', 'remove', 'after-remove', 'add', 'after-add'): + candidate = evidence.parent/phase/'session.json' + if candidate.is_file(): + owned = read_session_record(candidate, evidence_root=evidence.parent) + if Path(owned.get('library', '')).resolve() != Path(library).resolve(): + return result + if inspect_session_record(candidate, evidence_root=evidence.parent).get('status') == 'ACTIVE': + return result + bound.append(candidate) + if not bound: + return result # A generic timeout without a bound owner is not an exit fact. + proof = release_retained_library(library, evidence.parent/'late-release', block_name=block) + if proof.get('status') != 'RELEASE_CONFIRMED' or Path(proof.get('library', '')).resolve() != Path(library).resolve(): + return result + evidence.with_name('late-release-result.json').write_text(json.dumps(dict( + business_status=result.status, safe_to_continue=True, release_proof=proof), + ensure_ascii=False, default=str, indent=2), 'utf-8') + return replace(result, safe_to_continue=True, release_proof=proof) + except Exception: + return result + + def classify_save_state(markers: Sequence[str], *, helper_exited: bool | None, native_released: bool | None, forced: bool = False) -> dict: names = {line.strip().split('|', 1)[0] for line in markers} diff --git a/src/cbb_refresh_verify/pcb_open_consent.py b/src/cbb_refresh_verify/pcb_open_consent.py new file mode 100644 index 0000000..ed90dd1 --- /dev/null +++ b/src/cbb_refresh_verify/pcb_open_consent.py @@ -0,0 +1,154 @@ +"""Explicit user answers to the owned PCB's exact read/write question.""" +from contextlib import contextmanager, ExitStack +from pathlib import Path +from threading import Lock +import time + +from .post_repair_consent import exact_prompt + + +def _prompt_identity(snapshot): + # UIA adds chrome/reorders controls and omits Win32 caption accelerator marks. + return tuple(sorted((c.handle, c.control_id, c.class_name, + c.name.replace('&', '') if c.class_name == 'Button' else c.name) + for c in snapshot.controls if c.handle and c.handle != snapshot.hwnd)) + + +class OpenChoice: + def __init__(self, block, library): + self.block, self.library = block, library + self.decision = None + self._lock = Lock() + + def choose(self, decision): + if decision not in ('continue', 'skip', 'cancel'): + raise ValueError('无效的打开工程选择') + with self._lock: + if self.decision is None: + self.decision = decision + + +def validate_owner(job, target_pid, launcher_pid, worker_pid): + from .owner_probe import query_process_snapshot + from .session_record import process_identity + from .mentor_adapter import is_reusable_circuit_pcb + rows = {r['pid']: r for r in query_process_snapshot()} + target, launcher = rows.get(target_pid), rows.get(launcher_pid) + if (not target or not launcher or target['parent'] != launcher_pid or launcher['parent'] != worker_pid + or not str(job.get('desktop', '')).startswith('CbbVerify_') + or job.get('interactive_input') or job.get('native_lm_verify') or job.get('diagnostic_only')): + raise ValueError('PCB_OPEN_OWNER_UNCONFIRMED') + for row in (target, launcher): + if not is_reusable_circuit_pcb(row['executable'], row['command'], job['pcb']): + raise ValueError('PCB_OPEN_TARGET_CHANGED') + return {'target': process_identity(target_pid), 'launcher': process_identity(launcher_pid)} + + +@contextmanager +def resource_guard(job, allowed_pids): + import win32con, win32file + from .icdb_ownership import database_directories, unreleased_addresses + from .owner_probe import query_process_snapshot + from .library_lock import _owner_is_blocking + from .verify_runner import preflight, VerifyRequest + library = Path(job['lmc_file']) + project, pcb = preflight(VerifyRequest(library, job['block_name'], Path(job['root']))) + if project.resolve() != Path(job['project']).resolve() or pcb.resolve() != Path(job['pcb']).resolve(): + raise ValueError('PCB_OPEN_PROJECT_CHANGED') + roots = (project.parent, library.parent/'SymbolLibs') + def check(): + if unreleased_addresses(library, project, pcb): + raise ValueError('目标仍有数据库地址记录,暂不能确认读写打开。') + for row in query_process_snapshot(): + if row['pid'] not in allowed_pids and _owner_is_blocking(row, library, roots): + raise ValueError(f'目标还有其他会话,PID={row["pid"]};未确认读写打开。') + check() + paths = [library, pcb.parent/'Layout/LayoutDB.lyt', + *(d/'icdb.dat' for d in database_directories(library, project, pcb) if (d/'icdb.dat').is_file())] + with ExitStack() as stack: + for path in dict.fromkeys(paths): + handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None, + win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None) + stack.callback(handle.Close) + check() + yield + + +class OpenController: + def __init__(self, job): + self.job = job + self.choice = None + self.original = self.owner = None + self.sent = False + self.sent_at = 0.0 + + def handle(self, snapshot, snapshots, *, target_pid, launcher_pid, worker_pid, show, perform): + from .dialog_supervisor import DialogPollResult + from .management import _write_json + try: + if not exact_prompt(snapshot) or snapshot.pid != target_pid or len(snapshots) != 1: + raise ValueError('PCB_OPEN_PROMPT_CHANGED') + owner = validate_owner(self.job, target_pid, launcher_pid, worker_pid) + if self.choice is None: + self.owner, self.original = owner, snapshot + self.choice = OpenChoice(self.job['block_name'], self.job['lmc_file']) + show(self.choice) + if (owner != self.owner or snapshot.hwnd != self.original.hwnd + or _prompt_identity(snapshot) != _prompt_identity(self.original)): + raise ValueError('PCB_OPEN_IDENTITY_CHANGED') + if self.sent: + if time.monotonic()-self.sent_at < 2: + return DialogPollResult(observed_snapshots=tuple(snapshots)) + raise ValueError('PCB_OPEN_ANSWER_NOT_COMPLETED') + if self.choice.decision is None: + return DialogPollResult(activity=True, observed_snapshots=tuple(snapshots)) + control = 6 if self.choice.decision == 'continue' else 7 + action = {'action': 'user_confirmed_pcb_open', 'channels': ['win32_button_click'], + 'target': {'control_id': control}, 'desktop': self.job['desktop'], + 'pid': target_pid, 'owner': owner, 'choice': self.choice.decision} + def send(): + self.sent, self.sent_at = True, time.monotonic() + _write_json(Path(self.job['root'])/'pcb-open-user-choice.json', dict( + choice=self.choice.decision, project=self.job['project'], pcb=self.job['pcb'], + library=self.job['lmc_file'], owner=owner, snapshot=snapshot.to_record())) + return perform(snapshot, action, snapshot.phase) + if control == 6: + allowed = {target_pid, launcher_pid, worker_pid, self.job.get('supervisor_pid')} + with resource_guard(self.job, allowed): + result = send() + else: + result = send() + error = result.error_code + if not error and result.accepted_controls != (control,): + error = 'PCB_OPEN_ANSWER_FAILED' + if not error and control == 7: + error = 'PCB_OPEN_SKIPPED' if self.choice.decision == 'skip' else 'USER_CANCELLED' + return DialogPollResult(activity=True, action_sent=True, snapshot=snapshot, + error_code=error, detail=result.detail or ('用户跳过本项。' if control == 7 else ''), + accepted_controls=result.accepted_controls, channel=result.channel, + action=action['action'], observed_snapshots=tuple(snapshots)) + except Exception as error: + return DialogPollResult(error_code='DATABASE_RECOVERY_REQUIRED', detail=str(error), + snapshot=snapshot, observed_snapshots=tuple(snapshots)) + + +def validate_action_window(snapshot, action): + from dataclasses import replace + import win32gui, win32process + from .native_repair_ui import _current_desktop_name + from .dialog_models import ControlSnapshot + from .session_record import process_identity + if (not exact_prompt(snapshot) or action.get('target', {}).get('control_id') not in (6, 7) + or snapshot.pid != action.get('pid') or _current_desktop_name() != action.get('desktop') + or not str(action.get('desktop', '')).startswith('CbbVerify_') + or win32process.GetWindowThreadProcessId(snapshot.hwnd)[1] != snapshot.pid + or process_identity(snapshot.pid) != action.get('owner', {}).get('target')): + raise ValueError('PCB_OPEN_LIVE_OWNER_CHANGED') + children = [] + win32gui.EnumChildWindows(snapshot.hwnd, lambda h, _: children.append(int(h)), None) + controls = tuple(ControlSnapshot(h, win32gui.GetDlgCtrlID(h) & 0xffff, + win32gui.GetClassName(h), win32gui.GetWindowText(h), enabled=bool(win32gui.IsWindowEnabled(h))) for h in children) + if not exact_prompt(replace(snapshot, controls=controls)) or any( + c.handle != next(x.handle for x in snapshot.controls if x.control_id == c.control_id) + for c in controls if c.class_name == 'Button'): + raise ValueError('PCB_OPEN_LIVE_PROMPT_CHANGED') diff --git a/src/cbb_refresh_verify/pcb_restore_prompt.py b/src/cbb_refresh_verify/pcb_restore_prompt.py index abe429a..00844f6 100644 --- a/src/cbb_refresh_verify/pcb_restore_prompt.py +++ b/src/cbb_refresh_verify/pcb_restore_prompt.py @@ -37,10 +37,11 @@ def _choice(snapshot): class RestoreController: - def __init__(self, job): + def __init__(self, job, *, user_open=False): from .post_repair_consent import _validate_grant self.job = job - self.grant = _validate_grant(job) + self.grant = None if user_open else _validate_grant(job) + self.owner = None self.prompt = None self.original = None self.selection_sent = self.confirm_sent = self.failed = False @@ -60,13 +61,20 @@ class RestoreController: or snapshot.pid != self.original.pid or _candidate_key(choice['candidates']) != _candidate_key(self.prompt.candidates)): raise ValueError('PCB_VERSION_CANDIDATES_CHANGED') - pre = json.loads((Path(self.job['root'])/'post-repair-prelaunch.json').read_text(encoding='utf-8')) - if (pre.get('nonce') != self.grant['nonce'] or pre.get('desktop') != self.job['desktop'] - or pre.get('worker_pid') != worker_pid or pre.get('supervisor_pid') != self.job['supervisor_pid'] - or pre.get('addresses') != [] - or not all(consent._same(pre[key], self.grant[key]) for key in ('project', 'pcb', 'library'))): - raise ValueError('PCB_VERSION_PRELAUNCH_PROOF_INVALID') - consent._validate_current_processes(self.job, pre, target_pid, launcher_pid, worker_pid, companion_pids) + if self.grant is None: + from .pcb_open_consent import validate_owner + owner = validate_owner(self.job, target_pid, launcher_pid, worker_pid) + if self.owner is not None and owner != self.owner: + raise ValueError('PCB_VERSION_OWNER_CHANGED') + self.owner = owner + else: + pre = json.loads((Path(self.job['root'])/'post-repair-prelaunch.json').read_text(encoding='utf-8')) + if (pre.get('nonce') != self.grant['nonce'] or pre.get('desktop') != self.job['desktop'] + or pre.get('worker_pid') != worker_pid or pre.get('supervisor_pid') != self.job['supervisor_pid'] + or pre.get('addresses') != [] + or not all(consent._same(pre[key], self.grant[key]) for key in ('project', 'pcb', 'library'))): + raise ValueError('PCB_VERSION_PRELAUNCH_PROOF_INVALID') + consent._validate_current_processes(self.job, pre, target_pid, launcher_pid, worker_pid, companion_pids) if self.prompt is None: self.original = snapshot self.prompt = RestoreChoice(self.job['block_name'], self.job['lmc_file'], choice['candidates']) @@ -91,6 +99,8 @@ class RestoreController: action = {'action': 'user_selected_pcb_version', 'channels': ['win32_button_click'], 'target': {'control_id': control}, 'desktop': self.job['desktop'], 'pid': target_pid, 'choice': selected['kind'], 'candidates': list(self.prompt.candidates)} + if self.owner is not None: + action['owner'] = self.owner self.selection_sent = True self.confirm_sent = confirming self.sent_at = time.monotonic() @@ -119,6 +129,10 @@ def validate_action_window(snapshot, action): import win32gui, win32process from .native_repair_ui import _current_desktop_name from .dialog_models import ControlSnapshot + if action.get('owner') is not None: + from .session_record import process_identity + if process_identity(snapshot.pid) != action['owner']['target']: + raise ValueError('PCB_VERSION_LIVE_PROCESS_CHANGED') if (not str(action.get('desktop', '')).startswith('CbbVerify_') or _current_desktop_name() != action.get('desktop') or snapshot.pid != action.get('pid') or win32process.GetWindowThreadProcessId(snapshot.hwnd)[1] != snapshot.pid diff --git a/src/cbb_refresh_verify/residual_sessions.py b/src/cbb_refresh_verify/residual_sessions.py index c9100d6..5bfc561 100644 --- a/src/cbb_refresh_verify/residual_sessions.py +++ b/src/cbb_refresh_verify/residual_sessions.py @@ -447,7 +447,7 @@ def inspect_residual_sessions(library, *, block_names=()): try: item.update(_process_identity(row)) target, detail = close_target(row['name'], windows.get(row['pid'], []), incomplete=error) if row['scope_confirmed'] else ( - None, '归属未确认,请在原生窗口确认工程并关闭后重新检查') + None, '归属未确认,仅作观察;将检查当前库实际占用。') item.update(can_close=target is not None, detail=detail) except Exception as identity_error: item.update(can_close=False, detail=f'进程已变化或暂时无法确认:{identity_error}') @@ -616,6 +616,11 @@ def _session_evidence(row): return value +def release_targets_complete(rows): + return all(row.get('release_status') == 'RELEASED' or ( + row.get('scope_confirmed') is False and row.get('release_status') == 'OBSERVED') for row in rows) + + def _release_residual_sessions(plan, evidence_dir, *, stop=None, force=False, cancel_native=False): library = Path(plan['library']).resolve() root = Path(evidence_dir).resolve()/('sessions-'+uuid4().hex[:12]) @@ -666,6 +671,11 @@ def _release_residual_sessions(plan, evidence_dir, *, stop=None, force=False, ca outcome = {'release_status': 'RELEASED', 'detail': '已退出'} if stop is not None and stop.is_set(): outcome = {'release_status': 'CANCELLED', 'detail': '已停止释放'} + elif row.get('scope_confirmed') is False: + from .library_lock import _owner_is_blocking + outcome = ({'release_status': 'WAITING', 'detail': '当前归属已变化,请重新检查确认;未关闭'} + if current is not None and _owner_is_blocking(current, library, roots) else + {'release_status': 'OBSERVED', 'detail': '仅观察,未关闭;由目标资源检查确认是否影响当前库'}) elif current is not None: from .library_lock import _owner_matches_scope scoped = _owner_matches_scope(current, library, roots) is True @@ -702,7 +712,7 @@ def _release_residual_sessions(plan, evidence_dir, *, stop=None, force=False, ca cancel_prompt=(_cancel_question(row['name'], windows, incomplete=error) if row.get('force_user_confirmed') is True else None), native_activity=native_activity(row['name'], windows, incomplete=error)) - if all(row['release_status'] == 'RELEASED' for row in result['sessions']) and not (stop and stop.is_set()): + if release_targets_complete(result['sessions']) and not (stop and stop.is_set()): result['proof'] = _finish_library_release(library, root/'library-proof') proof = result['proof'] if (proof.get('status') != 'RELEASE_CONFIRMED' diff --git a/src/cbb_refresh_verify/session_record.py b/src/cbb_refresh_verify/session_record.py index d8d0114..f970a1a 100644 --- a/src/cbb_refresh_verify/session_record.py +++ b/src/cbb_refresh_verify/session_record.py @@ -449,13 +449,13 @@ def active_write_records(library): for path in paths: try: session, state, processes = _session(path, path.parent) - if state.get('phase') in ('NATIVE_CALL', 'CLOSING', 'UNCONFIRMED'): - result.append({**session, 'phase': state['phase']}) - else: + if processes: from .residual_sessions import _process_handle, _handle_identity, _force_ownership import win32con, win32event for identity in processes: - if identity.get('role') not in ('worker', 'helper'): + if identity.get('role') == 'supervisor' or ( + state.get('phase') not in ('NATIVE_CALL', 'CLOSING', 'UNCONFIRMED') + and identity.get('role') not in ('worker', 'helper')): continue try: with _process_handle(identity['pid']) as handle: @@ -465,7 +465,8 @@ def active_write_records(library): if any(actual[k] != identity[k] for k in IDENTITY_KEYS if k != 'pid'): continue # A retained caller may be inside Close after the last journal write failed. - result.append({**session, 'phase': 'UNCONFIRMED'}) + result.append({**session, 'phase': state['phase'] if state.get('phase') in ( + 'NATIVE_CALL', 'CLOSING', 'UNCONFIRMED') else 'UNCONFIRMED'}) break except Exception as error: if getattr(error, 'winerror', None) != 87: diff --git a/src/cbb_refresh_verify/ui/backup_recovery_dialog.py b/src/cbb_refresh_verify/ui/backup_recovery_dialog.py index 66024bb..20d3c1a 100644 --- a/src/cbb_refresh_verify/ui/backup_recovery_dialog.py +++ b/src/cbb_refresh_verify/ui/backup_recovery_dialog.py @@ -12,6 +12,7 @@ from .backup_notice import MANUAL_BACKUP_NOTICE class RecoverySignals(QObject): progress = Signal(object) + choice = Signal(object) class BackupRecoveryDialog(QDialog): @@ -31,6 +32,8 @@ class BackupRecoveryDialog(QDialog): self.pool.setMaxThreadCount(1) self.signals = RecoverySignals(self) self.signals.progress.connect(self._progress) + if parent is not None and hasattr(parent, '_show_version_choice'): + self.signals.choice.connect(parent._show_version_choice) self.block_combo = QComboBox() self.block_combo.addItems(list(names)) self.source_edit = QLineEdit() @@ -96,7 +99,8 @@ class BackupRecoveryDialog(QDialog): self.status_label.setText('正在准备恢复…') self.started.emit(name) def execute(): - action = lambda: recoverer(request, source, progress=self.signals.progress.emit) + options = {'version_prompt': self.signals.choice.emit} if self.recoverer is None else {} + action = lambda: recoverer(request, source, progress=self.signals.progress.emit, **options) if self.native_queue is None: return action() from ..operation_queue import QueueCancelled def restore(): diff --git a/src/cbb_refresh_verify/ui/icdb_check_task.py b/src/cbb_refresh_verify/ui/icdb_check_task.py index 76a38ca..30ed9ad 100644 --- a/src/cbb_refresh_verify/ui/icdb_check_task.py +++ b/src/cbb_refresh_verify/ui/icdb_check_task.py @@ -73,7 +73,11 @@ class IcdbCheckTask(QObject): if request.block_name in self.invalidated: return VerifyResult('SKIPPED', stderr='目标已有后续管理操作,请重新检查。') self.event.emit({'stage': 'icdb_check_start', 'block': request.block_name}) - return self.verifier(request) + result = self.verifier(request) + if not result.safe_to_continue: + from ..operation_lifecycle import recheck_failed_release + result = recheck_failed_release(request.lmc_file, request.block_name, result) + return result return self.queue.run(execute, stop=self.stop, wait_state=lambda: (self.paused, library_wait_reason(request.lmc_file)), ready=lambda: not self.paused and library_available(request.lmc_file), diff --git a/src/cbb_refresh_verify/ui/main_window.py b/src/cbb_refresh_verify/ui/main_window.py index 9b2af5c..f3598c1 100644 --- a/src/cbb_refresh_verify/ui/main_window.py +++ b/src/cbb_refresh_verify/ui/main_window.py @@ -832,10 +832,10 @@ class MainWindow(QWidget): path = QFileDialog.getOpenFileName(self, '选择中心库', '', 'LMC (*.lmc)')[0] if path: self.lmc_edit.setText(path); self.load_library() - def _start(self, action, callback): + def _start(self, action, callback, *, queued=True): self.stop.clear() self.busy = True; self._update() - self.worker = ServiceWorker(self._queued_action(action)) + self.worker = ServiceWorker(self._queued_action(action) if queued else action) self.worker.signals.succeeded.connect(callback) self.worker.signals.failed.connect(self._failed) self.worker.signals.finished.connect(self._finished) @@ -1370,6 +1370,7 @@ class MainWindow(QWidget): self.signals.event.emit({'block': req.block_name, 'stage': 'icdb_check_start'}) return verify(req) results = run_batch(requests, verifier=verifier, stop=self.stop, + item_executor=lambda req, action: self._queued_action(action)(), 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})) @@ -1383,9 +1384,9 @@ class MainWindow(QWidget): 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 + refresh = self._queued_action(lambda: self._read_affected_records(affected))() if safe and not self.stop.is_set() else None return results, report, affected, refresh - self._start(action, self._batch_done) + self._start(action, self._batch_done, queued=False) def _read_affected_records(self, names): """Worker-only read; never derive library state from action outcomes.""" @@ -1655,9 +1656,17 @@ class MainWindow(QWidget): 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 恢复版本') + from ..pcb_open_consent import OpenChoice + from .pcb_open_dialog import PcbOpenDialog + parent = self + backup = getattr(self, 'backup_dialog', None) + if backup is not None and backup.isVisible(): parent = backup + management = getattr(self, 'management_dialog', None) + if management is not None and management.isVisible(): parent = management + self.version_dialog = (PcbOpenDialog if isinstance(choice, OpenChoice) else PcbRestoreDialog)(choice, parent) + detail = '等待读写打开确认' if isinstance(choice, OpenChoice) else '等待选择 PCB 恢复版本' + self.status_label.setText(f'{choice.block}:{detail}。') + self.icdb_phase.setText(f'{choice.block} · {detail}') self.version_dialog.show() def request_stop(self): diff --git a/src/cbb_refresh_verify/ui/management_dialog.py b/src/cbb_refresh_verify/ui/management_dialog.py index 49b3ea5..bf78499 100644 --- a/src/cbb_refresh_verify/ui/management_dialog.py +++ b/src/cbb_refresh_verify/ui/management_dialog.py @@ -33,6 +33,7 @@ STAGE_LABELS = { class ManagementSignals(QObject): progress = Signal(object) + choice = Signal(object) class ManagementDialog(QDialog): @@ -60,6 +61,8 @@ class ManagementDialog(QDialog): self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1) self.signals = ManagementSignals(self) self.signals.progress.connect(self._progress) + if parent is not None and hasattr(parent, '_show_version_choice'): + self.signals.choice.connect(parent._show_version_choice) self.setWindowTitle({'add': '新增 CBB', 'update': '同名更新 CBB', 'remove': '移除 CBB'}[self.operation]) self.resize(850, 450) self.table = QTableWidget(0, 4) @@ -178,6 +181,17 @@ class ManagementDialog(QDialog): from ..operation_queue import QueueCancelled from ..session_record import library_available, library_wait_reason try: + if self.runner is run_management_batch: + def item(request, action): + return self.native_queue.run(action, stop=self.stop, + ready=lambda: library_available(request.library), + wait_state=lambda: library_wait_reason(request.library), + waiting=lambda: self.signals.progress.emit({'stage': 'waiting_native_slot', + 'retained': not library_available(request.library), + 'detail': library_wait_reason(request.library) or '已排队,等待当前原生操作结束'})) + return self.runner(requests, adapter=self.adapter, stop=self.stop, + progress=self.signals.progress.emit, item_executor=item, + version_prompt=self.signals.choice.emit) return self.native_queue.run(action, stop=self.stop, waiting=lambda: self.signals.progress.emit( {'stage': 'waiting_native_slot', 'retained': not library_available(self.template.library), diff --git a/src/cbb_refresh_verify/ui/pcb_open_dialog.py b/src/cbb_refresh_verify/ui/pcb_open_dialog.py new file mode 100644 index 0000000..feb23a9 --- /dev/null +++ b/src/cbb_refresh_verify/ui/pcb_open_dialog.py @@ -0,0 +1,21 @@ +from PySide6.QtWidgets import QMessageBox + + +class PcbOpenDialog(QMessageBox): + def __init__(self, choice, parent=None): + super().__init__(parent) + self.choice = choice + self.setWindowTitle('确认打开 PCB 工程') + self.setIcon(QMessageBox.Question) + self.setText(f'CBB:{choice.block}\n中心库:{choice.library}\n\n' + 'PCB 提示上次可能未正常关闭,或工程仍被其他用户打开。\n' + '请确认没有其他用户打开此工程,再选择继续以读写权限打开。') + self.continue_button = self.addButton('确认无人使用,继续打开', QMessageBox.ActionRole) + self.skip_button = self.addButton('跳过本项', QMessageBox.ActionRole) + self.cancel_button = self.addButton('取消本批次', QMessageBox.RejectRole) + self.setDefaultButton(self.cancel_button) + self.setEscapeButton(self.cancel_button) + self.setModal(True) + self.buttonClicked.connect(lambda b: choice.choose('continue' if b is self.continue_button else + 'skip' if b is self.skip_button else 'cancel')) + self.finished.connect(lambda _: choice.choose('cancel')) diff --git a/src/cbb_refresh_verify/ui/residual_release_dialog.py b/src/cbb_refresh_verify/ui/residual_release_dialog.py index 269d889..fb601d1 100644 --- a/src/cbb_refresh_verify/ui/residual_release_dialog.py +++ b/src/cbb_refresh_verify/ui/residual_release_dialog.py @@ -7,7 +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 +from ..residual_sessions import force_block_reason, release_targets_complete class ResidualReleaseDialog(QDialog): @@ -95,6 +95,7 @@ class ResidualReleaseDialog(QDialog): allowed = session.get('consent_allowed') permission = '允许' if allowed is True else '未允许' if allowed is False else '待确认' outcome = {'RELEASED': '已释放', 'WAITING': '未释放', 'IDENTITY_CHANGED': '身份已变化', + 'OBSERVED': '仅观察,未关闭', 'CANCELLED': '已停止', 'REQUESTING': '执行中', 'NOT_STARTED': '尚未执行'}.get( session.get('release_status'), '待执行') for column, value in enumerate((session.get('project', ''), session['name'], @@ -162,7 +163,7 @@ class ResidualReleaseDialog(QDialog): # Both paths were canonicalized by the worker; GUI comparison must not touch SMB. if (proof.get('status') != 'RELEASE_CONFIRMED' or Path(proof.get('library', '')).absolute() != self.library.absolute() - or any(r.get('release_status') != 'RELEASED' for r in result['sessions'])): + or not release_targets_complete(result['sessions'])): return False self.plan = None self.runtime_label.clear() @@ -174,7 +175,7 @@ class ResidualReleaseDialog(QDialog): proof = result.get('proof', {}) if (self.release_finalizer is not None and proof.get('status') == 'RELEASE_CONFIRMED' and Path(proof.get('library', '')).absolute() == self.library.absolute() - and all(row.get('release_status') == 'RELEASED' for row in result['sessions'])): + and release_targets_complete(result['sessions'])): self.release_finalizer(proof) return {**result, 'proof': {**proof, 'mapping_cleanup_complete': True}} return result @@ -203,7 +204,7 @@ class ResidualReleaseDialog(QDialog): self.library = Path(plan['library']) self.plan = plan self._rows(plan['sessions']) - text = ('确认后逐项正常关闭下列会话;有未保存更改时,可选择保存或保留。' + text = ('确认后正常关闭已确认属于当前库的会话,并复查库占用;其他会话仅作观察。' if plan['sessions'] else '未发现活跃会话。') records = plan.get('previous_records', []) if records: @@ -248,7 +249,8 @@ class ResidualReleaseDialog(QDialog): def done(result): self.plan = {**plan, 'sessions': result['sessions']} self._rows(result['sessions']) - count = sum(row['release_status'] == 'RELEASED' for row in result['sessions']) + count = sum(row['release_status'] == 'RELEASED' and row.get('scope_confirmed') is not False + for row in result['sessions']) if self._accept_release_proof(result): self.message.setText(f'已释放 {count} 个会话,旧占用记录已解除。' + ('\n记录保存失败:'+result['evidence_error'] if result.get('evidence_error') else '')) diff --git a/src/cbb_refresh_verify/verify_runner.py b/src/cbb_refresh_verify/verify_runner.py index 4d33218..0a63eae 100644 --- a/src/cbb_refresh_verify/verify_runner.py +++ b/src/cbb_refresh_verify/verify_runner.py @@ -940,6 +940,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run last_activity_key = None phase = DialogPhase.PCB_STARTING restore_controller = None + open_controller = None dialog_agent = None latest_snapshots = () if dialog_supervisor_factory is None: @@ -1038,6 +1039,17 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run dialog_result = dialog_supervisor.poll() else: dialog_result = dialog_supervisor.poll() + if (version_prompt is not None and consent is None and dialog_agent is not None + and not request.diagnostic_only and not request.native_lm_verify + and dialog_result.error_code == 'DATABASE_RECOVERY_REQUIRED' + and dialog_result.snapshot is not None): + from .pcb_open_consent import OpenController, exact_prompt + if exact_prompt(dialog_result.snapshot): + if open_controller is None: + open_controller = OpenController(job) + dialog_result = open_controller.handle(dialog_result.snapshot, dialog_result.observed_snapshots, + target_pid=target_pid, launcher_pid=launcher_pid, worker_pid=process.pid, + show=version_prompt, perform=dialog_supervisor.backend.perform) if (consent is not None and dialog_agent is not None and dialog_result.error_code == 'DATABASE_RECOVERY_REQUIRED' and dialog_result.snapshot is not None and exact_prompt(dialog_result.snapshot)): @@ -1050,11 +1062,11 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run from .dialog_rules import archive_version_choice choice_path = archive_version_choice(dialog_result.snapshot, root) dialog_result = replace(dialog_result, detail=dialog_result.detail + f'\n版本候选与原生窗口证据:{choice_path}') - if (version_prompt is not None and consent is not None and dialog_agent is not None + if (version_prompt is not None and not request.diagnostic_only and dialog_agent is not None and dialog_result.snapshot.hwnd in {int(h) for h in process.desktop.EnumDesktopWindows()}): from .pcb_restore_prompt import RestoreController if restore_controller is None: - restore_controller = RestoreController(job) + restore_controller = RestoreController(job, user_open=consent is None) dialog_result = restore_controller.handle(dialog_result.snapshot, dialog_result.observed_snapshots, target_pid=target_pid, launcher_pid=launcher_pid, worker_pid=process.pid, companion_pids=tuple(process.companion_pids), @@ -1089,7 +1101,8 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run # recovery checks for remaining native database clients. _stop_worker(process, timeout=40) return finish(VerifyResult( - 'FAIL', + 'CANCELLED' if dialog_result.error_code == 'USER_CANCELLED' else + 'SKIPPED' if dialog_result.error_code == 'PCB_OPEN_SKIPPED' else 'FAIL', stderr=f'{dialog_result.error_code}: {dialog_result.detail}', error_stage=phase.value, safe_to_continue=False, @@ -1291,7 +1304,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run return finish(result) -def run_batch(requests, max_workers=1, verifier=None, *, stop=None, progress=None): +def run_batch(requests, max_workers=1, verifier=None, *, stop=None, progress=None, item_executor=None): """Run serially and stop when database/session safety is unconfirmed.""" if max_workers != 1: raise ValueError('Only serial Verify is supported for the shared Library Manager session') @@ -1308,10 +1321,18 @@ def run_batch(requests, max_workers=1, verifier=None, *, stop=None, progress=Non result = VerifyResult('SKIPPED', stderr='同库原生会话尚未释放,未启动新的写入') else: try: - result = verifier(request) + def execute(): + result = verifier(request) + if not result.safe_to_continue: + from .operation_lifecycle import recheck_failed_release + result = recheck_failed_release(request.lmc_file, request.block_name, result) + return result + result = item_executor(request, execute) if item_executor is not None else execute() except Exception as error: + from .operation_queue import QueueCancelled # An unexpected exception cannot establish database safety. - result = VerifyResult('FAIL', stderr=str(error), safe_to_continue=False) + result = VerifyResult('CANCELLED' if isinstance(error, QueueCancelled) else 'FAIL', + stderr=str(error), safe_to_continue=isinstance(error, QueueCancelled)) results.append(result) # Never start another writer after an unconfirmed native shutdown. if not result.safe_to_continue: diff --git a/tests/test_batch_item_yield.py b/tests/test_batch_item_yield.py new file mode 100644 index 0000000..5095ddf --- /dev/null +++ b/tests/test_batch_item_yield.py @@ -0,0 +1,100 @@ +from threading import Event,Thread + + +def test_normal_verify_batch_yields_after_complete_item(qtbot,tmp_path,monkeypatch): + from test_ui_filters import load_window + from cbb_refresh_verify.verify_runner import VerifyResult + started,release,waiting=Event(),Event(),Event() + order=[] + def verify(request): + order.append(request.block_name) + if request.block_name=='Beta':started.set();release.wait(5) + return VerifyResult('FAIL',stderr='independent failed item',safe_to_continue=True) + window=load_window(qtbot,tmp_path,monkeypatch,verifier=verify) + window._run(['Beta','Gamma']) + qtbot.waitUntil(started.is_set) + other=Thread(target=lambda:window.native_queue.run(lambda:order.append('other'),waiting=waiting.set)) + other.start() + try: + assert waiting.wait(1) + release.set() + qtbot.waitUntil(lambda:not window.busy,timeout=10000) + other.join(2) + assert order==['Beta','other','Gamma'] + finally:release.set();other.join(5) + + +def test_management_cancel_between_items_keeps_completed_results(tmp_path,monkeypatch): + from cbb_refresh_verify import management + from cbb_refresh_verify.operation_queue import QueueCancelled + from dataclasses import replace + request=management.ManagementRequest('remove',tmp_path/'lib.lmc','A') + def run(req,**kwargs): + return management.ManagementResult(req.operation,req.library,req.name,req.partition,None,False, + 'complete','REMOVED',True) + monkeypatch.setattr(management,'run_management',run) + def execute(req,action): + if req.name=='B':raise QueueCancelled('cancelled waiting for native slot') + return action() + results=management.run_management_batch([request,replace(request,name='B')],item_executor=execute) + assert [r.status for r in results]==['REMOVED','CANCELLED'] + assert all(r.safe_to_continue for r in results) + + +def test_cancelled_verify_keeps_summary_without_queueing_cancelled_refresh(qtbot,tmp_path,monkeypatch): + from test_ui_filters import load_window + from cbb_refresh_verify.verify_runner import VerifyResult + calls=[] + def verify(req): + calls.append(req.block_name) + window.stop.set() + return VerifyResult('CANCELLED',safe_to_continue=True) + window=load_window(qtbot,tmp_path,monkeypatch,verifier=verify) + window._run(['Beta','Gamma']) + qtbot.waitUntil(lambda:not window.busy,timeout=5000) + assert calls==['Beta'] + assert window.summary is not None + assert '队列未执行 1' in window.summary.detailedText() + + +def test_verify_failure_recheck_finishes_before_yielding_native_queue(qtbot,tmp_path,monkeypatch): + from test_ui_filters import load_window + from cbb_refresh_verify.verify_runner import VerifyResult + from cbb_refresh_verify import operation_lifecycle + from dataclasses import replace + window=load_window(qtbot,tmp_path,monkeypatch, + verifier=lambda req:VerifyResult('FAIL',safe_to_continue=False)) + active=[];seen=[] + def queued(action): + def run(): + active.append(True) + try:return action() + finally:active.pop() + return run + def recheck(library,block,result): + seen.append(bool(active)) + return replace(result,safe_to_continue=True) + monkeypatch.setattr(window,'_queued_action',queued) + monkeypatch.setattr(operation_lifecycle,'recheck_failed_release',recheck) + window._run(['Beta']) + qtbot.waitUntil(lambda:not window.busy,timeout=5000) + assert seen==[True] + + +def test_management_failure_recheck_finishes_before_yielding_native_queue(tmp_path,monkeypatch): + from cbb_refresh_verify import management,operation_lifecycle + from dataclasses import replace + request=management.ManagementRequest('remove',tmp_path/'lib.lmc','A') + monkeypatch.setattr(management,'run_management',lambda req,**kw:management.ManagementResult( + req.operation,req.library,req.name,req.partition,None,False,'complete','BLOCKED',False)) + active=[];seen=[] + def item(req,action): + active.append(True) + try:return action() + finally:active.pop() + def recheck(library,block,result): + seen.append(bool(active)) + return replace(result,safe_to_continue=True) + monkeypatch.setattr(operation_lifecycle,'recheck_failed_release',recheck) + management.run_management_batch([request],item_executor=item) + assert seen==[True] diff --git a/tests/test_external_owner_release.py b/tests/test_external_owner_release.py new file mode 100644 index 0000000..199be01 --- /dev/null +++ b/tests/test_external_owner_release.py @@ -0,0 +1,54 @@ +from contextlib import nullcontext +from pathlib import Path +import pytest +import win32con,win32file +from cbb_refresh_verify import library_lock as locks, residual_sessions as sessions +from test_residual_sessions import row, OWNERSHIP + + +@pytest.mark.parametrize('command', ['viewdraw.exe', 'cscript.exe C:/other/QuickPartReplace.vbs']) +def test_unknown_external_owner_requires_resources_not_process_exit(tmp_path, monkeypatch, command): + library=tmp_path/'lib.lmc';library.touch() + owner=dict(pid=998877,name=command.split()[0],command=command) + monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners',lambda *_:[owner]) + with locks._prove_library_released(library) as proof: + assert proof['exclusive_files']==[str(library)] + assert proof['observed_owners']==[owner] + handle=win32file.CreateFile(str(library),win32con.GENERIC_READ,0,None,win32con.OPEN_EXISTING,0,None) + try: + with pytest.raises(Exception) as denied: + with locks._prove_library_released(library):pass + assert denied.value.winerror == 32 + finally:handle.Close() + + +def test_unknown_observation_is_never_closed_or_counted_as_target(tmp_path,monkeypatch): + library=tmp_path/'lib/lib.lmc';library.parent.mkdir();library.touch() + foreign=dict(row(20,''),name='viewdraw.exe',command='viewdraw.exe',scope_confirmed=False) + target=dict(row(10,library.parent/'A.prj'),scope_confirmed=True) + monkeypatch.setattr(sessions,'query_process_snapshot',lambda:[target,foreign]) + monkeypatch.setattr(sessions,'_process_windows',lambda _: {}) + closed=[] + monkeypatch.setattr(sessions,'_request_close',lambda r,**kw:closed.append(r['pid']) or + dict(release_status='RELEASED',detail='closed')) + monkeypatch.setattr(sessions,'_finish_library_release',lambda *_:dict(status='RELEASE_CONFIRMED',library=str(library))) + result=sessions.release_residual_sessions(dict(library=str(library),sessions=[target,foreign]),tmp_path/'evidence') + assert result['status']=='RELEASE_CONFIRMED',result + assert closed==[10] + assert result['sessions'][1]['release_status']=='OBSERVED' + + +def test_explicit_target_owner_still_blocks_proof(tmp_path,monkeypatch): + library=tmp_path/'lib.lmc';library.touch() + monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners',lambda *_: + [dict(pid=998877,name='viewdraw.exe',command=f'viewdraw.exe "{library}"')]) + with pytest.raises(locks.LibraryBusy): + with locks._prove_library_released(library):pass + + +def test_our_unbound_worker_still_blocks_proof(tmp_path,monkeypatch): + library=tmp_path/'lib.lmc';library.touch() + monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners',lambda *_: + [dict(pid=998877,name='CbbRefreshVerify.exe',command='CbbRefreshVerify.exe --verify-worker missing.json')]) + with pytest.raises(locks.LibraryBusy): + with locks._prove_library_released(library):pass diff --git a/tests/test_late_release_continuation.py b/tests/test_late_release_continuation.py new file mode 100644 index 0000000..7ca8516 --- /dev/null +++ b/tests/test_late_release_continuation.py @@ -0,0 +1,28 @@ +import json +from dataclasses import asdict +from pathlib import Path +import pytest +from cbb_refresh_verify.verify_runner import VerifyRequest,VerifyResult,run_batch + + +@pytest.mark.parametrize('released',[True,False]) +def test_batch_rechecks_owned_failure_before_skipping_next_item(tmp_path,monkeypatch,released): + from cbb_refresh_verify import library_lock,session_record + library=tmp_path/'lib.lmc';library.touch() + root=tmp_path/'failure';root.mkdir() + session_record.write_session_record(root/'session.json',dict(operation_id='test',library=str(library),block='A')) + outcome=VerifyResult('FAIL',stderr='original failure',safe_to_continue=False, + evidence_path=root/'result.json',session_record_path=root/'session.json') + calls=[] + monkeypatch.setattr(session_record,'inspect_session_record',lambda *a,**k:dict(status='UNCONFIRMED')) + def proof(*a,**k): + if not released:raise library_lock.LibraryBusy('shared database still occupied') + return dict(status='RELEASE_CONFIRMED',library=str(library),data_recovery_confirmed=False) + monkeypatch.setattr(library_lock,'release_retained_library',proof) + def verify(req): + calls.append(req.block_name) + return outcome if req.block_name=='A' else VerifyResult('PASS') + results=run_batch([VerifyRequest(library,n,tmp_path/'evidence') for n in ('A','B')],verifier=verify) + assert results[0].status=='FAIL' and results[0].stderr=='original failure' + assert results[0].safe_to_continue is released + assert calls==(['A','B'] if released else ['A']) diff --git a/tests/test_library_lock.py b/tests/test_library_lock.py index 9712cdd..359d4e3 100644 --- a/tests/test_library_lock.py +++ b/tests/test_library_lock.py @@ -70,6 +70,28 @@ def test_verification_refuses_uploader_exclusive_lock_before_native_work(tmp_pat handle.Close() +@pytest.mark.parametrize('checkpoint_matches',[True,False]) +def test_auto_verify_reuses_only_exact_active_parent_transaction(tmp_path,monkeypatch,checkpoint_matches): + import json + from cbb_refresh_verify import library_lock as locks,verify_runner as runner + library=tmp_path/'library/lib.lmc';library.parent.mkdir();library.touch() + calls=[] + monkeypatch.setattr(runner,'_run_verify_serialized',lambda *a,**k: + calls.append('verified') or runner.VerifyResult('PASS',library_flag='GREEN')) + with locks.LibraryLock(library,block_name='A'): + if not checkpoint_matches: + marker=locks.blocker_path(library) + value=json.loads(marker.read_text('utf-8'));value['lease_id']='b'*32 + marker.write_text(json.dumps(value),'utf-8') + result=runner.run_verify(runner.VerifyRequest(library,'A',tmp_path/'evidence')) + assert (result.status=='PASS') is checkpoint_matches,result.stderr + assert calls==(['verified'] if checkpoint_matches else []) + if not checkpoint_matches: + # Restore only the fixture checkpoint so the enclosing test lease can exit. + owner=locks._owners[locks.LibraryLock(library).key] + value['lease_id']=owner['lease_id'];marker.write_text(json.dumps(value),'utf-8') + + def test_unsafe_verify_records_failure_without_persistent_library_blocker(tmp_path, monkeypatch): import json import cbb_refresh_verify.verify_runner as runner @@ -203,7 +225,8 @@ def test_release_rechecks_owners_after_database_handles_are_acquired(tmp_path, m calls = [] def query(names): calls.append(1) - return [] if len(calls) == 1 else [{'pid': 123456, 'name': 'cscript.exe', 'command': 'helper'}] + return [] if len(calls) == 1 else [{'pid': 123456, 'name': 'cscript.exe', + 'command': 'cscript.exe close_failed_block.vbs'}] monkeypatch.setattr(probe, 'query_owners', query) with pytest.raises(locks.LibraryBusy, match='123456'): with locks._prove_library_released(library): pass diff --git a/tests/test_native_engineering_identity.py b/tests/test_native_engineering_identity.py index 36623d0..d33153b 100644 --- a/tests/test_native_engineering_identity.py +++ b/tests/test_native_engineering_identity.py @@ -221,6 +221,48 @@ def test_export_does_not_adopt_unrelated_existing_native_owner(project, tmp_path assert len(started) == 3 +def test_export_does_not_adopt_existing_child_of_reused_parent_pid(project, tmp_path, monkeypatch): + import cbb_refresh_verify.native_engineering_identity as identity + import win32api + source, _ = project + root = tmp_path/'exports'; root.mkdir() + # This process predates the exporter; its historical parent PID has been reused. + unrelated = dict(pid=888888, parent=987654, name='python.exe', executable='python.exe', + command='python other-tool.py', created='20261111120000.000000+480') + monkeypatch.setattr(identity, '_process_snapshot', lambda: [unrelated]) + monkeypatch.setattr(identity, '_database_released', lambda _: True) + monkeypatch.setattr(identity, 'validate_export_output', lambda *_: None) + monkeypatch.setattr(win32api, 'OpenProcess', lambda *a: pytest.fail('adopted another tool')) + class Finished: + pid = 987654 + returncode = 0 + def __init__(self, *a, **k): pass + def poll(self): return 0 + monkeypatch.setattr(identity.subprocess, 'Popen', Finished) + result = identity._run_exports(source, root, tmp_path, 1) + assert result['success'] and result['safe_to_continue'] + + +def test_export_lineage_rejects_reused_owner_and_its_new_children(): + from cbb_refresh_verify.native_engineering_identity import _export_descendants, _process_birth + old = '20261112120000.000000+480' + new = '20261112120100.000000+480' + tracked = {10: _process_birth(old), 20: _process_birth(old)} + rows = [dict(pid=20, parent=10, created=new), dict(pid=30, parent=20, created=new)] + assert _export_descendants(rows, tracked, set()) == [] + assert 30 not in tracked + # An orphaned real child can outlive its exact original parent. + rows = [dict(pid=40, parent=10, created=new)] + assert _export_descendants(rows, tracked, set()) == rows + + +def test_export_lineage_rejects_child_older_than_native_handle_birth(): + from cbb_refresh_verify.native_engineering_identity import _export_descendants, _process_birth + tracked = {10: _process_birth('20261112120000.000000+480')} + rows = [dict(pid=20, parent=10, created='20261111120000.000000+480')] + assert _export_descendants(rows, tracked, set()) == [] + + @pytest.mark.parametrize('remains_alive,database_busy', [(False, False), (True, False), (False, True)]) def test_export_reobserves_access_denied_child_before_deciding_release( project, tmp_path, monkeypatch, remains_alive, database_busy): diff --git a/tests/test_native_export_guard.py b/tests/test_native_export_guard.py index 345549e..156bde7 100644 --- a/tests/test_native_export_guard.py +++ b/tests/test_native_export_guard.py @@ -161,6 +161,29 @@ def test_recorded_export_pid_reuse_requires_matching_creation_identity(export_ca with prove_export_copies_released(library): pass +@pytest.mark.parametrize('in_memory', [False, True]) +def test_preexisting_process_misrecorded_as_descendant_does_not_retain_copy(export_case, monkeypatch, in_memory): + import win32api, win32con + from cbb_refresh_verify import native_engineering_identity as identity + from cbb_refresh_verify.native_export_guard import prove_export_copies_released + library, root, *_ = export_case + record = dict(pid=123456, observed_pids=[123456, os.getpid()], process_identities=[ + dict(pid=123456, created='20261112120000.000000+480', executable='native'), + dict(pid=os.getpid(), created='20261111120000.000000+480', executable='other')]) + (root/'ascii-process.json').write_text(json.dumps(record),'utf-8') + monkeypatch.setattr(identity, '_process_snapshot', lambda: [dict(pid=os.getpid(), name='other.exe', + parent=123456, created='20261111120000.000000+480', executable='other', command='')]) + handle = win32api.OpenProcess(win32con.SYNCHRONIZE, False, os.getpid()) + try: + if in_memory: + monkeypatch.setattr(identity, '_retained_exports', [(SimpleNamespace(pid=123456,poll=lambda: 0), + {os.getpid(): handle}, dict(library=str(library),analysis_root=str(root)))]) + with prove_export_copies_released(library) as copies: + assert copies == [str(root/'project')] + finally: + handle.Close() + + @pytest.mark.parametrize('active', [False, True]) def test_unknown_checkpoint_requires_explicit_full_proof_and_no_native_export_owner(tmp_path, monkeypatch, active): import cbb_refresh_verify.native_engineering_identity as identity diff --git a/tests/test_pcb_open_consent.py b/tests/test_pcb_open_consent.py new file mode 100644 index 0000000..8a39bb5 --- /dev/null +++ b/tests/test_pcb_open_consent.py @@ -0,0 +1,114 @@ +from contextlib import nullcontext +from types import SimpleNamespace +from dataclasses import replace +import pytest +from test_post_repair_consent import snapshot + + +@pytest.mark.parametrize('decision,control', [('continue',6),('skip',7),('cancel',7)]) +def test_readwrite_requires_explicit_choice_and_consumes_once(tmp_path,monkeypatch,decision,control): + from cbb_refresh_verify import pcb_open_consent as consent + monkeypatch.setattr(consent,'validate_owner',lambda *a:('bound-owner',)) + monkeypatch.setattr(consent,'resource_guard',lambda *a:nullcontext()) + job=dict(root=str(tmp_path),block_name='A',lmc_file=str(tmp_path/'lib.lmc'),desktop='CbbVerify_test', + project=str(tmp_path/'A.prj'),pcb=str(tmp_path/'A.pcb')) + controller=consent.OpenController(job) + shown=[];sent=[] + def perform(s,p,phase): + sent.append(p);return SimpleNamespace(accepted_controls=(control,),error_code='',detail='',channel='win32_button_click') + kwargs=dict(target_pid=20,launcher_pid=10,worker_pid=5,show=shown.append,perform=perform) + first=controller.handle(snapshot(),(snapshot(),),**kwargs) + assert not first.error_code and len(shown)==1 and not sent + shown[0].choose(decision) + result=controller.handle(snapshot(),(snapshot(),),**kwargs) + assert len(sent)==1 and sent[0]['target']=={'control_id':control} + assert result.error_code==('' if decision=='continue' else 'PCB_OPEN_SKIPPED' if decision=='skip' else 'USER_CANCELLED') + controller.handle(snapshot(),(snapshot(),),**kwargs) + assert len(sent)==1 + + +def test_no_consent_to_changed_window_or_database_owner(tmp_path,monkeypatch): + from cbb_refresh_verify import pcb_open_consent as consent + monkeypatch.setattr(consent,'validate_owner',lambda *a:('bound',)) + def occupied(*a):raise ValueError('target database occupied') + monkeypatch.setattr(consent,'resource_guard',occupied) + controller=consent.OpenController(dict(root=str(tmp_path),block_name='A',lmc_file=str(tmp_path/'lib.lmc'), + desktop='CbbVerify_test',project=str(tmp_path/'A.prj'),pcb=str(tmp_path/'A.pcb'))) + shown=[] + kwargs=dict(target_pid=20,launcher_pid=10,worker_pid=5,show=shown.append,perform=lambda *a:pytest.fail('unsafe Yes')) + controller.handle(snapshot(),(snapshot(),),**kwargs) + shown[0].choose('continue') + result=controller.handle(snapshot(),(snapshot(),),**kwargs) + assert result.error_code=='DATABASE_RECOVERY_REQUIRED' and 'occupied' in result.detail + + +def test_explicit_open_dialog_defaults_to_cancel(qtbot): + from cbb_refresh_verify.pcb_open_consent import OpenChoice + from cbb_refresh_verify.ui.pcb_open_dialog import PcbOpenDialog + choice=OpenChoice('A','lib.lmc') + dialog=PcbOpenDialog(choice);qtbot.addWidget(dialog) + assert dialog.defaultButton() is dialog.cancel_button + dialog.skip_button.click() + assert choice.decision=='skip' + + +def test_normal_open_can_request_a_version_without_automatic_repair(tmp_path,monkeypatch): + from cbb_refresh_verify import pcb_open_consent as consent + from cbb_refresh_verify.pcb_restore_prompt import RestoreController + from test_pcb_version_choice import captured + monkeypatch.setattr(consent,'validate_owner',lambda *a:('owned',)) + job=dict(root=str(tmp_path),block_name='A',lmc_file=str(tmp_path/'lib.lmc'), + desktop='CbbVerify_test',project=str(tmp_path/'A.prj'),pcb=str(tmp_path/'A.pcb')) + controller=RestoreController(job,user_open=True) + snap=captured();shown=[];sent=[] + def perform(s,p,phase): + sent.append(p);return SimpleNamespace(accepted_controls=(p['target']['control_id'],),error_code='',detail='',channel='win32_button_click') + kwargs=dict(target_pid=snap.pid,launcher_pid=10,worker_pid=5,companion_pids=(),show=shown.append,perform=perform) + assert not controller.handle(snap,(snap,),**kwargs).error_code + assert len(shown)==1 and not sent + shown[0].choose('last_user_saved') + assert controller.handle(snap,(snap,),**kwargs).action_sent + selected=replace(snap,controls=tuple(replace(c,checked=c.control_id==6213,selected=c.control_id==6213) + if c.control_id in (6213,6206) else c for c in snap.controls)) + assert controller.handle(selected,(selected,),**kwargs).action_sent + assert [p['target']['control_id'] for p in sent]==[6213,1] + + +def test_readwrite_choice_survives_uia_chrome_enrichment(tmp_path,monkeypatch): + from cbb_refresh_verify import pcb_open_consent as consent + from cbb_refresh_verify.dialog_models import ControlSnapshot + monkeypatch.setattr(consent,'validate_owner',lambda *a:('owned',)) + monkeypatch.setattr(consent,'resource_guard',lambda *a:nullcontext()) + controller=consent.OpenController(dict(root=str(tmp_path),block_name='A',lmc_file='lib.lmc', + project='A.prj',pcb='A.pcb',desktop='CbbVerify_test')) + original=snapshot();shown=[];sent=[] + original=replace(original,controls=tuple(replace(c,name='是(&Y)' if c.control_id==6 else '否(&N)') + if c.class_name=='Button' else c for c in original.controls)) + def perform(s,p,phase): + sent.append(p) + return SimpleNamespace(accepted_controls=(6,),error_code='',detail='',channel='win32_button_click') + kwargs=dict(target_pid=20,launcher_pid=10,worker_pid=5,show=shown.append,perform=perform) + controller.handle(original,(original,),**kwargs) + shown[0].choose('continue') + chrome=(ControlSnapshot(original.hwnd,0,original.window_class,original.title, + control_type='Window',patterns=('Window',)), + ControlSnapshot(0,0,'','',control_type='TitleBar',patterns=('Value',))) + enriched=replace(original,controls=tuple(replace(c,name=c.name.replace('&','')) + if c.class_name=='Button' else c for c in reversed(original.controls))+chrome) + assert consent.exact_prompt(enriched) + result=controller.handle(enriched,(enriched,),**kwargs) + assert not result.error_code and len(sent)==1 + + +def test_readwrite_choice_rejects_replaced_native_button(tmp_path,monkeypatch): + from cbb_refresh_verify import pcb_open_consent as consent + monkeypatch.setattr(consent,'validate_owner',lambda *a:('owned',)) + controller=consent.OpenController(dict(root=str(tmp_path),block_name='A',lmc_file='lib.lmc')) + original=snapshot();shown=[] + kwargs=dict(target_pid=20,launcher_pid=10,worker_pid=5,show=shown.append, + perform=lambda *a:pytest.fail('changed native button accepted')) + controller.handle(original,(original,),**kwargs) + shown[0].choose('continue') + changed=replace(original,controls=tuple(replace(c,handle=c.handle+1) if c.control_id==6 else c + for c in original.controls)) + assert controller.handle(changed,(changed,),**kwargs).error_code=='DATABASE_RECOVERY_REQUIRED' diff --git a/tests/test_residual_sessions.py b/tests/test_residual_sessions.py index 90c5572..fb6097f 100644 --- a/tests/test_residual_sessions.py +++ b/tests/test_residual_sessions.py @@ -53,7 +53,8 @@ def test_unknown_scope_is_visible_but_never_closed_even_with_force(tmp_path, mon monkeypatch.setattr(sessions, '_force_close', lambda *a, **kw: pytest.fail('ended unknown scope')) for force in (False, True): result = sessions.release_residual_sessions(plan, tmp_path.parent/'release-evidence'/tmp_path.name, force=force) - assert result['status'] == 'PARTIAL' + assert result['status'] == 'RELEASE_CONFIRMED' + assert result['sessions'][0]['release_status'] == 'OBSERVED' # A request file becoming readable must not expand the user's consent list. monkeypatch.setattr('cbb_refresh_verify.library_lock._owner_matches_scope', lambda *a: True) result = sessions.release_residual_sessions(plan, tmp_path.parent/'release-evidence'/tmp_path.name, force=True) diff --git a/tests/test_session_record.py b/tests/test_session_record.py index 656b1e9..3fe9736 100644 --- a/tests/test_session_record.py +++ b/tests/test_session_record.py @@ -38,6 +38,16 @@ def test_round_trip_and_exact_live_process(tmp_path, child): assert child.poll() is None +@pytest.mark.parametrize('exited', [True, False]) +def test_unconfirmed_journal_is_active_only_while_bound_native_is_alive(tmp_path, child, monkeypatch, exited): + path=record(tmp_path,[dict(role='native',**sessions.process_identity(child.pid))]) + sessions.write_session_record(path.with_name('worker-state.json'),dict(operation_id='test-session',phase='UNCONFIRMED')) + monkeypatch.setattr(sessions,'_retained_libraries',{str(path):{sessions._library_key(tmp_path/'lib.lmc')}}) + if exited:child.terminate();child.wait(5) + writes=sessions.active_write_records(tmp_path/'lib.lmc') + assert bool(writes) is not exited + + @pytest.mark.parametrize('key,value', [('created_handle', 'old'), ('image', 'C:/old.exe'), ('owner_sid', 'S-1-old'), ('session_id', -1)]) def test_reused_pid_is_observed_never_acted_on(tmp_path, child, key, value):