From d9a79b6535014fa9ccc2adc66062a7c543cb96f5 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: Fri, 6 Nov 2026 16:21:08 +0800 Subject: [PATCH] fix: reconcile reused identities and protect every native dispatch --- src/cbb_refresh_verify/integration.py | 1 + src/cbb_refresh_verify/native_management.py | 32 +++++++++++--- src/cbb_refresh_verify/session_record.py | 17 +++++++- src/cbb_refresh_verify/ui/main_window.py | 4 +- tests/test_integration.py | 15 +++++++ tests/test_native_add_failures.py | 46 ++++++++++++++++++--- tests/test_native_management.py | 31 ++++++++++++++ tests/test_session_record.py | 26 ++++++++++++ 8 files changed, 159 insertions(+), 13 deletions(-) diff --git a/src/cbb_refresh_verify/integration.py b/src/cbb_refresh_verify/integration.py index 4b5a3fa..c3adcdc 100644 --- a/src/cbb_refresh_verify/integration.py +++ b/src/cbb_refresh_verify/integration.py @@ -109,6 +109,7 @@ def refresh_integration(pi, *, emit=lambda **event: None, settle_seconds=5, time emit(stage='integration_action_unavailable', action=method, initial_status=state[name], reason='mentor_not_allowed') raise IntegrationError(f'{name}: required but not allowed') + check_error() # The permission getter itself can block past cancellation. emit(stage='integration_action', action=method, initial_status=state[name], reason='required_verification' if name not in executed else 'resynchronize') started = clock() diff --git a/src/cbb_refresh_verify/native_management.py b/src/cbb_refresh_verify/native_management.py index ed7fa98..25ac295 100644 --- a/src/cbb_refresh_verify/native_management.py +++ b/src/cbb_refresh_verify/native_management.py @@ -717,10 +717,22 @@ def _set_probe_field(hwnd, control_id, expected, root): def _probe_add_dialog(app, job, desktop, owned_pids, root, *, library=None): try: return _probe_add_dialog_impl(app, job, desktop, owned_pids, root, library=library) + except Exception as error: + if job.get('_native_add_pending') and str(error).startswith('NATIVE_ADD_FAILED:'): + try: + failure = json.loads((Path(root)/'native-add-output.json').read_text('utf-8')).get('failure', {}) + if failure.get('acknowledged') is True: + job['_native_add_pending'] = False + from .session_record import update_worker_state + update_worker_state(job, 'POSTCALL') + except (OSError, ValueError, AttributeError): + pass + raise finally: import gc gc.collect() # Release UIA wrappers before closing native child dialogs. - _close_probe_dialogs(desktop, owned_pids) + if not job.get('_native_add_pending'): + _close_probe_dialogs(desktop, owned_pids) def _require_management_continuation(job, root): @@ -823,6 +835,9 @@ def _probe_add_dialog_impl(app, job, desktop, owned_pids, root, *, library=None) _write_json(root/'native-add-log-baseline.json', log_baseline) observed_failures = {} _require_add_supervisor(job, root) + from .session_record import update_worker_state + update_worker_state(job, 'NATIVE_CALL') + job['_native_add_pending'] = True win32gui.PostMessage(ok, win32con.BM_CLICK, 0, 0) success = None while time.monotonic() < deadline: @@ -853,6 +868,8 @@ def _probe_add_dialog_impl(app, job, desktop, owned_pids, root, *, library=None) break if not success: raise TimeoutError('未取得原生新增成功消息;保留副本与私有桌面证据。') + job['_native_add_pending'] = False + update_worker_state(job, 'POSTCALL') def run_isolated_probe(source, root, name, *, mentor_home=None, replacement_source=None): @@ -1125,6 +1142,7 @@ def _catalog_com(job, root): if int(library.FlowType) != 1: raise RuntimeError('Native Add requires the DxDesigner Logical-Physical library flow.') _probe_add_dialog(app, job, desktop, owned_pids, root, library=library) + update_worker_state(job, 'CLOSING') library.Close() library = None _require_management_continuation(job, root) @@ -1169,14 +1187,18 @@ def _catalog_com(job, root): result['detail'] = str(error) result['exception'] = _exception_details(error) finally: - if library is not None: - try: library.Close() + if library is not None and not job.get('_native_add_pending'): + try: + update_worker_state(job, 'CLOSING') + library.Close() except Exception as error: result['close_detail'] = str(error) result['close_exception'] = _exception_details(error) library = None - if app is not None: - try: app.Quit() + if app is not None and not job.get('_native_add_pending'): + try: + update_worker_state(job, 'CLOSING') + app.Quit() except Exception as error: result['quit_detail'] = str(error) result['quit_exception'] = _exception_details(error) diff --git a/src/cbb_refresh_verify/session_record.py b/src/cbb_refresh_verify/session_record.py index fafdf46..bc0fd96 100644 --- a/src/cbb_refresh_verify/session_record.py +++ b/src/cbb_refresh_verify/session_record.py @@ -142,6 +142,9 @@ def _reconcile(path, root, handles, stack): if identity.get('role') == 'supervisor': continue key = tuple(identity[k] for k in IDENTITY_KEYS) + changed_key = ('identity_changed', *key) + if changed_key in handles: + return _result('IDENTITY_CHANGED', '记录中的进程身份已变化,仅供观察', session=session, state=state) if key not in handles: try: handle = win32api.OpenProcess(win32con.SYNCHRONIZE | 0x1000, False, identity['pid']) @@ -157,6 +160,8 @@ def _reconcile(path, root, handles, stack): actual = {'pid': identity['pid'], **_handle_identity(handle), **_force_ownership(handle, identity['pid'])} if any(actual[k] != identity[k] for k in IDENTITY_KEYS): + handles[key] = handle + handles[changed_key] = True return _result('IDENTITY_CHANGED', '记录中的进程身份已变化,仅供观察', session=session, state=state) handles[key] = handle @@ -205,6 +210,14 @@ def observe_retained_session(path, *, evidence_root, stop=None, progress=None, p session={'library': str(process.cbb_library)}, proof=proof) except Exception: pass + if result['status'] == 'IDENTITY_CHANGED': + try: + from .library_lock import release_retained_library + proof = release_retained_library(result['library'], Path(path).parent/'release-proof') + if proof.get('status') == 'RELEASE_CONFIRMED': + result = {**result, 'status': 'RELEASED', 'identity_changed': True, 'release_proof': proof} + except Exception as error: + result['detail'] += f';资源释放待确认:{error}' try: write_session_record(observation, {**result, 'operation_id': result['operation_id'] or 'unknown'}) except (OSError, ValueError): @@ -214,14 +227,14 @@ def observe_retained_session(path, *, evidence_root, stop=None, progress=None, p progress(result) except Exception: logging.getLogger(__name__).warning('Observation callback failed', exc_info=True) - if result['status'] in ('RELEASED', 'IDENTITY_CHANGED') or stop.is_set(): + if result['status'] == 'RELEASED' or stop.is_set(): return result if not handles and process is not None and process.poll() is None: stop.wait(1) continue # The exact owned handle survives a failed journal. if not handles and process is None: return result - stop.wait(5 if result['status'] == 'UNCONFIRMED' else 1) + stop.wait(5 if result['status'] in ('UNCONFIRMED', 'IDENTITY_CHANGED') else 1) def handoff_session(path, *, evidence_root, process=None, progress=None, stop=None): diff --git a/src/cbb_refresh_verify/ui/main_window.py b/src/cbb_refresh_verify/ui/main_window.py index 3c24a6f..5c5b686 100644 --- a/src/cbb_refresh_verify/ui/main_window.py +++ b/src/cbb_refresh_verify/ui/main_window.py @@ -475,8 +475,10 @@ class MainWindow(QWidget): f'{item.get("stage", "")}\n{item["evidence_path"]}') for session in sessions: if session['status'] != 'RELEASED': + phase = {'NATIVE_CALL': '原生操作进行中', 'CLOSING': '正在关闭', 'POSTCALL': '原生调用已返回', + 'PRECALL': '尚未开始', 'UNCONFIRMED': '当前状态无法确认'}.get(session.get('phase'), '待核对') self.output.append(f'未完成会话:{session.get("block") or ""} · ' - f'{session.get("phase", "")} · {session.get("detail", "")}\n{session["path"]}') + f'{phase} · {session.get("detail", "")}\n{session["path"]}') def check_library_release(self): if self.busy or not self.lmc_edit.text().strip(): diff --git a/tests/test_integration.py b/tests/test_integration.py index 9c6c588..64d0ba9 100644 --- a/tests/test_integration.py +++ b/tests/test_integration.py @@ -32,6 +32,21 @@ class FakeProjectIntegration: return True +def test_cancel_during_allowed_getter_prevents_new_integration_call(): + from threading import Event + stop = Event() + class Integration(FakeProjectIntegration): + @property + def IsForwardAnnotationAllowed(self): + stop.set() + return True + integration = Integration() + with pytest.raises(IntegrationError, match='VERIFY_CANCELLED'): + refresh_integration(integration, settle_seconds=0, + error_reader=lambda: 'VERIFY_CANCELLED' if stop.is_set() else '') + assert integration.forward_calls == 0 + + def test_database_restoration_dialog_requires_manual_recovery(): action = choose_dialog_action( 'Database Restoration', diff --git a/tests/test_native_add_failures.py b/tests/test_native_add_failures.py index 04427a2..fdffd11 100644 --- a/tests/test_native_add_failures.py +++ b/tests/test_native_add_failures.py @@ -52,7 +52,8 @@ def test_add_timeout_publishes_cancellation_without_killing_native_owner(tmp_pat assert len(native._retained_workers)==1 -def test_cancellation_during_log_evidence_prevents_native_submit(tmp_path, monkeypatch): +@pytest.mark.parametrize('cancel', [True, False]) +def test_cancellation_and_phase_at_native_add_submit(tmp_path, monkeypatch, cancel): import os,sys from types import SimpleNamespace import win32gui,win32process @@ -78,19 +79,54 @@ def test_cancellation_during_log_evidence_prevents_native_submit(tmp_path, monke def post(h,*args): state['posted'].append(h) if h==110:state['new']=True + if h==210: + from cbb_refresh_verify.session_record import read_session_record + assert read_session_record(root/'worker-state.json', evidence_root=root)['phase'] == 'NATIVE_CALL' monkeypatch.setattr(win32gui,'PostMessage',post) original=native._write_json def write(path,data): original(path,data) - if path.name=='native-add-log-baseline.json':(root/'cancel-native-add.signal').touch() + if path.name=='native-add-log-baseline.json' and cancel:(root/'cancel-native-add.signal').touch() monkeypatch.setattr(native,'_write_json',write) monkeypatch.setattr(failures,'observe_add_failure',lambda *a:(_ for _ in ()).throw(RuntimeError('unsafe OK posted'))) desktop=SimpleNamespace(EnumDesktopWindows=lambda:[100,200] if state['new'] else [100]) job={'operation':'probe_create_add','source':str(source),'library':str(library), - 'name':'Block','timeout_seconds':5,'supervisor_pid':os.getpid()} - with pytest.raises(RuntimeError,match='NATIVE_ADD_CANCELLED'): + 'name':'Block','timeout_seconds':5,'supervisor_pid':os.getpid(), + 'operation_id':'test-add-phase','session_record_path':str(root/'session.json')} + from cbb_refresh_verify.session_record import write_session_record + write_session_record(root/'worker-state.json', {'operation_id': 'test-add-phase', 'phase':'POSTCALL', 'processes':[]}) + with pytest.raises(RuntimeError,match='NATIVE_ADD_CANCELLED' if cancel else 'unsafe OK posted'): native._probe_add_dialog_impl(SimpleNamespace(OnReusableBlocksEditor=lambda:None),job,desktop,{99},root) - assert state['posted']==[110] + assert state['posted']==([110] if cancel else [110,210]) + + +def test_unknown_pending_add_does_not_send_cleanup_dialog_actions(tmp_path, monkeypatch): + from cbb_refresh_verify import native_management as native + def pending(app, job, *a, **kw): + job['_native_add_pending'] = True + raise TimeoutError('native Add pending') + monkeypatch.setattr(native, '_probe_add_dialog_impl', pending) + monkeypatch.setattr(native, '_close_probe_dialogs', lambda *a: pytest.fail('closing a pending Add')) + with pytest.raises(TimeoutError): + native._probe_add_dialog(None, {}, None, set(), tmp_path) + + +@pytest.mark.parametrize('acknowledged', [False, True]) +def test_add_failure_only_allows_cleanup_after_confirmed_native_ack(tmp_path, monkeypatch, acknowledged): + import json + from cbb_refresh_verify import native_management as native + job = {} + def failed(app, job, *a, **kw): + job['_native_add_pending'] = True + (tmp_path/'native-add-output.json').write_text(json.dumps({'failure': {'acknowledged': acknowledged}})) + raise RuntimeError('NATIVE_ADD_FAILED: simulated complete error') + closed = [] + monkeypatch.setattr(native, '_probe_add_dialog_impl', failed) + monkeypatch.setattr(native, '_close_probe_dialogs', lambda *a: closed.append(True)) + with pytest.raises(RuntimeError, match='NATIVE_ADD_FAILED'): + native._probe_add_dialog(None, job, None, set(), tmp_path) + assert bool(closed) is acknowledged + assert job['_native_add_pending'] is not acknowledged def test_copy_failure_log_must_be_new_and_match_current_block(tmp_path): diff --git a/tests/test_native_management.py b/tests/test_native_management.py index 771aa25..5f86cc6 100644 --- a/tests/test_native_management.py +++ b/tests/test_native_management.py @@ -429,6 +429,37 @@ def test_com_failure_without_owner_identity_cannot_claim_release(tmp_path, monke assert native._catalog_native({}, tmp_path)['safe_to_continue'] is False +def test_pending_async_add_does_not_close_or_quit_library(tmp_path, monkeypatch): + import cbb_refresh_verify.native_management as native + import cbb_refresh_verify.mentor_adapter as mentor + import win32com.client + library_path = tmp_path/'lib.lmc' + running = [] + class Library: + FullName = str(library_path) + FlowType = 1 + def Close(self): pytest.fail('Close during pending Add') + class App: + def OpenLibrary(self, path): return Library() + def Quit(self): pytest.fail('Quit during pending Add') + def dispatch(*a): running.append(True); return App() + monkeypatch.setattr(win32com.client, 'DispatchEx', dispatch) + monkeypatch.setattr(native, 'validate_owned_fixture_add', lambda *a: None) + monkeypatch.setattr(native, '_current_desktop', lambda: (SimpleNamespace(EnumDesktopWindows=lambda: []), 'CbbManagement_test')) + monkeypatch.setattr(mentor, '_process_details', lambda _: [ + (123, str(tmp_path/'lm/win32/bin/LibraryManager.exe'), '', 0)] if running else []) + def pending(app, job, *a, **kw): + job['_native_add_pending'] = True + raise TimeoutError('native result unknown') + monkeypatch.setattr(native, '_probe_add_dialog', pending) + result = native._catalog_com({'operation': 'add', 'library': str(library_path), + 'desktop': 'CbbManagement_test', 'mentor_home': str(tmp_path), + 'supervisor_pid': __import__('os').getpid()}, tmp_path) + assert result['success'] is False + assert result['native_pids'] == [123] + assert 'native result unknown' in result['detail'] + + @pytest.mark.parametrize('registered', [True, False]) def test_shared_add_reopens_exact_catalog_and_reports_identity_mismatch(tmp_path, monkeypatch, registered): import cbb_refresh_verify.native_management as native diff --git a/tests/test_session_record.py b/tests/test_session_record.py index face840..613983d 100644 --- a/tests/test_session_record.py +++ b/tests/test_session_record.py @@ -143,3 +143,29 @@ def test_bad_journal_does_not_drop_in_memory_supervision(tmp_path, child): assert child.poll() is None finally: stop.set() + + +def test_reused_pid_keeps_observing_resources_and_unblocks_only_after_proof(tmp_path, child, monkeypatch): + import threading + identity = sessions.process_identity(child.pid) + identity['created_handle'] = 'previous-owner' + path = record(tmp_path, [dict(role='worker', **identity)]) + released = threading.Event() + stop = threading.Event() + proof = {'status': 'RELEASE_CONFIRMED', 'library': str(tmp_path/'lib.lmc')} + monkeypatch.setattr('cbb_refresh_verify.library_lock.release_retained_library', lambda *a, **kw: proof) + def progress(result): + if result['status'] == 'RELEASED': + released.set() + sessions.handoff_session(path, evidence_root=tmp_path, stop=stop, progress=progress) + try: + assert released.wait(3), 'PID reuse ended observation before independent release' + assert child.poll() is None + # The callback precedes final observer cleanup by a few instructions. + import time + deadline = time.monotonic()+1 + while not sessions.library_available(tmp_path/'lib.lmc') and time.monotonic()