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>
584 lines
28 KiB
Python
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())
|