143 lines
7.1 KiB
Python
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))
|