Files
cbb-refresh-verify-795/src/cbb_refresh_verify/residual_sessions.py
T
阿白叔 b1c36e3ca6 Merge branch 'codex/review-residual-release' into codex/runtime-lifecycle-safety
# Conflicts:
#	src/cbb_refresh_verify/residual_sessions.py
2026-11-09 10:41:24 +08:00

705 lines
38 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Preview and cooperatively close the exact native sessions a user confirms."""
from contextlib import contextmanager
import json
import hashlib
import os
from pathlib import Path
import re
import time
from uuid import uuid4
from .owner_probe import query_process_snapshot
from .native_engineering_identity import _OWNER_NAMES
_NAMES = {'expeditionpcb.exe', 'librarymanager.exe', 'icdbprojectbackup.exe',
'viewdraw.exe', 'icdbnetserver.exe', 'icdbserver.exe',
'reuseblockimporter.exe', 'cleanwglib.exe', 'cscript.exe', 'wscript.exe'} | _OWNER_NAMES
_WORKER_NAMES = {'python.exe', 'pythonw.exe', 'cbbrefreshverify.exe'}
_WORKER_FLAGS = ('--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker')
_FORCE_CLIENT_NAMES = {'expeditionpcb.exe', 'librarymanager.exe', 'viewdraw.exe', 'icdbprojectbackup.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()
if name not in _FORCE_CLIENT_NAMES:
return '服务器或其他受保护进程仅供观察,不允许强制结束'
if (not row.get('created_handle') or not row.get('image')
or Path(row['image']).name.casefold() != name):
return '客户端身份未确认,不允许强制结束'
if (row.get('force_user_confirmed') is not True or not row.get('owner_sid')
or not isinstance(row.get('session_id'), int)):
return '未确认属于当前用户和 Windows 会话,不允许强制结束'
activity = row.get('native_activity', {})
if activity.get('status') in ('ACTIVE', 'UNCONFIRMED'):
return activity.get('detail', '原生操作状态未确认')+';请查看进展或请求原生取消后重新检查'
if name == 'icdbprojectbackup.exe' and activity.get('status') != 'IDLE':
return '备份/恢复/修复状态未确认,请重新检查'
return ''
def native_activity(name, windows, *, incomplete=None):
if incomplete or any(w['class'] == 'UNCONFIRMED' for w in windows):
return {'status': 'UNCONFIRMED', 'detail': '原生窗口读取不完整'}
if any((name.casefold() == 'icdbprojectbackup.exe' and not w['enabled'])
or any(c['class'].casefold() == 'msctls_progress32' for c in w['children']) for w in windows):
return {'status': 'ACTIVE', 'detail': '原生窗口显示操作进行中'}
if name.casefold() == 'icdbprojectbackup.exe':
main = [w for w in windows if w['class'].startswith('Afx:')
and w['title'].startswith('iCDB Project Backup')]
output = main[0].get('output') if len(main) == 1 else None
if not isinstance(output, str) or not output.strip():
return {'status': 'UNCONFIRMED', 'detail': '无法确认备份/恢复/修复输出'}
active = list(re.finditer(r'(?i)repairing|restoring|backing up|creating (?:a )?backup', output))
if active and max(output.rfind('Backup information loaded correctly.'),
output.rfind('Repair project error [')) < active[-1].start():
return {'status': 'ACTIVE', 'detail': '原生备份/恢复/修复尚未确认结束', 'output': output}
return {'status': 'IDLE', 'detail': '未观察到进行中的原生操作'}
@contextmanager
def _process_handle(pid, *, terminate=False):
import win32api, win32con
handle = win32api.OpenProcess(win32con.SYNCHRONIZE | 0x1000 | (1 if terminate else 0), False, int(pid))
try:
yield handle
finally:
handle.Close()
def _handle_identity(handle):
import ctypes
from ctypes import wintypes
import win32process
kernel = ctypes.WinDLL('kernel32', use_last_error=True)
kernel.QueryFullProcessImageNameW.argtypes = [wintypes.HANDLE, wintypes.DWORD,
wintypes.LPWSTR, ctypes.POINTER(wintypes.DWORD)]
kernel.QueryFullProcessImageNameW.restype = wintypes.BOOL
buffer = ctypes.create_unicode_buffer(32768)
length = wintypes.DWORD(len(buffer))
if not kernel.QueryFullProcessImageNameW(int(handle), 0, buffer, ctypes.byref(length)):
raise ctypes.WinError(ctypes.get_last_error())
return {'created_handle': win32process.GetProcessTimes(handle)['CreationTime'].isoformat(),
'image': buffer.value}
def _process_identity(row):
with _process_handle(row['pid']) as handle:
identity = _handle_identity(handle)
try:
identity.update(_force_ownership(handle, row['pid']))
except Exception as error:
identity.update(force_user_confirmed=False, owner_error=str(error))
return identity
def _force_ownership(handle, pid):
import win32api, win32con, win32process, win32security, win32ts
if win32process.GetProcessId(handle) != pid:
raise ValueError('进程身份已变化')
def owner(process):
token = win32security.OpenProcessToken(process, win32con.TOKEN_QUERY)
try:
return win32security.ConvertSidToStringSid(
win32security.GetTokenInformation(token, win32security.TokenUser)[0])
finally:
token.Close()
sid = owner(handle)
session = win32ts.ProcessIdToSessionId(pid)
return {'owner_sid': sid, 'session_id': session, 'force_user_confirmed':
sid == owner(win32api.GetCurrentProcess())
and session == win32ts.ProcessIdToSessionId(os.getpid())}
class _WindowSnapshot(dict):
def __init__(self, pids):
super().__init__((pid, []) for pid in pids)
self.incomplete = {}
def _process_threads(pids):
import ctypes
from ctypes import wintypes
class ThreadEntry(ctypes.Structure):
_fields_ = [('size', wintypes.DWORD), ('usage', wintypes.DWORD), ('tid', wintypes.DWORD),
('pid', wintypes.DWORD), ('base', wintypes.LONG), ('delta', wintypes.LONG),
('flags', wintypes.DWORD)]
kernel = ctypes.WinDLL('kernel32', use_last_error=True)
kernel.CreateToolhelp32Snapshot.argtypes = [wintypes.DWORD, wintypes.DWORD]
kernel.CreateToolhelp32Snapshot.restype = wintypes.HANDLE
kernel.CloseHandle.argtypes = [wintypes.HANDLE]
for name in ('Thread32First', 'Thread32Next'):
function = getattr(kernel, name)
function.argtypes = [wintypes.HANDLE, ctypes.POINTER(ThreadEntry)]
function.restype = wintypes.BOOL
snapshot = kernel.CreateToolhelp32Snapshot(4, 0) # TH32CS_SNAPTHREAD
if snapshot == ctypes.c_void_p(-1).value:
raise ctypes.WinError(ctypes.get_last_error())
result = {pid: [] for pid in pids}
try:
entry = ThreadEntry(); entry.size = ctypes.sizeof(entry)
more = kernel.Thread32First(snapshot, ctypes.byref(entry))
while more:
if entry.pid in result:
result[entry.pid].append(int(entry.tid))
entry.size = ctypes.sizeof(entry)
more = kernel.Thread32Next(snapshot, ctypes.byref(entry))
if ctypes.get_last_error() != 18: # ERROR_NO_MORE_FILES
raise ctypes.WinError(ctypes.get_last_error())
finally:
kernel.CloseHandle(snapshot)
return result
def _thread_desktop_name(tid):
import ctypes
from ctypes import wintypes
user = ctypes.WinDLL('user32', use_last_error=True)
user.GetThreadDesktop.argtypes = [wintypes.DWORD]
user.GetThreadDesktop.restype = wintypes.HANDLE
user.GetUserObjectInformationW.argtypes = [wintypes.HANDLE, ctypes.c_int, wintypes.LPVOID,
wintypes.DWORD, ctypes.POINTER(wintypes.DWORD)]
user.GetUserObjectInformationW.restype = wintypes.BOOL
ctypes.set_last_error(0)
desktop = user.GetThreadDesktop(tid)
if not desktop:
if error := ctypes.get_last_error():
raise ctypes.WinError(error)
return None # A non-GUI thread need not have an assigned desktop.
# GetThreadDesktop returns a borrowed handle; never CloseDesktop it.
name, needed = ctypes.create_unicode_buffer(512), wintypes.DWORD()
if not user.GetUserObjectInformationW(desktop, 2, name, ctypes.sizeof(name), ctypes.byref(needed)):
raise ctypes.WinError(ctypes.get_last_error())
return name.value
def _window_error(snapshot, pid):
return getattr(snapshot, 'incomplete', {}).get(pid)
def _process_windows(pids):
result = _WindowSnapshot(pids)
if not pids: return result
import win32api, win32con, win32gui, win32process, win32service
from .native_repair_ui import _native_output
observed = set()
def capture(hwnd, _, *, pid, desktop_name):
if win32process.GetWindowThreadProcessId(hwnd)[1] != pid:
raise ValueError('窗口所属进程已变化')
if hwnd in observed or not win32gui.IsWindowVisible(hwnd):
return
if desktop_name is None:
raise ValueError('窗口所属桌面无法读取')
observed.add(hwnd)
children, documents = [], []
def child(handle, _):
kind = win32gui.GetClassName(handle)
if kind == 'MDIClient' and win32gui.GetWindow(handle, win32con.GW_CHILD):
documents.append(handle)
if win32gui.IsWindowVisible(handle):
children.append({'hwnd': int(handle), 'class': kind,
'id': win32gui.GetDlgCtrlID(handle) & 0xffff,
'text': win32gui.GetWindowText(handle), 'enabled': bool(win32gui.IsWindowEnabled(handle))})
win32api.SetLastError(0)
win32gui.EnumChildWindows(hwnd, child, None)
window = {'hwnd': int(hwnd), 'title': win32gui.GetWindowText(hwnd),
'desktop': desktop_name,
'class': win32gui.GetClassName(hwnd), 'enabled': bool(win32gui.IsWindowEnabled(hwnd)),
'children': children, 'documents': documents, 'rect': list(win32gui.GetWindowRect(hwnd))}
if any(c['class'].casefold().startswith('richedit') for c in children):
window['output'] = _native_output([window])
result[pid].append(window)
try:
threads = _process_threads(pids)
except Exception as error:
result.incomplete = {pid: str(error)[:500] for pid in pids}
return result
desktops = {}
for pid in pids:
if not threads.get(pid):
result.incomplete[pid] = '进程线程已退出或暂时无法读取'
for tid in threads.get(pid, ()):
try:
desktop = _thread_desktop_name(tid)
if desktop:
desktops.setdefault(desktop, set()).add(pid)
except Exception as error:
result.incomplete.setdefault(pid, str(error)[:500])
if not any(pid in members for members in desktops.values()):
result.incomplete.setdefault(pid, '窗口所属桌面暂时无法确认')
# EnumThreadWindows silently omits windows on other desktops. Enumerate
# only desktops actually assigned to the target processes' threads.
for name, members in desktops.items():
desktop = None
try:
desktop = win32service.OpenDesktop(name, 0, False, win32con.DESKTOP_READOBJECTS)
win32api.SetLastError(0)
for hwnd in desktop.EnumDesktopWindows():
pid = None
try:
pid = win32process.GetWindowThreadProcessId(hwnd)[1]
if pid in members:
capture(hwnd, None, pid=pid, desktop_name=name)
except Exception as error:
for affected in (members if pid is None else {pid} & members):
result.incomplete.setdefault(affected, str(error)[:500])
except Exception as error:
for pid in members:
result.incomplete.setdefault(pid, str(error)[:500])
finally:
if desktop is not None:
desktop.CloseDesktop()
return result
def _project_name(row, library):
from .failed_session import _command_args
for arg in _command_args(row['command'])[1:]:
try:
relative = Path(arg.split('=', 1)[-1]).relative_to(library.parent/'ReusableBlocksLP')
if len(relative.parts) >= 2 and relative.parts[1].casefold() == 'work':
return relative.parts[0]
except ValueError:
continue
return '当前库关联会话'
def close_target(name, windows, *, incomplete=None):
"""No save/restore approval and no close against an unknown modal/window."""
if incomplete:
return None, '该会话窗口读取不完整,请重新检查:'+str(incomplete)
main = [w for w in windows if w['class'].startswith('Afx:') and (
name.casefold() == 'icdbprojectbackup.exe' and w['title'].startswith('iCDB Project Backup')
or name.casefold() == 'librarymanager.exe' and w['title'].startswith('Library Manager')
or name.casefold() == 'expeditionpcb.exe' and 'Expedition PCB' in w['title'])]
if len(main) != 1:
return None, '未确认空闲主窗口;有工程时请先在原生窗口保存并关闭'
window = main[0]
for other in windows:
if other is window: continue
benign = (not other['title'] and other['class'] in
('UAC_InputIndicatorOverlayWnd', 'UAC Input Indicator'))
benign = benign or (other['class'] == 'Internet Explorer_Hidden' and not other['title']
and not other.get('children') and other.get('rect', [1, 1, 2, 2])[0:2] == other.get('rect', [1, 1, 2, 2])[2:4])
if not benign: return None, '存在原生弹窗,请先处理该窗口后重新检查'
if not window['enabled']:
return None, '原生程序正在工作,请稍后重新检查'
if any(c['class'].casefold() == 'msctls_progress32' for c in window['children']):
return None, '原生操作尚未结束'
if name.casefold() == 'icdbprojectbackup.exe':
output = window.get('output')
if not isinstance(output, str): return None, '原生输出尚无法确认,请重新检查'
active = list(re.finditer(r'(?i)repairing|restoring|backing up|creating (?:a )?backup', output))
last_load = output.rfind('Backup information loaded correctly.')
failure = output.rfind('Repair project error [')
if active and max(last_load, failure) < active[-1].start():
return None, '备份、恢复或修复需要在原生窗口确认结束后再释放'
return window, ('将正常关闭工程;未保存时等待确认' if window.get('documents') else '可正常关闭')
def _save_question(windows, *, incomplete=None):
if incomplete:
return None
for window in windows:
text = '\n'.join(c['text'] for c in window['children'] if c['class'] == 'Static')
buttons = {c['id']: c for c in window['children'] if c['class'] == 'Button' and c['enabled']}
if (window['class'] == '#32770' and 'Expedition' in window['title']
and re.search(r'\bsave\b', text, re.I) and re.search(r'changes|modified', text, re.I)
and set(buttons) == {6, 7, 2}):
return {'hwnd': window['hwnd'], 'text': text, 'buttons': buttons,
'desktop': window.get('desktop', '')}
return None
def _cancel_question(name, windows, *, incomplete=None):
if (name.casefold() != 'icdbprojectbackup.exe'
or native_activity(name, windows, incomplete=incomplete)['status'] != 'ACTIVE'):
return None
candidates = []
for window in windows:
if not (window['class'].startswith('Afx:') or window['class'] == '#32770'):
continue
if not window['title'].startswith('iCDB Project Backup') or not window['enabled']:
continue
for button in window['children']:
if (button['class'] == 'Button' and button.get('id') == 2 and button.get('enabled')
and button.get('text', '').replace('&', '').strip() in ('Cancel', '取消')):
candidates.append({'hwnd': window['hwnd'], 'button': button,
'title': window['title'],
'desktop': window.get('desktop', '')})
return candidates[0] if len(candidates) == 1 else None
def inspect_residual_sessions(library, *, block_names=()):
from .library_lock import _owner_matches_scope, blocker_path, checkpoint_record, has_retained_library
library = Path(library).resolve()
if library.suffix.casefold() != '.lmc':
raise ValueError('请选择中心库 .lmc 文件')
if not library.is_file():
raise ValueError('中心库路径当前不可见,请检查文件是否存在及网络盘映射后重新检查')
blocks = tuple(dict.fromkeys(str(name) for name in block_names))
if any(not name or name in ('.', '..') or any(c in name for c in '\\/:*?"<>|') for name in blocks):
raise ValueError('残留检查的工程名称无效')
roots = tuple(library.parent/'ReusableBlocksLP'/b/'Work' for b in blocks) + (library.parent/'SymbolLibs',)
if not blocks: roots = (library.parent,)
candidates = []
for row in query_process_snapshot():
if row['pid'] == os.getpid(): continue
native = row['name'].casefold() in _NAMES
worker = (row['name'].casefold() in _WORKER_NAMES
and any(flag in row['command'].casefold() for flag in _WORKER_FLAGS))
if not (native or worker): continue
scope = _owner_matches_scope(row, library, roots)
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']
item['block_names'] = list(blocks)
error = _window_error(windows, row['pid'])
item.update(windows_incomplete=bool(error), window_read_error=error)
try:
item.update(_process_identity(row))
target, detail = close_target(row['name'], windows.get(row['pid'], []), incomplete=error) if row['scope_confirmed'] else (
None, '归属未确认,请在原生窗口确认工程并关闭后重新检查')
item.update(can_close=target is not None, detail=detail)
except Exception as identity_error:
item.update(can_close=False, detail=f'进程已变化或暂时无法确认:{identity_error}')
item['project'] = _project_name(row, library) if row['scope_confirmed'] else '归属未确认'
item['prompt'] = _save_question(windows.get(row['pid'], []), incomplete=error) if row['scope_confirmed'] else None
observed = windows.get(row['pid'], [])
item['windows'] = observed
item['desktops'] = sorted({w.get('desktop', '') for w in observed if w.get('desktop')})
item['native_activity'] = native_activity(row['name'], observed, incomplete=error)
item['cancel_prompt'] = (_cancel_question(row['name'], observed, incomplete=error)
if row['scope_confirmed'] and item.get('force_user_confirmed') is True else None)
if any(name.startswith('Cbb') for name in item['desktops']) and not item['can_close']:
item['detail'] += ';窗口在后台,可查看原生提示并使用已提供的保存/取消操作'
item['force_block_reason'] = force_block_reason(item)
item['force_allowed'] = not item['force_block_reason']
if item['force_block_reason']:
item['detail'] += ';'+item['force_block_reason']
sessions.append(item)
previous = []
marker = blocker_path(library)
for path in (marker, marker.with_suffix('.pending')):
if path.exists():
record = checkpoint_record(path)
previous.append({'path': str(path), 'recognized': record is not None,
'status': record.get('status', 'UNRECOGNIZED') if record else 'UNRECOGNIZED',
'time': record.get('time', '') if record else '',
'pid': record.get('pid') if record else None})
if has_retained_library(library):
previous.append({'path': str(library), 'status': 'RETAINED_IN_MEMORY', 'time': '',
'pid': os.getpid(), 'kind': 'in_memory'})
return {'library': str(library), 'block_names': list(blocks), 'sessions': sessions,
'previous_records': previous}
def _request_close(row, *, stop=None):
import win32con, win32event, win32gui, win32process
with _process_handle(row['pid']) as handle:
if win32event.WaitForSingleObject(handle, 0) == win32con.WAIT_OBJECT_0:
return {'release_status': 'RELEASED', 'detail': '已退出'}
identity = _handle_identity(handle)
if identity != {key: row.get(key) for key in ('created_handle', 'image')}:
return {'release_status': 'IDENTITY_CHANGED', 'detail': '进程身份已变化,未关闭'}
snapshot = _process_windows({row['pid']})
windows, error = snapshot.get(row['pid'], []), _window_error(snapshot, row['pid'])
if error:
return {'release_status': 'WAITING', 'detail': '该会话窗口读取不完整,请重新检查:'+error}
if row['name'].casefold() == 'expeditionpcb.exe':
from .failed_session import _startup_snapshot, _cancel_target
for window in windows:
if window['class'] != '#32770': continue
target = _cancel_target(_startup_snapshot(window['hwnd'], row['pid']))
if target:
win32gui.PostMessage(target[1].handle, win32con.BM_CLICK, 0, 0)
deadline = time.monotonic()+3
while time.monotonic() < deadline:
if win32event.WaitForSingleObject(handle, 100) == win32con.WAIT_OBJECT_0:
return {'release_status': 'RELEASED', 'detail': '已取消启动并退出'}
if stop is not None and stop.is_set():
return {'release_status': 'CANCELLED', 'detail': '已停止释放'}
snapshot = _process_windows({row['pid']})
windows, error = snapshot.get(row['pid'], []), _window_error(snapshot, row['pid'])
if error:
break
if close_target(row['name'], windows)[0] is not None: break
break
target, detail = close_target(row['name'], windows, incomplete=error)
if target is None: return {'release_status': 'WAITING', 'detail': detail}
if stop is not None and stop.is_set():
return {'release_status': 'CANCELLED', 'detail': '已停止释放'}
if win32process.GetWindowThreadProcessId(target['hwnd'])[1] != row['pid']:
return {'release_status': 'IDENTITY_CHANGED', 'detail': '窗口归属已变化,未关闭'}
win32gui.PostMessage(target['hwnd'], win32con.WM_CLOSE, 0, 0)
deadline = time.monotonic()+3
while time.monotonic() < deadline:
if win32event.WaitForSingleObject(handle, 100) == win32con.WAIT_OBJECT_0:
return {'release_status': 'RELEASED', 'detail': '已正常退出'}
if stop is not None and stop.is_set(): break
return {'release_status': 'WAITING', 'detail': '已请求正常关闭;请处理原生窗口,完成后重新检查'}
def _force_close(row, *, stop=None):
"""Separate UI consent permits ending only this exact, scoped process handle."""
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:
if win32event.WaitForSingleObject(handle, 0) == win32con.WAIT_OBJECT_0:
return {'release_status': 'RELEASED', 'detail': '已退出'}
if _handle_identity(handle) != {k: row.get(k) for k in ('created_handle', 'image')}:
return {'release_status': 'IDENTITY_CHANGED', 'detail': '进程身份已变化,未结束'}
ownership = _force_ownership(handle, row['pid'])
if (not ownership['force_user_confirmed'] or
any(ownership[k] != row.get(k) for k in ('owner_sid', 'session_id'))):
return {'release_status': 'IDENTITY_CHANGED', 'detail': '用户或 Windows 会话已变化,未结束'}
snapshot = _process_windows({row['pid']})
activity = native_activity(row['name'], snapshot.get(row['pid'], []),
incomplete=_window_error(snapshot, row['pid']))
if reason := force_block_reason({**row, 'native_activity': activity}):
return {'release_status': 'WAITING', 'detail': reason, 'native_activity': activity}
if stop is not None and stop.is_set():
return {'release_status': 'CANCELLED', 'detail': '已停止释放,未强制结束'}
win32api.TerminateProcess(handle, 1)
exited = win32event.WaitForSingleObject(handle, 3000) == win32con.WAIT_OBJECT_0
return {'release_status': 'RELEASED' if exited else 'WAITING',
'detail': '已强制结束客户端,工程待检查,未执行修复' if exited else '已请求结束客户端,等待退出'}
def _finish_library_release(library, evidence):
from .library_lock import release_retained_library
return release_retained_library(library, evidence)
def _request_native_cancel(row, *, stop=None):
"""Only click the exact currently visible Cancel control the user confirmed."""
import win32con, win32gui, win32process
if row.get('scope_confirmed') is not True:
raise ValueError('取消目标归属未确认,请重新检查')
fresh = next((r for r in query_process_snapshot() if r['pid'] == row['pid']), None)
if fresh is None or any(fresh.get(k) != row.get(k) for k in ('created', 'command', 'executable', 'name')):
raise ValueError('取消目标身份已变化,请重新检查')
with _process_handle(row['pid']) as handle:
if _handle_identity(handle) != {k: row.get(k) for k in ('created_handle', 'image')}:
raise ValueError('取消目标身份已变化,请重新检查')
owner = _force_ownership(handle, row['pid'])
if not owner['force_user_confirmed'] or any(owner[k] != row.get(k) for k in ('owner_sid', 'session_id')):
raise ValueError('取消目标用户/会话已变化')
snapshot = _process_windows({row['pid']})
prompt = _cancel_question(row['name'], snapshot.get(row['pid'], []),
incomplete=_window_error(snapshot, row['pid']))
if not prompt or prompt != row.get('cancel_prompt'):
raise ValueError('原生取消按钮已变化,请重新检查')
button = prompt['button']
if win32process.GetWindowThreadProcessId(button['hwnd'])[1] != row['pid']:
raise ValueError('原生取消按钮归属已变化')
if stop is not None and stop.is_set():
return {'release_status': 'CANCELLED', 'detail': '已停止,未请求原生取消'}
win32gui.PostMessage(button['hwnd'], win32con.BM_CLICK, 0, 0)
return {'release_status': 'WAITING', 'detail': '已请求原生取消,需重新检查实际结果;未强制结束'}
def request_native_cancel(row, library, evidence_dir, *, stop=None):
# Reuse serialized admission, consent and incremental evidence for cancellation.
plan = {'library': str(library), 'sessions': [row], 'block_names': row.get('block_names', [])}
return release_residual_sessions(plan, evidence_dir, stop=stop, cancel_native=True)
def _session_evidence(row):
"""Keep the full preview in memory, but bound repeatedly written Output."""
value = dict(row)
if 'native_activity' in value:
value['native_activity'] = {k: v for k, v in value['native_activity'].items() if k != 'output'}
if 'windows' in value:
value['windows'] = []
for window in row['windows']:
saved = {k: window[k] for k in ('hwnd', 'title', 'class', 'desktop', 'enabled') if k in window}
output = window.get('output')
if isinstance(output, str):
data = output.encode('utf-8')
saved.update(output_excerpt=data[:4096].decode('utf-8', errors='ignore'),
output_bytes=len(data), output_sha256=hashlib.sha256(data).hexdigest(),
output_truncated=len(data) > 4096)
value['windows'].append(saved)
return value
def _release_residual_sessions(plan, evidence_dir, *, stop=None, force=False, cancel_native=False):
library = Path(plan['library']).resolve()
root = Path(evidence_dir).resolve()/('sessions-'+uuid4().hex[:12])
if root.is_relative_to(library.parent) or library.parent.is_relative_to(root):
raise ValueError('释放记录需位于中心库之外')
root.mkdir(parents=True)
result = {'status': 'PARTIAL', 'library': str(library), 'sessions': [
{**row, 'release_status': 'NOT_STARTED', 'detail': '尚未执行',
'consent_allowed': not force_block_reason(row) if force else row.get('scope_confirmed') is True}
for row in plan['sessions']], 'force': force, 'cancel_native': cancel_native,
'evidence_path': str(root/'result.json'), 'previous_records': plan.get('previous_records', [])}
def save():
from .management import _write_json
try:
result['report_saved'] = True
_write_json(root/'result.json', {**result, 'sessions': [_session_evidence(row) for row in result['sessions']]})
return True
except OSError as error:
result.update(status='PARTIAL', report_saved=False, evidence_error=str(error))
return False
if not save():
return result # No native actions without the initial checkpoint.
if force or cancel_native:
consent_path = root/'consent.json'
consent = {'version': 1, 'mode': 'cancel_native' if cancel_native else 'force_document_clients', 'library': str(library),
'time_ns': time.time_ns(), 'sessions': [
{**_session_evidence(row), 'force_allowed': not force_block_reason(row),
'cancel_allowed': bool(row.get('cancel_prompt')) and row.get('scope_confirmed') is True,
'force_block_reason': force_block_reason(row)} for row in plan['sessions']]}
try:
with consent_path.open('x', encoding='utf-8') as stream:
json.dump(consent, stream, ensure_ascii=False, indent=2)
stream.flush(); os.fsync(stream.fileno())
except OSError as error:
result['detail'] = f'确认记录保存失败,未执行:{error}'
save()
raise
result['consent_path'] = str(consent_path)
try:
fresh = {r['pid']: r for r in query_process_snapshot()}
blocks = plan.get('block_names', ())
roots = (tuple(library.parent/'ReusableBlocksLP'/b/'Work' for b in blocks)
+ (library.parent/'SymbolLibs',)) if blocks else (library.parent,)
# Close native children first; keep output rows in the original preview order.
ordered = sorted(result['sessions'], key=lambda r: r['name'].casefold() in _WORKER_NAMES)
for row in ordered:
current = fresh.get(row['pid'])
outcome = {'release_status': 'RELEASED', 'detail': '已退出'}
if stop is not None and stop.is_set():
outcome = {'release_status': 'CANCELLED', 'detail': '已停止释放'}
elif current is not None:
from .library_lock import _owner_matches_scope
scoped = _owner_matches_scope(current, library, roots) is True
if row.get('scope_confirmed') is not True or not scoped or row['pid'] == os.getpid():
outcome = {'release_status': 'WAITING', 'detail': '未在确认名单中证明属于当前库,未关闭;请重新检查'}
elif not row.get('created') or any(current.get(key) != row.get(key)
for key in ('created', 'executable', 'command', 'name')):
outcome = {'release_status': 'IDENTITY_CHANGED', 'detail': '确认后进程身份已变化,未关闭'}
elif force and (reason := force_block_reason(row)):
outcome = {'release_status': 'WAITING', 'detail': reason, 'force_allowed': False}
else:
row.update(release_status='REQUESTING', detail='正在请求原生操作,结果待确认')
if not save():
return result
try:
outcome = (_request_native_cancel(row, stop=stop) if cancel_native else
(_force_close if force else _request_close)(row, stop=stop))
except Exception as error:
outcome = {'release_status': 'WAITING', 'detail': str(error)}
row.update(outcome)
if not save():
return result # Preserve completed facts; stop further actions on storage failure.
after = {r['pid']: r for r in query_process_snapshot()}
remaining_windows = _process_windows({r['pid'] for r in result['sessions']
if r['release_status'] == 'WAITING' and r['pid'] in after})
for row in result['sessions']:
if row['release_status'] == 'WAITING' and row['pid'] not in after:
row.update(release_status='RELEASED', detail='已退出')
elif row['release_status'] == 'WAITING':
windows = remaining_windows.get(row['pid'], [])
error = _window_error(remaining_windows, row['pid'])
row.update(prompt=_save_question(windows, incomplete=error), windows=windows,
windows_incomplete=bool(error), window_read_error=error,
cancel_prompt=(_cancel_question(row['name'], windows, incomplete=error)
if row.get('force_user_confirmed') is True else None),
native_activity=native_activity(row['name'], windows, incomplete=error))
if all(row['release_status'] == 'RELEASED' for row in result['sessions']) and not (stop and stop.is_set()):
result['proof'] = _finish_library_release(library, root/'library-proof')
proof = result['proof']
if (proof.get('status') != 'RELEASE_CONFIRMED'
or Path(proof.get('library', '')).resolve() != library):
raise ValueError('释放证明与当前库不一致')
result['status'] = 'RELEASE_CONFIRMED'
from .session_record import record_session_release
errors = record_session_release(proof, plan.get('runtime_sessions', []))
if errors:
result['evidence_error'] = ';'.join(errors)
except BaseException as error:
result.update(status='PARTIAL', detail=f'{type(error).__name__}: {error}')
if not isinstance(error, Exception):
raise
finally:
save()
return result
def release_residual_sessions(plan, evidence_dir, *, stop=None, force=False, cancel_native=False):
import win32con, win32event
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
acquired = False
try:
deadline = time.monotonic()+15
while time.monotonic() < deadline and not (stop and stop.is_set()):
acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
if acquired: break
time.sleep(.2)
if not acquired:
return {'status': 'PARTIAL', 'library': plan['library'], 'sessions': [
{**r, 'release_status': 'WAITING', 'detail': '其它批次尚在执行;请停止该批次后重试'}
for r in plan['sessions']], 'detail': '未取得执行通道,未关闭任何进程。'}
return _release_residual_sessions(plan, evidence_dir, stop=stop, force=force, cancel_native=cancel_native)
finally:
if acquired: win32event.ReleaseMutex(mutex)
mutex.Close()
def answer_save_question(row, choice):
"""Only the exact displayed save question receives an explicit user answer."""
import win32con, win32event, win32gui
if choice not in (6, 7, 2): raise ValueError('无效的保存选择')
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
if not acquired:
mutex.Close()
raise ValueError('其它批次正在执行,请稍后处理保存提示')
try:
_answer_save_question(row, choice)
finally:
win32event.ReleaseMutex(mutex)
mutex.Close()
def _answer_save_question(row, choice):
import win32con, win32gui
fresh = next((r for r in query_process_snapshot() if r['pid'] == row['pid']), None)
if fresh is None or any(fresh.get(k) != row.get(k) for k in ('created', 'command', 'executable')):
raise ValueError('进程已变化,请重新检查')
with _process_handle(row['pid']) as handle:
if _handle_identity(handle) != {k: row.get(k) for k in ('created_handle', 'image')}:
raise ValueError('进程已变化,请重新检查')
snapshot = _process_windows({row['pid']})
prompt = _save_question(snapshot.get(row['pid'], []), incomplete=_window_error(snapshot, row['pid']))
if not prompt or prompt != row.get('prompt'):
raise ValueError('原生提示已变化,请重新检查')
button = prompt['buttons'][choice]
import win32process
if win32process.GetWindowThreadProcessId(button['hwnd'])[1] != row['pid']:
raise ValueError('保存按钮归属已变化')
win32gui.PostMessage(button['hwnd'], win32con.BM_CLICK, 0, 0)