amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
One user-space repair task per eligible HWE debug-diag / compile-deploy base
ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content
filter. Each ships a public spec with a check-to-basis table, at least two
defects with single-fix fixtures, a symptom-masking fixture and an alternative
correct implementation. Claude re-checked all 320: structure, the HWE quality
items and trace6 Docker calibration receipts against current digests
(320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120
ad-hoc family names; the next batch maps them to the canonical list.
The batch's 1,256-line progress log stays in its factory report and the
36-local branch batch15-hwe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 01:55:56 +08:00

584 lines
28 KiB
Python

"""Independent Python state oracle and candidate-identity process supervisor."""
import base64
import decimal
import hashlib
import json
import math
import os
from pathlib import Path
import random
import stat
import subprocess
import sys
import tempfile
import time
FILES = ('param.h', 'schema.cpp', 'store.cpp', 'protocol.cpp', 'main.cpp')
ORDER = ('rate', 'retries', 'enabled', 'mode')
TYPES = {'rate': 'decimal', 'retries': 'integer', 'enabled': 'boolean', 'mode': 'text'}
DEFAULT = {'rate': '30', 'retries': '3', 'enabled': 'true', 'mode': 'auto'}
COMPILER_DEADLINE = 30.0
CANDIDATE_DEADLINE = 20.0
CLEANUP_DEADLINE = 12.0
ABSENCE_DEADLINE = 12.0
REAP_ALLOWANCE = 4.0
SUPERVISOR = r'''
import base64, ctypes, hashlib, json, os, selectors, signal, subprocess, sys, time
phase, nonce, deadline_text, cwd, argv_text = sys.argv[1:6]
argv = json.loads(argv_text)
input_bytes = sys.stdin.buffer.read()
deadline = float(deadline_text)
errors = []
tracked = {}
leader = None
leader_rc = None
leader_start = None
start = time.monotonic()
def stat_one(pid):
try:
raw = open('/proc/%d/stat' % pid, 'rb').read()
except (FileNotFoundError, ProcessLookupError):
return None
tail = raw[raw.rfind(b')') + 2:].split()
return (tail[0].decode('ascii'), int(tail[1]), int(tail[19]), int(tail[2]))
def table():
result = {}
for entry in os.listdir('/proc'):
if entry.isdecimal():
pid = int(entry)
item = stat_one(pid)
if item is not None: result[pid] = item
return result
def live(item):
return item is not None and item[0] not in ('Z', 'X')
def discover(snapshot):
self_pid = os.getpid()
own = snapshot.get(self_pid)
if own is None: raise RuntimeError('supervisor disappeared from proc')
parents = {self_pid}
for pid, expected_start in tracked.items():
item = snapshot.get(pid)
if live(item) and item[2] == expected_start: parents.add(pid)
changed = True
while changed:
changed = False
for pid, item in snapshot.items():
if pid == self_pid or not live(item): continue
if item[1] in parents and pid not in parents:
parents.add(pid)
tracked[pid] = item[2]
changed = True
return {pid: snapshot[pid] for pid in parents if pid != self_pid and live(snapshot.get(pid))}
def signal_fresh(pid, expected_start):
item = stat_one(pid)
if not live(item) or item[2] != expected_start: return
try: os.kill(pid, signal.SIGKILL)
except ProcessLookupError: pass
def reap_adopted():
while True:
try: pid, status = os.waitpid(-1, os.WNOHANG)
except ChildProcessError: return
if pid == 0: return
if leader is not None and pid == leader.pid:
errors.append('leader_stolen')
stdout, stderr = bytearray(), bytearray()
sel = selectors.DefaultSelector()
timed_out = False
remaining = {}
try:
if ctypes.CDLL(None).prctl(36, 1, 0, 0, 0) != 0:
raise RuntimeError('subreaper failed')
supervisor_pid = os.getpid()
supervisor_start = stat_one(supervisor_pid)[2]
leader = subprocess.Popen(argv, cwd=cwd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, start_new_session=True)
item = stat_one(leader.pid)
if item is None: raise RuntimeError('leader stat unavailable')
leader_start = item[2]
tracked[leader.pid] = leader_start
for stream, output in ((leader.stdout, stdout), (leader.stderr, stderr)):
os.set_blocking(stream.fileno(), False)
sel.register(stream, selectors.EVENT_READ, output)
if input_bytes:
try: leader.stdin.write(input_bytes)
except BrokenPipeError: pass
leader.stdin.close()
kill_at = start + deadline
hard_end = kill_at + 3.0
while time.monotonic() < hard_end:
for key, _ in sel.select(timeout=0.02):
try: chunk = os.read(key.fileobj.fileno(), 65536)
except BlockingIOError: continue
if chunk: key.data.extend(chunk)
else:
sel.unregister(key.fileobj)
key.fileobj.close()
snapshot = table()
current = discover(snapshot)
own_rc = leader.poll()
if own_rc is not None and leader_rc is None:
leader_rc = own_rc
leader.wait()
if leader_rc is not None or time.monotonic() >= kill_at:
if leader_rc is None: timed_out = True
for pid, proc in current.items(): signal_fresh(pid, proc[2])
if leader_rc is not None: reap_adopted()
if leader_rc is not None and not current and not sel.get_map(): break
if leader_rc is None:
timed_out = True
snapshot = table()
for pid, proc in discover(snapshot).items(): signal_fresh(pid, proc[2])
try: leader_rc = leader.wait(timeout=0.5)
except subprocess.TimeoutExpired: errors.append('leader_not_reaped')
reap_adopted()
remaining = discover(table())
if remaining: errors.append('descendants_alive')
if sel.get_map(): errors.append('pipes_open')
except BaseException as exc:
errors.append(type(exc).__name__ + ':' + str(exc)[:120])
try:
if leader is not None:
recovery_end = time.monotonic() + 3.0
while time.monotonic() < recovery_end:
current = discover(table())
for pid, proc in current.items(): signal_fresh(pid, proc[2])
own_rc = leader.poll()
if own_rc is not None and leader_rc is None:
leader_rc = own_rc
leader.wait()
if leader_rc is not None: reap_adopted()
if leader_rc is not None and not current: break
time.sleep(0.03)
remaining = discover(table())
if remaining: errors.append('exception_descendants_alive')
except BaseException as recovery:
errors.append('recovery:' + type(recovery).__name__)
finally:
try: sel.close()
except BaseException as exc: errors.append('selector:' + type(exc).__name__)
try:
pg_members = [[pid, item[2]] for pid, item in table().items()
if leader is not None and live(item) and item[3] == leader.pid]
except BaseException as exc:
errors.append('pg_probe:' + type(exc).__name__)
pg_members = [[-1, -1]]
elapsed = time.monotonic() - start
wire = {
'phase': phase, 'nonce': nonce, 'uid': os.getuid(), 'gid': os.getgid(),
'groups': os.getgroups(), 'supervisor_pid': os.getpid(),
'supervisor_start': stat_one(os.getpid())[2],
'leader_pid': leader.pid if leader else None, 'leader_start': leader_start,
'argv': argv, 'cwd': cwd, 'deadline': deadline, 'elapsed': elapsed,
'input_len': len(input_bytes), 'input_sha256': hashlib.sha256(input_bytes).hexdigest(),
'stdout_len': len(stdout), 'stdout_sha256': hashlib.sha256(stdout).hexdigest(),
'stderr_len': len(stderr), 'stderr_sha256': hashlib.sha256(stderr).hexdigest(),
'stdout_b64': base64.b64encode(stdout).decode('ascii'),
'stderr_b64': base64.b64encode(stderr).decode('ascii'),
'timeout': timed_out, 'rc': 124 if timed_out else leader_rc, 'leader_rc': leader_rc,
'leader_reaped': leader_rc is not None,
'descendants_absent': not remaining, 'pg_absent': not pg_members,
'pg_members': pg_members, 'exceptions': errors,
'tracked': [[pid, starttime] for pid, starttime in sorted(tracked.items())]
}
sys.stdout.write(json.dumps(wire, separators=(',', ':')) + '\n')
sys.exit(0 if not errors else 1)
'''
CLEAN_SCRIPT = "import shutil,sys; shutil.rmtree(sys.argv[1]); print('removed')"
ABSENCE_SCRIPT = "import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: print('absent')\nelse: print('present'); raise SystemExit(1)"
def sha(raw):
return hashlib.sha256(raw).hexdigest()
def strict_int(value, low=None):
return type(value) is int and (low is None or value >= low)
def validate_wire(data, phase, nonce, argv, cwd, stdin, deadline, uid, gid, groups, wrapper_rc):
if wrapper_rc != 0 or not isinstance(data, dict): raise ValueError('supervisor rc/wire')
if data.get('phase') != phase or data.get('nonce') != nonce: raise ValueError('phase/nonce')
if data.get('argv') != argv or data.get('cwd') != cwd: raise ValueError('argv/cwd')
if type(data.get('uid')) is not int or data['uid'] != uid: raise ValueError('uid')
if type(data.get('gid')) is not int or data['gid'] != gid: raise ValueError('gid')
actual_groups = data.get('groups')
if type(actual_groups) is not list or any(type(x) is not int for x in actual_groups): raise ValueError('groups type')
if actual_groups != groups: raise ValueError('groups')
for name in ('supervisor_pid', 'leader_pid', 'supervisor_start', 'leader_start'):
if not strict_int(data.get(name), 1): raise ValueError(name)
if data['supervisor_pid'] == data['leader_pid']: raise ValueError('pid collision')
elapsed = data.get('elapsed')
if type(elapsed) not in (float, int) or not math.isfinite(elapsed) or not 0 <= elapsed <= deadline + REAP_ALLOWANCE:
raise ValueError('elapsed')
if type(data.get('deadline')) not in (int, float) or data['deadline'] != deadline: raise ValueError('deadline')
if type(data.get('timeout')) is not bool: raise ValueError('timeout type')
if type(data.get('leader_reaped')) is not bool or not data['leader_reaped']: raise ValueError('leader reaped')
if type(data.get('descendants_absent')) is not bool or not data['descendants_absent']: raise ValueError('descendants')
if type(data.get('pg_absent')) is not bool or not data['pg_absent']: raise ValueError('process group')
if type(data.get('pg_members')) is not list or data['pg_members']: raise ValueError('pg members')
if type(data.get('exceptions')) is not list or data['exceptions']: raise ValueError('exceptions')
if not strict_int(data.get('rc')) or not strict_int(data.get('leader_rc')): raise ValueError('rc type')
if data['timeout']:
if data['rc'] != 124 or data['leader_rc'] == 0: raise ValueError('timeout rc')
elif data['rc'] != data['leader_rc']:
raise ValueError('rc inconsistent')
tracked = data.get('tracked')
if type(tracked) is not list or not tracked: raise ValueError('tracked')
seen = set()
for token in tracked:
if type(token) is not list or len(token) != 2 or not all(strict_int(x, 1) for x in token):
raise ValueError('tracked token')
if token[0] in seen: raise ValueError('tracked duplicate')
seen.add(token[0])
if [data['leader_pid'], data['leader_start']] not in tracked: raise ValueError('leader token')
if not strict_int(data.get('input_len'), 0) or type(data.get('input_sha256')) is not str:
raise ValueError('input shape')
if data['input_len'] != len(stdin) or data['input_sha256'] != sha(stdin): raise ValueError('input identity')
for stream in ('stdout', 'stderr'):
if not strict_int(data.get(stream + '_len'), 0): raise ValueError(stream + ' len')
value = data.get(stream + '_sha256')
if type(value) is not str or len(value) != 64: raise ValueError(stream + ' sha')
encoded = data.get(stream + '_b64')
if type(encoded) is not str: raise ValueError(stream + ' b64')
raw = base64.b64decode(encoded, validate=True)
if len(raw) != data[stream + '_len'] or sha(raw) != value: raise ValueError(stream + ' bytes')
data[stream + '_raw'] = raw
return data
def run_stage(phase, argv, cwd, stdin, deadline, identity):
nonce = sha(os.urandom(16))[:24]
wire_argv = [sys.executable, '-I', '-c', SUPERVISOR, phase, nonce, str(deadline), cwd,
json.dumps(argv, separators=(',', ':'))]
result = subprocess.run(wire_argv, input=stdin, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
cwd='/tmp', timeout=deadline + REAP_ALLOWANCE + 3)
# Preserve the real wrapper result before interpreting potentially broken wire.
raw = result.stdout
wrapper_fact = {'phase': phase, 'wrapper_rc': result.returncode, 'wire_len': len(raw), 'wire_sha256': sha(raw)}
try:
data = json.loads(raw)
parsed = validate_wire(data, phase, nonce, argv, cwd, stdin, deadline, *identity, result.returncode)
wrapper_fact['wire_valid'] = True
return parsed, wrapper_fact
except BaseException as exc:
wrapper_fact['wire_valid'] = False
wrapper_fact['wire_error'] = type(exc).__name__ + ':' + str(exc)[:100]
return None, wrapper_fact
class Oracle:
def __init__(self):
self.values = {}
def parse(self, name, token):
import re
if name == 'rate':
if not re.fullmatch(r'[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?', token):
return None
try:
number = decimal.Decimal(token)
scaled = number * decimal.Decimal(1000000)
if not decimal.Decimal(1) <= number <= decimal.Decimal(240) or scaled != scaled.to_integral_value():
return None
micros = int(scaled)
whole, fraction = divmod(micros, 1000000)
return str(whole) if not fraction else '%d.%s' % (whole, str(fraction).zfill(6).rstrip('0'))
except (decimal.InvalidOperation, ValueError, OverflowError):
return None
if name == 'retries':
if not re.fullmatch(r'[+-]?[0-9]+', token): return None
number = int(token)
return str(number) if 0 <= number <= 8 else None
if name == 'enabled': return token if token in ('true', 'false') else None
if name == 'mode': return token if token in ('auto', 'manual', 'safe') else None
return None
def target_error(self, name):
if name not in DEFAULT: return 'ERR unknown'
if name not in self.values: return 'ERR undeclared'
return None
def process(self, raw):
import re
if len(raw) > 4096: return 'ERR syntax'
fields = re.findall(r'[^ \t]+', raw.strip(' \t'))
if not fields: return None
op = fields[0]
if op == 'BOOT' and len(fields) == 1:
self.values = dict(DEFAULT)
return 'OK boot 4'
if op == 'DECLARE_MANY' and len(fields) == 2:
names = fields[1].split(',')
if not 1 <= len(names) <= 4 or any(not name for name in names): return 'ERR syntax'
proposed = dict(self.values)
for name in names:
if name not in DEFAULT: return 'ERR unknown'
if name in proposed: return 'ERR already_declared'
proposed[name] = DEFAULT[name]
self.values = proposed
return 'OK declare_many ' + str(len(names))
if op == 'DECLARE' and len(fields) == 2:
name = fields[1]
if name not in DEFAULT: return 'ERR unknown'
if name in self.values: return 'ERR already_declared'
self.values[name] = DEFAULT[name]
return 'OK declare ' + name
if op == 'GET' and len(fields) == 2:
name = fields[1]
error = self.target_error(name)
if error: return error
return 'OK %s %s %s' % (name, TYPES[name], self.values[name])
if op == 'SET' and len(fields) == 3:
name = fields[1]
error = self.target_error(name)
if error: return error
value = self.parse(name, fields[2])
if value is None: return 'ERR value'
self.values[name] = value
return 'OK set ' + name
if op == 'PATCH' and len(fields) == 2:
pieces = fields[1].split(',')
if not 1 <= len(pieces) <= 8: return 'ERR syntax'
pending = []
for item in pieces:
if item.count('=') != 1: return 'ERR syntax'
name, token = item.split('=')
if not name or not token: return 'ERR syntax'
pending.append((name, token))
next_values = dict(self.values)
for name, token in pending:
error = self.target_error(name)
if error: return error
value = self.parse(name, token)
if value is None: return 'ERR value'
next_values[name] = value
self.values = next_values
return 'OK patch ' + str(len(pending))
if op == 'CAS' and len(fields) == 4:
name = fields[1]
error = self.target_error(name)
if error: return error
before = self.parse(name, fields[2])
after = self.parse(name, fields[3])
if before is None or after is None: return 'ERR value'
if self.values[name] != before: return 'ERR mismatch'
self.values[name] = after
return 'OK cas ' + name
if op == 'DEFAULTS' and len(fields) == 1:
return 'OK defaults' + ''.join(' %s:%s:%s' % (name, TYPES[name], DEFAULT[name]) for name in ORDER)
if op == 'RESET' and len(fields) == 2:
name = fields[1]
error = self.target_error(name)
if error: return error
self.values[name] = DEFAULT[name]
return 'OK reset ' + name
if op == 'LIST' and len(fields) == 1:
return 'OK list' + ''.join(' %s:%s:%s' % (name, TYPES[name], self.values[name])
for name in ORDER if name in self.values)
if op == 'COUNT' and len(fields) == 1: return 'OK count ' + str(len(self.values))
if op == 'DESCRIBE' and len(fields) == 2:
name = fields[1]
if name not in DEFAULT: return 'ERR unknown'
return 'OK describe %s %s %s' % (name, TYPES[name], DEFAULT[name])
if op == 'COMPARE' and len(fields) == 3:
name = fields[1]
error = self.target_error(name)
if error: return error
value = self.parse(name, fields[2])
if value is None: return 'ERR value'
return 'OK equal ' + ('true' if self.values[name] == value else 'false')
if op == 'CHANGES' and len(fields) == 1:
return 'OK changes' + ''.join(' %s:%s' % (name, self.values[name]) for name in ORDER
if name in self.values and self.values[name] != DEFAULT[name])
if op == 'RESTORE' and len(fields) == 1:
changed = sum(self.values[name] != DEFAULT[name] for name in self.values)
self.values = {name: DEFAULT[name] for name in self.values}
return 'OK restore ' + str(changed)
if op == 'REMOVE' and len(fields) == 2:
name = fields[1]
error = self.target_error(name)
if error: return error
del self.values[name]
return 'OK remove ' + name
if op == 'CLEAR' and len(fields) == 1:
count = len(self.values)
self.values.clear()
return 'OK clear ' + str(count)
if op == 'VALIDATE' and len(fields) == 3:
name = fields[1]
if name not in DEFAULT: return 'ERR unknown'
value = self.parse(name, fields[2])
return 'ERR value' if value is None else 'OK valid %s %s' % (name, value)
if op == 'MISSING' and len(fields) == 1:
return 'OK missing' + ''.join(' ' + name for name in ORDER if name not in self.values)
if op == 'DECLARED' and len(fields) == 2:
name = fields[1]
if name not in DEFAULT: return 'ERR unknown'
return 'OK declared %s %s' % (name, 'true' if name in self.values else 'false')
return 'ERR syntax'
def build_cases():
lines = [
'GET rate', 'SET rate 24', 'RESET rate', 'MISSING', 'COUNT', 'LIST',
'DESCRIBE rate', 'VALIDATE rate 30.000000', 'DECLARE rate', 'GET rate',
'DECLARE rate', 'GET unknown', 'DECLARE unknown', 'SET mode manual',
'BOOT', 'DEFAULTS', 'GET rate', 'GET mode', 'SET mode manual', 'GET mode', 'CHANGES',
'SET rate 42.125', 'GET rate', 'COMPARE rate 42.125000', 'LIST',
'PATCH retries=8,enabled=false,mode=safe,rate=240', 'LIST',
'PATCH rate=1,mode=manual,retries=9', 'LIST',
'PATCH mode=safe,mode=manual', 'GET mode', 'CAS mode manual safe', 'GET mode', 'CAS rate 42 30', 'RESTORE', 'CHANGES',
'REMOVE rate', 'GET rate', 'MISSING', 'DECLARE rate', 'GET rate',
'CLEAR', 'COUNT', 'MISSING', 'DECLARE_MANY rate,retries', 'COUNT', 'DECLARE_MANY enabled,mode', 'BOOT', 'BOOT',
'SET rate 1', 'SET rate 240', 'SET rate 1.000001', 'SET rate 1.0000001',
'SET rate 3e1', 'SET rate +30.000', 'SET rate 0', 'SET rate 241',
'SET retries 0', 'SET retries 8', 'SET retries 9', 'SET retries -1',
'SET enabled false', 'SET enabled TRUE', 'SET mode safe', 'SET mode other',
'GET mode', 'COMPARE mode safe', 'VALIDATE rate 2.500000',
'VALIDATE rate .5', 'VALIDATE retries +0007',
'PATCH rate=22,rate=23', 'GET rate', 'PATCH a=1', 'PATCH rate=',
'PATCH rate=1,', 'PATCH rate=1,=2', 'PATCH rate=1,mode=bad', 'LIST',
'BOOT extra', 'GET', 'SET rate', 'GET\trate', ' LIST ',
'BOOt', 'PATCH ' + ','.join('rate=30' for _ in range(9)),
'SET rate ' + '0' * 3000 + '30',
'GET rate', 'X' * 4097, 'COUNT',
]
rng = random.Random(0xD3C1A9)
rate_tokens = ('1', '30.1', '30.000001', '2e2', '240', '240.000001', '0.999999', '1e-5', '3e1', '4.20')
retry_tokens = ('0', '3', '8', '9', '-1', '+2', '0007')
bool_tokens = ('true', 'false', 'TRUE', '1')
mode_tokens = ('auto', 'manual', 'safe', 'invalid')
for index in range(85):
name = rng.choice(ORDER)
token = rng.choice({'rate': rate_tokens, 'retries': retry_tokens,
'enabled': bool_tokens, 'mode': mode_tokens}[name])
lines.append('SET %s %s' % (name, token))
lines.append(rng.choice(('GET ' + name, 'LIST', 'CHANGES', 'COMPARE %s %s' % (name, token))))
if index % 5 == 0: lines.extend(('CAS %s %s %s' % (name, token, token), 'GET ' + name))
if index % 7 == 0:
lines.extend(('PATCH rate=15.25,mode=manual,enabled=false', 'LIST', 'BOOT'))
if index % 19 == 0:
lines.extend(('REMOVE ' + name, 'GET ' + name, 'DECLARE ' + name))
model = Oracle()
observations = [model.process(line) for line in lines]
return ('\n'.join(lines) + '\n').encode('ascii'), [line.encode('ascii') for line in observations if line is not None], len(lines)
def read_candidate(path):
descriptor = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
try:
if not stat.S_ISREG(os.fstat(descriptor).st_mode): raise ValueError('candidate not regular')
data = os.read(descriptor, 1024 * 1024 + 1)
if len(data) > 1024 * 1024: raise ValueError('candidate file too large')
return data
finally:
os.close(descriptor)
def summarize(phases, facts, scratch, failures, case_count):
columns = ['phase', 'wrapper_rc', 'wire_len', 'wire_sha256', 'wire_error', 'nonce', 'uid', 'gid', 'groups',
'supervisor_pid', 'supervisor_start', 'leader_pid', 'leader_start', 'argv', 'cwd', 'deadline', 'tracked', 'leader_rc', 'rc',
'timeout', 'elapsed', 'input_len', 'input_sha256', 'stdout_len', 'stdout_sha256',
'stderr_len', 'stderr_sha256', 'leader_reaped', 'descendants_absent', 'pg_absent', 'pg_members', 'exceptions']
rows = []
for phase in ('compiler', 'candidate', 'cleanup', 'absence'):
fact = facts.get(phase, {})
item = phases.get(phase, {}) or {}
merged = dict(item, **fact)
rows.append([merged.get(column) for column in columns])
return {'v': 1, 'columns': columns, 'rows': rows,
'scratch': scratch, 'cases': case_count, 'failures': failures}
def main():
candidate = Path(sys.argv[1])
program_input, expected_lines, case_count = build_cases()
expected_output = b'\n'.join(expected_lines) + b'\n'
isolated = os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534'
identity = (65534, 65534, []) if isolated else (os.getuid(), os.getgid(), os.getgroups())
scratch = None
phases, facts, failures = {}, {}, []
prepared = False
try:
scratch = Path(tempfile.mkdtemp(prefix='config-declared-'))
work = scratch / 'work'
work.mkdir(mode=0o777)
work.chmod(0o777)
for name in FILES:
data = read_candidate(candidate / name)
(work / name).write_bytes(data)
prepared = True
sources = [str(work / name) for name in FILES if name.endswith('.cpp')]
binary = str(work / 'paramctl')
build_argv = ['g++', '-std=c++17', '-O2', '-Wall', '-Wextra', '-Wpedantic',
*sources, '-o', binary]
build, fact = run_stage('compiler', build_argv, str(work), b'', COMPILER_DEADLINE, identity)
phases['compiler'], facts['compiler'] = build, fact
if build is None: failures.append('compiler_wire')
elif build['timeout']: failures.append('compiler_timeout')
elif build['rc'] != 0: failures.append('compiler_rc_%d' % build['rc'])
else:
candidate_result, fact = run_stage('candidate', [binary], str(work),
program_input, CANDIDATE_DEADLINE, identity)
phases['candidate'], facts['candidate'] = candidate_result, fact
if candidate_result is None: failures.append('candidate_wire')
elif candidate_result['timeout']: failures.append('candidate_timeout')
elif candidate_result['rc'] != 0: failures.append('candidate_rc_%d' % candidate_result['rc'])
else:
observed = candidate_result['stdout_raw']
if observed != expected_output:
actual_lines = observed.split(b'\n')
wanted_lines = expected_output.split(b'\n')
first = next((index for index, (a, b) in enumerate(zip(actual_lines, wanted_lines)) if a != b),
min(len(actual_lines), len(wanted_lines)))
failures.append('behavior_at_%d' % first)
print('OBS first=%d actual=%s expected=%s' %
(first, repr(actual_lines[first:first + 1])[:100],
repr(wanted_lines[first:first + 1])[:100]), file=sys.stderr)
except BaseException as exc:
failures.append('preparation_or_execution_' + type(exc).__name__)
finally:
if scratch is not None:
try:
cleanup, fact = run_stage('cleanup', [sys.executable, '-I', '-c', CLEAN_SCRIPT, str(scratch)],
'/tmp', b'', CLEANUP_DEADLINE, identity)
phases['cleanup'], facts['cleanup'] = cleanup, fact
if cleanup is None or cleanup['timeout'] or cleanup['rc'] != 0 or cleanup['stdout_raw'] != b'removed\n':
failures.append('cleanup_failed')
except BaseException as exc:
failures.append('cleanup_exception_' + type(exc).__name__)
try:
absence, fact = run_stage('absence', [sys.executable, '-I', '-c', ABSENCE_SCRIPT, str(scratch)],
'/tmp', b'', ABSENCE_DEADLINE, identity)
phases['absence'], facts['absence'] = absence, fact
if absence is None or absence['timeout'] or absence['rc'] != 0 or absence['stdout_raw'] != b'absent\n':
failures.append('absence_failed')
except BaseException as exc:
failures.append('absence_exception_' + type(exc).__name__)
else:
failures.append('no_scratch')
evidence = summarize(phases, facts, str(scratch) if scratch else None, failures, case_count)
encoded = json.dumps(evidence, separators=(',', ':'), ensure_ascii=True)
print('EVIDENCE ' + encoded, file=sys.stderr)
if failures:
print('FAIL ' + ','.join(failures)[:250])
return 1
if not prepared or not all(phases.get(name) is not None for name in ('compiler', 'candidate', 'cleanup', 'absence')):
print('FAIL incomplete')
return 1
print('PASS')
return 0
if __name__ == '__main__':
raise SystemExit(main())