120 lines
5.6 KiB
Python
120 lines
5.6 KiB
Python
"""Read-only native observations while a disposable CAD regression runs."""
|
|
import ctypes
|
|
from ctypes import wintypes
|
|
import json
|
|
from pathlib import Path
|
|
from threading import Event, Thread
|
|
import time
|
|
|
|
|
|
def input_desktop_name():
|
|
user = ctypes.WinDLL('user32', use_last_error=True)
|
|
user.OpenInputDesktop.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
|
|
user.OpenInputDesktop.restype = wintypes.HANDLE
|
|
user.GetUserObjectInformationW.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p,
|
|
wintypes.DWORD, ctypes.POINTER(wintypes.DWORD)]
|
|
user.CloseDesktop.argtypes = [wintypes.HANDLE]
|
|
handle = user.OpenInputDesktop(0, False, 1)
|
|
if not handle:
|
|
raise ctypes.WinError(ctypes.get_last_error())
|
|
try:
|
|
name, required = ctypes.create_unicode_buffer(256), wintypes.DWORD()
|
|
if not user.GetUserObjectInformationW(handle, 2, name, ctypes.sizeof(name), ctypes.byref(required)):
|
|
raise ctypes.WinError(ctypes.get_last_error())
|
|
return name.value
|
|
finally:
|
|
user.CloseDesktop(handle)
|
|
|
|
|
|
class PrivateDesktopObserver:
|
|
def __init__(self, output):
|
|
self.output = Path(output)
|
|
self.stop = Event()
|
|
self.handles, self.records = {}, {}
|
|
self.foreground_pids, self.default_cad_pids = set(), set()
|
|
self.samples = self.readable_samples = 0
|
|
self.errors = []
|
|
|
|
def _sample(self):
|
|
import win32api, win32gui, win32process
|
|
import pywintypes
|
|
foreground = win32gui.GetForegroundWindow()
|
|
self.foreground_pids.add(win32process.GetWindowThreadProcessId(foreground)[1] if foreground else 0)
|
|
self.samples += 1
|
|
if (Path(__file__).resolve().parents[1] / 'README.md').read_bytes():
|
|
self.readable_samples += 1
|
|
paths = list((self.output / 'data' / 'tasks').glob('*/quick-run/private-desktop.json'))
|
|
paths += list((self.output / 'data' / 'tasks').glob('*/quick-run-history/sheet-discovery-*/private-desktop.json'))
|
|
paths += list((self.output / 'data' / 'tasks').glob('*/quick-run-history/recovery-*/worker/private-desktop.json'))
|
|
paths += list((self.output / 'independent-read' / 'quick-run-history').glob('sheet-discovery-*/private-desktop.json'))
|
|
for path in paths:
|
|
# A Windows atomic replacement can briefly deny a simultaneous
|
|
# open. Retry briefly; persistent failures still fail the probe.
|
|
for attempt in range(4):
|
|
try:
|
|
value = json.loads(path.read_text(encoding='utf-8'))
|
|
break
|
|
except PermissionError:
|
|
if attempt == 3:
|
|
raise
|
|
time.sleep(0.01)
|
|
self.records[value['desktop']] = dict(value, evidence_path=str(path.relative_to(self.output)))
|
|
pid = value.get('cad_pid')
|
|
if pid and pid not in self.handles:
|
|
try:
|
|
self.handles[pid] = win32api.OpenProcess(0x100000, False, pid)
|
|
except (OSError, pywintypes.error) as error:
|
|
if getattr(error, 'winerror', error.args[0]) != 87:
|
|
raise
|
|
def collect(handle, _):
|
|
if win32gui.GetClassName(handle).startswith('Afx:') and 'DxDesigner' in win32gui.GetWindowText(handle):
|
|
self.default_cad_pids.add(win32process.GetWindowThreadProcessId(handle)[1])
|
|
win32gui.EnumWindows(collect, None)
|
|
|
|
def _watch(self):
|
|
while not self.stop.wait(0.2):
|
|
try:
|
|
self._sample()
|
|
except Exception as error:
|
|
self.errors.append(str(error))
|
|
|
|
def __enter__(self):
|
|
self.input_before = input_desktop_name()
|
|
self._sample()
|
|
self.baseline_cad_pids = set(self.default_cad_pids)
|
|
self.thread = Thread(target=self._watch, daemon=True)
|
|
self.thread.start()
|
|
return self
|
|
|
|
def __exit__(self, *_):
|
|
import win32event, win32service
|
|
import pywintypes
|
|
self.stop.set()
|
|
self.thread.join(3)
|
|
self._sample()
|
|
exits, desktops = {}, {}
|
|
for value in self.records.values():
|
|
pid, name = value.get('cad_pid'), value['desktop']
|
|
handle = self.handles.get(pid)
|
|
exits[str(pid)] = handle is None or win32event.WaitForSingleObject(handle, 5000) == 0
|
|
try:
|
|
desktop = win32service.OpenDesktop(name, 0, False, 1)
|
|
except (OSError, pywintypes.error) as error:
|
|
desktops[name] = getattr(error, 'winerror', error.args[0]) == 2
|
|
else:
|
|
desktops[name] = False
|
|
desktop.CloseDesktop()
|
|
for handle in self.handles.values():
|
|
handle.Close()
|
|
owned = {value.get('cad_pid') for value in self.records.values()}
|
|
report = {'samples': self.samples, 'file_read_samples': self.readable_samples,
|
|
'input_desktop_before': self.input_before, 'input_desktop_after': input_desktop_name(),
|
|
'foreground_pids': sorted(self.foreground_pids),
|
|
'owned_cad_became_foreground': bool(owned & self.foreground_pids),
|
|
'owned_cad_on_input_desktop': bool(owned & self.default_cad_pids),
|
|
'baseline_default_cad_pids': sorted(self.baseline_cad_pids),
|
|
'observed_default_cad_pids': sorted(self.default_cad_pids),
|
|
'cad_exit_confirmed': exits, 'desktop_absent': desktops,
|
|
'sessions': self.records, 'observer_errors': self.errors}
|
|
(self.output / 'desktop-observation.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
|