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>
485 lines
32 KiB
Python
485 lines
32 KiB
Python
import base64
|
|
import hashlib
|
|
import json
|
|
import math
|
|
import os
|
|
from pathlib import Path
|
|
import random
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import zlib
|
|
|
|
CONTEXT = '#include "reader.hpp"\n\n#include <charconv>\n#include <iostream>\n#include <sstream>\n#include <string>\n#include <system_error>\n#include <vector>\n\nusing exception_reader::Event;\nusing exception_reader::Reader;\nusing exception_reader::Request;\nusing exception_reader::Result;\nusing exception_reader::Store;\n\nnamespace {\n\nstd::vector<std::string> words(const std::string &line)\n{\n std::istringstream input(line);\n std::vector<std::string> output;\n std::string word;\n while (input >> word) {\n output.push_back(word);\n }\n return output;\n}\n\nint nibble(char value)\n{\n if (value >= \'0\' && value <= \'9\') {\n return value - \'0\';\n }\n if (value >= \'a\' && value <= \'f\') {\n return value - \'a\' + 10;\n }\n if (value >= \'A\' && value <= \'F\') {\n return value - \'A\' + 10;\n }\n return -1;\n}\n\nbool decode(const std::string &source, std::string &output)\n{\n output.clear();\n if (source == "-") {\n return true;\n }\n if (source.size() % 2 != 0) {\n return false;\n }\n for (std::size_t at = 0; at < source.size(); at += 2) {\n const int high = nibble(source[at]);\n const int low = nibble(source[at + 1]);\n if (high < 0 || low < 0) {\n return false;\n }\n output.push_back(static_cast<char>((high << 4) | low));\n }\n return true;\n}\n\nstd::string encode(const std::string &source)\n{\n static const char digits[] = "0123456789abcdef";\n if (source.empty()) {\n return "-";\n }\n std::string output;\n output.reserve(source.size() * 2);\n for (unsigned char byte : source) {\n output.push_back(digits[byte >> 4]);\n output.push_back(digits[byte & 15]);\n }\n return output;\n}\n\ntemplate<typename Number>\nbool parse_number(const std::string &text, Number &output)\n{\n if (text.empty()) {\n return false;\n }\n const char *first = text.data();\n const char *last = first + text.size();\n const auto result = std::from_chars(first, last, output);\n return result.ec == std::errc{} && result.ptr == last;\n}\n\nvoid print_result(const Result &result)\n{\n std::cout << "Q " << exception_reader::status_name(result.status)\n << \' \' << result.lines\n << \' \' << result.bytes\n << \' \' << result.longest\n << \' \' << result.digest\n << \' \' << result.index_value\n << \' \' << result.opened\n << \' \' << result.closed\n << \' \' << result.live << \'\\n\';\n}\n\nclass Observer {\npublic:\n explicit Observer(std::size_t capacity)\n : store_(capacity), reader_(store_) {}\n\n bool execute(const std::vector<std::string> &parts)\n {\n if (parts.empty()) {\n return true;\n }\n if (parts[0] == "P") {\n return put(parts);\n }\n if (parts[0] == "A") {\n return append(parts);\n }\n if (parts[0] == "O") {\n return open(parts);\n }\n if (parts[0] == "D") {\n return duplicate(parts);\n }\n if (parts[0] == "R") {\n return read(parts);\n }\n if (parts[0] == "C") {\n return close(parts);\n }\n if (parts[0] == "J") {\n return jump(parts);\n }\n if (parts[0] == "I") {\n return inspect(parts);\n }\n if (parts[0] == "Q") {\n return query(parts);\n }\n if (parts[0] == "S") {\n return state(parts);\n }\n return false;\n }\n\nprivate:\n bool put(const std::vector<std::string> &parts)\n {\n if (parts.size() != 3 || parts[1].empty()) {\n return false;\n }\n std::string bytes;\n if (!decode(parts[2], bytes)) {\n return false;\n }\n store_.put(parts[1], bytes);\n std::cout << "P " << parts[1] << \'\\n\';\n return true;\n }\n\n bool query(const std::vector<std::string> &parts)\n {\n if (parts.size() != 6 || parts[1].empty()) {\n return false;\n }\n unsigned use_index = 0;\n std::size_t chunk = 0;\n long long fault_after = 0;\n if (!parse_number(parts[3], use_index) || use_index > 1 ||\n !parse_number(parts[4], chunk) ||\n !parse_number(parts[5], fault_after)) {\n return false;\n }\n const Request request{parts[1], parts[2], use_index != 0,\n chunk, fault_after};\n print_result(reader_.run(request));\n return true;\n }\n\n bool append(const std::vector<std::string> &parts)\n {\n if (parts.size() != 3 || !store_.contains(parts[1])) {\n return false;\n }\n std::string bytes;\n if (!decode(parts[2], bytes)) {\n return false;\n }\n store_.append(parts[1], bytes);\n std::cout << "A " << parts[1] << \' \'\n << store_.file_size(parts[1]) << \'\\n\';\n return true;\n }\n\n bool open(const std::vector<std::string> &parts)\n {\n if (parts.size() != 2) return false;\n try {\n const int handle = store_.open(parts[1]);\n std::cout << "O " << handle << \'\\n\';\n } catch (const exception_reader::Missing &) {\n std::cout << "O MISSING\\n";\n } catch (const exception_reader::Exhausted &) {\n std::cout << "O EXHAUSTED\\n";\n }\n return true;\n }\n\n bool duplicate(const std::vector<std::string> &parts)\n {\n int handle = 0;\n if (parts.size() != 2 || !parse_number(parts[1],handle)) return false;\n try {\n const int next = store_.clone(handle);\n std::cout << "D " << next << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "D BAD_HANDLE\\n";\n } catch (const exception_reader::Exhausted &) {\n std::cout << "D EXHAUSTED\\n";\n }\n return true;\n }\n\n bool read(const std::vector<std::string> &parts)\n {\n int handle = 0;\n std::size_t limit = 0;\n long long fault = 0;\n if (parts.size() != 4 || !parse_number(parts[1],handle) ||\n !parse_number(parts[2],limit) || limit == 0 ||\n !parse_number(parts[3],fault)) return false;\n try {\n const std::string piece = store_.read(handle,limit,fault);\n std::cout << "R " << encode(piece) << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "R BAD_HANDLE\\n";\n } catch (const exception_reader::ReadFault &) {\n std::cout << "R READ_ERROR\\n";\n }\n return true;\n }\n\n bool close(const std::vector<std::string> &parts)\n {\n int handle = 0;\n if (parts.size() != 2 || !parse_number(parts[1],handle)) return false;\n try {\n store_.close(handle);\n std::cout << "C " << handle << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "C BAD_HANDLE\\n";\n }\n return true;\n }\n\n bool jump(const std::vector<std::string> &parts)\n {\n int handle = 0;\n std::size_t offset = 0;\n if (parts.size() != 3 || !parse_number(parts[1],handle) ||\n !parse_number(parts[2],offset)) return false;\n try {\n store_.seek(handle,offset);\n std::cout << "J " << offset << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "J BAD_HANDLE\\n";\n } catch (const std::invalid_argument &) {\n std::cout << "J RANGE_ERROR\\n";\n }\n return true;\n }\n\n bool inspect(const std::vector<std::string> &parts)\n {\n int handle = 0;\n if (parts.size() != 2 || !parse_number(parts[1],handle)) return false;\n try {\n const std::size_t position = store_.position(handle);\n const std::size_t remaining = store_.remaining(handle);\n std::cout << "I " << position << \' \' << remaining << \'\\n\';\n } catch (const exception_reader::BadHandle &) {\n std::cout << "I BAD_HANDLE\\n";\n }\n return true;\n }\n\n bool state(const std::vector<std::string> &parts)\n {\n if (parts.size() != 1) {\n return false;\n }\n const std::vector<Event> events = store_.events();\n std::cout << "S " << store_.live() << \' \'\n << events.size() - previous_event_ << \'\\n\';\n for (std::size_t at = previous_event_; at < events.size(); ++at) {\n const Event &event = events[at];\n std::cout << "E " << event.kind << \' \' << event.handle\n << \' \' << event.amount << \'\\n\';\n }\n previous_event_ = events.size();\n return true;\n }\n\n Store store_;\n Reader reader_;\n std::size_t previous_event_ = 0;\n};\n\n}\n\nint main()\n{\n Observer observer(3);\n std::string line;\n while (std::getline(std::cin, line)) {\n if (!observer.execute(words(line))) {\n return 2;\n }\n }\n return std::cin.bad() ? 2 : 0;\n}\n'
|
|
CANDIDATES = ('reader.hpp', 'reader.cpp')
|
|
COMPILE_DEADLINE = 25
|
|
RUN_DEADLINE = 16
|
|
CLEAN_DEADLINE = 8
|
|
ABSENCE_DEADLINE = 8
|
|
|
|
SUPERVISOR = r'''
|
|
import base64, ctypes, hashlib, json, os, signal, subprocess, sys, time
|
|
from pathlib import Path
|
|
|
|
def stat(pid):
|
|
try:
|
|
raw = Path('/proc/%d/stat' % pid).read_text()
|
|
except (FileNotFoundError, ProcessLookupError):
|
|
return None
|
|
close = raw.rfind(')')
|
|
values = raw[close + 2:].split()
|
|
return (values[0], int(values[1]), int(values[19]))
|
|
|
|
def table(errors):
|
|
found = {}
|
|
try:
|
|
names = os.listdir('/proc')
|
|
except Exception as exc:
|
|
errors.append('proc-list:' + repr(exc)); return found
|
|
for name in names:
|
|
if not name.isdigit(): continue
|
|
try:
|
|
item = stat(int(name))
|
|
if item is not None: found[int(name)] = item
|
|
except Exception as exc:
|
|
errors.append('proc-stat:' + name + ':' + repr(exc))
|
|
return found
|
|
|
|
def descendants(owner, owner_start, found):
|
|
own = found.get(owner)
|
|
if own is None or own[2] != owner_start or own[0] in ('Z','X'):
|
|
return {}
|
|
current = {owner}
|
|
result = {}
|
|
while True:
|
|
added = False
|
|
for pid, (state, ppid, start) in found.items():
|
|
if pid in result or pid == owner or ppid not in current: continue
|
|
result[pid] = (state, ppid, start)
|
|
if state not in ('Z','X'):
|
|
current.add(pid)
|
|
added = True
|
|
if not added: break
|
|
return result
|
|
|
|
def fresh_kill(pid, start, errors):
|
|
try:
|
|
current = stat(pid)
|
|
if current is None or current[2] != start or current[0] in ('Z','X'):
|
|
return False
|
|
os.kill(pid, signal.SIGKILL)
|
|
return True
|
|
except (FileNotFoundError, ProcessLookupError):
|
|
return False
|
|
except Exception as exc:
|
|
errors.append('signal:' + repr(exc))
|
|
return False
|
|
|
|
def reap_adopted(errors):
|
|
while True:
|
|
try: pid, _ = os.waitpid(-1, os.WNOHANG)
|
|
except ChildProcessError: return
|
|
except Exception as exc:
|
|
errors.append('reap:' + repr(exc)); return
|
|
if pid == 0: return
|
|
|
|
def main():
|
|
argv = json.loads(sys.argv[1]); cwd = sys.argv[2]
|
|
deadline = float(sys.argv[3]); input_bytes = base64.b64decode(sys.argv[4])
|
|
errors = []; started = time.monotonic(); sup = os.getpid()
|
|
try:
|
|
if ctypes.CDLL(None).prctl(36, 1, 0, 0, 0) != 0:
|
|
errors.append('subreaper:prctl returned nonzero')
|
|
except Exception as exc: errors.append('subreaper:' + repr(exc))
|
|
ownstat = stat(sup)
|
|
ownstart = ownstat[2] if ownstat else None
|
|
proc = None; leader_start = None; leader_rc = None
|
|
timed_out = False; stdout = b''; stderr = b''; reaped = False
|
|
try:
|
|
proc = subprocess.Popen(argv, cwd=cwd, stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True)
|
|
leaderstat = stat(proc.pid)
|
|
leader_start = leaderstat[2] if leaderstat else None
|
|
if leader_start is None: errors.append('leader-start-missing')
|
|
try:
|
|
stdout, stderr = proc.communicate(input_bytes, timeout=deadline)
|
|
except subprocess.TimeoutExpired:
|
|
timed_out = True
|
|
except Exception as exc: errors.append('execute:' + repr(exc))
|
|
limit = time.monotonic() + 3.0
|
|
observed = set(); signaled = set()
|
|
last = {}
|
|
while proc is not None and time.monotonic() < limit:
|
|
seen = table(errors)
|
|
last = descendants(sup, ownstart, seen)
|
|
for pid, (_, _, start) in last.items():
|
|
observed.add((pid,start))
|
|
if fresh_kill(pid, start, errors): signaled.add((pid,start))
|
|
try:
|
|
if proc.poll() is not None:
|
|
leader_rc = proc.wait(timeout=0.05); reaped = True
|
|
except Exception as exc: errors.append('leader-wait:' + repr(exc))
|
|
if reaped: reap_adopted(errors)
|
|
seen = table(errors)
|
|
last = descendants(sup, ownstart, seen)
|
|
living = {pid: info for pid, info in last.items() if info[0] not in ('Z','X')}
|
|
if reaped and not living: break
|
|
time.sleep(0.02)
|
|
if proc is not None:
|
|
try:
|
|
more_out, more_err = proc.communicate(timeout=0.2)
|
|
stdout, stderr = more_out, more_err
|
|
if not reaped:
|
|
leader_rc = proc.returncode; reaped = True
|
|
except Exception as exc: errors.append('communicate-final:' + repr(exc))
|
|
if reaped: reap_adopted(errors)
|
|
final = descendants(sup, ownstart, table(errors))
|
|
living = {pid: info for pid, info in final.items() if info[0] not in ('Z','X')}
|
|
absence = not living and not any(info[0] in ('Z','X') for info in final.values())
|
|
rc = 124 if timed_out else leader_rc
|
|
elapsed = time.monotonic() - started
|
|
wire = dict(supervisor_pid=sup, supervisor_start=ownstart,
|
|
leader_pid=proc.pid if proc is not None else None, leader_start=leader_start,
|
|
uid=os.getuid(), gid=os.getgid(), groups=os.getgroups(),
|
|
argv=argv, elapsed=elapsed, timeout=timed_out, rc=rc,
|
|
leader_rc=leader_rc, reaped=reaped, descendants_absent=absence,
|
|
descendants=[(pid, info[2], info[0]) for pid, info in sorted(final.items())],
|
|
observed_descendants=sorted(observed), signaled_descendants=sorted(signaled),
|
|
exceptions=errors, stdout_len=len(stdout), stderr_len=len(stderr),
|
|
stdout_sha256=hashlib.sha256(stdout).hexdigest(),
|
|
stderr_sha256=hashlib.sha256(stderr).hexdigest(),
|
|
stdout=base64.b64encode(stdout).decode('ascii'),
|
|
stderr=base64.b64encode(stderr).decode('ascii'))
|
|
sys.stdout.write(json.dumps(wire, separators=(',',':')))
|
|
return 0
|
|
|
|
if __name__ == '__main__': raise SystemExit(main())
|
|
'''
|
|
|
|
def is_int(x):
|
|
return type(x) is int
|
|
|
|
def checked_wire(raw, argv, deadline, expected_uid, expected_gid, expected_groups):
|
|
if type(raw) is not dict: raise ValueError('wire type')
|
|
keys = ('supervisor_pid','supervisor_start','leader_pid','leader_start','uid','gid',
|
|
'groups','argv','elapsed','timeout','rc','leader_rc','reaped',
|
|
'descendants_absent','descendants','observed_descendants','signaled_descendants',
|
|
'exceptions','stdout_len','stderr_len',
|
|
'stdout_sha256','stderr_sha256','stdout','stderr')
|
|
if any(key not in raw for key in keys): raise ValueError('wire missing field')
|
|
for key in ('supervisor_pid','supervisor_start','leader_pid','leader_start'):
|
|
if not is_int(raw[key]) or raw[key] <= 0: raise ValueError('wire pid/start')
|
|
if raw['supervisor_pid'] == raw['leader_pid']: raise ValueError('wire pid alias')
|
|
if not is_int(raw['uid']) or not is_int(raw['gid']): raise ValueError('wire uid/gid')
|
|
if raw['uid'] != expected_uid or raw['gid'] != expected_gid: raise ValueError('wire identity')
|
|
if type(raw['groups']) is not list or any(not is_int(x) for x in raw['groups']):
|
|
raise ValueError('wire groups type')
|
|
if raw['groups'] != expected_groups: raise ValueError('wire groups')
|
|
if type(raw['argv']) is not list or raw['argv'] != argv: raise ValueError('wire argv')
|
|
elapsed = raw['elapsed']
|
|
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0 <= elapsed <= deadline+4:
|
|
raise ValueError('wire elapsed')
|
|
if type(raw['timeout']) is not bool or type(raw['reaped']) is not bool or \
|
|
type(raw['descendants_absent']) is not bool: raise ValueError('wire flags')
|
|
if not is_int(raw['rc']) or not is_int(raw['leader_rc']): raise ValueError('wire rc')
|
|
if raw['timeout'] and raw['rc'] != 124: raise ValueError('wire timeout rc')
|
|
if not raw['timeout'] and raw['rc'] != raw['leader_rc']: raise ValueError('wire leader rc')
|
|
if not raw['reaped'] or not raw['descendants_absent']: raise ValueError('wire closure')
|
|
if type(raw['descendants']) is not list or type(raw['exceptions']) is not list or \
|
|
raw['exceptions']: raise ValueError('wire descendants/errors')
|
|
if raw['descendants']: raise ValueError('wire descendants remaining')
|
|
for key in ('observed_descendants','signaled_descendants'):
|
|
if type(raw[key]) is not list or any(type(item) is not list or len(item)!=2 or
|
|
any(not is_int(n) or n<=0 for n in item) for item in raw[key]):
|
|
raise ValueError('wire topology '+key)
|
|
if any(item not in raw['observed_descendants'] for item in raw['signaled_descendants']):
|
|
raise ValueError('wire signal ancestry')
|
|
for stream in ('stdout','stderr'):
|
|
if not is_int(raw[stream+'_len']) or raw[stream+'_len'] < 0: raise ValueError('wire io len')
|
|
if type(raw[stream]) is not str or type(raw[stream+'_sha256']) is not str:
|
|
raise ValueError('wire io type')
|
|
data = base64.b64decode(raw[stream], validate=True)
|
|
if len(data) != raw[stream+'_len'] or hashlib.sha256(data).hexdigest() != raw[stream+'_sha256']:
|
|
raise ValueError('wire io digest')
|
|
raw[stream+'_bytes'] = data
|
|
return raw
|
|
|
|
def supervised(argv, cwd, deadline, stdin=b''):
|
|
isolated = os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534'
|
|
uid = 65534 if isolated else os.getuid()
|
|
gid = 65534 if isolated else os.getgid()
|
|
groups = [] if isolated else os.getgroups()
|
|
args = [sys.executable, '-I', '-c', SUPERVISOR, json.dumps(argv), str(cwd),
|
|
str(deadline), base64.b64encode(stdin).decode('ascii')]
|
|
wrapper = subprocess.run(args, capture_output=True, timeout=deadline+8)
|
|
if wrapper.returncode != 0:
|
|
raise RuntimeError('supervisor rc=%s wire_len=%d wire_sha=%s stderr=%s' %
|
|
(wrapper.returncode,len(wrapper.stdout),hashlib.sha256(wrapper.stdout).hexdigest(),
|
|
wrapper.stderr[-200:].decode('utf-8','replace')))
|
|
wire_facts=(len(wrapper.stdout),hashlib.sha256(wrapper.stdout).hexdigest())
|
|
try:
|
|
wire = json.loads(wrapper.stdout)
|
|
wire=checked_wire(wire, argv, deadline, uid, gid, groups)
|
|
except Exception as exc:
|
|
raise ValueError('supervisor wire rc=%d len=%d sha=%s: %s' %
|
|
(wrapper.returncode,wire_facts[0],wire_facts[1],exc)) from exc
|
|
wire['wrapper_rc']=wrapper.returncode
|
|
wire['wire_len'],wire['wire_sha256']=wire_facts
|
|
return wire
|
|
|
|
def finish_phase(wire, name):
|
|
if wire['timeout'] or wire['rc'] != 0:
|
|
raise RuntimeError('%s rc=%s timeout=%s' % (name,wire['rc'],wire['timeout']))
|
|
|
|
class Model:
|
|
def __init__(self):
|
|
self.files = {}; self.handles = {}; self.events = []; self.output = []
|
|
def put(self, name, data):
|
|
self.files[name] = data; self.output.append('P '+name)
|
|
def append(self, name, data):
|
|
self.files[name] += data; self.output.append('A %s %d' % (name,len(self.files[name])))
|
|
def open(self, name):
|
|
if name not in self.files: return None, 'MISSING'
|
|
if len(self.handles) >= 3: return None, 'EXHAUSTED'
|
|
handle = next(x for x in range(1,4) if x not in self.handles)
|
|
self.handles[handle] = [name,0]; self.events.append(('O',handle,0))
|
|
return handle, None
|
|
def clone(self, handle):
|
|
if handle not in self.handles: return None,'BAD_HANDLE'
|
|
if len(self.handles) >= 3: return None,'EXHAUSTED'
|
|
next_handle=next(x for x in range(1,4) if x not in self.handles)
|
|
self.handles[next_handle]=self.handles[handle].copy()
|
|
self.events.append(('O',next_handle,0))
|
|
return next_handle,None
|
|
def raw_open(self,name):
|
|
handle,error=self.open(name)
|
|
self.output.append('O '+(str(handle) if handle is not None else error))
|
|
def raw_clone(self,handle):
|
|
next_handle,error=self.clone(handle)
|
|
self.output.append('D '+(str(next_handle) if next_handle is not None else error))
|
|
def raw_read(self,handle,limit,fault):
|
|
if handle not in self.handles: outcome='BAD_HANDLE'
|
|
else:
|
|
piece,bad=self.read(handle,limit,fault)
|
|
outcome='READ_ERROR' if bad else (piece.hex() or '-')
|
|
self.output.append('R '+outcome)
|
|
def raw_close(self,handle):
|
|
if handle not in self.handles: self.output.append('C BAD_HANDLE')
|
|
else:
|
|
self.close(handle)
|
|
self.output.append('C '+str(handle))
|
|
def raw_seek(self,handle,offset):
|
|
if handle not in self.handles: outcome='BAD_HANDLE'
|
|
elif offset > len(self.files[self.handles[handle][0]]): outcome='RANGE_ERROR'
|
|
else:
|
|
self.handles[handle][1]=offset
|
|
outcome=str(offset)
|
|
self.output.append('J '+outcome)
|
|
def raw_inspect(self,handle):
|
|
if handle not in self.handles: self.output.append('I BAD_HANDLE')
|
|
else:
|
|
name,pos=self.handles[handle]
|
|
self.output.append('I %d %d' % (pos,len(self.files[name])-pos))
|
|
def read(self, handle, chunk, fault):
|
|
name,pos = self.handles[handle]; data = self.files[name]
|
|
if pos == len(data):
|
|
self.events.append(('R',handle,0)); return b'',False
|
|
if fault >= 0 and pos >= fault: return b'',True
|
|
stop = min(pos+chunk,len(data))
|
|
if fault >= 0: stop = min(stop,fault)
|
|
piece = data[pos:stop]; self.handles[handle][1] = stop
|
|
self.events.append(('R',handle,len(piece)))
|
|
return piece,False
|
|
def close(self, handle):
|
|
del self.handles[handle]; self.events.append(('C',handle,0))
|
|
def query(self, primary,index,use,chunk,fault):
|
|
start = len(self.events); data = bytearray(); value = -1; status = 'OK'
|
|
if not 1 <= chunk <= 64 or fault < -1: status = 'BAD_REQUEST'
|
|
else:
|
|
handle,status = self.open(primary)
|
|
if handle is not None:
|
|
status = 'OK'
|
|
while True:
|
|
piece,bad = self.read(handle,chunk,fault)
|
|
if bad: status = 'READ_ERROR'; break
|
|
if not piece: break
|
|
data.extend(piece)
|
|
self.close(handle)
|
|
if status == 'OK' and use:
|
|
second,error = self.open(index)
|
|
if second is None: status = error
|
|
else:
|
|
raw = bytearray()
|
|
while True:
|
|
piece,_ = self.read(second,chunk,-1)
|
|
if not piece: break
|
|
raw.extend(piece)
|
|
self.close(second)
|
|
content = bytes(raw)
|
|
if content.endswith(b'\n'): content=content[:-1]
|
|
significant=content.lstrip(b'0')
|
|
if not content or any(x < 48 or x > 57 for x in content) or \
|
|
len(significant) > 7 or int(significant or b'0') > 1000000:
|
|
status = 'INDEX_ERROR'
|
|
else: value = int(significant or b'0')
|
|
b = bytes(data); lines=b.count(b'\n')+int(bool(b) and not b.endswith(b'\n'))
|
|
longest=max((len(x) for x in b.split(b'\n')),default=0)
|
|
if b.endswith(b'\n'): longest=max((len(x) for x in b[:-1].split(b'\n')),default=0)
|
|
digest=2166136261
|
|
for x in b: digest=((digest^x)*16777619)&0xffffffff
|
|
events=self.events[start:]
|
|
opened=sum(x[0]=='O' for x in events); closed=sum(x[0]=='C' for x in events)
|
|
self.output.append('Q %s %d %d %d %d %d %d %d %d' %
|
|
(status,lines,len(b),longest,digest,value,opened,closed,len(self.handles)))
|
|
def state(self):
|
|
self.output.append('S %d %d' % (len(self.handles),len(self.events)))
|
|
for event in self.events:
|
|
self.output.append('E %s %d %d' % event)
|
|
self.events.clear()
|
|
|
|
def cases():
|
|
m=Model(); commands=[]; rng=random.Random(0x726561646572)
|
|
def put(name,data): m.put(name,data); commands.append('P %s %s' % (name,data.hex() or '-'))
|
|
def append(name,data): m.append(name,data); commands.append('A %s %s' % (name,data.hex() or '-'))
|
|
def query(name,index,use,chunk,fault):
|
|
m.query(name,index,use,chunk,fault)
|
|
commands.append('Q %s %s %d %d %d' % (name,index,int(use),chunk,fault))
|
|
def state(): m.state(); commands.append('S')
|
|
def raw_o(name): m.raw_open(name); commands.append('O '+name)
|
|
def raw_d(handle): m.raw_clone(handle); commands.append('D '+str(handle))
|
|
def raw_r(handle,limit,fault):
|
|
m.raw_read(handle,limit,fault); commands.append('R %d %d %d' % (handle,limit,fault))
|
|
def raw_c(handle): m.raw_close(handle); commands.append('C '+str(handle))
|
|
def raw_j(handle,offset): m.raw_seek(handle,offset); commands.append('J %d %d' % (handle,offset))
|
|
def raw_i(handle): m.raw_inspect(handle); commands.append('I '+str(handle))
|
|
put('a',b'alpha\nbeta'); put('idx',b'42\n'); put('bad',b'12x'); put('empty',b'')
|
|
query('a','-',False,2,6); state()
|
|
query('a','idx',True,3,-1); state()
|
|
query('a','bad',True,2,-1); state()
|
|
for payload in (b'',b'\n',b'a',b'a\n',b'\r\n',b'a\x00b\ncc',b'abc\n\nxy'):
|
|
put('data',payload)
|
|
query('data','-',False,1,-1); state()
|
|
for fault in (0,1,len(payload),len(payload)+1):
|
|
query('data','-',False,3,fault); state()
|
|
for i,content in enumerate((b'0',b'00042\n',b'1000000',b'1000001',b'-1',b'+2',b'1\n2',b'\n',b'',b'9'*100)):
|
|
put('ix',content)
|
|
query('a','ix',True,1+(i%7),-1); state()
|
|
put('ix',b'0'*5000); query('a','ix',True,64,-1); state()
|
|
append('a',b'\nmore\r\n'); query('a','idx',True,64,-1); state()
|
|
for i in range(25):
|
|
data=bytes(rng.randrange(256) for _ in range(rng.randrange(0,150)))
|
|
put('random',data)
|
|
chunk=rng.randrange(1,65); fault=rng.choice([-1,0,1,len(data)//2,len(data)])
|
|
query('random','-',False,chunk,fault); state()
|
|
query('missing','-',False,4,-1); state()
|
|
query('a','-',False,0,-1); state()
|
|
query('a','-',False,65,-1); state()
|
|
query('a','-',False,4,-2); state()
|
|
raw_o('a'); raw_i(1); raw_r(1,2,-1); raw_i(1)
|
|
raw_d(1); raw_j(2,5); raw_i(2); state()
|
|
query('a','idx',True,2,-1); state()
|
|
raw_o('a'); raw_d(1); raw_i(7); state()
|
|
raw_c(2); raw_c(3); raw_c(1); raw_c(1); state()
|
|
raw_o('missing'); raw_d(7); raw_r(7,2,-1); raw_j(7,0); state()
|
|
raw_o('a'); raw_j(1,10000); raw_i(1); raw_c(1); state()
|
|
return ('\n'.join(commands)+'\n').encode(), ('\n'.join(m.output)+'\n').encode(),len(commands)
|
|
|
|
def number(token):
|
|
if not re.fullmatch(rb'[+-]?[0-9]+',token):
|
|
raise ValueError('nondecimal numeric token')
|
|
negative=token[:1]==b'-'
|
|
digits=token[1:] if token[:1] in (b'-',b'+') else token
|
|
significant=digits.lstrip(b'0') or b'0'
|
|
if len(significant)>20:
|
|
raise ValueError('numeric token out of observable range')
|
|
value=int(significant)
|
|
return -value if negative else value
|
|
|
|
def output_rows(data):
|
|
if data.endswith(b'\n'):
|
|
data=data[:-1]
|
|
rows=[]
|
|
for line in data.split(b'\n'):
|
|
tokens=re.split(rb'[ \t\r]+',line.strip(b' \t\r'))
|
|
if not tokens or not tokens[0]: raise ValueError('empty output row')
|
|
tag=tokens[0]
|
|
if tag==b'Q' and len(tokens)==10 and tokens[1] in (
|
|
b'OK',b'BAD_REQUEST',b'READ_ERROR',b'INDEX_ERROR',b'MISSING',b'EXHAUSTED'):
|
|
row=(tag,tokens[1],*(number(x) for x in tokens[2:]))
|
|
elif tag==b'S' and len(tokens)==3:
|
|
row=(tag,number(tokens[1]),number(tokens[2]))
|
|
elif tag==b'E' and len(tokens)==4 and tokens[1] in (b'O',b'R',b'C'):
|
|
row=(tag,tokens[1],number(tokens[2]),number(tokens[3]))
|
|
elif tag==b'P' and len(tokens)==2:
|
|
row=(tag,tokens[1])
|
|
elif tag==b'A' and len(tokens)==3:
|
|
row=(tag,tokens[1],number(tokens[2]))
|
|
elif tag in (b'O',b'D',b'C',b'J') and len(tokens)==2:
|
|
row=(tag,tokens[1] if tokens[1] in (b'MISSING',b'EXHAUSTED',b'BAD_HANDLE',b'RANGE_ERROR')
|
|
else number(tokens[1]))
|
|
elif tag==b'I' and len(tokens)==2 and tokens[1]==b'BAD_HANDLE':
|
|
row=(tag,tokens[1])
|
|
elif tag==b'I' and len(tokens)==3:
|
|
row=(tag,number(tokens[1]),number(tokens[2]))
|
|
elif tag==b'R' and len(tokens)==2:
|
|
if tokens[1] in (b'READ_ERROR',b'BAD_HANDLE',b'-'):
|
|
value=tokens[1]
|
|
else:
|
|
if not re.fullmatch(rb'(?:[0-9a-fA-F]{2})+',tokens[1]):
|
|
raise ValueError('invalid hex observation')
|
|
value=bytes.fromhex(tokens[1].decode('ascii'))
|
|
row=(tag,value)
|
|
else:
|
|
raise ValueError('invalid output row')
|
|
rows.append(row)
|
|
return rows
|
|
|
|
def main(candidate):
|
|
candidate=Path(candidate)
|
|
data,expected,checks=cases()
|
|
scratch=Path(tempfile.mkdtemp(prefix='exception-reader-'))
|
|
work=scratch/'work'
|
|
result='FAIL'; reason='unknown'; phases={}
|
|
try:
|
|
work.mkdir()
|
|
for name in CANDIDATES:
|
|
(work/name).write_bytes((candidate/name).read_bytes())
|
|
(work/'reader-demo.cpp').write_text(CONTEXT)
|
|
os.chmod(work,0o777)
|
|
compiler=['g++','-std=c++17','-O2','-Wall','-Wextra','-pedantic',
|
|
'-o',str(work/'reader-demo'),str(work/'reader-demo.cpp'),str(work/'reader.cpp')]
|
|
phases['compiler']=supervised(compiler,work,COMPILE_DEADLINE)
|
|
finish_phase(phases['compiler'],'compiler')
|
|
phases['candidate']=supervised([str(work/'reader-demo')],work,RUN_DEADLINE,data)
|
|
finish_phase(phases['candidate'],'candidate')
|
|
if output_rows(phases['candidate']['stdout_bytes']) != output_rows(expected):
|
|
reason='observation mismatch'
|
|
else:
|
|
result='PASS'; reason='all observations equal'
|
|
except Exception as exc:
|
|
result='FAIL'
|
|
reason=type(exc).__name__+': '+str(exc)
|
|
finally:
|
|
cleanup=['python3','-I','-c','import shutil,sys; shutil.rmtree(sys.argv[1])',str(scratch)]
|
|
absence=['python3','-I','-c',
|
|
'import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: raise SystemExit(0)\nraise SystemExit(1)',str(scratch)]
|
|
for label,argv,deadline in (('cleanup',cleanup,CLEAN_DEADLINE),
|
|
('absence',absence,ABSENCE_DEADLINE)):
|
|
try:
|
|
phases[label]=supervised(argv,Path('/'),deadline)
|
|
finish_phase(phases[label],label)
|
|
except Exception as exc:
|
|
result='FAIL'; reason+=('; '+label+' '+type(exc).__name__+': '+str(exc))
|
|
record=dict(result=result,reason=reason,checks=checks,
|
|
phases={key:{k:v for k,v in value.items() if not k.endswith('_bytes') and k not in ('stdout','stderr')}
|
|
for key,value in phases.items()})
|
|
packed=base64.b64encode(zlib.compress(json.dumps(record,sort_keys=True,separators=(',',':')).encode(),9)).decode()
|
|
print('META_ZLIB64 '+packed,file=sys.stderr)
|
|
print('PASS' if result=='PASS' else 'FAIL')
|
|
return 0 if result=='PASS' else 1
|
|
|
|
if __name__=='__main__':
|
|
raise SystemExit(main(sys.argv[1]))
|