fix: finish owned idle sessions before proving resource release

This commit is contained in:
阿白叔 committed 2026-11-19 11:14:49 +08:00
1 parent 3bde847ff7
commit 55cdf2b082
10 files changed
+632 -8

No files matched your search

@@ -0,0 +1,210 @@
{
"date": "2026-11-19",
"baseline": "3bde847",
"branch": "codex/issue17-batch-cleanup",
"scope": "Source GUI/native, deliberately delayed owned empty PCB cleanup in isolated constructed failure; not customer-original or frozen EXE acceptance",
"tests": {
"tests": 2500,
"failures": 0,
"errors": 0,
"skipped": 0
},
"test_seconds": 459.075,
"batch": {
"1GPHY_8212": "FAIL",
"1GPHY_RTL8211F": "PASS"
},
"batch_seconds": 327.85899999999674,
"owned_idle_cleanup": "CLIENT_EXITED",
"original_business_status": "FAIL",
"original_safe_to_continue": false,
"late_resource_safe_to_continue": true,
"release_proof_scope": "BLOCK",
"process_identities_checked": 8,
"exclusive_files_checked": 7,
"source_under_test_sha256": {
"src/cbb_refresh_verify/application.py": "aa02778f4ea4665a9d94926ae86fca32f7dadb535d1460b13fdbb064113eaf33",
"src/cbb_refresh_verify/backup_recovery.py": "eb5813b442de668650fff1ee800d3fba1409af233e374ea37b6ced688cc630e9",
"src/cbb_refresh_verify/batch_status.py": "55a4007cf54491ca8e045a5bf86aa4353ac8437cca5a76cd79304962e3d3fa0a",
"src/cbb_refresh_verify/close_failed_block.vbs": "e5f0d9678e07a239e96e634b90cdc761de52fc136311fae31484fa38d6fd9781",
"src/cbb_refresh_verify/com_runtime.py": "f0f3802d16c791a8bf9dfef44a94917072bfbe8fb3a927d76be8ef0341c7ed35",
"src/cbb_refresh_verify/content_check.py": "8239c17b6e2452917ed573a7deb3e4c8583eaef91bf3630eff5f424d2e398aa9",
"src/cbb_refresh_verify/defaults.py": "a1c03192f4a61ad0924b24bb635705b1ee4811d35483a02864200f95edbbebe3",
"src/cbb_refresh_verify/desktop_worker.py": "81d58513369046300f81cec20a43c3e681e38e46e8131427b354f9dff0e5241a",
"src/cbb_refresh_verify/diagnostic_open.py": "32bef6547d61fe36cbb7c21f35bd45419c4cdaf10c70452ee2368269e6c75d94",
"src/cbb_refresh_verify/dialog_agent.py": "5acb6e5cf1350a7ca20a6fe480668435fac785835874f266881973010db6504b",
"src/cbb_refresh_verify/dialog_models.py": "f68cee01d927b48364276d3c1f79e63ce8af231878db0b907d292780cfbafb56",
"src/cbb_refresh_verify/dialog_probe.py": "d6ecd359d9e5dbc9376c0a5b123c881670fc01d60dd3290a5f6468a2f599462f",
"src/cbb_refresh_verify/dialog_rules.py": "5531ea7b34cf2094629e7a750cb32a678701c5353a97616bcf7a89b903e386a1",
"src/cbb_refresh_verify/dialog_supervisor.py": "b0eb0aa92a18498843b51b6d8697bd0abfe8b014e1c545e32ddcc8baf7ff7274",
"src/cbb_refresh_verify/failed_session.py": "2b8a6321e1f4ff9b697d0e01ca85a8dd6e3672d3b32a9a6e4816cf495572e1a5",
"src/cbb_refresh_verify/file_probe.py": "2471d605bdee5eda781ea96f89bbfb598357c4cdfa5f7d99a8bc9ae882e12240",
"src/cbb_refresh_verify/icdb_maintenance.py": "e81d253d8b4d3e7c1000c45335a392c72b110748675c2c3324ebe524a7252e98",
"src/cbb_refresh_verify/icdb_ownership.py": "b1e25e5eddce70292c0ea2f67c2a3533273e64746b36d500b501b096470f7a5d",
"src/cbb_refresh_verify/icdb_recovery.py": "2d5ef548335ac0ca277241326ee51f5a015d327a646a7c7aa60f67165c1bfca1",
"src/cbb_refresh_verify/integration.py": "f188856af69ba25e265988c51db7a6d4263326440d972ca78378b733b891c1ed",
"src/cbb_refresh_verify/library_lock.py": "b55b608352c68ef30ad8e70a762bb148136a05adc1c2b71a261d50039a420507",
"src/cbb_refresh_verify/library_manager_verify.py": "71e16a8581ad44b646be78b480f9812d596a6d162b3eec03d078bf4ea4503195",
"src/cbb_refresh_verify/library_reader.py": "7831b502aa1f637426ab2e22f11cb6666e69200b7615925050a5af7472a84b2b",
"src/cbb_refresh_verify/maintenance_entry.py": "ddd0480ad8b04fd99462befbe6683bace526bf5085afb1ee3de918f30e796683",
"src/cbb_refresh_verify/management.py": "1a5d33cc75577de11bfbd06c780a46e4679089b44c42f51454e2fdbb4ac4b7ad",
"src/cbb_refresh_verify/management_transaction.py": "53ed1564d42492465c90117eeeeee25aa93324b5ddca702d0827ec786c75b1a1",
"src/cbb_refresh_verify/mentor_adapter.py": "b9485603e42fc098ba93fd90b5adce7b0b89085ede6390019d3be9332795eb18",
"src/cbb_refresh_verify/mentor_paths.py": "ba48c0003b3eacc88906497b2e43b299ca4536a9f7dae44bbacf6a6ec694c116",
"src/cbb_refresh_verify/models.py": "94d9d28c61ff7642ae59ac9af91a698bffd15c86a995295576fbbb2143faf789",
"src/cbb_refresh_verify/native_add_failures.py": "192202732423dc624c5548c75e80bb20973e5087c21d4798c9637f25b6de7e94",
"src/cbb_refresh_verify/native_backup.py": "152235f69aefe1bd1338fdd0ed2dec8afb7355de63399f746b02e31047be7909",
"src/cbb_refresh_verify/native_engineering_identity.py": "8c0fc144707d68a9b85f6da50ef950f1f6e7fee248acbf34d19b707d51212be0",
"src/cbb_refresh_verify/native_export_guard.py": "3f6af07737ee670584e6fa9d004c040cf318c3d568e8fa82f84eb70d351b3d6a",
"src/cbb_refresh_verify/native_management.py": "38503011be1c0d4755dd72a4d283d7704937aa576e9f8f9fc3382fc9f4b0be4e",
"src/cbb_refresh_verify/native_occupancy.py": "7d686079d12217382adace6361cd343d977b91075e3b157cf410ca92d07ffc49",
"src/cbb_refresh_verify/native_repair.py": "a720758b8195fd399c81673c13a1d38e69917c9c053e28967ff4e75f40118950",
"src/cbb_refresh_verify/native_repair_ui.py": "9bfb413193d9a917f5ac71d5826e6682b3d0e40d822a5f8366a28f71ca542690",
"src/cbb_refresh_verify/network_path.py": "6b5b159502d42a46bf4ee26d5698fd2c6498b359088e2138eae46e9065b13c6f",
"src/cbb_refresh_verify/operation_lifecycle.py": "b8bebad94885e576403b099d9819027e59834bf25185b3ccabfccdc375d16055",
"src/cbb_refresh_verify/operation_queue.py": "7a2f08d4bc32d1de0a3151d509d41e676fbc962aba2a9346008c71a48adf0e79",
"src/cbb_refresh_verify/owner_probe.py": "8dcfd60246cb2979db34d02e0a2d605c334b6f7e2666f22daa2f50c0408bc903",
"src/cbb_refresh_verify/pcb_bridge.py": "2f6c2b09642100468814500569dbfc6695fc2a46b9a3b8333daa8e1530cdeef5",
"src/cbb_refresh_verify/pcb_open_consent.py": "ba4d8da5ce3f7ed924621eb37b925371f14d074acaf9814adfb0f77fc6bb73e1",
"src/cbb_refresh_verify/pcb_restore_prompt.py": "a488ab48845173f463042c17ad1e719fe37a4bcf98a660f06453eef171b0e7bb",
"src/cbb_refresh_verify/post_repair_consent.py": "3b1eaff1db58fd311a9dbc5fdcd850911b04cc5afd4e747f70a62b721b8fafa4",
"src/cbb_refresh_verify/post_verify_diagnostics.py": "2442de485bc0d6a34c4b2d9b10bc5f323ea38f9ff66674119a50f5c6043bac63",
"src/cbb_refresh_verify/reimport_recovery.py": "ef148549751fa47518f5f2ca8f32ba25794ec5f22e0de545476ea33f89a3f0bf",
"src/cbb_refresh_verify/residual_sessions.py": "fa5ae0d857b8791b444d3b35366d4b311e444da61c042f77eb157ca3ab970ad1",
"src/cbb_refresh_verify/runtime_logging.py": "44ac25430a89c5ffc9e48e88c227e88052f4c815365e8556f67918f3edaba39e",
"src/cbb_refresh_verify/runtime_timing.py": "c4ed4057b5000e0b86ccc7dd1fe2004d6e0dae29f397fec77b01ad41a81c6367",
"src/cbb_refresh_verify/save_verified_block.vbs": "862fc40f4cf59c73ff0efa3dee1de3fff92df019e43cce46d4fa337378087143",
"src/cbb_refresh_verify/scoped_manifest.py": "f141cfedc901ddadb9be837bc0cbb69c57614d44ab9c347d63bbfa15d4be4a8b",
"src/cbb_refresh_verify/session_record.py": "d0fdcd3c403ce09adc49857340c0bbef7caae31e1360a0d2d4c9e7d2d5062b16",
"src/cbb_refresh_verify/status_bridge.py": "05d627d02934a14f5de409472c291d37565a95b836f9c130111aae80612e9196",
"src/cbb_refresh_verify/verify_diagnostics.py": "041b77d7d49e4c86338ed5e5741d0d27a2c42bc358f4da54b3efe64af847e9b8",
"src/cbb_refresh_verify/verify_probe.py": "3ed743df49d195c74f5045985ab23491d103ee2c42c07b558c1e037176402ed2",
"src/cbb_refresh_verify/verify_runner.py": "214f9a7313369d45f03141c0c99fbbe1038f936ba8821c17eabc4780df2caf81",
"src/cbb_refresh_verify/write_admission.py": "c5f879bd5cb70a5dedfc64349c8758bf370daa4240491addd2aecd344f3a935c",
"src/cbb_refresh_verify/__init__.py": "673ad8f884cd8a8f4c4097b348be1b77999ec018bdc6c70ab26b8cc383669878",
"src/cbb_refresh_verify/__main__.py": "dc4be034a0e43d4b659a9300137c29a6a6b7a32b7eaef02b6dff9a88c41305c0",
"src/cbb_refresh_verify/assets/cbb_refresh_verify.ico": "62d4472ebaa94f9b39aebae06459685d3322041d0e1a7ada9f368cfd816ba1d6",
"src/cbb_refresh_verify/assets/cbb_refresh_verify.png": "840f657fd7c622d9afd78625a64ed8ad04c90a895dd3c9fd37eebae543cdebe8",
"src/cbb_refresh_verify/assets/cbb_refresh_verify.svg": "cbba5b3f339cbeb5eb43012709237359442ef67c69fc5b6679a8ee4c0a1b7328",
"src/cbb_refresh_verify/assets/dialog_rules.v1.json": "3911080fc799a819662e225a7ad73e883abd8dcc9936cc30ec1b2d6d51a03c6e",
"src/cbb_refresh_verify/ui/backup_notice.py": "1a3fa5ac18a267907faf95f36d61b9f08bcbb939eef4d480dd06af1391a81599",
"src/cbb_refresh_verify/ui/backup_recovery_dialog.py": "5453c1b61ad2969cb3071d7ccf0bba571bcb0d1dac8270b3c96ec0dd1c3d88ff",
"src/cbb_refresh_verify/ui/icdb_check_task.py": "70a678e632487e0e829798284ee7644af0ecb0b27212866dfb23cdb6db6e168d",
"src/cbb_refresh_verify/ui/main_window.py": "368263a7aa57a85de4c76485ff83d68e12bcfd6254a874425bcaa53049c258a1",
"src/cbb_refresh_verify/ui/management_dialog.py": "fc67d7d3a4ba07ccbff5b40f789192c85c8dafa64349446e6a7d86b5f20941d2",
"src/cbb_refresh_verify/ui/pcb_open_dialog.py": "1b9689d555d221567263b6b587250b51a11bef276c35d64393e1b3d13803c625",
"src/cbb_refresh_verify/ui/pcb_restore_dialog.py": "11479db5520310af37824e083cb678d69d4cfd12f70dcd29ccb906b929e3d9bd",
"src/cbb_refresh_verify/ui/residual_release_dialog.py": "c2ebc63dd67186dff8ab2300a04ec173219314c2ad01cc70621630f30295a9cc",
"src/cbb_refresh_verify/ui/timed_prompt.py": "bafd5027d396e50458e4bd81e4596be51ebf87353f688e31943a97d71d2d5121",
"src/cbb_refresh_verify/ui/workers.py": "4cc9360a4820ded27a7d5ef709fc9f04b1d4804cb1e7a614f6c357ed547da888",
"src/cbb_refresh_verify/ui/write_owner_dialog.py": "65dc3c8287f4ac5dc767797c13e192f6bd916f9051570a33a2b18f4f8334c3b3",
"src/cbb_refresh_verify/ui/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
},
"original_source_postcheck": {
"status": "PASS",
"source": "G:\\CbbIssue15FinalAccept-20261117\\run-final-01\\library",
"checked_at": "2026-11-19T02:50:46.654715+00:00",
"files": 28348,
"missing": [],
"added": [],
"changed": [],
"excluded": "top-level .mentor_lib.cbb-upload.* coordinator files, matching pre-test manifest"
},
"automatic_followups": 1,
"application_exit": 0,
"forced_terminations": 0,
"native_lock_deletions": 0,
"evidence_sha256": {
"G:\\CbbOwnedRelease-20261119\\source-under-test.json": {
"bytes": 9066,
"sha256": "c5f04fa2c48582cf3538d17f7e7357b9ebcbd038d36d067f30c35fe8072ef2ec"
},
"G:\\CbbOwnedRelease-20261119\\fault-injection.json": {
"bytes": 2503,
"sha256": "1fb89d1b8c2a84d80393ede444ab11b6aa80264f9ec2ab1552550458ae2f964f"
},
"G:\\CbbOwnedRelease-20261119\\actual-result.json": {
"bytes": 6261,
"sha256": "efeedd20114e13796c9001c6aaf1c936e40448e3c1e0d366b3e08703e9218820"
},
"G:\\CbbOwnedRelease-20261119\\closure-proof.json": {
"bytes": 16836,
"sha256": "d772e924022bfae174004300516eb96eb7c72aab851b568407ba6dc3c214eca6"
},
"G:\\CbbOwnedRelease-20261119\\preparation-result.json": {
"bytes": 17126,
"sha256": "288913089686d6cee5e420bc1feba8ab5ddf40d97d1254be9b200afbcf35dc31"
},
"G:\\CbbOwnedRelease-20261119\\original-source-postcheck.json": {
"bytes": 321,
"sha256": "db9851f093513fbaa52bb66863664ea52dfb126b7de81f659ef92d8b427c4d69"
},
"G:\\CbbOwnedRelease-20261119\\native\\run-source-01\\data\\evidence\\verify-b5a731c7b22a\\result.json": {
"bytes": 1356,
"sha256": "21fd5904fa62fcf71a2b9dd24aa906b5046bdb5d372e89034dc322e504b44dd5"
},
"G:\\CbbOwnedRelease-20261119\\native\\run-source-01\\data\\evidence\\verify-b5a731c7b22a\\session.json": {
"bytes": 2387,
"sha256": "3b7341f101f1b655db6521b111b81596e250f2f4528e8224a200fab435e30d28"
},
"G:\\CbbOwnedRelease-20261119\\native\\run-source-01\\data\\evidence\\verify-b5a731c7b22a\\startup-close.json": {
"bytes": 1658,
"sha256": "4342b450f365769ae0664d86e4905a960a47c228c7882896949adb6b604036d5"
},
"G:\\CbbOwnedRelease-20261119\\native\\run-source-01\\data\\evidence\\verify-b5a731c7b22a\\owned-idle-cleanup-result.json": {
"bytes": 764,
"sha256": "cb60648b4d474ac36f961d4d22acdbdccf683cd4cd4265d91704b41fc94ba47b"
},
"G:\\CbbOwnedRelease-20261119\\native\\run-source-01\\data\\evidence\\verify-b5a731c7b22a\\late-release-result.json": {
"bytes": 5657,
"sha256": "b5c7558f75187bdd4e3556863b1f61e42eb10e82bbc39d090200eb7f386c3776"
},
"G:\\CbbOwnedRelease-20261119\\native\\run-source-01\\ui-01\\results\\1795056556817677800-f459.json": {
"bytes": 100,
"sha256": "9f0cb90cca6bc4388da6e21884e13772fd658272d89b1d4f294f0648cc828d40"
},
"G:\\CbbIssueLatest-20261118\\checks\\owned-release-final-full.log": {
"bytes": 2979,
"sha256": "e195023875728737aac8252af3b60a2550fd03d882348e3b5119bfe961c5b2e1"
},
"G:\\CbbIssueLatest-20261118\\checks\\owned-release-final-full.xml": {
"bytes": 364840,
"sha256": "22868613cbbc42603ba9706a69a763408501e4737b37ad273afedd8c40024e95"
},
"G:\\CbbIssueLatest-20261118\\checks\\owned-release-full.log": {
"bytes": 8164,
"sha256": "13144d335d9810ea17d86cd5c69637d9d2ad895919471bbf218e52e1560309cb"
},
"G:\\CbbIssueLatest-20261118\\checks\\owned-release-full.xml": {
"bytes": 369719,
"sha256": "b38fb41722f538db280c17c9b660efe3f221827718b968739108f1c4b0f99751"
},
"G:\\CbbIssueLatest-20261118\\checks\\owned-release-metadata-green.log": {
"bytes": 215,
"sha256": "fb872df90264cbf29bd633aed47619c8699d3d78fa3ae54c2a99119b22c1d9f6"
},
"G:\\CbbIssueLatest-20261118\\checks\\owned-idle-red.log": {
"bytes": 40884,
"sha256": "c120c4601b49a7d78fb6bf43f6d67741bbb5997f8d121b237e5c054073018c24"
},
"G:\\CbbIssueLatest-20261118\\checks\\retained-target-red.log": {
"bytes": 14393,
"sha256": "22fc9e83e0badc075193472a3a3326ab8c5e63ba6f932b410d94bbecf7227771"
},
"G:\\CbbIssueLatest-20261118\\checks\\owned-cleanup-binding-red.log": {
"bytes": 6208,
"sha256": "f3916183b5de3c755ee0de0dc5d2979378fa1dbecae865b8d25cb9499eaab89d"
},
"G:\\CbbIssueLatest-20261118\\checks\\owned-cleanup-binding-green.log": {
"bytes": 296,
"sha256": "46d2ef54e220d7757628be683706ac5e3582909ab179dd75b961ed4f5541d2fb"
},
"G:\\CbbIssueLatest-20261118\\owned-release-review.md": {
"bytes": 13350,
"sha256": "7cf8e8d5652af4382397e6507a280dfaacb41a10ad4f06d395d9aebb55fc3006"
}
},
"merged": false,
"released": false,
"issue_closed": false
}
@@ -0,0 +1,52 @@
# 本任务会话主动收尾与共享资源释放验证
基线:`3bde847`;分支:`codex/issue17-batch-cleanup`。日期:2026-11-19。
## 已确认的问题
1. `recheck_failed_release` 发现登记进程 ACTIVE 时直接返回;后台观察只接续已取消的启动,没有接续终态失败后本任务留下的空闲客户端。
2. 普通校验的 `LibraryLock(checkpoint=False)` 没有携带 `block_name`,保留租约成为无工程身份的整库范围。已实际复现:目标 Bad 的释放,被无关 Other 工程的 `sAddress.adr` 扩大阻塞。
3. 文件占用探测返回 Win32 32/33 时没有文件路径,无法从记录中准确判断是工程还是共享数据库占用。
## 当前收尾顺序
失败仍保持失败。先观察本次精确会话;只对已登记且工作进程/助手已退出的安全空客户端执行一次正常关闭,再独立证明工程和共享资源释放,之后才允许同库后续项继续。
自动正常关闭的条件为:请求、会话、操作、库、私有桌面和结果匹配;Verify 结果还必须匹配 CBB 名称及自身证据路径;进程创建身份、镜像、用户和 Windows 会话一致;所有 worker/helper 原身份已退出;没有其他原生写入任务。仅接续明确数据库启动失败且未进入 Save 的空 PCB、保存/关闭均有明确返回的空 PCB,或本任务只读目录调用留下的空 Library Manager。
有文档(包括隐藏文档)、未知窗口、进度、保存结果未知、身份变化、记录损坏、正在运行的工作进程或其他任务时不自动关闭。服务器不作为自动关闭目标。关闭前持久化一次性意图,并再次核对窗口、请求、结果和 worker-state;状态变化即不发送 Close。正常关闭等待最多 3 秒,不循环发送、不强杀、不删除原生锁。
`CLIENT_EXITED` 只描述客户端退出,明确保留 `resource_release_confirmed=false`。随后仍需独立释放证明覆盖目标工程、LMC 与 SymbolLibs 共享数据库。Verify 租约现在携带目标 CBB,复核不再无故扫描全部其他工程。共享库或其他程序仍占用时保留未释放状态;实际 Win32 32/33 记录为 IN_USE,保存准确的 `blocked_resources` 路径,超时/权限/无法确认等仍为 UNCONFIRMED。历史业务结果文件不被修改。
冷启动发现旧会话时仍按只读观察处理;用户的明确释放操作保持原有入口。新主动收尾接在正在执行的批次复核及非只读后台收尾观察中。
## 回归证据
自动化日志位于 `G:/CbbIssueLatest-20261118/checks`。
- `owned-idle-red`:18 条新增测试先失败,复现被动观察不能正常收尾的缺口。
- `retained-target-red`:真正文件探测复现无关 Other 地址扩大释放范围;补上租约 block_name 后通过。
- `owned-release-observer`:真实 Win32 share=0 句柄占住共享 icdb,客户端正常关闭但资源仍未释放;同时发现错误缺少路径,随后补齐。
- `owned-cleanup-parser-red`、`owned-cleanup-binding-red`:错误 JSON 类型、错置结果和意图持久化后状态改变均先复现,再修正为拒绝动作。
- 早期相关回归 162 项通过;随后资源回归 51 项通过;最终相关回归 84 项通过。编译与差异格式检查通过。
- 首轮全量 `owned-release-full` 保留 2 failed / 2,498 passed:恢复交接测试的 300ms 时限在实际文件复制到达其指定停顿点前触发,失败断言为 `entered.is_set()`,不是晚安装或跨库准入失效。仅调整该用例的局部时钟:准备期间冻结,到指定边界后推进以触发真实交接,再恢复实时时钟验证租约与后续操作。文件复制、库锁、TaskHandoff 与“不晚安装/不晚校验”断言均保留,未放宽产品超时;40 项相关用例通过。最终全量另记,不覆盖失败日志。
- 最终 `python -X utf8 G:/CbbIssueLatest-20261118/run_checks.py owned-release-final-full -q`:**2,500 passed,0 failed/error/skipped**,461.69 秒,实际退出码 0。相邻 JSON 保存测试统计、源码指纹和证据 SHA-256;独立复核无遗留代码问题。
- `G:/CbbOwnedRelease-20261119/original-source-postcheck.json`:原始隔离输入 28,348 个文件的 SHA-256、大小、修改时间及集合一致,新增、缺失、修改均为 0;排除项仍是复制前清单明确排除的旧顶层协调文件。
## 实际应用按钮验收
独立证据目录:`G:/CbbOwnedRelease-20261119`。复用此前明确隔离的库和构造损坏头部;健康项通过原生同名更新准备为 PENDING,未替换校验后端。76 个源码与资源 SHA-256 在运行前冻结、运行后逐一核对。
为了实际触发旧收尾失败,验证驱动只对本轮已登记、身份核实的私有桌面空 PCB 窗口临时设置不可用。原生数据库加载错误仍被正常识别;等待原始 `startup-close.json` 返回 RETAINED 后,立即恢复窗口可用。恢复不发送 Close、不结束进程;后续 Close 由产品自身完成。这是刻意制造的收尾延迟,不是客户现场原始故障复现。
`fault-injection.json`:PCB PID 65168,桌面 `CbbVerify_0058861f6eea`,干预仅两次 EnableWindow(false),66.469 秒后恢复;原收尾记录 PCB/启动器未退出、safe=false。
`verify-b5a731c7b22a/session.json` 保存一次 `owned_idle_cleanup`;`owned-idle-cleanup-result.json` 为 CLIENT_EXITED。原 `result.json` 仍是 FAIL/`MENTOR_DATABASE_LOAD_FAILED`、safe=false;独立 `late-release-result.json` 保存业务 FAIL、资源 safe=true 及 fresh RELEASE_CONFIRMED,范围为该 CBB 加共享数据库,明确包含 `SymbolLibs/__ReusableBlocksSymb/icdb.dat`。
后续 RTL 实际继续执行:首轮 `verify-5d4a9fe55bb4` 完成保存关闭、权威 PENDING;自动一次 `verify-8a460f0dd044` 后 PASS/GREEN、权威 READY。两轮累计 188.453 秒;批次共 327.859 秒,恰好 FAIL/PASS 两行,零 SKIPPED。运行期间切换筛选、清空勾选、切换页签,提交目标不变。
`closure-proof.json`:8 个登记进程身份退出、7 个关键文件独占打开、76 个源码指纹一致;保留原始失败与收尾失败,实际未强杀、未删原生锁。应用随后正常关闭 exit 0,控制回执位于 `native/run-source-01/ui-01/results`。只读 Library Manager 空壳自动收尾有回归覆盖,本轮未另外制造其真实残留。
## 边界
客户原始故障一致副本、冻结 EXE 和所有安装环境未在本轮验收。真实共享写入或未知保存状态仍不能强行解除;这个保护不会被“继续下一项”的要求替代。本轮不合并、不发行、不关闭工单。
+8 -2
View File
@@ -41,6 +41,7 @@ def hold_release_files(library, roots=None, *, timeout_seconds=10, stop=None):
if record.get('token') != token or record.get('status') != 'HELD' or process.poll() is not None:
error = OSError('FILE_PROBE_UNCONFIRMED: '+str(record.get('error', '探测身份或句柄失效')))
error.winerror = record.get('winerror')
error.blocked_resources = record.get('blocked_resources', [])
raise error
# Duplicate the already-open handles before acknowledging the probe.
# Its exit can never create a gap in the parent's commit protection.
@@ -108,6 +109,7 @@ def file_probe_main(job):
job = Path(job)
request = json.loads(job.read_text('utf-8'))
result = {'token': request['token'], 'status': 'UNCONFIRMED'}
opening = None
try:
def checked_path(value):
path = Path(value).absolute()
@@ -127,15 +129,18 @@ def file_probe_main(job):
with ExitStack() as stack:
handles = []
for path in snapshot['exclusive_files']:
opening = path
handle = win32file.CreateFile(path, win32con.GENERIC_READ, 0, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
stack.callback(handle.Close)
handles.append(int(handle))
for path in snapshot['binding_files']:
opening = path
handle = win32file.CreateFile(path, win32con.GENERIC_READ, win32con.FILE_SHARE_READ,
None, win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
stack.callback(handle.Close)
handles.append(int(handle))
opening = None
if _snapshot(library, roots) != snapshot:
raise ValueError('占用检查期间资源集合变化')
pending = job.with_name('result.pending')
@@ -145,7 +150,8 @@ def file_probe_main(job):
return 0
except Exception as error:
pending = job.with_name('result.pending')
pending.write_text(json.dumps({**result, 'error': str(error),
'winerror': getattr(error, 'winerror', None)}), 'utf-8')
blocked = [opening] if opening and getattr(error, 'winerror', None) in (32,33) else []
pending.write_text(json.dumps({**result, 'error': (opening+': ' if opening else '')+str(error),
'winerror': getattr(error, 'winerror', None), 'blocked_resources': blocked}), 'utf-8')
pending.replace(job.with_name('result.json'))
return 1
+2
View File
@@ -559,6 +559,7 @@ def _prove_library_released(library, block_name=None, *, block_names=(), allow_u
except OSError as error:
blocked = LibraryBusy(str(error))
blocked.winerror = getattr(error, 'winerror', None)
blocked.blocked_resources = getattr(error, 'blocked_resources', [])
raise blocked from error
note_metadata_progress()
if files['addresses']:
@@ -576,6 +577,7 @@ def _prove_library_released(library, block_name=None, *, block_names=(), allow_u
except OSError as error:
blocked = LibraryBusy(str(error))
blocked.winerror = getattr(error, 'winerror', None)
blocked.blocked_resources = getattr(error, 'blocked_resources', [])
raise blocked from error
if any(current[key] != files[key] for key in (
'exclusive_files', 'addresses', 'signatures', 'inspection_targets')):
+17 -3
View File
@@ -28,7 +28,10 @@ def recheck_failed_release(library, block, result, *, stop=None, timeout_seconds
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
from .residual_sessions import finish_owned_idle_session
finish_owned_idle_session(session, stop=stop)
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')
@@ -42,7 +45,10 @@ def recheck_failed_release(library, block, result, *, stop=None, timeout_seconds
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
from .residual_sessions import finish_owned_idle_session
finish_owned_idle_session(candidate, stop=stop)
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.
@@ -60,7 +66,15 @@ def recheck_failed_release(library, block, result, *, stop=None, timeout_seconds
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:
except Exception as error:
try:
evidence.with_name('late-release-attempt.json').write_text(json.dumps(dict(
business_status=result.status, safe_to_continue=False,
status='IN_USE' if getattr(error,'winerror',None) in (32,33) else 'UNCONFIRMED',
library=str(library), block=block, detail=str(error),
blocked_resources=getattr(error,'blocked_resources',[])),ensure_ascii=False,indent=2),'utf-8')
except OSError:
pass
return result
+112
View File
@@ -818,6 +818,118 @@ def resume_cancelled_startup(path, *, stop=None):
return False
def finish_owned_idle_session(path, *, stop=None):
"""One normal close for a registered, settled, empty client; never a server."""
from contextlib import ExitStack
import stat
import pywintypes, win32con, win32event
from .session_record import _session, active_write_records, write_session_record
from .operation_queue import check_active, native_phase
path = Path(path)
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
acquired = False
try:
acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
if not acquired or stop is not None and stop.is_set(): return False
session, state, identities = _session(path, path.parent)
if 'owned_idle_cleanup' in session: return False
def read(name):
item = path.with_name(name)
if item.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
raise ValueError('OWNED_CLEANUP_REPARSE_POINT')
with item.open('rb') as stream: data = stream.read(1024*1024+1)
if len(data) > 1024*1024: raise ValueError('OWNED_CLEANUP_RECORD_TOO_LARGE')
return json.loads(data)
job, result = read('request.json'), read('result.json')
if not isinstance(job, dict) or not isinstance(result, dict): return False
if (any(job.get(k) != session.get(k) for k in ('operation_id','operation','library','desktop','block'))
or Path(job.get('session_record_path','')).resolve() != path.resolve()
or result.get('safe_to_continue') is not False): return False
operation, desktop = job['operation'], job['desktop']
if operation == 'verify':
facts = result.get('write_outcome') or {}
failed_open = (result.get('error_stage') == 'PCB_STARTING'
and result.get('error_category') in ('MENTOR_DATABASE_LOAD_FAILED','ICDB_REPAIR_REQUIRED')
and not path.with_name('save.log').exists())
saved_closed = (isinstance(facts, dict) and facts.get('interrupted') is False
and all(facts.get(k) == v for k,v in (
('save_state','COMMITTED'),('close_state','CLOSED'),('helper_state','EXITED'))))
if (not desktop.startswith('CbbVerify_') or job.get('interactive_input') is not False
or result.get('status') not in ('FAIL','BLOCKED','TIMEOUT','CANCELLED')
or result.get('block_name') != job['block']
or Path(result.get('evidence_path','')).resolve() != path.with_name('result.json').resolve()
or Path(job.get('root','')).resolve() != path.parent.resolve()
or job.get('lmc_file') != job['library'] or not (failed_open or saved_closed)): return False
client_name = 'expeditionpcb.exe'
elif operation == 'catalog' and job.get('worker_role') == 'catalog_readonly' and desktop.startswith('CbbManagement_'):
client_name = 'librarymanager.exe'
else:
return False
workers = [p for p in identities if p.get('role') in ('worker','helper')]
clients = [p for p in identities if p.get('role') == 'native' and Path(p['image']).name.casefold() == client_name]
if not workers or len(clients) != 1: return False
if any(r.get('operation_id') != session['operation_id'] for r in active_write_records(session['library'])):
return False
with ExitStack() as held:
for worker in workers:
try:
handle = held.enter_context(_process_handle(worker['pid']))
if (win32event.WaitForSingleObject(handle, 0) != win32con.WAIT_OBJECT_0
and _handle_identity(handle) == {k:worker[k] for k in ('created_handle','image')}):
return False
except pywintypes.error as error:
if error.winerror != 87: raise
client = clients[0]
handle = held.enter_context(_process_handle(client['pid']))
def same_client():
owner = _force_ownership(handle, client['pid'])
return (win32event.WaitForSingleObject(handle, 0) == win32con.WAIT_TIMEOUT
and owner.get('force_user_confirmed') is True
and _handle_identity(handle) == {k:client[k] for k in ('created_handle','image')}
and all(owner.get(k) == client[k] for k in ('owner_sid','session_id')))
def empty_target():
snapshot = _process_windows({client['pid']}, include_hidden_documents=True)
windows = snapshot.get(client['pid'], [])
if (any(w.get('desktop') != desktop or w.get('documents')
or any(c['class'].casefold().startswith('afx:') and c.get('visible') is False
for c in w.get('children',[])) for w in windows)):
return None
return close_target(client_name, windows, incomplete=_window_error(snapshot,client['pid']))[0]
if not same_client(): return False
target = empty_target()
if target is None or stop is not None and stop.is_set(): return False
check_active()
current, _, _ = _session(path, path.parent)
if current != session: return False
claim = dict(operation_id=session['operation_id'],pid=client['pid'],identity=client,
status='REQUESTED',hwnd=target['hwnd'],desktop=desktop)
write_session_record(path, {**session,'owned_idle_cleanup':claim})
# Re-read after durable I/O; never act on a window that gained a document.
latest, latest_state, latest_identities = _session(path, path.parent)
if (latest_state != state or latest_identities != identities
or latest.get('owned_idle_cleanup') != claim
or any(latest.get(k) != v for k,v in session.items() if k != 'recorded_at')
or not same_client() or empty_target() != target or read('request.json') != job
or read('result.json') != result or stop is not None and stop.is_set()): return False
with native_phase(read_only=True):
_post_window_message(target,target['hwnd'],client['pid'],win32con.WM_CLOSE)
deadline = time.monotonic()+3
while time.monotonic() < deadline:
if win32event.WaitForSingleObject(handle,100) == win32con.WAIT_OBJECT_0: break
if stop is not None and stop.is_set(): break
exited = win32event.WaitForSingleObject(handle,0) == win32con.WAIT_OBJECT_0
write_session_record(path.with_name('owned-idle-cleanup-result.json'),dict(
operation_id=session['operation_id'],library=session['library'],
status='CLIENT_EXITED' if exited else 'WAITING',claim=claim,
resource_release_confirmed=False))
return True # Client exit is still not independent resource release proof.
except (OSError,pywintypes.error,ValueError,KeyError,TypeError,RuntimeError):
return False
finally:
if acquired: win32event.ReleaseMutex(mutex)
mutex.Close()
def _request_close(row, *, stop=None):
import win32con, win32event
with _process_handle(row['pid']) as handle:
+2 -2
View File
@@ -409,8 +409,8 @@ def observe_retained_session(path, *, evidence_root, stop=None, progress=None, p
pass
if result['status'] == 'ACTIVE' and not observation_only and not stop.is_set():
try:
from .residual_sessions import resume_cancelled_startup
if resume_cancelled_startup(path, stop=stop):
from .residual_sessions import resume_cancelled_startup, finish_owned_idle_session
if resume_cancelled_startup(path, stop=stop) or finish_owned_idle_session(path, stop=stop):
# Cleanup is not release proof. Re-read all held identities
# and independently prove the resource release as usual.
result = _reconcile(Path(path), Path(evidence_root), handles, stack)
+1 -1
View File
@@ -657,7 +657,7 @@ def _run_verify_task(request, *, progress=None, flag_reader=None, process_runner
Path(request.evidence_dir)/'previous-release', block_name=request.block_name,
progress=progress, stop=stop)
check_active()
library_lock = LibraryLock(request.lmc_file, checkpoint=False,
library_lock = LibraryLock(request.lmc_file, checkpoint=False, block_name=request.block_name,
safe_to_release=clients_released)
library_lock.__enter__()
check_active()
+219
View File
@@ -0,0 +1,219 @@
"""Finish a proved owned idle client, then prove resources independently."""
from contextlib import nullcontext
from dataclasses import replace
import json
from pathlib import Path
from threading import Event
import pytest
from cbb_refresh_verify import residual_sessions as residual, session_record as sessions
from cbb_refresh_verify import operation_lifecycle as lifecycle
from cbb_refresh_verify.verify_runner import VerifyResult
def owned_fixture(tmp_path, monkeypatch, kind='startup'):
import win32con, win32event
library=tmp_path/'library/lib.lmc';library.parent.mkdir();library.touch()
root=tmp_path/'evidence';root.mkdir()
operation='catalog' if kind=='catalog' else 'verify'
desktop=('CbbManagement_' if kind=='catalog' else 'CbbVerify_')+'owned'
job=dict(operation_id='owned',operation=operation,library=str(library),lmc_file=str(library),
block='Bad',root=str(root),desktop=desktop,interactive_input=False,
project=str(library.parent/'ReusableBlocksLP/Bad/Work/Bad.prj'),
pcb=str(library.parent/'ReusableBlocksLP/Bad/Work/PCB/Bad.pcb'),
session_record_path=str(root/'session.json'))
if kind=='catalog':job['worker_role']='catalog_readonly'
worker=dict(role='worker',pid=11,created_handle='worker-created',image='C:/Python/python.exe',
owner_sid='owner',session_id=1)
native=dict(role='native',pid=12,created_handle='native-created',
image='D:/Mentor/LibraryManager.exe' if kind=='catalog' else 'D:/Mentor/ExpeditionPCB.exe',
owner_sid='owner',session_id=1)
sessions.write_session_record(root/'session.json',dict(operation_id='owned',operation=operation,
library=str(library),block='Bad',desktop=desktop,processes=[worker]))
sessions.write_session_record(root/'worker-state.json',dict(operation_id='owned',phase='UNCONFIRMED',processes=[native]))
result=dict(status='FAIL',safe_to_continue=False,error_stage='PCB_STARTING',
error_category='MENTOR_DATABASE_LOAD_FAILED',block_name='Bad',evidence_path=str(root/'result.json'))
if kind=='saved':
result.update(error_stage='library_flag',error_category='MENTOR_VERIFY_NOT_COMMITTED',
write_outcome=dict(save_state='COMMITTED',close_state='CLOSED',helper_state='EXITED',interrupted=False))
if kind=='catalog':result=dict(success=False,safe_to_continue=False,detail='catalog close failed')
(root/'request.json').write_text(json.dumps(job))
(root/'result.json').write_text(json.dumps(result))
windows=[dict(hwnd=100,**{'class':'Afx:main'},title='Library Manager' if kind=='catalog' else 'Expedition PCB',
desktop=desktop,enabled=True,documents=[],children=[])]
state=dict(worker_alive=False,native_alive=True,identity_changed=False,posts=[])
monkeypatch.setattr(residual,'_process_handle',lambda pid,**kw:nullcontext(pid))
monkeypatch.setattr(residual,'_handle_identity',lambda handle:
{k:(('replacement' if state['identity_changed'] else v) if k=='created_handle' else v)
for k,v in (worker if handle==11 else native).items() if k in ('created_handle','image')})
monkeypatch.setattr(residual,'_force_ownership',lambda *a:dict(force_user_confirmed=True,owner_sid='owner',session_id=1))
monkeypatch.setattr(residual,'_process_windows',lambda *a,**kw:{12:windows})
monkeypatch.setattr(sessions,'active_write_records',lambda library:[])
wait=win32event.WaitForSingleObject
monkeypatch.setattr(win32event,'WaitForSingleObject',lambda handle,ms:
(win32con.WAIT_TIMEOUT if state['worker_alive' if handle==11 else 'native_alive'] else win32con.WAIT_OBJECT_0)
if handle in (11,12) else wait(handle,ms))
def post(window, hwnd, pid, message):
record=sessions.read_session_record(root/'session.json',evidence_root=root)
assert record.get('owned_idle_cleanup'), 'intent must be durable before native action'
state['posts'].append((hwnd,pid,message))
state['native_alive']=False
monkeypatch.setattr(residual,'_post_window_message',post)
return root,job,result,windows,state
@pytest.mark.parametrize('kind',['startup','saved','catalog'])
def test_owned_idle_client_is_closed_once_without_changing_business_result(tmp_path,monkeypatch,kind):
root,job,result,windows,state=owned_fixture(tmp_path,monkeypatch,kind)
before=(root/'result.json').read_bytes()
assert residual.finish_owned_idle_session(root/'session.json')
assert state['posts']==[(100,12,16)] and not state['native_alive']
residual.finish_owned_idle_session(root/'session.json')
assert state['posts']==[(100,12,16)]
assert (root/'result.json').read_bytes()==before
@pytest.mark.parametrize('obstacle',['worker_alive','identity_changed','documents','hidden_document','unknown',
'progress','desktop','request_identity','save_unknown','other_write','stopped','claim_io','window_race'])
def test_unproved_or_writing_client_is_never_automatically_closed(tmp_path,monkeypatch,obstacle):
root,job,result,windows,state=owned_fixture(tmp_path,monkeypatch)
stop=Event()
if obstacle in ('worker_alive','identity_changed'):state[obstacle]=True
if obstacle=='documents':windows[0]['documents']=[55]
if obstacle=='hidden_document':windows[0]['children'].append(dict(hwnd=55,**{'class':'Afx:document'},visible=False))
if obstacle=='unknown':windows.append(dict(hwnd=200,**{'class':'#32770'},title='Unknown',enabled=True,desktop=job['desktop'],documents=[],children=[]))
if obstacle=='progress':windows[0]['children'].append(dict(hwnd=60,**{'class':'msctls_progress32'}))
if obstacle=='desktop':windows[0]['desktop']='Default'
if obstacle=='request_identity':
job['operation_id']='other';(root/'request.json').write_text(json.dumps(job))
if obstacle=='save_unknown':(root/'save.log').write_text('SAVE_START\n')
if obstacle=='other_write':monkeypatch.setattr(sessions,'active_write_records',lambda _: [dict(operation_id='other')])
if obstacle=='stopped':stop.set()
if obstacle=='claim_io':
monkeypatch.setattr(sessions,'write_session_record',lambda *a,**kw: (_ for _ in ()).throw(OSError('journal unavailable')))
if obstacle=='window_race':
original=sessions.write_session_record
def write(path,value):
original(path,value)
if value.get('owned_idle_cleanup'):windows[0]['documents']=[55]
monkeypatch.setattr(sessions,'write_session_record',write)
residual.finish_owned_idle_session(root/'session.json',stop=stop)
assert not state['posts'] and state['native_alive']
def test_late_release_actively_finishes_owned_idle_client_then_proves_shared_files(tmp_path,monkeypatch):
root,job,result,windows,state=owned_fixture(tmp_path,monkeypatch)
monkeypatch.setattr(sessions,'inspect_session_record',lambda *a,**kw:
dict(status='ACTIVE' if state['native_alive'] else 'UNCONFIRMED'))
def release(library,evidence,**kw):
assert not state['native_alive'], 'resource proof must follow native cleanup'
return dict(status='RELEASE_CONFIRMED',lease_state='RELEASED',library=library,
blocked_resources=[],resource_scope=dict(scope_state='OBSERVED'))
monkeypatch.setattr('cbb_refresh_verify.library_lock.release_retained_library',release)
failed=VerifyResult('FAIL',stderr='database load failed',safe_to_continue=False,
evidence_path=root/'result.json')
updated=lifecycle.recheck_failed_release(job['library'],'Bad',failed)
assert updated.status=='FAIL' and updated.safe_to_continue
assert state['posts']==[(100,12,16)]
def test_closed_client_does_not_imply_shared_database_released(tmp_path,monkeypatch):
root,job,result,windows,state=owned_fixture(tmp_path,monkeypatch)
monkeypatch.setattr(sessions,'inspect_session_record',lambda *a,**kw:
dict(status='ACTIVE' if state['native_alive'] else 'UNCONFIRMED'))
from cbb_refresh_verify.library_lock import LibraryBusy
def release(*a,**kw):raise LibraryBusy('shared database still held by another client')
monkeypatch.setattr('cbb_refresh_verify.library_lock.release_retained_library',release)
failed=VerifyResult('FAIL',safe_to_continue=False,evidence_path=root/'result.json')
updated=lifecycle.recheck_failed_release(job['library'],'Bad',failed)
assert not updated.safe_to_continue and updated.status=='FAIL'
assert state['posts']==[(100,12,16)]
attempt=json.loads((root/'late-release-attempt.json').read_text())
assert 'shared database' in attempt['detail']
def test_retained_verify_lease_does_not_expand_one_target_to_every_cbb(tmp_path,monkeypatch):
from cbb_refresh_verify import verify_runner as runner, library_lock as locks
library=tmp_path/'library/lib.lmc';library.parent.mkdir();library.touch()
other=library.parent/'ReusableBlocksLP/Other/Work/database/cdbsvr/sAddress.adr'
other.parent.mkdir(parents=True);other.write_text('unrelated occupied engineering database')
evidence=tmp_path/'evidence/result.json';evidence.parent.mkdir()
evidence.write_text('{}')
monkeypatch.setattr(runner,'_run_verify_serialized',lambda *a,**kw:
VerifyResult('FAIL',safe_to_continue=False,evidence_path=evidence))
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners',lambda *_:[])
result=runner._run_verify_task(runner.VerifyRequest(library,'Bad',evidence.parent))
assert not result.safe_to_continue
try:
proof=locks.release_retained_library(library,tmp_path/'release',block_name='Bad')
assert proof['proof_scope']=='BLOCK' and proof['proof_block_name']=='Bad'
assert other.read_text()=='unrelated occupied engineering database'
finally:
with locks._guard:
owner=locks._owners.pop(locks.LibraryLock(library).key,None)
if owner:owner['handle'].Close()
@pytest.mark.parametrize('read_only',[False,True])
def test_background_observer_finishes_owned_idle_client_but_cold_observation_stays_read_only(tmp_path,monkeypatch,read_only):
root,job,result,windows,state=owned_fixture(tmp_path,monkeypatch)
def reconcile(*a,**kw):
return dict(status='ACTIVE' if state['native_alive'] else 'RELEASED',operation_id='owned',
library=job['library'],block='Bad',release_proof=None)
monkeypatch.setattr(sessions,'_reconcile',reconcile)
stop=Event()
outcome=sessions.observe_retained_session(root/'session.json',evidence_root=root,
observe_only=read_only,stop=stop,progress=lambda value:stop.set())
assert outcome['status']==('ACTIVE' if read_only else 'RELEASED')
assert state['posts']==([] if read_only else [(100,12,16)])
def test_real_shared_database_handle_still_prevents_release_after_own_client_exits(tmp_path,monkeypatch):
import win32con,win32file
root,job,result,windows,state=owned_fixture(tmp_path,monkeypatch)
library=Path(job['library'])
shared=library.parent/'SymbolLibs/__ReusableBlocksSymb/icdb.dat'
shared.parent.mkdir(parents=True);shared.write_bytes(b'actual shared database fixture')
monkeypatch.setattr(sessions,'inspect_session_record',lambda *a,**kw:
dict(status='ACTIVE' if state['native_alive'] else 'UNCONFIRMED'))
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners',lambda *_:[])
held=win32file.CreateFile(str(shared),win32con.GENERIC_READ,0,None,win32con.OPEN_EXISTING,0,None)
try:
failed=VerifyResult('FAIL',safe_to_continue=False,evidence_path=root/'result.json')
updated=lifecycle.recheck_failed_release(library,'Bad',failed)
assert state['posts']==[(100,12,16)] and not updated.safe_to_continue
attempt=json.loads((root/'late-release-attempt.json').read_text())
assert 'icdb.dat' in attempt['detail']
assert attempt['status']=='IN_USE' and attempt['blocked_resources']==[str(shared)]
finally:
held.Close()
@pytest.mark.parametrize('malformed',['request','result','write_outcome'])
def test_malformed_record_never_authorizes_or_crashes_cleanup(tmp_path,monkeypatch,malformed):
root,job,result,windows,state=owned_fixture(tmp_path,monkeypatch,'saved')
if malformed=='write_outcome':
result['write_outcome']=['not facts'];(root/'result.json').write_text(json.dumps(result))
else:
(root/(malformed+'.json')).write_text('[]')
assert not residual.finish_owned_idle_session(root/'session.json')
assert not state['posts']
@pytest.mark.parametrize('changed',['result_block','result_path','state_after_claim'])
def test_wrong_result_or_changed_state_cannot_authorize_normal_close(tmp_path,monkeypatch,changed):
root,job,result,windows,state=owned_fixture(tmp_path,monkeypatch,'saved')
if changed=='result_block':result['block_name']='Other'
if changed=='result_path':result['evidence_path']=str(tmp_path/'other/result.json')
(root/'result.json').write_text(json.dumps(result))
if changed=='state_after_claim':
write=sessions.write_session_record
def changed_state(path,record):
write(path,record)
if record.get('owned_idle_cleanup'):
previous=sessions.read_session_record(root/'worker-state.json',evidence_root=root)
write(root/'worker-state.json',{**previous,'phase':'NATIVE_CALL'})
monkeypatch.setattr(sessions,'write_session_record',changed_state)
assert not residual.finish_owned_idle_session(root/'session.json')
assert not state['posts']
+9
View File
@@ -1,4 +1,6 @@
from threading import Event
from types import SimpleNamespace
import time
import pytest
@@ -15,9 +17,15 @@ def test_real_recovery_handoff_preserves_A_lease_without_blocking_B_or_late_inst
request,original,source=recovery_files
entered,release,done=Event(),Event(),Event();calls=[]
context=BatchTaskContext(str(request.lmc_file),native_policy='external')
from cbb_refresh_verify import operation_queue
# Expire inactivity at the chosen stall, not during variable filesystem setup.
clock=[time.monotonic()]
monkeypatch.setattr(operation_queue,'time',SimpleNamespace(
monotonic=lambda:clock[0] if clock[0] is not None else time.monotonic()))
def hold():
entered.set()
if cancel:context.cancel()
clock[0]=time.monotonic()+1
assert release.wait(5)
def idle(*args):
if boundary=='idle' and not entered.is_set():hold()
@@ -43,6 +51,7 @@ def test_real_recovery_handoff_preserves_A_lease_without_blocking_B_or_late_inst
try:
with pytest.raises(TaskHandoff):context.run(action,timeout_seconds=.3)
assert entered.is_set()
clock[0]=None
with pytest.raises(LibraryBusy):
with LibraryLock(request.lmc_file):pytest.fail('A lease lost during stalled metadata')
def B():