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>
349 lines
30 KiB
Python
349 lines
30 KiB
Python
SUPERVISOR = "import base64\nimport ctypes\nimport hashlib\nimport json\nimport os\nimport selectors\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 tail = raw[raw.rfind(b')') + 2:].split()\n return {'pid': pid, 'state': tail[0].decode('ascii'),\n 'ppid': int(tail[1]), 'start': int(tail[19])}\n\n\ndef live(row):\n return row is not None and row['state'] not in ('Z', 'X')\n\n\ndef closure(table, supervisor, tracked):\n # Only this live supervisor or still-live, same-start tokens authorize roots.\n roots = {supervisor}\n roots.update(pid for pid, start in tracked.items()\n if live(table.get(pid)) and table[pid]['start'] == start)\n result = set()\n changed = True\n while changed:\n changed = False\n for pid, row in table.items():\n if pid != supervisor and (pid in roots or row['ppid'] in roots):\n if pid not in result:\n result.add(pid)\n roots.add(pid)\n changed = True\n return {pid: table[pid]['start'] for pid in result}\n\n\ndef proc_table(errors):\n table = {}\n try:\n names = os.listdir('/proc')\n except Exception as error:\n errors.append(['listproc', type(error).__name__, str(error)])\n return table\n for name in names:\n if not name.isascii() or not name.isdigit():\n continue\n try:\n row = read_stat(int(name))\n if row is not None:\n table[row['pid']] = row\n except Exception as error:\n errors.append(['stat', name, type(error).__name__, str(error)])\n return table\n\n\ndef send_kill(pid, start, errors):\n # Fresh stat is required immediately before every signal.\n try:\n current = read_stat(pid)\n if live(current) and current['start'] == start:\n try:\n os.kill(pid, signal.SIGKILL)\n except ProcessLookupError:\n pass\n except Exception as error:\n errors.append(['signal', pid, type(error).__name__, str(error)])\n\n\ndef reap_adopted(proc, errors):\n # poll/wait always owns the leader status before waitpid can reap adoptees.\n if proc.poll() is None:\n return\n try:\n while True:\n pid, status = os.waitpid(-1, os.WNOHANG)\n if pid == 0:\n break\n except ChildProcessError:\n pass\n except Exception as error:\n errors.append(['reap', type(error).__name__, str(error)])\n\n\ndef supervise(request):\n beginning = time.monotonic()\n errors = []\n nonce = request['nonce']\n argv = request['argv']\n deadline = request['deadline']\n result = dict(nonce=nonce, argv=argv, deadline=deadline,\n supervisor_pid=os.getpid(), uid=os.geteuid(), gid=os.getegid(),\n groups=os.getgroups(), leader_pid=None, leader_start=None,\n leader_rc=None, controlled_rc=None, leader_reaped=False,\n timeout=False, descendants_absent=False, remaining=[],\n exceptions=errors, elapsed=0, stdout_len=0, stderr_len=0,\n stdout_sha256=hashlib.sha256(b'').hexdigest(),\n stderr_sha256=hashlib.sha256(b'').hexdigest())\n output = bytearray()\n diagnostic = bytearray()\n proc = None\n tracked = {}\n selector = selectors.DefaultSelector()\n try:\n library = ctypes.CDLL(None, use_errno=True)\n if library.prctl(36, 1, 0, 0, 0) != 0:\n raise OSError(ctypes.get_errno(), 'PR_SET_CHILD_SUBREAPER')\n proc = subprocess.Popen(argv, cwd=request['cwd'], stdin=subprocess.PIPE,\n stdout=subprocess.PIPE, stderr=subprocess.PIPE,\n start_new_session=True)\n row = read_stat(proc.pid)\n if row is None:\n raise RuntimeError('leader identity unavailable')\n result.update(leader_pid=proc.pid, leader_start=row['start'])\n tracked[proc.pid] = row['start']\n payload = memoryview(base64.b64decode(request['input']))\n for stream, role in ((proc.stdout, 'out'), (proc.stderr, 'err')):\n os.set_blocking(stream.fileno(), False)\n selector.register(stream, selectors.EVENT_READ, role)\n os.set_blocking(proc.stdin.fileno(), False)\n if payload:\n selector.register(proc.stdin, selectors.EVENT_WRITE, 'in')\n else:\n proc.stdin.close()\n input_at = 0\n expiry = beginning + deadline\n finishing = False\n recovery = None\n while True:\n leader_rc = proc.poll()\n table = proc_table(errors)\n found = closure(table, os.getpid(), tracked)\n tracked.update(found)\n if not finishing and leader_rc is not None:\n finishing = True\n recovery = time.monotonic() + 2.0\n if not finishing and time.monotonic() >= expiry:\n result['timeout'] = True\n finishing = True\n recovery = time.monotonic() + 2.0\n if finishing:\n for pid, start in found.items():\n send_kill(pid, start, errors)\n reap_adopted(proc, errors)\n for key, flags in selector.select(0.01):\n if key.data == 'in':\n try:\n written = os.write(key.fd, payload[input_at:input_at+65536])\n input_at += written\n except BrokenPipeError:\n input_at = len(payload)\n if input_at == len(payload):\n selector.unregister(key.fileobj)\n key.fileobj.close()\n else:\n try:\n block = os.read(key.fd, 65536)\n except BlockingIOError:\n continue\n if block:\n (output if key.data == 'out' else diagnostic).extend(block)\n else:\n selector.unregister(key.fileobj)\n key.fileobj.close()\n if finishing:\n table = proc_table(errors)\n remaining = closure(table, os.getpid(), tracked)\n proc.poll()\n reap_adopted(proc, errors)\n if not remaining and proc.returncode is not None and not selector.get_map():\n break\n if time.monotonic() >= recovery:\n errors.append(['recovery', 'descendants or pipes remain'])\n break\n result['leader_rc'] = proc.poll()\n result['leader_reaped'] = proc.returncode is not None\n table = proc_table(errors)\n remaining = closure(table, os.getpid(), tracked)\n result['remaining'] = [[pid, start] for pid, start in sorted(remaining.items())]\n result['descendants_absent'] = not remaining\n result['controlled_rc'] = 124 if result['timeout'] else result['leader_rc']\n except Exception as error:\n errors.append(['supervision', type(error).__name__, str(error)])\n finally:\n if proc is not None:\n # Exceptions still take the bounded same-identity reclamation path.\n end = time.monotonic() + 2.0\n while time.monotonic() < end:\n proc.poll()\n table = proc_table(errors)\n remaining = closure(table, os.getpid(), tracked)\n for pid, start in remaining.items():\n send_kill(pid, start, errors)\n reap_adopted(proc, errors)\n if not remaining and proc.returncode is not None:\n break\n time.sleep(0.01)\n result['leader_rc'] = proc.poll()\n result['leader_reaped'] = proc.returncode is not None\n table = proc_table(errors)\n remaining = closure(table, os.getpid(), tracked)\n result['remaining'] = [[pid, start] for pid, start in sorted(remaining.items())]\n result['descendants_absent'] = not remaining\n result['controlled_rc'] = 124 if result['timeout'] else result['leader_rc']\n selector.close()\n result['elapsed'] = time.monotonic() - beginning\n for name, data in (('stdout', output), ('stderr', diagnostic)):\n result[name] = base64.b64encode(data).decode('ascii')\n result[name+'_len'] = len(data)\n result[name+'_sha256'] = hashlib.sha256(data).hexdigest()\n return result\n\n\nif __name__ == '__main__':\n request = json.loads(sys.stdin.buffer.read())\n print(json.dumps(supervise(request), separators=(',', ':')))\n"
|
|
CONTEXT = {'console.cpp': '#include "watch.hpp"\n#include <iostream>\n#include <sstream>\n#include <string>\n#include <vector>\nnamespace {\nvoid events(int status, const std::vector<watch::Event>& output)\n{\n std::cout << status << \' \' << output.size();\n for (const auto& item : output) {\n std::cout << \' \' << item.wd << \' \' << item.key << \' \'\n << item.mask << \' \' << item.cookie;\n }\n std::cout << \'\\n\';\n}\nint nibble(char value)\n{\n if (value >= \'0\' && value <= \'9\') return value - \'0\';\n if (value >= \'a\' && value <= \'f\') return value - \'a\' + 10;\n if (value >= \'A\' && value <= \'F\') return value - \'A\' + 10;\n return -1;\n}\nbool unhex(const std::string& value, std::string& output)\n{\n if (value == "-") return true;\n if (value.size() % 2) return false;\n for (std::size_t at = 0; at < value.size(); at += 2) {\n int high = nibble(value[at]);\n int low = nibble(value[at + 1]);\n if (high < 0 || low < 0) return false;\n output.push_back(static_cast<char>(high * 16 + low));\n }\n return true;\n}\nvoid configuration(int status, const std::vector<watch::Request>& output)\n{\n std::cout << status << \' \' << output.size();\n for (const auto& item : output) {\n std::cout << \' \' << item.key << \' \' << item.mask;\n }\n std::cout << \'\\n\';\n}\n}\nint main()\n{\n watch::Port port;\n watch::Service service(port);\n std::string line;\n while (std::getline(std::cin, line)) {\n std::istringstream input(line);\n std::string op;\n if (!(input >> op)) continue;\n int fd = 0;\n int key = 0;\n int wd = 0;\n unsigned mask = 0;\n std::uint64_t cookie = 0;\n std::size_t count = 0;\n if (op == "L" && input >> count) {\n std::vector<watch::Request> requests;\n if (count > 17) return 2;\n for (std::size_t index = 0; index < count; ++index) {\n if (!(input >> key >> mask)) return 2;\n requests.push_back(watch::Request{key, mask});\n }\n std::cout << service.reload(requests) << \'\\n\';\n } else if (op == "S") {\n std::cout << service.stop() << \'\\n\';\n } else if (op == "A") {\n std::cout << service.active() << \'\\n\';\n } else if (op == "C") {\n configuration(0, service.configuration());\n } else if (op == "O") {\n std::cout << port.open() << \'\\n\';\n } else if (op == "X" && input >> fd) {\n std::cout << port.close(fd) << \'\\n\';\n } else if (op == "+" && input >> fd >> key >> mask) {\n std::cout << port.add(fd, key, mask) << \'\\n\';\n } else if (op == "-" && input >> fd >> wd) {\n std::cout << port.remove(fd, wd) << \'\\n\';\n } else if (op == "E" && input >> key >> mask >> cookie) {\n std::cout << port.emit(key, mask, cookie) << \'\\n\';\n } else if (op == "R" && input >> count) {\n std::vector<watch::Event> output{{-77, -77, 77, 77}};\n const int rc = service.read(count, output);\n events(rc, output);\n } else if (op == "D" && input >> fd >> count) {\n std::vector<watch::Event> output{{-77, -77, 77, 77}};\n const int rc = port.read(fd, count, output);\n events(rc, output);\n } else if (op == "I" && input >> fd) {\n std::vector<watch::Watch> output{{-77, -77, 77}};\n const int rc = port.inspect(fd, output);\n std::cout << rc << \' \' << output.size();\n for (const auto& item : output) {\n std::cout << \' \' << item.wd << \' \' << item.key << \' \' << item.mask;\n }\n std::cout << \'\\n\';\n } else if (op == "K") {\n const auto value = port.counts();\n std::cout << value.instances << \' \' << value.watches << \' \'\n << value.queued << \' \' << value.opened << \' \'\n << value.closed << \' \' << value.delivered << \'\\n\';\n } else if (op == "P" && input >> op) {\n std::string text;\n if (!unhex(op, text)) return 2;\n std::vector<watch::Request> output{{77, 7}};\n const int rc = watch::parse_configuration(text, output);\n configuration(rc, output);\n } else if (op == "Z") {\n service.stop();\n port.reset();\n service.forget();\n std::cout << 0 << \'\\n\';\n } else {\n return 2;\n }\n }\n return std::cin.bad() ? 2 : 0;\n}\n'}
|
|
CANDIDATES = ['watch.hpp', 'port.cpp', 'service.cpp', 'config.cpp']
|
|
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 time
|
|
import uuid
|
|
import zlib
|
|
|
|
DEADLINES = {'compiler': 15.0, 'candidate': 8.0, 'cleanup': 5.0, 'absence': 5.0}
|
|
EVIDENCE = []
|
|
EXCEPTIONS = []
|
|
|
|
|
|
def execute(stage, argv, cwd, data=b''):
|
|
request = dict(nonce=uuid.uuid4().hex, argv=argv, cwd=str(cwd),
|
|
input=base64.b64encode(data).decode('ascii'), deadline=DEADLINES[stage])
|
|
proc = subprocess.Popen([sys.executable, '-I', '-c', SUPERVISOR],
|
|
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
wire, wrapper_stderr = proc.communicate(json.dumps(request).encode('ascii'))
|
|
# Record observed wrapper facts before parsing any untrusted/missing wire.
|
|
evidence = dict(stage=stage, wrapper_rc=proc.returncode, wire_len=len(wire),
|
|
wire_sha256=hashlib.sha256(wire).hexdigest(),
|
|
wrapper_stderr_len=len(wrapper_stderr),
|
|
wrapper_stderr_sha256=hashlib.sha256(wrapper_stderr).hexdigest(),
|
|
wrapper_argv_sha256=hashlib.sha256(json.dumps(proc.args).encode()).hexdigest(),
|
|
request=request.copy())
|
|
evidence['request'].pop('input')
|
|
evidence['input_len'] = len(data)
|
|
evidence['input_sha256'] = hashlib.sha256(data).hexdigest()
|
|
EVIDENCE.append(evidence)
|
|
if proc.returncode != 0 or wrapper_stderr:
|
|
raise RuntimeError(stage + ': supervisor exit')
|
|
result = json.loads(wire)
|
|
required = {'nonce','argv','deadline','supervisor_pid','uid','gid','groups','leader_pid',
|
|
'leader_start','leader_rc','controlled_rc','leader_reaped','timeout',
|
|
'descendants_absent','remaining','exceptions','elapsed','stdout','stderr',
|
|
'stdout_len','stderr_len','stdout_sha256','stderr_sha256'}
|
|
if type(result) is not dict or set(result) != required:
|
|
raise ValueError(stage + ': metadata fields')
|
|
evidence['metadata'] = {key:value for key,value in result.items() if key not in ('stdout','stderr')}
|
|
isolated = os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534'
|
|
wanted_uid = 65534 if isolated else os.geteuid()
|
|
wanted_gid = 65534 if isolated else os.getegid()
|
|
wanted_groups = [] if isolated else os.getgroups()
|
|
if result['nonce'] != request['nonce'] or result['argv'] != argv:
|
|
raise ValueError(stage + ': request binding')
|
|
if type(result['deadline']) not in (int,float) or result['deadline'] != request['deadline']:
|
|
raise ValueError(stage + ': deadline binding')
|
|
for key in ('uid','gid'):
|
|
if type(result[key]) is not int:
|
|
raise ValueError(stage + ': identity type')
|
|
if result['uid'] != wanted_uid or result['gid'] != wanted_gid:
|
|
raise ValueError(stage + ': identity')
|
|
if (type(result['groups']) is not list or any(type(x) is not int for x in result['groups'])
|
|
or result['groups'] != wanted_groups):
|
|
raise ValueError(stage + ': groups')
|
|
for key in ('supervisor_pid','leader_pid','leader_start'):
|
|
if type(result[key]) is not int or result[key] <= 0:
|
|
raise ValueError(stage + ': process identity')
|
|
if result['leader_pid'] == result['supervisor_pid']:
|
|
raise ValueError(stage + ': identical processes')
|
|
elapsed = result['elapsed']
|
|
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0 <= elapsed <= request['deadline'] + 5:
|
|
raise ValueError(stage + ': elapsed')
|
|
for key in ('timeout','leader_reaped','descendants_absent'):
|
|
if type(result[key]) is not bool:
|
|
raise ValueError(stage + ': boolean')
|
|
for key in ('leader_rc','controlled_rc'):
|
|
if type(result[key]) is not int:
|
|
raise ValueError(stage + ': returncode')
|
|
if result['controlled_rc'] != (124 if result['timeout'] else result['leader_rc']):
|
|
raise ValueError(stage + ': returncode conflict')
|
|
if result['timeout'] and result['leader_rc'] == 0:
|
|
raise ValueError(stage + ': timeout/leader conflict')
|
|
if type(result['exceptions']) is not list or type(result['remaining']) is not list:
|
|
raise ValueError(stage + ': collection types')
|
|
if result['exceptions'] or result['remaining'] or not result['descendants_absent'] or not result['leader_reaped']:
|
|
raise ValueError(stage + ': reclamation or exceptions')
|
|
streams = {}
|
|
for key in ('stdout','stderr'):
|
|
if type(result[key+'_len']) is not int or result[key+'_len'] < 0:
|
|
raise ValueError(stage + ': IO length')
|
|
blob = base64.b64decode(result[key], validate=True)
|
|
if len(blob) != result[key+'_len'] or hashlib.sha256(blob).hexdigest() != result[key+'_sha256']:
|
|
raise ValueError(stage + ': IO binding')
|
|
streams[key] = blob
|
|
if result['controlled_rc'] != 0:
|
|
evidence[key+'_tail_utf8_replace'] = blob[-400:].decode('utf-8','replace')
|
|
if result['timeout'] or result['controlled_rc'] != 0:
|
|
raise RuntimeError(stage + ': controlled exit ' + str(result['controlled_rc']))
|
|
return streams['stdout'], streams['stderr']
|
|
|
|
|
|
class Model:
|
|
def __init__(self):
|
|
self.objects = {}
|
|
self.active = -1
|
|
self.config = []
|
|
self.opened = self.closed = self.delivered = 0
|
|
|
|
def counts(self):
|
|
return [len(self.objects), sum(len(x['w']) for x in self.objects.values()),
|
|
sum(len(x['q']) for x in self.objects.values()), self.opened, self.closed, self.delivered]
|
|
|
|
def open(self):
|
|
for fd in range(3,11):
|
|
if fd not in self.objects:
|
|
self.objects[fd] = {'w':{},'q':[],'next':1}
|
|
self.opened += 1
|
|
return fd
|
|
return -24
|
|
|
|
def close(self,fd):
|
|
if fd not in self.objects: return -9
|
|
del self.objects[fd]
|
|
self.closed += 1
|
|
return 0
|
|
|
|
def add(self,fd,key,mask):
|
|
if fd not in self.objects: return -9
|
|
if not 1 <= key <= 1000000 or not 1 <= mask <= 7: return -22
|
|
obj = self.objects[fd]
|
|
for wd,value in obj['w'].items():
|
|
if value[0] == key:
|
|
obj['w'][wd] = (key,mask)
|
|
return wd
|
|
if self.counts()[1] == 32: return -28
|
|
wd = obj['next'];obj['next'] += 1
|
|
obj['w'][wd] = (key,mask)
|
|
return wd
|
|
|
|
def remove(self,fd,wd):
|
|
if fd not in self.objects: return -9
|
|
if wd not in self.objects[fd]['w']: return -2
|
|
del self.objects[fd]['w'][wd]
|
|
return 0
|
|
|
|
def emit(self,key,mask,cookie):
|
|
if not 1 <= key <= 1000000 or not 1 <= mask <= 7: return -22
|
|
deliveries=[]
|
|
for fd,obj in sorted(self.objects.items()):
|
|
for wd,(watched,selected) in sorted(obj['w'].items()):
|
|
if key == watched and mask & selected:
|
|
if len(obj['q']) == 64:return -28
|
|
deliveries.append((fd,[wd,key,mask & selected,cookie]))
|
|
for fd,event in deliveries:self.objects[fd]['q'].append(event)
|
|
return len(deliveries)
|
|
|
|
def read(self,fd,capacity):
|
|
if fd not in self.objects:return [-9,1,-77,-77,77,77]
|
|
if capacity > 64:return [-22,1,-77,-77,77,77]
|
|
obj=self.objects[fd];events=obj['q'][:capacity];del obj['q'][:capacity]
|
|
self.delivered += len(events)
|
|
return [len(events),len(events)]+[x for e in events for x in e]
|
|
|
|
def reload(self,requests):
|
|
if len(requests)>16:return -22
|
|
fd=self.open()
|
|
if fd<0:return fd
|
|
for key,mask in requests:
|
|
status=self.add(fd,key,mask)
|
|
if status<0:
|
|
self.close(fd)
|
|
return status
|
|
if self.active>=0:self.close(self.active)
|
|
self.active=fd
|
|
keys=[];values={}
|
|
for key,mask in requests:
|
|
if key not in values:keys.append(key)
|
|
values[key]=mask
|
|
self.config=[[key,values[key]] for key in keys]
|
|
return 0
|
|
|
|
def stop(self):
|
|
if self.active>=0:self.close(self.active)
|
|
self.active=-1;self.config=[]
|
|
return 0
|
|
|
|
|
|
def parse_config(text):
|
|
if len(text)>4096:return [-22,1,77,7]
|
|
result=[]
|
|
for line in text.split(b'\n'):
|
|
line=line.split(b'#',1)[0].strip(b' \t\r')
|
|
if not line:continue
|
|
parts=line.split(b':')
|
|
if len(parts)!=2:return [-22,1,77,7]
|
|
values=[]
|
|
for part in parts:
|
|
part=part.strip(b' \t\r')
|
|
if re.fullmatch(rb'[0-9]+',part) is None:return [-22,1,77,7]
|
|
significant=part.lstrip(b'0') or b'0'
|
|
if len(significant)>10:return [-22,1,77,7]
|
|
values.append(int(significant))
|
|
if not 1<=values[0]<=1000000 or not 1<=values[1]<=7 or len(result)==16:return [-22,1,77,7]
|
|
result.append(values)
|
|
return [0,len(result)]+[x for row in result for x in row]
|
|
|
|
|
|
class Suite:
|
|
def __init__(self):self.model=Model();self.commands=[];self.expected=[];self.labels=[]
|
|
def add(self,command,label):
|
|
m=self.model;words=command.split(' ');op=words[0];args=words[1:]
|
|
v=list(map(int,args)) if op!='P' else []
|
|
if op=='L':out=[m.reload(list(zip(v[1::2],v[2::2]))) ]
|
|
elif op=='S':out=[m.stop()]
|
|
elif op=='A':out=[m.active]
|
|
elif op=='C':out=[0,len(m.config)]+[x for row in m.config for x in row]
|
|
elif op=='O':out=[m.open()]
|
|
elif op=='X':out=[m.close(*v)]
|
|
elif op=='+':out=[m.add(*v)]
|
|
elif op=='-':out=[m.remove(*v)]
|
|
elif op=='E':out=[m.emit(*v)]
|
|
elif op=='R':out=m.read(m.active,*v)
|
|
elif op=='D':out=m.read(*v)
|
|
elif op=='I':
|
|
if v[0] not in m.objects:out=[-9,1,-77,-77,77]
|
|
else:
|
|
rows=[[wd,*value] for wd,value in sorted(m.objects[v[0]]['w'].items())]
|
|
out=[len(rows),len(rows)]+[x for row in rows for x in row]
|
|
elif op=='K':out=m.counts()
|
|
elif op=='P':out=parse_config(bytes.fromhex(args[0]) if args[0]!='-' else b'')
|
|
elif op=='Z':self.model=Model();out=[0]
|
|
else:raise ValueError(op)
|
|
self.commands.append(command);self.expected.append(out);self.labels.append(label)
|
|
|
|
|
|
def cases():
|
|
s=Suite();c=s.add;rng=random.Random(0x99c105e)
|
|
c('K','empty-counts');c('A','no-active');c('R 0','badfd-read');c('C','empty-configuration')
|
|
c('L 2 10 3 20 4','demo-load');c('E 10 1 123','demo-delivery');c('R 64','demo-read')
|
|
c('L 1 30 7','demo-reload');c('K','success-release');c('S','stop');c('K','stop-counts')
|
|
c('Z','reset');c('L 1 41 7','rollback-current');c('E 41 7 456','rollback-pending')
|
|
for _ in range(12):
|
|
c('L 3 50 3 0 2 60 1','rollback-invalid-later');c('K','rollback-resources');c('A','rollback-current-fd')
|
|
c('C','rollback-configuration');c('R 64','rollback-pending-preserved')
|
|
for index in range(30):
|
|
c(f'L 4 {100+index} 1 {200+index} 7 {100+index} 4 {300+index} 2','cycle-duplicates')
|
|
c('C','normalized-order');c(f'E {100+index} 5 {rng.getrandbits(64)}','mask-intersection');c('R 0','zero-capacity');c('R 1','partial-read');c('K','cycle-counts')
|
|
c('Z','reset');c('L 16 '+' '.join('1 7' for _ in range(16)),'max-repeated-requests');c('C','one-normalized-key')
|
|
c('L 17 '+' '.join('1 7' for _ in range(17)),'max-plus-one');c('K','oversize-no-open')
|
|
c('L 0','empty-reload');c('C','empty-committed');c('S','stop');c('S','stop-twice')
|
|
c('Z','reset')
|
|
for _ in range(8):c('O','all-fd-slots')
|
|
c('O','fd-limit');c('L 0','reload-no-fd');c('X 6','free-middle');c('O','lowest-reuse');c('X -1','bad-close')
|
|
for key in range(1,33):c(f'+ 3 {key} 7','watch-limit-fill')
|
|
c('+ 4 900 1','watch-limit');c('+ 3 1 2','update-at-limit');c('- 3 1','remove');c('+ 4 900 1','after-remove');c('I 3','wd-order');c('I 4','per-instance-wd')
|
|
c('Z','reset');c('O','queue-instance');c('O','second-instance');c('+ 3 99 7','first-watch');c('+ 4 99 3','second-watch')
|
|
for index in range(64):c(f'E 99 7 {index}','queue-fill')
|
|
c('D 4 64','drain-second');c('E 99 1 999','atomic-overflow');c('K','overflow-did-not-partially-deliver');c('D 4 64','second-stays-empty')
|
|
c('- 3 1','remove-preserves-queued');c('D 3 65','read-error-unchanged');c('D 3 64','queued-after-remove');c('D 3 0','empty-zero-read')
|
|
for command in ('+ 99 0 0','+ 3 0 7','+ 3 1 8','- 3 999','- 99 1','I 99','D 99 65','E 0 1 0','E 1 8 0'):
|
|
c(command,'error-precedence')
|
|
c('Z','reset');c('O','quota-peer');c('O','quota-peer2')
|
|
for key in range(1,25):c(f'+ 3 {key} 7','global-quota')
|
|
c('L 9 '+' '.join(f'{500+i} 1' for i in range(9)),'prepare-watch-quota-failure');c('K','quota-rollback');c('L 8 '+' '.join(f'{500+i} 1' for i in range(8)),'exact-global-watch-limit');c('K','exact-global-counts')
|
|
c('Z','reset')
|
|
for _ in range(200):
|
|
choice=rng.randrange(8)
|
|
if choice<3:
|
|
n=rng.randrange(0,17);requests=[(rng.randrange(1,8),rng.randrange(1,8)) for _ in range(n)]
|
|
if rng.randrange(6)==0 and requests:requests[-1]=(1000001,1)
|
|
c('L '+str(n)+''.join(f' {key} {mask}' for key,mask in requests),'random-reload')
|
|
elif choice==3:c(f'E {rng.randrange(1,8)} {rng.randrange(1,8)} {rng.getrandbits(64)}','random-event')
|
|
elif choice==4:c(f'R {rng.choice([0,1,3,64,65])}','random-read')
|
|
elif choice==5:c('S','random-stop')
|
|
elif choice==6:c('C','random-config')
|
|
else:c('K','random-ledger')
|
|
texts=[b'',b'# empty\n',b'1:1\n1000000:7\n',b' 00001 : 0007\r\n1:2 #last\n',b'1:1\v',b'1:1\f',b'+1:1',b'1_0:1',b'1:8',b'0:1',b'1:1:2',b'1:\x001',b'4294967296:1',b'9'*4097,b'0'*4000+b'1:1',b'1:1\n'*16,b'1:1\n'*17]
|
|
for text in texts:c('P '+(text.hex() or '-'),'configuration-parser')
|
|
c('Z','final-reset');c('K','final-counts')
|
|
return s
|
|
|
|
|
|
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 not row or not tokens:raise ValueError('empty stdout row')
|
|
values=[]
|
|
for token in tokens:
|
|
if re.fullmatch(rb'[+-]?[0-9]+',token) is None:raise ValueError('non-ASCII decimal')
|
|
negative=token.startswith(b'-');digits=token.lstrip(b'+-').lstrip(b'0') or b'0'
|
|
if len(digits)>20:raise ValueError('observable integer range')
|
|
value=int(digits)*(-1 if negative else 1)
|
|
if not -77<=value<=2**64-1:raise ValueError('observable integer range')
|
|
values.append(value)
|
|
result.append(values)
|
|
return result
|
|
|
|
|
|
def main():
|
|
scratch=None;passed=False;failure=None
|
|
try:
|
|
scratch=Path(tempfile.mkdtemp(prefix='resource-watch-'))
|
|
# All candidate-owned material is prepared before the first child.
|
|
work=scratch/'work';work.mkdir(mode=0o777);work.chmod(0o777)
|
|
for name in CANDIDATES:
|
|
(work/name).write_bytes((Path(sys.argv[1])/name).read_bytes())
|
|
for name,text in CONTEXT.items():(work/name).write_text(text)
|
|
for path in work.iterdir():path.chmod(0o666)
|
|
suite=cases();payload=('\n'.join(suite.commands)+'\n').encode('ascii')
|
|
execute('compiler',['g++','-std=c++17','-O2','-Wall','-Wextra','-pedantic','port.cpp','service.cpp','config.cpp','console.cpp','-o','console'],work)
|
|
raw,_=execute('candidate',[str(work/'console')],work,payload)
|
|
actual=observations(raw)
|
|
if actual!=suite.expected:
|
|
index=next((i for i,(a,b) in enumerate(zip(actual,suite.expected)) if a!=b),min(len(actual),len(suite.expected)))
|
|
failure='raw mismatch row='+str(index)+' label='+(suite.labels[index] if index<len(suite.labels) else 'extra')
|
|
else:passed=True
|
|
except Exception as error:
|
|
EXCEPTIONS.append([type(error).__name__,str(error)])
|
|
failure='execution '+type(error).__name__+': '+str(error)
|
|
finally:
|
|
if scratch is not None:
|
|
try:
|
|
execute('cleanup',[sys.executable,'-I','-c','import shutil,sys; shutil.rmtree(sys.argv[1])',str(scratch)],'/tmp')
|
|
except Exception as error:
|
|
EXCEPTIONS.append(['cleanup',type(error).__name__,str(error)])
|
|
failure='cleanup '+type(error).__name__+': '+str(error)
|
|
try:
|
|
absent,_=execute('absence',[sys.executable,'-I','-c',
|
|
'import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: print(0)\nelse: print(1)',str(scratch)],'/tmp')
|
|
if absent!=b'0\n':raise RuntimeError('scratch remains')
|
|
except Exception as error:
|
|
EXCEPTIONS.append(['absence',type(error).__name__,str(error)])
|
|
failure='absence '+type(error).__name__+': '+str(error)
|
|
facts=dict(stages=EVIDENCE,exceptions=EXCEPTIONS,rows=len(suite.expected) if 'suite' in locals() else 0,
|
|
passed=bool(passed and not failure and not EXCEPTIONS))
|
|
encoded=base64.b85encode(zlib.compress(json.dumps(facts,separators=(',',':')).encode(),9)).decode()
|
|
sys.stderr.write('RESOURCE_META_Z85 '+encoded+'\n')
|
|
print('PASS' if facts['passed'] else 'FAIL '+str(failure))
|
|
return 0 if facts['passed'] else 1
|
|
|
|
|
|
if __name__=='__main__':sys.exit(main())
|