From 55cdf2b0829212706256692cebfea41fab3eb436 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, 19 Nov 2026 11:14:49 +0800 Subject: [PATCH] fix: finish owned idle sessions before proving resource release --- .../2026-11-19-owned-session-release.json | 210 +++++++++++++++++ .../2026-11-19-owned-session-release.md | 52 +++++ src/cbb_refresh_verify/file_probe.py | 10 +- src/cbb_refresh_verify/library_lock.py | 2 + src/cbb_refresh_verify/operation_lifecycle.py | 20 +- src/cbb_refresh_verify/residual_sessions.py | 112 +++++++++ src/cbb_refresh_verify/session_record.py | 4 +- src/cbb_refresh_verify/verify_runner.py | 2 +- tests/test_owned_idle_cleanup.py | 219 ++++++++++++++++++ tests/test_recovery_metadata_handoff.py | 9 + 10 files changed, 632 insertions(+), 8 deletions(-) create mode 100644 docs/releases/2026-11-19-owned-session-release.json create mode 100644 docs/releases/2026-11-19-owned-session-release.md create mode 100644 tests/test_owned_idle_cleanup.py diff --git a/docs/releases/2026-11-19-owned-session-release.json b/docs/releases/2026-11-19-owned-session-release.json new file mode 100644 index 0000000..89fe38d --- /dev/null +++ b/docs/releases/2026-11-19-owned-session-release.json @@ -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 +} diff --git a/docs/releases/2026-11-19-owned-session-release.md b/docs/releases/2026-11-19-owned-session-release.md new file mode 100644 index 0000000..68254e9 --- /dev/null +++ b/docs/releases/2026-11-19-owned-session-release.md @@ -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 和所有安装环境未在本轮验收。真实共享写入或未知保存状态仍不能强行解除;这个保护不会被“继续下一项”的要求替代。本轮不合并、不发行、不关闭工单。 diff --git a/src/cbb_refresh_verify/file_probe.py b/src/cbb_refresh_verify/file_probe.py index 6406038..aaacd17 100644 --- a/src/cbb_refresh_verify/file_probe.py +++ b/src/cbb_refresh_verify/file_probe.py @@ -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 diff --git a/src/cbb_refresh_verify/library_lock.py b/src/cbb_refresh_verify/library_lock.py index 6769378..007be1b 100644 --- a/src/cbb_refresh_verify/library_lock.py +++ b/src/cbb_refresh_verify/library_lock.py @@ -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')): diff --git a/src/cbb_refresh_verify/operation_lifecycle.py b/src/cbb_refresh_verify/operation_lifecycle.py index 2c95e8f..956bacb 100644 --- a/src/cbb_refresh_verify/operation_lifecycle.py +++ b/src/cbb_refresh_verify/operation_lifecycle.py @@ -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 diff --git a/src/cbb_refresh_verify/residual_sessions.py b/src/cbb_refresh_verify/residual_sessions.py index ad54e07..5154e6a 100644 --- a/src/cbb_refresh_verify/residual_sessions.py +++ b/src/cbb_refresh_verify/residual_sessions.py @@ -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: diff --git a/src/cbb_refresh_verify/session_record.py b/src/cbb_refresh_verify/session_record.py index 68ba480..923c6ea 100644 --- a/src/cbb_refresh_verify/session_record.py +++ b/src/cbb_refresh_verify/session_record.py @@ -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) diff --git a/src/cbb_refresh_verify/verify_runner.py b/src/cbb_refresh_verify/verify_runner.py index 4332bd3..9d859c2 100644 --- a/src/cbb_refresh_verify/verify_runner.py +++ b/src/cbb_refresh_verify/verify_runner.py @@ -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() diff --git a/tests/test_owned_idle_cleanup.py b/tests/test_owned_idle_cleanup.py new file mode 100644 index 0000000..27a3ce9 --- /dev/null +++ b/tests/test_owned_idle_cleanup.py @@ -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'] diff --git a/tests/test_recovery_metadata_handoff.py b/tests/test_recovery_metadata_handoff.py index f14181d..1145588 100644 --- a/tests/test_recovery_metadata_handoff.py +++ b/tests/test_recovery_metadata_handoff.py @@ -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():