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>
379 lines
31 KiB
Python
379 lines
31 KiB
Python
"""Private independent oracle and candidate-identity execution; no hidden child assertions."""
|
|
import base64
|
|
import hashlib
|
|
import json
|
|
import lzma
|
|
import math
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import uuid
|
|
|
|
SUPERVISOR = "# Candidate-identity execution only: no expected values or grading assertions.\nimport base64\nimport ctypes\nimport hashlib\nimport json\nimport os\nimport signal\nimport subprocess\nimport sys\nimport time\n\n\ndef read_stat(pid):\n try:\n with open('/proc/%d/stat' % pid, 'rb') as stream:\n raw = stream.read()\n except (FileNotFoundError, ProcessLookupError):\n return None\n fields = raw[raw.rfind(b')') + 2:].split()\n return {'pid': int(pid), 'state': fields[0].decode('ascii'),\n 'ppid': int(fields[1]), 'pgid': int(fields[2]), 'start': int(fields[19])}\n\n\ndef closure(table, supervisor, tracked):\n roots = {supervisor}\n for pid, start in tracked.items():\n row = table.get(pid)\n if row and row['start'] == start and row['state'] not in ('Z', 'X'):\n roots.add(pid)\n included = set(roots)\n while True:\n added = {pid for pid, row in table.items() if row['ppid'] in included} - included\n if not added:\n break\n included.update(added)\n return {pid: table[pid]['start'] for pid in included if pid != supervisor and pid in table}\n\n\ndef group_members(table, pgid):\n return {pid: row['start'] for pid, row in table.items() if row['pgid'] == pgid}\n\n\ndef fresh_signal(pid, start, exceptions):\n try:\n row = read_stat(pid)\n if row and row['start'] == start and row['state'] not in ('Z', 'X'):\n os.kill(pid, signal.SIGKILL)\n except (FileNotFoundError, ProcessLookupError):\n pass\n except BaseException as error:\n exceptions.append('signal:' + type(error).__name__ + ':' + repr(error))\n\n\ndef table_now(exceptions):\n table = {}\n try:\n names = os.listdir('/proc')\n except BaseException as error:\n exceptions.append('proc-list:' + type(error).__name__ + ':' + repr(error))\n return table\n for name in names:\n if name.isascii() and name.isdigit():\n try:\n row = read_stat(int(name))\n if row is not None:\n table[int(name)] = row\n except BaseException as error:\n exceptions.append('proc-stat:' + type(error).__name__ + ':' + repr(error))\n return table\n\n\ndef digest_bytes(raw):\n return {'bytes': base64.b64encode(raw).decode('ascii'), 'length': len(raw),\n 'sha256': hashlib.sha256(raw).hexdigest()}\n\n\ndef main():\n begun = time.monotonic()\n exceptions = []\n proc = None\n tracked = {}\n stdout = b''\n stderr = b''\n timedout = False\n descendants = None\n members = None\n result = {'exceptions': exceptions, 'uid': os.getuid(), 'gid': os.getgid(),\n 'groups': os.getgroups(), 'supervisor_pid': os.getpid()}\n request = {}\n try:\n own = read_stat(os.getpid())\n result['supervisor_start'] = own['start']\n request_raw = sys.stdin.buffer.read()\n request = json.loads(request_raw)\n result.update(request_length=len(request_raw), request_sha256=hashlib.sha256(request_raw).hexdigest())\n result.update(nonce=request['nonce'], argv=request['argv'], cwd=request['cwd'],\n deadline=request['deadline'])\n libc = ctypes.CDLL(None, use_errno=True)\n if libc.prctl(36, 1, 0, 0, 0) != 0:\n raise OSError(ctypes.get_errno(), 'subreaper')\n proc = subprocess.Popen(request['argv'], cwd=request['cwd'], stdin=subprocess.PIPE,\n stdout=subprocess.PIPE, stderr=subprocess.PIPE,\n start_new_session=True)\n leader = read_stat(proc.pid)\n if leader is None:\n raise RuntimeError('leader stat missing before first poll')\n tracked[proc.pid] = leader['start']\n result.update(leader_pid=proc.pid, leader_start=leader['start'], leader_pgid=leader['pgid'])\n payload = base64.b64decode(request['input'], validate=True)\n result.update(input_length=len(payload), input_sha256=hashlib.sha256(payload).hexdigest())\n deadline = begun + request['deadline']\n while True:\n tracked.update(closure(table_now(exceptions), os.getpid(), tracked))\n remaining = deadline - time.monotonic()\n if remaining <= 0:\n timedout = True\n break\n try:\n stdout, stderr = proc.communicate(payload, timeout=min(0.05, remaining))\n break\n except subprocess.TimeoutExpired as error:\n if error.output is not None:\n stdout = error.output\n if error.stderr is not None:\n stderr = error.stderr\n payload = None\n except BaseException as error:\n exceptions.append('execute:' + type(error).__name__ + ':' + repr(error))\n finally:\n recovery = time.monotonic() + 3.0\n empty_rounds = 0\n while proc is not None:\n try:\n # Own Popen always receives its exit status before adopted waitpid calls.\n proc.poll()\n if proc.returncode is not None:\n proc.wait(timeout=0)\n while True:\n try:\n adopted, status = os.waitpid(-1, os.WNOHANG)\n except ChildProcessError:\n break\n if adopted == 0:\n break\n table = table_now(exceptions)\n descendants = closure(table, os.getpid(), tracked)\n tracked.update(descendants)\n members = group_members(table, result.get('leader_pgid'))\n if proc.returncode is not None and not descendants and not members:\n empty_rounds += 1\n if empty_rounds >= 2:\n break\n else:\n empty_rounds = 0\n for pid, start in descendants.items():\n fresh_signal(pid, start, exceptions)\n if time.monotonic() >= recovery:\n exceptions.append('recovery:deadline')\n break\n time.sleep(0.01)\n except BaseException as error:\n exceptions.append('recover:' + type(error).__name__ + ':' + repr(error))\n if time.monotonic() >= recovery:\n break\n time.sleep(0.01)\n if proc is not None:\n try:\n stdout, stderr = proc.communicate(timeout=max(0.01, recovery - time.monotonic()))\n except subprocess.TimeoutExpired as error:\n if error.output is not None:\n stdout = error.output\n if error.stderr is not None:\n stderr = error.stderr\n exceptions.append('final-communicate:TimeoutExpired')\n except BaseException as error:\n exceptions.append('final-communicate:' + type(error).__name__ + ':' + repr(error))\n try:\n proc.poll()\n except BaseException as error:\n exceptions.append('final-poll:' + type(error).__name__ + ':' + repr(error))\n result.update(real_rc=proc.returncode if proc else None,\n leader_reaped=proc is not None and proc.returncode is not None,\n timeout=timedout, controlled_rc=124 if timedout else (proc.returncode if proc else None),\n descendants_absent=descendants == {}, pg_absent=members == {},\n tracked=tracked, remaining_descendants=descendants, remaining_pg=members,\n elapsed=time.monotonic() - begun, stdout=digest_bytes(stdout), stderr=digest_bytes(stderr))\n sys.stdout.buffer.write(json.dumps(result, separators=(',', ':'), sort_keys=True).encode('ascii'))\n\n\nif __name__ == '__main__':\n main()\n"
|
|
HEADER = '#ifndef ARRAY_REPORT_H\n#define ARRAY_REPORT_H\n#include <stddef.h>\n#include <stdint.h>\n#define RA_LIMIT 128\n#define RA_FIELDS 56\ntypedef struct {\n int count;\n unsigned seed;\n int base;\n int step;\n int mode;\n int cutoff;\n int window;\n int bins;\n int fail_at;\n} ra_request;\ntypedef struct { int value; unsigned position; } ra_cell;\ntypedef struct { long long v[RA_FIELDS]; } ra_report;\ntypedef struct {\n void *context;\n void *(*allocate)(void *, size_t);\n void (*release)(void *, void *);\n void (*publish)(void *, const ra_report *);\n} ra_port;\nvoid ra_trends(const ra_cell *, size_t, ra_report *);\nint ra_process(const ra_request *, const ra_port *);\nint ra_valid(const ra_request *);\nint ra_transform(int, int);\nsize_t ra_generate(const ra_request *, ra_cell *);\nvoid ra_analyse(const ra_request *, const ra_cell *, size_t, ra_report *);\nvoid ra_order(const ra_cell *, size_t, unsigned *);\nvoid ra_rank(const ra_request *, const ra_cell *, const unsigned *, size_t, ra_report *);\n#endif\n'
|
|
OBSERVER = '#include "array_report.h"\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\ntypedef struct {\n void *blocks[2];\n size_t sizes[2];\n int fail_at;\n int calls;\n int releases;\n int live;\n int invalid;\n int publications;\n ra_report report;\n} observer;\nstatic void *allocate(void *context, size_t bytes)\n{\n observer *state = context;\n state->calls += 1;\n if (state->calls <= 2) {\n state->sizes[state->calls - 1] = bytes;\n }\n if (state->fail_at == state->calls || state->calls > 2) {\n return NULL;\n }\n void *block = malloc(bytes);\n if (block != NULL) {\n state->blocks[state->calls - 1] = block;\n state->live += 1;\n }\n return block;\n}\nstatic void release(void *context, void *block)\n{\n observer *state = context;\n state->releases += 1;\n for (int index = 0; index < 2; ++index) {\n if (block != NULL && block == state->blocks[index]) {\n free(block);\n state->blocks[index] = NULL;\n state->live -= 1;\n return;\n }\n }\n state->invalid += 1;\n}\nstatic void publish(void *context, const ra_report *report)\n{\n observer *state = context;\n state->publications += 1;\n if (state->live != 2) {\n state->invalid += 1;\n }\n state->report = *report;\n}\nint main(void)\n{\n for (;;) {\n ra_request request;\n int got = scanf("%d %u %d %d %d %d %d %d %d", &request.count,\n &request.seed, &request.base, &request.step, &request.mode,\n &request.cutoff, &request.window, &request.bins, &request.fail_at);\n if (got == EOF) {\n return 0;\n }\n if (got != 9) {\n return 2;\n }\n observer state;\n memset(&state, 0, sizeof(state));\n state.fail_at = request.fail_at;\n ra_port port = {&state, allocate, release, publish};\n const ra_request *selected_request = &request;\n const ra_port *selected_port = &port;\n int probe = request.count;\n if (probe <= -2 && probe >= -6) {\n request.count = 1;\n if (probe == -2) selected_request = NULL;\n if (probe == -3) selected_port = NULL;\n if (probe == -4) port.allocate = NULL;\n if (probe == -5) port.release = NULL;\n if (probe == -6) port.publish = NULL;\n }\n ra_request saved = request;\n ra_port saved_port = port;\n int rc = ra_process(selected_request, selected_port);\n if (request.count != saved.count || request.seed != saved.seed ||\n request.base != saved.base || request.step != saved.step ||\n request.mode != saved.mode || request.cutoff != saved.cutoff ||\n request.window != saved.window || request.bins != saved.bins ||\n request.fail_at != saved.fail_at ||\n port.context != saved_port.context ||\n port.allocate != saved_port.allocate ||\n port.release != saved_port.release ||\n port.publish != saved_port.publish) {\n state.invalid += 1;\n }\n printf("%d %d %d %d %d %zu %zu %d", rc, state.calls, state.releases,\n state.live, state.invalid, state.sizes[0], state.sizes[1], state.publications);\n for (int field = 0; field < RA_FIELDS; ++field) {\n printf(" %lld", state.report.v[field]);\n }\n putchar(\'\\n\');\n for (int index = 0; index < 2; ++index) {\n free(state.blocks[index]);\n }\n }\n}\n'
|
|
import bisect
|
|
import re
|
|
|
|
def cells(request):
|
|
count, seed, base, step, mode, cutoff, window, bins, fail_at = request
|
|
result = []
|
|
for position in range(count):
|
|
seed = (1664525 * seed + 1013904223) & 0xffffffff
|
|
value = base + position % 11 * step + (seed >> 16) % 101 - 50
|
|
if mode == 1: value = abs(value)
|
|
if mode == 2: value = max(-25, min(25, value))
|
|
if mode == 3: value = value * abs(value)
|
|
if abs(value) >= cutoff: result.append((value, position))
|
|
return result
|
|
|
|
def oracle(request):
|
|
count, seed, base, step, mode, cutoff, window, bins, fail_at = request
|
|
valid = (0 <= count <= 128 and 0 <= seed <= 65535 and -100 <= base <= 100 and
|
|
-7 <= step <= 7 and 0 <= mode <= 3 and 0 <= cutoff <= 100 and
|
|
1 <= window <= 16 and 1 <= bins <= 8 and 0 <= fail_at <= 2)
|
|
zero = [0]*56
|
|
if not valid: return [-2,0,0,0,0,0,0,0] + zero
|
|
if count == 0: return [1,0,0,0,0,0,0,0] + zero
|
|
if fail_at == 1: return [-1,1,0,0,0,count*8,0,0] + zero
|
|
if fail_at == 2: return [-1,2,1,0,0,count*8,count*4,0] + zero
|
|
selected = cells(request); values = [v for v,p in selected]; n = len(values)
|
|
report = zero[:]; report[:7] = [count,n,count-n,sum(values),sum(map(abs,values)),
|
|
sum(v*v for v in values),sum(v*(p+1) for v,p in selected)]
|
|
if n:
|
|
report[7:11] = [min(values),max(values),next(p for v,p in selected if v==min(values)),
|
|
next(p for v,p in selected if v==max(values))]
|
|
report[11:16] = [sum(v<0 for v in values), values.count(0), sum(v>0 for v in values),
|
|
sum(v for v in values if v%2==0),sum(v for v in values if v%2)]
|
|
for field, direction in [(16,1),(17,-1)]:
|
|
report[field] = max([0]+[end-start for start in range(n) for end in range(start+1,n+1)
|
|
if all(direction*values[j] <= direction*values[j+1] for j in range(start,end-1))])
|
|
report[18] = sum(abs(a-b) for a,b in zip(values,values[1:]))
|
|
width = min(window,n)
|
|
if n:
|
|
sums = [sum(values[i:i+width]) for i in range(n-width+1)]
|
|
report[19:22] = [max(sums),sums.index(max(sums)),
|
|
max(sum(values[a:b]) for a in range(n) for b in range(a+1,n+1))]
|
|
checksum = 2166136261
|
|
for value,position in selected:
|
|
checksum = ((checksum ^ (value & 0xffffffff)) * 16777619) & 0xffffffff
|
|
checksum = ((checksum ^ position) * 16777619) & 0xffffffff
|
|
report[22] = checksum
|
|
ordered = sorted(selected)
|
|
if n:
|
|
ranked = [v for v,p in ordered]; median = ranked[(n-1)//2]
|
|
report[23:31] = [len(set(values)), ranked[(n-1)//4],median,ranked[(n-1)*3//4],
|
|
sum((i+1)*v for i,v in enumerate(ranked)),
|
|
max([0]+[b-a for a,b in zip(ranked,ranked[1:])]),
|
|
sum(abs(v-median) for v in values),ordered[0][1]]
|
|
buckets = [0]*bins
|
|
for value in values:
|
|
k = (value-min(values))*bins//(max(values)-min(values)+1)
|
|
buckets[k] += 1
|
|
report[31:35] = [buckets.index(max(buckets)),max(buckets),sum(c>0 for c in buckets),
|
|
sum((i+1)*c for i,c in enumerate(buckets))]
|
|
report[35] = sum(values[a]>values[b] for a in range(n) for b in range(a+1,n))
|
|
prefixes = [sum(values[:i]) for i in range(n+1)]
|
|
report[36:38] = [min(prefixes),max(prefixes)]
|
|
for startfield, sign in [(38,1),(39,-1)]:
|
|
lengths=[];current=0
|
|
for value in values+[0]:
|
|
if value*sign>0: current+=1
|
|
elif current: lengths.append(current);current=0
|
|
report[startfield] = len(lengths)
|
|
report[startfield+2] = max([0]+lengths)
|
|
report[42:46] = [sum(values[i]>values[i-1] and values[i]>values[i+1] for i in range(1,n-1)),
|
|
sum(values[i]<values[i-1] and values[i]<values[i+1] for i in range(1,n-1)),
|
|
sum(a==b for a,b in zip(values,values[1:])),sum(a*b for a,b in zip(values,values[1:]))]
|
|
gaps = [b[1]-a[1]-1 for a,b in zip(selected,selected[1:])]
|
|
report[46:48] = [max([0]+gaps),sum(gaps)]
|
|
for field,sign in [(48,1),(49,-1)]:
|
|
tails=[]
|
|
for value in values:
|
|
i=bisect.bisect_left(tails,value*sign)
|
|
if i==len(tails):tails.append(value*sign)
|
|
else:tails[i]=value*sign
|
|
report[field]=len(tails)
|
|
if n:
|
|
winner=max(values,key=lambda v:values.count(v))
|
|
report[50:53]=[winner,values.count(winner),sum(values[a]==values[b] for a in range(n) for b in range(a+1,n))]
|
|
report[53]=sum(v if i%2==0 else -v for i,v in enumerate(values))
|
|
nonzero=[1 if v>0 else -1 for v in values if v]
|
|
report[54]=sum(a!=b for a,b in zip(nonzero,nonzero[1:]))
|
|
report[55]=max([0]+[end-start for start in range(n) for end in range(start+1,n+1) if len(set(values[start:end]))==1])
|
|
return [0,2,2,0,0,count*8,count*4,1]+report
|
|
|
|
def scenarios():
|
|
rows = [[100,1,0,1,0,0,4,4,0],[128,65535,-30,7,1,17,16,8,0],
|
|
[128,22222,30,-7,2,25,1,1,0],[128,119,-100,-7,3,100,16,8,0],
|
|
[1,0,0,0,0,100,1,8,0],[1,1,0,0,0,0,16,2,0],
|
|
[8,123,0,0,0,0,2,4,1],[8,123,0,0,0,0,2,4,2],[0,0,0,0,0,0,1,1,2]]
|
|
basic=[9,17,0,0,0,0,1,4,0]
|
|
for index,value in [(0,-1),(0,129),(1,65536),(2,-101),(2,101),(3,8),(4,4),
|
|
(5,-1),(5,101),(6,0),(6,17),(7,0),(7,9),(8,3)]:
|
|
row=basic[:];row[index]=value;rows.append(row)
|
|
for probe in range(-6,-1):
|
|
row=basic[:];row[0]=probe;rows.append(row)
|
|
return rows
|
|
|
|
def decimal(token):
|
|
if not re.fullmatch(rb'[+-]?[0-9]+',token): raise ValueError('decimal token')
|
|
negative=token[:1]==b'-'
|
|
digits=token.lstrip(b'+-').lstrip(b'0') or b'0'
|
|
if len(digits)>19: raise ValueError('signed64 range')
|
|
value=int(digits)*(-1 if negative else 1)
|
|
if not -2**63 <= value < 2**63: raise ValueError('signed64 range')
|
|
return value
|
|
|
|
def observations(raw):
|
|
rows=raw.split(b'\n')
|
|
if rows[-1:]==[b'']: rows.pop()
|
|
result=[]
|
|
for row in rows:
|
|
tokens=re.split(rb'[ \t\r]+',row.strip(b' \t\r'))
|
|
if len(tokens)!=64:raise ValueError('observation field count')
|
|
result.append([decimal(t) for t in tokens])
|
|
return result
|
|
|
|
DEADLINES = {'compiler': 12, 'candidate': 6, 'cleanup': 6, 'absence': 6}
|
|
OUTER_MARGIN = 8
|
|
RECLAIM_MARGIN = 4
|
|
CANDIDATES = ['engine.c','analyse.c','ordering.c','trends.c']
|
|
CLEANUP = "import shutil,sys; shutil.rmtree(sys.argv[1]); print(0)"
|
|
ABSENCE = "import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: print(0)\nelse: print(1)"
|
|
|
|
|
|
def blob(raw):
|
|
return {'length': len(raw), 'sha256': hashlib.sha256(raw).hexdigest(),
|
|
'latin1': raw.decode('latin1')}
|
|
|
|
|
|
def proc_token(pid):
|
|
try:
|
|
with open('/proc/%d/stat' % pid,'rb') as stream:
|
|
raw=stream.read()
|
|
except (FileNotFoundError,ProcessLookupError):
|
|
return None
|
|
parts=raw[raw.rfind(b')')+2:].split()
|
|
return int(parts[19])
|
|
|
|
|
|
def source_bytes(root, relative):
|
|
# All ancestor directories and the leaf are opened without following symlinks.
|
|
parts=Path(os.path.abspath(root)).parts
|
|
fd=os.open('/',os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW)
|
|
try:
|
|
for part in [*parts[1:],*Path(relative).parts[:-1]]:
|
|
child=os.open(part,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW,dir_fd=fd)
|
|
os.close(fd);fd=child
|
|
leaf=os.open(Path(relative).name,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK,dir_fd=fd)
|
|
try:
|
|
identity=os.fstat(leaf)
|
|
if not stat.S_ISREG(identity.st_mode) or identity.st_size>1048576:
|
|
raise ValueError('source is not a bounded regular file')
|
|
with os.fdopen(leaf,'rb',closefd=False) as stream:
|
|
data=stream.read(1048577)
|
|
if len(data)>1048576:
|
|
raise ValueError('source too large')
|
|
return data
|
|
finally:
|
|
os.close(leaf)
|
|
finally:
|
|
os.close(fd)
|
|
|
|
|
|
def valid_int(value, lower=None):
|
|
return type(value) is int and (lower is None or value>=lower)
|
|
|
|
|
|
def unblob(value):
|
|
if not isinstance(value,dict) or set(value)!={'bytes','length','sha256'}:
|
|
raise ValueError('IO structure')
|
|
if not valid_int(value['length'],0):raise ValueError('IO length')
|
|
raw=base64.b64decode(value['bytes'],validate=True)
|
|
if len(raw)!=value['length'] or hashlib.sha256(raw).hexdigest()!=value['sha256']:
|
|
raise ValueError('IO binding')
|
|
return raw
|
|
|
|
|
|
def verify_wire(wire, request, expected_pid, expected_start, wrapper_rc, raw_request):
|
|
if wrapper_rc!=0:raise ValueError('wrapper nonzero')
|
|
required={'exceptions','uid','gid','groups','supervisor_pid','supervisor_start','nonce','argv','cwd',
|
|
'deadline','leader_pid','leader_start','leader_pgid','real_rc','leader_reaped','timeout',
|
|
'controlled_rc','descendants_absent','pg_absent','tracked','remaining_descendants',
|
|
'remaining_pg','elapsed','stdout','stderr','request_length','request_sha256','input_length','input_sha256'}
|
|
if not isinstance(wire,dict) or set(wire)!=required:raise ValueError('wire fields')
|
|
for name in ('uid','gid'):
|
|
if not valid_int(wire[name],0):raise ValueError('identity type')
|
|
if not isinstance(wire['groups'],list) or any(not valid_int(g,0) for g in wire['groups']):
|
|
raise ValueError('groups type')
|
|
expected=(65534,65534,[]) if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534' else (os.getuid(),os.getgid(),os.getgroups())
|
|
if (wire['uid'],wire['gid'],wire['groups'])!=expected:raise ValueError('execution identity')
|
|
for name in ('supervisor_pid','supervisor_start','leader_pid','leader_start','leader_pgid'):
|
|
if not valid_int(wire[name],1):raise ValueError('PID/start type')
|
|
if wire['supervisor_pid']!=expected_pid or wire['supervisor_start']!=expected_start:
|
|
raise ValueError('Popen/supervisor binding')
|
|
if wire['supervisor_pid']==wire['leader_pid'] or wire['leader_pgid']!=wire['leader_pid']:
|
|
raise ValueError('leader/session identity')
|
|
if any(wire[name]!=request[name] for name in ('nonce','argv','cwd','deadline')):
|
|
raise ValueError('request binding')
|
|
for prefix,actual in [('request',raw_request),('input',base64.b64decode(request['input']))]:
|
|
if not valid_int(wire[prefix+'_length'],0) or wire[prefix+'_length']!=len(actual) or wire[prefix+'_sha256']!=hashlib.sha256(actual).hexdigest():
|
|
raise ValueError('inner raw request/input binding')
|
|
if type(wire['deadline']) is not int or wire['deadline']!=request['deadline']:
|
|
raise ValueError('deadline type')
|
|
elapsed=wire['elapsed']
|
|
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0<=elapsed<=request['deadline']+RECLAIM_MARGIN:
|
|
raise ValueError('elapsed type/range')
|
|
for name in ('timeout','leader_reaped','descendants_absent','pg_absent'):
|
|
if type(wire[name]) is not bool:raise ValueError('flag type')
|
|
if not valid_int(wire['real_rc']) or not valid_int(wire['controlled_rc']):
|
|
raise ValueError('returncode type')
|
|
if wire['controlled_rc']!=(124 if wire['timeout'] else wire['real_rc']):
|
|
raise ValueError('controlled returncode conflict')
|
|
if type(wire['exceptions']) is not list or wire['exceptions']:
|
|
raise ValueError('supervisor exception presence')
|
|
if not isinstance(wire['tracked'],dict) or any(not k.isascii() or not k.isdigit() or not valid_int(v,1) for k,v in wire['tracked'].items()):
|
|
raise ValueError('tracked type')
|
|
if wire['remaining_descendants']!={} or wire['remaining_pg']!={}:
|
|
raise ValueError('remaining process presence')
|
|
if not wire['leader_reaped'] or not wire['descendants_absent'] or not wire['pg_absent']:
|
|
raise ValueError('process absence unconfirmed')
|
|
out=unblob(wire['stdout']);err=unblob(wire['stderr'])
|
|
return out,err
|
|
|
|
|
|
def stage(name, argv, cwd, payload, evidence):
|
|
request={'nonce':uuid.uuid4().hex,'argv':argv,'cwd':cwd,'deadline':DEADLINES[name],
|
|
'input':base64.b64encode(payload).decode('ascii')}
|
|
raw_request=json.dumps(request,separators=(',',':'),sort_keys=True).encode('ascii')
|
|
wrapper_argv=[sys.executable,'-I','-c',SUPERVISOR]
|
|
record={'stage':name,'wrapper_argv':[sys.executable,'-I','-c',{'check_constant':'SUPERVISOR','sha256':hashlib.sha256(SUPERVISOR.encode()).hexdigest()}],'wrapper_cwd':'/',
|
|
'request':blob(raw_request),'wrapper_rc':None,'wire':None,'wrapper_stderr':None,
|
|
'inner_cleanup':'unknown','exceptions':[]}
|
|
evidence['stages'].append(record)
|
|
begun=time.monotonic()
|
|
process=None
|
|
try:
|
|
process=subprocess.Popen(wrapper_argv,cwd='/',stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
|
|
record['popen_pid']=process.pid
|
|
record['popen_start']=proc_token(process.pid)
|
|
if not valid_int(record['popen_start'],1):raise ValueError('observed Popen start missing')
|
|
try:
|
|
wire_raw,wrapper_err=process.communicate(raw_request,timeout=DEADLINES[name]+OUTER_MARGIN)
|
|
except subprocess.TimeoutExpired as error:
|
|
# Bos parent cannot kill another UID. Retain partial wire; never fabricate inner cleanup.
|
|
record.update(wire=blob(error.output or b''),wrapper_stderr=blob(error.stderr or b''),
|
|
wrapper_rc=None,outer_timeout=True,elapsed=time.monotonic()-begun)
|
|
raise RuntimeError('outer deadline; inner_cleanup=unknown')
|
|
# Save actual raw observation BEFORE JSON parsing/field validation.
|
|
record.update(wrapper_rc=process.returncode,wire=blob(wire_raw),wrapper_stderr=blob(wrapper_err),
|
|
outer_timeout=False,elapsed=time.monotonic()-begun)
|
|
parsed=json.loads(wire_raw)
|
|
result=verify_wire(parsed,request,process.pid,record['popen_start'],process.returncode,raw_request)
|
|
record['inner_cleanup']='confirmed'
|
|
if parsed['timeout'] or parsed['real_rc']!=0:
|
|
raise ValueError('controlled failure/timeout')
|
|
return result
|
|
except BaseException as error:
|
|
if process is not None and record['wire'] is None:
|
|
buffered=getattr(process,'_fileobj2output',{})
|
|
partial=getattr(error,'output',None) or b''.join(buffered.get(process.stdout,[]))
|
|
partial_err=getattr(error,'stderr',None) or b''.join(buffered.get(process.stderr,[]))
|
|
record.update(wire=blob(partial),wrapper_stderr=blob(partial_err),wrapper_rc=process.returncode,
|
|
elapsed=time.monotonic()-begun,outer_error=type(error).__name__,inner_cleanup='unknown')
|
|
record['exceptions'].append(type(error).__name__+':'+repr(error))
|
|
raise
|
|
|
|
|
|
def emit_evidence(evidence):
|
|
# Lossless wire codec: canonical JSON is recoverable byte for byte; raw IO may use an exact repeated block.
|
|
for record in evidence['stages']:
|
|
saved=record.get('wire')
|
|
if not saved or 'latin1' not in saved:
|
|
continue
|
|
captured=saved['latin1'].encode('latin1')
|
|
try:
|
|
obj=json.loads(captured)
|
|
if json.dumps(obj,separators=(',',':'),sort_keys=True).encode('ascii')!=captured:
|
|
continue
|
|
for channel in ('stdout','stderr'):
|
|
io=obj[channel]
|
|
payload=base64.b64decode(io['bytes'],validate=True)
|
|
if len(payload)>=256 and len(payload)%256==0 and payload==payload[:256]*(len(payload)//256):
|
|
io['capture']={'repeat':len(payload)//256,'block':payload[:256].decode('latin1')}
|
|
else:
|
|
io['capture']={'latin1':payload.decode('latin1')}
|
|
del io['bytes']
|
|
saved.update(encoding='canonical-json-io',object=obj)
|
|
del saved['latin1']
|
|
except (ValueError,KeyError,TypeError):
|
|
pass
|
|
raw=json.dumps(evidence,separators=(',',':'),sort_keys=True).encode('ascii')
|
|
packed=lzma.compress(raw,preset=6)
|
|
text=base64.b85encode(packed).decode('ascii')
|
|
sys.stderr.write('RRA1 '+text+'\n')
|
|
|
|
|
|
def main(candidate):
|
|
evidence={'schema':'resource-array-allocation/1','stages':[],'exceptions':[],
|
|
'check_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest()}
|
|
scratch=None
|
|
success=False
|
|
cleanup_ok=False
|
|
absence_ok=False
|
|
try:
|
|
scratch=tempfile.mkdtemp(prefix='rra-')
|
|
evidence['scratch']=scratch
|
|
# Bos's mkdtemp hook has already handed this only directory to the candidate identity.
|
|
source={name:source_bytes(candidate,name) for name in CANDIDATES}
|
|
source.update({'array_report.h':HEADER.encode(),'observer.c':OBSERVER.encode()})
|
|
cases=scenarios()
|
|
input_raw=(''.join(' '.join(map(str,row))+'\n' for row in cases)).encode('ascii')
|
|
expected=[oracle(row) for row in cases]
|
|
for name,raw in source.items():
|
|
Path(scratch,name).write_bytes(raw)
|
|
compile_argv=['gcc','-std=c11','-O2','-Wall','-Wextra',*CANDIDATES,'observer.c','-o','app']
|
|
stage('compiler',compile_argv,scratch,b'',evidence)
|
|
output,diagnostic=stage('candidate',[scratch+'/app'],scratch,input_raw,evidence)
|
|
observed=observations(output)
|
|
if observed!=expected:
|
|
first=next((i for i,(a,b) in enumerate(zip(observed,expected)) if a!=b),min(len(observed),len(expected)))
|
|
evidence['first_difference']={'row':first,'actual':observed[first] if first<len(observed) else None,
|
|
'expected':expected[first] if first<len(expected) else None}
|
|
raise ValueError('normal-exit observation mismatch')
|
|
evidence['observations']=len(observed)
|
|
success=True
|
|
except BaseException as error:
|
|
evidence['exceptions'].append(type(error).__name__+':'+repr(error))
|
|
finally:
|
|
if scratch is not None:
|
|
try:
|
|
cleaned,_=stage('cleanup',[sys.executable,'-I','-c',CLEANUP,scratch],'/',b'',evidence)
|
|
cleanup_ok=cleaned==b'0\n'
|
|
if not cleanup_ok:raise ValueError('cleanup output')
|
|
except BaseException as error:
|
|
evidence['exceptions'].append('cleanup:'+type(error).__name__+':'+repr(error))
|
|
try:
|
|
absent,_=stage('absence',[sys.executable,'-I','-c',ABSENCE,scratch],'/',b'',evidence)
|
|
absence_ok=absent==b'0\n'
|
|
if not absence_ok:raise ValueError('scratch remains')
|
|
except BaseException as error:
|
|
evidence['exceptions'].append('absence:'+type(error).__name__+':'+repr(error))
|
|
evidence.update(success=success,cleanup_ok=cleanup_ok,absence_ok=absence_ok)
|
|
emit_evidence(evidence)
|
|
if success and cleanup_ok and absence_ok and not evidence['exceptions'] and all(not s['exceptions'] for s in evidence['stages']):
|
|
print('PASS')
|
|
return 0
|
|
print('FAIL resource report, execution or cleanup')
|
|
return 1
|
|
|
|
|
|
if __name__=='__main__':
|
|
sys.exit(main(sys.argv[1]))
|