From 29959e2988cf4e458d6ab95e04605e80ade08eda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=98=BF=E7=99=BD=E5=8F=94?= <11794527+absfan@user.noreply.gitee.com> Date: Wed, 4 Nov 2026 14:16:00 +0800 Subject: [PATCH] feat: offer explicit copy recovery after failed ICDB maintenance --- .../2026-11-04-copy-reimport-recovery.md | 24 ++ src/cbb_refresh_verify/library_lock.py | 29 ++- src/cbb_refresh_verify/reimport_recovery.py | 70 +++++ src/cbb_refresh_verify/ui/main_window.py | 84 +++++- .../ui/management_dialog.py | 47 +++- tests/test_library_lock.py | 51 +++- tests/test_reimport_recovery.py | 242 ++++++++++++++++++ 7 files changed, 520 insertions(+), 27 deletions(-) create mode 100644 docs/releases/2026-11-04-copy-reimport-recovery.md create mode 100644 src/cbb_refresh_verify/reimport_recovery.py create mode 100644 tests/test_reimport_recovery.py diff --git a/docs/releases/2026-11-04-copy-reimport-recovery.md b/docs/releases/2026-11-04-copy-reimport-recovery.md new file mode 100644 index 0000000..34bc5ce --- /dev/null +++ b/docs/releases/2026-11-04-copy-reimport-recovery.md @@ -0,0 +1,24 @@ +# ICDB 失败后的副本恢复入口 + +原生修复失败、缺少有效备份,或 Repair 后完整校验失败时,结果窗口提供“选择副本恢复…”;主窗口保留“选择工程副本恢复失败项…”,允许关闭结果窗口后继续。单纯占用、未知诊断、仅检查或成功结果不提示替换。 + +入口固定使用本次失败任务的库、名称和分区,不使用用户后来勾选的其他条目。切换中心库使旧入口失效。选择的是库外完整工程的 PRJ 文件,相关 PCB、数据库和依赖资料仍由现有来源检查验证。 + +点击入口只打开来源选择窗口。用户明确确认手动备份、目标库、目标条目及副本后,才在后台检查释放,并复用现有原生移除/导入流程;不自动备份整个库,不自动删除目录代替原生操作。自动校验默认开启。 + +释放检查继续要求原生所有者退出、数据库地址记录处理完毕及独占可读。WMI 查询通过最多 10 秒的只读助手执行,超时不当作空闲;同时检查脚本与校验/修复工作进程。检查不通过显示具体原因、保留阻止记录和恢复入口。未完成的管理写入仍不自动重放。 + +原维护失败记录保持原样。副本恢复建立独立 `reimport-recovery/*/recovery.json`,关联原证据、来源、释放检查和管理结果。上传成功但校验失败继续显示失败;上传并取得 READY 后显示“副本恢复校验通过,版本待核对”,不改称原 ICDB 无损修复成功。 + +按用户要求精简界面:默认只展示目标、副本选择、备份确认和操作结果。开发流程说明已移除,诊断细节和证据路径放入默认收起的日志。恢复执行前仍明确说明先移除原条目再导入副本。 + +## 验收边界 + +- 核心流程专项测试 57 项通过;随后新增的两项主窗口取消/退出复核回归均先复现失败再通过。 +- 完整回归记录为 **1,194 passed / 1 failed**(1,013.66 秒)。该运行启动后用户要求精简 UI,已收集的测试仍断言旧文案“尚未修复成功”,运行时加载的界面已使用“修复未完成”,因此失败。未把该次结果标成全量通过。 +- 最终界面与更新后的测试重新验证 **77 passed**(43.00 秒),包含该失败用例及新增的日志默认收起检查。其余产品逻辑未在此期间修改。 +- 编译、差异检查、独立审查通过。最终冻结构建及启动/正常退出、占用辅助进程冒烟通过,EXE 内 5 个关键模块与当前源码一致。记录在 `diagnostics/copy-reimport-20261104/`。 + +本次验证覆盖 Qt 真实事件循环中的按钮、取消、来源确认、后台等待及故障分支,原生写入边界使用替身,不把这些测试当作 Mentor 修复验收。 + +既有隔离副本仍有 `IP101GR/Work/database/cdbsvr/sAddress.adr`,因此完整库释放条件目前不满足。该情况不能通过忽略地址或强制清除检查点解决,需要先处理对应工程。此前 `1GPHY_8212` 的原始 Repair 后 BackAnnotate 失败结论保持不变,工单未关闭。 diff --git a/src/cbb_refresh_verify/library_lock.py b/src/cbb_refresh_verify/library_lock.py index 8c4d1af..98ec832 100644 --- a/src/cbb_refresh_verify/library_lock.py +++ b/src/cbb_refresh_verify/library_lock.py @@ -288,7 +288,8 @@ def owned_snapshot(path): @contextmanager def _prove_library_released(library): """Hold all native database read handles during explicit lease release.""" - import pythoncom, win32com.client, win32con, win32file + import win32con, win32file + from .owner_probe import query_owners from .scoped_manifest import scan_tree from .native_management import _retained_workers from .native_export_guard import assert_retained_exports_idle, prove_export_copies_released @@ -299,15 +300,24 @@ def _prove_library_released(library): from .com_runtime import initialize_com, uninitialize_com initialized = initialize_com() try: - service = win32com.client.GetObject('winmgmts:') names = ('LibraryManager.exe', 'ExpeditionPCB.exe', 'viewdraw.exe', - 'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe', 'CleanWGLib.exe', *sorted(_OWNER_NAMES)) - query = 'SELECT ProcessId, Name FROM Win32_Process WHERE ' + ' OR '.join( - f"Name='{name}'" for name in names) - owners = [{'pid': int(item.ProcessId), 'name': str(item.Name)} for item in service.ExecQuery(query)] - service = None - if owners: - raise LibraryBusy(f'原生进程仍存在,不能解除协调阻止:{owners}') + 'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe', 'CleanWGLib.exe', + 'cscript.exe', 'wscript.exe', 'python.exe', 'pythonw.exe', + 'CbbRefreshVerify.exe', *sorted(_OWNER_NAMES)) + def check_owners(): + owners = [] + for item in query_owners(names): + if item['pid'] == os.getpid(): + continue + automation = item['name'].casefold() in ('python.exe', 'pythonw.exe', 'cbbrefreshverify.exe') + command = item['command'].casefold() + if not automation or not command or any(flag in command for flag in ( + '--verify-worker', '--repair-worker', '--management-worker')): + owners.append(item) + if owners: + raise LibraryBusy(f'原生进程仍存在,不能解除协调阻止:{owners}') + return owners + check_owners() entries = scan_tree(Path(library).parent) addresses = [str(path) for path in entries if path.name.casefold() == 'saddress.adr'] if addresses: @@ -322,6 +332,7 @@ def _prove_library_released(library): handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None) stack.callback(handle.Close) + owners = check_owners() yield {'native_owners': owners, 'addresses': addresses, 'export_copies': export_copies, 'exclusive_files': [str(path) for path in native]} finally: diff --git a/src/cbb_refresh_verify/reimport_recovery.py b/src/cbb_refresh_verify/reimport_recovery.py new file mode 100644 index 0000000..4905e23 --- /dev/null +++ b/src/cbb_refresh_verify/reimport_recovery.py @@ -0,0 +1,70 @@ +"""Explicit copy-based recovery after failed maintenance; never auto-replay.""" +from dataclasses import asdict +from pathlib import Path +from uuid import uuid4 + + +def offers_reimport(result): + return (result.status == 'FAIL' and result.evidence_path is not None + and any(attempt.get('status') in { + 'REPAIR_VALIDATION_FAILED', 'MISSING_HEALTHY_BACKUP', 'NATIVE_REPAIR_FAILED'} + for attempt in result.recovery_attempts)) + + +def run_reimport_recovery(requests, *, previous_evidence, evidence_dir, + adapter=None, stop=None, progress=None): + from .management import ManagementResult, _write_json, source_project, run_management_batch + from .library_lock import release_retained_library + requests = tuple(requests) + if not requests or stop is not None and stop.is_set(): + return [] + library = requests[0].library.resolve() + evidence_dir = Path(evidence_dir).resolve() + if evidence_dir.is_relative_to(library.parent) or library.parent.is_relative_to(evidence_dir): + raise ValueError('恢复记录必须位于目标库之外。') + root = evidence_dir/('reimport-' + uuid4().hex) + root.mkdir(parents=True) + report = root/'recovery.json' + record = {'library': str(library), 'previous_evidence': previous_evidence, + 'requests': [asdict(r) for r in requests], 'original_repair_succeeded': False} + stage = 'preflight' + def save(stage, **extra): + record.update(stage=stage, **extra) + _write_json(report, record) + def cancelled(): + if stop is not None and stop.is_set(): + save('cancelled', management_started=False) + return True + return False + try: + save(stage, management_started=False) + for request in requests: + if (request.operation != 'update' or request.library.resolve() != library + or not previous_evidence.get(request.name)): + raise ValueError('恢复目标与原失败项不一致。') + source, _, _ = source_project(request.source, request.top_level_block) + if (source.parent.is_relative_to(library.parent) + or library.parent.is_relative_to(source.parent)): + raise ValueError('请选择目标中心库之外的完整工程副本。') + if cancelled(): return [] + stage = 'release_check' + save(stage) + if progress: progress({'stage': stage, 'detail': '正在检查原生会话释放,尚未替换条目'}) + proof = release_retained_library(library, root/'release') + if proof.get('status') != 'RELEASE_CONFIRMED': + raise ValueError('原生会话释放未确认,未开始导入。') + save('released', release=proof) + if cancelled(): return [] + stage = 'management' + save(stage, management_started=True) + results = run_management_batch(requests, adapter=adapter, stop=stop, progress=progress) + save('complete', results=[asdict(result) for result in results], + version_review_required=True) + return results + except Exception as error: + save('release_failed' if stage == 'release_check' else 'failed', detail=str(error)) + guidance = ('请正常关闭提示中的原生程序;若提示数据库地址记录,请先对对应工程执行 ICDB 维护,再重试副本恢复。' + if stage == 'release_check' else '') + return [ManagementResult(r.operation, r.library, r.name, r.partition, r.source, + r.auto_verify, stage, 'BLOCKED' if stage != 'management' else 'RECOVERY_REQUIRED', + False, f'副本恢复未完成:{error}。{guidance}原修复失败记录仍保留。', report) for r in requests] diff --git a/src/cbb_refresh_verify/ui/main_window.py b/src/cbb_refresh_verify/ui/main_window.py index 1e7607f..d0e8b94 100644 --- a/src/cbb_refresh_verify/ui/main_window.py +++ b/src/cbb_refresh_verify/ui/main_window.py @@ -67,6 +67,10 @@ class MainWindow(QWidget): self._management_unsafe = False self._maintenance_recovery_view = False self._reload_after_maintenance = False + self._reimport_offers = () + self._batch_requests = () + self._batch_records = {} + self._reimport_summary_action = None if reader is not None: self.reader = reader elif authoritative_status and os.environ.get('CBB_STATUS_BRIDGE_MODE', 'authoritative').casefold() != 'legacy': @@ -145,6 +149,9 @@ class MainWindow(QWidget): self.icdb_repair_button.setToolTip('忽略 READY 项(包括已勾选项);先由原生工具检查占用和数据库,仅确认当前工程需要 ICDB Repair 时才修复。') self.backup_restore_button = QPushButton('从备份恢复 CBB…') self.backup_restore_button.clicked.connect(self.restore_backup) + self.reimport_button = QPushButton('选择工程副本恢复失败项…') + self.reimport_button.clicked.connect(self.reimport_failed) + self.reimport_button.hide() self.stop_button = QPushButton('当前项完成后停止'); self.stop_button.clicked.connect(self.request_stop) self.logs_button = QPushButton('打开日志目录'); self.logs_button.clicked.connect(self.open_logs) self.recovery_button = QPushButton('打开异常证据'); self.recovery_button.setEnabled(False) @@ -184,8 +191,7 @@ class MainWindow(QWidget): layout.addRow('搜索 / 筛选', filters) layout.addRow(self.counts_label) layout.addRow('CBB 清单(勾选后可批量)', self.cbb_table); layout.addRow('超时', self.timeout_spin) - layout.addRow(QLabel('逐个刷新:命令行启动 ReusableCircuit PCB → Project Integration → 保存并关闭,全程不切换桌面、不移动鼠标。' - '填写 LibSpec 与 DMS 登录配置后,会先执行一次 ReuseBlockImporter 内容检查。')) + layout.addRow(QLabel('逐项校验 CBB,完成后刷新状态。')) controls = QHBoxLayout() for widget in (self.selected_batch_button, self.batch_button, self.stop_button, self.logs_button): controls.addWidget(widget) layout.addRow(controls) @@ -198,6 +204,7 @@ class MainWindow(QWidget): maintenance_row.addWidget(description, 1) maintenance_layout.addLayout(maintenance_row) maintenance_layout.addWidget(self.backup_restore_button) + maintenance_layout.addWidget(self.reimport_button) self.icdb_progress = QProgressBar() self.icdb_progress.setVisible(False) self.icdb_phase = QLabel('') @@ -226,7 +233,12 @@ class MainWindow(QWidget): self.release_library_button.clicked.connect(self.check_library_release) management_layout.addWidget(self.release_library_button) layout.addRow(management) - layout.addRow(self.status_label); layout.addRow(self.output) + layout.addRow(self.status_label) + self.runtime_log_toggle = QToolButton(); self.runtime_log_toggle.setText('查看运行日志') + self.runtime_log_toggle.setCheckable(True) + self.runtime_log_toggle.toggled.connect(self.output.setVisible) + self.output.hide() + layout.addRow(self.runtime_log_toggle); layout.addRow(self.output) layout.addRow(self.recovery_button) self.lmc_edit.textChanged.connect(self._invalidate) for field in (self.libspec_edit, self.dms_edit, self.mentor_bin_edit): @@ -236,6 +248,7 @@ class MainWindow(QWidget): self._update() def _invalidate(self): + 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 = {} @@ -287,6 +300,12 @@ class MainWindow(QWidget): 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()) self.stop_button.setText('取消当前检查并停止队列' if self._global_icdb_run else '当前项完成后停止') + available = bool(self._reimport_offers) and not self.busy and self.management_capabilities['update'].supported + self.reimport_button.setVisible(bool(self._reimport_offers)) + 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) def _show_unfinished_management(self): from cbb_refresh_verify.management import unfinished_operations @@ -338,7 +357,6 @@ class MainWindow(QWidget): self.status_label.setText(reason) return from cbb_refresh_verify.management import ManagementRequest - from .management_dialog import ManagementDialog records = self.selected_records() if operation != 'add' and not records: return @@ -351,19 +369,55 @@ class MainWindow(QWidget): [request(record.name, 'Logical-Physical' if record.logical_type == 'LP' and record.partition_name in ('Reusable Blocks', 'LP') else record.partition_name) for record in records]) - self.management_dialog = ManagementDialog(requests, self, adapter=self.management_adapter) + self._open_management_dialog(requests) + + def _open_management_dialog(self, requests, *, recovery_from=None): + from .management_dialog import ManagementDialog + self._global_icdb_run = False + self.stop.clear() + self._management_is_recovery = bool(recovery_from) + self.management_dialog = ManagementDialog(requests, self, adapter=self.management_adapter, + recovery_from=recovery_from) self._management_results = [] self.management_dialog.completed.connect(self._management_completed) self.management_dialog.finished.connect(self._management_closed) self.busy = True; self._update() self.management_dialog.show() + def reimport_failed(self): + if self.busy or not self._reimport_offers or not self.management_capabilities['update'].supported: + return + from cbb_refresh_verify.management import ManagementRequest + requests, previous = [], {} + library = Path(self.mentor_lmc_path or self.loaded_path) + for req, record, result in self._reimport_offers: + if req.lmc_file != library: + return + partition = ('Logical-Physical' if record.logical_type == 'LP' + and record.partition_name in ('Reusable Blocks', 'LP') else record.partition_name) + requests.append(ManagementRequest('update', library, record.name, partition, + evidence_dir=self.data_root/'management', timeout_seconds=self.timeout_spin.value(), + mapped_drive=getattr(self.library_lease, 'drive', ''), + mapped_remote_root=getattr(self.library_lease, 'remote_root', ''))) + previous[record.name] = str(result.evidence_path) + self._reload_after_maintenance = False + if getattr(self, 'summary', None): self.summary.close() + self._open_management_dialog(requests, recovery_from=previous) + def _management_completed(self, results): self._management_results = results + if (getattr(self, '_management_is_recovery', False) and results + and all(result.safe_to_continue for result in results)): + self._management_unsafe = False + self._maintenance_recovery_view = False + restored = {result.name for result in results if result.status == 'UPLOADED_VERIFIED'} + self._reimport_offers = tuple(offer for offer in self._reimport_offers if offer[1].name not in restored) from .management_dialog import RESULT_LABELS for result in results: self.output.append(f'{result.name}:{RESULT_LABELS.get(result.status, result.status)} ' f'{result.detail}\n{result.evidence_path or ""}') + if getattr(self, '_management_is_recovery', False) and result.status == 'UPLOADED_VERIFIED': + self.output.append('副本恢复校验通过,版本待核对。') if any(not result.safe_to_continue for result in results): self._management_unsafe = True if self.library_lease: @@ -694,6 +748,9 @@ class MainWindow(QWidget): self._update() return requests = [replace(self._request(name), maintenance=maintenance) for name in names] + self._batch_requests = tuple(requests) + self._batch_records = {name: self._records_by_name[name] for name in names} + self._reimport_offers = () self._global_icdb_run = maintenance self._icdb_completed = 0 self.icdb_progress.setVisible(maintenance) @@ -851,6 +908,10 @@ class MainWindow(QWidget): def _batch_done(self, outcome): results, report = outcome[:2] + from cbb_refresh_verify.reimport_recovery import offers_reimport + self._reimport_offers = tuple((req, self._batch_records[req.block_name], result) + for req, result in zip(self._batch_requests, results) + if req.maintenance and req.block_name in self._batch_records and offers_reimport(result)) if self._maintenance_recovery_view and self._global_icdb_run and results: self._reload_after_maintenance = all(result.safe_to_continue for result in results) if len(outcome) > 2: @@ -897,10 +958,20 @@ class MainWindow(QWidget): explanation = '\n首个未完成原因:' + first_failure[:1500] status_text += explanation text += explanation + if self._reimport_offers: + guidance = '\n修复未完成,可选择工程副本恢复。' + text += guidance + status_text += guidance self.status_label.setText(status_text); self.output.append(text) self.summary = QMessageBox(self) self.summary.setWindowTitle('非 READY ICDB 检查与修复结果' if self._global_icdb_run else 'CBB 校验结果'); self.summary.setText(text) self.summary.setIcon(QMessageBox.Warning if failed else QMessageBox.Information) + self._reimport_summary_action = None + if self._reimport_offers: + self.summary.setStandardButtons(QMessageBox.Close) + self._reimport_summary_action = self.summary.addButton('选择副本恢复…', QMessageBox.ActionRole) + self._reimport_summary_action.clicked.connect(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 self.summary.setAttribute(Qt.WA_ShowWithoutActivating) @@ -919,6 +990,9 @@ class MainWindow(QWidget): def request_stop(self): if self.version_dialog is not None: self.version_dialog.reject() + management = getattr(self, 'management_dialog', None) + if management is not None and management.isVisible(): + management.stop.set() self.stop.set(); self.status_label.setText('已请求取消;检查将停止,原生写入只等待安全结束,不强制终止。'); self._update() def _failed(self, error): diff --git a/src/cbb_refresh_verify/ui/management_dialog.py b/src/cbb_refresh_verify/ui/management_dialog.py index b7404cd..6bbeb43 100644 --- a/src/cbb_refresh_verify/ui/management_dialog.py +++ b/src/cbb_refresh_verify/ui/management_dialog.py @@ -20,10 +20,11 @@ RESULT_LABELS = { STAGE_LABELS = { 'prepare_identity': '正在核对来源工程内容', 'catalog_before': '正在核对原生目录', 'baseline': '正在记录中心库内容基线', - 'stage_source': '正在复制并检查来源工程', 'native_remove': '正在原生移除', - 'removed': '原条目已移除', 'native_add': '正在原生上传', 'uploaded': '上传身份已确认', + 'stage_source': '正在复制并检查来源工程', 'native_remove': '正在移除', + 'removed': '原条目已移除', 'native_add': '正在上传', 'uploaded': '上传已确认', 'verify': '正在校验上传结果', 'verified': '校验已返回', 'copy': '正在准备来源副本', 'hash': '正在校验主要文件', + 'release_check': '正在检查工程是否被占用', } @@ -34,13 +35,19 @@ class ManagementSignals(QObject): class ManagementDialog(QDialog): completed = Signal(object) - def __init__(self, requests, parent=None, *, adapter=None, runner=None): + def __init__(self, requests, parent=None, *, adapter=None, runner=None, recovery_from=None): super().__init__(parent) self.templates = tuple(requests) self.template = self.templates[0] self.operation = self.template.operation self.adapter = adapter + self.recovery_from = dict(recovery_from or {}) self.runner = runner or run_management_batch + if self.recovery_from and runner is None: + from ..reimport_recovery import run_reimport_recovery + self.runner = lambda requests, **kwargs: run_reimport_recovery(requests, + previous_evidence=self.recovery_from, + evidence_dir=self.template.evidence_dir.parent/'reimport-recovery', **kwargs) self.busy = False self.executed = False self.stop = Event() @@ -62,16 +69,26 @@ class ManagementDialog(QDialog): self.status_label = QLabel(MANUAL_BACKUP_NOTICE + ' 更新会先移除再重新导入,失败时请使用手动备份恢复。') self.status_label.setWordWrap(True) self.output = QTextEdit(); self.output.setReadOnly(True) + self.output.document().setMaximumBlockCount(2000) + self.output.hide() + self.logs_button = QPushButton('查看日志') + self.logs_button.setCheckable(True) + self.logs_button.toggled.connect(self.output.setVisible) + if self.recovery_from: + self.setWindowTitle('从副本恢复 CBB') + self.status_label.setText('修复未完成。请选择完整工程副本(.prj)。所列 CBB 将替换为副本中的版本。\n' + + MANUAL_BACKUP_NOTICE) + self.output.append('\n'.join(f'原失败记录 {name}:{path}' for name, path in self.recovery_from.items())) 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.close_button = QPushButton('关闭'); self.close_button.clicked.connect(self.reject) layout = QVBoxLayout(self) - layout.addWidget(QLabel(f'目标库:{self.template.library}\n操作记录:{self.template.evidence_dir}')) + layout.addWidget(QLabel(f'目标库:{self.template.library}')) layout.addWidget(self.table) layout.addWidget(self.sources_button); layout.addWidget(self.auto_verify) - layout.addWidget(self.status_label); layout.addWidget(self.output) + layout.addWidget(self.status_label); layout.addWidget(self.logs_button); layout.addWidget(self.output) buttons = QHBoxLayout() for widget in (self.execute_button, self.stop_button, self.close_button): buttons.addWidget(widget) layout.addLayout(buttons) @@ -132,9 +149,12 @@ class ManagementDialog(QDialog): description = ('同名更新会原生移除并重新导入;导入失败需要使用手动备份恢复。' if self.operation == 'update' else '将通过原生操作移除所列 CBB;恢复时需要使用手动备份。' if self.operation == 'remove' else '新增同名冲突会拒绝覆盖,完整来源工程将先复制到暂存区。') + if self.recovery_from: + description = ('将用所选副本替换这些 CBB。操作会先移除原条目,再导入副本;' + '导入失败时需要用备份恢复。请确认副本版本。') answer = QMessageBox.question(self, '确认管理操作', f'{MANUAL_BACKUP_NOTICE}\n{description}\n\n目标库:{self.template.library}\n{preview}\n\n' - f'操作记录与检查点:{self.template.evidence_dir}\n确认继续执行?', QMessageBox.Yes | QMessageBox.No, + '确认继续执行?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if answer != QMessageBox.Yes: return @@ -155,7 +175,8 @@ class ManagementDialog(QDialog): def _progress(self, event): stage = str(event.get('stage', '')) - text = f'{event.get("block", "")} {STAGE_LABELS.get(stage, RESULT_LABELS.get(stage, stage))}' + text = f'{event.get("block", "")} {STAGE_LABELS.get(stage, RESULT_LABELS.get(stage, "正在处理"))}' + self.output.append(str(event)) if 'copied_files' in event: text += f' {event["copied_files"]}/{event.get("total_files", "?")}' elif 'hashed_files' in event: @@ -163,14 +184,20 @@ class ManagementDialog(QDialog): self.status_label.setText(text) def _result(self, results): - lines = [] + lines, summaries = [], [] for result in results: - text = f'{result.name}:{RESULT_LABELS.get(result.status, result.status)} — {result.detail}' + summary = f'{result.name}:{RESULT_LABELS.get(result.status, result.status)}' + text = f'{summary} — {result.detail}' + if self.recovery_from and result.status == 'UPLOADED_VERIFIED': + summary += ',版本待核对。' + elif result.status not in ('UPLOADED', 'UPLOADED_VERIFIED', 'REMOVED'): + summary += ',详情请查看日志。' + summaries.append(summary) if result.evidence_path: text += f'\n记录:{result.evidence_path}' lines.append(text) message = '\n'.join(lines) if lines else '队列已取消,未执行任何项。' - self.status_label.setText(message); self.output.append(message) + self.status_label.setText('\n'.join(summaries) if summaries else message); self.output.append(message) self.completed.emit(results) def _failed(self, error): diff --git a/tests/test_library_lock.py b/tests/test_library_lock.py index d65c417..fa9d8b3 100644 --- a/tests/test_library_lock.py +++ b/tests/test_library_lock.py @@ -118,9 +118,8 @@ def test_explicit_release_requires_fresh_proof_and_never_deletes_sidecar(tmp_pat def test_release_proof_checks_addresses_and_exclusive_databases(tmp_path, monkeypatch): import cbb_refresh_verify.library_lock as locks - import win32com.client - from types import SimpleNamespace - monkeypatch.setattr(win32com.client, 'GetObject', lambda *_: SimpleNamespace(ExecQuery=lambda *_: [])) + import cbb_refresh_verify.owner_probe as probe + monkeypatch.setattr(probe, 'query_owners', lambda *_: []) library = tmp_path/'lib.lmc'; library.touch() address = tmp_path/'database/cdbsvr/sAddress.adr'; address.parent.mkdir(parents=True) address.touch() @@ -138,6 +137,52 @@ def test_release_proof_checks_addresses_and_exclusive_databases(tmp_path, monkey assert proof['exclusive_files'] == [str(library)] +def test_release_probe_timeout_does_not_clear_retained_checkpoint(tmp_path, monkeypatch): + import cbb_refresh_verify.library_lock as locks + import cbb_refresh_verify.owner_probe as probe + library = tmp_path/'library/lib.lmc'; library.parent.mkdir(); library.touch() + with locks.LibraryLock(library, safe_to_release=lambda: False) as lease: pass + marker = locks.blocker_path(library) + before = marker.read_bytes() + def timeout(*args): raise RuntimeError('OWNER_QUERY_TIMEOUT') + monkeypatch.setattr(probe, 'query_owners', timeout) + try: + with pytest.raises(RuntimeError, match='OWNER_QUERY_TIMEOUT'): + locks.release_retained_library(library, tmp_path/'release') + assert marker.read_bytes() == before + finally: + with locks._guard: + owner = locks._owners.pop(lease.key, None) + if owner: owner['handle'].Close() + + +@pytest.mark.parametrize('name,command', [ + ('cscript.exe', 'cscript.exe close_failed_block.vbs'), + ('python.exe', 'python.exe -m cbb_refresh_verify --repair-worker job.json'), +]) +def test_release_proof_waits_for_late_operation_helpers(tmp_path, monkeypatch, name, command): + import cbb_refresh_verify.library_lock as locks + import cbb_refresh_verify.owner_probe as probe + library = tmp_path/'lib.lmc'; library.touch() + monkeypatch.setattr(probe, 'query_owners', lambda names: + [{'pid': 123456, 'name': name, 'command': command}] if name in names else []) + with pytest.raises(locks.LibraryBusy, match='123456'): + with locks._prove_library_released(library): pass + + +def test_release_rechecks_owners_after_database_handles_are_acquired(tmp_path, monkeypatch): + import cbb_refresh_verify.library_lock as locks + import cbb_refresh_verify.owner_probe as probe + library = tmp_path/'lib.lmc'; library.touch() + calls = [] + def query(names): + calls.append(1) + return [] if len(calls) == 1 else [{'pid': 123456, 'name': 'cscript.exe', 'command': 'helper'}] + monkeypatch.setattr(probe, 'query_owners', query) + with pytest.raises(locks.LibraryBusy, match='123456'): + with locks._prove_library_released(library): pass + + def test_public_verify_initializes_com_in_its_operation_thread(tmp_path, monkeypatch): import ctypes import cbb_refresh_verify.verify_runner as runner diff --git a/tests/test_reimport_recovery.py b/tests/test_reimport_recovery.py new file mode 100644 index 0000000..1c203d5 --- /dev/null +++ b/tests/test_reimport_recovery.py @@ -0,0 +1,242 @@ +from dataclasses import replace +from pathlib import Path +from threading import Event +from types import SimpleNamespace + +import pytest +from PySide6.QtCore import QTimer +from PySide6.QtWidgets import QMessageBox + +from cbb_refresh_verify.management import Capability, ManagementRequest, ManagementResult +from cbb_refresh_verify.verify_runner import VerifyResult + + +def failed_repair(path, *, safe=False): + return VerifyResult('FAIL', error_category='CBB_REIMPORT_REQUIRED', + stderr='Back Annotation is not allowed on verified (or once verified) Reusable Blocks.', + evidence_path=path, safe_to_continue=safe, + recovery_attempts=({'native_status': 'REPAIRED', 'status': 'REPAIR_VALIDATION_FAILED', + 'validation_passed': False},)) + + +def recovery_window(qtbot, tmp_path, monkeypatch, result=None): + from test_ui_filters import load_window + adapter = SimpleNamespace(capabilities=lambda: {op: Capability(True, 'available') + for op in ('add', 'update', 'remove')}) + result = result or failed_repair(tmp_path/'maintenance/result.json') + window = load_window(qtbot, tmp_path, monkeypatch, management_adapter=adapter, + verifier=lambda _: result, status_refresher=lambda names, path: {n: 'PENDING' for n in names}) + window.search_edit.setText('Beta') + window.repair_icdb_all() + qtbot.waitUntil(lambda: not window.busy) + return window, result + + +def test_failed_repair_offers_copy_import_bound_to_failed_target(qtbot, tmp_path, monkeypatch): + window, failed = recovery_window(qtbot, tmp_path, monkeypatch) + assert '副本' in window.summary.text() + action = next(b for b in window.summary.buttons() if '副本' in b.text()) + window.search_edit.setText('Alpha') + window.select_visible_button.click() + action.click() + dialog = window.management_dialog + requests = dialog.requests() + assert len(requests) == 1 and requests[0].name == 'Beta' + assert requests[0].partition == 'Power' and requests[0].operation == 'update' + assert requests[0].source is None and requests[0].auto_verify + assert '修复未完成' in dialog.status_label.text() + assert '手动备份' in dialog.status_label.text() + assert str(failed.evidence_path) in dialog.output.toPlainText() + dialog.reject() + assert failed.status == 'FAIL' + assert window.reimport_button.isEnabled() + + +def test_declining_reimport_confirmation_does_not_check_release_or_write(qtbot, tmp_path, monkeypatch): + import cbb_refresh_verify.library_lock as locks + window, _ = recovery_window(qtbot, tmp_path, monkeypatch) + window.summary.close() + window.reimport_button.click() + dialog = window.management_dialog + source = tmp_path/'copy/test.prj'; source.parent.mkdir(); source.touch() + dialog.add_sources([source]) + monkeypatch.setattr(locks, 'release_retained_library', lambda *a: pytest.fail('unconfirmed release')) + confirmations = [] + monkeypatch.setattr(QMessageBox, 'question', lambda *a, **kw: + confirmations.append(a[2]) or QMessageBox.No) + dialog.execute_button.click() + assert not dialog.busy and not dialog.executed + assert 'Beta' in confirmations[0] and str(source) in confirmations[0] + assert '副本' in confirmations[0] and '先移除' in confirmations[0] + dialog.reject() + + +@pytest.mark.parametrize('result', [VerifyResult('CHECKED'), VerifyResult('PASS', library_flag='GREEN'), + VerifyResult('BLOCKED', error_category='ICDB_DATABASE_IN_USE', safe_to_continue=False), + VerifyResult('FAIL', stderr='unknown error')]) +def test_no_reimport_offer_for_unconfirmed_diagnosis_or_success(qtbot, tmp_path, monkeypatch, result): + window, _ = recovery_window(qtbot, tmp_path, monkeypatch, result) + assert not window.reimport_button.isVisible() + assert not any('副本' in b.text() for b in window.summary.buttons()) + + +def test_changing_library_invalidates_old_reimport_offer(qtbot, tmp_path, monkeypatch): + window, _ = recovery_window(qtbot, tmp_path, monkeypatch) + old_action = next(b for b in window.summary.buttons() if '副本' in b.text()) + window.lmc_edit.setText('another.lmc') + old_action.click() + assert not getattr(window, 'management_dialog', None) + assert not window.reimport_button.isVisible() + + +def request(tmp_path): + library = tmp_path/'lib/mentor.lmc'; library.parent.mkdir(); library.touch() + source = tmp_path/'copy/Block.prj'; source.parent.mkdir(); source.touch() + return ManagementRequest('update', library, 'Block', source=source, evidence_dir=tmp_path/'management') + + +def test_release_failure_preserves_failure_and_never_dispatches_management(tmp_path, monkeypatch): + from cbb_refresh_verify.reimport_recovery import run_reimport_recovery + import cbb_refresh_verify.library_lock as locks + import cbb_refresh_verify.management as management + req = request(tmp_path) + monkeypatch.setattr(management, 'source_project', lambda *a: (req.source, req.source, 'Block')) + def denied(*a): raise locks.LibraryBusy('PCB still active: 123') + monkeypatch.setattr(locks, 'release_retained_library', denied) + monkeypatch.setattr(management, 'run_management_batch', lambda *a, **kw: pytest.fail('unsafe write')) + results = run_reimport_recovery([req], previous_evidence={'Block': tmp_path/'old/result.json'}, + evidence_dir=tmp_path/'reimport') + assert results[0].status == 'BLOCKED' and not results[0].safe_to_continue + assert '123' in results[0].detail + import json + record = json.loads(results[0].evidence_path.read_text('utf-8')) + assert record['previous_evidence']['Block'] == str(tmp_path/'old/result.json') + assert record['stage'] == 'release_failed' + + +def test_cancel_during_release_prevents_import(tmp_path, monkeypatch): + from cbb_refresh_verify.reimport_recovery import run_reimport_recovery + import cbb_refresh_verify.library_lock as locks + import cbb_refresh_verify.management as management + req = request(tmp_path); stop = Event() + monkeypatch.setattr(management, 'source_project', lambda *a: (req.source, req.source, 'Block')) + def release(*a): + stop.set() + return {'status': 'RELEASE_CONFIRMED', 'evidence_path': 'release.json'} + monkeypatch.setattr(locks, 'release_retained_library', release) + monkeypatch.setattr(management, 'run_management_batch', lambda *a, **kw: pytest.fail('cancelled write')) + results = run_reimport_recovery([req], previous_evidence={'Block': 'old.json'}, + evidence_dir=tmp_path/'reimport', stop=stop) + assert results == [] + + +@pytest.mark.parametrize('uploaded_status', ['UPLOADED', 'UPLOADED_VERIFY_FAILED', 'UPLOADED_VERIFIED']) +def test_copy_recovery_keeps_native_management_outcome_and_original_evidence(tmp_path, monkeypatch, uploaded_status): + from cbb_refresh_verify.reimport_recovery import run_reimport_recovery + import cbb_refresh_verify.library_lock as locks + import cbb_refresh_verify.management as management + import json + req = request(tmp_path) + old = tmp_path/'old.json'; old.write_text('{"status":"FAIL"}', encoding='utf-8') + before = old.read_bytes() + monkeypatch.setattr(management, 'source_project', lambda *a: (req.source, req.source, 'Block')) + monkeypatch.setattr(locks, 'release_retained_library', lambda *a: + {'status': 'RELEASE_CONFIRMED', 'evidence_path': 'release.json'}) + expected = ManagementResult('update', req.library, req.name, req.partition, req.source, + True, 'complete', uploaded_status, True) + monkeypatch.setattr(management, 'run_management_batch', lambda *a, **kw: [expected]) + results = run_reimport_recovery([req], previous_evidence={'Block': str(old)}, + evidence_dir=tmp_path/'reimport') + assert results == [expected] and old.read_bytes() == before + record = json.loads(next((tmp_path/'reimport').glob('*/recovery.json')).read_text('utf-8')) + assert record['original_repair_succeeded'] is False + assert record['results'][0]['status'] == uploaded_status and record['version_review_required'] + + +def test_incomplete_copy_never_releases_or_removes_target(tmp_path, monkeypatch): + from cbb_refresh_verify.reimport_recovery import run_reimport_recovery + import cbb_refresh_verify.library_lock as locks + req = request(tmp_path) # Empty PRJ is deliberately incomplete. + monkeypatch.setattr(locks, 'release_retained_library', lambda *a: pytest.fail('incomplete source')) + results = run_reimport_recovery([req], previous_evidence={'Block': 'old.json'}, + evidence_dir=tmp_path/'reimport') + assert results[0].status == 'BLOCKED' and results[0].stage == 'preflight' + + +def test_recovery_uses_background_release_then_existing_management(qtbot, tmp_path, monkeypatch): + from cbb_refresh_verify.ui.management_dialog import ManagementDialog + import cbb_refresh_verify.library_lock as locks + import cbb_refresh_verify.management as management + req = request(tmp_path); entered, finish = Event(), Event(); calls = [] + monkeypatch.setattr(management, 'source_project', lambda *a: (req.source, req.source, 'Block')) + def release(*a): + entered.set(); assert finish.wait(5) + calls.append('release') + return {'status': 'RELEASE_CONFIRMED', 'evidence_path': 'release.json'} + monkeypatch.setattr(locks, 'release_retained_library', release) + def run(items, **kw): + calls.append('management') + return [ManagementResult('update', req.library, req.name, req.partition, req.source, + True, 'complete', 'UPLOADED_VERIFIED', True)] + monkeypatch.setattr(management, 'run_management_batch', run) + monkeypatch.setattr(QMessageBox, 'question', lambda *a, **kw: QMessageBox.Yes) + dialog = ManagementDialog([req], recovery_from={'Block': 'old.json'}) + qtbot.addWidget(dialog) + ticks = [] + timer = QTimer(); timer.setInterval(10); timer.timeout.connect(lambda: ticks.append(1)); timer.start() + try: + dialog.execute_button.click() + qtbot.waitUntil(entered.is_set) + qtbot.waitUntil(lambda: len(ticks) >= 3) + assert calls == [] and dialog.busy + finally: + finish.set() + qtbot.waitUntil(lambda: not dialog.busy) + timer.stop() + assert calls == ['release', 'management'] + assert '版本待核对' in dialog.status_label.text() + + +def test_recovery_dialog_keeps_internal_details_in_optional_log(qtbot, tmp_path): + from cbb_refresh_verify.ui.management_dialog import ManagementDialog + req = request(tmp_path) + dialog = ManagementDialog([req], recovery_from={'Block': 'old-result.json'}) + qtbot.addWidget(dialog); dialog.show() + assert dialog.output.isHidden() + assert not any(word in dialog.status_label.text() for word in ('原生', '证据', '检查点', '记录保留')) + detail = 'OWNER_QUERY_TIMEOUT: diagnostic internals' + result = ManagementResult('update', req.library, req.name, req.partition, req.source, + True, 'release_check', 'BLOCKED', False, detail, tmp_path/'recovery.json') + dialog._result([result]) + assert detail not in dialog.status_label.text() + assert '日志' in dialog.status_label.text() + dialog.logs_button.click() + assert dialog.output.isVisible() and detail in dialog.output.toPlainText() + + +def test_main_stop_during_recovery_release_cancels_import(qtbot, tmp_path, monkeypatch): + import cbb_refresh_verify.library_lock as locks + import cbb_refresh_verify.management as management + window, _ = recovery_window(qtbot, tmp_path, monkeypatch) + window.summary.close(); window.reimport_button.click() + dialog = window.management_dialog + source = tmp_path/'copy/source.prj'; source.parent.mkdir(); source.touch() + dialog.add_sources([source]) + monkeypatch.setattr(management, 'source_project', lambda *a: (source, source, 'Beta')) + entered, finish = Event(), Event() + def release(*args): + entered.set(); assert finish.wait(5) + return {'status': 'RELEASE_CONFIRMED', 'evidence_path': 'release.json'} + monkeypatch.setattr(locks, 'release_retained_library', release) + dispatched = [] + monkeypatch.setattr(management, 'run_management_batch', lambda *a, **kw: dispatched.append(a) or []) + dialog.execute_button.click() + try: + qtbot.waitUntil(entered.is_set) + window.stop_button.click() + assert dialog.stop.is_set() + finally: + finish.set(); qtbot.waitUntil(lambda: not dialog.busy) + dialog.reject() + assert dispatched == [] +