fix: observe retained sessions without blocking independent libraries

This commit is contained in:
阿白叔 committed 2026-11-06 15:42:40 +08:00
1 parent 6278091f21
commit cb11624b68
9 files changed
+134 -7

No files matched your search

+20 -1
View File
@@ -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
@@ -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:
+12 -3
View File
@@ -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)
+46 -1
View File
@@ -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]}'
@@ -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,
+16
View File
@@ -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)
+2 -1
View File
@@ -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()
+5
View File
@@ -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}
+19
View File
@@ -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 = []