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>
874 lines
37 KiB
Python
874 lines
37 KiB
Python
import base64
|
|
import hashlib
|
|
import json
|
|
import math
|
|
import os
|
|
from pathlib import Path
|
|
import random
|
|
import re
|
|
import secrets
|
|
import shutil
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import zlib
|
|
|
|
|
|
CANDIDATES = ["include/request.hpp", "src/request.cpp", "src/text.cpp",
|
|
"src/format.cpp", "src/console.cpp"]
|
|
HARNESS = '#include "request.hpp"\n\n#include <cerrno>\n#include <cstdint>\n#include <iostream>\n#include <sstream>\n#include <string>\n#include <vector>\n\nnamespace {\n\nstruct Event {\n char kind;\n std::int64_t first;\n std::int64_t second;\n};\n\nclass ScriptedPort final : public remaining::WaitPort {\npublic:\n void push(Event event) { events_.push_back(event); }\n\n int wait(const remaining::Time &requested, remaining::Time &left, int &error) override\n {\n Event event{\'F\', EAGAIN, 0};\n if (cursor_ < events_.size()) {\n event = events_[cursor_++];\n }\n int result = -1;\n if (event.kind == \'S\') {\n result = 0;\n error = 0;\n } else if (event.kind == \'I\') {\n error = EINTR;\n left = remaining::to_time(static_cast<std::uint64_t>(event.first));\n } else if (event.kind == \'X\') {\n error = EINTR;\n left = {event.first, event.second};\n } else {\n error = static_cast<int>(event.first);\n left = {-7, -7};\n }\n std::cout << "W " << requested.sec << \' \' << requested.nsec << \' \'\n << result << \' \' << error << \'\\n\';\n return result;\n }\n\nprivate:\n std::vector<Event> events_;\n std::size_t cursor_ = 0;\n};\n\nbool event_line(const std::string &line, Event &event)\n{\n std::istringstream input(line);\n std::string prefix;\n std::string extra;\n if (!(input >> prefix) || prefix != "E" || !(input >> event.kind)) return false;\n if (event.kind == \'S\') return !(input >> extra);\n if (event.kind == \'I\' || event.kind == \'F\') {\n return bool(input >> event.first) && !(input >> extra);\n }\n if (event.kind == \'X\') {\n return bool(input >> event.first >> event.second) && !(input >> extra);\n }\n return false;\n}\n\n} // namespace\n\nint main()\n{\n ScriptedPort port;\n remaining::Manager manager(port);\n remaining::Console console(manager);\n std::string line;\n while (std::getline(std::cin, line)) {\n if (line.size() >= 2 && line[0] == \'E\' && line[1] == \' \') {\n Event event{};\n if (!event_line(line, event)) return 2;\n port.push(event);\n continue;\n }\n std::string output;\n if (!console.execute(line, output)) return 2;\n if (!output.empty()) std::cout << "O " << output << \'\\n\';\n }\n return std::cin.bad() ? 2 : 0;\n}\n'
|
|
IMAGE_DEADLINE = 12.0
|
|
CASE_DEADLINE = 3.0
|
|
STAGE_GRACE = 3.0
|
|
ISOLATED = os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534'
|
|
EXPECTED_UID = 65534 if ISOLATED else os.getuid()
|
|
EXPECTED_GID = 65534 if ISOLATED else os.getgid()
|
|
EXPECTED_GROUPS = [] if ISOLATED else os.getgroups()
|
|
STAGE_RECORDS = []
|
|
|
|
SUPERVISOR = r'''
|
|
import base64, ctypes, hashlib, json, os, selectors, signal, subprocess, sys, time
|
|
|
|
def exact_stat(pid):
|
|
try:
|
|
raw = open('/proc/%d/stat' % pid, 'rb').read()
|
|
except (FileNotFoundError, ProcessLookupError):
|
|
return None
|
|
fields = raw[raw.rfind(b')') + 2:].split()
|
|
return (fields[0].decode('ascii'), int(fields[1]), int(fields[2]),
|
|
int(fields[3]), int(fields[19]))
|
|
|
|
def scan(problems):
|
|
table = {}
|
|
for name in os.listdir('/proc'):
|
|
if not name.isdecimal():
|
|
continue
|
|
pid = int(name)
|
|
try:
|
|
record = exact_stat(pid)
|
|
except Exception as error:
|
|
entry = 'scan:%d:%s' % (pid, type(error).__name__)
|
|
if entry not in problems:
|
|
problems.append(entry)
|
|
continue
|
|
if record is not None:
|
|
table[pid] = record
|
|
return table
|
|
|
|
def live(record):
|
|
return record is not None and record[0] not in ('Z', 'X')
|
|
|
|
def descendants(table, self_pid, known):
|
|
roots = {self_pid}
|
|
for pid, token in known.items():
|
|
record = table.get(pid)
|
|
if live(record) and record[4] == token:
|
|
roots.add(pid)
|
|
found = {}
|
|
changed = True
|
|
while changed:
|
|
changed = False
|
|
for pid, record in table.items():
|
|
if pid == self_pid or not live(record) or pid in found:
|
|
continue
|
|
if record[1] in roots:
|
|
found[pid] = record[4]
|
|
roots.add(pid)
|
|
changed = True
|
|
return found
|
|
|
|
def signal_owned(found, problems):
|
|
for pid, start in found.items():
|
|
try:
|
|
fresh = exact_stat(pid)
|
|
if not live(fresh) or fresh[4] != start:
|
|
continue
|
|
os.kill(pid, signal.SIGKILL)
|
|
except (FileNotFoundError, ProcessLookupError):
|
|
continue
|
|
except Exception as error:
|
|
problems.append('signal:%d:%s' % (pid, type(error).__name__))
|
|
|
|
def main():
|
|
request_bytes = sys.stdin.buffer.read()
|
|
plan = json.loads(request_bytes)
|
|
deadline = float(plan['deadline'])
|
|
started = time.monotonic()
|
|
self_pid = os.getpid()
|
|
self_record = exact_stat(self_pid)
|
|
problems = []
|
|
reaped = []
|
|
known = {}
|
|
output = {1: bytearray(), 2: bytearray()}
|
|
leader = None
|
|
leader_start = None
|
|
leader_pgid = None
|
|
leader_rc = None
|
|
timed_out = False
|
|
try:
|
|
if ctypes.CDLL(None).prctl(36, 1, 0, 0, 0) != 0:
|
|
raise OSError('prctl subreaper failed')
|
|
input_data = base64.b64decode(plan['stdin_b64'], validate=True)
|
|
leader = subprocess.Popen(plan['argv'], cwd=plan['cwd'],
|
|
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE, start_new_session=True)
|
|
leader_record = exact_stat(leader.pid)
|
|
if leader_record is None:
|
|
raise RuntimeError('leader disappeared before start identity capture')
|
|
leader_start = leader_record[4]
|
|
leader_pgid = leader_record[2]
|
|
known[leader.pid] = leader_start
|
|
watch = selectors.DefaultSelector()
|
|
for number, stream in ((1, leader.stdout), (2, leader.stderr)):
|
|
os.set_blocking(stream.fileno(), False)
|
|
watch.register(stream, selectors.EVENT_READ, number)
|
|
os.set_blocking(leader.stdin.fileno(), False)
|
|
if input_data:
|
|
watch.register(leader.stdin, selectors.EVENT_WRITE, 0)
|
|
else:
|
|
leader.stdin.close()
|
|
offset = 0
|
|
while True:
|
|
own = leader.poll()
|
|
if own is not None:
|
|
leader_rc = own
|
|
table = scan(problems)
|
|
current = descendants(table, self_pid, known)
|
|
known.update(current)
|
|
if time.monotonic() - started >= deadline:
|
|
timed_out = True
|
|
break
|
|
if leader_rc is not None and not current and not watch.get_map():
|
|
break
|
|
if leader_rc is not None and current:
|
|
signal_owned(current, problems)
|
|
for key, mask in watch.select(0.025):
|
|
stream = key.fileobj
|
|
if key.data == 0:
|
|
try:
|
|
count = os.write(stream.fileno(), input_data[offset:offset + 65536])
|
|
except BrokenPipeError:
|
|
count = 0
|
|
offset = len(input_data)
|
|
except BlockingIOError:
|
|
continue
|
|
offset += count
|
|
if offset >= len(input_data):
|
|
watch.unregister(stream)
|
|
stream.close()
|
|
else:
|
|
try:
|
|
data = os.read(stream.fileno(), 65536)
|
|
except BlockingIOError:
|
|
continue
|
|
if data:
|
|
output[key.data].extend(data)
|
|
else:
|
|
watch.unregister(stream)
|
|
stream.close()
|
|
if leader_rc is not None:
|
|
for pid in list(known):
|
|
if pid == leader.pid:
|
|
continue
|
|
try:
|
|
result, status = os.waitpid(pid, os.WNOHANG)
|
|
if result:
|
|
reaped.append([pid, status])
|
|
except (ChildProcessError, ProcessLookupError):
|
|
pass
|
|
watch.close()
|
|
except Exception as error:
|
|
problems.append('supervisor:%s:%s' % (type(error).__name__, str(error)[:120]))
|
|
finally:
|
|
if leader is not None:
|
|
until = time.monotonic() + 2.0
|
|
while time.monotonic() < until:
|
|
leader_rc = leader.poll() if leader_rc is None else leader_rc
|
|
try:
|
|
table = scan(problems)
|
|
current = descendants(table, self_pid, known)
|
|
known.update(current)
|
|
signal_owned(current, problems)
|
|
if leader_rc is not None and not current:
|
|
break
|
|
for pid in list(known):
|
|
if pid == leader.pid:
|
|
continue
|
|
try:
|
|
result, status = os.waitpid(pid, os.WNOHANG)
|
|
if result:
|
|
reaped.append([pid, status])
|
|
except (ChildProcessError, ProcessLookupError):
|
|
pass
|
|
except Exception as error:
|
|
problems.append('recovery:%s' % type(error).__name__)
|
|
time.sleep(0.02)
|
|
leader_rc = leader.poll() if leader_rc is None else leader_rc
|
|
if leader_rc is None:
|
|
problems.append('leader-not-reaped')
|
|
try:
|
|
table = scan(problems)
|
|
current = descendants(table, self_pid, known)
|
|
absence = not current
|
|
try:
|
|
os.killpg(leader_pgid, 0)
|
|
pg_absence = False
|
|
except ProcessLookupError:
|
|
pg_absence = True
|
|
except Exception as error:
|
|
problems.append('pg-absence:%s' % type(error).__name__)
|
|
pg_absence = False
|
|
except Exception as error:
|
|
problems.append('absence:%s' % type(error).__name__)
|
|
absence = False
|
|
pg_absence = False
|
|
else:
|
|
absence = False
|
|
pg_absence = False
|
|
for number, stream in ((1, leader.stdout if leader else None),
|
|
(2, leader.stderr if leader else None)):
|
|
if stream is None:
|
|
continue
|
|
try:
|
|
while True:
|
|
data = os.read(stream.fileno(), 65536)
|
|
if not data:
|
|
break
|
|
output[number].extend(data)
|
|
except (OSError, ValueError):
|
|
pass
|
|
try:
|
|
stream.close()
|
|
except Exception:
|
|
pass
|
|
stdout = bytes(output[1]); stderr = bytes(output[2])
|
|
wire = dict(version=1, nonce=plan['nonce'], cwd=plan['cwd'],
|
|
request_len=len(request_bytes),
|
|
request_sha256=hashlib.sha256(request_bytes).hexdigest(),
|
|
input_len=len(input_data) if 'input_data' in locals() else None,
|
|
input_sha256=hashlib.sha256(input_data).hexdigest() if 'input_data' in locals() else None,
|
|
supervisor_pid=self_pid, supervisor_start=self_record[4],
|
|
leader_pid=leader.pid if leader else None, leader_start=leader_start,
|
|
leader_pgid=leader_pgid,
|
|
uid=os.getuid(), gid=os.getgid(), groups=os.getgroups(),
|
|
argv=plan['argv'], deadline=deadline,
|
|
elapsed=time.monotonic() - started, leader_rc=leader_rc,
|
|
returncode=leader_rc, leader_reaped=leader_rc is not None,
|
|
timed_out=timed_out, descendants_absent=absence, pg_absent=pg_absence,
|
|
exceptions=problems, reaped=reaped,
|
|
stdout_b64=base64.b64encode(stdout).decode('ascii'),
|
|
stderr_b64=base64.b64encode(stderr).decode('ascii'),
|
|
stdout_len=len(stdout), stderr_len=len(stderr),
|
|
stdout_sha256=hashlib.sha256(stdout).hexdigest(),
|
|
stderr_sha256=hashlib.sha256(stderr).hexdigest())
|
|
sys.stdout.write(json.dumps(wire, separators=(',', ':')))
|
|
|
|
main()
|
|
'''
|
|
|
|
ABSENCE = r'''import os,sys
|
|
try:
|
|
os.lstat(sys.argv[1])
|
|
except FileNotFoundError:
|
|
raise SystemExit(0)
|
|
raise SystemExit(1)
|
|
'''
|
|
|
|
|
|
def sha(data):
|
|
return hashlib.sha256(data).hexdigest()
|
|
|
|
|
|
def prepare(candidate, scratch):
|
|
for name in CANDIDATES:
|
|
root_fd = os.open(candidate, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
|
|
folder_fd = os.dup(root_fd)
|
|
try:
|
|
for part in Path(name).parts[:-1]:
|
|
next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW,
|
|
dir_fd=folder_fd)
|
|
os.close(folder_fd)
|
|
folder_fd = next_fd
|
|
file_fd = os.open(Path(name).name, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK,
|
|
dir_fd=folder_fd)
|
|
try:
|
|
info = os.fstat(file_fd)
|
|
if not stat.S_ISREG(info.st_mode) or info.st_size > 1024 * 1024:
|
|
raise ValueError('candidate is not a regular bounded file')
|
|
with os.fdopen(file_fd, 'rb', closefd=False) as stream:
|
|
data = stream.read(1024 * 1024 + 1)
|
|
if len(data) != info.st_size:
|
|
raise ValueError('candidate changed during copy')
|
|
finally:
|
|
os.close(file_fd)
|
|
target = scratch / name
|
|
target.parent.mkdir(parents=True, exist_ok=True)
|
|
target.write_bytes(data)
|
|
if ISOLATED:
|
|
os.chown(target, 65534, 65534)
|
|
finally:
|
|
os.close(folder_fd)
|
|
os.close(root_fd)
|
|
driver = scratch / 'driver.cpp'
|
|
driver.write_text(HARNESS)
|
|
if ISOLATED:
|
|
os.chown(driver, 65534, 65534)
|
|
for folder in (scratch / 'src', scratch / 'include'):
|
|
os.chown(folder, 65534, 65534)
|
|
|
|
|
|
def valid_wire(meta, argv, deadline, nonce, cwd, input_data, request_bytes):
|
|
def integer(value, positive=False):
|
|
return type(value) is int and (not positive or value > 0)
|
|
if type(meta) is not dict or type(meta.get('version')) is not int or meta['version'] != 1:
|
|
return False, 'wire-version'
|
|
if type(meta.get('nonce')) is not str or meta['nonce'] != nonce:
|
|
return False, 'nonce'
|
|
if type(meta.get('cwd')) is not str or meta['cwd'] != cwd:
|
|
return False, 'cwd'
|
|
if type(meta.get('request_len')) is not int or meta['request_len'] != len(request_bytes):
|
|
return False, 'request-len'
|
|
if type(meta.get('request_sha256')) is not str or meta['request_sha256'] != sha(request_bytes):
|
|
return False, 'request-digest'
|
|
if type(meta.get('input_len')) is not int or meta['input_len'] != len(input_data):
|
|
return False, 'input-len'
|
|
if type(meta.get('input_sha256')) is not str or meta['input_sha256'] != sha(input_data):
|
|
return False, 'input-digest'
|
|
for field in ('supervisor_pid', 'supervisor_start', 'leader_pid', 'leader_start', 'leader_pgid'):
|
|
if not integer(meta.get(field), True):
|
|
return False, field
|
|
if meta['supervisor_pid'] == meta['leader_pid']:
|
|
return False, 'pid-alias'
|
|
if meta['leader_pgid'] != meta['leader_pid']:
|
|
return False, 'leader-pgid'
|
|
for field in ('uid', 'gid'):
|
|
expected = EXPECTED_UID if field == 'uid' else EXPECTED_GID
|
|
if not integer(meta.get(field)) or meta[field] != expected:
|
|
return False, field
|
|
if (type(meta.get('groups')) is not list or
|
|
any(type(x) is not int for x in meta['groups']) or meta['groups'] != EXPECTED_GROUPS):
|
|
return False, 'groups'
|
|
if meta.get('argv') != argv or type(meta.get('argv')) is not list:
|
|
return False, 'argv'
|
|
elapsed = meta.get('elapsed')
|
|
if type(elapsed) not in (int, float) or not math.isfinite(elapsed) or not 0 <= elapsed <= deadline + STAGE_GRACE:
|
|
return False, 'elapsed'
|
|
if type(meta.get('deadline')) not in (int, float) or meta['deadline'] != deadline:
|
|
return False, 'deadline'
|
|
if type(meta.get('timed_out')) is not bool or type(meta.get('leader_reaped')) is not bool:
|
|
return False, 'timeout-reap'
|
|
if type(meta.get('descendants_absent')) is not bool or type(meta.get('pg_absent')) is not bool:
|
|
return False, 'absence-types'
|
|
if type(meta.get('exceptions')) is not list or any(type(x) is not str for x in meta['exceptions']):
|
|
return False, 'exceptions'
|
|
if type(meta.get('reaped')) is not list:
|
|
return False, 'reaped'
|
|
if any(type(item) is not list or len(item) != 2 or
|
|
not integer(item[0], True) or not integer(item[1])
|
|
for item in meta['reaped']):
|
|
return False, 'reaped-items'
|
|
for field in ('leader_rc', 'returncode'):
|
|
if not integer(meta.get(field)):
|
|
return False, field
|
|
if meta['returncode'] != meta['leader_rc'] or not meta['leader_reaped']:
|
|
return False, 'leader-consistency'
|
|
for stream in ('stdout', 'stderr'):
|
|
size = meta.get(stream + '_len')
|
|
if not integer(size) or size < 0:
|
|
return False, stream + '-len'
|
|
try:
|
|
data = base64.b64decode(meta[stream + '_b64'], validate=True)
|
|
except Exception:
|
|
return False, stream + '-bytes'
|
|
if len(data) != size or sha(data) != meta.get(stream + '_sha256'):
|
|
return False, stream + '-digest'
|
|
if (meta['timed_out'] or not meta['descendants_absent'] or
|
|
not meta['pg_absent'] or meta['exceptions']):
|
|
return False, 'stage-presence-timeout-exception'
|
|
return True, ''
|
|
|
|
|
|
def stage(argv, cwd, data, deadline):
|
|
nonce = secrets.token_hex(16)
|
|
plan = dict(argv=argv, cwd=str(cwd), stdin_b64=base64.b64encode(data).decode('ascii'),
|
|
deadline=deadline, nonce=nonce)
|
|
request_bytes = json.dumps(plan, sort_keys=True, separators=(',', ':')).encode()
|
|
wrapper = subprocess.run([sys.executable, '-I', '-c', SUPERVISOR],
|
|
input=request_bytes, capture_output=True,
|
|
timeout=deadline + STAGE_GRACE + 3)
|
|
raw = wrapper.stdout
|
|
evidence = dict(wrapper_rc=wrapper.returncode, wire_len=len(raw), wire_sha256=sha(raw),
|
|
wrapper_stderr_len=len(wrapper.stderr), wrapper_stderr_sha256=sha(wrapper.stderr),
|
|
argv=argv, deadline=deadline,
|
|
request_len=len(request_bytes), request_sha256=sha(request_bytes))
|
|
def note(reason, meta=None):
|
|
entry = dict(argv=argv, role=argv[0], reason=reason or 'ok', wrapper_rc=evidence['wrapper_rc'],
|
|
wire_len=evidence['wire_len'], wire_sha256=evidence['wire_sha256'],
|
|
request_len=evidence['request_len'],
|
|
request_sha256=evidence['request_sha256'],
|
|
wrapper_stderr_len=evidence['wrapper_stderr_len'],
|
|
nonce=nonce, cwd=str(cwd), input_len=len(data), input_sha256=sha(data),
|
|
deadline=deadline)
|
|
if evidence['wrapper_stderr_len']:
|
|
entry['wrapper_stderr_sha256'] = evidence['wrapper_stderr_sha256']
|
|
if meta is not None:
|
|
entry['meta'] = {key: meta.get(key) for key in
|
|
('nonce', 'cwd', 'request_len', 'request_sha256',
|
|
'input_len', 'input_sha256',
|
|
'supervisor_pid', 'supervisor_start', 'leader_pid',
|
|
'leader_start', 'leader_pgid', 'uid', 'gid', 'groups',
|
|
'elapsed', 'leader_rc', 'returncode', 'leader_reaped',
|
|
'timed_out', 'descendants_absent', 'pg_absent',
|
|
'exceptions', 'reaped', 'stdout_len', 'stderr_len',
|
|
'stdout_sha256', 'stderr_sha256')}
|
|
STAGE_RECORDS.append(entry)
|
|
if wrapper.returncode != 0:
|
|
note('wrapper-exit')
|
|
return None, evidence, 'wrapper-exit'
|
|
try:
|
|
meta = json.loads(raw)
|
|
except (UnicodeError, json.JSONDecodeError):
|
|
note('wire-json')
|
|
return None, evidence, 'wire-json'
|
|
okay, reason = valid_wire(meta, argv, deadline, nonce, str(cwd), data, request_bytes)
|
|
note(reason, meta if type(meta) is dict else None)
|
|
selected = meta if type(meta) is dict else {}
|
|
evidence['meta'] = {key: selected.get(key) for key in
|
|
('nonce', 'cwd', 'request_len', 'request_sha256',
|
|
'input_len', 'input_sha256',
|
|
'supervisor_pid', 'supervisor_start', 'leader_pid', 'leader_start',
|
|
'leader_pgid', 'pg_absent',
|
|
'uid', 'gid', 'groups', 'elapsed', 'leader_rc', 'returncode',
|
|
'leader_reaped', 'timed_out', 'descendants_absent', 'exceptions',
|
|
'stdout_len', 'stderr_len', 'stdout_sha256', 'stderr_sha256')}
|
|
if not okay:
|
|
return None, evidence, reason
|
|
meta['stdout'] = base64.b64decode(meta['stdout_b64'], validate=True)
|
|
meta['stderr'] = base64.b64decode(meta['stderr_b64'], validate=True)
|
|
return meta, evidence, ''
|
|
|
|
|
|
def integer_token(raw):
|
|
if not re.fullmatch(r'[+-]?[0-9]+', raw, re.ASCII):
|
|
raise ValueError('non-decimal token')
|
|
sign = -1 if raw.startswith('-') else 1
|
|
digits = raw.lstrip('+-').lstrip('0') or '0'
|
|
if len(digits) > 20:
|
|
raise ValueError('number exceeds observable range')
|
|
return sign * int(digits)
|
|
|
|
|
|
def normalize(stdout):
|
|
if not stdout.endswith(b'\n'):
|
|
raise ValueError('missing final newline')
|
|
lines = stdout.decode('ascii').split('\n')[:-1]
|
|
result = []
|
|
for line in lines:
|
|
words = re.split(r'[ \t\r]+', line.strip(' \t\r'))
|
|
if not words or words[0] not in ('W', 'O'):
|
|
raise ValueError('raw line prefix')
|
|
result.append([integer_token(word) if re.fullmatch(r'[+-]?[0-9]+', word, re.ASCII)
|
|
else word for word in words])
|
|
return result
|
|
|
|
|
|
def render_expected(lines):
|
|
return normalize(('\n'.join(lines) + '\n').encode())
|
|
|
|
|
|
class Model:
|
|
def __init__(self):
|
|
self.rows = []
|
|
self.serial = 0
|
|
self.consumed = 0
|
|
self.calls = 0
|
|
self.events = []
|
|
self.output = []
|
|
self.input = []
|
|
|
|
def row(self, ident):
|
|
return next((item for item in self.rows if item['id'] == ident), None)
|
|
|
|
def emit(self, value):
|
|
self.output.append('O ' + value)
|
|
|
|
def event(self, kind, first=0, second=0):
|
|
if kind == 'S':
|
|
self.input.append('E S')
|
|
elif kind in ('I', 'F'):
|
|
self.input.append(f'E {kind} {first}')
|
|
else:
|
|
self.input.append(f'E X {first} {second}')
|
|
self.events.append((kind, first, second))
|
|
|
|
def add(self, ident, duration, priority, display=None):
|
|
self.input.append(f'A {ident} {display or duration} {priority}')
|
|
if not 1 <= ident <= 9999 or not 1 <= duration <= 10**12 or not 0 <= priority <= 3:
|
|
rc = -22
|
|
elif self.row(ident):
|
|
rc = -17
|
|
elif len(self.rows) == 16:
|
|
rc = -28
|
|
else:
|
|
rc = 0
|
|
self.rows.append(dict(id=ident, state=0, priority=priority, original=duration,
|
|
remaining=duration, consumed=0, attempts=0, interrupts=0,
|
|
error=0, serial=self.serial))
|
|
self.serial += 1
|
|
self.emit(f'A {rc}')
|
|
return rc
|
|
|
|
def amend(self, ident, duration, priority, display=None):
|
|
self.input.append(f'M {ident} {display or duration} {priority}')
|
|
row = self.row(ident)
|
|
if row is None:
|
|
rc = -2
|
|
elif row['state'] != 0:
|
|
rc = -114
|
|
elif not 1 <= duration <= 10**12 or not 0 <= priority <= 3:
|
|
rc = -22
|
|
else:
|
|
rc = 0
|
|
row.update(original=duration, remaining=duration, priority=priority)
|
|
self.emit(f'M {rc}')
|
|
|
|
def duplicate(self, ident, new_id):
|
|
self.input.append(f'D {ident} {new_id}')
|
|
row = self.row(ident)
|
|
if row is None:
|
|
rc = -2
|
|
elif row['state'] != 0:
|
|
rc = -114
|
|
elif not 1 <= new_id <= 9999:
|
|
rc = -22
|
|
elif self.row(new_id):
|
|
rc = -17
|
|
elif len(self.rows) == 16:
|
|
rc = -28
|
|
else:
|
|
rc = 0
|
|
self.rows.append(dict(id=new_id, state=0, priority=row['priority'],
|
|
original=row['remaining'], remaining=row['remaining'],
|
|
consumed=0, attempts=0, interrupts=0, error=0,
|
|
serial=self.serial))
|
|
self.serial += 1
|
|
self.emit(f'D {rc}')
|
|
|
|
def priority(self, ident, priority):
|
|
self.input.append(f'T {ident} {priority}')
|
|
row = self.row(ident)
|
|
rc = -2 if row is None else -114 if row['state'] != 0 else -22 if not 0 <= priority <= 3 else 0
|
|
if rc == 0:
|
|
row['priority'] = priority
|
|
self.emit(f'T {rc}')
|
|
|
|
def cancel(self, ident):
|
|
self.input.append(f'C {ident}')
|
|
row = self.row(ident)
|
|
rc = -2 if row is None else -114 if row['state'] != 0 else 0
|
|
if rc == 0:
|
|
row['state'] = 3
|
|
self.emit(f'C {rc}')
|
|
|
|
def wait(self, row):
|
|
while row['remaining']:
|
|
asked = row['remaining']
|
|
event = self.events.pop(0) if self.events else ('F', 11, 0)
|
|
kind, first, second = event
|
|
sec, nsec = divmod(asked, 10**9)
|
|
rc = 0 if kind == 'S' else -1
|
|
error = 0 if kind == 'S' else 4 if kind in ('I', 'X') else first
|
|
self.output.append(f'W {sec} {nsec} {rc} {error}')
|
|
self.calls += 1
|
|
row['attempts'] += 1
|
|
if kind == 'S':
|
|
row['consumed'] += asked
|
|
self.consumed += asked
|
|
row.update(state=1, remaining=0, error=0)
|
|
return 0
|
|
if kind == 'F':
|
|
row.update(state=2, error=error)
|
|
return -error
|
|
if kind == 'I':
|
|
left = first
|
|
valid = 0 <= left <= asked
|
|
else:
|
|
valid = first >= 0 and 0 <= second < 10**9
|
|
left = first * 10**9 + second if valid else -1
|
|
valid = valid and left <= asked
|
|
if not valid:
|
|
row.update(state=2, error=71)
|
|
return -71
|
|
delta = asked - left
|
|
row['consumed'] += delta
|
|
self.consumed += delta
|
|
row['remaining'] = left
|
|
row['interrupts'] += 1
|
|
if left == 0:
|
|
row.update(state=1, error=0)
|
|
return 0
|
|
if row['interrupts'] >= 32:
|
|
row.update(state=2, error=40)
|
|
return -40
|
|
row.update(state=1, error=0)
|
|
return 0
|
|
|
|
def run(self, ident):
|
|
self.input.append(f'R {ident}')
|
|
row = self.row(ident)
|
|
rc = -2 if row is None else -114 if row['state'] != 0 else self.wait(row)
|
|
self.emit(f'R {rc}')
|
|
|
|
def order(self):
|
|
return sorted((row for row in self.rows if row['state'] == 0),
|
|
key=lambda row: (-row['priority'], row['serial']))
|
|
|
|
def next(self):
|
|
self.input.append('N')
|
|
order = self.order()
|
|
if order:
|
|
ident = order[0]['id']
|
|
rc = self.wait(order[0])
|
|
else:
|
|
ident = -1
|
|
rc = -2
|
|
self.emit(f'N {ident} {rc}')
|
|
|
|
def batch(self):
|
|
self.input.append('B')
|
|
count = 0
|
|
rc = 0
|
|
while self.order():
|
|
rc = self.wait(self.order()[0])
|
|
count += 1
|
|
if rc:
|
|
break
|
|
self.emit(f'B {count} {rc}')
|
|
|
|
@staticmethod
|
|
def fields(row):
|
|
return ' '.join(str(row[key]) for key in
|
|
('id', 'state', 'priority', 'original', 'remaining', 'consumed',
|
|
'attempts', 'interrupts', 'error'))
|
|
|
|
def query(self, ident):
|
|
self.input.append(f'Q {ident}')
|
|
row = self.row(ident)
|
|
self.emit('Q -2' if row is None else 'Q 0 ' + self.fields(row))
|
|
|
|
def list(self):
|
|
self.input.append('L')
|
|
self.emit('L ' + str(len(self.rows)) + ''.join(' | ' + self.fields(row) for row in self.rows))
|
|
|
|
def ordered(self):
|
|
self.input.append('O')
|
|
rows = self.order()
|
|
self.emit('O ' + str(len(rows)) + ''.join(' ' + str(row['id']) for row in rows))
|
|
|
|
def totals(self):
|
|
self.input.append('S')
|
|
counts = [sum(row['state'] == state for row in self.rows) for state in range(4)]
|
|
self.emit('S ' + ' '.join(map(str, counts + [self.consumed, self.calls])))
|
|
|
|
def purge(self):
|
|
self.input.append('P')
|
|
count = sum(row['state'] != 0 for row in self.rows)
|
|
self.rows = [row for row in self.rows if row['state'] == 0]
|
|
self.emit(f'P {count}')
|
|
|
|
def reset(self):
|
|
self.input.append('Z')
|
|
self.rows = []
|
|
self.serial = 0
|
|
self.consumed = 0
|
|
self.calls = 0
|
|
self.emit('Z 0')
|
|
|
|
|
|
def scenarios():
|
|
cases = []
|
|
m = Model()
|
|
m.event('I', 4000000); m.event('S')
|
|
m.add(7, 10000000, 1, '10ms'); m.run(7); m.query(7); m.totals()
|
|
cases.append(('public-interrupt', m))
|
|
|
|
m = Model()
|
|
m.event('I', 1000000001); m.event('I', 250000001); m.event('S')
|
|
m.add(181, 2400000003, 2); m.run(181); m.query(181); m.totals()
|
|
cases.append(('multi-second-interrupt', m))
|
|
|
|
m = Model()
|
|
m.event('F', 5)
|
|
m.add(512, 9000000, 0, '9ms'); m.run(512); m.query(512); m.totals()
|
|
m.run(512); m.ordered()
|
|
cases.append(('hard-error', m))
|
|
|
|
m = Model()
|
|
m.event('I', 3); m.event('F', 11)
|
|
m.add(8, 9, 0); m.run(8); m.query(8); m.totals()
|
|
cases.append(('interrupted-then-error', m))
|
|
|
|
m = Model()
|
|
m.event('I', 0)
|
|
m.add(41, 1000000000, 3, '1s'); m.run(41); m.query(41)
|
|
m.event('X', -1, 1)
|
|
m.add(42, 7000, 1, '7us'); m.run(42); m.query(42)
|
|
m.totals()
|
|
cases.append(('zero-and-invalid-remain', m))
|
|
|
|
m = Model()
|
|
m.add(100, 1000, 1, '1us'); m.add(200, 2000000, 3, '2ms')
|
|
m.add(300, 400, 3); m.ordered(); m.priority(100, 3); m.ordered()
|
|
m.event('S'); m.event('F', 5)
|
|
m.batch(); m.query(100); m.ordered(); m.event('S'); m.next(); m.list(); m.totals()
|
|
cases.append(('queue-error-stop', m))
|
|
|
|
m = Model()
|
|
m.add(23, 17, 0); m.amend(23, 5000000, 3, '5ms'); m.duplicate(23, 24)
|
|
m.cancel(23); m.query(23); m.ordered(); m.event('S'); m.batch(); m.list()
|
|
m.purge(); m.add(23, 40, 2); m.event('S'); m.run(23); m.totals(); m.reset(); m.totals()
|
|
cases.append(('lifecycle', m))
|
|
|
|
m = Model()
|
|
for ident in range(1, 17):
|
|
m.add(ident, ident * 100, ident % 4)
|
|
m.add(17, 9, 0); m.add(1, 8, 0); m.ordered(); m.cancel(4)
|
|
m.amend(3, 0, 0); m.query(3); m.purge(); m.add(17, 9, 0)
|
|
m.totals(); m.list()
|
|
cases.append(('capacity-and-parse', m))
|
|
|
|
m = Model()
|
|
rng = random.Random(370137)
|
|
for index in range(10):
|
|
duration = rng.randint(1, 10**11)
|
|
ident = rng.randint(5000, 9000)
|
|
m.add(ident, duration, index % 4)
|
|
left = rng.randint(0, duration)
|
|
m.event('I', left)
|
|
if left:
|
|
m.event('S')
|
|
m.run(ident)
|
|
m.query(ident)
|
|
m.totals(); m.list()
|
|
cases.append(('seeded-variants', m))
|
|
|
|
m = Model()
|
|
m.add(777, 1, 2, '+' + '0' * 5000 + '1ns')
|
|
for unused in range(32):
|
|
m.event('I', 1)
|
|
m.run(777); m.query(777); m.totals()
|
|
m.event('X', 0, 5); m.event('S')
|
|
m.add(778, 5, 0); m.run(778); m.query(778)
|
|
m.event('S')
|
|
m.add(779, 99, 0); m.next(); m.query(779)
|
|
cases.append(('leading-zero-and-interrupt-bound', m))
|
|
|
|
return cases
|
|
|
|
|
|
def assess(candidate):
|
|
issues = []
|
|
rows = 0
|
|
scratch = Path(tempfile.mkdtemp(prefix='cc-rm-037-'))
|
|
try:
|
|
prepare(candidate, scratch)
|
|
argv = ['g++', '-std=c++17', '-O2', '-Wall', '-Wextra', '-Wpedantic',
|
|
'-Iinclude', 'driver.cpp', 'src/request.cpp', 'src/text.cpp',
|
|
'src/format.cpp', 'src/console.cpp', '-o', 'app']
|
|
compiled, evidence, reason = stage(argv, scratch, b'', IMAGE_DEADLINE)
|
|
if reason:
|
|
issues.append('compile-stage:' + reason)
|
|
elif compiled['returncode'] != 0:
|
|
issues.append('compile-rc:' + str(compiled['returncode']))
|
|
issues.append('compile-stderr:' + compiled['stderr'].decode('utf-8', 'replace')[-300:])
|
|
if not issues:
|
|
cases = scenarios()
|
|
for offset in range(0, len(cases), 2):
|
|
group = cases[offset:offset + 2]
|
|
label = '+'.join(item[0] for item in group)
|
|
commands = []
|
|
observations = []
|
|
for index, (_, model) in enumerate(group):
|
|
if index:
|
|
commands.append('Z')
|
|
observations.append('O Z 0')
|
|
commands.extend(model.input)
|
|
observations.extend(model.output)
|
|
data = ('\n'.join(commands) + '\n').encode('ascii')
|
|
expected = render_expected(observations)
|
|
rows += len(expected)
|
|
executed, evidence, reason = stage(['./app'], scratch, data, CASE_DEADLINE)
|
|
if reason:
|
|
issues.append(label + ':stage:' + reason)
|
|
continue
|
|
if executed['returncode'] != 0:
|
|
issues.append(label + ':candidate-rc:' + str(executed['returncode']))
|
|
continue
|
|
try:
|
|
actual = normalize(executed['stdout'])
|
|
except (UnicodeError, ValueError) as error:
|
|
issues.append(label + ':stdout:' + str(error))
|
|
continue
|
|
if actual != expected:
|
|
position = next((index for index, pair in enumerate(zip(actual, expected))
|
|
if pair[0] != pair[1]), min(len(actual), len(expected)))
|
|
observed = actual[position] if position < len(actual) else '<missing>'
|
|
wanted = expected[position] if position < len(expected) else '<missing>'
|
|
issues.append(label + ':observation:' + str(position) + ':' + str(observed) + '!=' + str(wanted))
|
|
except Exception as error:
|
|
issues.append('check-exception:' + type(error).__name__ + ':' + str(error)[:100])
|
|
finally:
|
|
try:
|
|
cleanup, evidence, reason = stage(['rm', '-rf', '--', str(scratch)], scratch.parent,
|
|
b'', CASE_DEADLINE)
|
|
if reason or cleanup is None or cleanup['returncode'] != 0:
|
|
issues.append('cleanup:' + (reason or str(cleanup['returncode'])))
|
|
except Exception as error:
|
|
issues.append('cleanup-exception:' + type(error).__name__)
|
|
try:
|
|
absent, evidence, reason = stage([sys.executable, '-I', '-c', ABSENCE, str(scratch)],
|
|
scratch.parent, b'', CASE_DEADLINE)
|
|
if reason or absent is None or absent['returncode'] != 0:
|
|
issues.append('absence:' + (reason or str(absent['returncode'])))
|
|
except Exception as error:
|
|
issues.append('absence-exception:' + type(error).__name__)
|
|
return issues, rows
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) != 2:
|
|
print('candidate argument required')
|
|
return 1
|
|
issues, rows = assess(Path(sys.argv[1]))
|
|
binary = bytearray()
|
|
def compact(value, field=''):
|
|
if type(value) is dict:
|
|
return {key: compact(item, key) for key, item in value.items()}
|
|
if type(value) is list:
|
|
return [compact(item, field) for item in value]
|
|
if (type(value) is str and (field.endswith('_sha256') or field == 'nonce') and
|
|
re.fullmatch(r'[0-9a-f]+', value, re.ASCII) and len(value) in (32, 64)):
|
|
position = len(binary)
|
|
binary.extend(bytes.fromhex(value))
|
|
return {'$': [position, len(value) // 2]}
|
|
return value
|
|
head = json.dumps(compact(STAGE_RECORDS), separators=(',', ':')).encode()
|
|
payload = len(head).to_bytes(4, 'big') + head + binary
|
|
encoded = base64.b64encode(zlib.compress(payload, 9))
|
|
print('STAGES_ZLIB64=' + encoded.decode('ascii'), file=sys.stderr)
|
|
print('stage_encoded_len=' + str(len(encoded)), file=sys.stderr)
|
|
print('observation_rows=' + str(rows), file=sys.stderr)
|
|
if issues:
|
|
for issue in issues[:2]:
|
|
print(issue, file=sys.stderr)
|
|
print('FAIL')
|
|
return 1
|
|
print('PASS')
|
|
return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
raise SystemExit(main())
|