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
124 lines
6.0 KiB
Python
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)
|