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

143 lines
7.1 KiB
Python

"""Windows-only real external OpenDesktop reference acceptance (never starts CAD)."""
from __future__ import annotations
import argparse
import hashlib
import json
import os
from pathlib import Path
import subprocess
import sys
import time
from uuid import uuid4
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
from dx_productivity.trial_task_center.batch_resources import (
BatchResourceCleanupError, cleanup_pending_resources, pending_resources,
)
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.isolated_desktop import _Win32Api
HOLDER = '''import json,os,sys,win32service
handle=win32service.OpenDesktop(sys.argv[1],0,False,1)
print(json.dumps({'state':'holding','pid':os.getpid(),'handle':int(handle)}),flush=True)
assert sys.stdin.readline().strip()=='release'
handle.CloseDesktop()
print(json.dumps({'state':'released','pid':os.getpid()}),flush=True)
'''
def probe(output):
if os.name != 'nt':
raise RuntimeError('Windows is required')
output = Path(output).resolve() / ('run-' + uuid4().hex)
root = output / 'data'
output.mkdir(parents=True)
started = time.monotonic()
before_desktop = current_desktop_name()
cad_requests = []
def forbidden_cad(*args, **kwargs):
cad_requests.append(True)
raise AssertionError('This resource-only probe must not create CAD')
runtime = BatchCadRuntime(root, 'external_holder_acceptance', cad_factory=forbidden_cad)
runtime.__enter__()
desktop = runtime._ensure_desktop()
result_path = runtime.path.parent / 'business-result.json'
original_result = {'kind': 'acceptance_fixture', 'status': 'verified',
'completed': True, 'saved_projects': 0, 'note': 'Synthetic result, no CAD/project operation'}
original_bytes = json.dumps(original_result, ensure_ascii=False, indent=2).encode('utf-8')
result_path.write_bytes(original_bytes)
runtime.result = original_result
digest = hashlib.sha256(original_bytes).hexdigest()
holder = None
report = {'version': 1, 'probe_pid': os.getpid(), 'desktop': desktop.name,
'result_sha256_before': digest, 'events': [], 'cad_requests': cad_requests,
'holder_identification': {'diagnostics_identified_external_handle_holder': False,
'external_handle_holders': 'unknown',
'fixture_pid_source': 'PID returned by subprocess.Popen and confirmed by fixture handshake; not inferred from diagnostics'}}
try:
holder = subprocess.Popen((sys.executable, '-u', '-c', HOLDER, desktop.name),
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
text=True, encoding='utf-8', creationflags=subprocess.CREATE_NO_WINDOW)
handshake = json.loads(holder.stdout.readline())
assert handshake['pid'] == holder.pid and handshake['state'] == 'holding'
report['holder_fixture'] = handshake
try:
runtime.close()
raise AssertionError('cleanup incorrectly succeeded with external holder')
except BatchResourceCleanupError as failure:
assert failure.completed_result == original_result
report['events'].append({'phase': 'initial_cleanup', 'blocked': True,
'error': str(failure), 'holder_still_running': holder.poll() is None})
assert holder.poll() is None
blocked = pending_resources(root)
assert len(blocked) == 1 and blocked[0]['state'] == 'blocked'
assert blocked[0]['cleanup']['desktop_confirmation']['remaining_windows'] == []
assert blocked[0]['cleanup']['desktop_handle_closed']
report['blocked_resource_record'] = blocked[0]
candidate = BatchCadRuntime(root, 'must_be_blocked', cad_factory=forbidden_cad)
try:
candidate.__enter__()
raise AssertionError('new batch bypassed pending resource guard')
except BatchResourceCleanupError as failure:
report['events'].append({'phase': 'new_batch', 'blocked': True, 'error': str(failure)})
assert candidate.generation == 0 and candidate.desktop is None
pending = cleanup_pending_resources(root)
assert pending and pending[0]['state'] == 'blocked' and holder.poll() is None
report['events'].append({'phase': 'resource_only_retry_while_held',
'blocked': True, 'holder_still_running': True})
assert result_path.read_bytes() == original_bytes
holder.stdin.write('release\n')
holder.stdin.flush()
released = json.loads(holder.stdout.readline())
assert released['state'] == 'released' and released['pid'] == holder.pid
assert holder.wait(timeout=5) == 0
remaining = cleanup_pending_resources(root)
assert remaining == ()
final = json.loads(runtime.path.read_text(encoding='utf-8'))
assert final['state'] == 'released'
assert final['cad_pid'] is None and final['cad_start_requested'] is False
assert final['processes'] == [] and cad_requests == []
assert result_path.read_bytes() == original_bytes and runtime.result == original_result
assert current_desktop_name() == before_desktop
listed = _Win32Api().service.GetProcessWindowStation().EnumDesktops()
assert desktop.name.casefold() not in {name.casefold() for name in listed}
# Admission may be checked again, but no batch resources or business work
# are started by this independent acceptance probe.
with BatchCadRuntime(root, 'post_release_admission', cad_factory=forbidden_cad) as admitted:
assert admitted.generation == 0 and admitted.desktop is None
report.update(success=True, final_resource_record=final,
result_sha256_after=hashlib.sha256(result_path.read_bytes()).hexdigest(),
business_result_unchanged=True, cad_started=False, business_replayed=False,
desktop_released=True, input_desktop_unchanged=True,
elapsed_seconds=time.monotonic() - started)
report['events'].append({'phase': 'resource_only_retry_after_holder_release',
'released': True, 'business_result_unchanged': True})
except Exception as failure:
report.update(success=False, failure=repr(failure))
raise
finally:
if holder is not None:
if holder.poll() is None:
# Only this explicitly created helper may be stopped on probe failure.
holder.terminate()
holder.wait(timeout=5)
for stream in (holder.stdin, holder.stdout, holder.stderr):
if stream is not None:
stream.close()
try:
runtime.close(reason='probe_finally')
finally:
(output / 'evidence.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
return output / 'evidence.json'
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--output', type=Path, default=Path('build/issue-3-external-holder'))
args = parser.parse_args()
print(probe(args.output))