diff --git a/src/cbb_refresh_verify/library_reader.py b/src/cbb_refresh_verify/library_reader.py index 09e8983..f576b73 100644 --- a/src/cbb_refresh_verify/library_reader.py +++ b/src/cbb_refresh_verify/library_reader.py @@ -203,20 +203,22 @@ def filesystem_status_map(library: Path, names): return {name: details['status'] for name, details in filesystem_evidence_map(library, names).items()} def read_library_fast(path: Path, *, status_reader=None): - """List CBBs from ReusableBlocksLP without touching COM or the .lmc. - - Useful when Library Manager is unavailable or already running: the folder - is the same source the LM tree shows, and an optional status_reader can - supply each item's flag without a full COM session. - """ + """Discover directories; this does not validate native format/registration.""" try: path = Path(path) + if path.suffix.casefold() != '.lmc': + return LibraryReadResult((), 'INPUT_SUFFIX: 请选择 .lmc 中心库文件。') if not path.is_file(): - return LibraryReadResult((), f'中心库不存在: {path}') + return LibraryReadResult((), f'INPUT_MISSING: 中心库不存在或不是文件: {path}') + with path.open('rb') as stream: + if not stream.read(1): + return LibraryReadResult((), 'INPUT_EMPTY: 中心库文件为空。') + if any(lock.is_dir() for lock in (path.with_suffix('.lock'), path.with_name('.'+path.stem+'.cbb-upload.lock'))): + return LibraryReadResult((), 'INPUT_LOCK_DIRECTORY: 中心库锁路径是目录。') folder = path.parent/'ReusableBlocksLP' - if not folder.is_dir(): - return LibraryReadResult((), f'缺少 ReusableBlocksLP 目录: {folder}') - entries = [entry for entry in folder.iterdir() if entry.is_dir()] + if folder.exists() and not folder.is_dir(): + return LibraryReadResult((), f'INPUT_DIRECTORY: ReusableBlocksLP 不是目录: {folder}') + entries = [entry for entry in folder.iterdir() if entry.is_dir()] if folder.is_dir() else [] names = tuple(sorted((entry.name for entry in entries), key=str.casefold)) statuses = {} if status_reader is not None and names: @@ -240,8 +242,11 @@ def read_library_fast(path: Path, *, status_reader=None): status = str(statuses.get(entry.name, 'UNKNOWN') or 'UNKNOWN') if status not in {'READY', 'PENDING', 'UNKNOWN', 'UNAVAILABLE', 'ERROR', 'TIMEOUT'}: status = 'UNKNOWN' - records.append(CbbRecord(entry.name, 'Reusable Blocks', status=status)) - return LibraryReadResult(tuple(sorted(records, key=lambda item: item.name))) + records.append(CbbRecord(entry.name, 'Reusable Blocks', status=status, + catalog_source='directory', status_source='status_reader' if status_reader else 'unknown')) + return LibraryReadResult(tuple(sorted(records, key=lambda item: item.name)), directory_count=len(entries)) + except PermissionError as error: + return LibraryReadResult((), f'INPUT_PERMISSION: 无权读取中心库: {error}') except Exception as error: return LibraryReadResult((), str(error)) diff --git a/src/cbb_refresh_verify/models.py b/src/cbb_refresh_verify/models.py index 551c12c..eb519fc 100644 --- a/src/cbb_refresh_verify/models.py +++ b/src/cbb_refresh_verify/models.py @@ -7,8 +7,15 @@ class CbbRecord: partition_name: str logical_type: str = "LP" status: str = "UNKNOWN" + catalog_source: str = "provided" + status_source: str = "provided" + missing_reason: str = "" @dataclass(frozen=True) class LibraryReadResult: records: tuple[CbbRecord, ...] error: str | None = None + directory_count: int | None = None + native_count: int | None = None + missing_project_count: int | None = None + catalog_verified: bool = False diff --git a/src/cbb_refresh_verify/operation_queue.py b/src/cbb_refresh_verify/operation_queue.py index ac3c5e1..f1a2a23 100644 --- a/src/cbb_refresh_verify/operation_queue.py +++ b/src/cbb_refresh_verify/operation_queue.py @@ -63,6 +63,7 @@ def request_library_keys(request, context=None): class _Call: context: object external_stop: object = None + metadata_only: bool = False done: Event = field(default_factory=Event) abandoned: bool = False native_depth: int = 0 @@ -120,6 +121,8 @@ def hold_native_handoff(process, session_record_path): def native_phase(): """Never abandon a transaction between native writes (including Remove/Add).""" call = getattr(_local, 'call', None) + if call is not None and call.metadata_only: + raise RuntimeError('A metadata-only call cannot enter native work') with _tasks_guard: check_active() if call is not None: @@ -224,14 +227,14 @@ class BatchTaskContext: call.abandoned = True return self.snapshot() - def run(self, action, *, stop=None, timeout_seconds=10): + def run(self, action, *, stop=None, timeout_seconds=10, metadata_only=False): self.check_active() if current_context() is self: return action() # Preserve nested lease and mutex thread identity. aliases = {_path_key(v) for v in (self.library, *self.aliases)} - call = _Call(self, stop) + call = _Call(self, stop, metadata_only=metadata_only) with _tasks_guard: - if any(c.abandoned and aliases.intersection( + if not metadata_only and any(c.abandoned and not c.metadata_only and aliases.intersection( _path_key(v) for v in (c.context.library, *c.context.aliases)) for c in _calls.values()): raise TaskHandoff(self) diff --git a/src/cbb_refresh_verify/ui/backup_recovery_dialog.py b/src/cbb_refresh_verify/ui/backup_recovery_dialog.py index f724816..cfe2444 100644 --- a/src/cbb_refresh_verify/ui/backup_recovery_dialog.py +++ b/src/cbb_refresh_verify/ui/backup_recovery_dialog.py @@ -2,13 +2,14 @@ from pathlib import Path from threading import Event -from PySide6.QtCore import QObject, QThreadPool, Signal +from PySide6.QtCore import QObject, QThreadPool, Signal, Qt from PySide6.QtWidgets import (QComboBox, QDialog, QFileDialog, QFormLayout, QHBoxLayout, QLabel, QLineEdit, QPushButton, QMessageBox) from .workers import ServiceWorker from .backup_notice import MANUAL_BACKUP_NOTICE from . import timed_prompt +from ..operation_queue import BatchTaskContext class RecoverySignals(QObject): @@ -28,13 +29,17 @@ class BackupRecoveryDialog(QDialog): self.recoverer = recoverer self.native_queue = None self.stop = Event() + self.context = None + self.ui_job = None + self.admit = None + self.setWindowModality(Qt.NonModal) self.busy = False self.pool = QThreadPool(self) self.pool.setMaxThreadCount(1) self.signals = RecoverySignals(self) self.signals.progress.connect(self._progress) - if parent is not None and hasattr(parent, '_show_version_choice'): - self.signals.choice.connect(parent._show_version_choice) + self._choice_handler = getattr(parent, '_show_version_choice', None) + self.signals.choice.connect(self._choice) self.block_combo = QComboBox() self.block_combo.addItems(list(names)) self.source_edit = QLineEdit() @@ -47,7 +52,7 @@ class BackupRecoveryDialog(QDialog): self.close_button.clicked.connect(self.reject) self.cancel_queue_button = QPushButton('取消排队') self.cancel_queue_button.setEnabled(False) - self.cancel_queue_button.clicked.connect(self.stop.set) + self.cancel_queue_button.clicked.connect(lambda:self.stop.set()) self.status_label = QLabel(MANUAL_BACKUP_NOTICE + ' 所选备份先在隔离库中验证;安装时旧 Work 仅改名保留。') self.status_label.setWordWrap(True) layout = QFormLayout(self) @@ -94,37 +99,64 @@ class BackupRecoveryDialog(QDialog): '\n\n将创建用于校验的隔离库副本,校验通过后替换目标工程。确认继续?', QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes) != QMessageBox.Yes: return + if self.admit is not None and not self.admit((request, source)): + self.status_label.setText('相同任务已提交,未重复执行。') + return self.busy = True - self.stop.clear() + self.context = BatchTaskContext(str(request.lmc_file), targets=(name,)) + context = self.context + self.stop = context.stop self._set_enabled(False) self.status_label.setText('正在准备恢复…') self.started.emit(name) def execute(): - options = {'version_prompt': self.signals.choice.emit,'stop':self.stop} if self.recoverer is None else {} - action = lambda: recoverer(request, source, progress=self.signals.progress.emit, **options) - if self.native_queue is None: return action() + options = {'version_prompt': lambda choice:self._emit(context, 'choice',choice),'stop':context.stop} if self.recoverer is None else {} + action = lambda: recoverer(request, source, progress=lambda event:self._emit(context, 'progress',event), **options) + if self.native_queue is None: return context.run(action) from ..operation_queue import QueueCancelled def restore(): - self.signals.progress.emit({'stage': 'queue_acquired'}) + self._emit(context, 'progress',{'stage': 'queue_acquired'}) return action() try: - return self.native_queue.run(restore, stop=self.stop, waiting=lambda: self.signals.progress.emit( + return self.native_queue.run(restore, stop=context.stop, context=context, waiting=lambda: self._emit(context, 'progress', {'stage': 'waiting_native_slot', 'detail': '已排队,等待当前检查结束'})) except QueueCancelled as error: - from ..verify_runner import VerifyResult + from ..operation_queue import TaskHandoff + from ..verify_runner import VerifyResult, _handoff_verify_result + if isinstance(error, TaskHandoff): return _handoff_verify_result(error) return VerifyResult('CANCELLED', stderr=str(error)) self.worker = ServiceWorker(execute) - self.worker.signals.succeeded.connect(lambda result: self._result(name, result)) - self.worker.signals.failed.connect(lambda error: self._failed(name, error)) - self.worker.signals.finished.connect(self._finished) + self.worker.signals.succeeded.connect(context.guard_callback(lambda result: self._result(name, result), current=lambda:self.context)) + self.worker.signals.failed.connect(context.guard_callback(lambda error: self._failed(name, error), current=lambda:self.context)) + self.worker.signals.finished.connect(lambda:self._finished() if self.context is context else None) self.pool.start(self.worker) + def _emit(self, context, signal, value): + if context is not self.context or not self.busy or signal == 'choice' and context.stop.is_set(): + if signal == 'choice': value.choose('cancel') + return + try: + delivered = context.guard_callback(lambda:getattr(self.signals, signal).emit((context,value)) or True)() + if not delivered and signal == 'choice': value.choose('cancel') + except RuntimeError: + if signal == 'choice': value.choose('cancel') + + def _choice(self, payload): + context, choice = payload + if context is not self.context or not self.busy or context.stop.is_set() or self._choice_handler is None: + choice.choose('cancel') + return + self._choice_handler((self.ui_job,choice) if self.ui_job else choice) + def _set_enabled(self, enabled): for widget in (self.block_combo, self.source_edit, self.browse_button, self.restore_button, self.close_button): widget.setEnabled(enabled) def _progress(self, event): + if isinstance(event, tuple): + context, event = event + if context is not self.context or not self.busy: return if isinstance(event, dict): if event.get('stage') in ('waiting_native_slot', 'queue_acquired'): self.cancel_queue_button.setEnabled(event['stage'] == 'waiting_native_slot') @@ -160,6 +192,7 @@ class BackupRecoveryDialog(QDialog): def closeEvent(self, event): if self.busy: + self.stop.set() event.ignore() else: super().closeEvent(event) diff --git a/src/cbb_refresh_verify/ui/icdb_check_task.py b/src/cbb_refresh_verify/ui/icdb_check_task.py index 30ed9ad..d3960e1 100644 --- a/src/cbb_refresh_verify/ui/icdb_check_task.py +++ b/src/cbb_refresh_verify/ui/icdb_check_task.py @@ -1,8 +1,7 @@ """A check batch owns its snapshot and yields the native queue after each CBB.""" -from threading import Event from PySide6.QtCore import QObject, QThreadPool, Signal from .workers import ServiceWorker -from ..operation_queue import QueueCancelled +from ..operation_queue import QueueCancelled, BatchTaskContext from ..verify_runner import VerifyResult, run_verify, write_batch_report from ..icdb_maintenance import write_maintenance_report @@ -12,14 +11,17 @@ class IcdbCheckTask(QObject): item_done = Signal(str, object) finished = Signal(object) - def __init__(self, requests, queue, report_root, *, verifier=None, path_lease=None, parent=None): + def __init__(self, requests, queue, report_root, *, verifier=None, path_lease=None, parent=None, status_reader=None, choice_prompt=None): super().__init__(parent) self.requests = tuple(requests) self.queue, self.report_root = queue, report_root self.path_lease = path_lease - self.verifier = verifier or (lambda req: run_verify(req, progress=self.event.emit, stop=self.stop)) + self.context = BatchTaskContext(str(self.requests[0].lmc_file), targets=tuple(r.block_name for r in self.requests)) + self.status_reader = status_reader + self.verifier = verifier or (lambda req: run_verify(req, progress=self._emit_event, + stop=self.stop, version_prompt=choice_prompt)) self.results = [] - self.stop = Event() + self.stop = self.context.stop self.active = False self.paused = False self.invalidated = set() @@ -30,6 +32,12 @@ class IcdbCheckTask(QObject): self.retained_libraries = set() self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1) + def _emit_event(self, event): + try: + self.context.guard_callback(self.event.emit)(event) + except RuntimeError: + pass + def start(self): self.active = True self._next() @@ -68,23 +76,31 @@ class IcdbCheckTask(QObject): from ..session_record import library_available, library_wait_reason try: def execute(): + if self.status_reader is not None: + statuses = self.status_reader((request.block_name,), request.lmc_file) + self.update_statuses(statuses) + if statuses.get(request.block_name) == 'NOT_REGISTERED': + return VerifyResult('SKIPPED', stderr='仅发现目录,原生目录未登记此 CBB。') if request.block_name in self.ready_names: return VerifyResult('SKIPPED', stderr='工程已为 READY,跳过 ICDB 检查。') if request.block_name in self.invalidated: return VerifyResult('SKIPPED', stderr='目标已有后续管理操作,请重新检查。') - self.event.emit({'stage': 'icdb_check_start', 'block': request.block_name}) + self._emit_event({'stage': 'icdb_check_start', 'block': request.block_name}) result = self.verifier(request) if not result.safe_to_continue: from ..operation_lifecycle import recheck_failed_release result = recheck_failed_release(request.lmc_file, request.block_name, result) return result - return self.queue.run(execute, stop=self.stop, + return self.queue.run(execute, stop=self.stop, context=self.context, wait_state=lambda: (self.paused, library_wait_reason(request.lmc_file)), - ready=lambda: not self.paused and library_available(request.lmc_file), - waiting=lambda: self.event.emit({'stage': 'waiting_native_slot', 'block': request.block_name, + ready=lambda: not self.paused, + waiting=lambda: self._emit_event({'stage': 'waiting_native_slot', 'block': request.block_name, 'library': str(request.lmc_file), 'retained': not library_available(request.lmc_file), 'detail': library_wait_reason(request.lmc_file) or '已排队,等待当前原生操作结束'})) except QueueCancelled as error: + from ..operation_queue import TaskHandoff + from ..verify_runner import _handoff_verify_result + if isinstance(error, TaskHandoff): return _handoff_verify_result(error) return VerifyResult('CANCELLED', stderr=str(error)) except Exception as error: return VerifyResult('FAIL', stderr=str(error), safe_to_continue=False, @@ -117,7 +133,12 @@ class IcdbCheckTask(QObject): return report, '' except Exception as error: return None, str(error) - self.worker = ServiceWorker(write) + def bounded_write(): + try: + return BatchTaskContext(str(self.requests[0].lmc_file)).run(write) + except Exception as error: + return None, str(error) + self.worker = ServiceWorker(bounded_write) self.worker.signals.succeeded.connect(self._report_ready) self.worker.signals.finished.connect(self._complete) self.pool.start(self.worker) diff --git a/src/cbb_refresh_verify/ui/main_window.py b/src/cbb_refresh_verify/ui/main_window.py index 3d6a6cf..e57a2c4 100644 --- a/src/cbb_refresh_verify/ui/main_window.py +++ b/src/cbb_refresh_verify/ui/main_window.py @@ -5,6 +5,10 @@ import ntpath import time from collections import Counter from dataclasses import replace +from types import SimpleNamespace +import json + +from cbb_refresh_verify.operation_queue import BatchTaskContext, QueueCancelled, TaskHandoff from PySide6.QtCore import QObject, QThreadPool, Signal, Qt, QTimer from PySide6.QtGui import QColor, QIcon @@ -73,6 +77,9 @@ STATUS_LABELS = { 'CRASHED': '状态桥崩溃', } +# Qt must not destroy a pool whose native observer is still handing off. +_shutdown_pools = set() + def application_icon_path(): return Path(__file__).resolve().parents[1] / 'assets' / 'cbb_refresh_verify.ico' @@ -81,7 +88,7 @@ def application_icon_path(): class MainWindow(QWidget): def __init__(self, reader=None, verifier=None, logging_context=None, data_root=None, authoritative_status=True, path_lease_factory=None, status_refresher=None, - management_adapter=None, native_backup_launcher=None): + management_adapter=None, native_backup_launcher=None, catalog_reader=None): super().__init__() self.setWindowTitle('CBB 刷新校验') icon_path = application_icon_path() @@ -94,6 +101,7 @@ class MainWindow(QWidget): self.library_lease = None self.mentor_lmc_path = None self.data_root = Path(data_root or (logging_context.root if logging_context else Path(os.environ.get('LOCALAPPDATA', '.'))/'CbbRefreshVerify')) + self._settings_enabled = data_root is not None or logging_context is not None or reader is None from cbb_refresh_verify.native_management import NativeManagementAdapter self.management_adapter = management_adapter or NativeManagementAdapter() self.management_capabilities = self.management_adapter.capabilities() @@ -111,30 +119,27 @@ class MainWindow(QWidget): self.native_backup_timer = QTimer(self) self.native_backup_timer.setInterval(400) self.native_backup_timer.timeout.connect(self._poll_native_backup) - if reader is not None: - self.reader = reader - elif authoritative_status and os.environ.get('CBB_STATUS_BRIDGE_MODE', 'authoritative').casefold() != 'legacy': - self.reader = lambda path: read_library_fast( - path, - status_reader=lambda p, names: authoritative_status_map( - names, p, self.data_root / 'status-scan.jsonl'), - ) - else: - # Legacy icon/filesystem reader remains opt-in until the bridge is - # accepted on the target Mentor installation. It cannot override - # the authoritative path when that path is enabled explicitly. - self.reader = lambda path: read_library_fast( - path, - status_reader=lambda p, names: scan_open_library_status( - p, names, mapping_store=self.data_root/'image-status-map.json'), - ) - self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1) + self._injected_reader = reader is not None + self.reader = reader or read_library_fast + self.catalog_reader = catalog_reader or (None if reader is not None else getattr(self.management_adapter,'catalog',None)) + self._view_revision = 0 + self._jobs = {} + self._dialogs = [] + self._current_job = None + self._stale_table = False + self._read_counts = (None, None, None) + self._diagnostic_evidence = {} + self.pool = QThreadPool(self); self.pool.setMaxThreadCount(8) self.lifecycle_pool = QThreadPool(self); self.lifecycle_pool.setMaxThreadCount(1) + self.lease_pool = QThreadPool(self); self.lease_pool.setMaxThreadCount(1) self._lifecycle_workers = set() + self._lifecycle_contexts = set() self._lease_pending = 0 self._lease_workers = set() + self._lease_contexts = set() self._mapping_busy = 0 - self._mapping_auto_idle = False + self._mapping_owners = Counter() + self._mapping_auto_owners = set() self._mapping_finish_waiters = [] self._closing = self._close_ready = False self._queue_wait_library = None @@ -157,11 +162,14 @@ class MainWindow(QWidget): self._icdb_completed = 0 self.signals = ProgressSignals(self); self.signals.event.connect(self._progress) self.signals.batch_ready.connect(self._batch_done) - if hasattr(self.management_adapter, 'session_progress'): - self.management_adapter.session_progress = self.signals.event.emit self.signals.version_choice.connect(self._show_version_choice) self.version_dialog = None self.lmc_edit = QLineEdit() + try: + if self._settings_enabled: + self.lmc_edit.setText(str(json.loads((self.data_root/'settings.json').read_text('utf-8')).get('last_library', ''))) + except (OSError, ValueError, TypeError): + pass self.libspec_edit = QLineEdit(os.environ.get('CBB_LIBSPEC', 'EE7.9')) self.dms_edit = QLineEdit(os.environ.get('CBB_DMS_LOGIN_CONFIG', '')) self.mentor_bin_edit = QLineEdit(os.environ.get('SDD_LM_BIN', '')) @@ -188,6 +196,7 @@ class MainWindow(QWidget): self.cbb_table.horizontalHeader().setSectionResizeMode(column, QHeaderView.ResizeToContents) self.cbb_table.setSelectionBehavior(QTableWidget.SelectRows) self.cbb_table.setMinimumHeight(150) + self.cbb_table.currentCellChanged.connect(lambda *_: self._update()) self.cbb_table.itemChanged.connect(lambda _item: self._update()) self.search_edit = QLineEdit() self.search_edit.setPlaceholderText('按 CBB 名称或分区搜索') @@ -279,6 +288,9 @@ class MainWindow(QWidget): self.native_backup_button.setToolTip('勾选一个非 READY CBB,打开原生备份列表并选择回退版本。') self.native_backup_button.clicked.connect(self.open_native_backup) maintenance_layout.addWidget(self.native_backup_button) + self.native_repair_button = QPushButton('手动 Repair…') + self.native_repair_button.clicked.connect(lambda: self.open_native_backup(mode='repair')) + maintenance_layout.addWidget(self.native_repair_button) maintenance_row = QHBoxLayout() maintenance_row.addWidget(self.icdb_repair_button) self.icdb_stop_button = QPushButton('停止检查') @@ -338,15 +350,60 @@ class MainWindow(QWidget): self._update() def _invalidate(self): + if self._current_job is not None and self._current_job.kind == 'read': + self._current_job.context.close(timeout_seconds=0) + self._view_revision += 1 + self._current_job = None self._reimport_offers = () - if self.loaded_path is not None and self.lmc_edit.text() != self.loaded_path: - self._release_library_lease() - self.loaded_path = None; self.mentor_lmc_path = None; self.cbb_table.setRowCount(0); self._row_by_name = {} - self._records_by_name = {} - self.ready_names = set(); self.skipped_names = set(); self.skip_reasons = {}; self._update() - self._global_icdb_run = False - if not self._icdb_active(): - self.icdb_progress.hide(); self.icdb_phase.hide() + self._diagnostic_evidence.clear() + self._resume_batch = None + self._stale_table = bool(self._records_by_name) + self._release_library_lease() + self.loaded_path = None + self.mentor_lmc_path = None + self.busy = False + self._update() + + def _new_job(self, kind, *, library=None, targets=(), lease=None): + library = str(library or self.mentor_lmc_path or self.lmc_edit.text()) + lease = self.library_lease if lease is None else lease + context = BatchTaskContext(library, aliases=tuple(_library_path_keys(library, lease)), targets=tuple(targets)) + job = SimpleNamespace(context=context, kind=kind, revision=self._view_revision, + lease=lease, requests=(), records={}, active=True, keep_session=False) + self._jobs[context.operation_id] = job + self._current_job = job + self.stop = context.stop + return job + + def _job_current(self, job): + from shiboken6 import isValid + return (not self._closing and isValid(self) and isValid(self.cbb_table) + and job.revision == self._view_revision and self._current_job is job) + + def _emit_job(self, job, signal, value): + # A native observer may outlive both its Qt receiver and its handoff. + if self._closing or not job.active: + if signal == 'version_choice': value.choose('cancel') + return + try: + getattr(self.signals, signal).emit((job, value)) + except RuntimeError: + if signal == 'version_choice': value.choose('cancel') + + def _finish_job(self, job): + if job.keep_session: + if self._job_current(job): self._finished() + return + paused = getattr(job, 'paused_check', None) + if paused is not None and paused.active and not paused.stop.is_set() and not self._closing: + paused.resume() + job.active = False + self._jobs.pop(job.context.operation_id, None) + job.context.close(timeout_seconds=0) + if job.lease is not None and job.lease is not self.library_lease: + if not any(other.lease is job.lease for other in self._jobs.values()): + self._close_path_lease(job.lease) + if self._job_current(job): self._finished() def _release_library_lease(self): lease, self.library_lease = self.library_lease, None @@ -354,7 +411,7 @@ class MainWindow(QWidget): return # The visible native session still needs this mapping. if self._icdb_active() and self.icdb_task.path_lease is lease: return # This background task still uses its captured mapping. - if lease is None: + if lease is None or any(job.lease is lease for job in self._jobs.values()): return try: self._close_path_lease(lease) @@ -363,45 +420,63 @@ class MainWindow(QWidget): self.logging_context.logger.warning('library_lease_release_failed error=%s', error) def _close_path_lease(self, lease): - self._lease_action(lease.close, hold_busy=self.busy) + self._lease_action(lease.close) def _retain_path_lease(self, lease, *, hold_busy=False): if lease is not None: self._lease_action(lease.retain_for_recovery, hold_busy=hold_busy) - def _lease_action(self, action, completed=None, failed=None, *, hold_busy=False): + def _lease_action(self, action, completed=None, failed=None, *, hold_busy=False, + library=None, completed_always=False): # The serial pool orders retain before every subsequent close. + owner = (self._view_revision, id(self._current_job)) + def current(): + from shiboken6 import isValid + return (isValid(self) and isValid(self.cbb_table) and not self._closing + and owner == (self._view_revision, id(self._current_job))) self._lease_pending += 1 if hold_busy: - if not self._mapping_busy and not self.busy: - self._mapping_auto_idle = True + if not self.busy: self._mapping_auto_owners.add(owner) + self._mapping_owners[owner] += 1 self._mapping_busy += 1 self.busy = True self._update() - worker = ServiceWorker(action) + library = library or getattr(getattr(action,'__self__',None),'mentor_path',None) + context = BatchTaskContext(str(library or self.mentor_lmc_path or self.loaded_path or self.data_root)) + self._lease_contexts.add(context) + worker = ServiceWorker(lambda:context.run(action)) self._lease_workers.add(worker) - if completed is not None: worker.signals.succeeded.connect(completed) - worker.signals.failed.connect(failed or self._display_error) + if completed is not None: + worker.signals.succeeded.connect(lambda result:completed(result) if completed_always or current() else None) + worker.signals.failed.connect(lambda error:(failed or self._display_error)(error) if current() else None) def finished(): self._lease_workers.discard(worker) + self._lease_contexts.discard(context) self._lease_pending -= 1 - if hold_busy: self._mapping_busy -= 1 + if hold_busy: + self._mapping_busy -= 1 + self._mapping_owners[owner] -= 1 from shiboken6 import isValid if not isValid(self) or not isValid(self.cbb_table): return - if not self._mapping_busy: - callbacks, self._mapping_finish_waiters = self._mapping_finish_waiters, [] - auto_idle, self._mapping_auto_idle = self._mapping_auto_idle, False - for callback in callbacks: callback() - if auto_idle and not callbacks: self._finished() + if not self._mapping_owners[owner]: + callbacks = [entry for entry in self._mapping_finish_waiters if entry[0] == owner] + self._mapping_finish_waiters = [entry for entry in self._mapping_finish_waiters if entry[0] != owner] + for callback_owner, callback in callbacks: + if current(): callback() + if owner in self._mapping_auto_owners and not callbacks and current(): self._finished() + self._mapping_auto_owners.discard(owner) + self._mapping_owners.pop(owner, None) self._update() worker.signals.finished.connect(finished) - self.pool.start(worker) + self.lease_pool.start(worker) def _defer_mapping_finish(self, callback): - if not self._mapping_busy: return False - if callback not in self._mapping_finish_waiters: - self._mapping_finish_waiters.append(callback) + owner = (self._view_revision, id(self._current_job)) + if not self._mapping_owners[owner]: return False + waiter = (owner, callback) + if waiter not in self._mapping_finish_waiters: + self._mapping_finish_waiters.append(waiter) return True def _update(self): @@ -413,8 +488,13 @@ class MainWindow(QWidget): ready = not self.busy and self.loaded_path == self.lmc_edit.text() and self.cbb_table.rowCount() > 0 selected = self.selected_records() native_target = self._native_backup_target() - self.native_backup_button.setEnabled(ready and self._native_backup_session is None - and native_target is not None) + native_pending = any(job.active and job.kind == 'native_session' for job in self._jobs.values()) + native_enabled = ready and self._native_backup_session is None and not native_pending and native_target is not None + self.native_backup_button.setEnabled(native_enabled) + self.native_repair_button.setEnabled(native_enabled) + reason = ('原生版本/修复窗口仍在使用或正在打开。' if self._native_backup_session is not None or native_pending else + '请选择一个当前可见的非 READY CBB。' if native_target is None else '') + self.native_repair_button.setToolTip(reason or '打开原生工具;请在其中手动选择 Repair。') ready = ready and not self._native_backup_same_library() self.batch_button.setEnabled(ready and bool(self._eligible_names())) self.selected_batch_button.setEnabled(ready and bool(self._eligible_names(checked_only=True))) @@ -422,7 +502,7 @@ class MainWindow(QWidget): self.icdb_stop_button.setEnabled(self._icdb_active() and not self.icdb_task.stop.is_set()) self.backup_restore_button.setEnabled(ready and bool( self._eligible_names(checked_only=bool(self.selected_records())))) - self.release_library_button.setEnabled(not self.busy and bool(self.lmc_edit.text().strip())) + self.release_library_button.setEnabled(not self._closing and bool(self.lmc_edit.text().strip())) waiting_library = self._queued_release_library() self.queue_release_button.setVisible(waiting_library is not None) self.queue_release_button.setEnabled(waiting_library is not None and not self._closing) @@ -431,7 +511,11 @@ class MainWindow(QWidget): if action is not None and isValid(action): queued_target = bool(waiting_library and _library_path_keys(waiting_library, task.path_lease) & _library_path_keys(task.requests[0].lmc_file, task.path_lease)) - action.setEnabled(not self._closing and (not self.busy or queued_target)) + action.setEnabled(self._summary_current(getattr(task,'summary',None)) and (not self.busy or queued_target)) + recovery = getattr(task,'recovery_action',None) + if recovery is not None and isValid(recovery): + recovery.setEnabled(not self.busy and self._summary_current(getattr(task,'summary',None)) + and not (getattr(task,'recovery_names',set()) & task.invalidated)) reasons = [] for operation, widget in (('add', self.add_button), ('update', self.update_button), ('remove', self.remove_button)): reason = self._management_block_reason(operation) @@ -443,15 +527,21 @@ class MainWindow(QWidget): current_library = _path_key(self.mentor_lmc_path or self.lmc_edit.text()) if self.lmc_edit.text().strip() else None notice = ('上次操作结果待复查,执行前将重新检查占用。' if self._management_library_unsafe(current_library) else '') + notice = '旧表已失效,请重新读取中心库。' if self._stale_table else notice self.library_notice.setText(notice) self.library_notice.setVisible(bool(notice)) for widget in (self.lmc_edit, self.browse_button, self.load_button, self.timeout_spin, self.advanced_toggle, self.advanced_panel): - widget.setEnabled(not self.busy) + widget.setEnabled(not self._closing) counts = self.visible_counts() self.counts_label.setText(f'可见 {counts["visible"]} / {len(self._records_by_name)} · ' f'READY {counts["ready"]} · 异常/待确认 {counts["error"]}') - self.stop_button.setEnabled((self.busy and self.loaded_path is not None and not self.stop.is_set()) + directory, native, missing = self._read_counts + if directory is not None: + self.counts_label.setText(self.counts_label.text() + + f' · 目录 {directory} · 原生 {native if native is not None else "未知"} · 缺工程 {missing or 0}') + self.stop_button.setEnabled(any(job.active and not job.context.stop.is_set() for job in self._jobs.values()) + or (self.busy and not self.stop.is_set()) or self._icdb_active() and not self.icdb_task.stop.is_set()) self.stop_button.setText('取消当前任务并停止队列') available = bool(self._reimport_offers) and not self.busy and self.management_capabilities['update'].supported @@ -459,20 +549,27 @@ class MainWindow(QWidget): self.reimport_button.setEnabled(available) self.reimport_button.setToolTip(self.management_capabilities['update'].reason) if self._reimport_summary_action is not None: - self._reimport_summary_action.setEnabled(available) + self._reimport_summary_action.setEnabled(available and self._summary_current(getattr(self,'_batch_summary',None))) if getattr(self, '_residual_release_action', None) is not None: - self._residual_release_action.setEnabled(not self.busy) + self._residual_release_action.setEnabled(not self.busy and self._summary_current(getattr(self,'_batch_summary',None))) if getattr(self, '_resume_batch_action', None) is not None: pending = getattr(self, '_resume_batch', None) same = bool(pending and _library_path_keys(pending['library'], self.library_lease) & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)) - self._resume_batch_action.setEnabled(not self.busy and same and pending['released']) + self._resume_batch_action.setEnabled(not self.busy and same and pending['released'] + and self._summary_current(getattr(self,'_batch_summary',None))) def _show_unfinished_management(self): from cbb_refresh_verify.management import unfinished_operations from cbb_refresh_verify.session_record import discover_sessions, handoff_session root = self.data_root - notify = self.signals.event.emit + revision, owner = self._view_revision, self._current_job + context = BatchTaskContext(str(root)) + self._lifecycle_contexts.add(context) + def notify(value): + if self._closing: return + try: self.signals.event.emit((revision, owner, value)) + except RuntimeError: pass def inspect(): unfinished = unfinished_operations(root/'management') sessions = discover_sessions(root) @@ -482,11 +579,14 @@ class MainWindow(QWidget): observe_only=True, progress=lambda value: notify({'stage': 'session_observation', **value})) return unfinished, sessions - worker = ServiceWorker(inspect) + worker = ServiceWorker(lambda:context.run(inspect)) self._lifecycle_workers.add(worker) - worker.signals.succeeded.connect(self._unfinished_sessions_ready) - worker.signals.failed.connect(self._display_error) - worker.signals.finished.connect(lambda: self._lifecycle_workers.discard(worker)) + def current(): + from shiboken6 import isValid + return (isValid(self) and not self._closing and revision == self._view_revision and owner is self._current_job) + worker.signals.succeeded.connect(lambda payload:self._unfinished_sessions_ready(payload) if current() else None) + worker.signals.failed.connect(lambda error:self._display_error(error) if current() else None) + worker.signals.finished.connect(lambda: (self._lifecycle_workers.discard(worker), self._lifecycle_contexts.discard(context))) self.lifecycle_pool.start(worker) def _unfinished_sessions_ready(self, payload): @@ -523,7 +623,7 @@ class MainWindow(QWidget): if queued and not allowed_queue: self._update() return - if (self.busy and not allowed_queue) or not self.lmc_edit.text().strip(): + if not self.lmc_edit.text().strip(): return from shiboken6 import isValid previous = getattr(self, 'release_dialog', None) @@ -532,16 +632,21 @@ class MainWindow(QWidget): return from .residual_release_dialog import ResidualReleaseDialog library = Path(self._queue_wait_library if allowed_queue else self.mentor_lmc_path or self.lmc_edit.text().strip()) - self._queue_release_mode = bool(allowed_queue and self.busy) + self._queue_release_mode = self.busy + revision, owner_job, lease = self._view_revision, self._current_job, self.library_lease self.release_dialog = ResidualReleaseDialog(library, self.data_root/'release-checks', self) + dialog = self.release_dialog + self._dialogs.append(dialog) self.release_dialog.native_queue = self.native_queue - if self._queue_release_mode: - from cbb_refresh_verify.network_path import release_retained_path_leases - lease = self.library_lease - self.release_dialog.release_finalizer = lambda proof: release_retained_path_leases(proof, current_lease=lease) - self.release_dialog.before_release.connect(self._stop_icdb_check) - self.release_dialog.released.connect(lambda result: self._complete_library_release(self.release_dialog.library, result)) - self.release_dialog.finished.connect(self._release_dialog_finished) + from cbb_refresh_verify.network_path import release_retained_path_leases + self.release_dialog.release_finalizer = lambda proof: release_retained_path_leases(proof, current_lease=lease) + release_check = self.icdb_task if self._check_matches_library(library) else None + self.release_dialog.before_release.connect(lambda:release_check.cancel() + if release_check is not None and release_check.active else None) + self.release_dialog.released.connect(lambda result: self._complete_library_release( + library, result, lease=lease, revision=revision)) + self.release_dialog.finished.connect(lambda *_:self._release_dialog_finished() + if revision == self._view_revision and owner_job is self._current_job else None) self.busy = True; self._update() self.release_dialog.show() @@ -558,33 +663,39 @@ class MainWindow(QWidget): self.summary = self._new_result_summary('_batch_summary') self.summary.setWindowTitle('继续未执行项') self._resume_batch_action = self.summary.addButton('继续未执行项', QMessageBox.ActionRole) - self._resume_batch_action.clicked.connect(self._resume_released_batch) + summary = self.summary + self._bind_summary_action(summary, self._resume_batch_action, self._resume_released_batch) self._update() self.summary.setText('会话已释放,可以继续未执行项。') self.summary.show() - def _complete_library_release(self, library, result): + def _complete_library_release(self, library, result, *, lease=None, revision=None): from cbb_refresh_verify.network_path import release_retained_path_leases + lease = self.library_lease if lease is None else lease + revision = self._view_revision if revision is None else revision + def ready(): + self._management_unsafe_libraries.discard(_path_key(library)) + if revision == self._view_revision and not self._closing: self._library_release_ready(library, result) try: if (not isinstance(result, dict) or result.get('status') != 'RELEASE_CONFIRMED' - or not (_library_path_keys(result.get('library'), self.library_lease) - & _library_path_keys(library, self.library_lease))): + or not (_library_path_keys(result.get('library'), lease) + & _library_path_keys(library, lease))): raise ValueError('RELEASE_PROOF_UNCONFIRMED: 释放证明未确认或不属于当前中心库。') except Exception as error: - self._failed(error) + if revision == self._view_revision: self._display_error(error) return if result.get('mapping_cleanup_complete') is True: - self._library_release_ready(library, result) + ready() return - lease = self.library_lease def release(): try: release_retained_path_leases(result, current_lease=lease) except Exception: if lease is not None: lease.retain_for_recovery() raise - self._lease_action(release, lambda _: self._library_release_ready(library, result), - self._display_error, hold_busy=True) + self._lease_action(release, lambda _: ready(), + lambda error:self._display_error(error) if revision == self._view_revision else None, + hold_busy=revision == self._view_revision, library=library, completed_always=True) def _library_release_ready(self, library, result): current_library = _path_key(self.mentor_lmc_path or self.lmc_edit.text().strip()) @@ -605,11 +716,12 @@ class MainWindow(QWidget): def _resume_released_batch(self): pending = getattr(self, '_resume_batch', None) if self.busy or not pending or not pending['released']: return + if pending.get('revision',self._view_revision) != self._view_revision: return if not (_library_path_keys(pending['library'], self.library_lease) & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): return self._resume_batch = None - self._run(pending['names'], maintenance=pending['maintenance']) + self._run(pending['names'], maintenance=pending['maintenance'], request_snapshot=pending.get('requests')) def _management_library_unsafe(self, library): if self._management_unsafe and self._management_unsafe_library is not None: @@ -653,22 +765,70 @@ class MainWindow(QWidget): def _open_management_dialog(self, requests, *, recovery_from=None): from .management_dialog import ManagementDialog self._global_icdb_run = False - self.stop.clear() + job = self._new_job('management', library=requests[0].library, targets=tuple(r.name for r in requests)) self._management_is_recovery = bool(recovery_from) self._management_operation_library = _path_key(requests[0].library) if requests else None requests = [replace(request, check_previous_release=True) if self._management_library_unsafe(request.library) else request for request in requests] - self.management_dialog = ManagementDialog(requests, self, adapter=self.management_adapter, + adapter = self.management_adapter + if hasattr(adapter, 'session_progress'): + from copy import copy + adapter = copy(adapter) + adapter.session_progress = lambda event:self._emit_job(job,'event',event) + self.management_dialog = ManagementDialog(requests, self, adapter=adapter, recovery_from=recovery_from) + dialog = self.management_dialog + self._dialogs.append(dialog) + dialog.ui_job = job + dialog.admit = lambda snapshot:self._admit_snapshot(job,snapshot) self.management_dialog.native_queue = self.native_queue self.management_dialog.release_requested.connect(self._open_waiting_release) - self.management_dialog.before_execute.connect(lambda names: self._invalidate_check_targets(requests[0].library, names)) + def started(names): + self._adopt_dialog_context(job, dialog) + self._invalidate_check_targets(requests[0].library, names) + self.management_dialog.before_execute.connect(started) self._management_results = [] - self.management_dialog.completed.connect(self._management_completed) - self.management_dialog.finished.connect(self._management_closed) + def completed(results): + job.submitted = False + job.results = tuple(results) + if self._job_current(job): self._management_completed(results) + else: self._stale_operation_results(job, results) + def closed(*_): + if self._job_current(job): self._management_closed() + self._finish_job(job) + self.management_dialog.completed.connect(completed) + self.management_dialog.finished.connect(closed) self.busy = True; self._update() self.management_dialog.show() + def _admit_snapshot(self, job, snapshot): + if any(other is not job and other.kind == job.kind and getattr(other,'submitted',False) + and getattr(other,'submitted_snapshot',None) == snapshot for other in self._jobs.values()): return False + job.submitted_snapshot, job.submitted = snapshot, True + return True + + def _adopt_dialog_context(self, job, dialog): + self._jobs.pop(job.context.operation_id, None) + job.context = dialog.context or job.context + job.active = True + self._jobs[job.context.operation_id] = job + if job.revision == self._view_revision and (self._job_current(job) or not self.busy): + self._current_job = job + self.stop = job.context.stop + + def _stale_operation_results(self, job, results): + # Housekeeping belongs to the submitted lease, even after a view switch. + unsafe = any(not result.safe_to_continue for result in results) + if unsafe: + self._management_unsafe_libraries.add(_path_key(job.context.library)) + if job.lease is not None: self._retain_path_lease(job.lease) + proofs = [getattr(result, 'release_proof', None) for result in results] + for proof in proofs: + if isinstance(proof, dict) and proof.get('status') == 'RELEASE_CONFIRMED': + from cbb_refresh_verify.network_path import release_retained_path_leases + self._lease_action(lambda proof=proof: release_retained_path_leases(proof, current_lease=job.lease), + library=job.context.library) + def _open_waiting_release(self, library): from cbb_refresh_verify.session_record import library_available if not library_available(library): @@ -836,32 +996,47 @@ class MainWindow(QWidget): path = QFileDialog.getOpenFileName(self, '选择中心库', '', 'LMC (*.lmc)')[0] if path: self.lmc_edit.setText(path); self.load_library() - def _start(self, action, callback, *, queued=True): - self.stop.clear() + def _start(self, action, callback, *, queued=True, job=None, metadata_only=False, bounded=True, stale=None): + job = job or self._new_job('action') self.busy = True; self._update() - self.worker = ServiceWorker(self._queued_action(action) if queued else action) - self.worker.signals.succeeded.connect(callback) - self.worker.signals.failed.connect(self._failed) - self.worker.signals.finished.connect(self._finished) + execute = (self._queued_action(action, job=job) if queued else + lambda: job.context.run(action, metadata_only=metadata_only)) if bounded else action + self.worker = ServiceWorker(execute) + worker = self.worker + self._lifecycle_workers.add(worker) + self.worker.signals.succeeded.connect(lambda value: callback(value) if self._job_current(job) + else stale(value) if stale is not None else None) + def failed(error): + if isinstance(error, TaskHandoff) and job.lease is not None: + self._retain_path_lease(job.lease) + if not self._job_current(job): return + if isinstance(error, QueueCancelled): self._display_error(error) + else: self._failed(error) + self.worker.signals.failed.connect(failed) + self.worker.signals.finished.connect(lambda: (self._lifecycle_workers.discard(worker), self._finish_job(job))) self.pool.start(self.worker) - def _queued_action(self, action, *, label='', library=None): + def _queued_action(self, action, *, label='', library=None, job=None): from cbb_refresh_verify.session_record import library_available, library_wait_reason if library is None: from PySide6.QtCore import QThread if QThread.currentThread() != self.thread(): raise RuntimeError('后台入队必须传入任务绑定的中心库路径') library = getattr(self, 'mentor_lmc_path', None) or self.lmc_edit.text() + job = job or self._current_job + stop = job.context.stop if job else self.stop + def emit(event): + if job: self._emit_job(job, 'event', event) + else: self.signals.event.emit(event) def execute(): event = {'stage': 'native_slot_acquired', 'library': str(library)} if label: event['detail'] = label+'中…' - self.signals.event.emit(event) + emit(event) return action() - return lambda: self.native_queue.run(execute, stop=self.stop, - ready=lambda: library_available(library), + return lambda: self.native_queue.run(execute, stop=stop, context=job.context if job else None, wait_state=lambda: library_wait_reason(library), - waiting=lambda: self.signals.event.emit({'stage': 'waiting_native_slot', + waiting=lambda: emit({'stage': 'waiting_native_slot', 'library': str(library), 'retained': not library_available(library), 'detail': (label+':' if label else '')+(library_wait_reason(library) or '已排队,等待当前原生操作结束')})) @@ -899,15 +1074,33 @@ class MainWindow(QWidget): & _library_path_keys(task.requests[0].lmc_file, task.path_lease)): task.update_statuses(statuses) - def _start_icdb_check(self, names): + def _start_icdb_check(self, names, *, request_snapshot=None): if self.busy or self._icdb_active() or not self.loaded_path or self._native_backup_same_library(): return eligible = set(self._maintenance_names()) names = [name for name in names if name in eligible] if not names: return from .icdb_check_task import IcdbCheckTask - requests = tuple(replace(self._request(name), maintenance=True, auto_repair=False) for name in names) + requests = (tuple(request for request in request_snapshot if request.block_name in names) if request_snapshot is not None + else tuple(replace(self._request(name), maintenance=True, auto_repair=False) for name in names)) + if not requests: return task = IcdbCheckTask(requests, self.native_queue, self.data_root/'reports', - verifier=self.verifier, path_lease=self.library_lease, parent=self) + verifier=self.verifier, path_lease=self.library_lease, parent=self, + status_reader=self.status_refresher if self.catalog_reader is not None else None) + previous_job = self._current_job + job = self._new_job('icdb', library=requests[0].lmc_file, targets=names) + self._current_job = previous_job + self._jobs.pop(job.context.operation_id, None) + job.context = task.context + self._jobs[job.context.operation_id] = job + task.ui_job = job + task.revision = self._view_revision + task.status_reader = self._execution_status_reader(task.context.operation_id, task.path_lease) + if self.verifier is None: + def verify_request(req): + from cbb_refresh_verify.verify_runner import run_verify + return run_verify(req, progress=task._emit_event, stop=task.stop, + version_prompt=lambda choice:self._emit_job(job,'version_choice',choice)) + task.verifier = verify_request task.records = {name: self._records_by_name[name] for name in names} self.icdb_task = task self.icdb_tasks.append(task) @@ -921,6 +1114,7 @@ class MainWindow(QWidget): task.start(); self._update() def _icdb_event(self, task, event): + if self._closing or getattr(task,'revision',self._view_revision) != self._view_revision: return name, stage = str(event.get('block', '')), str(event.get('stage', '')) detail = str(event.get('detail') or stage) self.icdb_phase.setText(f'{name} · '+({'icdb_check_start': '正在检查', @@ -934,6 +1128,9 @@ class MainWindow(QWidget): self.logging_context.logger.info('icdb_background block=%s stage=%s detail=%s', name, stage, detail) def _icdb_item_done(self, task, name, result): + if self._closing or getattr(task,'revision',self._view_revision) != self._view_revision: return + if result.error_category == 'ICDB_REPAIR_REQUIRED' and result.evidence_path: + self._diagnostic_evidence[name] = result.evidence_path.parent/'diagnostics'/'icdb-recovery.json' self.icdb_progress.setValue(len(task.results)) if not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): @@ -976,6 +1173,13 @@ class MainWindow(QWidget): held_by_native = self._native_backup_session is not None and self._native_backup_session.path_lease is lease if lease is not self.library_lease and not held_by_native: self._close_path_lease(lease) + job = getattr(task,'ui_job',None) + if job is not None: + job.lease = None # The explicit task lease cleanup above owns it. + self._finish_job(job) + if self._closing or getattr(task,'revision',self._view_revision) != self._view_revision: + self._update() + return for request, result in zip(task.requests, task.results): if result.status == 'SKIPPED': self._icdb_item_done(task, request.block_name, result) text = (f'ICDB 检查结束:未发现异常 {counts["checked_without_repair"]},发现问题 {counts["issues_found"]},' @@ -1001,28 +1205,37 @@ class MainWindow(QWidget): summary.setTextFormat(Qt.PlainText); summary.setAttribute(Qt.WA_ShowWithoutActivating) if any(not result.safe_to_continue for result in task.results): def release_task(): + if not self._summary_current(summary): return if not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): self.status_label.setText(f'请切回 {task.requests[0].lmc_file} 后释放该检查的残留。') return self.check_library_release(queued=self.busy) task.release_action = summary.addButton('查看残留并释放…', QMessageBox.ActionRole) - task.release_action.clicked.connect(release_task) + self._bind_summary_action(summary, task.release_action, release_task) if offers: action = summary.addButton('选择副本恢复…', QMessageBox.ActionRole) task.recovery_action = action task.recovery_names = {req.block_name for req, _, _ in offers} def recover(): + if not self._summary_current(summary): return if task.recovery_names & task.invalidated: return if self.busy or not (_library_path_keys(task.requests[0].lmc_file, task.path_lease) & _library_path_keys(self.mentor_lmc_path or self.loaded_path, self.library_lease)): return self._reimport_offers = offers self.reimport_failed() - action.clicked.connect(recover) + self._bind_summary_action(summary, action, recover) summary.show(); self._update() def load_library(self): - if self.busy or not self.lmc_edit.text(): return + if self._closing or not self.lmc_edit.text(): return + if (self._current_job is not None and self._current_job.kind == 'read' + and self._current_job.active and self._current_job.revision == self._view_revision): return + self._view_revision += 1 + self._diagnostic_evidence.clear() + self._stale_table = bool(self._records_by_name) + job = self._new_job('read', library=self.lmc_edit.text()) + job.lease = None self._maintenance_recovery_view = False self._global_icdb_run = False if self._management_unsafe_library is not None: @@ -1034,9 +1247,7 @@ class MainWindow(QWidget): if not self._icdb_active(): self.icdb_progress.hide(); self.icdb_phase.hide() self._release_library_lease() - self.loaded_path = None; self.cbb_table.setRowCount(0); self._row_by_name = {}; self.ready_names = set() - self._records_by_name = {} - self.skipped_names = set(); self.skip_reasons = {} + self.loaded_path = None path = self.lmc_edit.text() self.status_label.setText('正在读取中心库…') def read(): @@ -1058,6 +1269,7 @@ class MainWindow(QWidget): lease.remote_root or '-', lease.created) recovery_view = False result = self.reader(mentor_path) + job.context.check_active() if not result.error: self._publish_check_statuses(mentor_path, {record.name: record.status for record in result.records}, lease) @@ -1082,17 +1294,28 @@ class MainWindow(QWidget): finally: pythoncom.CoUninitialize() def loaded(payload): result, skip_reasons, lease, mentor_path, recovery_view = payload - if path != self.lmc_edit.text(): + if path != self.lmc_edit.text() or job.revision != self._view_revision: self._close_path_lease(lease) return if result.error: self._close_path_lease(lease) self.status_label.setText(result.error); return self.library_lease = lease + self._stale_table = False + self._read_counts = (result.directory_count, result.native_count, + result.missing_project_count if result.missing_project_count is not None else len(skip_reasons)) self._maintenance_recovery_view = recovery_view self.mentor_lmc_path = mentor_path self.loaded_path = path + try: + if self._settings_enabled: + self.data_root.mkdir(parents=True, exist_ok=True) + settings = self.data_root/'settings.json' + settings.write_text(json.dumps({'last_library': path}, ensure_ascii=False), encoding='utf-8') + except OSError as error: + self.output.append(f'无法保存上次路径:{error}') self.cbb_table.setRowCount(0) + self._row_by_name = {} self.ready_names = {r.name for r in result.records if r.status == 'READY' and r.name not in skip_reasons} self.skip_reasons = dict(skip_reasons) self.skipped_names = set(skip_reasons) @@ -1115,7 +1338,7 @@ class MainWindow(QWidget): self.cbb_table.setItem(row, 1, QTableWidgetItem(record.partition_name)) status_text = STATUS_LABELS.get(record.status, record.status) if record.name in self.skipped_names: - status_text += ' · 缺少工程/PCB' + status_text += ' · 未登记目录' if record.catalog_source == 'directory_only' else ' · 缺少工程/PCB' self.cbb_table.setItem(row, 2, QTableWidgetItem(status_text)) # Preflight touches each CBB's project and was previously run # synchronously in this GUI callback, making large libraries @@ -1146,11 +1369,81 @@ class MainWindow(QWidget): self.status_label.setText( f'已读取 {len(result.records)} 个 CBB,其中 Ready {ready_count} 个,' f'缺文件跳过 {len(self.skipped_names)} 个。{suffix}') + if result.directory_count is not None and not result.catalog_verified: + self.status_label.setText(f'目录发现 {result.directory_count} 项,原生记录数待复核。{suffix}') if recovery_view: self.status_label.setText('协调阻止恢复视图:仅按目录显示工程,状态未确认(UNKNOWN),不代表损坏。' '仅可明确执行 ICDB 维护或释放检查,其他写入与原生状态读取已禁用。') self._apply_filters() - self._start(read, loaded) + if self.catalog_reader is not None and not result.catalog_verified: + self._start_catalog(job, result, lease, mentor_path, loaded) + self._start(read, loaded, queued=False, job=job, metadata_only=True, + stale=lambda payload: self._close_path_lease(payload[2])) + + def _start_catalog(self, read_job, initial, lease, library, deliver): + from cbb_refresh_verify.models import CbbRecord, LibraryReadResult + context = BatchTaskContext(str(library), aliases=tuple(_library_path_keys(library, lease))) + job = SimpleNamespace(context=context, kind='catalog', revision=read_job.revision, + lease=lease, requests=(), records={}, active=True, keep_session=False) + self._jobs[context.operation_id] = job + def reconcile(): + catalog = self.catalog_reader(Path(library), self.data_root/'catalog'/context.operation_id) + if _path_key(catalog.library) != _path_key(library) or not catalog.safe_to_continue or catalog.flow != 1: + raise ValueError('CATALOG_UNCONFIRMED: 原生目录身份或退出未确认。') + native = {entry.name: entry for entry in catalog.entries if entry.partition == 'Logical-Physical'} + directories = {record.name: record for record in initial.records} + names = tuple(sorted(native.keys() | directories.keys())) + try: + statuses = self.status_refresher(tuple(native), Path(library)) + except Exception: + statuses = {name:'UNAVAILABLE' for name in native} + self._publish_check_statuses(library, statuses, lease) + records, reasons = [], {} + for name in names: + source = ('both' if name in native and name in directories else + 'native_only' if name in native else 'directory_only') + reason = ('CATALOG_NOT_REGISTERED: 仅发现目录,原生目录未登记。' if name not in native else + preflight_skip_reason(Path(library), name) or '') + if name not in directories and not reason: + reason = 'PROJECT_MISSING: 原生记录缺少工程目录。' + if reason: reasons[name] = reason + records.append(CbbRecord(name, native[name].partition if name in native else directories[name].partition_name, + status=statuses.get(name,'UNKNOWN'), catalog_source=source, + status_source='authoritative' if name in native else 'unknown', missing_reason=reason)) + context.check_active() + result = LibraryReadResult(tuple(records), directory_count=len(directories), native_count=len(native), + missing_project_count=sum(name in native for name in reasons), catalog_verified=True) + return result, reasons, lease, library, False + worker = ServiceWorker(lambda:self.native_queue.run(reconcile, context=context)) + self._lifecycle_workers.add(worker) + def completed(payload): + if self._job_current(read_job): deliver(payload) + def failed(error): + if self._job_current(read_job): + self.status_label.setText(f'目录已显示;原生目录未确认:{error}') + worker.signals.succeeded.connect(completed) + worker.signals.failed.connect(failed) + worker.signals.finished.connect(lambda:(self._lifecycle_workers.discard(worker),self._finish_job(job))) + self.pool.start(worker) + + def _execution_status_reader(self, operation_id, lease): + """Recheck registration once per submission and status at each admission.""" + catalog_reader, status_reader = self.catalog_reader, self.status_refresher + if catalog_reader is None: return None # Injected readers own their boundary. + evidence = self.data_root/'catalog-admission'/operation_id + registered = None + def read(names, library): + nonlocal registered + if registered is None: + catalog = catalog_reader(Path(library), evidence) + if (_path_key(catalog.library) != _path_key(library) or not catalog.safe_to_continue or catalog.flow != 1): + raise ValueError('CATALOG_UNCONFIRMED: 原生目录身份或退出未确认。') + registered = frozenset(entry.name for entry in catalog.entries if entry.partition == 'Logical-Physical') + statuses = dict(status_reader(tuple(name for name in names if name in registered), Path(library))) + statuses.update({name:'NOT_REGISTERED' for name in names if name not in registered}) + self._publish_check_statuses(library, statuses, lease) + return statuses + return read def _request(self, name): return VerifyRequest(Path(self.mentor_lmc_path or self.loaded_path), name, self.data_root/'evidence', @@ -1202,9 +1495,10 @@ class MainWindow(QWidget): _library_path_keys(library, lease or self.library_lease) & _library_path_keys(session.library, getattr(session, 'path_lease', None))) - def open_native_backup(self): + def open_native_backup(self, checked=False, *, mode='versions'): if self.busy or not self.loaded_path or self._native_backup_session is not None: return + if any(job.active and job.kind == 'native_session' for job in self._jobs.values()): return target = self._native_backup_target() if target is None: self.status_label.setText('请勾选一个非 READY CBB。') @@ -1212,74 +1506,101 @@ class MainWindow(QWidget): from cbb_refresh_verify.native_backup import launch_native_backup request = self._request(target.name) launcher = self.native_backup_launcher or launch_native_backup - self._global_icdb_run = False - self._reimport_offers = () - self.status_label.setText(f'正在打开 {request.block_name} 的版本与备份…') + job = self._new_job('native_session', library=request.lmc_file, targets=(target.name,)) paused_check = self.icdb_task if self._check_matches_library(request.lmc_file) else None + job.paused_check = paused_check if paused_check is not None: paused_check.pause(); paused_check.invalidate([request.block_name]) + self.status_label.setText(f'正在打开 {target.name} 的原生{ "修复工具" if mode == "repair" else "版本与备份" }…') def opened(session): - session.path_lease = self.library_lease + session.path_lease = job.lease + session.ui_job = job + job.keep_session = True self._native_backup_session = session + if self._closing: + if job.lease is not None: self._retain_path_lease(job.lease) + return self.native_backup_timer.start() - self.status_label.setText(f'正在打开 {session.block} 的原生备份窗口,请在其中选择版本。') - self.output.append(f'{session.block} · 原生版本与备份\n{session.job}') - self.busy = True; self._update() - self.stop.clear() - self.worker = ServiceWorker(self._queued_action(lambda: launcher(request))) - self.worker.signals.succeeded.connect(opened) - def failed(error): - self.status_label.setText(f'无法打开版本与备份:{error}') - if paused_check is not None: paused_check.resume() - self.worker.signals.failed.connect(failed) - self.worker.signals.finished.connect(self._finished) - self.pool.start(self.worker) + if self._job_current(job): + self.status_label.setText(f'{session.block} 的原生窗口已打开,请在其中手动操作。') + self.output.append(f'{session.block} · {mode}\n{session.job}') + self._update() + # Existing injected version launchers accept only the positional request. + diagnostic = self._diagnostic_evidence.get(target.name) if mode == 'repair' else None + def action(): + if diagnostic is not None: + diagnosis = json.loads(diagnostic.read_text('utf-8')) + database = diagnosis.get('database_path') + if not isinstance(database,str) or not database: + raise ValueError('诊断未绑定唯一数据库,请重新检查目标。') + return launcher(request, mode=mode, target_database=database) + return launcher(request, mode=mode) if mode != 'versions' else launcher(request) + self._start(action, opened, job=job, stale=opened) def _release_native_backup_session(self, session): - self._native_backup_session = None - if session.path_lease is not None and session.path_lease is not self.library_lease: + if self._native_backup_session is session: self._native_backup_session = None + job = getattr(session, 'ui_job', None) + if job is not None: + job.keep_session = False + self._finish_job(job) + elif session.path_lease is not None and session.path_lease is not self.library_lease: self._close_path_lease(session.path_lease) - if self._icdb_active(): self.icdb_task.resume() + self._update() def _poll_native_backup(self): session = self._native_backup_session - if session is None or self.busy or session.process.poll() is None: + if session is None or getattr(session, 'polling', False) or session.process.poll() is None: return + session.polling = True self.native_backup_timer.stop() + job = getattr(session, 'ui_job', None) + revision = self._view_revision + current = self._current_job same_library = self._native_backup_same_library() + context = BatchTaskContext(str(session.library)) + polling_foreground = not self.busy + if polling_foreground: + self.busy = True + self._update() def read_result(): - import json result = json.loads(session.job.with_name('result.json').read_text('utf-8')) - if (not self._native_backup_matches_library(result['library'], getattr(session, 'path_lease', None)) - or result['block'] != session.block): + aliases = _library_path_keys(session.library, session.path_lease) + if (not aliases & _library_path_keys(result.get('library'), session.path_lease) + or result.get('block') != session.block + or getattr(session,'operation_id','') and result.get('operation_id') != session.operation_id): raise ValueError('原生会话返回的工程身份不一致。') - refresh = (self._read_affected_records((session.block,), library=session.library) - if result.get('safe_to_continue') is True and same_library else None) - return result, refresh - def completed(payload): - result, refresh = payload + return result + def current_delivery(): + return (not self._closing and revision == self._view_revision and current is self._current_job + and same_library and (job is None or self._job_current(job))) + def completed(result): if result.get('safe_to_continue') is not True: unconfirmed(result.get('detail', '未取得会话释放结果。')) return + deliver = current_delivery() self._release_native_backup_session(session) - if refresh is not None: - self._apply_refreshed_records(refresh) - message = ('原生备份窗口已关闭。需要时可单独运行校验。' if result.get('status') == 'CLOSED' - else '原生备份操作未结束:' + result.get('detail', '请检查原生窗口。')) - self.status_label.setText(message) - self.output.append(f'{session.block} · {message}\n{session.job.with_name("result.json")}') - if same_library and session.block in self._row_by_name: - self.cbb_table.item(self._row_by_name[session.block], 3).setText(message) + if deliver: + message = ('原生窗口已关闭;恢复或修复结果仍需单独校验。' if result.get('status') == 'CLOSED' + else '原生操作未完成:'+str(result.get('detail') or result.get('status'))) + self.status_label.setText(message) + self.output.append(f'{session.block} · {result.get("status")}\n{session.job.with_name("result.json")}') + self.refresh_affected_records([session.block], callback=lambda _:self.status_label.setText(message)) def unconfirmed(error): - self.status_label.setText('原生窗口退出尚未确认,请关闭窗口后检查释放。') - self.output.append(f'{session.block} · 退出尚未确认:{error}\n{session.job}') - self.busy = True; self._update() - self.stop.clear() - self.worker = ServiceWorker(self._queued_action(read_result, library=session.library)) - self.worker.signals.succeeded.connect(completed) - self.worker.signals.failed.connect(unconfirmed) - self.worker.signals.finished.connect(self._finished) - self.pool.start(self.worker) + if session.path_lease is not None: self._retain_path_lease(session.path_lease) + if current_delivery(): + self.status_label.setText('原生窗口退出尚未确认,请检查释放。') + self.output.append(f'{session.block} · {error}\n{session.job}') + session.polling = False + worker = ServiceWorker(lambda:context.run(read_result, metadata_only=True)) + self._lifecycle_workers.add(worker) + worker.signals.succeeded.connect(completed) + worker.signals.failed.connect(unconfirmed) + worker.signals.finished.connect(lambda:self._lifecycle_workers.discard(worker)) + def finish_poll(): + if polling_foreground and revision == self._view_revision and current is self._current_job: + if not getattr(self, '_refreshing_records', False): self._finished() + worker.signals.finished.connect(finish_poll) + self.pool.start(worker) def restore_backup(self): if self.busy or not self.loaded_path or self._native_backup_same_library(): @@ -1288,15 +1609,35 @@ class MainWindow(QWidget): names = self._eligible_names(checked_only=bool(self.selected_records())) if not names: return - self.backup_dialog = BackupRecoveryDialog(names, self._backup_request, self) + requests = {name:self._request(name) for name in names} + job = self._new_job('recovery', targets=names) + def request(name): + if name not in requests: raise ValueError('目标不属于此恢复任务。') + if job.revision == self._view_revision: return self._backup_request(name) + return requests[name] + self.backup_dialog = BackupRecoveryDialog(names, request, self) + dialog = self.backup_dialog + self._dialogs.append(dialog) + dialog.ui_job = job + dialog.admit = lambda snapshot:self._admit_snapshot(job,snapshot) self.backup_dialog.native_queue = self.native_queue row = self.cbb_table.currentRow() if row >= 0 and self.cbb_table.item(row, 0).text() in names: self.backup_dialog.block_combo.setCurrentText(self.cbb_table.item(row, 0).text()) - self.backup_dialog.started.connect(self._backup_started) - self.backup_dialog.completed.connect(self._backup_completed) - self.backup_dialog.finished.connect(lambda _code: self._backup_dialog_closed()) - self.backup_dialog.setModal(True) + def started(name): + self._adopt_dialog_context(job, dialog) + if self._job_current(job): self._backup_started(name) + def completed(name, result): + job.submitted = False + if self._job_current(job): self._backup_completed(name, result) + else: self._stale_operation_results(job, [result]) + def closed(*_): + if self._job_current(job): self._backup_dialog_closed() + self._finish_job(job) + self.backup_dialog.started.connect(started) + self.backup_dialog.completed.connect(completed) + self.backup_dialog.finished.connect(closed) + self.backup_dialog.setWindowModality(Qt.NonModal) self.backup_dialog.show() def _backup_request(self, name): @@ -1341,8 +1682,8 @@ class MainWindow(QWidget): if not getattr(self, '_refreshing_records', False): self._finished() - def _run(self, names, *, maintenance=False): - if maintenance: return self._start_icdb_check(names) + def _run(self, names, *, maintenance=False, request_snapshot=None): + if maintenance: return self._start_icdb_check(names, request_snapshot=request_snapshot) if self.busy or not self.loaded_path: return if self._native_backup_same_library(): self.status_label.setText('请先关闭该库的版本与备份窗口。') @@ -1353,8 +1694,16 @@ class MainWindow(QWidget): self.status_label.setText('当前可见选择中没有可校验的非 READY CBB。') self._update() return - requests = [replace(self._request(name), maintenance=maintenance, auto_repair=False) for name in names] + requests = ([request for request in request_snapshot if request.block_name in names] if request_snapshot is not None + else [replace(self._request(name), maintenance=maintenance, auto_repair=False) for name in names]) + if not requests: return library = requests[0].lmc_file + if any(job.active and job.kind == 'verify' and job.requests == tuple(requests) + and _path_key(job.context.library) == _path_key(library) for job in self._jobs.values()): return + job = self._new_job('verify', library=library, targets=names) + job.requests = tuple(requests) + job.records = {name: self._records_by_name[name] for name in names} + eligibility_reader = self._execution_status_reader(job.context.operation_id, job.lease) self._batch_requests = tuple(requests) self._batch_records = {name: self._records_by_name[name] for name in names} self._reimport_offers = () @@ -1367,48 +1716,58 @@ class MainWindow(QWidget): self.icdb_progress.setValue(0) self.icdb_progress.setFormat('已处理 %v / %m 个 CBB') self.icdb_phase.setText('准备检查…') - self.stop.clear(); self.recovery_path = None; self.recovery_button.setEnabled(False) + self.recovery_path = None; self.recovery_button.setEnabled(False) self.output.clear(); self.status_label.setText( f'正在 ICDB 批量检查:共 {len(names)} 个 CBB' if maintenance else f'正在校验:共 {len(names)} 个 CBB') def action(): from cbb_refresh_verify.verify_runner import read_library_flag_if_available, run_verify verify = self.verifier or (lambda req: run_verify( - req, progress=lambda e: self.signals.event.emit(e), + req, progress=lambda e: self._emit_job(job, 'event', e), flag_reader=read_library_flag_if_available, - version_prompt=self.signals.version_choice.emit, stop=self.stop)) + version_prompt=lambda choice: self._emit_job(job, 'version_choice', choice), stop=job.context.stop)) def verifier(req): + if eligibility_reader is not None: + statuses = eligibility_reader((req.block_name,), req.lmc_file) + self._publish_check_statuses(req.lmc_file, statuses, job.lease) + if statuses.get(req.block_name) == 'READY': + from cbb_refresh_verify.verify_runner import VerifyResult + return VerifyResult('SKIPPED', stderr='工程已为 READY,未执行校验。') + if statuses.get(req.block_name) == 'NOT_REGISTERED': + from cbb_refresh_verify.verify_runner import VerifyResult + return VerifyResult('SKIPPED', stderr='仅发现目录,原生目录未登记此 CBB。') if maintenance: - self.signals.event.emit({'block': req.block_name, 'stage': 'icdb_check_start'}) + self._emit_job(job, 'event', {'block': req.block_name, 'stage': 'icdb_check_start'}) return verify(req) - results = run_batch(requests, verifier=verifier, stop=self.stop, - item_executor=lambda req, action: self._queued_action(action, library=req.lmc_file)(), - progress=lambda name, result: self.signals.event.emit({'block': name, 'stage': result.status, + results = run_batch(requests, verifier=verifier, stop=job.context.stop, context=job.context, + item_executor=lambda req, action: self._queued_action(action, library=req.lmc_file, job=job)(), + progress=lambda name, result: self._emit_job(job, 'event', {'block': name, 'stage': result.status, 'error_category': result.error_category, 'evidence': str(result.evidence_path or ''), 'detail': result.stderr or result.stdout})) report = None try: - report = write_batch_report(requests, results, self.data_root/'reports') + report = BatchTaskContext(str(library)).run(lambda: + write_batch_report(requests, results, self.data_root/'reports')) if maintenance: from cbb_refresh_verify.icdb_maintenance import write_maintenance_report write_maintenance_report(requests, results, report, ()) except Exception as error: - self.signals.event.emit({'stage': 'report_failed', 'detail': str(error)}) + self._emit_job(job, 'event', {'stage': 'report_failed', 'detail': str(error)}) affected = [req.block_name for req, result in zip(requests, results) if result.status != 'SKIPPED'] safe = all(result.safe_to_continue for result in results) - self.signals.batch_ready.emit((results, report)) + self._emit_job(job, 'batch_ready', (results, report)) refresh = None - if safe and not self.stop.is_set(): + if safe and not job.context.stop.is_set(): from cbb_refresh_verify.operation_queue import QueueCancelled try: - refresh = self._queued_action(lambda: self._read_affected_records(affected, library=library), - label='批次已结束,状态刷新', library=library)() + refresh = self._queued_action(lambda: self._read_affected_records(affected, library=library, lease=job.lease), + label='批次已结束,状态刷新', library=library, job=job)() except QueueCancelled: pass # Cancelling the refresh must not erase completed item results. return results, report, affected, refresh - self._start(action, self._batch_refreshed, queued=False) + self._start(action, self._batch_refreshed, queued=False, job=job, bounded=False) - def _read_affected_records(self, names, *, library): + def _read_affected_records(self, names, *, library, lease=None): """Worker-only read; never derive library state from action outcomes.""" import pythoncom pythoncom.CoInitialize() @@ -1417,7 +1776,7 @@ class MainWindow(QWidget): try: statuses = self.status_refresher(tuple(names), path) # Publish before yielding the native queue, ahead of Qt callbacks. - self._publish_check_statuses(path, statuses) + self._publish_check_statuses(path, statuses, lease) reasons = {name: reason for name in names if (reason := preflight_skip_reason(path, name))} return tuple(names), statuses, reasons, '' @@ -1491,11 +1850,20 @@ class MainWindow(QWidget): self._refreshing_records = False if callback: callback(records) - library = self.mentor_lmc_path or self.loaded_path - self._start(lambda: self._read_affected_records(targets, library=library), refreshed) + library, lease = self.mentor_lmc_path or self.loaded_path, self.library_lease + self._start(lambda: self._read_affected_records(targets, library=library, lease=lease), refreshed) return True def _progress(self, event): + if isinstance(event, tuple): + if len(event) == 3: + revision, owner, event = event + if self._closing or revision != self._view_revision or owner is not self._current_job: return + library = self.mentor_lmc_path or self.loaded_path + if not library or not _library_path_keys(library,self.library_lease) & _library_path_keys(event.get('library')): return + else: + job, event = event + if not self._job_current(job): return from shiboken6 import isValid if not isValid(self) or not isValid(self.cbb_table): return @@ -1559,6 +1927,10 @@ class MainWindow(QWidget): if previous is not None: previous.close() summary = QMessageBox(self) + summary.view_revision = self._view_revision + summary.operation_job = self._current_job + summary.dismissed = False + summary.setWindowModality(Qt.NonModal) summary.setStandardButtons(QMessageBox.Close) arm_default(summary, summary.button(QMessageBox.Close)) setattr(self, attribute, summary) @@ -1566,7 +1938,19 @@ class MainWindow(QWidget): summary.finished.connect(lambda _: self._forget_result_summary(summary)) return summary + def _summary_current(self, summary): + from shiboken6 import isValid + return (summary is not None and isValid(summary) and not self._closing and not summary.dismissed + and summary.view_revision == self._view_revision and summary.operation_job is self._current_job) + + def _bind_summary_action(self, summary, button, callback): + # QMessageBox closes ActionRole buttons before their own clicked slots; + # its buttonClicked signal still carries the live notification identity. + summary.buttonClicked.connect(lambda clicked:callback() + if clicked is button and self._summary_current(summary) else None) + def _forget_result_summary(self, summary): + summary.dismissed = True if getattr(self, '_batch_summary', None) is summary: self._reimport_summary_action = None self._residual_release_action = None @@ -1596,7 +1980,17 @@ class MainWindow(QWidget): else '批次已结束。') def _batch_done(self, outcome): + bound_job = None + if isinstance(outcome, tuple) and outcome and hasattr(outcome[0], 'context'): + job, outcome = outcome + bound_job = job + if job.lease is not None and any(not result.safe_to_continue for result in outcome[0]): + self._retain_path_lease(job.lease, hold_busy=self._job_current(job)) + if not self._job_current(job): return results, report = outcome[:2] + for request, result in zip(bound_job.requests if bound_job is not None else self._batch_requests, results): + if result.error_category == 'ICDB_REPAIR_REQUIRED' and result.evidence_path: + self._diagnostic_evidence[request.block_name] = result.evidence_path.parent/'diagnostics'/'icdb-recovery.json' failure_report = failure_report_path(report) if report is not None else '未写入' report = report if report is not None else '未写入' from cbb_refresh_verify.reimport_recovery import offers_reimport @@ -1604,10 +1998,10 @@ class MainWindow(QWidget): for req, result in zip(self._batch_requests, results) if req.maintenance and req.block_name in self._batch_records and offers_reimport(result)) self._batch_refreshed(outcome) - if self.library_lease is not None and any(not result.safe_to_continue for result in results): + if bound_job is None and self.library_lease is not None and any(not result.safe_to_continue for result in results): self._retain_path_lease(self.library_lease, hold_busy=True) for result in results: - if not result.safe_to_continue and result.evidence_path: + if result.evidence_path and result.status not in ('PASS', 'SKIPPED', 'CHECKED'): self.recovery_path = result.evidence_path.parent self.recovery_button.setEnabled(self.recovery_path.is_dir()) passed = sum(r.status == 'PASS' for r in results) @@ -1652,6 +2046,7 @@ class MainWindow(QWidget): status_text += guidance self.status_label.setText(status_text.replace('\n', ' ')); self.output.append(text) self.summary = self._new_result_summary('_batch_summary') + summary = self.summary self.summary.setWindowTitle('ICDB 批量检查结果' if self._global_icdb_run else 'CBB 校验结果') self.summary.setText(status_text) self.summary.setDetailedText(text) @@ -1662,19 +2057,21 @@ class MainWindow(QWidget): self._resume_batch = None if any(not result.safe_to_continue for result in results): self._residual_release_action = self.summary.addButton('查看残留并释放…', QMessageBox.ActionRole) - self._residual_release_action.clicked.connect(self.check_library_release) + self._bind_summary_action(summary, self._residual_release_action, self.check_library_release) self._residual_release_action.setEnabled(False) names = [req.block_name for req, result in zip(self._batch_requests, results) if result.status == 'SKIPPED'] if names: self._resume_batch = {'library': self._batch_requests[0].lmc_file, 'names': names, - 'maintenance': self._global_icdb_run, 'released': False} + 'maintenance': self._global_icdb_run, 'released': False, + 'revision':self._view_revision, + 'requests':tuple(req for req in self._batch_requests if req.block_name in names)} self._resume_batch_action = self.summary.addButton('继续未执行项', QMessageBox.ActionRole) - self._resume_batch_action.clicked.connect(self._resume_released_batch) + self._bind_summary_action(summary, self._resume_batch_action, self._resume_released_batch) self._resume_batch_action.setEnabled(False) if self._reimport_offers: self._reimport_summary_action = self.summary.addButton('选择副本恢复…', QMessageBox.ActionRole) - self._reimport_summary_action.clicked.connect(self.reimport_failed) + self._bind_summary_action(summary, self._reimport_summary_action, self.reimport_failed) self._reimport_summary_action.setEnabled(False) # Enabled after the worker finishes. # Modeless notification: do not force activation or steal keyboard focus. from PySide6.QtCore import Qt @@ -1684,7 +2081,11 @@ class MainWindow(QWidget): def _show_version_choice(self, choice): from .pcb_restore_dialog import PcbRestoreDialog - if not self.busy or self.stop.is_set(): + job = None + if isinstance(choice, tuple): job, choice = choice + active = (job.active and self._jobs.get(job.context.operation_id) is job and not job.context.stop.is_set() + if job else self.busy and not self.stop.is_set()) + if self._closing or not active: choice.choose('cancel') return from ..pcb_open_consent import OpenChoice @@ -1699,13 +2100,19 @@ class MainWindow(QWidget): dialog_class = (WriteOwnerDialog if isinstance(choice,WriteOwnerChoice) else PcbOpenDialog if isinstance(choice,OpenChoice) else PcbRestoreDialog) self.version_dialog = dialog_class(choice,parent) + self.version_dialog.ui_job = job detail = ('等待确认库未被其他程序使用' if isinstance(choice,WriteOwnerChoice) else '等待读写打开确认' if isinstance(choice,OpenChoice) else '等待选择 PCB 恢复版本') - self.status_label.setText(f'{choice.block}:{detail}。') - self.icdb_phase.setText(f'{choice.block} · {detail}') + if job is None or self._job_current(job): + self.status_label.setText(f'{choice.block}:{detail}。') + self.icdb_phase.setText(f'{choice.block} · {detail}') self.version_dialog.show() def request_stop(self): + for job in tuple(self._jobs.values()): + job.context.cancel() + if job.kind == 'read': job.context.close(timeout_seconds=0) + self.native_queue.wake() if self._icdb_active(): self._stop_icdb_check() if not self.busy: return @@ -1729,7 +2136,8 @@ class MainWindow(QWidget): def _finished(self): if self._defer_mapping_finish(self._finished): return - if self.version_dialog is not None: + choice_job = getattr(self.version_dialog, 'ui_job', None) + if self.version_dialog is not None and (choice_job is None or not choice_job.active or choice_job.context.stop.is_set()): self.version_dialog.reject() self.version_dialog = None # Foreground completion must not erase an independent check's wait. @@ -1741,8 +2149,8 @@ class MainWindow(QWidget): def open_logs(self): try: - self.data_root.mkdir(parents=True, exist_ok=True) - os.startfile(str(self.data_root)) + (self.data_root/'logs').mkdir(parents=True, exist_ok=True) + os.startfile(str(self.data_root/'logs')) except Exception as error: self._display_error(error) @@ -1756,12 +2164,23 @@ class MainWindow(QWidget): event.accept() elif self._closing: event.ignore() - elif self._icdb_active(): - self._stop_icdb_check(); event.ignore() - elif self.busy: - self.request_stop(); event.ignore() else: self._closing = True + self._close_started = time.monotonic() + for job in tuple(self._jobs.values()): + job.context.close(timeout_seconds=0) + for context in tuple(self._lease_contexts): context.close(timeout_seconds=0) + for context in tuple(self._lifecycle_contexts): context.close(timeout_seconds=0) + self.native_queue.wake() + for task in self.icdb_tasks: + if task.active: task.cancel() + if self.version_dialog is not None: self.version_dialog.reject() + for name in ('management_dialog', 'backup_dialog', 'release_dialog'): + dialog = getattr(self, name, None) + if dialog is not None and getattr(dialog, 'busy', False): + dialog.stop.set() + context = getattr(dialog, 'context', None) + if context is not None: context.close(timeout_seconds=0) self.busy = True; self._update() self.setWindowTitle('CBB 刷新校验 · 等待任务安全结束') self.status_label.setText('正在等待当前操作安全结束,完成后关闭。') @@ -1784,19 +2203,30 @@ class MainWindow(QWidget): self.status_label.setText('当前操作尚未结束,仍在等待安全关闭。') def _close_when_idle(self): - owners = [self, *self.icdb_tasks] + owners = [self, *self.icdb_tasks, *self._dialogs] for name in ('management_dialog', 'backup_dialog', 'release_dialog'): owners.append(getattr(self, name, None)) - active = bool(self.lifecycle_pool.activeThreadCount()) + active = bool(self._lifecycle_workers or self.lifecycle_pool.activeThreadCount() or self.lease_pool.activeThreadCount()) for owner in owners: try: pool = getattr(owner, 'pool', None) active = active or bool(pool is not None and pool.activeThreadCount()) except RuntimeError: pass # Qt may already have deleted a closed dialog's pool. - if self._lease_pending or active: + if (self._lease_pending or active) and time.monotonic()-getattr(self,'_close_started',time.monotonic()) < 30: QTimer.singleShot(20, self._close_when_idle) return + if active: + for pool in (self.lifecycle_pool, self.lease_pool): + pool.setParent(None) + _shutdown_pools.add(pool) + for owner in owners: + pool = getattr(owner, 'pool', None) + if pool is not None: + try: + pool.setParent(None) + _shutdown_pools.add(pool) + except RuntimeError: pass self.close_wait_timer.stop() self._close_ready = True self.close() diff --git a/src/cbb_refresh_verify/ui/management_dialog.py b/src/cbb_refresh_verify/ui/management_dialog.py index de42829..581dc68 100644 --- a/src/cbb_refresh_verify/ui/management_dialog.py +++ b/src/cbb_refresh_verify/ui/management_dialog.py @@ -1,7 +1,6 @@ """Explicit preview and asynchronous, checkpointed CBB management batch.""" from dataclasses import replace from pathlib import Path -from threading import Event from PySide6.QtCore import QObject, QThreadPool, Signal, Qt from PySide6.QtWidgets import (QCheckBox, QDialog, QFileDialog, QHBoxLayout, QLabel, @@ -11,6 +10,7 @@ from .workers import ServiceWorker from .backup_notice import MANUAL_BACKUP_NOTICE from . import timed_prompt from ..management import run_management_batch +from ..operation_queue import BatchTaskContext RESULT_LABELS = { 'REMOVED': '已移除', 'UPLOADED': '已上传 / 未自动校验', @@ -59,12 +59,16 @@ class ManagementDialog(QDialog): evidence_dir=self.template.evidence_dir.parent/'reimport-recovery', **kwargs) self.busy = False self.executed = False - self.stop = Event() + self.context = BatchTaskContext(str(self.template.library)) + self.stop = self.context.stop + self.ui_job = None + self.admit = None + self.setWindowModality(Qt.NonModal) self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1) self.signals = ManagementSignals(self) self.signals.progress.connect(self._progress) - if parent is not None and hasattr(parent, '_show_version_choice'): - self.signals.choice.connect(parent._show_version_choice) + self._choice_handler = getattr(parent, '_show_version_choice', None) + self.signals.choice.connect(self._choice) self.setWindowTitle({'add': '新增 CBB', 'update': '同名更新 CBB', 'remove': '移除 CBB'}[self.operation]) self.resize(850, 450) self.table = QTableWidget(0, 4) @@ -96,7 +100,7 @@ class ManagementDialog(QDialog): self.execute_button = QPushButton('预览并确认执行…') self.execute_button.clicked.connect(self._execute) self.stop_button = QPushButton('当前项结束后停止'); self.stop_button.setEnabled(False) - self.stop_button.clicked.connect(self.stop.set) + self.stop_button.clicked.connect(lambda:self.stop.set()) self.close_button = QPushButton('关闭'); self.close_button.clicked.connect(self.reject) layout = QVBoxLayout(self) layout.addWidget(QLabel(f'目标库:{self.template.library}')) @@ -170,44 +174,67 @@ class ManagementDialog(QDialog): QMessageBox.Yes) if answer != QMessageBox.Yes: return + if self.admit is not None and not self.admit(tuple(requests)): + self.status_label.setText('相同任务已提交,未重复执行。') + return + self.context = BatchTaskContext(str(self.template.library), targets=tuple(r.name for r in requests)) + context = self.context + self.stop = context.stop self.busy = True; self.executed = True self._enabled(False) self.before_execute.emit([r.name for r in requests]) def execute(): - choices={'version_prompt':self.signals.choice.emit} if self.runner is run_management_batch or self.recovery_from else {} - action = lambda: self.runner(requests, adapter=self.adapter, stop=self.stop, - progress=self.signals.progress.emit,**choices) - if self.native_queue is None: return action() + choices={'version_prompt':lambda choice:self._emit(context, 'choice',choice)} if self.runner is run_management_batch or self.recovery_from else {} + action = lambda: self.runner(requests, adapter=self.adapter, stop=context.stop, + progress=lambda event:self._emit(context, 'progress',event),**choices) + if self.native_queue is None: return context.run(action) from ..operation_queue import QueueCancelled from ..session_record import library_available, library_wait_reason try: if self.runner is run_management_batch: def item(request, action): - return self.native_queue.run(action, stop=self.stop, - ready=lambda: library_available(request.library), + return self.native_queue.run(action, stop=context.stop, context=context, wait_state=lambda: library_wait_reason(request.library), - waiting=lambda: self.signals.progress.emit({'stage': 'waiting_native_slot', + waiting=lambda: self._emit(context, 'progress',{'stage': 'waiting_native_slot', 'retained': not library_available(request.library), 'detail': library_wait_reason(request.library) or '已排队,等待当前原生操作结束'})) - return self.runner(requests, adapter=self.adapter, stop=self.stop, - progress=self.signals.progress.emit, item_executor=item, - version_prompt=self.signals.choice.emit) - return self.native_queue.run(action, stop=self.stop, waiting=lambda: self.signals.progress.emit( + return self.runner(requests, adapter=self.adapter, stop=context.stop, + progress=lambda event:self._emit(context, 'progress',event), item_executor=item, + version_prompt=lambda choice:self._emit(context, 'choice',choice), context=context) + return self.native_queue.run(action, stop=context.stop, context=context, waiting=lambda: self._emit(context, 'progress', {'stage': 'waiting_native_slot', 'retained': not library_available(self.template.library), 'detail': library_wait_reason(self.template.library) or '已排队,等待当前检查结束'}), - ready=lambda: library_available(self.template.library), wait_state=lambda: library_wait_reason(self.template.library)) except QueueCancelled as error: + from ..operation_queue import TaskHandoff from ..management import ManagementResult return [ManagementResult(r.operation, r.library, r.name, r.partition, r.source, r.auto_verify, - 'complete', 'BLOCKED', True, str(error)) for r in requests] + 'complete', 'RECOVERY_REQUIRED' if isinstance(error,TaskHandoff) else 'CANCELLED', + not isinstance(error,TaskHandoff), str(error)) for r in requests] self.worker = ServiceWorker(execute) - self.worker.signals.succeeded.connect(self._result) - self.worker.signals.failed.connect(self._failed) - self.worker.signals.finished.connect(self._finished) + self.worker.signals.succeeded.connect(context.guard_callback(self._result, current=lambda:self.context)) + self.worker.signals.failed.connect(context.guard_callback(self._failed, current=lambda:self.context)) + self.worker.signals.finished.connect(lambda:self._finished() if self.context is context else None) self.pool.start(self.worker) + def _emit(self, context, signal, value): + if context is not self.context or not self.busy or signal == 'choice' and context.stop.is_set(): + if signal == 'choice': value.choose('cancel') + return + try: + delivered = context.guard_callback(lambda:getattr(self.signals, signal).emit((context,value)) or True)() + if not delivered and signal == 'choice': value.choose('cancel') + except RuntimeError: + if signal == 'choice': value.choose('cancel') + + def _choice(self, payload): + context, choice = payload + if context is not self.context or not self.busy or context.stop.is_set() or self._choice_handler is None: + choice.choose('cancel') + return + self._choice_handler((self.ui_job,choice) if self.ui_job else choice) + def _enabled(self, enabled): for widget in (self.table, self.sources_button, self.auto_verify, self.close_button): widget.setEnabled(enabled) @@ -215,6 +242,9 @@ class ManagementDialog(QDialog): self.stop_button.setEnabled(not enabled) def _progress(self, event): + if isinstance(event, tuple): + context, event = event + if context is not self.context or not self.busy: return stage = str(event.get('stage', '')) self.release_wait_button.setVisible(stage == 'waiting_native_slot' and bool(event.get('retained'))) text = f'{event.get("block", "")} {STAGE_LABELS.get(stage, RESULT_LABELS.get(stage, "正在处理"))}' diff --git a/src/cbb_refresh_verify/ui/residual_release_dialog.py b/src/cbb_refresh_verify/ui/residual_release_dialog.py index 2d7dee6..2bde690 100644 --- a/src/cbb_refresh_verify/ui/residual_release_dialog.py +++ b/src/cbb_refresh_verify/ui/residual_release_dialog.py @@ -2,13 +2,14 @@ from pathlib import Path from threading import Event -from PySide6.QtCore import QThreadPool, Signal +from PySide6.QtCore import QThreadPool, Signal, Qt from PySide6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QTableWidget, QTableWidgetItem, QHeaderView, QMessageBox) from .workers import ServiceWorker from .timed_prompt import arm_default from . import timed_prompt +from ..operation_queue import BatchTaskContext from ..residual_sessions import force_block_reason, release_targets_complete @@ -24,10 +25,12 @@ class ResidualReleaseDialog(QDialog): self.release_finalizer = None self.busy = False self.stop = Event() + self.context = None + self._workers = set() self._refresh_after = False self.pool = QThreadPool(self) self.setWindowTitle('释放残留会话') - self.setModal(True) + self.setWindowModality(Qt.NonModal) self.resize(1040, 400) layout = QVBoxLayout(self) self.message = QLabel('正在检查当前库关联的会话…') @@ -66,6 +69,8 @@ class ResidualReleaseDialog(QDialog): self.refresh() def _start(self, action, completed): + context = BatchTaskContext(str(self.library)) + self.context, self.stop = context, context.stop self.busy = True self.confirm_button.setEnabled(False) self.refresh_button.setEnabled(False) @@ -73,10 +78,12 @@ class ResidualReleaseDialog(QDialog): self.force_button.setEnabled(False) self.cancel_native_button.setEnabled(False) self.close_button.setText('停止释放') - self.worker = ServiceWorker(action) - self.worker.signals.succeeded.connect(completed) - self.worker.signals.failed.connect(lambda error: self.message.setText(str(error))) - self.worker.signals.finished.connect(self._finished) + self.worker = ServiceWorker(lambda:context.run(action)) + worker = self.worker + self._workers.add(worker) + self.worker.signals.succeeded.connect(context.guard_callback(completed, current=lambda:self.context)) + self.worker.signals.failed.connect(context.guard_callback(lambda error: self.message.setText(str(error)), current=lambda:self.context)) + self.worker.signals.finished.connect(lambda:(self._workers.discard(worker), self._finished() if self.context is context else None)) self.pool.start(self.worker) def _finished(self): @@ -130,6 +137,7 @@ class ResidualReleaseDialog(QDialog): details.extend(c.get('text', '') for c in window.get('children', []) if c.get('class') == 'Static') box.setDetailedText('\n'.join(details)) + box.setWindowModality(Qt.NonModal) box.setStandardButtons(QMessageBox.Close) arm_default(box, box.button(QMessageBox.Close)) box.show() @@ -146,7 +154,7 @@ class ResidualReleaseDialog(QDialog): QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes) if answer != QMessageBox.Yes: return from cbb_refresh_verify.residual_sessions import request_native_cancel - self.before_release.emit(); self.stop.clear() + self.before_release.emit(); self.stop = Event() def execute(): action = lambda: self._finalize_release_result( request_native_cancel(session, self.library, self.evidence_dir, stop=self.stop)) @@ -246,7 +254,7 @@ class ResidualReleaseDialog(QDialog): def confirm_release(self, checked=False, *, force=False): if self.busy or self.plan is None: return from cbb_refresh_verify.library_lock import release_residual_sessions - self.stop.clear() + self.stop = Event() plan = self.plan self.before_release.emit() self.message.setText('正在逐项释放,请稍候…') diff --git a/src/cbb_refresh_verify/ui/timed_prompt.py b/src/cbb_refresh_verify/ui/timed_prompt.py index 264afed..1cbcaf1 100644 --- a/src/cbb_refresh_verify/ui/timed_prompt.py +++ b/src/cbb_refresh_verify/ui/timed_prompt.py @@ -45,7 +45,8 @@ class _Countdown(QObject): def stop(self): self.done = True self.timer.stop() - self.button.setText(self.label) + from shiboken6 import isValid + if isValid(self.button): self.button.setText(self.label) @Slot() def tick(self): @@ -57,6 +58,7 @@ class _Countdown(QObject): self.button.setText(f'{self.label}({ceil(remaining / 1000)} 秒)') return self.timer.stop() + self.done = True if not self.button.isEnabled(): self.box.setProperty('selectionOrigin', 'timeout_default') self.box.reject() diff --git a/tests/test_all_buttons.py b/tests/test_all_buttons.py index 3bfaa08..6987e22 100644 --- a/tests/test_all_buttons.py +++ b/tests/test_all_buttons.py @@ -130,7 +130,7 @@ def test_main_logs_and_evidence_buttons_open_the_correct_paths(controls, qtbot): w.recovery_path = evidence w.recovery_button.setEnabled(True) press(qtbot, w.recovery_button) - assert controls.opened == [w.data_root, evidence] + assert controls.opened == [w.data_root/'logs', evidence] @pytest.mark.parametrize('attribute', ['selected_batch_button', 'batch_button', 'icdb_repair_button']) diff --git a/tests/test_background_icdb.py b/tests/test_background_icdb.py index da9507f..c1f5260 100644 --- a/tests/test_background_icdb.py +++ b/tests/test_background_icdb.py @@ -69,9 +69,10 @@ def test_completed_old_library_result_does_not_release_new_library(qtbot, tmp_pa qtbot.waitUntil(lambda: not window._icdb_active()) summary = window.icdb_summary window.lmc_edit.setText('other.lmc') + message = window.status_label.text() next(button for button in summary.buttons() if '释放' in button.text()).click() assert getattr(window, 'release_dialog', None) is None - assert '切' in window.status_label.text() + assert window.status_label.text() == message def test_later_management_invalidates_old_recovery_offer(qtbot, tmp_path, monkeypatch): @@ -109,4 +110,4 @@ def test_check_release_action_tracks_busy_and_retained_queue(qtbot, tmp_path, mo assert opened == [{'queued': True}] window.busy = False window._update() - assert action.isEnabled() + assert not action.isEnabled(), 'A dismissed one-shot result cannot be reactivated' diff --git a/tests/test_issue15_metadata_context.py b/tests/test_issue15_metadata_context.py new file mode 100644 index 0000000..cb60498 --- /dev/null +++ b/tests/test_issue15_metadata_context.py @@ -0,0 +1,38 @@ +from threading import Event +import pytest +from cbb_refresh_verify.operation_queue import BatchTaskContext, TaskHandoff, native_phase + + +def test_metadata_can_refresh_while_abandoned_native_scope_stays_protected(): + entered, release = Event(), Event() + old = BatchTaskContext('a.lmc') + def stalled(): + entered.set(); release.wait(3) + try: + with pytest.raises(TaskHandoff): old.run(stalled, timeout_seconds=.01) + assert entered.is_set() + new = BatchTaskContext('a.lmc') + assert new.run(lambda: 'metadata', metadata_only=True) == 'metadata' + with pytest.raises(TaskHandoff): new.run(lambda: 'native') + finally: + release.set(); old.close(timeout_seconds=1) + + +def test_metadata_cannot_escalate_into_native_phase(): + context = BatchTaskContext('a.lmc') + def escalate(): + with native_phase(): + pytest.fail('metadata admitted native action') + with pytest.raises(RuntimeError, match='metadata'): + context.run(escalate, metadata_only=True) + + +def test_abandoned_metadata_does_not_block_next_native_admission(): + release = Event() + old = BatchTaskContext('a.lmc') + try: + with pytest.raises(TaskHandoff): + old.run(lambda: release.wait(3), timeout_seconds=.01, metadata_only=True) + assert BatchTaskContext('a.lmc').run(lambda: 'admitted') == 'admitted' + finally: + release.set(); old.close(timeout_seconds=1) diff --git a/tests/test_issue15_native_entry.py b/tests/test_issue15_native_entry.py index 7fe3eb7..dcf4888 100644 --- a/tests/test_issue15_native_entry.py +++ b/tests/test_issue15_native_entry.py @@ -241,7 +241,14 @@ def test_common_admission_refusal_publishes_bound_receipt_and_ui_can_reopen(qtbo session.process.poll = lambda: 1 launched = [] window = load_window(qtbot, tmp_path, monkeypatch, - native_backup_launcher=lambda req: (launched.append(req) or session)) + native_backup_launcher=lambda req: (launched.append(req) or session), + status_refresher=lambda names, _: {name:'UNKNOWN' for name in names}) + # Deliver the receipt to its actual library view; a foreign view must not + # receive an old session's status label after Task 4's callback isolation. + window.path_lease_factory = lambda path: SimpleNamespace(mentor_path=path, display_path=path, + drive='', remote_root='', close=lambda:None, retain_for_recovery=lambda:None) + window.lmc_edit.setText(str(session.library)); window.load_library() + qtbot.waitUntil(lambda:not window.busy) session.block = 'Beta'; record['block'] = 'Beta' session.job.with_name('result.json').write_text(json.dumps(record), encoding='utf-8') window._native_backup_session = session diff --git a/tests/test_issue15_ui_integration.py b/tests/test_issue15_ui_integration.py new file mode 100644 index 0000000..e702039 --- /dev/null +++ b/tests/test_issue15_ui_integration.py @@ -0,0 +1,651 @@ +"""Task-bound UI delivery and filesystem/native catalog separation.""" +from pathlib import Path +from threading import Event +from types import SimpleNamespace + +import pytest +from PySide6.QtCore import Qt + +from cbb_refresh_verify.models import CbbRecord, LibraryReadResult +from cbb_refresh_verify.ui.main_window import MainWindow +from cbb_refresh_verify.verify_runner import VerifyResult + + +def window_for(qtbot, tmp_path, monkeypatch, *, reader=None, **kwargs): + monkeypatch.setattr('cbb_refresh_verify.ui.main_window.preflight_skip_reason', lambda *_: None) + def lease(path): + return SimpleNamespace(mentor_path=path, display_path=path, drive='', remote_root='', + close=lambda: None, retain_for_recovery=lambda: None) + window = MainWindow(reader=reader or (lambda _: LibraryReadResult((CbbRecord('A', 'LP'),))), + path_lease_factory=lease, data_root=tmp_path, **kwargs) + qtbot.addWidget(window) + window.show() + return window + + +def load(window, qtbot, path='a.lmc'): + window.lmc_edit.setText(path) + window.load_library() + qtbot.waitUntil(lambda: not window.busy) + + +def test_first_read_can_cancel_and_keeps_navigation_live(qtbot, tmp_path, monkeypatch): + entered, release = Event(), Event() + def reader(_): + entered.set(); release.wait(5) + return LibraryReadResult((CbbRecord('Late', 'LP'),)) + window = window_for(qtbot, tmp_path, monkeypatch, reader=reader) + window.lmc_edit.setText('a.lmc'); window.load_library() + qtbot.waitUntil(entered.is_set) + try: + assert window.stop_button.isEnabled() + assert window.lmc_edit.isEnabled() and window.load_button.isEnabled() + window.stop_button.click() + qtbot.waitUntil(lambda: not window.busy, timeout=2000) + assert window.loaded_path is None + finally: + release.set(); window.pool.waitForDone(6000) + + +def test_failed_read_preserves_stale_table_without_write_eligibility(qtbot, tmp_path, monkeypatch): + window = window_for(qtbot, tmp_path, monkeypatch) + load(window, qtbot) + window.reader = lambda _: LibraryReadResult((), 'INPUT_EMPTY: 空文件') + load(window, qtbot, 'bad.lmc') + assert window.cbb_table.rowCount() == 1 + assert window.loaded_path is None + assert not window.batch_button.isEnabled() + assert '失效' in window.library_notice.text() + + +def test_successful_path_is_local_and_only_prefilled(qtbot, tmp_path, monkeypatch): + window = window_for(qtbot, tmp_path, monkeypatch) + load(window, qtbot, 'remember.lmc') + calls = [] + other = window_for(qtbot, tmp_path, monkeypatch, reader=lambda p: calls.append(p)) + assert other.lmc_edit.text() == 'remember.lmc' + assert not calls and other.loaded_path is None + isolated = window_for(qtbot, tmp_path/'other', monkeypatch) + assert isolated.lmc_edit.text() == '' + + +def test_result_nonmodal_and_safe_cancel_evidence_and_logs(qtbot, tmp_path, monkeypatch): + window = window_for(qtbot, tmp_path, monkeypatch) + load(window, qtbot) + evidence = tmp_path/'evidence'/'result.json' + evidence.parent.mkdir(); evidence.write_text('{}') + window._batch_done(([VerifyResult('CANCELLED', safe_to_continue=True, evidence_path=evidence)], None)) + assert window.summary.windowModality() == Qt.NonModal + assert window.recovery_button.isEnabled() + opened = [] + monkeypatch.setattr('os.startfile', opened.append) + window.open_logs() + assert Path(opened[-1]) == tmp_path/'logs' + + +def test_read_does_not_wait_forever_on_old_retained_cache(qtbot, tmp_path, monkeypatch): + calls = [] + monkeypatch.setattr('cbb_refresh_verify.session_record.library_available', lambda _: False) + monkeypatch.setattr('cbb_refresh_verify.session_record.library_wait_reason', lambda _: 'old retained') + window = window_for(qtbot, tmp_path, monkeypatch, reader=lambda p: ( + calls.append(p) or LibraryReadResult((CbbRecord('A', 'LP'),)))) + window.lmc_edit.setText('a.lmc'); window.load_library() + try: + qtbot.waitUntil(lambda: bool(calls), timeout=1500) + finally: + window.request_stop(); window.pool.waitForDone(3000) + + +@pytest.mark.parametrize('filename,content,category', [ + ('wrong.txt', b'library', 'INPUT_SUFFIX'), ('empty.lmc', b'', 'INPUT_EMPTY')]) +def test_fast_read_rejects_invalid_input(tmp_path, filename, content, category): + from cbb_refresh_verify.library_reader import read_library_fast + path = tmp_path/filename; path.write_bytes(content) + (tmp_path/'ReusableBlocksLP').mkdir() + result = read_library_fast(path) + assert result.error and category in result.error + + +def test_fast_read_distinguishes_unknown_native_count(tmp_path): + from cbb_refresh_verify.library_reader import read_library_fast + path = tmp_path/'lib.lmc'; path.write_bytes(b'not-a-native-validation') + (tmp_path/'ReusableBlocksLP'/'Orphan').mkdir(parents=True) + result = read_library_fast(path) + assert result.directory_count == 1 and result.native_count is None + assert result.records[0].catalog_source == 'directory' + assert result.records[0].status == 'UNKNOWN' + + +def test_late_read_a_b_a_cannot_replace_newer_snapshot(qtbot, tmp_path, monkeypatch): + entered, release = Event(), Event() + count = 0 + def reader(path): + nonlocal count + count += 1 + if count == 1: + entered.set(); release.wait(5) + return LibraryReadResult((CbbRecord('Old', 'LP'),)) + return LibraryReadResult((CbbRecord('New', 'LP'),)) + window = window_for(qtbot, tmp_path, monkeypatch, reader=reader) + window.lmc_edit.setText('a.lmc'); window.load_library() + qtbot.waitUntil(entered.is_set) + try: + window.lmc_edit.setText('b.lmc'); window.lmc_edit.setText('a.lmc') + window.load_library() + qtbot.waitUntil(lambda: window.loaded_path == 'a.lmc', timeout=2000) + release.set(); qtbot.wait(100) + assert tuple(window._records_by_name) == ('New',) + finally: + release.set(); window.pool.waitForDone(6000) + + +def test_batch_result_cannot_modify_reloaded_library_and_current_cancel_displays(qtbot, tmp_path, monkeypatch): + entered, release = Event(), Event() + def verify(_): + entered.set(); release.wait(5) + return VerifyResult('CANCELLED', stderr='old A cancelled') + window = window_for(qtbot, tmp_path, monkeypatch, verifier=verify, + status_refresher=lambda names, _: {name:'PENDING' for name in names}) + load(window, qtbot) + try: + window._run(['A']); qtbot.waitUntil(entered.is_set) + load(window, qtbot, 'b.lmc'); load(window, qtbot, 'a.lmc') + release.set(); qtbot.wait(200) + assert 'old A cancelled' not in window.status_label.text() + assert window.cbb_table.item(0,3).text() == '未检查' + window._run(['A']); qtbot.waitUntil(lambda:not window.busy) + assert '取消' in window.output.toPlainText() or 'CANCELLED' in window.output.toPlainText() + finally: + release.set(); window.pool.waitForDone(6000) + + +def test_catalog_union_keeps_registration_source_and_counts(qtbot, tmp_path, monkeypatch): + from cbb_refresh_verify.management import Catalog, CatalogEntry + entered, release = Event(), Event() + def catalog(path, evidence): + entered.set(); release.wait(5) + return Catalog(path,1,(CatalogEntry('A','Logical-Physical'),CatalogEntry('NativeOnly','Logical-Physical'))) + window = window_for(qtbot,tmp_path,monkeypatch, reader=lambda _:LibraryReadResult( + (CbbRecord('A','LP',catalog_source='directory'), CbbRecord('Orphan','LP',catalog_source='directory')), + directory_count=2), catalog_reader=catalog, status_refresher=lambda names,_:{name:'READY' for name in names}) + try: + load(window,qtbot) + qtbot.waitUntil(entered.is_set) + assert '未知' in window.counts_label.text() + assert window.batch_button.isEnabled() + release.set() + qtbot.waitUntil(lambda:'NativeOnly' in window._records_by_name) + assert window._records_by_name['Orphan'].catalog_source == 'directory_only' + assert window._records_by_name['NativeOnly'].catalog_source == 'native_only' + assert window._records_by_name['A'].status_source == 'authoritative' + assert '原生 2' in window.counts_label.text() + finally: + release.set(); window.pool.waitForDone(6000) + + +def test_execution_rechecks_ready_when_directory_snapshot_was_unknown(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.management import Catalog, CatalogEntry + calls=[] + window=window_for(qtbot,tmp_path,monkeypatch, verifier=lambda r:(calls.append(r.block_name) or VerifyResult('PASS')), + catalog_reader=lambda p,e:Catalog(p,1,(CatalogEntry('A','Logical-Physical'),)), + status_refresher=lambda names,_:{name:'READY' for name in names}) + load(window,qtbot) + window._run(['A']) + qtbot.waitUntil(lambda:not window.busy) + assert calls == [] + + +def test_active_a_choice_defaults_after_switch_to_b(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.pcb_open_consent import OpenChoice + from cbb_refresh_verify.ui import timed_prompt + monkeypatch.setattr(timed_prompt,'DEFAULT_TIMEOUT_MS',80) + window=window_for(qtbot,tmp_path,monkeypatch) + load(window,qtbot) + job=window._new_job('verify',targets=('A',)) + load(window,qtbot,'b.lmc') + choice=OpenChoice('A',Path('a.lmc')) + window._emit_job(job,'version_choice',choice) + qtbot.waitUntil(lambda:choice.decision is not None) + assert choice.decision == 'skip' + window._finish_job(job) + + +@pytest.mark.parametrize('mode',['versions','repair']) +def test_native_session_outlives_launcher_and_cleans_up_after_a_b_a(qtbot,tmp_path,monkeypatch,mode): + import json + exited=Event(); calls=[] + job_file=tmp_path/'native'/'job.json'; job_file.parent.mkdir(); job_file.write_text('{}') + def launcher(request, **options): + calls.append(options.get('mode','versions')) + return SimpleNamespace(process=SimpleNamespace(poll=lambda:0 if exited.is_set() else None), + job=job_file,library=request.lmc_file,block=request.block_name,path_lease=None,operation_id='native-1') + window=window_for(qtbot,tmp_path,monkeypatch,native_backup_launcher=launcher, + status_refresher=lambda names,_:{name:'PENDING' for name in names}) + load(window,qtbot); window.cbb_table.setCurrentCell(0,0) + button=window.native_backup_button if mode=='versions' else window.native_repair_button + button.click(); qtbot.waitUntil(lambda:window._native_backup_session is not None) + qtbot.waitUntil(lambda:not window.busy) + assert calls == [mode] + load(window,qtbot,'b.lmc'); load(window,qtbot,'a.lmc') + message=window.status_label.text() + job_file.with_name('result.json').write_text(json.dumps(dict(operation_id='native-1', + library='a.lmc',block='A',safe_to_continue=True,status='CLOSED'))) + exited.set(); window._poll_native_backup() + qtbot.waitUntil(lambda:window._native_backup_session is None) + assert window.status_label.text() == message + window.cbb_table.setCurrentCell(0,0) + assert window.native_backup_button.isEnabled() + + +def test_close_during_first_read_finishes_and_late_emit_is_harmless(qtbot,tmp_path,monkeypatch): + entered, release=Event(),Event() + def reader(_): + entered.set(); release.wait(5) + return LibraryReadResult((CbbRecord('Late','LP'),)) + window=window_for(qtbot,tmp_path,monkeypatch,reader=reader) + window.lmc_edit.setText('a.lmc'); window.load_library(); qtbot.waitUntil(entered.is_set) + job=window._current_job + try: + window.close() + qtbot.waitUntil(lambda:not window.isVisible(),timeout=2000) + window._emit_job(job,'event',{'stage':'late'}) + finally: release.set() + + +def test_input_lock_directory_and_permissions_are_classified(tmp_path,monkeypatch): + from cbb_refresh_verify.library_reader import read_library_fast + path=tmp_path/'lib.lmc'; path.write_bytes(b'library') + (tmp_path/'ReusableBlocksLP').mkdir(); path.with_suffix('.lock').mkdir() + assert 'INPUT_LOCK_DIRECTORY' in read_library_fast(path).error + original=Path.open + def denied(self,*a,**k): + if self == path: raise PermissionError('denied') + return original(self,*a,**k) + monkeypatch.setattr(Path,'open',denied) + assert 'INPUT_PERMISSION' in read_library_fast(path).error + + +def test_management_completion_after_switch_preserves_current_table(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.management import Capability, ManagementResult + from PySide6.QtWidgets import QMessageBox + monkeypatch.setattr('cbb_refresh_verify.ui.timed_prompt.question',lambda *a,**k:QMessageBox.Yes) + entered,release=Event(),Event() + adapter=SimpleNamespace(capabilities=lambda:{op:Capability(True,'available') for op in ('add','update','remove')}) + window=window_for(qtbot,tmp_path,monkeypatch,management_adapter=adapter) + load(window,qtbot); window.select_visible_button.click(); window.manage_cbb('remove') + dialog=window.management_dialog + def runner(requests,**kwargs): + entered.set(); release.wait(5) + r=requests[0] + return [ManagementResult('remove',r.library,r.name,r.partition,None,False,'complete','REMOVED',True,'old remove')] + dialog.runner=runner + try: + dialog.execute_button.click(); qtbot.waitUntil(entered.is_set) + assert dialog.windowModality()==Qt.NonModal + load(window,qtbot,'b.lmc'); load(window,qtbot,'a.lmc') + message=window.status_label.text() + release.set(); qtbot.waitUntil(lambda:not dialog.busy) + dialog.close(); qtbot.wait(100) + assert window.status_label.text()==message + assert window.cbb_table.item(0,3).text()=='未检查' + finally: release.set(); dialog.pool.waitForDone(6000) + + +def test_recovery_dialog_binds_original_library_and_is_nonmodal(qtbot,tmp_path,monkeypatch): + from PySide6.QtWidgets import QMessageBox + monkeypatch.setattr('cbb_refresh_verify.ui.timed_prompt.question',lambda *a,**k:QMessageBox.Yes) + entered,release=Event(),Event(); calls=[] + window=window_for(qtbot,tmp_path,monkeypatch) + load(window,qtbot); window.restore_backup(); dialog=window.backup_dialog + source=tmp_path/'A.prj'; source.write_text('project') + dialog.source_edit.setText(str(source)) + def recover(request,source,**kwargs): + calls.append(request.lmc_file); entered.set(); release.wait(5) + return VerifyResult('FAIL',stderr='old recovery',safe_to_continue=True) + dialog.recoverer=recover + try: + assert dialog.windowModality()==Qt.NonModal + load(window,qtbot,'b.lmc') + dialog.restore_button.click(); qtbot.waitUntil(entered.is_set) + message=window.status_label.text() + release.set(); qtbot.waitUntil(lambda:not dialog.busy) + assert calls == [Path('a.lmc')] + assert window.status_label.text()==message + finally: release.set(); dialog.pool.waitForDone(6000) + + +def test_icdb_does_not_wait_on_stale_retained_and_late_result_is_scoped(qtbot,tmp_path,monkeypatch): + entered,release=Event(),Event() + monkeypatch.setattr('cbb_refresh_verify.session_record.library_available',lambda _:False) + monkeypatch.setattr('cbb_refresh_verify.session_record.library_wait_reason',lambda _:'historical') + def verify(_): + entered.set(); release.wait(5) + return VerifyResult('CHECKED',safe_to_continue=True) + window=window_for(qtbot,tmp_path,monkeypatch,verifier=verify) + load(window,qtbot); window._start_icdb_check(['A']) + try: + qtbot.waitUntil(entered.is_set,timeout=1500) + load(window,qtbot,'b.lmc'); load(window,qtbot,'a.lmc') + message=window.status_label.text() + release.set(); qtbot.waitUntil(lambda:not window._icdb_active()) + assert window.status_label.text()==message + assert window.cbb_table.item(0,3).text()=='未检查' + finally: + release.set(); window._stop_icdb_check(); window.icdb_task.pool.waitForDone(6000) + + +def test_default_reentrant_tick_commits_one_choice(qtbot,monkeypatch): + from PySide6.QtWidgets import QMessageBox + from cbb_refresh_verify.ui.timed_prompt import arm_default + monkeypatch.setattr('cbb_refresh_verify.ui.timed_prompt.DEFAULT_TIMEOUT_MS',50) + box=QMessageBox(); qtbot.addWidget(box); box.setStandardButtons(QMessageBox.Yes|QMessageBox.No) + choices=[] + def clicked(button): + choices.append(button) + if len(choices)==1: countdown.tick() + box.buttonClicked.connect(clicked) + countdown=arm_default(box,box.button(QMessageBox.Yes)) + box.show(); qtbot.wait(120) + assert len(choices) == 1 + + +def test_release_dialog_is_available_during_task_and_stale_receipt_keeps_view(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog + monkeypatch.setattr(ResidualReleaseDialog,'refresh',lambda self:None) + released=[] + monkeypatch.setattr('cbb_refresh_verify.network_path.release_retained_path_leases',lambda proof,**kw:released.append(proof)) + window=window_for(qtbot,tmp_path,monkeypatch) + load(window,qtbot); window.busy=True; window._update() + window.release_library_button.click() + dialog=window.release_dialog + assert dialog.isVisible() and dialog.windowModality()==Qt.NonModal + load(window,qtbot,'b.lmc'); load(window,qtbot,'a.lmc'); message=window.status_label.text() + dialog.released.emit(dict(status='RELEASE_CONFIRMED',library='a.lmc',evidence_path='proof.json')) + qtbot.waitUntil(lambda:bool(released)) + dialog.close(); qtbot.wait(100) + assert window.status_label.text()==message + + +@pytest.mark.parametrize('kind',['read','lease']) +def test_source_process_exits_after_stalled_bookkeeping(tmp_path,kind): + import subprocess,sys,os,time + script=tmp_path/'close_app.py' + script.write_text('''from threading import Event +from pathlib import Path +import sys +from PySide6.QtWidgets import QApplication +from PySide6.QtCore import QTimer +from cbb_refresh_verify.ui.main_window import MainWindow +app=QApplication([]) +MainWindow._show_unfinished_management=lambda self:None +block=Event() +w=MainWindow(reader=lambda _:block.wait(90),data_root=Path(sys.argv[2])) +w.show() +if sys.argv[1]=='read': + w.lmc_edit.setText('stalled.lmc'); w.load_library() +else: w._lease_action(lambda:block.wait(90)) +QTimer.singleShot(150,w.close) +app.exec() +print('APP_RETURNED',flush=True) +''',encoding='utf-8') + env=dict(os.environ,QT_QPA_PLATFORM='offscreen') + started=__import__('time').monotonic() + process=subprocess.Popen([sys.executable,'-X','utf8',str(script),kind,str(tmp_path/'data')], + stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True,encoding='utf-8',env=env) + try: + stdout,stderr=process.communicate(timeout=8) + assert process.returncode==0,stderr + assert 'APP_RETURNED' in stdout + assert time.monotonic()-started < 8 + finally: + if process.poll() is None: + process.kill(); process.communicate() + + +def test_old_library_mapping_cleanup_does_not_keep_new_library_busy(qtbot,tmp_path,monkeypatch): + entered,release=Event(),Event(); calls=[] + window=window_for(qtbot,tmp_path,monkeypatch,verifier=lambda r:(calls.append(r.lmc_file) or VerifyResult('PASS')), + status_refresher=lambda names,_:{name:'PENDING' for name in names}) + load(window,qtbot) + def cleanup(): entered.set(); release.wait(5) + window._lease_action(cleanup,hold_busy=True) + qtbot.waitUntil(entered.is_set) + try: + window.lmc_edit.setText('b.lmc'); window.load_library() + qtbot.waitUntil(lambda:window.loaded_path=='b.lmc' and not window.busy,timeout=1000) + window._run(['A']) + qtbot.waitUntil(lambda:bool(calls),timeout=1000) + assert calls == [Path('b.lmc')] + finally: + release.set(); qtbot.waitUntil(lambda:window._lease_pending==0) + + +@pytest.mark.parametrize('kind',['recovery','management']) +def test_dialog_handoff_is_not_claimed_as_safe_cancellation(qtbot,tmp_path,monkeypatch,kind): + from cbb_refresh_verify.operation_queue import TaskHandoff,BatchTaskContext + from cbb_refresh_verify.management import Capability + from PySide6.QtWidgets import QMessageBox + monkeypatch.setattr('cbb_refresh_verify.ui.timed_prompt.question',lambda *a,**k:QMessageBox.Yes) + adapter=SimpleNamespace(capabilities=lambda:{op:Capability(True,'available') for op in ('add','update','remove')}) + window=window_for(qtbot,tmp_path,monkeypatch,management_adapter=adapter) + load(window,qtbot); results=[] + def handed_off(*a,**k): raise TaskHandoff(BatchTaskContext('a.lmc')) + if kind=='recovery': + window.restore_backup(); dialog=window.backup_dialog + source=tmp_path/'A.prj'; source.write_text('project'); dialog.source_edit.setText(str(source)) + dialog.recoverer=handed_off + dialog.completed.connect(lambda name,result:results.append(result)) + dialog.restore_button.click() + else: + window.select_visible_button.click(); window.manage_cbb('remove'); dialog=window.management_dialog + dialog.runner=handed_off + dialog.completed.connect(results.extend) + dialog.execute_button.click() + qtbot.waitUntil(lambda:bool(results)) + assert results[0].safe_to_continue is False + + +def test_real_startup_observer_delivery_after_destroy_is_ignored(qtbot,tmp_path,monkeypatch): + callbacks=[] + monkeypatch.setattr('cbb_refresh_verify.management.unfinished_operations',lambda _:[]) + monkeypatch.setattr('cbb_refresh_verify.session_record.discover_sessions',lambda _:[dict( + status='ACTIVE',path='owned-session.json',block='A',phase='NATIVE_CALL',detail='running')]) + monkeypatch.setattr('cbb_refresh_verify.session_record.handoff_session',lambda *a,**kw:callbacks.append(kw['progress'])) + # This test explicitly destroys the QObject, so pytest-qt must not retain it + # for its normal close-at-teardown fixture. + window=MainWindow(reader=lambda _:LibraryReadResult(()),data_root=tmp_path) + window.show() + qtbot.waitUntil(lambda:bool(callbacks)) + window.close(); qtbot.waitUntil(lambda:not window.isVisible()) + import shiboken6 + shiboken6.delete(window) + callbacks[0]({'library':'a.lmc','status':'RELEASED'}) + + +def test_running_a_emits_real_choice_after_reading_b(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.pcb_open_consent import OpenChoice + entered,continue_a,answered=Event(),Event(),Event(); choices=[] + monkeypatch.setattr('cbb_refresh_verify.ui.timed_prompt.DEFAULT_TIMEOUT_MS',80) + def verify(request,*,version_prompt,**kwargs): + entered.set(); continue_a.wait(5) + choice=OpenChoice(request.block_name,request.lmc_file); choices.append(choice) + version_prompt(choice) + for _ in range(100): + if choice.decision is not None: answered.set(); break + Event().wait(.02) + return VerifyResult('SKIPPED',safe_to_continue=True) + monkeypatch.setattr('cbb_refresh_verify.verify_runner.run_verify',verify) + window=window_for(qtbot,tmp_path,monkeypatch,status_refresher=lambda names,_:{name:'UNKNOWN' for name in names}) + load(window,qtbot); window._run(['A']); qtbot.waitUntil(entered.is_set) + try: + load(window,qtbot,'b.lmc'); message=window.status_label.text() + continue_a.set(); qtbot.waitUntil(answered.is_set) + assert choices[0].decision=='skip' and choices[0].library==Path('a.lmc') + assert window.status_label.text()==message + finally: continue_a.set(); window.pool.waitForDone(6000) + + +def test_second_management_dialog_cannot_submit_same_active_snapshot(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.management import Capability + from PySide6.QtWidgets import QMessageBox + monkeypatch.setattr('cbb_refresh_verify.ui.timed_prompt.question',lambda *a,**k:QMessageBox.Yes) + entered,release=Event(),Event(); calls=[] + adapter=SimpleNamespace(capabilities=lambda:{op:Capability(True,'available') for op in ('add','update','remove')}) + window=window_for(qtbot,tmp_path,monkeypatch,management_adapter=adapter) + def runner(requests,**kwargs): + calls.append(requests[0].name); entered.set(); release.wait(5); return [] + load(window,qtbot); window.select_visible_button.click(); window.manage_cbb('remove') + first=window.management_dialog; first.runner=runner; first.execute_button.click() + qtbot.waitUntil(entered.is_set) + try: + load(window,qtbot,'b.lmc'); load(window,qtbot,'a.lmc') + window.select_visible_button.click(); window.manage_cbb('remove') + second=window.management_dialog; second.runner=runner; second.execute_button.click() + assert not second.busy + assert '重复' in second.status_label.text() + release.set(); qtbot.waitUntil(lambda:not first.busy) + assert calls==['A'] + finally: release.set(); first.pool.waitForDone(6000) + + +def test_manual_repair_uses_current_diagnostic_database(qtbot,tmp_path,monkeypatch): + import json + evidence=tmp_path/'run'/'result.json'; evidence.parent.mkdir(); evidence.write_text('{}') + diagnostic=evidence.parent/'diagnostics'/'icdb-recovery.json'; diagnostic.parent.mkdir() + database=tmp_path/'actual-project'/'database' + diagnostic.write_text(json.dumps({'database_path':str(database),'scope':'project'})) + calls=[] + def launcher(request,**kwargs): + calls.append(kwargs) + return SimpleNamespace(process=SimpleNamespace(poll=lambda:None),job=evidence, + library=request.lmc_file,block=request.block_name,path_lease=None) + window=window_for(qtbot,tmp_path,monkeypatch,native_backup_launcher=launcher, + verifier=lambda _:VerifyResult('FAIL',safe_to_continue=True,evidence_path=evidence,error_category='ICDB_REPAIR_REQUIRED'), + status_refresher=lambda names,_:{name:'UNKNOWN' for name in names}) + load(window,qtbot); window._run(['A']); qtbot.waitUntil(lambda:not window.busy) + window.cbb_table.setCurrentCell(0,0); window.native_repair_button.click() + qtbot.waitUntil(lambda:bool(calls)) + assert calls[0]['target_database']==str(database) + + +@pytest.mark.parametrize('maintenance',[False,True]) +def test_directory_only_submission_is_not_treated_as_native_registration(qtbot,tmp_path,monkeypatch,maintenance): + from cbb_refresh_verify.management import Catalog + calls=[] + window=window_for(qtbot,tmp_path,monkeypatch, + verifier=lambda req:(calls.append(req.block_name) or VerifyResult('PASS')), + status_refresher=lambda names,_:{name:'UNKNOWN' for name in names}) + load(window,qtbot) + # The snapshot was already selectable while the native catalog was unknown. + window.catalog_reader=lambda path,evidence:Catalog(path,1,()) + window._run(['A'],maintenance=maintenance) + qtbot.waitUntil(lambda:not window.busy and not window._icdb_active()) + assert calls == [] + + +def test_missing_all_project_directories_still_allows_native_catalog_reconciliation(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.management import Catalog,CatalogEntry + path=tmp_path/'lib.lmc'; path.write_bytes(b'library metadata') + window=MainWindow(data_root=tmp_path/'data', + catalog_reader=lambda library,evidence:Catalog(library,1,(CatalogEntry('NativeOnly','Logical-Physical'),)), + status_refresher=lambda names,_:{name:'UNKNOWN' for name in names}) + qtbot.addWidget(window); window.show() + load(window,qtbot,str(path)) + qtbot.waitUntil(lambda:'NativeOnly' in window._records_by_name) + assert window._records_by_name['NativeOnly'].catalog_source=='native_only' + assert window._read_counts==(0,1,1) + + +def test_failed_native_entry_resumes_captured_check_after_view_switch(qtbot,tmp_path,monkeypatch): + entered,release=Event(),Event(); calls=[] + def verify(request): + calls.append(request.block_name) + if len(calls)==1: entered.set(); release.wait(5) + return VerifyResult('CHECKED',safe_to_continue=True) + def failed(*a,**k): raise RuntimeError('entry refused') + window=window_for(qtbot,tmp_path,monkeypatch,reader=lambda _:LibraryReadResult((CbbRecord('A','LP'),CbbRecord('Next','LP'))), + verifier=verify,native_backup_launcher=failed) + load(window,qtbot); window._start_icdb_check(['A','Next']); qtbot.waitUntil(entered.is_set) + task=window.icdb_task + try: + window.cbb_table.setCurrentCell(0,0); window.native_backup_button.click() + assert task.paused + load(window,qtbot,'b.lmc'); message=window.status_label.text() + release.set() + qtbot.waitUntil(lambda:len(calls)==2,timeout=2000) + assert window.status_label.text()==message + finally: + release.set(); task.cancel(); qtbot.waitUntil(lambda:not task.active) + + +def test_old_release_panel_never_cancels_replacement_check(qtbot,tmp_path,monkeypatch): + from cbb_refresh_verify.ui.residual_release_dialog import ResidualReleaseDialog + monkeypatch.setattr(ResidualReleaseDialog,'refresh',lambda self:None) + entered=Event(); window=None + def verify(_): + task=window.icdb_task; entered.set(); task.stop.wait(5) + return VerifyResult('CANCELLED',safe_to_continue=True) + window=window_for(qtbot,tmp_path,monkeypatch,verifier=verify) + load(window,qtbot); window._start_icdb_check(['A']); qtbot.waitUntil(entered.is_set) + old=window.icdb_task + window.release_library_button.click(); dialog=window.release_dialog + old.cancel(); qtbot.waitUntil(lambda:not old.active) + entered.clear(); load(window,qtbot,'b.lmc'); window._start_icdb_check(['A']) + qtbot.waitUntil(entered.is_set); newer=window.icdb_task + try: + dialog.before_release.emit() + assert not newer.stop.is_set() + finally: + newer.cancel(); qtbot.waitUntil(lambda:not newer.active) + + +@pytest.mark.parametrize('switch_view',[True,False]) +def test_summary_actions_keep_original_revision_and_resume_configuration(qtbot,tmp_path,monkeypatch,switch_view): + monkeypatch.setattr('cbb_refresh_verify.ui.timed_prompt.DEFAULT_TIMEOUT_MS',10000) + monkeypatch.setattr('cbb_refresh_verify.operation_lifecycle.recheck_failed_release',lambda library,name,result,**kw:result) + requests=[]; release_clicks=[] + def verify(request): + requests.append(request) + return VerifyResult('FAIL' if request.block_name=='A' else 'PASS',safe_to_continue=request.block_name!='A') + window=window_for(qtbot,tmp_path,monkeypatch,reader=lambda _:LibraryReadResult((CbbRecord('A','LP'),CbbRecord('Next','LP'))), + verifier=verify,status_refresher=lambda names,_:{name:'PENDING' for name in names}) + monkeypatch.setattr(window,'check_library_release',lambda *a,**k:release_clicks.append(True)) + load(window,qtbot); original_timeout=window.timeout_spin.value(); window._run(['A','Next']) + qtbot.waitUntil(lambda:not window.busy) + old_release,old_resume=window._residual_release_action,window._resume_batch_action + window._resume_batch['released']=True; window._update() + if switch_view: + load(window,qtbot,'b.lmc'); load(window,qtbot,'a.lmc') + old_release.click(); old_resume.click(); qtbot.wait(100) + assert release_clicks==[] and len(requests)==1 + else: + window.timeout_spin.setValue(45) + old_resume.click(); qtbot.waitUntil(lambda:not window.busy) + assert len(requests)==2 and requests[-1].block_name=='Next' + assert requests[-1].timeout_seconds==original_timeout + + +def test_recovery_retry_rejects_old_external_progress_and_choice(qtbot,tmp_path,monkeypatch): + from PySide6.QtWidgets import QMessageBox + from cbb_refresh_verify.pcb_open_consent import OpenChoice + monkeypatch.setattr('cbb_refresh_verify.ui.timed_prompt.question',lambda *a,**k:QMessageBox.Yes) + callbacks=[]; entered,release=Event(),Event() + def recover(*args,progress,version_prompt,stop): + callbacks.append((progress,version_prompt)) + if len(callbacks)==2: entered.set(); release.wait(5) + return VerifyResult('CANCELLED',safe_to_continue=True) + monkeypatch.setattr('cbb_refresh_verify.backup_recovery.recover_from_backup',recover) + window=window_for(qtbot,tmp_path,monkeypatch,status_refresher=lambda names,_:{name:'UNKNOWN' for name in names}) + load(window,qtbot); window.restore_backup(); dialog=window.backup_dialog + source=tmp_path/'A.prj'; source.write_text('project'); dialog.source_edit.setText(str(source)) + dialog.restore_button.click(); qtbot.waitUntil(lambda:not dialog.busy and not window.busy) + try: + dialog.restore_button.click(); qtbot.waitUntil(entered.is_set) + message=dialog.status_label.text() + callbacks[0][0]({'detail':'old external observer'}) + choice=OpenChoice('A',Path('a.lmc')); callbacks[0][1](choice) + qtbot.wait(50) + assert dialog.status_label.text()==message + assert choice.decision=='cancel' + finally: + release.set(); qtbot.waitUntil(lambda:not dialog.busy) diff --git a/tests/test_library_reader.py b/tests/test_library_reader.py index fcaadb7..926f95f 100644 --- a/tests/test_library_reader.py +++ b/tests/test_library_reader.py @@ -35,7 +35,7 @@ def test_reader_accepts_com_collections_exposing_callable_count(): def test_reader_fast_scans_reusable_blocks_without_com(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') (tmp_path / 'ReusableBlocksLP' / 'B_CBB').mkdir(parents=True) (tmp_path / 'ReusableBlocksLP' / 'A_CBB').mkdir() from cbb_refresh_verify.library_reader import read_library_fast @@ -45,7 +45,7 @@ def test_reader_fast_scans_reusable_blocks_without_com(tmp_path): def test_reader_fast_applies_status_reader(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') (tmp_path / 'ReusableBlocksLP' / 'READY_CBB').mkdir(parents=True) from cbb_refresh_verify.library_reader import read_library_fast result = read_library_fast(lmc, status_reader=lambda name: 'READY' if name == 'READY_CBB' else 'PENDING') @@ -53,7 +53,7 @@ def test_reader_fast_applies_status_reader(tmp_path): def test_reader_fast_bulk_status_reader_is_called_once(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') (tmp_path / 'ReusableBlocksLP' / 'A_CBB').mkdir(parents=True) (tmp_path / 'ReusableBlocksLP' / 'B_CBB').mkdir() calls = [] @@ -68,7 +68,7 @@ def test_reader_fast_bulk_status_reader_is_called_once(tmp_path): def test_reader_fast_preserves_unavailable_bridge_status(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') (tmp_path / 'ReusableBlocksLP' / 'A_CBB').mkdir(parents=True) from cbb_refresh_verify.library_reader import read_library_fast result = read_library_fast(lmc, status_reader=lambda path, names: {'A_CBB': 'UNAVAILABLE'}) @@ -77,7 +77,7 @@ def test_reader_fast_preserves_unavailable_bridge_status(tmp_path): def test_reader_fast_exposes_status_reader_failure_as_unavailable(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') (tmp_path / 'ReusableBlocksLP' / 'A_CBB').mkdir(parents=True) from cbb_refresh_verify.library_reader import read_library_fast result = read_library_fast(lmc, status_reader=lambda path, names: (_ for _ in ()).throw(RuntimeError('bridge down'))) @@ -86,7 +86,7 @@ def test_reader_fast_exposes_status_reader_failure_as_unavailable(tmp_path): def test_filesystem_status_uses_complete_fresh_cert_artifacts(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') root = tmp_path / 'ReusableBlocksLP' ready = root / 'READY_CBB' / 'Work' pending = root / 'PENDING_CBB' / 'Work' @@ -325,7 +325,7 @@ def test_status_scan_logs_each_cbb_image_id(caplog, tmp_path): def test_status_scan_without_native_observation_does_not_guess_status(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') root = lmc.parent / 'ReusableBlocksLP' ready = root / 'READY_CBB' / 'Work' (ready / 'PCB' / 'Layout').mkdir(parents=True) @@ -353,7 +353,7 @@ def test_status_scan_without_native_observation_does_not_guess_status(tmp_path): def test_filesystem_evidence_exposes_multiple_persistent_dimensions(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') work = tmp_path / 'ReusableBlocksLP' / 'A_CBB' / 'Work' (work / 'PCB' / 'Layout').mkdir(parents=True) (work / 'A_CBB.prj').write_text('KEY PCBDesignPath "PCB\\actual.pcb"', encoding='utf-8') @@ -375,7 +375,7 @@ def test_filesystem_evidence_exposes_multiple_persistent_dimensions(tmp_path): def test_filesystem_evidence_preserves_mapped_drive_paths(tmp_path, monkeypatch): """Legacy evidence scanning must not resolve a mapped drive back to UNC.""" lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') work = tmp_path / 'ReusableBlocksLP' / 'A_CBB' / 'Work' (work / 'PCB' / 'Layout').mkdir(parents=True) (work / 'A_CBB.prj').write_text('KEY PCBDesignPath "PCB\\actual.pcb"', encoding='utf-8') @@ -393,7 +393,7 @@ def test_filesystem_evidence_preserves_mapped_drive_paths(tmp_path, monkeypatch) def test_missing_work_project_is_a_pending_calibration_anchor(tmp_path): lmc = tmp_path / 'center.lmc' - lmc.touch() + lmc.write_bytes(b'fixture metadata; native format is not checked') (tmp_path / 'ReusableBlocksLP' / 'IMPORTED_CBB').mkdir(parents=True) from cbb_refresh_verify.library_reader import filesystem_evidence_map evidence = filesystem_evidence_map(lmc, ('IMPORTED_CBB',))['IMPORTED_CBB'] diff --git a/tests/test_residual_release_dialog.py b/tests/test_residual_release_dialog.py index 9b7600e..685630c 100644 --- a/tests/test_residual_release_dialog.py +++ b/tests/test_residual_release_dialog.py @@ -154,6 +154,7 @@ def test_released_batch_can_resume_only_its_unexecuted_items(qtbot, tmp_path, mo action = window._resume_batch_action assert action.isEnabled() calls = [] + original_remaining = (window._batch_requests[1],) monkeypatch.setattr(window, '_run', lambda names, **kw: calls.append((names, kw))) action.click() - assert calls == [(['Gamma'], {'maintenance': False})] + assert calls == [(['Gamma'], {'maintenance': False, 'request_snapshot': original_remaining})] diff --git a/tests/test_review326_queue_guidance.py b/tests/test_review326_queue_guidance.py index 64b36b6..2174c40 100644 --- a/tests/test_review326_queue_guidance.py +++ b/tests/test_review326_queue_guidance.py @@ -28,6 +28,8 @@ def test_queued_action_has_visible_release_entry_and_resumes_after_proof(qtbot, window.show() library = window.mentor_lmc_path retain(monkeypatch, library) + from test_review381_queue_release import hold_native_queue + queue_release, queue_worker = hold_native_queue(window) finished = Event() window._start(lambda: VerifyResult('PASS'), lambda _: finished.set()) qtbot.waitUntil(lambda: 'BlockedCBB' in window.status_label.text()) @@ -37,6 +39,7 @@ def test_queued_action_has_visible_release_entry_and_resumes_after_proof(qtbot, window.queue_release_button.click() assert opened == [{'queued': True}] sessions._retained_libraries.clear() + queue_release.set(); queue_worker.join(2) window.native_queue.wake() qtbot.waitUntil(finished.is_set) qtbot.waitUntil(lambda: not window.busy) @@ -70,7 +73,9 @@ def test_release_mapping_cleanup_finishes_before_waiting_ticket_resumes(qtbot, t retain(monkeypatch, library) monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda _: dict(library=str(library), sessions=[])) + entered, allow_release = Event(), Event() def backend_release(*a, **kw): + entered.set(); assert allow_release.wait(5) sessions._retained_libraries.clear() return dict(status='RELEASE_CONFIRMED', sessions=[], proof=dict(status='RELEASE_CONFIRMED', library=str(library), evidence_path='controlled-proof.json')) @@ -82,15 +87,20 @@ def test_release_mapping_cleanup_finishes_before_waiting_ticket_resumes(qtbot, t def action(): assert cleaned.is_set(), 'new native operation began before old mapping release completed' finished.set() - window._start(action, lambda _: None) - qtbot.waitUntil(lambda: window._queue_wait_library is not None) + window._queue_wait_library = str(library) window.check_library_release(queued=True) qtbot.waitUntil(lambda: not window.release_dialog.busy) window.release_dialog.confirm_button.click() - qtbot.waitUntil(finished.is_set) - qtbot.waitUntil(lambda: not window.release_dialog.busy) - qtbot.waitUntil(lambda: not window.busy) - window.release_dialog.close() + qtbot.waitUntil(entered.is_set) + try: + window._start(action, lambda _: None) + allow_release.set() + qtbot.waitUntil(finished.is_set) + qtbot.waitUntil(lambda: not window.release_dialog.busy) + qtbot.waitUntil(lambda: not window.busy) + window.release_dialog.close() + finally: + allow_release.set() def test_wait_reason_updates_when_active_task_becomes_a_retained_session(qtbot, tmp_path, monkeypatch): @@ -110,7 +120,6 @@ def test_wait_reason_updates_when_active_task_becomes_a_retained_session(qtbot, qtbot.waitUntil(lambda: '已排队' in window.status_label.text()) assert window._queue_wait_library is None sessions._retained_libraries['controlled-session'] = {sessions._library_key(library)} - release.set(); first.join(3) qtbot.waitUntil(lambda: 'BlockedCBB' in window.status_label.text()) assert not window.queue_release_button.isHidden() finally: @@ -132,6 +141,8 @@ def test_management_wait_shows_same_block_and_emits_release_target(qtbot, tmp_pa qtbot.addWidget(dialog); dialog.show() targets = [] dialog.release_requested.connect(targets.append) + from test_review381_queue_release import hold_native_queue + queue_release, queue_worker = hold_native_queue(dialog) dialog.execute_button.click() qtbot.waitUntil(lambda: 'BlockedCBB' in dialog.status_label.text()) assert dialog.release_wait_button.isVisible() @@ -139,6 +150,7 @@ def test_management_wait_shows_same_block_and_emits_release_target(qtbot, tmp_pa assert targets == [library] dialog.stop.set() qtbot.waitUntil(lambda: not dialog.busy) + queue_release.set(); queue_worker.join(2) def test_close_waits_for_independent_release_worker(qtbot, tmp_path, monkeypatch): diff --git a/tests/test_review381_queue_release.py b/tests/test_review381_queue_release.py index 673a1ac..c2714e7 100644 --- a/tests/test_review381_queue_release.py +++ b/tests/test_review381_queue_release.py @@ -1,5 +1,5 @@ """Stale and repeated user actions around native queue admission.""" -from threading import Event +from threading import Event, Thread from types import SimpleNamespace from pathlib import Path @@ -12,6 +12,18 @@ from test_review326_queue_guidance import retain from test_ui_filters import load_window + +def hold_native_queue(window): + """A live owner, rather than old retention metadata, keeps admission queued.""" + entered, release = Event(), Event() + def action(): + entered.set() + assert release.wait(10) + worker = Thread(target=lambda:window.native_queue.run(action)) + worker.start() + assert entered.wait(2) + return release, worker + def test_verify_admission_hides_release_entry_before_action_finishes(qtbot, tmp_path, monkeypatch): window = load_window(qtbot, tmp_path, monkeypatch) window.show() @@ -81,6 +93,7 @@ def test_old_waiting_event_is_rechecked_against_current_release_state(qtbot, tmp def test_other_library_icdb_start_preserves_the_foreground_wait(qtbot, tmp_path, monkeypatch): window = load_window(qtbot, tmp_path, monkeypatch) window.show() + queue_release, queue_worker = hold_native_queue(window) retain(monkeypatch, window.mentor_lmc_path) window._start(lambda: None, lambda _: None) try: @@ -90,6 +103,7 @@ def test_other_library_icdb_start_preserves_the_foreground_wait(qtbot, tmp_path, assert window.queue_release_button.isVisible() assert window._queue_wait_library == 'test.lmc' finally: + queue_release.set(); queue_worker.join(2) sessions._retained_libraries.clear() window.native_queue.wake() qtbot.waitUntil(lambda: not window.busy) @@ -130,6 +144,7 @@ def test_repeated_click_and_close_reuse_one_panel_without_unlocking_the_task(qtb from cbb_refresh_verify import library_lock window = load_window(qtbot, tmp_path, monkeypatch) window.show() + queue_release, queue_worker = hold_native_queue(window) retain(monkeypatch, window.mentor_lmc_path) monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda library: dict(library=str(library), sessions=[])) @@ -150,6 +165,7 @@ def test_repeated_click_and_close_reuse_one_panel_without_unlocking_the_task(qtb reopened.close() assert window.busy finally: + queue_release.set(); queue_worker.join(2) sessions._retained_libraries.clear() window.native_queue.wake() qtbot.waitUntil(lambda: not window.busy) @@ -159,6 +175,7 @@ def test_repeat_verify_then_stop_then_delayed_release_click_never_starts_work(qt calls = [] window = load_window(qtbot, tmp_path, monkeypatch, verifier=lambda request: calls.append(request.block_name)) window.show() + queue_release, queue_worker = hold_native_queue(window) retain(monkeypatch, window.mentor_lmc_path) window.search_edit.setText('Beta') window.verify_all() @@ -167,15 +184,16 @@ def test_repeat_verify_then_stop_then_delayed_release_click_never_starts_work(qt for _ in range(5): qtbot.mouseClick(window.batch_button, Qt.LeftButton) window.verify_all() - assert len(window.native_queue.pending) == 1 + assert len(window.native_queue.pending) == 2 qtbot.mouseClick(window.stop_button, Qt.LeftButton) qtbot.waitUntil(lambda: not window.busy) for _ in range(5): window.check_library_release(queued=True) assert calls == [] - assert not window.native_queue.pending + assert len(window.native_queue.pending) == 1 assert getattr(window, 'release_dialog', None) is None finally: + queue_release.set(); queue_worker.join(2) window.stop.set() sessions._retained_libraries.clear() window.native_queue.wake() @@ -186,11 +204,14 @@ def test_repeat_verify_then_stop_then_delayed_release_click_never_starts_work(qt def test_foreground_completion_and_background_cancel_keep_only_live_waits(qtbot, tmp_path, monkeypatch, foreground_finishes_first): window = load_window(qtbot, tmp_path, monkeypatch, - verifier=lambda _: pytest.fail('A retained library must not start a native check')) + verifier=lambda _: pytest.fail('An intentionally paused check must not execute')) window.show() + queue_release, queue_worker = hold_native_queue(window) retain(monkeypatch, window.mentor_lmc_path) window._run(['Beta'], maintenance=True) + window.icdb_task.pause() qtbot.waitUntil(lambda: window.queue_release_button.isVisible()) + queue_release.set(); queue_worker.join(2) window.mentor_lmc_path = Path('other.lmc') window.lmc_edit.setText('other.lmc') started, finish = Event(), Event() @@ -215,6 +236,7 @@ def test_foreground_completion_and_background_cancel_keep_only_live_waits(qtbot, if not foreground_finishes_first: assert window.busy finally: + queue_release.set(); queue_worker.join(2) finish.set() window.icdb_task.cancel() sessions._retained_libraries.clear() diff --git a/tests/test_review391.py b/tests/test_review391.py index b47ef37..35b83bd 100644 --- a/tests/test_review391.py +++ b/tests/test_review391.py @@ -49,7 +49,8 @@ def test_batch_result_is_visible_before_queued_refresh_and_survives_user_actions other_started.set();other_release.wait(5) thread=Thread(target=lambda:window.native_queue.run(other));thread.start() try: - qtbot.waitUntil(lambda:len(window.native_queue.pending)==1) + # The queue retains both the active ticket and its waiting successor. + qtbot.waitUntil(lambda:len(window.native_queue.pending)==2) release.set();qtbot.waitUntil(other_started.is_set) qtbot.waitUntil(lambda:getattr(window,'summary',None) is not None,timeout=1500) assert window.summary.isVisible() and window.busy diff --git a/tests/test_ui.py b/tests/test_ui.py index a74fbe3..18e4333 100644 --- a/tests/test_ui.py +++ b/tests/test_ui.py @@ -126,7 +126,8 @@ def test_verify_requires_loaded_library_and_invalidates_on_path_change(qtbot): assert hasattr(window, 'libspec_edit') and hasattr(window, 'dms_edit') window.lmc_edit.setText('different.lmc') assert not window.batch_button.isEnabled() - assert window.cbb_table.rowCount() == 0 + assert window.cbb_table.rowCount() == 1 + assert '失效' in window.library_notice.text() def test_ui_removes_current_cbb_controls_and_hides_advanced_settings(qtbot):