Files
cbb-refresh-verify-795/src/cbb_refresh_verify/native_management.py
T

1310 lines
72 KiB
Python

"""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