"""Version-pinned native adapter, private desktop transport and strict catalog. The installed Tcl CleanWGLib/F4 contract has isolated removal proof. Discovery of an Add dialog is deliberately insufficient to enable production Add/Update. """ from dataclasses import asdict, replace import ctypes import json import os from pathlib import Path import re import subprocess import sys import threading import time from uuid import uuid4 from .management import (Capability, Catalog, CatalogEntry, NativeOutcome, engineering_identity, validate_name, _write_json) from .scoped_manifest import hash_file from .network_path import absolute_preserving_drive _retained_workers = [] class NativeOperationError(RuntimeError): def __init__(self, detail, *, safe_to_continue): super().__init__(detail) self.safe_to_continue = safe_to_continue # Coordinator-owned Create/Add/conflict/update/remove/backup-reimport evidence: # diagnostics/issue2-native-crud-20261103/engine-e2e/cycle-result.json _PRODUCTION_ADD_VALIDATED = True _PRODUCTION_UPDATE_VALIDATED = True _BINARY_PROOF = { 'lm/win32/bin/CleanWGLib.exe': '7808ded326555f1fd5d5c14f68803dbb4f970d624f9ad6e1c7982dc9ed867917', 'lm/win32/bin/LibraryManager.exe': 'a9c4c3d806794dbdc56d2bc4c637a1cf25e87e98644a7d5fd4eb0067ca5845e0', 'common/win32/lib/LMCDLL70.dll': 'fc614d43ed0a2fd28dbe37116510e303fc0e71542da585ac03aaa147630629b8', 'common/win32/lib/LMCDocAddin70.dll': 'ff022ce285544ddd7eb639e4eb90216899b63adabcef8b3448236b4916150154', } def removal_input(name, partition): validate_name(name); validate_name(partition) try: return f'REUSE_BLOCK\t{partition}\t{name}\n'.encode('ascii') except UnicodeEncodeError as error: raise ValueError('已验证的 CleanWGLib 输入仅支持 ASCII 名称和分区。') from error def removal_output_ok(code, output, name, partition): return (code == 0 and '# Warning:' not in output and '# Error:' not in output and re.search(r"# Note: Removed [^\r\n]+ '" + re.escape(name) + r"' from partition '" + re.escape(partition) + r"'\.", output) is not None) def catalog_dialog_action(title, text): value = (title + '\n' + text).casefold() if ('this central library must be updated' in value or 'select flow type' in value): return 'cancel' return 'observe' class NativeManagementAdapter: def __init__(self, *, mentor_home=None, worker_factory=None, timeout_seconds=180): from .mentor_paths import discover_sdd_home self.home = Path(mentor_home) if mentor_home is not None else discover_sdd_home() self.worker_factory = worker_factory self.timeout_seconds = timeout_seconds self.mapped_drive = '' self.mapped_remote_root = '' self._pending_workers = {} self.stop = None self.session_progress = None def bind_stop(self, stop): self.stop = stop def release_confirmed(self, library): """Worker exit/result files do not replace independent resource proof.""" key = str(Path(library).resolve()).casefold() pending = self._pending_workers.get(key) if pending is None: return False worker, evidence = pending if worker.poll() is None: return False try: if (evidence/'session.json').is_file(): from .session_record import reconcile_session_record proof = reconcile_session_record(evidence/'session.json', evidence_root=evidence) if proof['status'] != 'RELEASED': return False else: from .library_lock import release_retained_library proof = release_retained_library(library, evidence/'release-proof') if proof.get('status') != 'RELEASE_CONFIRMED': return False except Exception: return False worker.close() if worker in _retained_workers: _retained_workers.remove(worker) del self._pending_workers[key] return True def bind_library_mapping(self, drive, remote_root): self.mapped_drive = drive or '' self.mapped_remote_root = remote_root or '' def _binary_capability(self): reason = '' for relative, expected in _BINARY_PROOF.items(): path = self.home/relative if self.home else Path(relative) try: if not self.home or not path.is_file() or hash_file(path) != expected: reason = f'{Path(relative).name} 缺失或与已隔离验证的 EE 7.9.5 版本不一致。' break except OSError as error: reason = f'无法核对原生程序 {path}: {error}' break return reason def route_capabilities(self): """Report the proven native transport separately from production gates.""" reason = self._binary_capability() return { 'remove': Capability(not reason, reason or 'CleanWGLib/F4 route ready.'), 'add': Capability(not reason, reason or 'Library Manager Logical-Physical Add route ready.'), 'update': Capability(False, 'Update is composed from Remove and Add; there is no separate native Update call.'), } def capabilities(self): reason = self._binary_capability() add_reason = reason if not add_reason: from .native_engineering_identity import check_exporters try: check_exporters(self.home) except (ValueError, OSError, TypeError) as error: add_reason = str(error) return { 'remove': Capability(not reason, reason or '已验证 CleanWGLib/F4;仅 ASCII 名称、Logical-Physical 和 DxDesigner 库。'), 'add': Capability(not add_reason and _PRODUCTION_ADD_VALIDATED, add_reason or '已验证 EE7.9.5 原生导入及完整工程复读;仅 ASCII 名称、Logical-Physical 和 DxDesigner 库。'), 'update': Capability(not add_reason and _PRODUCTION_ADD_VALIDATED and _PRODUCTION_UPDATE_VALIDATED, add_reason or '已验证同名原生替换:移除并重新导入;操作前请手动备份。'), } def _worker(self, job, evidence): try: evidence = Path(evidence) evidence.mkdir(parents=True, exist_ok=False) desktop = 'CbbManagement_' + uuid4().hex[:12] timeout = float(job.get('timeout_seconds', self.timeout_seconds)) job = {**job, 'desktop': desktop, 'mentor_home': str(self.home or ''), 'mapped_drive': job.get('mapped_drive', self.mapped_drive), 'mapped_remote_root': job.get('mapped_remote_root', self.mapped_remote_root), 'timeout_seconds': timeout, 'supervisor_pid': os.getpid()} except Exception as error: error.safe_to_continue = True raise if job['operation'] == 'add': import win32con, win32event mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795') acquired = False try: acquired = win32event.WaitForSingleObject(mutex, 0) in ( win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED) if not acquired: raise RuntimeError('Another CBB operation owns the management mutex.') if job.get('authority_kind') == 'management': from .management_transaction import validate_transaction validate_transaction(job, evidence.parent) else: job = prepare_owned_fixture_add(job, evidence) from .library_lock import LibraryLock owner_safe = False # Nest only after preparation proves an existing caller lease. # An unsafe result/exception retains that same owner even when # the caller used a plain LibraryLock without a callback. with LibraryLock(job['library'], safe_to_release=lambda: owner_safe): result = self._launch_worker(job, evidence) owner_safe = result.get('safe_to_continue') is True return result finally: if acquired: win32event.ReleaseMutex(mutex) mutex.Close() if job['operation'] in ('probe_create_add', 'probe_create'): # Prepare the fixed NEW fixture before a native owner can start. # The parent owns its sidecar for the entire create/add invocation. from .library_lock import LibraryLock library = absolute_preserving_drive(evidence)/'fixture/mentor_lib.lmc' if Path(job['library']).resolve() != library.resolve() or not job.get('probe_token'): raise ValueError('隔离创建目标必须为本次工作目录内的新库。') library.parent.mkdir(exist_ok=False) _write_json(evidence/'probe-prepared.json', {'library': str(library), 'token': job['probe_token'], 'supervisor_pid': os.getpid()}) owner_safe = True with LibraryLock(library, safe_to_release=lambda: owner_safe): owner_safe = False result = self._launch_worker(job, evidence) owner_safe = result.get('safe_to_continue') is True return result return self._launch_worker(job, evidence) def _launch_worker(self, job, evidence): state = {'attempted': False, 'worker': None, 'released': False} try: return self._launch_worker_observed(job, evidence, state) except Exception as error: proof = getattr(error, 'worker_launch_release', None) no_launch = (isinstance(proof, dict) and proof.get('safe_to_continue') is True and proof.get('process_created') is False and proof.get('worker_exited') is True and proof.get('remaining_pids') == []) error.safe_to_continue = (not state['attempted'] or state['released'] or (state['worker'] is None and no_launch)) if state['worker'] is not None and not error.safe_to_continue: if state['worker'] not in _retained_workers: _retained_workers.append(state['worker']) self._pending_workers[str(Path(job['library']).resolve()).casefold()] = (state['worker'], evidence) raise def _launch_worker_observed(self, job, evidence, state): from .desktop_worker import DesktopWorker from .session_record import process_identity job = {**job, 'cancel_signal': str(evidence/'cancel-management.signal'), 'start_gate': str(evidence/'start-management.signal'), 'session_record_path': str(evidence/'session.json'), 'operation_id': uuid4().hex, 'supervisor_pid': os.getpid(), 'supervisor_identity': process_identity(os.getpid()), 'block': job.get('name')} request_path = evidence/'request.json' desktop, timeout = job['desktop'], job['timeout_seconds'] deadline = time.monotonic() + timeout add_job = job['operation'] in ('add', 'probe_create_add', 'probe_readd') if add_job: job = {**job, 'native_add_deadline': deadline} _write_json(request_path, job) command = ([sys.executable] if getattr(sys, 'frozen', False) else [sys.executable, '-m', 'cbb_refresh_verify']) state['attempted'] = True worker = (self.worker_factory or DesktopWorker)(command + ['--management-worker', str(request_path)], desktop) state['worker'] = worker worker.cbb_library = str(Path(job['library']).resolve()) if hasattr(worker, 'bind_cancellation'): worker.bind_cancellation(job['cancel_signal']) if hasattr(worker, 'bind_session'): worker.bind_session(job) Path(job['start_gate']).touch() while worker.poll() is None and time.monotonic() < deadline: if self.stop is not None and self.stop.is_set(): Path(job['cancel_signal']).touch() break time.sleep(.1) if worker.poll() is None: # DesktopWorker.close() requests a kill without a cancellation file. # Keep this exact worker alive until its native call returns normally. _retained_workers.append(worker) self._pending_workers[str(Path(job['library']).resolve()).casefold()] = (worker, evidence) Path(job['cancel_signal']).touch() if getattr(worker, 'session_record_path', None): from .session_record import handoff_session handoff_session(worker.session_record_path, evidence_root=evidence, process=worker, progress=(lambda value: self.session_progress({'stage': 'session_observation', **value})) if self.session_progress is not None else None) if add_job: (evidence/'cancel-native-add.signal').touch() return {'success': False, 'safe_to_continue': False, 'detail': f'TIMEOUT: 原生调用尚未返回,保留私有桌面 {desktop},请检查 {evidence}'} try: result = json.loads((evidence/'result.json').read_text(encoding='utf-8')) if not isinstance(result.get('safe_to_continue'), bool): raise ValueError('原生释放记录缺失') state['released'] = result['safe_to_continue'] return result except (OSError, ValueError) as error: return {'success': False, 'safe_to_continue': False, 'detail': str(error)} finally: worker.close() def catalog(self, library, evidence): result = self._worker({'operation': 'catalog', 'library': str(absolute_preserving_drive(library))}, evidence) if not result.get('success') or not result.get('safe_to_continue'): raise NativeOperationError(result.get('detail', '原生目录复读未确认,禁止文件夹回退。'), safe_to_continue=result.get('safe_to_continue') is True) return Catalog(Path(result['library']), int(result['flow']), tuple(CatalogEntry(**entry) for entry in result['entries']), result['safe_to_continue']) def remove(self, request, evidence): caps = self.capabilities() if not caps['remove'].supported: return NativeOutcome(False, True, caps['remove'].reason) removal_input(request.name, request.partition) if request.partition != 'Logical-Physical': return NativeOutcome(False, True, '仅已验证 Logical-Physical 原生移除。') result = self._worker({'operation': 'remove', 'library': str(absolute_preserving_drive(request.library)), 'name': request.name, 'partition': request.partition, 'mapped_drive': request.mapped_drive, 'mapped_remote_root': request.mapped_remote_root, 'timeout_seconds': request.timeout_seconds}, evidence) return NativeOutcome(bool(result.get('success')), bool(result.get('safe_to_continue')), result.get('detail', '')) def preflight(self, request, catalog): if request.operation in ('add', 'remove', 'update'): removal_input(request.name, request.partition) if request.partition != 'Logical-Physical' or catalog.flow != 1: raise ValueError('仅验证了 DxDesigner / Logical-Physical 管理操作。') def add(self, request, evidence): # Route readiness never grants production mutation authority. capability = self.capabilities()['add'] if not capability.supported: return NativeOutcome(False, True, capability.reason, evidence_path=Path(evidence)) return self._add_transaction(request, Path(evidence)) def prepare_add_transaction(self, request, root, *, original_source): from .native_engineering_identity import project_library, asset_identity, capture_identity, IdentityOutcome from .native_add_failures import validate_native_copy_paths from .management_transaction import current_lease, prepare_transaction from .management import source_project from .backup_recovery import _align_library try: if not self.capabilities()['add'].supported: raise ValueError(self.capabilities()['add'].reason) validate_native_copy_paths(request.source, request.library, request.name) current_lease(request.library) original_assets = asset_identity(original_source, project_library(original_source)) staged, pcb, _ = source_project(request.source, request.top_level_block) if staged.parent != Path(root).resolve()/'source': raise ValueError('Only the engine staged source can be aligned for native Add.') _align_library(staged, pcb, request.library) if asset_identity(staged, request.library) != original_assets: raise ValueError('Staged engineering assets differ from the original source.') except Exception as error: return request, IdentityOutcome(None, True, str(error), Path(root)) proof = capture_identity(staged, Path(root)/'source-identity', expected_library=request.library, owner_library=request.library, mentor_home=self.home, timeout_seconds=request.timeout_seconds) if proof.identity is None or not proof.safe_to_continue: return request, proof try: token = prepare_transaction(request, root, proof.identity, mentor_home=self.home, fixture=getattr(self, '_fixture_authority', None)) except Exception as error: return request, IdentityOutcome(None, proof.safe_to_continue, str(error), Path(root)) return replace(request, transaction_token=token), proof def _add_transaction(self, request, evidence): from contextlib import contextmanager from .management_transaction import validate_transaction from .library_lock import LibraryLock from .native_engineering_identity import capture_identity, project_library from .management import source_project from .backup_recovery import _align_library, _idle_check try: job = {'operation': 'add', 'authority_kind': 'management', 'transaction_nonce': request.transaction_token, 'library': str(absolute_preserving_drive(request.library)), 'source': str(request.source), 'name': request.name, 'partition': request.partition, 'top_level_block': request.top_level_block, 'source_identity': engineering_identity(request.source), 'supervisor_pid': os.getpid(), 'mentor_home': str(self.home), 'timeout_seconds': request.timeout_seconds, 'mapped_drive': request.mapped_drive, 'mapped_remote_root': request.mapped_remote_root} prepared = validate_transaction(job, evidence.parent) except Exception as error: error.safe_to_continue = True raise owner_safe = True @contextmanager def preserve_release(): nonlocal owner_safe try: yield except Exception as error: owner_safe = getattr(error, 'safe_to_continue', owner_safe) is True error.safe_to_continue = owner_safe raise with LibraryLock(request.library, safe_to_release=lambda: owner_safe), preserve_release(): owner_safe = False result = self._worker(job, evidence) owner_safe = result.get('safe_to_continue') is True if not owner_safe or not result.get('success'): return NativeOutcome(False, owner_safe, result.get('detail', 'Native Add failed.'), evidence_path=evidence) # The native editor may leave PCB/pcb.prj relative to the staged # location. Correct only documented library-reference tokens after # its owner has exited, then reopen the native catalog independently. validate_transaction(job, evidence.parent, check_source=False) work = Path(request.library).parent/'ReusableBlocksLP'/request.name/'Work' projects = list(work.glob('*.prj')) if len(projects) != 1: return NativeOutcome(True, owner_safe, 'Registered engineering project is not unique.', identity_matches=False, evidence_path=evidence) target, pcb, _ = source_project(projects[0], request.top_level_block) _idle_check(request.library, target, pcb) from .maintenance_entry import maintenance_project_files project_files = maintenance_project_files(target, pcb) before_refs = {str(p): hash_file(p) for p in project_files} _align_library(target, pcb, request.library) if project_library(target) != Path(request.library).resolve(): raise ValueError('Registered project references do not resolve to the exact target library.') _write_json(evidence/'reference-alignment.json', {'before': before_refs, 'after': {str(p): hash_file(p) for p in project_files}, 'library': job['library']}) owner_safe = False catalog = self.catalog(request.library, evidence/'reopen-aligned') owner_safe = catalog.safe_to_continue entries = [entry for entry in catalog.entries if entry.name == request.name and entry.partition == request.partition] if (not owner_safe or Path(catalog.library).resolve() != Path(request.library).resolve() or catalog.flow != 1 or len(entries) != 1): return NativeOutcome(True, owner_safe, 'Aligned target did not reopen with the exact catalog identity.', identity_matches=False, evidence_path=evidence) owner_safe = False proof = capture_identity(target, evidence/'registered-identity', expected_library=request.library, owner_library=request.library, mentor_home=self.home, timeout_seconds=request.timeout_seconds) owner_safe = proof.safe_to_continue matched = proof.identity is not None and proof.identity == prepared['expected_identity'] _write_json(evidence/'identity-comparison.json', {'identity_matches': matched, 'expected': prepared['expected_identity'], 'registered': proof.identity, 'safe_to_continue': owner_safe, 'detail': proof.detail}) return NativeOutcome(True, owner_safe, 'Native ASCII/CSV/EDIF, physical assets and library references match.' if matched else 'Native registration succeeded but complete engineering identity proof did not match: '+proof.detail, identity_matches=matched, evidence_path=evidence, identity_proof=proof.identity) def add_owned_fixture(self, request, evidence, *, probe_token): """Research only: stage and back up a token-bound, actively leased fixture.""" evidence = Path(evidence) validate_name(request.name) if request.partition != 'Logical-Physical': return NativeOutcome(False, True, 'Only the verified Logical-Physical native Add route is supported.', evidence_path=evidence) source = Path(request.source) if request.source is not None else None if source is None or not source.is_file(): return NativeOutcome(False, True, 'Native Add requires an existing staged PRJ source project.', evidence_path=evidence) try: source_identity = engineering_identity(source) except (ValueError, OSError) as error: return NativeOutcome(False, True, f'Unable to read source engineering identity: {error}', evidence_path=evidence) route = self.route_capabilities()['add'] if not route.supported: return NativeOutcome(False, True, route.reason, evidence_path=evidence) result = self._worker({ 'operation': 'add', 'library': str(absolute_preserving_drive(request.library)), 'source': str(source), 'name': request.name, 'partition': request.partition, 'top_level_block': request.top_level_block, 'mapped_drive': request.mapped_drive or self.mapped_drive, 'mapped_remote_root': request.mapped_remote_root or self.mapped_remote_root, 'timeout_seconds': request.timeout_seconds, 'source_identity': source_identity, 'probe_token': probe_token, }, evidence) identity_matches = result.get('identity_matches') detail = result.get('detail', '') if result.get('success') and identity_matches is False and not detail: detail = 'Native Add registered the block, but engineering identity readback differs from the staged source.' return NativeOutcome(bool(result.get('success')), bool(result.get('safe_to_continue')), detail, identity_matches=identity_matches, evidence_path=evidence) class _OwnedFixtureManagementAdapter(NativeManagementAdapter): """Diagnostic capability grant restricted to a token-bound created fixture.""" def __init__(self, root, token, **kwargs): super().__init__(**kwargs) from .management_transaction import fixture_authority self._fixture_authority = fixture_authority(root, Path(root)/'native-add/fixture/mentor_lib.lmc', token) def capabilities(self): from .management_transaction import fixture_authority from .native_engineering_identity import check_exporters fixture = self._fixture_authority fixture_authority(fixture['root'], Path(fixture['root'])/'native-add/fixture/mentor_lib.lmc', fixture['token']) caps = super().capabilities() reason = self._binary_capability() try: check_exporters(self.home) except (ValueError, OSError) as error: reason = str(error) for operation in ('add', 'update'): caps[operation] = Capability(not reason, reason or 'Owned fixture engine validation only; production capability unchanged.') return caps def preflight(self, request, catalog): from .management_transaction import fixture_authority fixture = self._fixture_authority fixture_authority(fixture['root'], request.library, fixture['token']) super().preflight(request, catalog) def run_owned_fixture_management(request, root, *, probe_token, mentor_home=None, **kwargs): """Run the real engine with a narrow fixture grant, never a public override.""" from .management import run_management from .management_transaction import fixture_authority fixture_authority(root, request.library, probe_token) adapter = _OwnedFixtureManagementAdapter(root, probe_token, mentor_home=mentor_home) return run_management(request, adapter=adapter, **kwargs) def create_owned_fixture(root, *, mentor_home=None): """Diagnostic-only empty native library, guarded by the existing creation protocol.""" import win32con, win32event root = absolute_preserving_drive(root) if root.exists(): raise ValueError('Native fixture root must be entirely new.') adapter = NativeManagementAdapter(mentor_home=mentor_home) if not adapter.route_capabilities()['add'].supported: raise ValueError(adapter.route_capabilities()['add'].reason) mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795') acquired = False token = uuid4().hex try: acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED) if not acquired: raise RuntimeError('Another CBB operation owns the management mutex.') library = root/'native-add/fixture/mentor_lib.lmc' result = adapter._worker({'operation': 'probe_create', 'library': str(library), 'probe_token': token}, root/'native-add') return {**result, 'probe_token': token, 'fixture_root': str(root)} finally: if acquired: win32event.ReleaseMutex(mutex) mutex.Close() def prepare_owned_fixture_add(job, root): """Create fresh transaction evidence while this thread owns the fixture.""" from .library_lock import LibraryLock, owned_snapshot, checkpoint_record, blocker_path, _guard, _owners from .scoped_manifest import copy_verified, ManifestScope library = validate_probe_readd(job, root) lease = LibraryLock(library) if owned_snapshot(lease.path) is None: raise ValueError('Owned fixture Add requires the current thread library lease.') guard = checkpoint_record(blocker_path(library)) with _guard: owner = _owners.get(lease.key) if (guard is None or guard['pid'] != os.getpid() or guard['status'] != 'OPERATION_IN_PROGRESS' or owner is None or guard['lease_id'] != owner['lease_id']): raise ValueError('Owned fixture lease is not active.') lease_handle = int(owner['handle']) source = Path(job['source']).resolve(strict=True) if (source.parent.is_relative_to(root.resolve()) or root.resolve().is_relative_to(source.parent) or source.parent.is_relative_to(library.parent.resolve()) or library.parent.resolve().is_relative_to(source.parent)): raise ValueError('Research source must be independent of fixture and transaction evidence.') source_manifest = copy_verified(source.parent, root/'source') backup = copy_verified(library.parent, root/'library-before', scope=ManifestScope.library(job['name'], library.name)) nonce = uuid4().hex prepared = {'nonce': nonce, 'library': str(library), 'lease_id': guard['lease_id'], 'supervisor_pid': os.getpid(), 'source_name': source.name, 'source_manifest': source_manifest, 'backup_manifest': backup, 'name': job['name'], 'partition': job['partition'], 'source_identity': job['source_identity'], 'probe_token': job['probe_token'], 'lease_handle': lease_handle} _write_json(root/'add-prepared.json', prepared) return {**job, 'source': str(root/'source'/source.name), 'transaction_nonce': nonce} def validate_owned_fixture_add(job, root): """Reject unprepared, stale or foreign Add jobs before any native activation.""" from .library_lock import checkpoint_record, blocker_path, _supervisor_alive from .scoped_manifest import build_manifest, ManifestScope library = validate_probe_readd(job, root) prepared = json.loads((root/'add-prepared.json').read_text(encoding='utf-8')) guard = checkpoint_record(blocker_path(library)) source = root/'source'/prepared['source_name'] valid = (bool(job.get('transaction_nonce')) and prepared['nonce'] == job['transaction_nonce'] and prepared['probe_token'] == job['probe_token'] and prepared['name'] == job['name'] and prepared['partition'] == job['partition'] and prepared['source_identity'] == job['source_identity'] and Path(prepared['library']).resolve() == library.resolve() and prepared['supervisor_pid'] == job['supervisor_pid'] and guard is not None and guard['pid'] == job['supervisor_pid'] and guard['lease_id'] == prepared['lease_id'] and guard['status'] == 'OPERATION_IN_PROGRESS' and Path(guard['library']).resolve() == library.resolve() and _supervisor_alive(job['supervisor_pid']) and Path(job['source']).resolve() == source.resolve() and source.resolve().parent == (root/'source').resolve() and build_manifest(root/'source') == prepared['source_manifest'] and build_manifest(root/'library-before', scope=ManifestScope.library(job['name'], library.name)) == prepared['backup_manifest']) if not valid: raise ValueError('Owned fixture Add authority, staging or backup proof is invalid.') # Metadata alone does not prove ownership. Duplicate the supervisor's # still-open exclusive sidecar handle and verify its exact final path. import win32api, win32con, win32file process = win32api.OpenProcess(win32con.PROCESS_DUP_HANDLE, False, job['supervisor_pid']) duplicate = None try: duplicate = win32api.DuplicateHandle(process, prepared['lease_handle'], win32api.GetCurrentProcess(), 0, False, win32con.DUPLICATE_SAME_ACCESS) final_path = win32file.GetFinalPathNameByHandle(duplicate, 0) if final_path.startswith('\\\\?\\UNC\\'): final_path = '\\\\' + final_path[8:] elif final_path.startswith('\\\\?\\'): final_path = final_path[4:] expected_lock = library.with_name('.' + library.stem + '.cbb-upload.lock') if Path(final_path).resolve() != expected_lock.resolve(): raise ValueError('Supervisor lease handle belongs to a different library.') finally: if duplicate is not None: duplicate.Close() process.Close() return source def prepare_probe_library(job, root): """Validate a NEW fixed fixture already guarded by its supervisor.""" from .library_lock import blocker_path, checkpoint_record expected = absolute_preserving_drive(root)/'fixture/mentor_lib.lmc' try: prepared = json.loads((Path(root)/'probe-prepared.json').read_text(encoding='utf-8')) guard = checkpoint_record(blocker_path(expected)) allowed = {'.mentor_lib.cbb-upload.lock', '.mentor_lib.cbb-upload.blocked.json'} valid = (Path(job['library']).resolve() == expected.resolve() and not expected.exists() and expected.parent.is_dir() and {p.name for p in expected.parent.iterdir()} == allowed and prepared.get('token') == job.get('probe_token') and bool(job.get('probe_token')) and Path(prepared['library']).resolve() == expected.resolve() and prepared.get('supervisor_pid') == job.get('supervisor_pid') and guard is not None and guard['pid'] == job.get('supervisor_pid') and Path(guard['library']).resolve() == expected.resolve() and guard['status'] == 'OPERATION_IN_PROGRESS') except (OSError, ValueError, KeyError): valid = False if not valid: raise ValueError('诊断只能创建当前监督进程已持锁的全新 fixture/mentor_lib.lmc。') return expected def validate_probe_readd(job, root): expected = absolute_preserving_drive(root).parent/'native-add/fixture/mentor_lib.lmc' try: owner = json.loads((Path(root).parent/'probe-owner.json').read_text(encoding='utf-8')) except (OSError, ValueError) as error: raise ValueError('没有本次原生创建的隔离库所有权记录。') from error if (Path(job['library']).resolve() != expected.resolve() or not expected.is_file() or not owner.get('library') or Path(owner['library']).resolve() != expected.resolve() or not job.get('probe_token') or owner.get('token') != job['probe_token']): raise ValueError('重新导入诊断仅允许本次原生新建的固定隔离库。') return expected def _close_probe_dialogs(desktop, owned_pids): """Normal child-first close; never terminate a native owner.""" import pythoncom, win32con, win32gui, win32process for title, control in (('New Reusable Block', 1082), ('Reusable Blocks', 1052)): for hwnd in desktop.EnumDesktopWindows(): if (win32process.GetWindowThreadProcessId(hwnd)[1] in owned_pids and win32gui.GetWindowText(hwnd) == title and win32gui.IsWindowVisible(hwnd)): button = win32gui.GetDlgItem(hwnd, control) if not button or not win32gui.IsWindowEnabled(button): return win32gui.PostMessage(button, win32con.BM_CLICK, 0, 0) deadline = time.monotonic() + 3 while win32gui.IsWindow(hwnd) and time.monotonic() < deadline: pythoncom.PumpWaitingMessages(); time.sleep(.1) if win32gui.IsWindow(hwnd): return # Never close a parent with an unreleased child. def _exception_details(error): import traceback return {'type': f'{type(error).__module__}.{type(error).__name__}', 'message': str(error), 'args': json.loads(json.dumps(error.args, default=str)), 'hresult': getattr(error, 'hresult', None), 'traceback': ''.join(traceback.format_exception(type(error), error, error.__traceback__))} def _dispatch_diagnostics(root, stage, app, library, *, paths=None): """Read only three known DISPIDs, preserving errors hidden by dynamic COM.""" record = {'stage': stage, 'members': {}} for label, obj, name in (('application.OnReusableBlocksEditor', app, 'OnReusableBlocksEditor'), ('application.Quit', app, 'Quit'), ('library.Close', library, 'Close')): try: record['members'][label] = {'dispid': obj._oleobj_.GetIDsOfNames(name)} except Exception as error: record['members'][label] = {'error': _exception_details(error)} if paths is not None: record['paths'] = paths with (Path(root)/'dispatch-diagnostics.jsonl').open('a', encoding='utf-8') as stream: stream.write(json.dumps(record, ensure_ascii=False, default=str) + '\n') def _set_probe_field(hwnd, control_id, expected, root): """Set/read a remote Edit with a one-second total message budget.""" from ctypes import wintypes record = {'control_id': control_id, 'hwnd': int(hwnd), 'expected': expected, 'actual': None, 'matched': False} deadline = time.monotonic() + 1.0 try: user32 = ctypes.WinDLL('user32', use_last_error=True) send = user32.SendMessageTimeoutW send.argtypes = [wintypes.HWND, wintypes.UINT, wintypes.WPARAM, wintypes.LPARAM, wintypes.UINT, wintypes.UINT, ctypes.POINTER(ctypes.c_size_t)] send.restype = wintypes.LPARAM def message(code, count, buffer): remaining = min(1000, int((deadline - time.monotonic()) * 1000)) if remaining <= 0: raise TimeoutError(f'原生字段消息超时:{control_id}') returned = ctypes.c_size_t() if not send(int(hwnd), code, count, ctypes.addressof(buffer), 0x0002, remaining, ctypes.byref(returned)): raise TimeoutError(f'原生字段消息超时或失败:{control_id}, Windows={ctypes.get_last_error()}') return returned.value text = ctypes.create_unicode_buffer(expected) if not message(0x000C, 0, text): # WM_SETTEXT raise RuntimeError(f'原生字段拒绝写入:{control_id}') buffer = ctypes.create_unicode_buffer(32768) copied = message(0x000D, len(buffer), buffer) # WM_GETTEXT, remote Edit marshalled by Windows. record['actual'] = buffer.value if copied >= len(buffer) - 1: raise RuntimeError(f'原生字段复读可能截断:{control_id}') if record['actual'] != expected: raise RuntimeError(f'原生新增字段回读失败:{control_id}') record['matched'] = True return record['actual'] except Exception as error: record['exception'] = _exception_details(error) raise finally: with (Path(root)/'native-field-readback.jsonl').open('a', encoding='utf-8') as stream: stream.write(json.dumps(record, ensure_ascii=False, default=str) + '\n') def _probe_add_dialog(app, job, desktop, owned_pids, root, *, library=None): try: return _probe_add_dialog_impl(app, job, desktop, owned_pids, root, library=library) except Exception as error: if job.get('_native_add_pending') and str(error).startswith('NATIVE_ADD_FAILED:'): try: failure = json.loads((Path(root)/'native-add-output.json').read_text('utf-8')).get('failure', {}) if failure.get('acknowledged') is True: job['_native_add_pending'] = False from .session_record import update_worker_state update_worker_state(job, 'POSTCALL') except (OSError, ValueError, AttributeError): pass raise finally: import gc gc.collect() # Release UIA wrappers before closing native child dialogs. if not job.get('_native_add_pending'): _close_probe_dialogs(desktop, owned_pids) def _require_management_continuation(job, root): """Check before a new native call; never abort a call already on the stack.""" from .library_lock import _supervisor_alive cancelled = job.get('cancel_signal') and Path(job['cancel_signal']).exists() supervisor = job.get('supervisor_pid') if cancelled or supervisor is None or not _supervisor_alive(supervisor): raise RuntimeError('MANAGEMENT_CANCELLED: 操作已停止或监督器已退出,未提交新的原生调用') if job.get('supervisor_identity'): from .session_record import process_identity, IDENTITY_KEYS actual = process_identity(supervisor) if any(actual[k] != job['supervisor_identity'].get(k) for k in IDENTITY_KEYS): raise RuntimeError('MANAGEMENT_CANCELLED: 监督器身份已变化,未提交新的原生调用') def _require_add_supervisor(job, root): try: _require_management_continuation(job, root) except RuntimeError as error: raise RuntimeError(f'NATIVE_ADD_CANCELLED: {error}') from error from .library_lock import _supervisor_alive deadline = job.get('native_add_deadline') if ((Path(root)/'cancel-native-add.signal').exists() or deadline is not None and time.monotonic() >= deadline or not _supervisor_alive(job['supervisor_pid'])): raise RuntimeError('NATIVE_ADD_CANCELLED: 操作已超时、停止或监督进程退出,未提交新的导入。') def _probe_add_dialog_impl(app, job, desktop, owned_pids, root, *, library=None): """Submit the proven Logical-Physical Add dialog on an owned library.""" import pythoncom, win32con, win32gui, win32process _dispatch_diagnostics(root, 'before-pywinauto-import', app, library) from pywinauto import Desktop _dispatch_diagnostics(root, 'after-pywinauto-import', app, library) from .backup_recovery import _align_library from .management import source_project from .native_add_failures import validate_native_copy_paths, snapshot_add_log, observe_add_failure source, pcb, top = source_project(job['source'], job.get('top_level_block', '')) source_folder = 'source-replacement' if job['operation'] == 'probe_readd' else 'source' source_root = (Path(root).resolve()/'source' if job['operation'] == 'add' and job.get('authority_kind') != 'management' else Path(root).parent.resolve()/source_folder) if not source.is_relative_to(source_root): raise ValueError('隔离新增只允许使用本次复制的来源工程。') validate_native_copy_paths(source, job['library'], job['name']) _align_library(source, pcb, Path(job['library'])) _dispatch_diagnostics(root, 'after-source-alignment', app, library, paths={'source': str(source), 'pcb': str(pcb), 'library_argument': job['library']}) validate_name(job['name']) deadline = time.monotonic() + float(job['timeout_seconds']) def find_window(title): for hwnd in desktop.EnumDesktopWindows(): if (win32process.GetWindowThreadProcessId(hwnd)[1] in owned_pids and win32gui.IsWindowVisible(hwnd) and win32gui.GetWindowText(hwnd) == title): return int(hwnd) return None def await_window(title): while time.monotonic() < deadline: hwnd = find_window(title) if hwnd: return hwnd pythoncom.PumpWaitingMessages(); time.sleep(.1) raise TimeoutError(f'原生窗口未出现:{title}') _require_add_supervisor(job, root) from .session_record import dispatch_native dispatch_native(job, lambda: app.OnReusableBlocksEditor()) _require_add_supervisor(job, root) editor = await_window('Reusable Blocks') tabs = Desktop(backend='uia').window(handle=editor).descendants(control_type='TabItem') physical = [tab for tab in tabs if tab.window_text() == 'Logical - Physical'] if len(physical) != 1: raise RuntimeError('无法唯一识别已验证的 Logical - Physical 页签。') if not physical[0].is_selected(): physical[0].select() if not physical[0].is_selected(): raise RuntimeError('Logical - Physical 页签未选中。') # UIA objects hold COM references into Library Manager. Do not retain them # during the native write or app.Quit / process-release observation. physical = tabs = None import gc gc.collect() new_button = win32gui.GetDlgItem(editor, 1066) if not new_button or not win32gui.IsWindowEnabled(new_button): raise RuntimeError('原生 New 按钮不可用。') win32gui.PostMessage(new_button, win32con.BM_CLICK, 0, 0) dialog = await_window('New Reusable Block') fields = {1217: str(source), 1215: job['name'], 1218: top, 1216: job.get('description', '')} for control, value in fields.items(): hwnd = win32gui.GetDlgItem(dialog, control) if not hwnd or win32gui.GetClassName(hwnd) != 'Edit': raise RuntimeError(f'原生新增字段身份不匹配:{control}') _set_probe_field(hwnd, control, value, root) _write_json(root/'submitted-fields.json', fields) ok = win32gui.GetDlgItem(dialog, 1083) if not ok: raise RuntimeError('原生新增确认按钮缺失。') _require_add_supervisor(job, root) log_baseline = snapshot_add_log(job['library']) _write_json(root/'native-add-log-baseline.json', log_baseline) observed_failures = {} _require_add_supervisor(job, root) from .session_record import dispatch_native, update_worker_state def submit_add(): job['_native_add_pending'] = True win32gui.PostMessage(ok, win32con.BM_CLICK, 0, 0) dispatch_native(job, submit_add, asynchronous=True, required=True) success = None while time.monotonic() < deadline: pythoncom.PumpWaitingMessages() observe_add_failure(desktop, owned_pids, root, log_baseline, job['name'], observed_failures) for hwnd in desktop.EnumDesktopWindows(): if win32process.GetWindowThreadProcessId(hwnd)[1] not in owned_pids or not win32gui.IsWindowVisible(hwnd): continue children = [] win32gui.EnumChildWindows(hwnd, lambda child, _: children.append(child), None) text = '\n'.join(win32gui.GetWindowText(child) for child in children) if 'New Logical-Physical Reuse Block was successfully added.' in text: success = text button = win32gui.GetDlgItem(hwnd, 2) or win32gui.GetDlgItem(hwnd, 1) if button: win32gui.PostMessage(button, win32con.BM_CLICK, 0, 0) break if success: break time.sleep(.1) _write_json(root/'native-add-output.json', {'success_message': success}) close = win32gui.GetDlgItem(editor, 1052) if success and close: win32gui.PostMessage(close, win32con.BM_CLICK, 0, 0) for _ in range(20): pythoncom.PumpWaitingMessages(); time.sleep(.1) if not win32gui.IsWindow(editor): break if not success: raise TimeoutError('未取得原生新增成功消息;保留副本与私有桌面证据。') job['_native_add_pending'] = False update_worker_state(job, 'POSTCALL') def run_isolated_probe(source, root, name, *, mentor_home=None, replacement_source=None): """Create a fresh native fixture and test Add without enabling production. Root must not exist. Source is copied completely before native access. A successful command alone is not acceptance: close/reopen and byte identity checks are recorded independently for human review. """ from .management import source_project, ManagementRequest from .library_lock import LibraryLock from .scoped_manifest import ManifestScope from .scoped_manifest import copy_verified, build_manifest import pythoncom, win32con, win32event root = absolute_preserving_drive(root) if root.exists(): raise ValueError('诊断目录必须是全新目录,不能复用现有中心库或旧 fixture。') source, _, top = source_project(source) validate_name(name) if root.resolve().is_relative_to(source.parent) or source.parent.is_relative_to(root.resolve()): raise ValueError('诊断目录不能与来源工程相互包含。') mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795') acquired = False token = uuid4().hex record = {'operation': 'isolated_add_probe', 'source': str(source), 'name': name, 'production_capability_enabled': False} owner_safe = True from .com_runtime import initialize_com, uninitialize_com initialized = initialize_com() try: acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED) if not acquired: raise RuntimeError('已有 CBB 校验/恢复/管理任务,请稍后运行隔离诊断。') root.mkdir(parents=True, exist_ok=False) manifest = copy_verified(source.parent, root/'source') staged = root/'source'/source.name identity = engineering_identity(staged) adapter = NativeManagementAdapter(mentor_home=mentor_home) if not adapter.capabilities()['remove'].supported: raise RuntimeError('诊断要求已识别的 EE7.9.5 原生安装。') library = root/'native-add/fixture/mentor_lib.lmc' def read_catalog(evidence): nonlocal owner_safe owner_safe = False catalog = adapter.catalog(library, evidence) owner_safe = catalog.safe_to_continue return catalog native = adapter._worker({'operation': 'probe_create_add', 'library': str(library), 'source': str(staged), 'name': name, 'top_level_block': top, 'probe_token': token}, root/'native-add') record['native'] = native record['source_unchanged'] = build_manifest(source.parent) == manifest if native.get('success') and native.get('safe_to_continue'): with LibraryLock(library, safe_to_release=lambda: owner_safe): catalog = read_catalog(root/'reopen') record['catalog'] = asdict(catalog) matches = [entry for entry in catalog.entries if entry.name == name and entry.partition == 'Logical-Physical'] record['identity_matches'] = len(matches) == 1 and matches[0].engineering_identity == identity record['accepted'] = record['identity_matches'] and record['source_unchanged'] else: record['accepted'] = False _write_json(root/'probe-result.json', record) if record['accepted'] and replacement_source is not None: replacement, _, replacement_top = source_project(replacement_source) if replacement.is_relative_to(root.resolve()) or root.resolve().is_relative_to(replacement.parent): raise ValueError('更新诊断来源必须位于隔离库与证据目录之外。') replacement_manifest = copy_verified(replacement.parent, root/'source-replacement') staged_replacement = root/'source-replacement'/replacement.name replacement_identity = engineering_identity(staged_replacement) record['update'] = {'stage': 'backup', 'accepted': False, 'source': str(replacement)} record['accepted'] = False with LibraryLock(library, safe_to_release=lambda: owner_safe): copy_verified(library.parent, root/'library-before-update', scope=ManifestScope.library(name, library.name)) request = ManagementRequest('remove', library, name, evidence_dir=root) owner_safe = False removal = adapter.remove(request, root/'native-remove') owner_safe = removal.safe_to_continue record['update']['removal'] = asdict(removal) _write_json(root/'probe-result.json', record) if not removal.success or not removal.safe_to_continue: return record missing = read_catalog(root/'after-remove') if any(e.name == name for e in missing.entries): record['update']['error'] = '原生移除后条目仍存在' _write_json(root/'probe-result.json', record) return record record['update']['stage'] = 'removed' _write_json(root/'probe-result.json', record) owner_safe = False readd = adapter._worker({'operation': 'probe_readd', 'library': str(library), 'source': str(staged_replacement), 'name': name, 'top_level_block': replacement_top, 'probe_token': token}, root/'native-readd') owner_safe = readd.get('safe_to_continue') is True record['update']['readd'] = readd if readd.get('success') and readd.get('safe_to_continue'): updated = read_catalog(root/'reopen-update') record['update']['catalog'] = asdict(updated) entries = [e for e in updated.entries if e.name == name and e.partition == 'Logical-Physical'] record['update']['accepted'] = (len(entries) == 1 and entries[0].engineering_identity == replacement_identity and build_manifest(replacement.parent) == replacement_manifest) record['update']['stage'] = 'complete' if record['update']['accepted'] else 'RECOVERY_REQUIRED' record['accepted'] = record['update']['accepted'] _write_json(root/'probe-result.json', record) return record except Exception as error: record.update(accepted=False, error=str(error)) if root.exists(): _write_json(root/'probe-result.json', record) raise finally: if acquired: win32event.ReleaseMutex(mutex) mutex.Close() uninitialize_com(initialized) def _current_desktop(): import win32api, win32service desktop = win32service.GetThreadDesktop(win32api.GetCurrentThreadId()) user32 = ctypes.WinDLL('user32', use_last_error=True) user32.GetUserObjectInformationW.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_uint)] buffer = ctypes.create_unicode_buffer(256) needed = ctypes.c_uint() if not user32.GetUserObjectInformationW(int(desktop), 2, buffer, ctypes.sizeof(buffer), ctypes.byref(needed)): raise OSError('无法确认工作进程桌面身份') return desktop, buffer.value def _wait_native_exit(pids, timeout=10): """Observe exact process handles after COM teardown, without COM/WMI.""" import pywintypes, win32api, win32con, win32event deadline = time.monotonic() + timeout for pid in pids: try: handle = win32api.OpenProcess(win32con.SYNCHRONIZE, False, int(pid)) except pywintypes.error as error: if error.winerror == 87: # Process no longer exists. continue return False try: remaining = max(0, int((deadline - time.monotonic()) * 1000)) if win32event.WaitForSingleObject(handle, remaining) != win32con.WAIT_OBJECT_0: return False finally: handle.Close() return True def _catalog_native(job, root): import gc, pythoncom from .com_runtime import initialize_com, uninitialize_com if job.get('operation') in ('add', 'probe_create_add', 'probe_readd'): # The installed UIA import disconnects existing Mentor proxies # (CO_E_OBJNOTCONNECTED). Finish its initialization before creating any. from pywinauto import Desktop initialized = initialize_com() try: result = _catalog_com(job, root) finally: gc.collect() uninitialize_com(initialized) # A failed COM activation can have created an unaccounted server. An empty # PID list is missing release evidence, not proof that nothing was launched. result['safe_to_continue'] = bool(result.get('native_pids')) and _wait_native_exit(result['native_pids']) return result def _catalog_com(job, root): import pythoncom, win32com.client, win32con, win32gui, win32process from .mentor_adapter import _process_details try: if job['operation'] == 'add': if job.get('authority_kind') == 'management': from .management_transaction import validate_transaction validate_transaction(job, root.parent) else: validate_owned_fixture_add(job, root) desktop, name = _current_desktop() if name != job['desktop'] or not name.startswith('CbbManagement_'): raise RuntimeError('拒绝在非本次私有桌面读取原生目录。') if _process_details('LibraryManager.exe'): raise RuntimeError('已有 Library Manager 运行,请关闭后重试。') except Exception as error: error.safe_to_continue = True raise stop = threading.Event() refused = [] observed = [] acknowledged_notices = set() owned_pids = set() def observe_dialogs(): while not stop.wait(.1): for hwnd in desktop.EnumDesktopWindows(): try: pid = win32process.GetWindowThreadProcessId(hwnd)[1] if pid not in owned_pids or not win32gui.IsWindowVisible(hwnd): continue children = [] win32gui.EnumChildWindows(hwnd, lambda child, _: children.append(child), None) title = win32gui.GetWindowText(hwnd) text = '\n'.join(win32gui.GetWindowText(child) for child in children) if catalog_dialog_action(title, text) == 'cancel': if hwnd not in observed: observed.append(hwnd) refused.append({'title': title, 'text': text}) _write_json(root/'refused-dialogs.json', refused) cancel = win32gui.GetDlgItem(hwnd, 2) if cancel: win32gui.PostMessage(cancel, win32con.BM_CLICK, 0, 0) elif (job['operation'] in ('add', 'probe_create_add', 'probe_readd') and win32gui.GetClassName(hwnd) == '#32770'): from .native_add_failures import missing_other_pcb_notice controls = [{'hwnd': int(child), 'id': win32gui.GetDlgCtrlID(child), 'class': win32gui.GetClassName(child), 'text': win32gui.GetWindowText(child), 'enabled': bool(win32gui.IsWindowEnabled(child))} for child in children] notice = missing_other_pcb_notice(job['library'], job.get('name'), title, '\n'.join(c['text'] for c in controls if c['class'] == 'Static'), [c for c in controls if c['class'] == 'Button']) key = (int(hwnd), text) if notice and key not in acknowledged_notices: acknowledged_notices.add(key) with (root/'native-information.jsonl').open('a', encoding='utf-8') as stream: stream.write(json.dumps({'pid': pid, 'hwnd': int(hwnd), 'text': text, 'missing_names': notice['names'], 'action': 'acknowledge_unrelated_missing_pcb'}, ensure_ascii=False)+'\n') win32gui.PostMessage(notice['button'], win32con.BM_CLICK, 0, 0) except Exception: continue app = library = None result = {'success': False, 'safe_to_continue': False} watcher = None try: _require_management_continuation(job, root) from .session_record import dispatch_native, update_worker_state # Keep the launch pending until its exact native identity is recorded. app = dispatch_native(job, lambda: win32com.client.DispatchEx('LibraryManager.Application'), asynchronous=True) app.Visible = True processes = _process_details('LibraryManager.exe') owned_pids.update(int(p[0]) for p in processes) from .session_record import update_worker_state update_worker_state(job, 'POSTCALL', identities=[('native', pid) for pid in owned_pids]) if len(owned_pids) != 1: raise RuntimeError('无法唯一确认本次 Library Manager 进程。') expected_binary = Path(job['mentor_home'])/'lm/win32/bin/LibraryManager.exe' if Path(processes[0][1]).resolve() != expected_binary.resolve(): raise RuntimeError('COM 注册指向不同的 Library Manager 安装,拒绝打开中心库。') watcher = threading.Thread(target=observe_dialogs, daemon=True) watcher.start() if job['operation'] in ('probe_create_add', 'probe_create'): target = prepare_probe_library(job, root) _require_management_continuation(job, root) library = dispatch_native(job, lambda: app.CreateLibrary(str(target), 1), asynchronous=True) _write_json(root.parent/'probe-owner.json', {'library': str(target), 'token': job['probe_token']}) else: if job['operation'] == 'probe_readd': validate_probe_readd(job, root) _require_management_continuation(job, root) library = dispatch_native(job, lambda: app.OpenLibrary(str(absolute_preserving_drive(job['library']))), asynchronous=True) update_worker_state(job, 'POSTCALL') if refused: raise RuntimeError('目录读取需要升级中心库或选择流程;已拒绝,目标未获准自动升级。') if library is None or Path(str(library.FullName)).resolve() != Path(job['library']).resolve(): raise RuntimeError('原生返回中心库身份不一致。') if job['operation'] in ('add', 'probe_create_add', 'probe_readd'): if int(library.FlowType) != 1: raise RuntimeError('Native Add requires the DxDesigner Logical-Physical library flow.') _probe_add_dialog(app, job, desktop, owned_pids, root, library=library) dispatch_native(job, lambda: library.Close(), phase='CLOSING') library = None _require_management_continuation(job, root) library = dispatch_native(job, lambda: app.OpenLibrary(str(absolute_preserving_drive(job['library'])))) if (library is None or Path(str(library.FullName)).resolve() != Path(job['library']).resolve() or int(library.FlowType) != 1): raise RuntimeError('Native Add reopen did not confirm the exact library and flow.') entries = [] parts = library.Partitions(7) for i in range(1, int(parts.Count) + 1): partition = parts.Item(i) for j in range(1, int(partition.Count) + 1): item = partition.Item(j) block_name, partition_name = str(item.Name), str(item.PartitionName) validate_name(block_name) identity = {} work = Path(job['library']).parent/'ReusableBlocksLP'/block_name/'Work' projects = list(work.glob('*.prj')) if len(projects) == 1: try: identity = engineering_identity(projects[0]) except (ValueError, OSError): pass entries.append(asdict(CatalogEntry(block_name, partition_name, identity))) item = None partition = None parts = None result.update(success=True, library=str(library.FullName), flow=int(library.FlowType), entries=entries) if job['operation'] == 'add': matches = [entry for entry in entries if entry['name'] == job['name'] and entry['partition'] == job['partition']] identity_matches = (len(matches) == 1 and matches[0]['engineering_identity'] == job.get('source_identity')) result['identity_matches'] = identity_matches if len(matches) != 1: result.update(success=False, detail='Native Add reopen did not confirm the exact name and partition.') elif not identity_matches: result['detail'] = ('Native Add registered the block, but engineering identity readback ' 'differs from the staged source.') except Exception as error: result['detail'] = str(error) result['exception'] = _exception_details(error) finally: if library is not None and not job.get('_native_add_pending'): try: dispatch_native(job, lambda: library.Close(), phase='CLOSING') except Exception as error: result['close_detail'] = str(error) result['close_exception'] = _exception_details(error) library = None if app is not None and not job.get('_native_add_pending'): try: dispatch_native(job, lambda: app.Quit(), phase='CLOSING') except Exception as error: result['quit_detail'] = str(error) result['quit_exception'] = _exception_details(error) app = None stop.set() if watcher: watcher.join(1) result['native_pids'] = sorted(owned_pids) if refused: result.update(success=False, detail='拒绝目录读取触发的中心库升级/流程选择。') return result def management_worker_main(request_path): """Internal worker. Desktop identity and capability gates are rechecked here.""" request_path = Path(request_path) root = request_path.parent job = json.loads(request_path.read_text(encoding='utf-8')) result = {'success': False, 'safe_to_continue': True} try: _, desktop = _current_desktop() if desktop != job['desktop'] or not desktop.startswith('CbbManagement_'): raise RuntimeError('原生管理操作仅允许在本次私有桌面执行。') _require_management_continuation(job, root) if job.get('cancel_signal'): from .session_record import update_worker_state update_worker_state(job, 'PRECALL') from .desktop_worker import start_supervisor_watchdog start_supervisor_watchdog(job['supervisor_pid'], cancel_path=job['cancel_signal'], supervisor_identity=job.get('supervisor_identity'), session_record_path=job.get('session_record_path'), operation_id=job.get('operation_id')) if job.get('start_gate'): deadline = time.monotonic() + 30 while not Path(job['start_gate']).is_file(): _require_management_continuation(job, root) if time.monotonic() >= deadline: raise RuntimeError('MANAGEMENT_CANCELLED: 启动门未放行,未启动原生操作') time.sleep(.05) _require_management_continuation(job, root) if job.get('mapped_drive') and job.get('mapped_remote_root'): from .network_path import ensure_mapped_drive_visible ensure_mapped_drive_visible(job['mapped_drive'], job['mapped_remote_root']) if job['operation'] in ('catalog', 'add', 'probe_create', 'probe_create_add', 'probe_readd'): if job['operation'] == 'add': route = NativeManagementAdapter(mentor_home=job['mentor_home']).route_capabilities()['add'] if not route.supported: raise RuntimeError(route.reason) validate_name(job['name']) if job.get('partition') != 'Logical-Physical': raise ValueError('Native Add requires Logical-Physical.') if engineering_identity(job['source']) != job.get('source_identity'): raise ValueError('Staged source engineering identity changed before native Add.') result['safe_to_continue'] = False result = _catalog_native(job, root) elif job['operation'] == 'remove': adapter = NativeManagementAdapter(mentor_home=job['mentor_home']) cap = adapter.capabilities()['remove'] if not cap.supported: raise RuntimeError(cap.reason) if job['partition'] != 'Logical-Physical': raise ValueError('未验证的分区类型') input_path = root/'remove-list.txt' input_path.write_bytes(removal_input(job['name'], job['partition'])) command = [str(adapter.home/'lm/win32/bin/CleanWGLib.exe'), str(job['library']), 'F4', str(input_path)] _write_json(root/'command.json', command) with (root/'native-output.txt').open('wb') as output: _require_management_continuation(job, root) from .session_record import dispatch_native, update_worker_state result['safe_to_continue'] = False try: process = dispatch_native(job, lambda: subprocess.Popen(command, stdout=output, stderr=subprocess.STDOUT, creationflags=subprocess.CREATE_NO_WINDOW), asynchronous=True) except (FileNotFoundError, PermissionError): result['safe_to_continue'] = True raise update_worker_state(job, 'NATIVE_CALL', identities=[('native', process.pid)], continuation=True) try: _write_json(root/'native-process.json', {'pid': process.pid, 'command': command}) except OSError: pass # Keep supervising the native owner even when evidence storage fails. # Never terminate this native database owner on timeout. try: code = process.wait(timeout=float(job['timeout_seconds'])) except subprocess.TimeoutExpired: result.update(detail=f'TIMEOUT: CleanWGLib PID {process.pid} 尚未释放') while True: try: code = process.wait(timeout=1) break except subprocess.TimeoutExpired: continue result['wait_exceeded'] = True update_worker_state(job, 'POSTCALL') result.update(safe_to_continue=True, exit_code=code) text = (root/'native-output.txt').read_bytes().decode('mbcs', errors='replace') result.update(success=removal_output_ok(code, text, job['name'], job['partition']), detail=text) else: raise ValueError('未验证的原生管理操作') except Exception as error: if getattr(error, 'safe_to_continue', None) is True: result['safe_to_continue'] = True result['detail'] = str(error) result['exception'] = _exception_details(error) finally: from .session_record import update_worker_state _write_json(root/'result.json', result) # FINISHED permits the orphan watchdog to exit immediately. update_worker_state(job, 'FINISHED' if result.get('safe_to_continue') is True else 'UNCONFIRMED') return 0 if result['success'] and result['safe_to_continue'] else 2