diff --git a/src/cbb_refresh_verify/application.py b/src/cbb_refresh_verify/application.py index 8d2fb88..bd753ff 100644 --- a/src/cbb_refresh_verify/application.py +++ b/src/cbb_refresh_verify/application.py @@ -1,10 +1,26 @@ from __future__ import annotations import argparse, os, sys +from contextlib import contextmanager from pathlib import Path from typing import Sequence from .runtime_logging import configure +@contextmanager +def batch_stop_signals(stop): + import signal + previous = {} + try: + for name in ('SIGINT', 'SIGTERM', 'SIGBREAK'): + signum = getattr(signal, name, None) + if signum is not None: + previous[signum] = signal.signal(signum, lambda *_: stop.set()) + yield + finally: + for signum, handler in previous.items(): + signal.signal(signum, handler) + + def configure_qt_application(app): """Apply a predictable light palette across machines and Qt themes.""" from PySide6.QtGui import QColor, QPalette @@ -118,7 +134,10 @@ def main(argv: Sequence[str] | None = None) -> int: native_lm_verify=native_lm_verify_enabled()) for name in names] try: - results = run_batch(requests) + from threading import Event + stop = Event() + with batch_stop_signals(stop): + results = run_batch(requests, stop=stop) except Exception: lease.retain_for_recovery() raise diff --git a/src/cbb_refresh_verify/residual_sessions.py b/src/cbb_refresh_verify/residual_sessions.py index e7af2ab..96e9e50 100644 --- a/src/cbb_refresh_verify/residual_sessions.py +++ b/src/cbb_refresh_verify/residual_sessions.py @@ -20,6 +20,8 @@ _FORCE_CLIENT_NAMES = {'expeditionpcb.exe', 'librarymanager.exe', 'viewdraw.exe' def force_block_reason(row): """A library path proves scope, never exclusive ownership of a server.""" + if row.get('runtime_phase') in ('NATIVE_CALL', 'CLOSING', 'UNCONFIRMED'): + return '本工具的保存或原生调用尚未确认返回,请等待或查看原生提示' if row.get('scope_confirmed') is not True: return '进程归属未确认,不允许强制结束' name = str(row.get('name', '')).casefold() @@ -265,9 +267,14 @@ def inspect_residual_sessions(library, *, block_names=()): if scope is not False: candidates.append({**row, 'scope_confirmed': scope is True}) windows = _process_windows({r['pid'] for r in candidates}) + from .session_record import active_write_records + runtime_writes = active_write_records(library) sessions = [] for row in candidates: item = dict(row) + item['library'] = str(library) + if runtime_writes and row['scope_confirmed']: + item['runtime_phase'] = runtime_writes[0]['phase'] try: item.update(_process_identity(row)) target, detail = close_target(row['name'], windows.get(row['pid'], [])) if row['scope_confirmed'] else ( @@ -351,6 +358,10 @@ def _force_close(row, *, stop=None): import win32api, win32con, win32event if stop is not None and stop.is_set(): return {'release_status': 'CANCELLED', 'detail': '已停止释放'} + if row.get('library'): + from .session_record import active_write_records + if active_write_records(row['library']): + return {'release_status': 'WAITING', 'detail': '保存或原生调用尚未确认返回,未强制结束'} if reason := force_block_reason(row): return {'release_status': 'WAITING', 'detail': reason} with _process_handle(row['pid'], terminate=True) as handle: diff --git a/src/cbb_refresh_verify/ui/icdb_check_task.py b/src/cbb_refresh_verify/ui/icdb_check_task.py index 997e33e..c374640 100644 --- a/src/cbb_refresh_verify/ui/icdb_check_task.py +++ b/src/cbb_refresh_verify/ui/icdb_check_task.py @@ -27,6 +27,7 @@ class IcdbCheckTask(QObject): self.running = False self.report = None self.report_error = '' + self.retained_libraries = set() self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1) def start(self): @@ -53,14 +54,18 @@ class IcdbCheckTask(QObject): def _next(self): if self.running or not self.active: return - if self.stop.is_set() or self.results and not self.results[-1].safe_to_continue: + if self.stop.is_set(): self.results.extend(VerifyResult('SKIPPED', stderr='队列已停止,未操作此 CBB') for _ in self.requests[len(self.results):]) + while len(self.results) < len(self.requests) and str( + self.requests[len(self.results)].lmc_file).casefold() in self.retained_libraries: + self.results.append(VerifyResult('SKIPPED', stderr='同库原生会话尚未释放,未启动新的检查')) if len(self.results) == len(self.requests): self._report(); return if self.paused: return request = self.requests[len(self.results)] def check(): + from ..session_record import library_available try: def execute(): if request.block_name in self.ready_names: @@ -69,7 +74,8 @@ class IcdbCheckTask(QObject): return VerifyResult('SKIPPED', stderr='目标已有后续管理操作,请重新检查。') self.event.emit({'stage': 'icdb_check_start', 'block': request.block_name}) return self.verifier(request) - return self.queue.run(execute, stop=self.stop, ready=lambda: not self.paused, + return self.queue.run(execute, stop=self.stop, + ready=lambda: not self.paused and library_available(request.lmc_file), waiting=lambda: self.event.emit({'stage': 'waiting_native_slot', 'block': request.block_name, 'detail': '已排队,等待当前原生操作结束'})) except QueueCancelled as error: @@ -84,7 +90,10 @@ class IcdbCheckTask(QObject): self.pool.start(self.worker) def _record(self, result): - name = self.requests[len(self.results)].block_name + request = self.requests[len(self.results)] + name = request.block_name + if not result.safe_to_continue: + self.retained_libraries.add(str(request.lmc_file).casefold()) self.results.append(result) if result.status in ('CANCELLED', 'QUEUE_STOP'): self.stop.set() self.item_done.emit(name, result) diff --git a/src/cbb_refresh_verify/ui/main_window.py b/src/cbb_refresh_verify/ui/main_window.py index f32cce2..3c24a6f 100644 --- a/src/cbb_refresh_verify/ui/main_window.py +++ b/src/cbb_refresh_verify/ui/main_window.py @@ -127,6 +127,8 @@ class MainWindow(QWidget): p, names, mapping_store=self.data_root/'image-status-map.json'), ) self.pool = QThreadPool(self); self.pool.setMaxThreadCount(1) + self.lifecycle_pool = QThreadPool(self); self.lifecycle_pool.setMaxThreadCount(1) + self._lifecycle_workers = set() self._lease_pending = 0 self._lease_workers = set() self._mapping_busy = 0 @@ -146,6 +148,8 @@ class MainWindow(QWidget): self._global_icdb_run = False self._icdb_completed = 0 self.signals = ProgressSignals(self); self.signals.event.connect(self._progress) + 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() @@ -369,6 +373,9 @@ class MainWindow(QWidget): self._lease_workers.discard(worker) self._lease_pending -= 1 if hold_busy: self._mapping_busy -= 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 @@ -385,6 +392,9 @@ class MainWindow(QWidget): return True def _update(self): + from shiboken6 import isValid + if not isValid(self) or not isValid(self.cbb_table): + return # The refresh flow needs only the library and a CBB; LibSpec/DMS config # are optional and only enable the extra contents check. ready = not self.busy and self.loaded_path == self.lmc_edit.text() and self.cbb_table.rowCount() > 0 @@ -438,12 +448,35 @@ class MainWindow(QWidget): def _show_unfinished_management(self): from cbb_refresh_verify.management import unfinished_operations - unfinished = unfinished_operations(self.data_root/'management') + from cbb_refresh_verify.session_record import discover_sessions, handoff_session + root = self.data_root + notify = self.signals.event.emit + def inspect(): + unfinished = unfinished_operations(root/'management') + sessions = discover_sessions(root) + for session in sessions: + if session['status'] == 'ACTIVE': + handoff_session(session['path'], evidence_root=root, + progress=lambda value: notify({'stage': 'session_observation', **value})) + return unfinished, sessions + worker = ServiceWorker(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)) + self.lifecycle_pool.start(worker) + + def _unfinished_sessions_ready(self, payload): + unfinished, sessions = payload self.unfinished_label.setText(f'发现 {len(unfinished)} 项未完成或需恢复的管理任务;只显示记录,不自动重放。' if unfinished else '') for item in unfinished: self.output.append(f'未完成:{item.get("name", "")} {item.get("status", "")} ' f'{item.get("stage", "")}\n{item["evidence_path"]}') + for session in sessions: + if session['status'] != 'RELEASED': + self.output.append(f'未完成会话:{session.get("block") or ""} · ' + f'{session.get("phase", "")} · {session.get("detail", "")}\n{session["path"]}') def check_library_release(self): if self.busy or not self.lmc_edit.text().strip(): @@ -740,7 +773,10 @@ class MainWindow(QWidget): self.pool.start(self.worker) def _queued_action(self, action): + from cbb_refresh_verify.session_record import library_available + library = getattr(self, 'mentor_lmc_path', None) or self.lmc_edit.text() return lambda: self.native_queue.run(action, stop=self.stop, + ready=lambda: library_available(library), waiting=lambda: self.signals.event.emit({'stage': 'waiting_native_slot', 'detail': '已排队,等待当前原生操作结束'})) @@ -1355,6 +1391,15 @@ class MainWindow(QWidget): return True def _progress(self, event): + from shiboken6 import isValid + if not isValid(self) or not isValid(self.cbb_table): + return + if event.get('stage') in ('session_handoff', 'save_stop_requested'): + self.status_label.setText(event.get('detail', '当前状态无法确认')) + if (event.get('stage') == 'session_observation' and event.get('status') == 'RELEASED' + and event.get('release_proof')): + self._complete_library_release(event['library'], event['release_proof']) + self.native_queue.wake() line = f"{event.get('block', '')} | {event.get('stage', '')}" for key in ('detail', 'error', 'action', 'statuses', 'evidence'): if event.get(key): line += f' | {event[key]}' diff --git a/src/cbb_refresh_verify/ui/management_dialog.py b/src/cbb_refresh_verify/ui/management_dialog.py index f883fad..c6852ae 100644 --- a/src/cbb_refresh_verify/ui/management_dialog.py +++ b/src/cbb_refresh_verify/ui/management_dialog.py @@ -171,9 +171,11 @@ class ManagementDialog(QDialog): progress=self.signals.progress.emit) if self.native_queue is None: return action() from ..operation_queue import QueueCancelled + from ..session_record import library_available try: return self.native_queue.run(action, stop=self.stop, waiting=lambda: self.signals.progress.emit( - {'stage': 'waiting_native_slot', 'detail': '已排队,等待当前检查结束'})) + {'stage': 'waiting_native_slot', 'detail': '已排队,等待当前检查结束'}), + ready=lambda: library_available(self.template.library)) except QueueCancelled as error: from ..management import ManagementResult return [ManagementResult(r.operation, r.library, r.name, r.partition, r.source, r.auto_verify, diff --git a/tests/test_application.py b/tests/test_application.py index a04607f..0ef069a 100644 --- a/tests/test_application.py +++ b/tests/test_application.py @@ -1,6 +1,22 @@ from pathlib import Path +def test_cli_signal_requests_cooperative_batch_stop(tmp_path, monkeypatch): + import signal + from cbb_refresh_verify import application, verify_runner + library = tmp_path/'center.lmc' + library.touch() + old = signal.getsignal(signal.SIGINT) + def run(requests, *, stop): + signal.getsignal(signal.SIGINT)(signal.SIGINT, None) + assert stop.is_set() + return [verify_runner.VerifyResult('CANCELLED')] + monkeypatch.setattr(verify_runner, 'run_batch', run) + assert application.main(['--batch-lmc', str(library), '--block', 'A', + '--data-root', str(tmp_path/'data')]) == 2 + assert signal.getsignal(signal.SIGINT) is old + + def test_smoke_arguments_exit_zero_and_write_lifecycle_log(tmp_path: Path): import subprocess, sys result = subprocess.run([sys.executable, '-m', 'cbb_refresh_verify', '--smoke-test', '--data-root', str(tmp_path)], timeout=30) diff --git a/tests/test_management_ui.py b/tests/test_management_ui.py index acfd0ad..ef2c1d2 100644 --- a/tests/test_management_ui.py +++ b/tests/test_management_ui.py @@ -76,7 +76,8 @@ def test_restart_shows_unfinished_without_starting_worker(qtbot, tmp_path): adapter = SimpleNamespace(capabilities=lambda: {n: Capability(False, 'disabled') for n in ('add', 'update', 'remove')}) window = MainWindow(data_root=tmp_path, management_adapter=adapter) qtbot.addWidget(window) - assert '未完成' in window.unfinished_label.text() and not window.busy + qtbot.waitUntil(lambda: '未完成' in window.unfinished_label.text()) + assert not window.busy assert 'Block' in window.output.toPlainText() diff --git a/tests/test_residual_sessions.py b/tests/test_residual_sessions.py index 1e439d0..f364242 100644 --- a/tests/test_residual_sessions.py +++ b/tests/test_residual_sessions.py @@ -4,6 +4,11 @@ from types import SimpleNamespace import pytest +def test_registered_save_is_not_treated_as_an_idle_hung_client(): + from cbb_refresh_verify.residual_sessions import force_block_reason + assert '保存' in force_block_reason({'runtime_phase': 'NATIVE_CALL'}) + + OWNERSHIP = {"owner_sid": "S-1-current", "session_id": 1, "force_user_confirmed": True} diff --git a/tests/test_ui_lease_lifecycle.py b/tests/test_ui_lease_lifecycle.py index 5081a47..56eb89f 100644 --- a/tests/test_ui_lease_lifecycle.py +++ b/tests/test_ui_lease_lifecycle.py @@ -8,6 +8,25 @@ from PySide6.QtCore import QTimer from test_ui_filters import load_window +def test_late_lease_callback_does_not_refresh_destroyed_view(qtbot, tmp_path, monkeypatch): + import shiboken6 + window = load_window(qtbot, tmp_path, monkeypatch) + entered, release = Event(), Event() + def action(): + entered.set() + assert release.wait(3) + try: + window._lease_action(action) + qtbot.waitUntil(entered.is_set) + window.cbb_table.deleteLater() + qtbot.waitUntil(lambda: not shiboken6.isValid(window.cbb_table)) + release.set() + qtbot.waitUntil(lambda: window._lease_pending == 0) + finally: + release.set() + window.pool.waitForDone(3000) + + def slow_lease(main_thread): entered, release, closed = Event(), Event(), Event() calls = []