From dbc685b9a54046742b87aac887c0d3364c4183ee 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: Mon, 16 Nov 2026 23:28:36 +0800 Subject: [PATCH] fix: hand off UI shutdown without releasing native ownership --- src/cbb_refresh_verify/operation_queue.py | 68 ++++- src/cbb_refresh_verify/session_record.py | 17 +- .../ui/backup_recovery_dialog.py | 2 +- src/cbb_refresh_verify/ui/icdb_check_task.py | 3 +- src/cbb_refresh_verify/ui/main_window.py | 99 +++--- .../ui/management_dialog.py | 4 +- src/cbb_refresh_verify/verify_runner.py | 4 +- tests/test_desktop_worker.py | 23 +- tests/test_issue15_shutdown_handoff.py | 281 ++++++++++++++++++ tests/test_issue15_task_lifecycle.py | 5 +- 10 files changed, 454 insertions(+), 52 deletions(-) create mode 100644 tests/test_issue15_shutdown_handoff.py diff --git a/src/cbb_refresh_verify/operation_queue.py b/src/cbb_refresh_verify/operation_queue.py index f1a2a23..c74a6f1 100644 --- a/src/cbb_refresh_verify/operation_queue.py +++ b/src/cbb_refresh_verify/operation_queue.py @@ -67,6 +67,10 @@ class _Call: done: Event = field(default_factory=Event) abandoned: bool = False native_depth: int = 0 + readonly_depth: int = 0 + supervised_depth: int = 0 + worker_sessions: list = field(default_factory=list) + shutdown_handoff: bool = False native_handoff: str = '' handoff_cancelled: bool = False phase_started: float = field(default_factory=time.monotonic) @@ -102,6 +106,24 @@ def remember_result(result): return result +def bind_supervised_worker(path, record): + """Called only after the common launcher has durably registered its worker.""" + call = getattr(_local, 'call', None) + if call is not None: + with _tasks_guard: + call.worker_sessions.append(dict(path=str(path), operation_id=record['operation_id'], + processes=record['processes'], worker_lease_handle=record.get('worker_lease_handle'), + worker_protection=record.get('worker_protection'), resource_scope=record.get('resource_scope'))) + + +def check_worker_admission(job): + check_active() + call = getattr(_local, 'call', None) + if (call is not None and call.readonly_depth and job.get('inspection_only') is not True + and job.get('operation') != 'catalog'): + raise RuntimeError('NATIVE_ROLE_REQUIRED: 只读观察不能启动原生写入进程。') + + def hold_native_handoff(process, session_record_path): """Yield parent admission to controls; the gated worker retains write exclusion. @@ -118,29 +140,39 @@ def hold_native_handoff(process, session_record_path): @contextmanager -def native_phase(): +def native_phase(*, read_only=False, supervised=False): """Never abandon a transaction between native writes (including Remove/Add).""" call = getattr(_local, 'call', None) if call is not None and call.metadata_only: raise RuntimeError('A metadata-only call cannot enter native work') + if call is not None: + if call.readonly_depth and not read_only: + raise RuntimeError('NATIVE_ROLE_REQUIRED: 只读观察不能提交原生写入。') + if not read_only and (call.context.native_policy == 'restricted' + or call.context.native_policy == 'external' and not supervised): + raise RuntimeError('NATIVE_ROLE_REQUIRED: 界面写入必须通过已登记的独立工作进程。') with _tasks_guard: check_active() if call is not None: call.native_depth += 1 + call.readonly_depth += int(read_only) + call.supervised_depth += int(supervised) try: yield finally: if call is not None: with _tasks_guard: call.native_depth -= 1 + call.readonly_depth -= int(read_only) + call.supervised_depth -= int(supervised) call.phase_started = time.monotonic() @contextmanager -def native_channel(*, inspection_only=False): +def native_channel(*, inspection_only=False, read_only=False): """Shared by Verify, Repair and backup native clients; reentrant per thread.""" import win32con, win32event - with native_phase(): + with native_phase(read_only=read_only or inspection_only, supervised=True): mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795') acquired = False try: @@ -168,8 +200,11 @@ class BatchTaskContext: operation_id: str = field(default_factory=lambda: uuid4().hex) stop: _StopSignal = field(default_factory=_StopSignal, repr=False, compare=False) _closed: Event = field(default_factory=Event, repr=False, compare=False) + native_policy: str = field(default='legacy', kw_only=True) def __post_init__(self): + if self.native_policy not in ('legacy', 'restricted', 'external'): + raise ValueError('Unknown native task role') object.__setattr__(self, 'library', str(self.library)) for name in ('aliases', 'targets', 'resources'): object.__setattr__(self, name, tuple(str(v) for v in getattr(self, name))) @@ -195,6 +230,29 @@ class BatchTaskContext: 'RUNNING' if pending else 'IDLE', pending=pending, pending_native=any(c.native_depth for c in calls)) + def shutdown(self): + """Yield UI supervision, never a native worker's write/lease ownership. + + External-role code only dispatches through register_worker_session. An + empty binding list means pre-dispatch preparation; its late gate is + cancelled by that hook. Legacy in-process transactions cannot opt in. + """ + self._closed.set() + self.cancel() + with _tasks_guard: + calls = [c for c in _calls.values() if c.context is self and not c.done.is_set()] + for call in calls: + readonly = call.native_depth and call.readonly_depth == call.native_depth + external = (self.native_policy == 'external' and + call.supervised_depth == call.native_depth and + all(s.get('worker_protection') in ('duplicated_lease', 'worker_owned_lease', 'inspection_only') + for s in call.worker_sessions)) + if not call.native_depth or readonly or external: + call.shutdown_handoff = call.abandoned = True + return {**self.snapshot(), 'safe_to_continue': False, + 'shutdown_handoff': all(c.shutdown_handoff for c in calls), + 'worker_sessions': [s for c in calls for s in c.worker_sessions]} + def cancel(self): self.stop.set() @@ -234,7 +292,7 @@ class BatchTaskContext: aliases = {_path_key(v) for v in (self.library, *self.aliases)} call = _Call(self, stop, metadata_only=metadata_only) with _tasks_guard: - if not metadata_only and any(c.abandoned and not c.metadata_only and aliases.intersection( + if not metadata_only and self.native_policy != 'restricted' and any(c.abandoned and not c.metadata_only and aliases.intersection( _path_key(v) for v in (c.context.library, *c.context.aliases)) for c in _calls.values()): raise TaskHandoff(self) @@ -254,6 +312,8 @@ class BatchTaskContext: Thread(target=execute, name='cbb-task-'+self.operation_id[:12], daemon=True).start() while not call.done.wait(.02): with _tasks_guard: + if call.shutdown_handoff: + raise TaskHandoff(self, cancelled=True, result=call.last_result) if call.native_handoff: cancelled = call.handoff_cancelled call.abandoned = True diff --git a/src/cbb_refresh_verify/session_record.py b/src/cbb_refresh_verify/session_record.py index 2c76ef9..04cdf70 100644 --- a/src/cbb_refresh_verify/session_record.py +++ b/src/cbb_refresh_verify/session_record.py @@ -128,14 +128,27 @@ def library_wait_reason(library): def register_worker_session(worker, job): """The launcher must persist identity before opening the worker's gate.""" path = Path(job['session_record_path']) + from .operation_queue import check_worker_admission, current_context, bind_supervised_worker + check_worker_admission(job) + context = current_context() + protection = ('duplicated_lease' if job.get('worker_lease_handle') else + 'worker_owned_lease' if job.get('operation') == 'native_backup' else + 'inspection_only' if job.get('inspection_only') is True else None) + if context is not None and context.native_policy == 'external': + if protection is None or worker.pid == os.getpid(): + raise RuntimeError('WORKER_OWNERSHIP_REQUIRED: 原生写入未登记独立进程和租约。') from .icdb_ownership import session_resource_scope - write_session_record(path, {k: job.get(k) for k in ( + record = ({k: job.get(k) for k in ( 'operation_id', 'operation', 'library', 'block', 'desktop', 'cancel_signal', 'worker_lease_handle')} | {'processes': [{'role': 'worker', **process_identity(worker.pid)}], 'lease_state': 'ACTIVE', 'resource_scope': session_resource_scope(job), - 'blocked_resources': [], 'data_recovery_required': None}) + 'worker_protection': protection, 'task_operation_id': context.operation_id if context else None, + 'blocked_resources': [], 'data_recovery_required': None}) + write_session_record(path, record) + bind_supervised_worker(path, record) worker.session_record_path = path worker.cbb_library = job['library'] + check_worker_admission(job) # A slow registration must not open a gate after UI shutdown. def update_worker_state(job, phase, *, identities=(), observed_identities=(), write_outcome=None, diff --git a/src/cbb_refresh_verify/ui/backup_recovery_dialog.py b/src/cbb_refresh_verify/ui/backup_recovery_dialog.py index cfe2444..0fedaeb 100644 --- a/src/cbb_refresh_verify/ui/backup_recovery_dialog.py +++ b/src/cbb_refresh_verify/ui/backup_recovery_dialog.py @@ -103,7 +103,7 @@ class BackupRecoveryDialog(QDialog): self.status_label.setText('相同任务已提交,未重复执行。') return self.busy = True - self.context = BatchTaskContext(str(request.lmc_file), targets=(name,)) + self.context = BatchTaskContext(str(request.lmc_file), targets=(name,), native_policy='external') context = self.context self.stop = context.stop self._set_enabled(False) diff --git a/src/cbb_refresh_verify/ui/icdb_check_task.py b/src/cbb_refresh_verify/ui/icdb_check_task.py index d3960e1..36dd25d 100644 --- a/src/cbb_refresh_verify/ui/icdb_check_task.py +++ b/src/cbb_refresh_verify/ui/icdb_check_task.py @@ -16,7 +16,8 @@ class IcdbCheckTask(QObject): self.requests = tuple(requests) self.queue, self.report_root = queue, report_root self.path_lease = path_lease - self.context = BatchTaskContext(str(self.requests[0].lmc_file), targets=tuple(r.block_name for r in self.requests)) + self.context = BatchTaskContext(str(self.requests[0].lmc_file), + targets=tuple(r.block_name for r in self.requests), native_policy='external') self.status_reader = status_reader self.verifier = verifier or (lambda req: run_verify(req, progress=self._emit_event, stop=self.stop, version_prompt=choice_prompt)) diff --git a/src/cbb_refresh_verify/ui/main_window.py b/src/cbb_refresh_verify/ui/main_window.py index e57a2c4..18edbc7 100644 --- a/src/cbb_refresh_verify/ui/main_window.py +++ b/src/cbb_refresh_verify/ui/main_window.py @@ -77,10 +77,6 @@ STATUS_LABELS = { 'CRASHED': '状态桥崩溃', } -# Qt must not destroy a pool whose native observer is still handing off. -_shutdown_pools = set() - - def application_icon_path(): return Path(__file__).resolve().parents[1] / 'assets' / 'cbb_refresh_verify.ico' @@ -137,6 +133,9 @@ class MainWindow(QWidget): self._lease_pending = 0 self._lease_workers = set() self._lease_contexts = set() + self._shutdown_leases = {} + self._retention_intents = {} + self._retention_ready = set() self._mapping_busy = 0 self._mapping_owners = Counter() self._mapping_auto_owners = set() @@ -367,7 +366,9 @@ class MainWindow(QWidget): def _new_job(self, kind, *, library=None, targets=(), lease=None): library = str(library or self.mentor_lmc_path or self.lmc_edit.text()) lease = self.library_lease if lease is None else lease - context = BatchTaskContext(library, aliases=tuple(_library_path_keys(library, lease)), targets=tuple(targets)) + policy = 'external' if kind in ('verify','management','recovery','icdb','catalog','status','native_session') else 'restricted' + context = BatchTaskContext(library, aliases=tuple(_library_path_keys(library, lease)), + targets=tuple(targets), native_policy=policy) job = SimpleNamespace(context=context, kind=kind, revision=self._view_revision, lease=lease, requests=(), records={}, active=True, keep_session=False) self._jobs[context.operation_id] = job @@ -399,9 +400,11 @@ class MainWindow(QWidget): paused.resume() job.active = False self._jobs.pop(job.context.operation_id, None) - job.context.close(timeout_seconds=0) + state = job.context.close(timeout_seconds=0) if job.lease is not None and job.lease is not self.library_lease: - if not any(other.lease is job.lease for other in self._jobs.values()): + if state['pending'] or id(job.lease) in self._shutdown_leases: + self._retain_path_lease(job.lease) + elif not any(other.lease is job.lease for other in self._jobs.values()): self._close_path_lease(job.lease) if self._job_current(job): self._finished() @@ -420,11 +423,20 @@ class MainWindow(QWidget): self.logging_context.logger.warning('library_lease_release_failed error=%s', error) def _close_path_lease(self, lease): + if id(lease) in self._shutdown_leases: return + if id(lease) in self._retention_intents and id(lease) not in self._retention_ready: return self._lease_action(lease.close) def _retain_path_lease(self, lease, *, hold_busy=False): if lease is not None: - self._lease_action(lease.retain_for_recovery, hold_busy=hold_busy) + self._retention_intents[id(lease)] = lease + self._retention_ready.discard(id(lease)) + def retained(_): + self._retention_ready.add(id(lease)) + if (not self._closing and lease is not self.library_lease + and not any(job.lease is lease for job in self._jobs.values())): + self._close_path_lease(lease) + self._lease_action(lease.retain_for_recovery, retained, hold_busy=hold_busy, completed_always=True) def _lease_action(self, action, completed=None, failed=None, *, hold_busy=False, library=None, completed_always=False): @@ -442,7 +454,8 @@ class MainWindow(QWidget): self.busy = True self._update() library = library or getattr(getattr(action,'__self__',None),'mentor_path',None) - context = BatchTaskContext(str(library or self.mentor_lmc_path or self.loaded_path or self.data_root)) + context = BatchTaskContext(str(library or self.mentor_lmc_path or self.loaded_path or self.data_root), + native_policy='restricted') self._lease_contexts.add(context) worker = ServiceWorker(lambda:context.run(action)) self._lease_workers.add(worker) @@ -636,6 +649,7 @@ class MainWindow(QWidget): revision, owner_job, lease = self._view_revision, self._current_job, self.library_lease self.release_dialog = ResidualReleaseDialog(library, self.data_root/'release-checks', self) dialog = self.release_dialog + dialog.path_lease = lease self._dialogs.append(dialog) self.release_dialog.native_queue = self.native_queue from cbb_refresh_verify.network_path import release_retained_path_leases @@ -644,7 +658,7 @@ class MainWindow(QWidget): self.release_dialog.before_release.connect(lambda:release_check.cancel() if release_check is not None and release_check.active else None) self.release_dialog.released.connect(lambda result: self._complete_library_release( - library, result, lease=lease, revision=revision)) + library, result, lease=lease, revision=revision, owner_job=owner_job)) self.release_dialog.finished.connect(lambda *_:self._release_dialog_finished() if revision == self._view_revision and owner_job is self._current_job else None) self.busy = True; self._update() @@ -669,20 +683,26 @@ class MainWindow(QWidget): self.summary.setText('会话已释放,可以继续未执行项。') self.summary.show() - def _complete_library_release(self, library, result, *, lease=None, revision=None): + def _complete_library_release(self, library, result, *, lease=None, revision=None, owner_job=None): from cbb_refresh_verify.network_path import release_retained_path_leases lease = self.library_lease if lease is None else lease - revision = self._view_revision if revision is None else revision + if revision is None: + revision, owner_job = self._view_revision, self._current_job + def current(): + return not self._closing and revision == self._view_revision and owner_job is self._current_job def ready(): self._management_unsafe_libraries.discard(_path_key(library)) - if revision == self._view_revision and not self._closing: self._library_release_ready(library, result) + if lease is not None and not getattr(lease, '_retained_for_recovery', False): + self._retention_intents.pop(id(lease), None) + self._retention_ready.discard(id(lease)) + if current(): self._library_release_ready(library, result) try: if (not isinstance(result, dict) or result.get('status') != 'RELEASE_CONFIRMED' or not (_library_path_keys(result.get('library'), lease) & _library_path_keys(library, lease))): raise ValueError('RELEASE_PROOF_UNCONFIRMED: 释放证明未确认或不属于当前中心库。') except Exception as error: - if revision == self._view_revision: self._display_error(error) + if current(): self._display_error(error) return if result.get('mapping_cleanup_complete') is True: ready() @@ -694,8 +714,8 @@ class MainWindow(QWidget): if lease is not None: lease.retain_for_recovery() raise self._lease_action(release, lambda _: ready(), - lambda error:self._display_error(error) if revision == self._view_revision else None, - hold_busy=revision == self._view_revision, library=library, completed_always=True) + lambda error:self._display_error(error) if current() else None, + hold_busy=current(), library=library, completed_always=True) def _library_release_ready(self, library, result): current_library = _path_key(self.mentor_lmc_path or self.lmc_edit.text().strip()) @@ -1382,7 +1402,7 @@ class MainWindow(QWidget): def _start_catalog(self, read_job, initial, lease, library, deliver): from cbb_refresh_verify.models import CbbRecord, LibraryReadResult - context = BatchTaskContext(str(library), aliases=tuple(_library_path_keys(library, lease))) + context = BatchTaskContext(str(library), aliases=tuple(_library_path_keys(library, lease)), native_policy='external') job = SimpleNamespace(context=context, kind='catalog', revision=read_job.revision, lease=lease, requests=(), records={}, active=True, keep_session=False) self._jobs[context.operation_id] = job @@ -1851,7 +1871,8 @@ class MainWindow(QWidget): if callback: callback(records) library, lease = self.mentor_lmc_path or self.loaded_path, self.library_lease - self._start(lambda: self._read_affected_records(targets, library=library, lease=lease), refreshed) + job = self._new_job('status', library=library, targets=targets, lease=lease) + self._start(lambda: self._read_affected_records(targets, library=library, lease=lease), refreshed, job=job) return True def _progress(self, event): @@ -2167,8 +2188,16 @@ class MainWindow(QWidget): else: self._closing = True self._close_started = time.monotonic() - for job in tuple(self._jobs.values()): - job.context.close(timeout_seconds=0) + owned = {**self._retention_intents, **{id(job.lease):job.lease for job in self._jobs.values() + if job.lease is not None and (job.active or job.keep_session or job.context.snapshot()['pending'])}} + for dialog in self._dialogs: + lease = getattr(dialog,'path_lease',None) + if lease is not None and getattr(dialog,'busy',False): owned[id(lease)] = lease + if self._native_backup_session is not None: + lease = self._native_backup_session.path_lease + if lease is not None: owned[id(lease)] = lease + self._shutdown_leases.update(owned) + handoffs = [job.context.shutdown() for job in tuple(self._jobs.values())] for context in tuple(self._lease_contexts): context.close(timeout_seconds=0) for context in tuple(self._lifecycle_contexts): context.close(timeout_seconds=0) self.native_queue.wake() @@ -2180,19 +2209,26 @@ class MainWindow(QWidget): if dialog is not None and getattr(dialog, 'busy', False): dialog.stop.set() context = getattr(dialog, 'context', None) - if context is not None: context.close(timeout_seconds=0) + if context is not None: handoffs.append(context.shutdown()) self.busy = True; self._update() self.setWindowTitle('CBB 刷新校验 · 等待任务安全结束') self.status_label.setText('正在等待当前操作安全结束,完成后关闭。') self.close_wait_timer.start() - retained = None if self._native_backup_session is not None: self.native_backup_timer.stop() - retained = self._native_backup_session.path_lease lease, self.library_lease = self.library_lease, None def release(): - if retained is not None: retained.retain_for_recovery() - if lease is not None and lease is not retained: lease.close() + for retained in owned.values(): retained.retain_for_recovery() + if lease is not None and id(lease) not in owned: lease.close() + # Original worker/session registrations already precede native + # admission; this receipt records the UI shutdown, never release. + from cbb_refresh_verify.session_record import write_session_record + receipt = self.data_root/'shutdown'/('close-'+str(time.time_ns())+'.json') + receipt.parent.mkdir(parents=True, exist_ok=True) + write_session_record(receipt, + dict(status='UNCONFIRMED',safe_to_continue=False,task_scopes=handoffs, + retained_mappings=[dict(display=str(getattr(item,'display_path','')), + mentor=str(getattr(item,'mentor_path',''))) for item in owned.values()])) self._lease_action(release) self._close_when_idle() event.ignore() @@ -2213,20 +2249,9 @@ class MainWindow(QWidget): active = active or bool(pool is not None and pool.activeThreadCount()) except RuntimeError: pass # Qt may already have deleted a closed dialog's pool. - if (self._lease_pending or active) and time.monotonic()-getattr(self,'_close_started',time.monotonic()) < 30: + if self._lease_pending or active: QTimer.singleShot(20, self._close_when_idle) return - if active: - for pool in (self.lifecycle_pool, self.lease_pool): - pool.setParent(None) - _shutdown_pools.add(pool) - for owner in owners: - pool = getattr(owner, 'pool', None) - if pool is not None: - try: - pool.setParent(None) - _shutdown_pools.add(pool) - except RuntimeError: pass self.close_wait_timer.stop() self._close_ready = True self.close() diff --git a/src/cbb_refresh_verify/ui/management_dialog.py b/src/cbb_refresh_verify/ui/management_dialog.py index 581dc68..09ed6e7 100644 --- a/src/cbb_refresh_verify/ui/management_dialog.py +++ b/src/cbb_refresh_verify/ui/management_dialog.py @@ -59,7 +59,7 @@ class ManagementDialog(QDialog): evidence_dir=self.template.evidence_dir.parent/'reimport-recovery', **kwargs) self.busy = False self.executed = False - self.context = BatchTaskContext(str(self.template.library)) + self.context = BatchTaskContext(str(self.template.library), native_policy='external') self.stop = self.context.stop self.ui_job = None self.admit = None @@ -177,7 +177,7 @@ class ManagementDialog(QDialog): if self.admit is not None and not self.admit(tuple(requests)): self.status_label.setText('相同任务已提交,未重复执行。') return - self.context = BatchTaskContext(str(self.template.library), targets=tuple(r.name for r in requests)) + self.context = BatchTaskContext(str(self.template.library), targets=tuple(r.name for r in requests), native_policy='external') context = self.context self.stop = context.stop self.busy = True; self.executed = True diff --git a/src/cbb_refresh_verify/verify_runner.py b/src/cbb_refresh_verify/verify_runner.py index af2f9a4..7314ee9 100644 --- a/src/cbb_refresh_verify/verify_runner.py +++ b/src/cbb_refresh_verify/verify_runner.py @@ -889,7 +889,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run timing.begin('content_check') try: from .operation_queue import native_channel - with native_channel(): + with native_channel(read_only=True): exit_code, stdout, stderr, timed_out = runner(command, request.timeout_seconds, Path(request.lmc_file).parent) finally: timing.end('content_check') @@ -1358,7 +1358,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run if progress: _notify_progress(progress, {'stage': 'library_flag_probe', 'block': request.block_name, **record}) try: - with native_channel(): + with native_channel(read_only=True): probe = read_library_flag_with_retry( flag_reader or read_library_flag_if_available, Path(request.lmc_file), request.block_name, on_attempt=record_attempt) diff --git a/tests/test_desktop_worker.py b/tests/test_desktop_worker.py index 539d237..12c516e 100644 --- a/tests/test_desktop_worker.py +++ b/tests/test_desktop_worker.py @@ -115,7 +115,28 @@ def test_reader_never_creates_a_desktop_or_process(monkeypatch, tmp_path, reader import win32service import win32process import cbb_refresh_verify.mentor_adapter as module - from pywinauto import Desktop + import sys + import pythoncom + if 'pywinauto' not in sys.modules: + # Match the real worker's STA apartment. pywinauto's first import probes + # MTA and may report its fallback; validate that exact diagnostic only. + import warnings + pythoncom.CoInitializeEx(pythoncom.COINIT_APARTMENTTHREADED) + try: + with warnings.catch_warnings(record=True) as diagnostics: + warnings.simplefilter('always') + from pywinauto import Desktop + for diagnostic in diagnostics: + if diagnostic.category is UserWarning and str(diagnostic.message) in ( + 'Revert to STA COM threading mode', 'Apply externally defined coinit_flags: 2'): + assert sys.coinit_flags == pythoncom.COINIT_APARTMENTTHREADED + else: + warnings.warn_explicit(diagnostic.message, diagnostic.category, + diagnostic.filename, diagnostic.lineno) + finally: + pythoncom.CoUninitialize() + else: + from pywinauto import Desktop monkeypatch.setattr(Desktop, 'windows', lambda *_: []) closed = [] diff --git a/tests/test_issue15_shutdown_handoff.py b/tests/test_issue15_shutdown_handoff.py new file mode 100644 index 0000000..56d1031 --- /dev/null +++ b/tests/test_issue15_shutdown_handoff.py @@ -0,0 +1,281 @@ +"""Actual process shutdown and captured native ownership regressions.""" +from pathlib import Path +from threading import Event +from types import SimpleNamespace +import json +import os +import subprocess +import sys +import time + +import pytest + +from test_issue15_ui_integration import window_for, load + + +def test_close_retains_captured_mapping_while_native_supervisor_is_active(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.operation_queue import native_channel + from cbb_refresh_verify.network_path import LibraryPathLease + from test_network_path import FakeWNet + window=window_for(qtbot,tmp_path,monkeypatch) + load(window,qtbot) + backend=FakeWNet() + lease=LibraryPathLease.acquire(r'\\server\share\A\library.lmc',backend=backend) + window.library_lease=lease; window.mentor_lmc_path=lease.mentor_path + entered,release=Event(),Event() + def action(): + with native_channel(): entered.set(); release.wait(5) + job=window._new_job('verify',library=lease.mentor_path) + window._start(action,lambda _:None,job=job) + qtbot.waitUntil(entered.is_set) + try: + window.close(); qtbot.wait(150) + assert not lease._closed, 'active native owner lost its captured mapping' + assert lease._retained_for_recovery + finally: + release.set(); qtbot.waitUntil(lambda:not window.isVisible()) + lease.release_after_recovery({'status':'RELEASE_CONFIRMED','library':str(lease.mentor_path)}) + lease.close() + + +def test_old_release_proof_cleans_its_lease_without_updating_new_operation(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog + monkeypatch.setattr(ResidualReleaseDialog,'refresh',lambda self:None) + cleaned=[] + monkeypatch.setattr('cbb_refresh_verify.network_path.release_retained_path_leases', + lambda proof,**kw:cleaned.append((proof,kw))) + window=window_for(qtbot,tmp_path,monkeypatch); load(window,qtbot) + first,second=Event(),Event() + window._start(lambda:first.wait(5),lambda _:None,queued=False) + window.check_library_release(); panel=window.release_dialog + first.set(); qtbot.waitUntil(lambda:not window.busy) + window._start(lambda:second.wait(5),lambda _:None,queued=False) + window.status_label.setText('NEW OPERATION STATUS') + pending={'library':Path('a.lmc'),'names':['A'],'maintenance':False,'released':False} + window._resume_batch=pending + try: + panel.released.emit({'status':'RELEASE_CONFIRMED','library':'a.lmc','evidence_path':'old-proof.json'}) + qtbot.waitUntil(lambda:bool(cleaned)); qtbot.waitUntil(lambda:window._lease_pending==0) + assert window.status_label.text()=='NEW OPERATION STATUS' + assert pending['released'] is False + assert cleaned[0][0]['evidence_path']=='old-proof.json' + finally: + second.set(); qtbot.waitUntil(lambda:not window.busy); panel.close() + + +def test_shutdown_role_rejects_unregistered_ui_write_before_its_body(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.operation_queue import native_phase + window=window_for(qtbot,tmp_path,monkeypatch); load(window,qtbot) + effects=[] + def action(): + with native_phase(): effects.append('write') + window._start(action,lambda _:None) + qtbot.waitUntil(lambda:not window.busy) + assert effects==[] + assert 'NATIVE_ROLE_REQUIRED' in window.status_label.text() + + +def test_readonly_native_phase_process_really_exits_while_observer_remains_pending(tmp_path): + script=tmp_path/'readonly_app.py' + script.write_text('''from threading import Event +from pathlib import Path +import sys +from PySide6.QtWidgets import QApplication +from PySide6.QtCore import QTimer +from cbb_refresh_verify.ui.main_window import MainWindow +from cbb_refresh_verify.operation_queue import native_phase +app=QApplication([]) +MainWindow._show_unfinished_management=lambda self:None +w=MainWindow(reader=lambda _:None,data_root=Path(sys.argv[1])); w.show() +def action(): + with native_phase(read_only=True): + print('READONLY_PHASE_ACTIVE',flush=True) + Event().wait(90) +w._start(action,lambda _:None) +QTimer.singleShot(250,w.close) +app.exec() +print('APP_RETURNED',flush=True) +''',encoding='utf-8') + process=subprocess.Popen([sys.executable,'-X','utf8',str(script),str(tmp_path/'data')], + stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True,encoding='utf-8', + env=dict(os.environ,QT_QPA_PLATFORM='offscreen')) + try: + stdout,stderr=process.communicate(timeout=8) + assert process.returncode==0,stderr + assert 'READONLY_PHASE_ACTIVE' in stdout and 'APP_RETURNED' in stdout + finally: + if process.poll() is None: process.kill(); process.communicate() + + +def test_main_process_exit_hands_off_exact_worker_with_sidecar_and_writer_barrier(tmp_path): + import win32api,win32con,win32event + from cbb_refresh_verify.library_lock import LibraryLock, LibraryBusy + from cbb_refresh_verify.operation_queue import native_channel + library=tmp_path/'lib.lmc'; library.write_bytes(b'isolated metadata') + child_script=tmp_path/'protected_child.py' + child_script.write_text('''import sys,time,json,os +from pathlib import Path +from cbb_refresh_verify.desktop_worker import worker_native_channel +root=Path(sys.argv[1]) +while not (root/'gate').exists(): time.sleep(.01) +session=json.loads((root/'session.json').read_text('utf-8')) +with worker_native_channel(lease_handle=session['worker_lease_handle']): + (root/'ready').write_text(str(os.getpid())) + while not (root/'finish').exists(): time.sleep(.02) +(root/'done').touch() +''',encoding='utf-8') + script=tmp_path/'owner_app.py' + script.write_text('''import sys,time,subprocess,win32api,win32con +from pathlib import Path +from threading import Event +from PySide6.QtWidgets import QApplication +from PySide6.QtCore import QTimer +from cbb_refresh_verify.ui.main_window import MainWindow +from cbb_refresh_verify.operation_queue import native_channel +from cbb_refresh_verify.library_lock import LibraryLock,duplicate_worker_lease +from cbb_refresh_verify.session_record import register_worker_session +root=Path(sys.argv[1]); library=root/'lib.lmc' +app=QApplication([]); MainWindow._show_unfinished_management=lambda self:None +w=MainWindow(reader=lambda _:None,data_root=root/'data'); w.show() +def action(): + with LibraryLock(library,checkpoint=False), native_channel(): + child=subprocess.Popen([sys.executable,'-X','utf8',str(root/'protected_child.py'),str(root)], + stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL) + handle=win32api.OpenProcess(win32con.PROCESS_DUP_HANDLE,False,child.pid) + try: lease=duplicate_worker_lease(library,handle) + finally: handle.Close() + register_worker_session(child,dict(library=str(library),block='A',operation='verify', + operation_id='protected-child',session_record_path=str(root/'session.json'), + worker_lease_handle=lease,cancel_signal=str(root/'cancel'))) + (root/'gate').touch() + Event().wait(90) +job=w._new_job('verify',library=library,targets=('A',)) +w._start(action,lambda _:None,job=job) +def close_ready(): + if (root/'ready').exists(): + print('PROTECTED_WRITER_ACTIVE',flush=True); w.close() + else: QTimer.singleShot(20,close_ready) +QTimer.singleShot(20,close_ready) +app.exec(); print('APP_RETURNED',flush=True) +''',encoding='utf-8') + started=time.monotonic() + process=subprocess.Popen([sys.executable,'-X','utf8',str(script),str(tmp_path)], + stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True,encoding='utf-8', + env=dict(os.environ,QT_QPA_PLATFORM='offscreen')) + try: + stdout,stderr=process.communicate(timeout=36) + assert process.returncode==0,stderr + assert 'PROTECTED_WRITER_ACTIVE' in stdout and 'APP_RETURNED' in stdout + assert time.monotonic()-started<30 + record=json.loads((tmp_path/'session.json').read_text('utf-8')) + pid=int((tmp_path/'ready').read_text()) + assert record['processes'][0]['pid']==pid and record['worker_lease_handle'] + receipt=json.loads(next((tmp_path/'data'/'shutdown').glob('*.json')).read_text('utf-8')) + assert receipt['safe_to_continue'] is False and receipt['status']=='UNCONFIRMED' + bindings=[binding for scope in receipt['task_scopes'] for binding in scope['worker_sessions']] + assert any(binding['operation_id']=='protected-child' and binding['path']==str(tmp_path/'session.json') + and binding['worker_protection']=='duplicated_lease' for binding in bindings) + assert record['task_operation_id'] in {scope['operation_id'] for scope in receipt['task_scopes']} + handle=win32api.OpenProcess(win32con.SYNCHRONIZE,False,pid) + try: assert win32event.WaitForSingleObject(handle,0)==win32con.WAIT_TIMEOUT + finally: handle.Close() + with pytest.raises(LibraryBusy): + with LibraryLock(library,checkpoint=False): pass + with pytest.raises(RuntimeError,match='NATIVE_WRITER_ACTIVE'): + with native_channel(): pass + finally: + (tmp_path/'finish').touch() + if process.poll() is None: process.kill(); process.communicate() + deadline=time.monotonic()+5 + while (tmp_path/'ready').exists() and not (tmp_path/'done').exists() and time.monotonic()