148 lines
7.9 KiB
Python
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)
|