From 7cc65f78da7b1383cadfcc84e36d1dfd5d10f64e 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 08:37:23 +0800 Subject: [PATCH] fix: reconcile cancelled sessions and resume queued native work --- src/cbb_refresh_verify/diagnostic_open.py | 15 +- src/cbb_refresh_verify/operation_queue.py | 11 +- src/cbb_refresh_verify/residual_sessions.py | 160 +++++++++++++++++++ src/cbb_refresh_verify/session_record.py | 27 +++- src/cbb_refresh_verify/ui/icdb_check_task.py | 2 +- src/cbb_refresh_verify/verify_runner.py | 37 +++-- tests/test_cancelled_diagnostic_report.py | 34 ++++ tests/test_cancelled_session_handoff.py | 129 +++++++++++++++ tests/test_live_observer_queue.py | 90 +++++++++++ tests/test_registered_startup_release.py | 150 +++++++++++++++++ 10 files changed, 637 insertions(+), 18 deletions(-) create mode 100644 tests/test_cancelled_diagnostic_report.py create mode 100644 tests/test_cancelled_session_handoff.py create mode 100644 tests/test_live_observer_queue.py create mode 100644 tests/test_registered_startup_release.py diff --git a/src/cbb_refresh_verify/diagnostic_open.py b/src/cbb_refresh_verify/diagnostic_open.py index 33066f8..3aec202 100644 --- a/src/cbb_refresh_verify/diagnostic_open.py +++ b/src/cbb_refresh_verify/diagnostic_open.py @@ -365,14 +365,16 @@ def _pending_prompt(windows, *, closing=False, frame=None, session=None, clicked return False -def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post, emit): +def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post, emit, + read_windows=None, identity_check=None): """Finish only the owned no-write diagnostic startup; never establish PASS. Cancellation already ended supervisor polling. Cleanup is its sole prompt actor and uses the caller's original deadline and single-close state. """ from types import SimpleNamespace - windows = _windows(pcb_pid) + read_windows = read_windows or (lambda: _windows(pcb_pid)) + windows = read_windows() if any(window['pid'] != pcb_pid for window in windows): raise RuntimeError('STARTUP_PROCESS_UNCONFIRMED') current = _target_frame(windows, Path(job['pcb']).stem, require_ready=False) @@ -387,7 +389,11 @@ def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post, if closed_frame is not None and frame['hwnd'] != closed_frame: raise RuntimeError('STARTUP_DOCUMENT_CHANGED') if old is None: - if _load_evidence(job, pcb_pid, job['diagnostic_log_baseline'], require_autosave=False) is None: + # Explicit legacy cleanup supplies already checked registration. It is + # revalidated immediately before every action, never used as open proof. + confirmed = (identity_check is not None or + _load_evidence(job, pcb_pid, job['diagnostic_log_baseline'], require_autosave=False) is not None) + if not confirmed: return closed_frame, False state['frame'] = frame # Validate every window before allowing a known No. An unknown sibling @@ -402,7 +408,8 @@ def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post, raise actions = [] def act(hwnd, message): - if _windows(pcb_pid) != windows or time.monotonic() >= deadline: + 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') post(hwnd, message) actions.append((hwnd, message)) diff --git a/src/cbb_refresh_verify/operation_queue.py b/src/cbb_refresh_verify/operation_queue.py index 2c3bafa..441284e 100644 --- a/src/cbb_refresh_verify/operation_queue.py +++ b/src/cbb_refresh_verify/operation_queue.py @@ -390,6 +390,13 @@ class NativeQueue: def run(self, action, *, stop=None, waiting=None, ready=lambda: True, wait_state=None, context=None, timeout_seconds=10): + def available_now(): + if not ready(): + return False + if context is None: + return True # Explicit recovery controls must still reach their retained clients. + from .session_record import _live_library_available + return all(_live_library_available(path) for path in (context.library, *context.aliases)) ticket = [object(), False] acquired, notified = False, False previous_state = None @@ -401,7 +408,7 @@ class NativeQueue: self.pending.append(ticket) try: while not acquired: - available = ready() # Call only this ticket's predicate, outside the queue lock. + available = available_now() # Cached predicates only, outside the queue lock. with self.condition: if (self.closed or stop is not None and stop.is_set() or context is not None and (context.stop.is_set() or context.stop_after_current.is_set())): @@ -412,7 +419,7 @@ class NativeQueue: self.active = acquired = True else: self.condition.wait(.1) - if acquired and not ready(): + if acquired and not available_now(): with self.condition: ticket[1] = self.active = acquired = False self.condition.notify_all() diff --git a/src/cbb_refresh_verify/residual_sessions.py b/src/cbb_refresh_verify/residual_sessions.py index c585d0f..9264809 100644 --- a/src/cbb_refresh_verify/residual_sessions.py +++ b/src/cbb_refresh_verify/residual_sessions.py @@ -570,6 +570,161 @@ def _dismiss_startup_tip(row, handle, windows, *, incomplete=None, dismissed=(), return tip['hwnd'] +def _cancelled_diagnostic_record(row): + """Existing complete registration can authorize cleanup, never validation.""" + import stat + import pywintypes, win32con, win32event + from .session_record import _session, IDENTITY_KEYS, active_write_records + from .failed_session import _command_args + if row.get('scope_confirmed') is not True or row.get('name', '').casefold() != 'expeditionpcb.exe': + return None + def same(a, b): + return os.path.normcase(os.path.abspath(str(a))) == os.path.normcase(os.path.abspath(str(b))) + def read(path, *, lines=False): + if path.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT: + raise ValueError('STARTUP_RECORD_REPARSE_POINT') + with path.open('rb') as stream: + data = stream.read(1024*1024+1) + if len(data) > 1024*1024: + raise ValueError('STARTUP_RECORD_TOO_LARGE') + return [json.loads(line) for line in data.splitlines()] if lines else json.loads(data) + matches = [] + for record in row.get('session_records', ()): + try: + path = Path(record['path']); root = path.parent + session, state, identities = _session(path, root) + job, result = read(root/'request.json'), read(root/'result.json') + operation = session['operation_id'] + scope = session.get('resource_scope', {}) + if (record.get('operation_id') != operation or job.get('operation_id') != operation + or job.get('diagnostic_only') is not True or job.get('interactive_input') is not False + or job.get('operation') != 'verify' or session.get('operation') != 'verify' + or not all(same(value, row['library']) for value in (job['library'], job['lmc_file'], session['library'])) + or not same(job['root'], root) or not same(job['session_record_path'], path) + or job.get('desktop') != session.get('desktop') or not job['desktop'].startswith('CbbVerify_') + or scope.get('scope_state') != 'DECLARED' or scope.get('operation_id') != operation + or not same(scope.get('library', ''), row['library']) + or scope.get('projects') != [job['project']] + or not Path(job['pcb']).is_relative_to(Path(job['project']).parent) + or not same(job['cancel_signal'], session['cancel_signal']) + or Path(job['cancel_signal']).parent != root or not Path(job['cancel_signal']).is_file() + or result.get('status') != 'CANCELLED' or result.get('error_stage') != 'PCB_STARTING' + or result.get('write_outcome', {}).get('save_state') != 'UNKNOWN' + or state.get('phase') != 'UNCONFIRMED' or (root/'save.log').exists()): + continue + native = [p for p in identities if p.get('role') == 'native' and p['pid'] == row['pid']] + workers = [p for p in identities if p.get('role') in ('worker', 'helper')] + if (len(native) != 1 or not workers + or any(native[0][k] != row.get(k) for k in IDENTITY_KEYS) + or any(p.get('role') not in ('worker','helper','native','supervisor') for p in identities)): + continue + for worker in workers: + try: + with _process_handle(worker['pid']) as held: + if win32event.WaitForSingleObject(held, 0) != win32con.WAIT_OBJECT_0: + raise ValueError('STARTUP_WORKER_STILL_ACTIVE') + except (OSError, pywintypes.error) as error: + if getattr(error, 'winerror', None) != 87: + raise + args = _command_args(row['command']) + if ('-reusablecircuit' not in [a.casefold() for a in args] + or not any(same(a, job['pcb']) for a in args[1:])): + continue + events = read(root/'events.jsonl', lines=True) + if (not any(e.get('stage') == 'pcb_worker_started' and e.get('pcb_pid') == row['pid'] for e in events) + or not any(e.get('stage') == 'pcb_baseline' and row['pid'] not in e.get('pids', []) for e in events) + or any(str(e.get('stage', '')).startswith(('save', 'integration', 'validate', 'failure_close')) + or e.get('stage') == 'diagnostic_complete' for e in events)): + continue + closes = [e for e in events if e.get('stage') in ('startup_close_requested', 'diagnostic_wm_close')] + if len(closes) > 1 or any(e.get('pcb_pid') != row['pid'] or not e.get('hwnd') for e in closes): + continue + if any(r.get('operation_id') != operation for r in active_write_records(row['library'])): + continue + matches.append(dict(job=job, record_path=str(path), operation_id=operation, + closed_frame=closes[0]['hwnd'] if closes else None)) + except (OSError, pywintypes.error, ValueError, KeyError, TypeError): + continue + return matches[0] if len(matches) == 1 else None + + +def _legacy_diagnostic_windows(row): + """Adapt the existing complete private-desktop snapshot for diagnostic policy.""" + import win32con, win32gui + snapshot = _process_windows({row['pid']}) + if _window_error(snapshot, row['pid']): + raise ValueError('STARTUP_WINDOW_UNCONFIRMED') + result = [] + for window in snapshot.get(row['pid'], []): + if window.get('desktop') != row['cleanup_desktop']: + raise ValueError('STARTUP_DESKTOP_UNCONFIRMED') + benign = (not window['title'] and window['class'] in ('UAC_InputIndicatorOverlayWnd', 'UAC Input Indicator')) + benign = benign or (window['class'] == 'Internet Explorer_Hidden' and not window['title'] + and not window['children'] and window.get('rect', [1,1,2,2])[:2] == window.get('rect', [1,1,2,2])[2:]) + if benign: + continue + with _window_desktop(window['desktop']): + children = [dict(c, parent=win32gui.GetParent(c['hwnd']), visible=True) for c in window['children']] + result.append(dict(hwnd=window['hwnd'], pid=row['pid'], **{'class':window['class']}, + text=window['title'], enabled=window['enabled'], children=children, + owner=int(win32gui.GetWindow(window['hwnd'], win32con.GW_OWNER) or 0))) + return result + + +def _close_registered_startup(row, handle, proof, *, stop=None): + import pywintypes, win32con, win32event + 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 + def active_owner(): + check_active() + if stop is not None and stop.is_set(): + return False + owner = _force_ownership(handle,row['pid']) + return (owner.get('force_user_confirmed') is True + and win32event.WaitForSingleObject(handle,0) == win32con.WAIT_TIMEOUT + and _handle_identity(handle) == {k:row.get(k) for k in ('created_handle','image')} + and all(owner.get(k) == row.get(k) for k in ('owner_sid','session_id'))) + def confirmed(): + if not active_owner():return False + fresh = next((p for p in query_process_snapshot() if p['pid'] == row['pid']), None) + return (fresh is not None and all(fresh.get(k) == row.get(k) for k in ('created','command','executable','name')) + and _cancelled_diagnostic_record(row) == proof) + def post(hwnd, message): + if not active_owner() or time.monotonic() >= deadline: + raise ValueError('STARTUP_ACTION_UNCONFIRMED') + _post_window_message({'desktop':job['desktop']}, hwnd, row['pid'], message) + state = {'clicked':set()}; closed = proof['closed_frame'] + try: + while time.monotonic() < deadline: + if win32event.WaitForSingleObject(handle, 0) == win32con.WAIT_OBJECT_0: + return {'release_status':'RELEASED','detail':'已正常结束已取消的诊断启动'} + if not active_owner(): + break + snapshot = _process_windows({row['pid']}) + # Only this fully proved no-write operation may bypass its historical + # UNCONFIRMED label; other operations were vetoed by the proof above. + tip_row = {k:v for k,v in row.items() if k not in ('runtime_phase','library')} + if closed is not None: + tip_row['startup_frame'] = closed + has_tip = any(w['title'] == 'Tip of the Day' for w in snapshot.get(row['pid'],[])) + if has_tip and confirmed() and _dismiss_startup_tip(tip_row,handle,snapshot.get(row['pid'],[]), + incomplete=_window_error(snapshot,row['pid']),deadline=deadline,stop=stop) is not None: + while time.monotonic() < deadline: + if win32event.WaitForSingleObject(handle,100) == win32con.WAIT_OBJECT_0: + 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) + time.sleep(.1) + except (OSError, pywintypes.error, ValueError, RuntimeError) as error: + return {'release_status':'WAITING','detail':str(error)} + return {'release_status':'WAITING','detail':'已请求取消启动清理,等待原生退出后重新检查'} + + def _request_close(row, *, stop=None): import win32con, win32event with _process_handle(row['pid']) as handle: @@ -584,6 +739,8 @@ def _request_close(row, *, stop=None): return {'release_status': 'WAITING', 'detail': '该会话窗口读取不完整,请重新检查:'+error} 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) 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. @@ -795,6 +952,9 @@ def _release_residual_sessions(plan, evidence_dir, *, stop=None, force=False, ca if not save(): return result try: + if not force and not cancel_native: + row['session_records'] = [{k:r.get(k) for k in ('path','operation_id')} + for r in plan.get('runtime_sessions', []) if r.get('path')] outcome = (_request_native_cancel(row, stop=stop) if cancel_native else (_force_close if force else _request_close)(row, stop=stop)) except Exception as error: diff --git a/src/cbb_refresh_verify/session_record.py b/src/cbb_refresh_verify/session_record.py index 6d0abf9..51aace8 100644 --- a/src/cbb_refresh_verify/session_record.py +++ b/src/cbb_refresh_verify/session_record.py @@ -22,13 +22,30 @@ def _library_key(library): return os.path.normcase(os.path.normpath(str(library))) -def library_available(library): +def library_available(library, *, live_only=False): """Cached queue predicate: no file, process or network queries.""" + if live_only: + return _live_library_available(library) key = _library_key(library) with _observer_guard: return not any(key in aliases for aliases in _retained_libraries.values()) +def _live_library_available(library): + """Ignore stale retention, but wait for an actual registered observer.""" + key = _library_key(library) + with _observer_guard: + for path, aliases in _retained_libraries.items(): + observer = _observers.get(path) + if key not in aliases or observer is None or not observer[0].is_alive(): + continue + state = _retained_results.get(path, {}) + if (state.get('observer_initializing') is True or state.get('status') == 'ACTIVE' + or state.get('owned_worker_alive') is True): + return False + return True + + def retained_session_snapshot(library): key = _library_key(library) with _observer_guard: @@ -396,6 +413,10 @@ def observe_retained_session(path, *, evidence_root, stop=None, progress=None, p result = {**result, 'status': 'RELEASED', 'identity_changed': True, 'release_proof': proof} except Exception as error: result['detail'] += f';资源释放待确认:{error}' + try: + result['owned_worker_alive'] = process is not None and process.poll() is None + except Exception: + result['owned_worker_alive'] = False try: write_session_record(observation, {**result, 'operation_id': result['operation_id'] or 'unknown'}) except (OSError, ValueError): @@ -432,12 +453,14 @@ def handoff_session(path, *, evidence_root, process=None, progress=None, stop=No _retained_libraries[key] = aliases _retained_results[key] = {'status': 'UNCONFIRMED', 'phase': 'UNCONFIRMED', 'library': str(library) if library else None, 'block': session.get('block'), - 'detail': '正在核对残留会话', 'operation_id': session.get('operation_id')} + 'detail': '正在核对残留会话', 'operation_id': session.get('operation_id'), + 'observer_initializing': True} def notify(value): with _observer_guard: if _retained_libraries.get(key) is aliases: previous = _retained_results[key] _retained_results[key] = {**previous, **value, + 'observer_initializing': False, 'library': value.get('library') or previous['library'], 'operation_id': value.get('operation_id') or previous['operation_id'], 'block': value.get('block') or previous['block']} diff --git a/src/cbb_refresh_verify/ui/icdb_check_task.py b/src/cbb_refresh_verify/ui/icdb_check_task.py index 36dd25d..3aa077a 100644 --- a/src/cbb_refresh_verify/ui/icdb_check_task.py +++ b/src/cbb_refresh_verify/ui/icdb_check_task.py @@ -136,7 +136,7 @@ class IcdbCheckTask(QObject): return None, str(error) def bounded_write(): try: - return BatchTaskContext(str(self.requests[0].lmc_file)).run(write) + return BatchTaskContext(str(self.requests[0].lmc_file)).run(write, metadata_only=True) except Exception as error: return None, str(error) self.worker = ServiceWorker(bounded_write) diff --git a/src/cbb_refresh_verify/verify_runner.py b/src/cbb_refresh_verify/verify_runner.py index f1a7445..addc4ad 100644 --- a/src/cbb_refresh_verify/verify_runner.py +++ b/src/cbb_refresh_verify/verify_runner.py @@ -230,7 +230,7 @@ def _run_process(command, timeout_seconds, cwd, *, evidence_root=None): return run_content_check(command, timeout_seconds, cwd, evidence_root=evidence_root) -def _stop_worker(process, *, timeout=5): +def _stop_worker(process, *, timeout=5, wait_for_native_write=True): """Request stop without interrupting a possibly unreturned native call.""" try: if hasattr(process, 'request_stop'): @@ -243,7 +243,7 @@ def _stop_worker(process, *, timeout=5): process.wait(timeout=timeout) except Exception: pending = getattr(process, 'native_write_pending', lambda: False)() - if pending is not False and not getattr(process, '_stop_wait_complete', False): + if wait_for_native_write and pending is not False and not getattr(process, '_stop_wait_complete', False): from .defaults import NATIVE_WRITE_STOP_WAIT_SECONDS try: process.wait(timeout=max(0, NATIVE_WRITE_STOP_WAIT_SECONDS - timeout)) @@ -1070,7 +1070,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run '已请求停止,等待当前原生操作返回') _notify_progress(progress, {'stage': 'save_stop_requested', 'block': request.block_name, 'detail': detail}) - _stop_worker(process) + _stop_worker(process, wait_for_native_write=not request.diagnostic_only) return finish(VerifyResult('CANCELLED', stderr='已取消当前校验。', safe_to_continue=False, error_stage=phase.value)) if events.exists(): @@ -1237,7 +1237,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run target_pid=target_pid, observation=last_post_verify_observation, ) - _stop_worker(process) + _stop_worker(process, wait_for_native_write=not request.diagnostic_only) if dispatch_failure is not None: status, detail = dispatch_failure if progress: @@ -1260,7 +1260,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run result = VerifyResult(**outcome) except Exception as error: if 'process' in locals() and process.poll() is None: - _stop_worker(process) + _stop_worker(process, wait_for_native_write=not request.diagnostic_only) launch_release = getattr(error, 'worker_launch_release', None) if 'process' not in locals() else None if not worker_launch_attempted: launch_release = {'process_created': False, 'worker_exited': True, @@ -1279,6 +1279,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run finally: close_errors = [] worker_exited = False + observer_started = False automation_release = {'safe_to_continue': False} if 'process' not in locals() or process.poll() is not None or getattr(process, 'session_record_path', None): # A gated worker owns its writer barrier and inherited sidecar. @@ -1293,18 +1294,17 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run try: worker_exited = process.poll() is not None if not worker_exited: - worker_exited = _stop_worker(process) + worker_exited = _stop_worker(process, wait_for_native_write=not request.diagnostic_only) if hasattr(process, 'automation_release_state'): automation_release = process.automation_release_state() else: automation_release = {'safe_to_continue': worker_exited, 'remaining_pids': []} - if worker_exited: - process.close() - elif getattr(process, 'session_record_path', None): + if not worker_exited and getattr(process, 'session_record_path', None): from .session_record import handoff_session handoff_session(process.session_record_path, evidence_root=root, process=process, progress=lambda state: _notify_progress(progress, {'stage': 'session_observation', 'block': request.block_name, **state})) + observer_started = True _notify_progress(progress, {'stage': 'session_handoff', 'block': request.block_name, 'detail': '已转后台观察,可查看状态'}) from .operation_queue import hold_native_handoff @@ -1353,6 +1353,25 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run 'automation_release': automation_release, 'worker_exited': worker_exited} release_result['remaining_pids'] = sorted(set(release_result.get('remaining_pids', [])) | set(automation_release.get('remaining_pids', []))) + if worker_exited: + try: + if (release_result.get('safe_to_continue') is not True + and getattr(process, 'session_record_path', None)): + if not observer_started: + from .session_record import handoff_session + # Retain the exact worker handle until registered + # native clients exit and the observer obtains proof. + handoff_session(process.session_record_path, evidence_root=root, + process=process, progress=lambda state: _notify_progress(progress, + {'stage': 'session_observation', 'block': request.block_name, **state})) + observer_started = True + _notify_progress(progress, {'stage': 'session_handoff', 'block': request.block_name, + 'detail': '工作进程已退出,原生会话继续后台观察'}) + else: + process.close() + except Exception as error: + release_result = {**release_result, 'safe_to_continue': False, + 'close_errors': [*close_errors, str(error)]} try: from .operation_lifecycle import classify_save_state save_lines = ((root/'save.log').read_text('utf-8', errors='replace').splitlines() diff --git a/tests/test_cancelled_diagnostic_report.py b/tests/test_cancelled_diagnostic_report.py new file mode 100644 index 0000000..5f6f13e --- /dev/null +++ b/tests/test_cancelled_diagnostic_report.py @@ -0,0 +1,34 @@ +from threading import Event + +import pytest + +from cbb_refresh_verify.operation_queue import BatchTaskContext, NativeQueue, TaskHandoff, hold_native_handoff +from cbb_refresh_verify.ui.icdb_check_task import IcdbCheckTask +from cbb_refresh_verify.verify_runner import VerifyResult +from test_verify_runner import fixture, request + + +def test_cancelled_diagnostic_report_survives_ongoing_handoff_finalization(qtbot,tmp_path): + fixture(tmp_path) + req=request(tmp_path,diagnostic_only=True) + context=BatchTaskContext(str(req.lmc_file),native_policy='external') + entered,finish=Event(),Event() + def finalize(): + try: + hold_native_handoff(None,tmp_path/'session.json') + except TaskHandoff: + entered.set() + assert finish.wait(5) + try: + with pytest.raises(TaskHandoff):context.run(finalize) + assert entered.is_set() + task=IcdbCheckTask([req],NativeQueue(),tmp_path/'reports') + task.active=True + task.results=[VerifyResult('CANCELLED',safe_to_continue=False,stderr='已转后台观察')] + task._report() + qtbot.waitUntil(lambda:not task.active,timeout=3000) + assert task.report is not None and task.report.exists(),task.report_error + assert not task.report_error and task.results[0].status=='CANCELLED' + finally: + finish.set() + context.close(timeout_seconds=2) diff --git a/tests/test_cancelled_session_handoff.py b/tests/test_cancelled_session_handoff.py new file mode 100644 index 0000000..5a50693 --- /dev/null +++ b/tests/test_cancelled_session_handoff.py @@ -0,0 +1,129 @@ +import json +from pathlib import Path +from threading import Event + +import pytest + +from cbb_refresh_verify import desktop_worker, session_record, verify_runner as runner +from cbb_refresh_verify.dialog_supervisor import DialogPollResult +from test_verify_runner import fixture, request, PORTS_OK + + +def worker_fixture(tmp_path, monkeypatch, *, exited=False): + fixture(tmp_path) + state = dict(waits=[], closed=False, observers=[], polling=False, polls=0) + stop = Event() + class Worker: + desktop=None; pid=700; companion_pids=[]; returncode=1 if exited else None + def __init__(self, command, name): + self.name=name + path=Path(command[-1]); state.update(path=path,job=json.loads(path.read_text()),worker=self) + self.session_record_path=path.with_name('session.json') + session_record.write_session_record(self.session_record_path, dict( + operation_id=state['job']['operation_id'],library=state['job']['library'], + block=state['job']['block'])) + path.with_name('events.jsonl').write_text(json.dumps(dict(stage='pcb_worker_started',pcb_pid=901))+'\n') + path.with_name('outcome.json').write_text(json.dumps(dict(status='CANCELLED',safe_to_continue=False))) + def poll(self):return self.returncode + def request_stop(self): + assert not state['polling'] + Path(state['job']['cancel_signal']).touch() + def native_write_pending(self):return True + def wait(self,timeout=5): + state['waits'].append(timeout) + if timeout <= 5:raise TimeoutError('native startup still closing') + self.returncode=1;return 1 + def automation_release_state(self):return {'safe_to_continue':self.poll() is not None,'remaining_pids':[]} + def close(self):state['closed']=True + class Supervisor: + def poll(self,*args): + assert not state['observers'] + state['polling']=True;state['polls']+=1;stop.set();state['polling']=False + return DialogPollResult() + monkeypatch.setattr(desktop_worker,'DesktopWorker',Worker) + monkeypatch.setattr(runner,'_cleanup_session_processes',lambda *a,**kw: + {'safe_to_continue':False,'remaining_pids':[901]}) + monkeypatch.setattr(session_record,'handoff_session',lambda path,**kw: + state['observers'].append((path,kw,state['closed']))) + # Keep the task runner deterministic while exercising real supervisor ownership decisions. + monkeypatch.setattr('cbb_refresh_verify.operation_queue.hold_native_handoff',lambda *a:None) + return state,stop,lambda diagnostic:runner.run_verify(request(tmp_path,diagnostic_only=diagnostic), + port_check=PORTS_OK,stop=stop,dialog_supervisor_factory=lambda **kw:Supervisor()) + + +@pytest.mark.parametrize('diagnostic',[True,False]) +def test_diagnostic_cancel_yields_after_five_seconds_but_write_wait_is_unchanged(tmp_path,monkeypatch,diagnostic): + state,stop,run=worker_fixture(tmp_path,monkeypatch) + assert run(diagnostic).status=='CANCELLED' + assert state['waits']==([5] if diagnostic else [5,115]) + assert state['observers'] and state['observers'][0][1]['process'] is state['worker'] + assert not state['observers'][0][2] and not state['closed'] + assert state['polls']==1 + + +def test_exited_worker_with_live_native_clients_keeps_ownership_for_observer(tmp_path,monkeypatch): + state,stop,run=worker_fixture(tmp_path,monkeypatch,exited=True) + result=run(True) + assert result.status=='CANCELLED' and not result.safe_to_continue + assert len(state['observers'])==1, 'worker exit must not orphan the still-live registered native client' + path,options,already_closed=state['observers'][0] + assert path==state['worker'].session_record_path + assert options['process'] is state['worker'] and not already_closed and not state['closed'] + original=json.loads(state['path'].with_name('result.json').read_text()) + assert original['status']=='CANCELLED' and not original['safe_to_continue'] + + +def test_failed_observer_registration_preserves_original_cancelled_result_and_handle(tmp_path,monkeypatch): + state,stop,run=worker_fixture(tmp_path,monkeypatch,exited=True) + def fail(*args,**kwargs):raise OSError('observation journal unavailable') + monkeypatch.setattr(session_record,'handoff_session',fail) + result=run(True) + assert result.status=='CANCELLED' and not result.safe_to_continue + assert not state['closed'] + + +def test_natural_native_exit_gets_fresh_release_and_admits_waiting_scope_without_click(tmp_path,monkeypatch): + import subprocess,sys,time + from concurrent.futures import ThreadPoolExecutor + from types import SimpleNamespace + from cbb_refresh_verify import library_lock + from cbb_refresh_verify.operation_queue import NativeQueue,BatchTaskContext + from test_issue15_resource_release import library_file,cleanup + library=library_file(tmp_path) + gate=tmp_path/'native-exit' + native=subprocess.Popen([sys.executable,'-c', + 'from pathlib import Path; import time,sys\nwhile not Path(sys.argv[1]).exists(): time.sleep(.02)',str(gate)]) + evidence=tmp_path/'evidence';evidence.mkdir();path=evidence/'session.json' + session_record.write_session_record(path,dict(operation_id='cancelled-owned',operation='verify', + library=str(library),block='A',processes=[dict(role='native',**session_record.process_identity(native.pid))])) + original=evidence/'result.json';original.write_text('{"status":"CANCELLED","safe_to_continue":false}') + before=original.read_bytes() + with library_lock.LibraryLock(library,block_name='A',safe_to_release=lambda:False) as lease:pass + monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners',lambda *a,**kw:[]) + active=Event();stop=Event();closed=[] + 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, + 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] + assert not session_record.library_available(library) + queue=NativeQueue() + def admitted(): + with library_lock.LibraryLock(library,checkpoint=False):return 'fresh admission' + with ThreadPoolExecutor(1) as pool: + future=pool.submit(queue.run,admitted,context=BatchTaskContext(str(library)),stop=stop) + time.sleep(.15);assert not future.done() + gate.touch();native.wait(5) + assert future.result(8)=='fresh admission' + thread.join(3) + assert not thread.is_alive() and closed==[0] + observations=[json.loads(p.read_text()) for p in evidence.glob('observation-*.json')] + assert any(o.get('status')=='RELEASED' and o['release_proof']['proof_block_name']=='A' for o in observations) + assert original.read_bytes()==before + finally: + gate.touch();native.wait(5);stop.set() + if thread:thread.join(3) + cleanup(lease) diff --git a/tests/test_live_observer_queue.py b/tests/test_live_observer_queue.py new file mode 100644 index 0000000..eb0ef55 --- /dev/null +++ b/tests/test_live_observer_queue.py @@ -0,0 +1,90 @@ +from concurrent.futures import ThreadPoolExecutor +from threading import Event +from types import SimpleNamespace + +import pytest + +from cbb_refresh_verify import session_record as sessions +from cbb_refresh_verify.operation_queue import BatchTaskContext,NativeQueue + + +def observed(tmp_path,monkeypatch,*,status='ACTIVE',initializing=False,registered=True,alive=True,worker_alive=False): + library=tmp_path/'lib.lmc';key='record' + states={key:dict(status=status,observer_initializing=initializing,owned_worker_alive=worker_alive)} + monkeypatch.setattr(sessions,'_retained_libraries',{key:{sessions._library_key(library)}}) + monkeypatch.setattr(sessions,'_retained_results',states) + monkeypatch.setattr(sessions,'_observers',{key:(SimpleNamespace(is_alive=lambda:alive),None)} if registered else {}) + return library,states[key] + + +@pytest.mark.parametrize('initializing',[False,True]) +def test_same_library_waits_for_actual_observer_and_other_library_can_run(tmp_path,monkeypatch,initializing): + library,state=observed(tmp_path,monkeypatch,status='UNCONFIRMED' if initializing else 'ACTIVE',initializing=initializing) + queue=NativeQueue();waiting=Event();entered=Event();stop=Event() + # Queue predicates may not perform filesystem/process probes. + monkeypatch.setattr(sessions,'query_process_snapshot',lambda *a,**kw:pytest.fail('queue probed native clients'),raising=False) + context=BatchTaskContext(str(library),native_policy='external') + with ThreadPoolExecutor(2) as pool: + future=pool.submit(queue.run,lambda:entered.set() or 'resumed',context=context,stop=stop,waiting=waiting.set) + try: + assert waiting.wait(.5) and not entered.is_set() + other=pool.submit(queue.run,lambda:'unrelated',context=BatchTaskContext(str(tmp_path/'other.lmc'))) + assert other.result(1)=='unrelated' + state.update(status='RELEASED',observer_initializing=False) + assert future.result(2)=='resumed' + finally: + stop.set();queue.wake() + + +@pytest.mark.parametrize('case',['orphaned','dead_thread','unconfirmed','released']) +def test_stale_or_nonlive_cache_does_not_prevent_fresh_scoped_admission(tmp_path,monkeypatch,case): + library,state=observed(tmp_path,monkeypatch,status='RELEASED' if case=='released' else 'UNCONFIRMED', + registered=case!='orphaned',alive=case!='dead_thread') + assert not sessions.library_available(library) # Historical cache is deliberately stale. + assert NativeQueue().run(lambda:'fresh admission',context=BatchTaskContext(str(library)))=='fresh admission' + + +def test_live_owned_worker_still_blocks_when_its_journal_cannot_be_read(tmp_path,monkeypatch): + library,state=observed(tmp_path,monkeypatch,status='UNCONFIRMED',worker_alive=True) + queue=NativeQueue();waiting=Event();stop=Event();entered=Event() + with ThreadPoolExecutor(1) as pool: + future=pool.submit(queue.run,lambda:entered.set(),context=BatchTaskContext(str(library)), + stop=stop,waiting=waiting.set) + try: + assert waiting.wait(.5) and not entered.is_set() + state['owned_worker_alive']=False + future.result(2) + finally: + stop.set();queue.wake() + + +def test_actual_observer_initialization_closes_queue_race_then_unconfirmed_cache_releases_it(tmp_path,monkeypatch): + library=tmp_path/'lib.lmc';path=tmp_path/'session.json' + sessions.write_session_record(path,dict(operation_id='initializing',library=str(library))) + entered,finish,waiting,stop=Event(),Event(),Event(),Event() + def first_scan(*args,**kwargs): + entered.set();assert finish.wait(3) + return dict(status='UNCONFIRMED',operation_id='initializing',library=str(library), + detail='No live client; fresh admission must recheck resource proof') + monkeypatch.setattr(sessions,'_reconcile',first_scan) + queue=NativeQueue();thread=None + try: + sessions.handoff_session(path,evidence_root=tmp_path,observe_only=True,stop=stop) + assert entered.wait(2) + thread=sessions._observers[str(path.absolute()).casefold()][0] + assert not sessions.library_available(library,live_only=True) + with ThreadPoolExecutor(1) as pool: + future=pool.submit(queue.run,lambda:'fresh scoped admission',context=BatchTaskContext(str(library)), + waiting=waiting.set,stop=stop) + try: + assert waiting.wait(1) and not future.done() + finish.set() + assert future.result(2)=='fresh scoped admission' + finally: + stop.set();queue.wake() + thread.join(2) + assert not sessions.library_available(library) # Unproved historical state remains visible. + assert sessions.library_available(library,live_only=True) + finally: + finish.set();stop.set() + if thread:thread.join(2) diff --git a/tests/test_registered_startup_release.py b/tests/test_registered_startup_release.py new file mode 100644 index 0000000..b9c7d20 --- /dev/null +++ b/tests/test_registered_startup_release.py @@ -0,0 +1,150 @@ +from contextlib import nullcontext +import json +from pathlib import Path + +import pytest + +from cbb_refresh_verify import diagnostic_open, residual_sessions as sessions, session_record +from test_cancelled_loaded_startup import loaded_fixture + + +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) + 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. + identity=dict(pid=12,created_handle='native-created',image=records[0][1],owner_sid='current',session_id=1) + worker=dict(pid=11,created_handle='worker-created',image='C:/App/CbbRefreshVerify.exe',owner_sid='current',session_id=1) + session_record.write_session_record(tmp_path/'session.json',dict(operation_id='verify-old',operation='verify', + library=job['library'],block=job['block'],desktop=job['desktop'],cancel_signal=job['cancel_signal'], + processes=[dict(role='worker',**worker)],resource_scope=dict(scope_state='DECLARED', + library=job['library'],operation_id='verify-old',projects=[job['project']]))) + session_record.write_session_record(tmp_path/'worker-state.json',dict(operation_id='verify-old', + phase='UNCONFIRMED',processes=[dict(role='native',**identity)])) + result=dict(status='CANCELLED',error_stage='PCB_STARTING',safe_to_continue=False, + write_outcome=dict(save_state='UNKNOWN')) + events=[dict(stage='pcb_baseline',pids=[]),dict(stage='pcb_worker_started',pcb_pid=12,command=records[0][2])] + if closed:events.append(dict(stage='startup_close_requested',pcb_pid=12,hwnd=100)) + if obstacle=='ordinary':job['diagnostic_only']=False + if obstacle=='interactive':job['interactive_input']=True + if obstacle=='other_project':job['project']=str(tmp_path/'Other.prj') + if obstacle=='wrong_operation':job['operation_id']='other' + if obstacle=='missing_cancel':Path(job['cancel_signal']).unlink() + if obstacle=='save':(tmp_path/'save.log').write_text('SAVE_ENTERED') + if obstacle=='save_event':events.append(dict(stage='save_start')) + if obstacle=='not_cancelled':result['status']='FAIL' + if obstacle=='wrong_stage':result['error_stage']='SAVING' + (tmp_path/'request.json').write_text(json.dumps(job)) + (tmp_path/'result.json').write_text(json.dumps(result)) + (tmp_path/'events.jsonl').write_text(''.join(json.dumps(e)+'\n' for e in events)) + row=dict(pid=12,name='ExpeditionPCB.exe',command=records[0][2],created='native-created', + executable=identity['image'],library=job['library'],scope_confirmed=True,runtime_phase='UNCONFIRMED', + session_records=[dict(path=str(tmp_path/'session.json'),operation_id='verify-old')],**{k:v for k,v in identity.items() if k!='pid'}) + if obstacle=='foreign_identity':row['created_handle']='replacement' + if obstacle=='unscoped':row['scope_confirmed']=False + monkeypatch.setattr(sessions,'_process_handle',lambda pid,**kw:nullcontext(pid)) + monkeypatch.setattr(sessions,'_handle_identity',lambda handle:{k:v for k,v in (worker if handle==11 else identity).items() if k in ('created_handle','image')}) + monkeypatch.setattr(sessions,'_force_ownership',lambda h,p:{'owner_sid':'current','session_id':1,'force_user_confirmed':True}) + def wait(handle,ms): + state['ticks']+=ms/1000 + return win32con.WAIT_OBJECT_0 if handle==11 and obstacle!='live_worker' or handle==12 and not records else win32con.WAIT_TIMEOUT + monkeypatch.setattr(win32event,'WaitForSingleObject',wait) + monkeypatch.setattr(sessions,'time',diagnostic_open.time) + monkeypatch.setattr(sessions,'query_process_snapshot',lambda:[row]) + monkeypatch.setattr(sessions,'_legacy_diagnostic_windows',lambda r:diagnostic_open._windows(r['pid']),raising=False) + monkeypatch.setattr(sessions,'_window_desktop',lambda *a,**kw:nullcontext()) + monkeypatch.setattr(sessions,'_post_window_message',lambda w,h,p,m:__import__('win32gui').PostMessage(h,m,0,0)) + monkeypatch.setattr(session_record,'active_write_records',lambda library: + [dict(operation_id='other-write' if obstacle=='other_write' else 'verify-old',phase='UNCONFIRMED')]) + monkeypatch.setattr(diagnostic_open,'_load_evidence',lambda *a,**kw: + pytest.fail('legacy cleanup may not manufacture missing prelaunch log evidence')) + return job,row,records,messages,state + + +@pytest.mark.parametrize('closed',[False,True]) +def test_normal_release_finishes_exact_registered_cancelled_startup_without_save_or_second_close(tmp_path,monkeypatch,closed): + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch,closed=closed) + original=(tmp_path/'result.json').read_bytes() + result=sessions._request_close(row) + assert result['release_status']=='RELEASED' + assert messages==([(31,245)] if closed else [(31,245),(100,16)]) + assert not records and (tmp_path/'result.json').read_bytes()==original + + +@pytest.mark.parametrize('obstacle',['ordinary','interactive','other_project','wrong_operation','missing_cancel', + 'save','save_event','not_cancelled','wrong_stage','foreign_identity','unscoped','live_worker','other_write']) +def test_registered_startup_release_rejects_partial_foreign_or_writing_evidence(tmp_path,monkeypatch,obstacle): + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch,obstacle=obstacle) + assert sessions._request_close(row)['release_status'] in ('WAITING','IDENTITY_CHANGED') + assert not messages and records + + +@pytest.mark.parametrize('error_code',[87,5]) +def test_registered_worker_exit_requires_kernel_exit_or_missing_pid_not_access_denial(tmp_path,monkeypatch,error_code): + import pywintypes + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch) + original=sessions._process_handle + def open_process(pid,**kwargs): + if pid==11:raise pywintypes.error(error_code,'OpenProcess','worker probe') + return original(pid,**kwargs) + monkeypatch.setattr(sessions,'_process_handle',open_process) + result=sessions._request_close(row) + assert result['release_status']==('RELEASED' if error_code==87 else 'WAITING') + assert messages==([(31,245),(100,16)] if error_code==87 else []) + + +def test_completed_identity_snapshots_fit_existing_release_budget_without_duplicate_polling(tmp_path,monkeypatch): + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch) + def snapshot(): + state['ticks']+=.4 + return [row] + monkeypatch.setattr(sessions,'query_process_snapshot',snapshot) + assert sessions._request_close(row)['release_status']=='RELEASED' + assert messages==[(31,245),(100,16)] and state['ticks']<3 + + +@pytest.mark.parametrize('change',['result','stop','identity']) +def test_legacy_no_rechecks_registered_state_after_fresh_windows(tmp_path,monkeypatch,change): + from threading import Event + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch) + stop=Event();reads=[] + original=sessions._legacy_diagnostic_windows + def windows(bound): + value=original(bound);reads.append(1) + if len(reads)==2: + if change=='result':(tmp_path/'result.json').write_text('{"status":"PASS"}') + if change=='stop':stop.set() + if change=='identity':row['created_handle']='replacement' + return value + monkeypatch.setattr(sessions,'_legacy_diagnostic_windows',windows) + assert sessions._request_close(row,stop=stop)['release_status']=='WAITING' + assert records and not messages + + +@pytest.mark.parametrize('frame_handle',[100,999]) +def test_normal_release_clears_registered_late_tip_despite_historical_unknown_phase(tmp_path,monkeypatch,frame_handle): + import win32con,win32gui + from copy import deepcopy + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch,closed=True) + state['tip']=True + windows=[dict(hwnd=frame_handle,**{'class':'Afx:main'},title='Expedition PCB',enabled=False, + desktop=job['desktop'],children=[],documents=[]), + dict(hwnd=200,**{'class':'#32770'},title='Tip of the Day',enabled=True, + desktop=job['desktop'],documents=[],children=[dict(hwnd=201,**{'class':'Button'},id=1,text='OK',enabled=True)])] + monkeypatch.setattr(sessions,'_process_windows',lambda pids:{12:deepcopy(windows)}) + monkeypatch.setattr(win32gui,'GetWindow',lambda h,k:frame_handle if h==200 and k==win32con.GW_OWNER else 0) + def post(hwnd,message,*args):messages.append((hwnd,message));records.clear() + monkeypatch.setattr(win32gui,'PostMessage',post) + result=sessions._request_close(row) + assert result['release_status']==('RELEASED' if frame_handle==100 else 'WAITING') + assert messages==([(201,245)] if frame_handle==100 else []) + + +def test_registered_cleanup_cannot_act_from_another_windows_user_session(tmp_path,monkeypatch): + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch) + monkeypatch.setattr(sessions,'_force_ownership',lambda h,p: + dict(owner_sid='current',session_id=1,force_user_confirmed=False)) + assert sessions._request_close(row)['release_status']=='WAITING' + assert not messages and records