From a3f69de20139f581e6d1d140f3319b6342256be3 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: Tue, 17 Nov 2026 09:44:49 +0800 Subject: [PATCH] fix: complete confirmed legacy cleanup from one release intent --- src/cbb_refresh_verify/diagnostic_open.py | 14 ++-- src/cbb_refresh_verify/residual_sessions.py | 29 +++++-- src/cbb_refresh_verify/session_record.py | 23 ++++-- .../ui/residual_release_dialog.py | 6 +- tests/test_cancelled_session_handoff.py | 29 ++++++- tests/test_registered_startup_release.py | 78 +++++++++++++++++++ tests/test_residual_inspection_metadata.py | 30 +++++++ 7 files changed, 189 insertions(+), 20 deletions(-) create mode 100644 tests/test_residual_inspection_metadata.py diff --git a/src/cbb_refresh_verify/diagnostic_open.py b/src/cbb_refresh_verify/diagnostic_open.py index 3aec202..81d2c88 100644 --- a/src/cbb_refresh_verify/diagnostic_open.py +++ b/src/cbb_refresh_verify/diagnostic_open.py @@ -151,8 +151,9 @@ def _target_frame(windows, name, *, require_ready=True): if not window['text'].casefold().startswith('expedition pcb') or f'[{name}]'.casefold() not in window['text'].casefold(): continue mdi = {child['hwnd'] for child in window['children'] if child['class'].casefold() == 'mdiclient'} - if any(child.get('parent') in mdi and child['text'].casefold() == name.casefold() - and child['class'].casefold().startswith('afx:') for child in window['children']): + documents = [child for child in window['children'] if child.get('parent') in mdi + and child['class'].casefold().startswith('afx:')] + if len(documents) == 1 and documents[0]['text'].casefold() == name.casefold(): matches.append(window) return matches[0] if len(matches) == 1 else None @@ -408,9 +409,12 @@ def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post, raise actions = [] def act(hwnd, message): - if (read_windows() != windows or identity_check is not None and not identity_check() - or time.monotonic() >= deadline): - raise RuntimeError('STARTUP_ACTION_UNCONFIRMED: native state or deadline changed') + if read_windows() != windows: + raise RuntimeError('STARTUP_WINDOW_CHANGED: native snapshot changed before action') + if identity_check is not None and not identity_check(): + raise RuntimeError('STARTUP_IDENTITY_UNCONFIRMED: registered cleanup binding changed') + if time.monotonic() >= deadline: + raise RuntimeError('STARTUP_CLEANUP_TIMEOUT: original cleanup deadline reached') post(hwnd, message) actions.append((hwnd, message)) if message == 0xF5: diff --git a/src/cbb_refresh_verify/residual_sessions.py b/src/cbb_refresh_verify/residual_sessions.py index 9264809..f5958c8 100644 --- a/src/cbb_refresh_verify/residual_sessions.py +++ b/src/cbb_refresh_verify/residual_sessions.py @@ -676,7 +676,7 @@ def _close_registered_startup(row, handle, proof, *, stop=None): from .diagnostic_open import cancelled_startup_step from .operation_queue import check_active job = proof['job']; bound = dict(row, cleanup_desktop=job['desktop']) - deadline = time.monotonic()+3 + deadline = time.monotonic()+30 # One diagnostic cleanup intent; ordinary close still uses 3 seconds. def active_owner(): check_active() if stop is not None and stop.is_set(): @@ -716,9 +716,15 @@ def _close_registered_startup(row, handle, proof, *, stop=None): return {'release_status':'RELEASED','detail':'已关闭启动提示并正常退出'} if stop is not None and stop.is_set():break break # Never stack another Close after a legacy Tip acknowledgement. - closed,_ = cancelled_startup_step(job,row['pid'],state,closed_frame=closed,deadline=deadline, - post=post,emit=lambda **event:None,read_windows=lambda:_legacy_diagnostic_windows(bound), - identity_check=confirmed) + try: + closed,_ = cancelled_startup_step(job,row['pid'],state,closed_frame=closed,deadline=deadline, + post=post,emit=lambda **event:None,read_windows=lambda:_legacy_diagnostic_windows(bound), + identity_check=confirmed) + except RuntimeError as error: + if not str(error).startswith('STARTUP_WINDOW_CHANGED:'): + raise + # No may remove a modal and enable the target while the next + # snapshot is being read. Revalidate anew inside the same budget. time.sleep(.1) except (OSError, pywintypes.error, ValueError, RuntimeError) as error: return {'release_status':'WAITING','detail':str(error)} @@ -740,7 +746,20 @@ def _request_close(row, *, stop=None): if stop is not None and stop.is_set(): return {'release_status': 'CANCELLED', 'detail': '已停止释放'} if proof := _cancelled_diagnostic_record(row): - return _close_registered_startup(row, handle, proof, stop=stop) + owner = _force_ownership(handle,row['pid']) + if (owner.get('force_user_confirmed') is not True + or any(owner.get(k) != row.get(k) for k in ('owner_sid','session_id'))): + return {'release_status':'WAITING','detail':'取消启动会话的用户或 Windows 会话未确认'} + if stop is not None and stop.is_set(): + return {'release_status':'CANCELLED','detail':'已停止释放'} + from .session_record import handoff_session + record_path = Path(proof['record_path']) + handoff_session(record_path, evidence_root=record_path.parent, observe_only=False) + from .operation_queue import native_phase + # This confirmed no-write native cleanup has its own single bounded + # budget; metadata inactivity must not abandon it between No and Close. + with native_phase(read_only=True): + return _close_registered_startup(row, handle, proof, stop=stop) if _dismiss_startup_tip(row, handle, windows, stop=stop) is not None: # Legacy startup cleanup may already have sent WM_CLOSE. Only wait # for it here; never stack another close behind this acknowledgement. diff --git a/src/cbb_refresh_verify/session_record.py b/src/cbb_refresh_verify/session_record.py index 51aace8..6050ab6 100644 --- a/src/cbb_refresh_verify/session_record.py +++ b/src/cbb_refresh_verify/session_record.py @@ -387,15 +387,17 @@ def inspect_session_record(path, *, evidence_root): def observe_retained_session(path, *, evidence_root, stop=None, progress=None, process=None, observe_only=False): stop = stop if stop is not None else threading.Event() + read_only = observe_only if callable(observe_only) else lambda: observe_only observation = Path(path).with_name('observation-' + uuid4().hex + '.json') with ExitStack() as stack: handles = {} while True: + observation_only = read_only() try: - result = _reconcile(Path(path), Path(evidence_root), handles, stack, release=not observe_only) + result = _reconcile(Path(path), Path(evidence_root), handles, stack, release=not observation_only) except Exception as error: result = _result('UNCONFIRMED', str(error)) - if (not observe_only and process is not None and process.poll() is not None + if (not observation_only and process is not None and process.poll() is not None and getattr(process, 'cbb_library', None)): try: from .library_lock import release_retained_library @@ -405,7 +407,7 @@ 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' and not observe_only: + if result['status'] == 'IDENTITY_CHANGED' and not observation_only: try: from .library_lock import release_retained_library proof = release_retained_library(result['library'], Path(path).parent/'release-proof') @@ -427,7 +429,7 @@ def observe_retained_session(path, *, evidence_root, stop=None, progress=None, p except Exception: logging.getLogger(__name__).warning('Observation callback failed', exc_info=True) if (result['status'] == 'RELEASED' or stop.is_set() - or observe_only and result['status'] != 'ACTIVE'): + or read_only() and result['status'] != 'ACTIVE'): return result if not handles and process is not None and process.poll() is None: stop.wait(1) @@ -449,6 +451,9 @@ def handoff_session(path, *, evidence_root, process=None, progress=None, stop=No aliases = {_library_key(library), _library_key(Path(library).resolve())} if library else set() with _observer_guard: if key in _observers: + if (observe_only is False and session.get('operation_id') + and _retained_results.get(key, {}).get('operation_id') == session['operation_id']): + _retained_results[key]['release_operation_id'] = session['operation_id'] return _retained_libraries[key] = aliases _retained_results[key] = {'status': 'UNCONFIRMED', 'phase': 'UNCONFIRMED', @@ -466,11 +471,19 @@ def handoff_session(path, *, evidence_root, process=None, progress=None, stop=No 'block': value.get('block') or previous['block']} if progress is not None: progress(value) + def observation_only(): + if not observe_only: + return False + with _observer_guard: + value = _retained_results.get(key, {}) + return not (session.get('operation_id') and _retained_libraries.get(key) is aliases + and value.get('operation_id') == session.get('operation_id') + and value.get('release_operation_id') == session.get('operation_id')) def observe(): result = None try: result = observe_retained_session(path, evidence_root=evidence_root, progress=notify, - stop=stop, process=process, observe_only=observe_only) + stop=stop, process=process, observe_only=observation_only) if process is not None and process.poll() is not None: process.close() return result diff --git a/src/cbb_refresh_verify/ui/residual_release_dialog.py b/src/cbb_refresh_verify/ui/residual_release_dialog.py index 2bde690..9482ab6 100644 --- a/src/cbb_refresh_verify/ui/residual_release_dialog.py +++ b/src/cbb_refresh_verify/ui/residual_release_dialog.py @@ -68,7 +68,7 @@ class ResidualReleaseDialog(QDialog): self.table.itemSelectionChanged.connect(self._update_prompt) self.refresh() - def _start(self, action, completed): + def _start(self, action, completed, *, metadata_only=False): context = BatchTaskContext(str(self.library)) self.context, self.stop = context, context.stop self.busy = True @@ -78,7 +78,7 @@ class ResidualReleaseDialog(QDialog): self.force_button.setEnabled(False) self.cancel_native_button.setEnabled(False) self.close_button.setText('停止释放') - self.worker = ServiceWorker(lambda:context.run(action)) + self.worker = ServiceWorker(lambda:context.run(action, metadata_only=metadata_only)) worker = self.worker self._workers.add(worker) self.worker.signals.succeeded.connect(context.guard_callback(completed, current=lambda:self.context)) @@ -238,7 +238,7 @@ class ResidualReleaseDialog(QDialog): states.update({str(Path(row['path']).absolute()).casefold(): row for row in discover_sessions(self.evidence_dir.parent, library=library)}) return {**plan, 'runtime_sessions': list(states.values())} - self._start(inspect, ready) + self._start(inspect, ready, metadata_only=True) def force_release(self): if self.busy or not self.plan or not self.plan['sessions']: return diff --git a/tests/test_cancelled_session_handoff.py b/tests/test_cancelled_session_handoff.py index 5a50693..158faff 100644 --- a/tests/test_cancelled_session_handoff.py +++ b/tests/test_cancelled_session_handoff.py @@ -82,7 +82,29 @@ def test_failed_observer_registration_preserves_original_cancelled_result_and_ha assert not state['closed'] -def test_natural_native_exit_gets_fresh_release_and_admits_waiting_scope_without_click(tmp_path,monkeypatch): +def test_missing_operation_identity_cannot_promote_cold_observation(tmp_path,monkeypatch): + from types import SimpleNamespace + path=tmp_path/'session.json';path.write_text('{invalid') + entered,finish=Event(),Event();modes=[] + def observe(*args,**kwargs): + mode=kwargs['observe_only'];modes.append(mode() if callable(mode) else mode) + entered.set();assert finish.wait(3) + return dict(status='UNCONFIRMED',operation_id=None) + monkeypatch.setattr(session_record,'observe_retained_session',observe) + owner=SimpleNamespace(cbb_library=str(tmp_path/'lib.lmc'),poll=lambda:0,close=lambda:None) + thread=None + try: + session_record.handoff_session(path,evidence_root=tmp_path,process=owner,observe_only=True) + assert entered.wait(2) + thread=session_record._observers[str(path.absolute()).casefold()][0] + assert modes==[True] + finally: + finish.set() + if thread:thread.join(3) + + +@pytest.mark.parametrize('cold_observer',[False,True]) +def test_natural_native_exit_gets_fresh_release_and_admits_waiting_scope_without_click(tmp_path,monkeypatch,cold_observer): import subprocess,sys,time from concurrent.futures import ThreadPoolExecutor from types import SimpleNamespace @@ -104,11 +126,14 @@ def test_natural_native_exit_gets_fresh_release_and_admits_waiting_scope_without owner=SimpleNamespace(pid=700,poll=lambda:0,close=lambda:closed.append(native.poll())) thread=None try: - session_record.handoff_session(path,evidence_root=evidence,process=owner,stop=stop, + session_record.handoff_session(path,evidence_root=evidence,process=owner,stop=stop,observe_only=cold_observer, progress=lambda state:active.set() if state['status']=='ACTIVE' else None) assert active.wait(3) and not closed key=str(path.absolute()).casefold() thread=session_record._observers[key][0] + if cold_observer: + session_record.handoff_session(path,evidence_root=evidence,observe_only=False) + assert session_record._observers[key][0] is thread assert not session_record.library_available(library) queue=NativeQueue() def admitted(): diff --git a/tests/test_registered_startup_release.py b/tests/test_registered_startup_release.py index b9c7d20..9299fbb 100644 --- a/tests/test_registered_startup_release.py +++ b/tests/test_registered_startup_release.py @@ -12,6 +12,9 @@ def registered_fixture(tmp_path,monkeypatch,*,closed=False,obstacle=''): import win32con,win32event job,records,messages,state=loaded_fixture(tmp_path,monkeypatch) state.update(tip=False,closing=closed) + state['observer_requests']=[] + monkeypatch.setattr(session_record,'handoff_session',lambda path,**kw: + state['observer_requests'].append((path,list(messages),kw))) job.update(operation_id='verify-old',operation='verify',library=job['lmc_file'],block='IP101GR', session_record_path=str(tmp_path/'session.json'),interactive_input=False) job.pop('diagnostic_log_baseline') # Old builds never persisted this; do not invent it. @@ -148,3 +151,78 @@ def test_registered_cleanup_cannot_act_from_another_windows_user_session(tmp_pat dict(owner_sid='current',session_id=1,force_user_confirmed=False)) assert sessions._request_close(row)['release_status']=='WAITING' assert not messages and records + assert not state['observer_requests'] + + +@pytest.mark.parametrize('obstacle',['','progress','stop','unknown']) +def test_one_legacy_intent_keeps_diagnostic_budget_across_no_ready_and_close(tmp_path,monkeypatch,obstacle): + from threading import Event + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch) + stop=Event();original=sessions._legacy_diagnostic_windows + def windows(bound): + value=original(bound) + if state['declined']: + if obstacle=='stop' and state['ticks']>=4:stop.set() + if state['ticks']<4 or obstacle=='progress': + value[0]['children'].append(dict(hwnd=123,**{'class':'msctls_progress32'},text='',visible=True)) + if obstacle=='unknown': + value.append(dict(hwnd=999,pid=12,**{'class':'#32770'},text='Unknown action',children=[])) + return value + monkeypatch.setattr(sessions,'_legacy_diagnostic_windows',windows) + result=sessions._request_close(row,stop=stop) + assert state['observer_requests'] and state['observer_requests'][0][1]==[] + assert state['observer_requests'][0][2].get('observe_only',False) is False + if not obstacle: + assert result['release_status']=='RELEASED' and not records + assert messages==[(31,245),(100,16)] and 4<=state['ticks']<5 + else: + assert result['release_status'] in ('WAITING','CANCELLED') and records + assert messages==[(31,245)] + assert state['ticks']<5 if obstacle=='stop' else 30<=state['ticks']<30.2 + + +def test_known_no_then_changing_ready_snapshot_revalidates_within_same_intent(tmp_path,monkeypatch): + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch) + original=sessions._legacy_diagnostic_windows;reads=[] + def windows(bound): + value=original(bound) + if state['declined']: + reads.append(1) + if len(reads)==2:value[0]['children'].append(dict(hwnd=124,**{'class':'Afx:tool'},text='settling',parent=100)) + return value + monkeypatch.setattr(sessions,'_legacy_diagnostic_windows',windows) + assert sessions._request_close(row)['release_status']=='RELEASED' + assert messages==[(31,245),(100,16)] and not records + + +def test_proved_native_cleanup_uses_its_budget_instead_of_metadata_inactivity(tmp_path,monkeypatch): + from threading import Event,Timer + from cbb_refresh_verify.operation_queue import BatchTaskContext + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch) + ready,done=Event(),Event();original=sessions._legacy_diagnostic_windows + def windows(bound): + if state['declined']:assert ready.wait(1) + return original(bound) + monkeypatch.setattr(sessions,'_legacy_diagnostic_windows',windows) + timer=Timer(.25,ready.set);timer.start() + context=BatchTaskContext(str(row['library'])) + def cleanup(): + try:return sessions._request_close(row) + finally:done.set() + try: + result=context.run(cleanup,timeout_seconds=.08) + assert result['release_status']=='RELEASED' and messages==[(31,245),(100,16)] + finally: + ready.set();timer.join(1);assert done.wait(2) + + +def test_registered_cleanup_preserves_frame_with_an_additional_mdi_document(tmp_path,monkeypatch): + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch) + original=sessions._legacy_diagnostic_windows + def windows(bound): + value=original(bound) + value[0]['children'].append(dict(hwnd=888,**{'class':'Afx:document'},text='Other',parent=101)) + return value + monkeypatch.setattr(sessions,'_legacy_diagnostic_windows',windows) + assert sessions._request_close(row)['release_status']=='WAITING' + assert records and not messages diff --git a/tests/test_residual_inspection_metadata.py b/tests/test_residual_inspection_metadata.py new file mode 100644 index 0000000..9e3b8b8 --- /dev/null +++ b/tests/test_residual_inspection_metadata.py @@ -0,0 +1,30 @@ +from threading import Event + +import pytest + +from cbb_refresh_verify.operation_queue import BatchTaskContext,TaskHandoff,hold_native_handoff +from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog + + +def test_pure_residual_inspection_remains_available_during_native_finalizer(qtbot,tmp_path,monkeypatch): + library=tmp_path/'lib.lmc';library.touch() + context=BatchTaskContext(str(library),native_policy='external') + entered,finish=Event(),Event();reads=[] + def finalize(): + try:hold_native_handoff(None,tmp_path/'session.json') + except TaskHandoff:entered.set();assert finish.wait(5) + monkeypatch.setattr('cbb_refresh_verify.library_lock.inspect_residual_sessions',lambda path: + reads.append(path) or dict(library=str(library),sessions=[],previous_records=[])) + monkeypatch.setattr('cbb_refresh_verify.session_record.discover_sessions',lambda *a,**kw:[]) + monkeypatch.setattr('cbb_refresh_verify.session_record.retained_session_states',lambda *a:[]) + dialog=None + try: + with pytest.raises(TaskHandoff):context.run(finalize) + assert entered.is_set() + dialog=ResidualReleaseDialog(library,tmp_path/'evidence');qtbot.addWidget(dialog) + qtbot.waitUntil(lambda:not dialog.busy,timeout=3000) + assert reads==[library] and dialog.plan is not None,dialog.message.text() + assert dialog.library==library and dialog.confirm_button.isEnabled() + finally: + finish.set();context.close(timeout_seconds=2) + if dialog is not None:dialog.close()