Files
dxdesigner-part-replacement/tools/probe_managed_desktop.py
T

148 lines
7.9 KiB
Python

"""Real Windows desktop reuse/owner-loss probe. Never launches CAD or opens projects."""
import argparse
import json
import os
from pathlib import Path
import subprocess
import sys
import time
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
from dx_productivity.trial_task_center.batch_runtime import BatchCadRuntime
from dx_productivity.trial_task_center.cad_identity import current_desktop_name
from dx_productivity.trial_task_center.desktop_slot import DesktopSlot
from dx_productivity.trial_task_center.errors import TaskCenterError
GUI = ('import win32gui,time; w=win32gui.CreateWindowEx(0,"STATIC","managed desktop probe",'
'0,0,0,100,60,0,0,0,None); assert w; time.sleep(.05); '
'win32gui.DestroyWindow(w); print("gui_closed",flush=True)')
HOLDER = ('import win32service,sys; h=win32service.OpenDesktop(sys.argv[1],0,False,1);'
'print("held",flush=True);sys.stdin.readline();h.CloseDesktop()')
def worker(root, mode):
if mode == 'compete':
try:
with BatchCadRuntime(root, 'slot_competition') as runtime:
runtime._ensure_desktop()
except TaskCenterError:
print(json.dumps({'busy': True})); return
raise AssertionError('competing owner acquired the slot')
runtime = BatchCadRuntime(root, 'desktop_reuse_probe')
with runtime:
with runtime.native_scope(root / 'operation') as scope:
if mode == 'crash-unpublished':
def interrupted(job, identity):
print(json.dumps({'job': job, 'pid': identity['pid'], 'desktop': scope.name}), flush=True)
assert sys.stdin.readline().strip() == 'crash'
os._exit(0)
runtime.desktop._slot.launched = interrupted
command = 'import time;time.sleep(60)' if mode.startswith('crash') else GUI
with (root / 'stdout.txt').open('wb') as out, (root / 'stderr.txt').open('wb') as err:
process = scope.start_process((sys.executable, '-u', '-c', command), stdout=out, stderr=err)
if mode == 'crash':
job = runtime.desktop._slot.record['launches'][-1]['job']
print(json.dumps({'job': job, 'pid': process.pid, 'desktop': scope.name}), flush=True)
assert sys.stdin.readline().strip() == 'crash'
os._exit(0)
assert process.wait(timeout=15) == 0
runtime.result = {'synthetic_gui_closed': True, 'cad_started': False}
print(json.dumps(dict(desktop=runtime.record['desktop'], state=runtime.record['state'],
lease_id=runtime.record['cleanup']['desktop_lease']['lease_id'],
desktop_released=runtime.record['release_results']['desktop_released'])))
def invoke(root, mode='worker'):
root.mkdir(parents=True, exist_ok=True)
result = subprocess.run([sys.executable, '-u', __file__, '--mode', mode, '--output', str(root)],
capture_output=True, text=True, encoding='utf-8', timeout=30,
creationflags=subprocess.CREATE_NO_WINDOW)
assert result.returncode == 0, result.stderr
return json.loads(result.stdout)
def probe(root, cycles):
import win32api
import win32event
import win32job
import win32service
root.mkdir(parents=True, exist_ok=False)
before_home = current_desktop_name()
before = set(win32service.GetProcessWindowStation().EnumDesktops())
name = DesktopSlot().name
report = dict(desktop=name, cad_started=False, cycles=[], success=False, desktops_before=sorted(before))
holder = crash = retained_job = root_process = None
started = time.perf_counter()
try:
with BatchCadRuntime(root / 'initial', 'desktop_reuse_probe') as initial:
initial._ensure_desktop()
assert invoke(root / 'competition', 'compete')['busy']
holder = subprocess.Popen([sys.executable, '-u', '-c', HOLDER, name],
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
text=True, creationflags=subprocess.CREATE_NO_WINDOW)
assert holder.stdout.readline().strip() == 'held'
for index in range(cycles):
item = invoke(root / f'cycle-{index:02d}')
assert item['desktop'] == name and item['desktop_released'] is False
assert item['state'] == 'isolated'
item['new_system_desktops'] = sorted(set(win32service.GetProcessWindowStation().EnumDesktops()) - before)
owned = {json.loads(p.read_text(encoding='utf-8'))['desktop'] for p in root.rglob('session.json')}
assert owned == {name} # Other applications may create desktops concurrently.
report['cycles'].append(item)
assert len({item['lease_id'] for item in report['cycles']}) == cycles
for mode in ('crash', 'crash-unpublished'):
crash_root = root / mode; crash_root.mkdir()
crash = subprocess.Popen([sys.executable, '-u', __file__, '--mode', mode, '--output', str(crash_root)],
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
text=True, creationflags=subprocess.CREATE_NO_WINDOW)
line = crash.stdout.readline()
assert line, crash.stderr.read()
observation = json.loads(line)
retained_job = win32job.OpenJobObject(0xC, False, observation['job'])
root_process = win32api.OpenProcess(0x100000, False, observation['pid'])
crash.stdin.write('crash\n'); crash.stdin.flush(); assert crash.wait(timeout=10) == 0
assert invoke(root / (mode+'-competition'), 'compete')['busy']
win32job.TerminateJobObject(retained_job, 1)
assert win32event.WaitForSingleObject(root_process, 10_000) == 0
retained_job.Close(); retained_job = None
root_process.Close(); root_process = None
report[mode] = invoke(root / ('after-'+mode))
assert report[mode]['desktop'] == name
for stream in (crash.stdin, crash.stdout, crash.stderr): stream.close()
crash = None
holder.stdin.write('release\n'); holder.stdin.flush(); assert holder.wait(timeout=5) == 0
deadline = time.monotonic() + 5
while name in win32service.GetProcessWindowStation().EnumDesktops() and time.monotonic() < deadline:
time.sleep(.05)
assert name not in win32service.GetProcessWindowStation().EnumDesktops()
assert current_desktop_name() == before_home
report.update(success=True, maximum_managed_desktops=1, competition_blocked=True,
surviving_job_blocked=True, fresh_lease_after_job_exit=True, desktop_disappeared=True)
finally:
if retained_job is not None:
win32job.TerminateJobObject(retained_job, 1); retained_job.Close()
if root_process is not None: root_process.Close()
for process in (crash, holder):
if process is None: continue
if process.poll() is None:
if process is holder:
process.stdin.write('release\n'); process.stdin.flush()
else: process.terminate()
process.wait(timeout=10)
for stream in (process.stdin, process.stdout, process.stderr): stream.close()
report['seconds'] = time.perf_counter() - started
(root / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
print(json.dumps({k:v for k,v in report.items() if k!='cycles'}))
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--cycles', type=int, default=20)
parser.add_argument('--mode', choices=('probe','worker','compete','crash','crash-unpublished'), default='probe')
args = parser.parse_args()
if args.mode == 'probe': probe(args.output.resolve(), args.cycles)
else: worker(args.output.resolve(), args.mode)