Files
dxdesigner-part-replacement/tools/probe_saved_source_handoff.py
T
阿白叔 e63a82b695
Core regression / Python core, intervention UI and release configuration (push) Successful in 4m44s
Core regression / JavaScript syntax (push) Successful in 6s
Core regression / Python core, intervention UI and release configuration (pull_request) Successful in 3m57s
Core regression / JavaScript syntax (pull_request) Successful in 6s
fix: reconcile saved database locks without replaying replacements
2026-11-18 18:24:50 +08:00

124 lines
6.0 KiB
Python

"""Exercise saved-source handoff using real Windows file locks on synthetic files."""
import argparse
import hashlib
import json
from pathlib import Path
import subprocess
import sys
from threading import Event, Thread
import time
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
from dx_productivity.trial_task_center import saved_source
from dx_productivity.trial_task_center.execution_proof import bind_project_commit_source
HOLDER = ('import win32file,sys;h=win32file.CreateFile(sys.argv[1],0x80000000,0,None,3,0,None);'
'print("locked",flush=True);sys.stdin.readline();h.Close()')
def probe(root, cycles):
root.mkdir(parents=True, exist_ok=False)
started = time.perf_counter()
report = dict(passed=False, cad_started=False, samples=[])
saved_source.LOCK_WAIT_SECONDS = .3
try:
for index in range(cycles):
mode = ('transient', 'release_then_read', 'persistent_external', 'pause', 'missing')[index % 5]
folder = root / f'{index:02d}-{mode}'
folder.mkdir()
project = folder / 'test.prj'
project.write_text('KEY iCDBDir "database"\n')
database = folder / 'database/icdb.dat'
database.parent.mkdir()
database.write_bytes(b'synthetic saved source')
evidence = folder / 'data/quick-run'
evidence.mkdir(parents=True)
(evidence / 'command.tsv').write_text('immutable synthetic command')
stop = Event()
holder = thread = None
failures = []
releases = []
sample = dict(mode=mode, passed=False)
try:
if mode == 'missing':
database.unlink()
else:
holder = subprocess.Popen([sys.executable, '-u', '-c', HOLDER, str(database)],
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
text=True, creationflags=subprocess.CREATE_NO_WINDOW)
assert holder.stdout.readline().strip() == 'locked'
try:
saved_source.source_hash(database)
raise AssertionError('exclusive file lock admitted a reader')
except OSError as error:
assert error.winerror == 32
observation = saved_source.locking_processes(database)
assert any(p['pid'] == holder.pid for p in observation['processes']), observation
sample['observed_holder'] = observation
def release():
if holder is not None and holder.poll() is None:
holder.stdin.write('release\n'); holder.stdin.flush()
assert holder.wait(timeout=5) == 0
def after_wait():
deadline = time.monotonic() + 10
try:
while time.monotonic() < deadline:
path = evidence / 'saved-source-status.json'
if path.is_file() and json.loads(path.read_text(encoding='utf-8'))['state'] == 'waiting':
if mode == 'pause': stop.set()
else: release()
return
time.sleep(.01)
raise AssertionError('did not reach saved-source wait')
except Exception as error:
failures.append(str(error))
if mode in ('transient', 'pause'):
thread = Thread(target=after_wait)
thread.start()
def release_owner(error):
releases.append(error.winerror)
if mode == 'release_then_read': release()
try:
proof = bind_project_commit_source(dict(session_token=f'{index:032x}'), evidence.parent,
evidence, project, stop_event=stop, release_mentor=release_owner)
assert mode in ('transient', 'release_then_read')
assert proof['saved_sources'][str(database.resolve()).casefold()] == hashlib.sha256(database.read_bytes()).hexdigest()
except saved_source.SavedSourceReadError as error:
assert mode in ('persistent_external', 'pause', 'missing'), str(error)
assert error.winerror == (2 if mode == 'missing' else 32)
assert error.interrupted == (mode == 'pause')
sample['pending_code'] = error.code
if thread is not None:
thread.join(timeout=12)
assert not thread.is_alive() and not failures, failures
assert releases == ([32] if mode in ('release_then_read', 'persistent_external') else [])
status = json.loads((evidence / 'saved-source-status.json').read_text(encoding='utf-8'))
assert status['replacement_replayed'] is False
sample.update(passed=True, state=status['state'], release_requests=len(releases))
finally:
if holder is not None:
release()
for stream in (holder.stdin, holder.stdout, holder.stderr): stream.close()
if thread is not None: thread.join(timeout=12)
report['samples'].append(sample)
report['passed'] = all(sample['passed'] for sample in report['samples'])
finally:
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(dict(passed=report['passed'], samples=len(report['samples']), seconds=report['seconds'])))
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--cycles', type=int, default=20)
args = parser.parse_args()
probe(args.output.resolve(), args.cycles)