From 8374cabe5c2ae0c76fdb3330454494f904aeb1f8 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 19:51:21 +0800 Subject: [PATCH] fix: preserve async writer ownership and bounded handoff --- src/cbb_refresh_verify/desktop_worker.py | 100 ++++- src/cbb_refresh_verify/library_lock.py | 8 +- src/cbb_refresh_verify/management.py | 28 +- src/cbb_refresh_verify/native_management.py | 15 +- src/cbb_refresh_verify/native_repair.py | 20 +- src/cbb_refresh_verify/operation_queue.py | 16 +- src/cbb_refresh_verify/session_record.py | 9 +- src/cbb_refresh_verify/verify_runner.py | 19 +- tests/support/async_add_lifecycle_fixture.py | 97 +++++ tests/test_issue15_task_lifecycle.py | 20 +- tests/test_issue15_task_lifecycle_review.py | 387 +++++++++++++++++++ tests/test_native_add_failures.py | 20 +- 12 files changed, 692 insertions(+), 47 deletions(-) create mode 100644 tests/support/async_add_lifecycle_fixture.py create mode 100644 tests/test_issue15_task_lifecycle_review.py diff --git a/src/cbb_refresh_verify/desktop_worker.py b/src/cbb_refresh_verify/desktop_worker.py index 4b3ef81..bf6bf8a 100644 --- a/src/cbb_refresh_verify/desktop_worker.py +++ b/src/cbb_refresh_verify/desktop_worker.py @@ -55,6 +55,97 @@ def register_native_writer(process): return process +class _PendingNativeOperation: + """One asynchronously submitted operation, including its native descendants.""" + def __init__(self, job, identities): + import win32api + from .residual_sessions import _handle_identity, _force_ownership + from .session_record import IDENTITY_KEYS + self.record = job + self.job = win32job.CreateJobObject(None, '') # Deliberately no kill-on-close. + self.owners = {} + self.recorded = set() + self.completed = False + self.exited = False + self.lock = threading.Lock() + try: + for identity in identities: + pid = identity['pid'] + handle = win32api.OpenProcess(win32con.SYNCHRONIZE | 0x1000 | + win32con.PROCESS_SET_QUOTA | win32con.PROCESS_TERMINATE, False, pid) + try: + actual = dict(pid=pid, **_handle_identity(handle), **_force_ownership(handle, pid)) + if any(actual[key] != identity.get(key) for key in IDENTITY_KEYS): + raise RuntimeError('NATIVE_OPERATION_IDENTITY_CHANGED') + win32job.AssignProcessToJobObject(self.job, handle) + self.owners[pid] = _RegisteredWriter(handle) + self.recorded.add(pid) + finally: + handle.Close() + except Exception: + self._close() + raise # Admission failure is not permission to post Add without protection. + + def _close(self): + for owner in self.owners.values(): + if owner.returncode is None: + owner.handle.Close() + self.job.Close() + self.exited = True + + def complete(self): + with self.lock: + self.completed = True # Only an exact native acknowledgement settles the operation. + + def poll(self): + with self.lock: + return self._poll() + + def _poll(self): + if self.exited: + return 0 + pids = set(win32job.QueryInformationJobObject(self.job, win32job.JobObjectBasicProcessIdList)) + fresh = pids-self.recorded + if fresh: + from .session_record import update_worker_state + from .residual_sessions import _process_handle, _handle_identity, _force_ownership + identities = [] + for pid in fresh: + with _process_handle(pid) as handle: + if not win32job.IsProcessInJob(handle, self.job): + continue # The snapshot PID may have been reused outside this job. + identities.append(('native', dict(pid=pid, **_handle_identity(handle), + **_force_ownership(handle, pid)))) + if identities and update_worker_state(self.record, 'UNCONFIRMED', observed_identities=identities): + self.recorded.update(identity['pid'] for _, identity in identities) + # An acknowledged Add does not retain an otherwise idle LM shell. + # Descendants still need observed exit; PID reuse cannot imitate an owner. + idle = {pid for pid, owner in self.owners.items() if owner.poll() is None} if self.completed else set() + if not pids-idle: + self._close() + return 0 + return None + + +def register_pending_native_operation(job, pids): + from .session_record import read_session_record, update_worker_state + pids = set(pids) + if not pids: + raise RuntimeError('NATIVE_OPERATION_OWNER_REQUIRED') + # Retain the creation/image/owner identity in the existing bound journal + # before asynchronous dispatch, so a restarted UI can validate controls. + update_worker_state(job, 'POSTCALL', identities=[('native', pid) for pid in pids], required=True) + path = Path(job['session_record_path']).with_name('worker-state.json') + record = read_session_record(path, evidence_root=path.parent) + identities = [p for p in record.get('processes', ()) if p['pid'] in pids and p.get('role') == 'native'] + if record['operation_id'] != job['operation_id'] or {p['pid'] for p in identities} != pids: + raise RuntimeError('NATIVE_OPERATION_OWNER_UNCONFIRMED') + operation = _PendingNativeOperation(job, identities) + with _automation_clients_lock: + _automation_clients.append(operation) + return operation + + @contextmanager def worker_native_channel(*, lease_handle=None, inspection_only=False): """The native worker, not its disposable supervisor, owns write exclusion.""" @@ -221,9 +312,12 @@ def start_supervisor_watchdog(supervisor_pid, *, cancel_path=None, stop_clients= pending = _record_write_pending(session_record_path, operation_id) # The same gate blocks new calls/helpers after loss. A stale # POSTCALL on disk cannot override an active in-memory call. - if (pending is False and _phase_pending(_native_phases.get(operation_id)) is False - and all(helper.poll() is not None for helper in _automation_clients)): - os._exit(75) # This Python worker only; native children remain untouched. + returned = pending is False and _phase_pending(_native_phases.get(operation_id)) is False + clients = tuple(_automation_clients) + # Polling can publish a job descendant's exact identity. Never + # hold the client registry lock while that journal is updated. + if returned and all(helper.poll() is not None for helper in clients): + os._exit(75) # This Python worker only; native children remain untouched. threading.Event().wait(.2) finally: parent.Close() diff --git a/src/cbb_refresh_verify/library_lock.py b/src/cbb_refresh_verify/library_lock.py index e6141f7..278adc9 100644 --- a/src/cbb_refresh_verify/library_lock.py +++ b/src/cbb_refresh_verify/library_lock.py @@ -563,11 +563,9 @@ def _prove_library_released(library, block_name=None, *, block_names=(), allow_u from .icdb_ownership import inspect_release_addresses # Checkpoint I/O is per-library; only native inspection owns # the host channel. The sidecar still excludes other writers. - from .operation_queue import native_channel - with native_channel(inspection_only=True): - if stop is not None and stop.is_set(): - raise InterruptedError('已停止释放检查') - inspections = inspect_release_addresses(files, stop=stop) + if stop is not None and stop.is_set(): + raise InterruptedError('已停止释放检查') + inspections = inspect_release_addresses(files, stop=stop) try: current = stack.enter_context(hold_release_files(library, roots, stop=stop)) except OSError as error: diff --git a/src/cbb_refresh_verify/management.py b/src/cbb_refresh_verify/management.py index 6f646ab..b486a61 100644 --- a/src/cbb_refresh_verify/management.py +++ b/src/cbb_refresh_verify/management.py @@ -174,7 +174,7 @@ def run_management(request, *, adapter=None, verifier=None, idle_check=None, pro from .verify_runner import VerifyRequest, run_verify from .backup_recovery import _idle_check from contextlib import ExitStack - from .operation_queue import check_active, native_channel, task_stop + from .operation_queue import check_active, native_channel, task_stop, remember_result stop = task_stop(stop) import pythoncom if adapter is None: @@ -219,11 +219,15 @@ def run_management(request, *, adapter=None, verifier=None, idle_check=None, pro progress({'stage': stage, 'block': request.name, 'operation': request.operation, **details}) def finish(status, detail='', safe=True): nonlocal change_report + remember_result(ManagementResult(request.operation, request.library, request.name, request.partition, + request.source, request.auto_verify, 'complete', status, safe, detail, report, release_proof, change_report)) if mutated and original is not None and change_report is None: change_report = {'status': 'UNCONFIRMED', 'scope': original['scope'], **comparison_rules(scope), 'unrelated_cbb_content_checked': False, 'detail': '原生会话尚未释放,未读取写后内容'} + remember_result(ManagementResult(request.operation, request.library, request.name, request.partition, + request.source, request.auto_verify, 'complete', status, safe, detail, report, release_proof, change_report)) if safe: try: after = build_exclusive_library_manifest(library_root, scope=scope, progress=progress) @@ -245,12 +249,13 @@ def run_management(request, *, adapter=None, verifier=None, idle_check=None, pro detail = (detail+'\n'+change_report['detail']).strip() result = ManagementResult(request.operation, request.library, request.name, request.partition, request.source, request.auto_verify, 'complete', status, safe, detail, report, release_proof, change_report) + remember_result(result) if report: try: _write_json(report, {**asdict(result), 'history': history, 'backup_policy': 'manual'}) except OSError as error: result = replace(result, detail=f'{detail}\n操作记录写入失败:{error}'.strip()) - return result + return remember_result(result) from .com_runtime import initialize_com, uninitialize_com initialized = initialize_com() try: @@ -449,7 +454,7 @@ def run_management(request, *, adapter=None, verifier=None, idle_check=None, pro def run_management_batch(requests, *, stop=None, progress=None, item_executor=None, context=None, **kwargs): from threading import Event from .write_admission import WriteAdmission - from .operation_queue import QueueCancelled, TaskHandoff, request_library_keys + from .operation_queue import QueueCancelled, TaskHandoff, request_library_keys, remember_result if context is not None: stop = stop if stop is not None else context.stop progress = context.guard_callback(progress) if progress else None @@ -472,6 +477,7 @@ def run_management_batch(requests, *, stop=None, progress=None, item_executor=No continue def action(): result = run_management(request, progress=progress, stop=stop, **kwargs) + remember_result(result) if not result.safe_to_continue: from .operation_lifecycle import recheck_failed_release result = recheck_failed_release(request.library, request.name, result, stop=stop) @@ -479,10 +485,18 @@ def run_management_batch(requests, *, stop=None, progress=None, item_executor=No try: result = item_executor(request, action) if item_executor is not None else action() except QueueCancelled as error: - result = ManagementResult(request.operation, request.library, request.name, request.partition, - request.source, request.auto_verify, 'complete', - 'TIMEOUT' if isinstance(error, TaskHandoff) and not error.cancelled else 'CANCELLED', - not isinstance(error, TaskHandoff), str(error)) + known = error.result if isinstance(error, TaskHandoff) else None + if isinstance(known, ManagementResult): + result = replace(known, safe_to_continue=False, + status='RECOVERY_REQUIRED' if known.status in ('PASS', 'UPLOADED', 'UPLOADED_VERIFIED', 'REMOVED') + else known.status, + release_proof=dict(status='RELEASE_PENDING', lease_state='PENDING', + resource_scope=error.scope, previous_release_proof=known.release_proof)) + else: + result = ManagementResult(request.operation, request.library, request.name, request.partition, + request.source, request.auto_verify, 'complete', + 'TIMEOUT' if isinstance(error, TaskHandoff) and not error.cancelled else 'CANCELLED', + not isinstance(error, TaskHandoff), str(error)) results.append(result) if progress: progress({'stage': result.status, 'block': result.name, 'detail': result.detail, diff --git a/src/cbb_refresh_verify/native_management.py b/src/cbb_refresh_verify/native_management.py index 1df8ffa..7bfa5c1 100644 --- a/src/cbb_refresh_verify/native_management.py +++ b/src/cbb_refresh_verify/native_management.py @@ -745,6 +745,9 @@ def _probe_add_dialog(app, job, desktop, owned_pids, root, *, library=None): import gc gc.collect() # Release UIA wrappers before closing native child dialogs. if not job.get('_native_add_pending'): + writer = job.pop('_native_add_writer', None) + if writer is not None: + writer.complete() _close_probe_dialogs(desktop, owned_pids) @@ -851,9 +854,18 @@ def _probe_add_dialog_impl(app, job, desktop, owned_pids, root, *, library=None) _require_add_supervisor(job, root) from .session_record import dispatch_native, update_worker_state def submit_add(): + _require_add_supervisor(job, root) # Registration/journal I/O may have outlived cancellation. job['_native_add_pending'] = True win32gui.PostMessage(ok, win32con.BM_CLICK, 0, 0) - dispatch_native(job, submit_add, asynchronous=True, required=True) + from .desktop_worker import register_pending_native_operation + writer = register_pending_native_operation(job, owned_pids) + job['_native_add_writer'] = writer + try: + dispatch_native(job, submit_add, asynchronous=True, required=True) + except Exception: + if not job.get('_native_add_pending'): + writer.complete() + raise success = None while time.monotonic() < deadline: pythoncom.PumpWaitingMessages() @@ -884,6 +896,7 @@ def _probe_add_dialog_impl(app, job, desktop, owned_pids, root, *, library=None) if not success: raise TimeoutError('未取得原生新增成功消息;保留副本与私有桌面证据。') job['_native_add_pending'] = False + writer.complete() update_worker_state(job, 'POSTCALL') diff --git a/src/cbb_refresh_verify/native_repair.py b/src/cbb_refresh_verify/native_repair.py index 0552ec2..818db4e 100644 --- a/src/cbb_refresh_verify/native_repair.py +++ b/src/cbb_refresh_verify/native_repair.py @@ -278,9 +278,8 @@ def run_native_repair(target, root, *, mentor_bin='', timeout_seconds=300, progr job_path.write_text(json.dumps(job, ensure_ascii=False), encoding='utf-8') command = ([sys.executable] if getattr(sys, 'frozen', False) else [sys.executable, '-m', 'cbb_refresh_verify']) + ['--repair-worker', str(job_path)] - from .operation_queue import native_channel, task_stop - with native_channel(inspection_only=inspection_only is True): - return _supervise_repair(command, desktop, cancel, root, timeout_seconds, progress, task_stop(stop), job) + from .operation_queue import task_stop + return _supervise_repair(command, desktop, cancel, root, timeout_seconds, progress, task_stop(stop), job) def _supervise_repair(command, desktop, cancel, root, timeout_seconds, progress, stop, job): @@ -289,15 +288,19 @@ def _supervise_repair(command, desktop, cancel, root, timeout_seconds, progress, worker.bind_cancellation(cancel) if hasattr(worker, 'bind_session'): worker.bind_session(job) - from .operation_queue import check_active - check_active() - Path(job['start_gate']).touch() + from .operation_queue import check_active, native_channel + native = native_channel(inspection_only=job.get('inspection_only') is True) + entered = False # Worker admission includes filesystem/ownership checks before the native # timeout begins. Bound that preparation separately; never extend on polls. deadline = time.monotonic()+60+max(1, float(timeout_seconds))+5 event_count = 0 cancelled = False try: + check_active() + native.__enter__() + entered = True + Path(job['start_gate']).touch() while worker.poll() is None and time.monotonic()