diff --git a/docs/releases/2026-11-09-pr11-review345.md b/docs/releases/2026-11-09-pr11-review345.md new file mode 100644 index 0000000..8eb3ddd --- /dev/null +++ b/docs/releases/2026-11-09-pr11-review345.md @@ -0,0 +1,38 @@ +# PR11 review 345 follow-up + +Repeated CBB verification and ICDB check runs replace the previous result dialog +for the same operation. Closing a result retires its Qt widgets and action +references, while the check task keeps its requests, results, invalidated targets, +and recovery context. A result for the other operation stays available. + +During application shutdown, the title and status show that background work and +path release are pending. After approximately 120 seconds a second notice says +the application is still waiting. This is a notice interval, not a deadline; +shutdown still waits for existing workers and never forces native tools to stop. + +The batch CLI accepts an optional positive `--limit`: + +```powershell +python -m cbb_refresh_verify --batch-lmc 'Z:\library\library.lmc' --limit 2 +``` + +The limit selects the first requested names in their existing order. With no +`--block`, the existing non-READY selection supplies those names; repeated +`--block` options retain their explicit order. Omitting `--limit` retains the +existing all-requested behavior. `batch_selection` logs selected, total, and +remaining counts. On batch exceptions or unconfirmed native release, +`batch_drive_retained` identifies the drive, remote share, display library and +Mentor path, and directs the operator to the confirmed-release entry. It never +disconnects a mapping while a native writer may still be active. + +Management change counts explicitly cover the compared engineering files only. + +Removed from the standalone PR11 head: all five `if False` blocks for the later +release flow, and `_reload_after_maintenance` assignments and its unused reload +branch. The hidden release control and existing method signatures remain for +the later PR12 implementation. When integrating forward, preserve PR12's live +release/resume behavior and retire its dialog-owned action references as well. +Preserve PR13's asynchronous close and lease guards when adding the wait notice. + +Validation uses the isolated offscreen review wrapper with fake native boundaries; +it does not open Mentor, kill native processes, invoke Repair, or back up a library. diff --git a/docs/reviews/2026-11-05-native-backend.md b/docs/reviews/2026-11-05-native-backend.md index da20c81..130deca 100644 --- a/docs/reviews/2026-11-05-native-backend.md +++ b/docs/reviews/2026-11-05-native-backend.md @@ -9,3 +9,12 @@ Dependency rationale: library release imports native engineering identity and re Rollback: before dependents are merged, revert this commit. After merging dependents, revert in reverse order or use the previous candidate package after closing the current app. Code rollback does not undo a native transaction; use a consistent manual backup or explicitly selected native history on an isolated copy. Validation: full Python suite 1,376 passed (one existing pywinauto COM-threading warning); compileall and git diff --check passed. Native field recovery, Windows 10 and cross-machine shared-library acceptance remain pending. + +Review comment 344 follow-up (2026-11-09): + +- Production status scans continue to query fresh bridge results. The low-level session now also defaults to fresh scans; explicit checkpoint reuse is documented as a controlled read-only option with no production resume promise. +- `library-changes.json` declares `rule_version`, the selected `scope`, excluded directory categories and suffixes, positional runtime rules, runtime filenames/prefixes, and recognized coordination checkpoints. Names, suffixes, prefixes and native database locations come from the same constants used by semantic classification. These are differences in participating engineering files; excluded content is not proven unchanged, and unrelated CBB content is not checked. +- Removed the tests-only `pcb_bridge.execution_outcome` helper. Production release safety continues to come from observed release state and remaining clients. +- Unlocked primary snapshots hash the copy stream, then independently hash the final source and destination. Source reads decrease from three to two. Rejected the suggestion to remove/threshold the final source hash: size and mtime cannot detect same-size, same-timestamp source edits. Locked LMC/icdb streams and owned lock snapshots retain their existing behavior; no source-rehash skip flag is added. + +Validation for this follow-up: 287 targeted cases passed through the isolated mutex/PYTHONPATH wrapper (`test_batch_status`, `test_batch_status_faults`, `test_review_backend_followup`, `test_scoped_manifest`, `test_pcb_bridge`, `test_management_retry_blockers`, `test_backup_recovery`, `test_library_lock`, `test_management`). AST parsing, `git diff --check`, and original newline-style checks passed. No real Mentor, COM automation, shared library or process control was exercised; no full-suite run was requested. diff --git a/docs/superpowers/plans/2026-09-18-batch-status-bridge.md b/docs/superpowers/plans/2026-09-18-batch-status-bridge.md index 2e043da..fe02870 100644 --- a/docs/superpowers/plans/2026-09-18-batch-status-bridge.md +++ b/docs/superpowers/plans/2026-09-18-batch-status-bridge.md @@ -1,5 +1,7 @@ # CBB Batch Status Bridge Implementation Plan +Current behavior (2026-11-09): production status scans always query the bridge fresh and overwrite checkpoint evidence. `BatchStatusSession.scan` defaults to `resume=False`; `resume=True` remains an explicit low-level option for controlled read-only scans, not an exposed production resume feature. Its lightweight fingerprint cannot detect every native payload/database write, so saved READY/PENDING rows must not authorize production actions. + > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. **Goal:** Read 180 to 3000 CBB Verify states through one resilient x86 Mentor bridge session with checkpoint recovery and authoritative `READY/PENDING` results. diff --git a/docs/superpowers/specs/2026-09-18-batch-status-bridge-design.md b/docs/superpowers/specs/2026-09-18-batch-status-bridge-design.md index b7eba51..bcd2cc6 100644 --- a/docs/superpowers/specs/2026-09-18-batch-status-bridge-design.md +++ b/docs/superpowers/specs/2026-09-18-batch-status-bridge-design.md @@ -1,5 +1,7 @@ # CBB 批量状态桥设计 +Current behavior (2026-11-09): production status scans always query the bridge fresh and overwrite checkpoint evidence. `BatchStatusSession.scan` defaults to `resume=False`; `resume=True` remains an explicit low-level option for controlled read-only scans, not an exposed production resume feature. Its lightweight fingerprint cannot detect every native payload/database write, so saved READY/PENDING rows must not authorize production actions. + ## 目标 支持对 180 到 3000 个 CBB 进行 Mentor authoritative Verify 状态读取,要求单条失败隔离、过程可恢复、结果可审计,并避免现有“一条 CBB 启动一个桥进程”的启动开销。 diff --git a/src/cbb_refresh_verify/application.py b/src/cbb_refresh_verify/application.py index 8d2fb88..8fe6dad 100644 --- a/src/cbb_refresh_verify/application.py +++ b/src/cbb_refresh_verify/application.py @@ -46,6 +46,16 @@ def resolve_data_root(cli_value: Path | None) -> Path: local = os.environ.get("LOCALAPPDATA") return (Path(local) / "CbbRefreshVerify" if local else Path.home() / "AppData" / "Local" / "CbbRefreshVerify").resolve() +def _positive_int(value): + try: + number = int(value) + except ValueError: + raise argparse.ArgumentTypeError('must be a positive integer') from None + if number <= 0: + raise argparse.ArgumentTypeError('must be a positive integer') + return number + + def main(argv: Sequence[str] | None = None) -> int: parser = argparse.ArgumentParser(prog="CbbRefreshVerify") parser.add_argument('--verify-worker', type=Path, help=argparse.SUPPRESS) @@ -57,6 +67,7 @@ def main(argv: Sequence[str] | None = None) -> int: parser.add_argument('--collect-failure-logs', type=Path, help=argparse.SUPPRESS) parser.add_argument('--batch-lmc', type=Path, help=argparse.SUPPRESS) parser.add_argument('--block', action='append', default=[], help=argparse.SUPPRESS) + parser.add_argument('--limit', type=_positive_int, help='Maximum requested CBB names for --batch-lmc (default: all)') parser.add_argument('--libspec', default='', help=argparse.SUPPRESS) parser.add_argument('--dms-login-config', default='', help=argparse.SUPPRESS) parser.add_argument('--mentor-bin', default='', help=argparse.SUPPRESS) @@ -110,6 +121,11 @@ def main(argv: Sequence[str] | None = None) -> int: if library.error: raise RuntimeError(library.error) names = [record.name for record in library.records if record.status != 'READY'] if not names: raise RuntimeError('中心库未读取到需要校验的 CBB') + total = len(names) + if args.limit is not None: + names = names[:args.limit] + logger.info('batch_selection selected=%s total=%s remaining=%s limit=%s', + len(names), total, total - len(names), args.limit or 'all') requests = [VerifyRequest(mentor_path, name, context.root/'evidence', libspec=args.libspec, dms_login_config=args.dms_login_config, mentor_bin=args.mentor_bin, logging_context=context, @@ -117,13 +133,21 @@ def main(argv: Sequence[str] | None = None) -> int: mapped_remote_root=lease.remote_root, native_lm_verify=native_lm_verify_enabled()) for name in names] + def retain_mapping(reason): + lease.retain_for_recovery() + logger.warning( + 'batch_drive_retained drive=%s remote=%s display=%s mentor=%s reason=%s ' + 'guidance=请打开此中心库的“释放残留会话…”入口,确认原生会话安全释放后再释放映射;' + '原生写入仍可能运行时请保留映射。', + lease.drive or '-', lease.remote_root or '-', lease.display_path, + mentor_path, reason) try: results = run_batch(requests) except Exception: - lease.retain_for_recovery() + retain_mapping('batch_exception') raise if any(not result.safe_to_continue for result in results): - lease.retain_for_recovery() + retain_mapping('native_release_unconfirmed') report = write_batch_report(requests, results, context.root/'reports') logger.info('batch_report path=%s', report) logger.info('failure_report path=%s', failure_report_path(report)) diff --git a/src/cbb_refresh_verify/batch_status.py b/src/cbb_refresh_verify/batch_status.py index f435783..3f796e4 100644 --- a/src/cbb_refresh_verify/batch_status.py +++ b/src/cbb_refresh_verify/batch_status.py @@ -107,7 +107,7 @@ def fingerprint_library(lmc: Path) -> LmcFingerprint: # Metadata alone is not a safe checkpoint key: on network shares and on # file systems with coarse timestamp resolution, two different LMC # contents can have the same size and mtime. Include the actual file - # digest so a changed central library can never reuse an old status row. + # digest to invalidate changed LMC bytes; payload edits remain outside this key. content_sha256 = _sha256_file(path) combined = hashlib.sha256() combined.update(str(path).casefold().encode('utf-8', errors='surrogatepass')) @@ -186,7 +186,12 @@ def _now() -> str: class BatchStatusSession: - """Supervised serial bridge session with checkpoint recovery.""" + """Supervised serial bridge session; fresh status queries by default. + + Checkpoints record scan evidence. Explicit ``resume=True`` is a low-level + opt-in for controlled read-only scans, not a production freshness proof: + the lightweight fingerprint does not cover native payload/database edits. + """ def __init__(self, bridge: StatusBridgeClient, *, timeout_seconds: float = 10.0, rotate_every: int = 500) -> None: @@ -196,7 +201,7 @@ class BatchStatusSession: self.restart_count = 0 def scan(self, names: Iterable[str], lmc_file: Path, checkpoint_path: Path, - *, block_type: str = "RULP", resume: bool = True) -> list[BatchStatusRecord]: + *, block_type: str = "RULP", resume: bool = False) -> list[BatchStatusRecord]: fingerprint = fingerprint_library(Path(lmc_file)) if resume: checkpoint = BatchCheckpoint.load(checkpoint_path) @@ -291,6 +296,8 @@ def authoritative_status_map(names: Iterable[str], lmc_file: Path, checkpoint_pa timeout_seconds: float = 10.0) -> dict[str, str]: """Return only bridge-backed statuses for an optional UI integration. + Production always queries fresh statuses, including after native writes; + saved READY/PENDING rows are never reused here. A missing bridge is represented as ``UNAVAILABLE``/``UNKNOWN`` by callers; it is never promoted to ``READY``. """ diff --git a/src/cbb_refresh_verify/management.py b/src/cbb_refresh_verify/management.py index bcd7266..f1a3347 100644 --- a/src/cbb_refresh_verify/management.py +++ b/src/cbb_refresh_verify/management.py @@ -8,7 +8,7 @@ from uuid import uuid4 from .library_lock import LibraryLock, LibraryBusy from .scoped_manifest import (ManifestScope, build_manifest, build_exclusive_library_manifest, - copy_verified, hash_file, scan_tree) + comparison_rules, copy_verified, hash_file, scan_tree) @dataclass(frozen=True) @@ -212,6 +212,7 @@ def run_management(request, *, adapter=None, verifier=None, idle_check=None, pro nonlocal change_report if mutated and original is not None and change_report is None: change_report = {'status': 'UNCONFIRMED', 'scope': original['scope'], + **comparison_rules(scope), 'unrelated_cbb_content_checked': False, 'detail': '原生会话尚未释放,未读取写后内容'} if safe: diff --git a/src/cbb_refresh_verify/pcb_bridge.py b/src/cbb_refresh_verify/pcb_bridge.py index 1e9ee60..1acb80b 100644 --- a/src/cbb_refresh_verify/pcb_bridge.py +++ b/src/cbb_refresh_verify/pcb_bridge.py @@ -160,18 +160,3 @@ def wait_for_target_document(job, app_provider, *, process_alive, emit=lambda ** last_observation = observation sleep(.25) raise PcbBridgeError('PCB_EXITED_BEFORE_COM', 'PCB 在 COM 文档就绪前退出') - - -def execution_outcome(*, save_complete: bool, pcb_exited: bool, - fatal_error: str = '') -> dict[str, object]: - if fatal_error: - code, _, detail = str(fatal_error).partition(':') - return {'status': 'FAIL', 'error_code': code.strip() or 'FATAL_DIALOG', - 'stderr': detail.strip() or str(fatal_error), 'safe_to_continue': True} - if not save_complete: - return {'status': 'FAIL', 'error_code': 'SAVE_NOT_CONFIRMED', - 'stderr': '保存/关闭未完成', 'safe_to_continue': True} - if not pcb_exited: - return {'status': 'FAIL', 'error_code': 'PCB_EXIT_NOT_CONFIRMED', - 'stderr': '保存后未确认 PCB 退出', 'safe_to_continue': True} - return {'status': 'PASS', 'stdout': 'Project Integration 已同步;保存、关闭和 PCB 退出均已确认。'} diff --git a/src/cbb_refresh_verify/scoped_manifest.py b/src/cbb_refresh_verify/scoped_manifest.py index a83fa04..ab1015c 100644 --- a/src/cbb_refresh_verify/scoped_manifest.py +++ b/src/cbb_refresh_verify/scoped_manifest.py @@ -15,6 +15,15 @@ import stat MANIFEST_VERSION = 1 +MANIFEST_RULE_VERSION = 1 +_ROOT_RUNTIME_PREFIX = 'work.before-restore-' +_ROOT_RUNTIME_PATH = ('projectbackup', 'backups') +_NATIVE_RUNTIME_DIRECTORIES = ('log', 'dbcheck', 'dbrestore') +_NATIVE_SERVER_DIRECTORY = 'cdbsvr' +_PROJECT_PCB_DIRECTORY = 'pcb' +_PROJECT_DATABASE_PREFIXES = (('database',), (_PROJECT_PCB_DIRECTORY, 'database')) +_NONPRIMARY_FILENAMES = ('saddress.adr',) +_NONPRIMARY_FILENAME_PREFIXES = ('~$',) _NONPRIMARY_DIRECTORIES = frozenset({ 'log', 'logs', 'temp', 'tmp', '__pycache__', 'backup', 'backups', 'output', 'outputs', 'report', 'reports', 'gerber', 'gerbers', 'odb++', @@ -29,22 +38,21 @@ def _root_runtime(directories): """Known runtime/history children of a library or project workspace root.""" return bool(directories and ( directories[0] in _NONPRIMARY_DIRECTORIES - or directories[0].startswith('work.before-restore-') - or directories[:2] == ('projectbackup', 'backups'))) + or directories[0].startswith(_ROOT_RUNTIME_PREFIX) + or directories[:len(_ROOT_RUNTIME_PATH)] == _ROOT_RUNTIME_PATH)) def _native_runtime(directories, database_prefix): - runtime_prefix = database_prefix + ('cdbsvr',) + runtime_prefix = database_prefix + (_NATIVE_SERVER_DIRECTORY,) return (directories[:len(runtime_prefix)] == runtime_prefix and len(directories) > len(runtime_prefix) - and directories[len(runtime_prefix)] in ('log', 'dbcheck', 'dbrestore')) + and directories[len(runtime_prefix)] in _NATIVE_RUNTIME_DIRECTORIES) def _project_runtime(directories): return (_root_runtime(directories) - or (directories[:1] == ('pcb',) and _root_runtime(directories[1:])) - or _native_runtime(directories, ('database',)) - or _native_runtime(directories, ('pcb', 'database'))) + or (directories[:1] == (_PROJECT_PCB_DIRECTORY,) and _root_runtime(directories[1:])) + or any(_native_runtime(directories, prefix) for prefix in _PROJECT_DATABASE_PREFIXES)) @dataclass(frozen=True) @@ -85,7 +93,8 @@ class ManifestScope: """ directories = parts if directory else parts[:-1] if not directory and (Path(parts[-1]).suffix in _NONPRIMARY_SUFFIXES - or parts[-1] == 'saddress.adr' or parts[-1].startswith('~$')): + or parts[-1] in _NONPRIMARY_FILENAMES + or parts[-1].startswith(_NONPRIMARY_FILENAME_PREFIXES)): return True if self.kind == 'project': return _project_runtime(directories) @@ -123,6 +132,36 @@ class ManifestScope: return 'shared_dependency' +def comparison_rules(scope): + """Describe semantic exclusions using the classifier's rule constants.""" + project_positions = ['project root or its PCB child'] + project_native = ' or '.join('/'.join(prefix + (_NATIVE_SERVER_DIRECTORY,)) + for prefix in _PROJECT_DATABASE_PREFIXES) + native_positions = [project_native + ' under project root'] + if scope.kind == 'library': + project_positions = ['library root', 'selected CBB Work/Cert root or its PCB child'] + native_positions = [ + project_native + ' under selected CBB Work/Cert', + 'SymbolLibs//' + _NATIVE_SERVER_DIRECTORY, + '/' + _NATIVE_SERVER_DIRECTORY, + ] + return { + 'rule_version': MANIFEST_RULE_VERSION, + 'excluded_categories': sorted(_NONPRIMARY_DIRECTORIES), + 'excluded_suffixes': sorted(_NONPRIMARY_SUFFIXES), + 'runtime_exclusions': { + 'directory_name_positions': project_positions, + 'directory_prefixes': [_ROOT_RUNTIME_PREFIX], + 'relative_directories': ['/'.join(_ROOT_RUNTIME_PATH)], + 'native_directory_names': sorted(_NATIVE_RUNTIME_DIRECTORIES), + 'native_directory_positions': native_positions, + 'file_names': list(_NONPRIMARY_FILENAMES), + 'file_name_prefixes': list(_NONPRIMARY_FILENAME_PREFIXES), + 'coordination_checkpoints': 'recognized CBB coordination checkpoints', + }, + } + + def hash_file(path): digest = hashlib.sha256() with Path(path).open('rb') as stream: @@ -271,7 +310,10 @@ def copy_verified(source, destination, *, scope=None, progress=None, hash_functi Native icdb.dat/LMC files are held with exclusive read handles for the copy. Their expected SHA256 comes from the source read stream, independently of - hashing destination bytes. Failures retain the partial destination evidence. + hashing destination bytes. Unlocked primary files are also hashed while + streaming the copy, then rehashed at source to detect even same-size/mtime + edits. Every primary destination is independently hashed. Failures retain + the partial destination evidence. Progress receives one dict with stage, hashed_files/bytes and copied_files. """ import win32con @@ -329,9 +371,15 @@ def copy_verified(source, destination, *, scope=None, progress=None, hash_functi shutil.copystat(path, copied) if stream_hash is not None: digest = stream_hash.hexdigest() + elif label is not None: + stream_hash = hashlib.sha256() + with path.open('rb') as incoming, copied.open('wb') as outgoing: + for data in iter(lambda: incoming.read(1024 * 1024), b''): + stream_hash.update(data) + outgoing.write(data) + shutil.copystat(path, copied) + digest = stream_hash.hexdigest() else: - if label is not None: - digest = hash_function(path) shutil.copy2(path, copied) before, after = entries[path], path.stat() if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns): diff --git a/src/cbb_refresh_verify/ui/main_window.py b/src/cbb_refresh_verify/ui/main_window.py index f32cce2..863a592 100644 --- a/src/cbb_refresh_verify/ui/main_window.py +++ b/src/cbb_refresh_verify/ui/main_window.py @@ -99,7 +99,6 @@ class MainWindow(QWidget): self._management_unsafe_libraries = set() self._management_operation_library = None self._maintenance_recovery_view = False - self._reload_after_maintenance = False self._reimport_offers = () self._batch_requests = () self._batch_records = {} @@ -133,6 +132,10 @@ class MainWindow(QWidget): self._mapping_auto_idle = False self._mapping_finish_waiters = [] self._closing = self._close_ready = False + self.close_wait_timer = QTimer(self) + self.close_wait_timer.setSingleShot(True) + self.close_wait_timer.setInterval(120_000) + self.close_wait_timer.timeout.connect(self._show_close_wait_notice) from cbb_refresh_verify.operation_queue import NativeQueue self.native_queue = NativeQueue() self.icdb_task = None @@ -462,7 +465,7 @@ class MainWindow(QWidget): if self._defer_mapping_finish(self._release_dialog_finished): return self._finished() pending = getattr(self, '_resume_batch', None) - if pending and pending['released']: + if pending and pending['released'] and getattr(self, 'summary', None) is not None: self.summary.setText('会话已释放,可以继续未执行项。') self.summary.show() @@ -584,7 +587,6 @@ class MainWindow(QWidget): 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) @@ -760,7 +762,7 @@ class MainWindow(QWidget): if hasattr(task, 'summary'): prefix = '已更新的工程:'+', '.join(sorted(task.invalidated))+'。下列为此前检查记录。\n' task.summary.setDetailedText(prefix+task.summary.detailedText()) - if names & getattr(task, 'recovery_names', set()): + if names & getattr(task, 'recovery_names', set()) and hasattr(task, 'recovery_action'): task.recovery_action.setEnabled(False) task.recovery_action.setToolTip('工程已有后续管理操作,请重新检查。') self._reimport_offers = tuple(offer for offer in self._reimport_offers if offer[0].block_name not in names @@ -860,7 +862,7 @@ class MainWindow(QWidget): self.icdb_phase.setText(text) if not self.busy: self.status_label.setText(text) self.output.append(text+'\n'+str(task.report or task.report_error)) - summary = QMessageBox(self); self.icdb_summary = summary + summary = self._new_result_summary('icdb_summary') task.summary = summary if not self.busy: self.summary = summary summary.setWindowTitle('ICDB 批量检查结果'); summary.setText(text) @@ -1398,6 +1400,30 @@ class MainWindow(QWidget): if cell is not None: cell.setBackground(QColor('#E8F5E9')) + def _new_result_summary(self, attribute): + previous = getattr(self, attribute, None) + if previous is not None: + previous.close() + summary = QMessageBox(self) + setattr(self, attribute, summary) + summary.setAttribute(Qt.WA_DeleteOnClose) + summary.finished.connect(lambda _: self._forget_result_summary(summary)) + return summary + + def _forget_result_summary(self, summary): + if getattr(self, '_batch_summary', None) is summary: + self._reimport_summary_action = None + self._residual_release_action = None + self._resume_batch_action = None + for attribute in ('summary', '_batch_summary', 'icdb_summary'): + if getattr(self, attribute, None) is summary: + setattr(self, attribute, None) + for task in self.icdb_tasks: + if getattr(task, 'summary', None) is summary: + del task.summary + if hasattr(task, 'recovery_action'): + del task.recovery_action + def _batch_done(self, outcome): results, report = outcome[:2] failure_report = failure_report_path(report) if report is not None else '未写入' @@ -1459,7 +1485,7 @@ class MainWindow(QWidget): text += guidance status_text += guidance self.status_label.setText(status_text.replace('\n', ' ')); self.output.append(text) - self.summary = QMessageBox(self) + self.summary = self._new_result_summary('_batch_summary') self.summary.setWindowTitle('ICDB 批量检查结果' if self._global_icdb_run else 'CBB 校验结果') self.summary.setText(status_text) self.summary.setDetailedText(text) @@ -1529,10 +1555,6 @@ class MainWindow(QWidget): self.version_dialog.reject() self.version_dialog = None self.busy = False; self._update() - if self._reload_after_maintenance: - from PySide6.QtCore import QTimer - self._reload_after_maintenance = False - QTimer.singleShot(0, self.load_library) def open_logs(self): self.data_root.mkdir(parents=True, exist_ok=True); os.startfile(str(self.data_root)) @@ -1554,6 +1576,9 @@ class MainWindow(QWidget): else: self._closing = True self.busy = True; self._update() + self.setWindowTitle('CBB 刷新校验 · 等待任务安全结束') + self.status_label.setText('正在等待当前操作安全结束,完成后关闭。') + self.close_wait_timer.start() retained = None if self._native_backup_session is not None: self.native_backup_timer.stop() @@ -1566,6 +1591,11 @@ class MainWindow(QWidget): self._close_when_idle() event.ignore() + def _show_close_wait_notice(self): + if self._closing and not self._close_ready: + self.setWindowTitle('CBB 刷新校验 · 仍在等待任务安全结束') + self.status_label.setText('当前操作尚未结束,仍在等待安全关闭。') + def _close_when_idle(self): owners = [self, *self.icdb_tasks] for name in ('management_dialog', 'backup_dialog', 'release_dialog'): @@ -1580,5 +1610,6 @@ class MainWindow(QWidget): if self._lease_pending or active: QTimer.singleShot(20, self._close_when_idle) return + 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 f883fad..1f4249c 100644 --- a/src/cbb_refresh_verify/ui/management_dialog.py +++ b/src/cbb_refresh_verify/ui/management_dialog.py @@ -209,8 +209,8 @@ class ManagementDialog(QDialog): changes = getattr(result, 'change_report', None) if changes: if changes.get('status') == 'RECORDED': - text += (f'\n变更:新增 {len(changes["added"])}、删除 {len(changes["deleted"])}、' - f'修改 {len(changes["modified"])} 个主要文件。') + text += (f'\n已比对的工程文件:新增 {len(changes["added"])}、删除 {len(changes["deleted"])}、' + f'修改 {len(changes["modified"])};范围仅限报告列出的工程文件。') else: summary += ',变更清单待核对' text += '\n'+changes.get('detail', '变更清单未确认') diff --git a/tests/test_batch_status.py b/tests/test_batch_status.py index bdbd48e..b90b389 100644 --- a/tests/test_batch_status.py +++ b/tests/test_batch_status.py @@ -84,11 +84,30 @@ def test_scan_reuses_checkpoint_and_queries_only_missing(tmp_path): encoding="utf-8", ) bridge = FakeBridge() - records = BatchStatusSession(bridge).scan(["A", "B"], lmc, checkpoint) + records = BatchStatusSession(bridge).scan(["A", "B"], lmc, checkpoint, resume=True) assert bridge.requests == ["B"] assert {record.block_name for record in records} == {"A", "B"} +def test_default_scan_refreshes_cached_ready_after_payload_change(tmp_path): + lmc = tmp_path/'library.lmc'; lmc.write_bytes(b'library') + checkpoint = tmp_path/'scan.jsonl' + BatchStatusSession(FakeBridge()).scan(['A'], lmc, checkpoint) + # The lightweight fingerprint cannot prove payload status is unchanged. + fingerprint = fingerprint_library(lmc) + (tmp_path/'payload.pcb').write_bytes(b'native edit without LMC change') + assert fingerprint_library(lmc) == fingerprint + class PendingBridge(FakeBridge): + def query(self, *args, **kwargs): + self.requests.append(args[1]) + return BridgeResult('PENDING', 'fake') + bridge = PendingBridge() + records = BatchStatusSession(bridge).scan(['A'], lmc, checkpoint) + assert [record.status for record in records] == ['PENDING'] + assert bridge.requests == ['A'] + assert len(checkpoint.read_text('utf-8').splitlines()) == 1 + + def test_timeout_isolated_and_later_item_continues(tmp_path): lmc = tmp_path / "mentor_lib.lmc" lmc.write_bytes(b"library") @@ -180,7 +199,7 @@ def test_retry_rechecks_failed_scan_without_library_changes(tmp_path): first = BatchStatusSession(FakeBridge(timeout_name='A')).scan(['A', 'B'], lmc, checkpoint) assert first[0].status == 'TIMEOUT' bridge = FakeBridge() - second = BatchStatusSession(bridge).scan(['A', 'B'], lmc, checkpoint) + second = BatchStatusSession(bridge).scan(['A', 'B'], lmc, checkpoint, resume=True) assert bridge.requests == ['A'] assert second[0].status == 'READY' diff --git a/tests/test_batch_status_faults.py b/tests/test_batch_status_faults.py index 9666320..8b06c57 100644 --- a/tests/test_batch_status_faults.py +++ b/tests/test_batch_status_faults.py @@ -82,5 +82,5 @@ def test_fingerprint_change_does_not_reuse_checkpoint(tmp_path): from cbb_refresh_verify.status_bridge import BridgeResult return BridgeResult("PENDING", "fake") bridge = Bridge() - BatchStatusSession(bridge).scan(["A"], lmc, checkpoint) + BatchStatusSession(bridge).scan(["A"], lmc, checkpoint, resume=True) assert bridge.requests == ["A"] diff --git a/tests/test_management_retry_blockers.py b/tests/test_management_retry_blockers.py index 6431884..e3f2b9b 100644 --- a/tests/test_management_retry_blockers.py +++ b/tests/test_management_retry_blockers.py @@ -283,7 +283,7 @@ def test_status_cache_does_not_reuse_a_different_block_type(tmp_path): return BridgeResult('READY', 'test') session = BatchStatusSession(Bridge()) session.scan(['Block'], library, tmp_path/'scan.jsonl', block_type='RULP') - session.scan(['Block'], library, tmp_path/'scan.jsonl', block_type='Other') + session.scan(['Block'], library, tmp_path/'scan.jsonl', block_type='Other', resume=True) assert calls == ['RULP', 'Other'] diff --git a/tests/test_pcb_bridge.py b/tests/test_pcb_bridge.py index 523f840..045ef79 100644 --- a/tests/test_pcb_bridge.py +++ b/tests/test_pcb_bridge.py @@ -2,7 +2,6 @@ import pytest from cbb_refresh_verify.pcb_bridge import ( PcbBridgeError, - execution_outcome, require_document_identity, wait_for_target_document, ) @@ -74,23 +73,6 @@ def test_bridge_stops_if_pcb_exits_before_com_is_ready(tmp_path): assert raised.value.error_code == 'PCB_EXITED_BEFORE_COM' -def test_fatal_dialog_overrides_successful_save_markers(): - result = execution_outcome( - save_complete=True, - pcb_exited=True, - fatal_error='SAVE_REUSABLE_BLOCK_FAILED: Error saving the Reusable Block', - ) - - assert result['status'] == 'FAIL' - assert result['error_code'] == 'SAVE_REUSABLE_BLOCK_FAILED' - - -def test_success_requires_save_and_pcb_exit(): - assert execution_outcome(save_complete=True, pcb_exited=True)['status'] == 'PASS' - assert execution_outcome(save_complete=False, pcb_exited=True)['status'] == 'FAIL' - assert execution_outcome(save_complete=True, pcb_exited=False)['status'] == 'FAIL' - - def test_connected_com_without_document_remains_startup_and_checks_native_failure(tmp_path): errors = iter(('', 'ICDB_REPAIR_REQUIRED: original lost session')) events = [] diff --git a/tests/test_review345_ui_cli.py b/tests/test_review345_ui_cli.py new file mode 100644 index 0000000..d3bf41d --- /dev/null +++ b/tests/test_review345_ui_cli.py @@ -0,0 +1,166 @@ +from pathlib import Path +from threading import Event +from types import SimpleNamespace + +import pytest +from PySide6.QtCore import QCoreApplication, QEvent +from PySide6.QtWidgets import QMessageBox +from shiboken6 import isValid + +from cbb_refresh_verify.verify_runner import VerifyResult + + +def flush_deletes(): + QCoreApplication.sendPostedEvents(None, QEvent.DeferredDelete) + + +def test_repeated_batch_results_retire_previous_dialog(qtbot, tmp_path): + from cbb_refresh_verify.ui.main_window import MainWindow + window = MainWindow(data_root=tmp_path) + qtbot.addWidget(window) + window._batch_done(([VerifyResult('FAIL')], tmp_path/'report.log')) + previous = window.summary + window._batch_done(([VerifyResult('PASS')], tmp_path/'report2.log')) + flush_deletes() + assert not isValid(previous) + assert len(window.findChildren(QMessageBox)) == 1 + current = window.summary + current.close() + flush_deletes() + assert not isValid(current) + window._update() # No retained reference to deleted result actions. + + +def test_repeated_icdb_results_preserve_latest_recovery_task(qtbot, tmp_path, monkeypatch): + from test_ui_filters import load_window + from test_reimport_recovery import failed_repair + window = load_window(qtbot, tmp_path, monkeypatch, + verifier=lambda _: failed_repair(tmp_path/'result.json', safe=True)) + window._run(['Beta'], maintenance=True) + qtbot.waitUntil(lambda: not window._icdb_active()) + first_task, previous = window.icdb_task, window.icdb_summary + window._run(['Gamma'], maintenance=True) + qtbot.waitUntil(lambda: not window._icdb_active()) + flush_deletes() + assert not isValid(previous) + assert not hasattr(first_task, 'summary') + assert len(window.findChildren(QMessageBox)) == 1 + assert window.icdb_task.summary is window.icdb_summary + action = next(b for b in window.icdb_summary.buttons() if '副本' in b.text()) + action.click() + assert [request.name for request in window.management_dialog.requests()] == ['Gamma'] + window.management_dialog.reject() + window._invalidate_check_targets('test.lmc', ['Beta', 'Gamma']) + window._update() + + +def test_batch_replacement_preserves_independent_icdb_result(qtbot, tmp_path, monkeypatch): + from test_ui_filters import load_window + window = load_window(qtbot, tmp_path, monkeypatch, + verifier=lambda _: VerifyResult('CHECKED')) + window._run(['Beta'], maintenance=True) + qtbot.waitUntil(lambda: not window._icdb_active()) + icdb_summary = window.icdb_summary + window._batch_done(([VerifyResult('PASS')], tmp_path/'first.log')) + old_batch = window.summary + window._batch_done(([VerifyResult('PASS')], tmp_path/'second.log')) + flush_deletes() + assert not isValid(old_batch) + assert isValid(icdb_summary) and icdb_summary.isVisible() + assert window.icdb_task.summary is icdb_summary + assert len(window.findChildren(QMessageBox)) == 2 + + +def test_close_wait_notice_remains_visible_and_timer_stops_on_idle(qtbot, tmp_path): + from cbb_refresh_verify.ui.main_window import MainWindow + entered, release = Event(), Event() + def close_lease(): + entered.set() + release.wait(5) + window = MainWindow(data_root=tmp_path) + qtbot.addWidget(window) + window.library_lease = SimpleNamespace(close=close_lease) + window.show() + try: + window.close() + qtbot.waitUntil(entered.is_set) + assert window.isVisible() and '等待' in window.windowTitle() + timer = window.close_wait_timer + assert timer.isActive() and timer.interval() == 120_000 + timer.start(10) + qtbot.waitUntil(lambda: '仍在等待' in window.windowTitle()) + assert '仍在等待' in window.status_label.text() + window.close() + assert window.isVisible() + finally: + release.set() + qtbot.waitUntil(lambda: not window.isVisible()) + assert not timer.isActive() + + +@pytest.fixture +def batch_cli(tmp_path, monkeypatch): + import cbb_refresh_verify.application as application + import cbb_refresh_verify.library_reader as reader + import cbb_refresh_verify.network_path as network + import cbb_refresh_verify.verify_runner as runner + from cbb_refresh_verify.models import CbbRecord, LibraryReadResult + log, requested, retained = [], [], [] + def record(message, *args, **kwargs): + log.append(message % args if args else message) + logger = SimpleNamespace(info=record, warning=record, exception=record, handlers=()) + monkeypatch.setattr(application, 'configure', lambda *_: SimpleNamespace(root=tmp_path, logger=logger)) + class Lease: + display_path = Path(r'\\server\share\library') + mentor_path = tmp_path/'lib.lmc' + drive, remote_root, created = 'Z:', r'\\server\share', True + def __enter__(self): return self + def __exit__(self, *_): pass + def retain_for_recovery(self): retained.append(self.drive) + monkeypatch.setattr(network.LibraryPathLease, 'acquire', lambda _: Lease()) + monkeypatch.setattr(network, 'select_library_file', lambda path: path) + monkeypatch.setattr(reader, 'read_library_fast', lambda *a, **kw: LibraryReadResult(( + CbbRecord('Ready', 'LP', status='READY'), CbbRecord('One', 'LP'), + CbbRecord('Two', 'LP'), CbbRecord('Three', 'LP')))) + def run(requests): + requested.extend(request.block_name for request in requests) + return [VerifyResult('PASS') for _ in requests] + monkeypatch.setattr(runner, 'run_batch', run) + monkeypatch.setattr(runner, 'write_batch_report', lambda *a: tmp_path/'batch.log') + return application, runner, log, requested, retained + + +@pytest.mark.parametrize('extra, expected, counts', [ + ([], ['One', 'Two', 'Three'], (3, 3, 0)), + (['--limit', '2'], ['One', 'Two'], (2, 3, 1)), + (['--block', 'Three', '--block', 'One', '--limit', '1'], ['Three'], (1, 2, 1)), +]) +def test_batch_cli_limit_is_optional_and_reports_selection(batch_cli, extra, expected, counts): + app, _, log, requested, _ = batch_cli + assert app.main(['--batch-lmc', 'lib.lmc', *extra]) == 0 + assert requested == expected + assert any(all(f'{key}={value}' in line for key, value in zip( + ('selected', 'total', 'remaining'), counts)) for line in log) + + +@pytest.mark.parametrize('value', ['0', '-1', 'no']) +def test_batch_cli_rejects_nonpositive_limit(batch_cli, value): + app, _, _, requested, _ = batch_cli + with pytest.raises(SystemExit) as error: + app.main(['--batch-lmc', 'lib.lmc', '--limit', value]) + assert error.value.code == 2 and not requested + + +@pytest.mark.parametrize('raised', [False, True]) +def test_retained_mapping_logs_context_and_confirmed_release_guidance(batch_cli, monkeypatch, raised): + app, runner, log, _, retained = batch_cli + def run(_): + if raised: raise RuntimeError('native writer status unknown') + return [VerifyResult('FAIL', safe_to_continue=False)] + monkeypatch.setattr(runner, 'run_batch', run) + assert app.main(['--batch-lmc', 'lib.lmc', '--block', 'One']) == (1 if raised else 2) + assert retained == ['Z:'] + notice = next(line for line in log if 'batch_drive_retained' in line) + assert 'Z:' in notice and r'\\server\share' in notice + assert '释放残留会话' in notice and '确认' in notice + assert 'net use' not in notice.lower() diff --git a/tests/test_review348_release_comparison.py b/tests/test_review348_release_comparison.py index 625d93d..f9093d5 100644 --- a/tests/test_review348_release_comparison.py +++ b/tests/test_review348_release_comparison.py @@ -23,3 +23,18 @@ def test_confirmed_scope_and_execution_divergence_are_visible(qtbot, tmp_path, m assert dialog.table.item(1, 7).text() == '未释放' assert '原生操作进行中' in dialog.table.item(1, 3).text() assert '确认允许 2' in dialog.message.text() and '未释放 1' in dialog.message.text() + + +def test_retiring_batch_summary_forgets_enabled_release_actions(qtbot, tmp_path): + from cbb_refresh_verify.ui.main_window import MainWindow + from cbb_refresh_verify.verify_runner import VerifyResult + from test_review345_ui_cli import flush_deletes + window = MainWindow(data_root=tmp_path) + qtbot.addWidget(window) + window._batch_done(([VerifyResult('FAIL', safe_to_continue=False)], None)) + assert window._residual_release_action is not None + window.summary.close(); flush_deletes() + window._update() + assert window._residual_release_action is None + window._resume_batch = dict(library=tmp_path/'lib.lmc', released=True) + window._release_dialog_finished() diff --git a/tests/test_review_backend_followup.py b/tests/test_review_backend_followup.py index fdfd2fe..a9a33e6 100644 --- a/tests/test_review_backend_followup.py +++ b/tests/test_review_backend_followup.py @@ -87,6 +87,20 @@ def test_management_records_scoped_changes_without_hashing_unrelated_cbb(setup, assert 'SymbolLibs/shared/icdb.dat' in report['modified'] assert 'ReusableBlocksLP/Block/Work/Block.prj' in report['modified'] assert result.change_report == report + assert report['rule_version'] == 1 + assert report['scope'] == {'kind': 'library', 'block_name': 'Block', + 'library_name': request.library.name} + from cbb_refresh_verify import scoped_manifest as manifests + assert report['excluded_categories'] == sorted(manifests._NONPRIMARY_DIRECTORIES) + assert report['excluded_suffixes'] == sorted(manifests._NONPRIMARY_SUFFIXES) + runtime = report['runtime_exclusions'] + assert runtime['native_directory_names'] == ['dbcheck', 'dbrestore', 'log'] + assert runtime['file_names'] == ['saddress.adr'] + assert runtime['file_name_prefixes'] == ['~$'] + assert runtime['relative_directories'] == ['projectbackup/backups'] + assert runtime['directory_prefixes'] == ['work.before-restore-'] + assert 'selected CBB Work/Cert root or its PCB child' in runtime['directory_name_positions'] + assert 'SymbolLibs//cdbsvr' in runtime['native_directory_positions'] def test_failed_mutation_still_records_changes_and_release_fact(setup): diff --git a/tests/test_review_management_ui_followup.py b/tests/test_review_management_ui_followup.py index ef34087..21dd401 100644 --- a/tests/test_review_management_ui_followup.py +++ b/tests/test_review_management_ui_followup.py @@ -29,3 +29,17 @@ def test_report_failure_is_visible_without_inventing_native_failure(qtbot, setup assert '历史会话已释放' in dialog.output.toPlainText() dialog._progress({'stage':'previous_release_check','block':request.name}) assert '正在复核历史占用' in dialog.status_label.text() + + +def test_recorded_counts_identify_compared_engineering_file_scope(qtbot, setup): + from cbb_refresh_verify.management import ManagementResult + from cbb_refresh_verify.ui.management_dialog import ManagementDialog + request, _, _ = setup + dialog = ManagementDialog([request]); qtbot.addWidget(dialog) + result = ManagementResult(request.operation, request.library, request.name, request.partition, + None, False, 'complete', 'REMOVED', True, 'removed', + change_report={'status': 'RECORDED', 'added': ['a'], 'deleted': [], 'modified': ['b']}) + dialog._result([result]) + text = dialog.output.toPlainText() + assert '已比对的工程文件' in text + assert '新增 1' in text and '删除 0' in text and '修改 1' in text diff --git a/tests/test_scoped_manifest.py b/tests/test_scoped_manifest.py index d4d5647..b0dbb17 100644 --- a/tests/test_scoped_manifest.py +++ b/tests/test_scoped_manifest.py @@ -118,17 +118,42 @@ def test_corrupted_destination_bytes_are_rejected_and_evidence_is_preserved(tmp_ assert (destination/relative).exists() +def test_unlocked_primary_copy_reads_source_twice_and_target_once(tmp_path, monkeypatch): + from collections import Counter + source, destination = tmp_path/'source', tmp_path/'destination' + primary = put(source, 'A.prj', b'engineering' * 100000) + reads = Counter() + original_open = Path.open + def opened(path, mode='r', *args, **kwargs): + if mode == 'rb': + reads[path] += 1 + return original_open(path, mode, *args, **kwargs) + monkeypatch.setattr(Path, 'open', opened) + hashes = Counter() + original_hash = recovery._hash + def hashed(path): + hashes[path] += 1 + return original_hash(path) + monkeypatch.setattr(recovery, '_hash', hashed) + manifest = recovery._copy_verified(source, destination) + assert hashes[primary] == 1 # Only the final source rehash is a separate pass. + assert hashes[destination/'A.prj'] == 1 + assert reads[primary] == 2 # Copy/hash stream, then final source content proof. + assert reads[destination/'A.prj'] == 1 + assert manifest['files']['A.prj']['sha256'] == hashlib.sha256(primary.read_bytes()).hexdigest() + + def test_source_byte_changes_with_preserved_metadata_are_rejected(tmp_path, monkeypatch): source, destination = tmp_path/'source', tmp_path/'destination' primary = put(source, 'A.prj') - real_copy = shutil.copy2 + real_copy = shutil.copystat def copy_then_change_source(src, dst, *args, **kwargs): result = real_copy(src, dst, *args, **kwargs) metadata = primary.stat() primary.write_bytes(b'X' * metadata.st_size) os.utime(primary, ns=(metadata.st_atime_ns, metadata.st_mtime_ns)) return result - monkeypatch.setattr(shutil, 'copy2', copy_then_change_source) + monkeypatch.setattr(shutil, 'copystat', copy_then_change_source) with pytest.raises(OSError): recovery._copy_verified(source, destination) assert (destination/'A.prj').read_bytes() == b'engineering' @@ -140,7 +165,7 @@ def test_complete_tree_metadata_must_stay_stable_during_copy(tmp_path, monkeypat put(source, 'A.prj') runtime = put(source, 'logs/session.log') destination = tmp_path/'destination' - real_copy = shutil.copy2 + real_copy = shutil.copystat def copy_then_mutate(src, dst, *args, **kwargs): result = real_copy(src, dst, *args, **kwargs) if Path(src).name == 'A.prj': @@ -151,7 +176,7 @@ def test_complete_tree_metadata_must_stay_stable_during_copy(tmp_path, monkeypat else: put(source, 'logs/added.log') return result - monkeypatch.setattr(shutil, 'copy2', copy_then_mutate) + monkeypatch.setattr(shutil, 'copystat', copy_then_mutate) with pytest.raises(OSError): recovery._copy_verified(source, destination) assert destination.exists() @@ -277,7 +302,7 @@ def test_colliding_engineering_names_cannot_bypass_primary_copy_byte_checks(tmp_ scope = ManifestScope.library(block, 'target.lmc') source, destination = tmp_path/'source', tmp_path/'destination' put(source, relative) - real_copy = shutil.copy2 + real_copy = shutil.copystat def copy_then_corrupt(src, dst, *args, **kwargs): result = real_copy(src, dst, *args, **kwargs) corrupt = Path(src) if side == 'source' else Path(dst) @@ -285,7 +310,7 @@ def test_colliding_engineering_names_cannot_bypass_primary_copy_byte_checks(tmp_ corrupt.write_bytes(b'X' * metadata.st_size) os.utime(corrupt, ns=(metadata.st_atime_ns, metadata.st_mtime_ns)) return result - monkeypatch.setattr(shutil, 'copy2', copy_then_corrupt) + monkeypatch.setattr(shutil, 'copystat', copy_then_corrupt) with pytest.raises(OSError): recovery._copy_verified(source, destination, scope=scope) assert (destination/relative).exists()