amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
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>
2026-10-27 01:55:56 +08:00

309 lines
29 KiB
Python

CONTEXT = {'observer.cpp': '#include "lifecycle.hpp"\n#include <iostream>\n#include <limits>\n#include <sstream>\n#include <string>\n#include <vector>\n\nnamespace {\nstd::vector<std::string> words(const std::string& line)\n{\n std::vector<std::string> result;\n std::string token;\n for (char value : line)\n {\n if (value == \' \' || value == \'\\t\' || value == \'\\r\')\n {\n if (!token.empty())\n {\n result.push_back(token);\n token.clear();\n }\n }\n else\n {\n token.push_back(value);\n }\n }\n if (!token.empty())\n {\n result.push_back(token);\n }\n return result;\n}\nbool number(const std::string& text, int& result)\n{\n std::size_t at = 0;\n bool negative = false;\n if (!text.empty() && (text[0] == \'+\' || text[0] == \'-\'))\n {\n negative = text[0] == \'-\';\n ++at;\n }\n if (at == text.size())\n {\n return false;\n }\n std::uint64_t value = 0;\n const std::uint64_t limit = negative ? 2147483648ULL : 2147483647ULL;\n for (; at < text.size(); ++at)\n {\n const char digit = text[at];\n if (digit < \'0\' || digit > \'9\')\n {\n return false;\n }\n value = value * 10 + static_cast<unsigned>(digit - \'0\');\n if (value > limit)\n {\n return false;\n }\n }\n result = negative ? static_cast<int>(-static_cast<std::int64_t>(value)) : static_cast<int>(value);\n return true;\n}\nvoid print(const std::vector<int>& values)\n{\n std::cout << \'[\';\n bool first = true;\n for (int value : values)\n {\n if (!first)\n {\n std::cout << \',\';\n }\n first = false;\n std::cout << value;\n }\n std::cout << "]\\n";\n}\nvoid print_view(const station::Station& station, int slot)\n{\n station::View value;\n const int status = station.inspect(slot, value);\n if (status != 0)\n {\n print({status});\n return;\n }\n std::vector<int> row{0, value.owner, value.state, value.subscriptions, value.device,\n value.shutdown_calls, value.cleanup_calls};\n row.insert(row.end(), value.tickets.begin(), value.tickets.end());\n print(row);\n}\nvoid print_port(const station::Port& port)\n{\n const auto entries = port.entries();\n std::vector<int> row{port.attempts(), port.next_ticket(), port.serial(),\n port.deliveries(), static_cast<int>(entries.size())};\n for (const auto& entry : entries)\n {\n row.push_back(entry.id);\n row.push_back(entry.owner);\n row.push_back(entry.kind);\n row.push_back(entry.index);\n row.push_back(entry.enabled);\n }\n print(row);\n}\nvoid print_events(const station::Port& port)\n{\n const auto& events = port.events();\n std::vector<int> row{static_cast<int>(events.size())};\n for (const auto& event : events)\n {\n row.push_back(event.serial);\n row.push_back(event.code);\n row.push_back(event.ticket);\n row.push_back(event.owner);\n row.push_back(event.kind);\n row.push_back(event.index);\n row.push_back(event.value);\n }\n print(row);\n}\nbool execute(station::Station& station, station::Port& port, const std::vector<std::string>& tokens)\n{\n const std::string& op = tokens[0];\n std::vector<int> args;\n for (std::size_t at = 1; at < tokens.size(); ++at)\n {\n int value;\n if (!number(tokens[at], value))\n {\n return false;\n }\n args.push_back(value);\n }\n int status;\n if (op == "NEW" && args.size() == 3)\n {\n status = station.create(args[0], args[1], args[2]);\n }\n else if (op == "FAIL" && args.size() == 1)\n {\n status = port.inject_failure(args[0]);\n }\n else if (op == "PUBLISH" && args.size() == 3)\n {\n status = port.publish(args[0], args[1], args[2]);\n }\n else if (op == "STATS" && args.size() == 1)\n {\n std::vector<int> values;\n const int rc = port.statistics(args[0], values);\n values.insert(values.begin(), rc);\n print(values);\n return true;\n }\n else if (op == "HISTORY" && args.size() == 2)\n {\n std::vector<station::Event> events;\n const int rc = port.history(args[0], args[1], events);\n std::vector<int> values{rc};\n if (rc == 0)\n {\n values.push_back(static_cast<int>(events.size()));\n for (const auto& event : events)\n {\n values.insert(values.end(), {event.serial, event.code, event.ticket,\n event.owner, event.kind, event.index, event.value});\n }\n }\n print(values);\n return true;\n }\n else if (op == "PORT" && args.empty())\n {\n print_port(port);\n return true;\n }\n else if (op == "EVENTS" && args.empty())\n {\n print_events(port);\n return true;\n }\n else if (op == "VIEW" && args.size() == 1)\n {\n print_view(station, args[0]);\n return true;\n }\n else if (args.size() == 1)\n {\n const int slot = args[0];\n if (op == "CONFIG") status = station.configure(slot);\n else if (op == "ACTIVATE") status = station.activate(slot);\n else if (op == "DEACTIVATE") status = station.deactivate(slot);\n else if (op == "CLEANUP") status = station.cleanup(slot);\n else if (op == "SHUTDOWN") status = station.shutdown(slot);\n else if (op == "STOP") status = station.stop(slot);\n else return false;\n }\n else\n {\n return false;\n }\n print({status});\n return true;\n}\n}\nint main()\n{\n station::Port port;\n station::Station station(port);\n std::string line;\n while (std::getline(std::cin, line))\n {\n const auto tokens = words(line);\n if (tokens.empty() || tokens[0][0] == \'#\')\n {\n continue;\n }\n if (!execute(station, port, tokens))\n {\n return 2;\n }\n }\n return std::cin.bad() ? 2 : 0;\n}\n'}
SUPERVISOR = "import base64, ctypes, hashlib, json, os, selectors, signal, subprocess, sys, time\ncfg = json.loads(sys.argv[1])\nstarted = time.monotonic()\nerrors = []\n\ndef error(where, exc):\n errors.append([where, type(exc).__name__, str(exc)])\n\ndef 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 (int(fields[1]), int(fields[2]), int(fields[19]), fields[0].decode('ascii'))\n\ndef owned(table, me, tracked):\n roots = {me}\n roots.update(pid for pid, start in tracked.items()\n if pid in table and table[pid][2] == start and table[pid][3] not in ('Z', 'X'))\n result = set()\n changed = True\n while changed:\n changed = False\n for pid, value in table.items():\n if pid != me and (value[0] in roots or pid in roots) and pid not in result:\n result.add(pid)\n roots.add(pid)\n changed = True\n return result\n\ndef discover(me, tracked):\n table = {}\n for name in os.listdir('/proc'):\n if name.isascii() and name.isdigit():\n value = stat(int(name))\n if value is not None:\n table[int(name)] = value\n result = owned(table, me, tracked)\n for pid in result:\n tracked[pid] = table[pid][2]\n return table, result\n\ndef fresh_signal(pid, start):\n value = stat(pid)\n if value is not None and value[2] == start and value[3] not in ('Z', 'X'):\n try:\n os.kill(pid, signal.SIGKILL)\n return True\n except (ProcessLookupError, FileNotFoundError):\n pass\n return False\n\nme = os.getpid()\nself_stat = stat(me)\nmeta = dict(version=1, stage=cfg['stage'], nonce=cfg['nonce'], argv=cfg['argv'],\n deadline=cfg['deadline'], recovery=cfg['recovery'],\n uid=os.getuid(), gid=os.getgid(), groups=os.getgroups(),\n supervisor_pid=me, supervisor_start=self_stat[2], leader_pid=None,\n leader_start=None, leader_rc=None, controlled_rc=None, timeout=False,\n leader_reaped=False, pg_absent=False, descendants_absent=False,\n exceptions=errors, adopted=[], signaled=[], elapsed=0)\nproc = None\ntracked = {}\nselector = selectors.DefaultSelector()\nchunks = {'stdout': [], 'stderr': []}\ninput_data = base64.b64decode(cfg['input'])\ninput_at = 0\n\ndef drain(timeout):\n global input_at\n for key, mask in selector.select(timeout):\n stream, name = key.fileobj, key.data\n if name == 'stdin':\n try:\n written = os.write(stream.fileno(), input_data[input_at:input_at + 65536])\n input_at += written\n except BrokenPipeError:\n input_at = len(input_data)\n if input_at == len(input_data):\n selector.unregister(stream)\n stream.close()\n else:\n try:\n part = os.read(stream.fileno(), 65536)\n except BlockingIOError:\n continue\n if part:\n chunks[name].append(part)\n else:\n selector.unregister(stream)\n stream.close()\n\ntry:\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(cfg['argv'], cwd=cfg['cwd'], stdin=subprocess.PIPE,\n stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True)\n meta['leader_pid'] = proc.pid\n leader = stat(proc.pid)\n if leader is None:\n raise RuntimeError('leader identity disappeared before capture')\n meta['leader_start'] = leader[2]\n tracked[proc.pid] = leader[2]\n for stream, name in ((proc.stdout, 'stdout'), (proc.stderr, 'stderr')):\n os.set_blocking(stream.fileno(), False)\n selector.register(stream, selectors.EVENT_READ, name)\n if input_data:\n os.set_blocking(proc.stdin.fileno(), False)\n selector.register(proc.stdin, selectors.EVENT_WRITE, 'stdin')\n else:\n proc.stdin.close()\n end = started + cfg['deadline']\n while True:\n leader_rc = proc.poll()\n table, current = discover(me, tracked)\n if leader_rc is not None and not selector.get_map():\n break\n if time.monotonic() >= end:\n meta['timeout'] = True\n break\n drain(min(.02, max(0, end - time.monotonic())))\nexcept BaseException as exc:\n error('execute', exc)\nfinally:\n end_recovery = time.monotonic() + cfg['recovery']\n while time.monotonic() < end_recovery:\n table, current = {}, set()\n discovered = False\n try:\n if proc is not None:\n proc.poll()\n meta['leader_rc'] = proc.returncode\n meta['leader_reaped'] = proc.returncode is not None\n except BaseException as exc:\n error('recovery.poll', exc)\n try:\n table, current = discover(me, tracked)\n discovered = True\n except BaseException as exc:\n error('recovery.discover', exc)\n for pid in sorted(current):\n try:\n if fresh_signal(pid, table[pid][2]):\n meta['signaled'].append([pid, table[pid][2]])\n except BaseException as exc:\n error('recovery.signal', exc)\n # Never waitpid(-1): own Popen owns its real leader status.\n for pid in sorted(current):\n if proc is not None and pid == proc.pid:\n continue\n try:\n fresh = stat(pid)\n if fresh is not None and fresh[2] == table[pid][2] and fresh[0] == me:\n reaped, status = os.waitpid(pid, os.WNOHANG)\n if reaped:\n meta['adopted'].append([pid, table[pid][2], os.waitstatus_to_exitcode(status)])\n except ChildProcessError:\n pass\n except BaseException as exc:\n error('recovery.reap', exc)\n try:\n drain(0)\n except BaseException as exc:\n error('recovery.drain', exc)\n try:\n if proc is not None:\n proc.poll()\n meta['leader_rc'] = proc.returncode\n meta['leader_reaped'] = proc.returncode is not None\n except BaseException as exc:\n error('recovery.poll2', exc)\n try:\n final_table, final_current = discover(me, tracked)\n if meta['leader_reaped'] and not final_current and not selector.get_map():\n meta['descendants_absent'] = True\n # PG membership is observed with PID/start ownership, not killpg(0).\n meta['pg_absent'] = not any(pid in final_current and value[1] == meta['leader_pid']\n for pid, value in final_table.items())\n break\n except BaseException as exc:\n error('recovery.absence', exc)\n time.sleep(.01)\n try:\n selector.close()\n except BaseException as exc:\n error('selector.close', exc)\n for name in ('stdout', 'stderr'):\n raw = b''.join(chunks[name])\n meta[name + '_length'] = len(raw)\n meta[name + '_sha256'] = hashlib.sha256(raw).hexdigest()\n meta['elapsed'] = time.monotonic() - started\n meta['controlled_rc'] = 124 if meta['timeout'] else meta['leader_rc']\n wire = dict(meta=meta, stdout=base64.b64encode(b''.join(chunks['stdout'])).decode('ascii'),\n stderr=base64.b64encode(b''.join(chunks['stderr'])).decode('ascii'))\n sys.stdout.write(json.dumps(wire, separators=(',', ':')) + '\\n')\n"
import base64
import hashlib
import json
import math
import os
from pathlib import Path
import random
import shutil
import subprocess
import sys
import tempfile
import uuid
import zlib
CANDIDATES = ['lifecycle.hpp', 'lifecycle.cpp', 'resource_port.cpp']
COMPILE_DEADLINE = 20
RUN_DEADLINE = 6
CLEANUP_DEADLINE = 3
ABSENCE_DEADLINE = 3
RECOVERY = 3
EVIDENCE = []
class Model:
def __init__(self):
self.nodes = {}
self.live = {}
self.events = []
self.attempts = self.fail = self.deliveries = 0
self.ticket = 100
def event(self, code, ticket, owner, kind, index, value):
self.events.append([len(self.events) + 1, code, ticket, owner, kind, index, value])
def acquire(self, owner, kind, index):
self.attempts += 1
if self.attempts == self.fail:
self.fail = 0
self.event(4, -1, owner, kind, index, -5)
return -5
ticket = self.ticket
self.ticket += 1
self.live[ticket] = [ticket, owner, kind, index, 0]
self.event(1, ticket, owner, kind, index, 0)
return ticket
def release(self, ticket):
if ticket != -1:
row = self.live.pop(ticket)
self.event(2, *row)
def toggle(self, ticket, value):
row = self.live[ticket]
if row[-1] != value:
row[-1] = value
self.event(3, *row)
def end(self, node):
if node['state'] != 3:
node['shutdown'] += 1
self.event(6, -1, node['owner'], -1, -1, node['state'])
for ticket in node['tickets']:
if ticket != -1:
self.toggle(ticket, 0)
self.free(node)
node['state'] = 3
def free(self, node):
for ticket in reversed(node['tickets']):
self.release(ticket)
self.release(node['device'])
node['tickets'] = [-1] * node['subscriptions']
node['device'] = -1
def run(self, op, args):
if op == 'FAIL':
if args[0] < 0: return [-22]
self.fail = args[0]
return [0]
if op == 'PORT':
return [self.attempts, self.ticket, len(self.events), self.deliveries, len(self.live)] + [v for t in sorted(self.live) for v in self.live[t]]
if op == 'EVENTS':
return [len(self.events)] + [v for row in self.events for v in row]
if op == 'HISTORY':
owner, after = args
if not 0 <= owner <= 1000000 or not 0 <= after <= len(self.events): return [-22]
rows = [r for r in self.events if r[0] > after and (owner == 0 or r[3] == owner)]
return [0, len(rows)] + [v for row in rows for v in row]
if op == 'STATS':
owner = args[0]
if not 1 <= owner <= 1000000: return [-22]
rows = [r for r in self.live.values() if r[1] == owner]
counts = [sum(r[2] == k for r in rows) for k in (0, 1)]
return [0] + counts + [sum(r[4] for r in rows)] + [sum(r[1] == code and r[3] == owner for r in self.events) for code in (1, 2, 4, 5)]
if op == 'PUBLISH':
owner, index, payload = args
if not 1 <= owner <= 1000000 or not 0 <= index <= 5 or not 0 <= payload <= 1000000: return [-22]
matches = [r for r in self.live.values() if r[1:4] == [owner, 1, index] and r[4]]
if not matches: return [0]
row = min(matches)
self.event(5, *row[:4], payload)
self.deliveries += 1
return [1]
slot = args[0]
if not 0 <= slot <= 7: return [-22]
if op == 'NEW':
_, owner, subscriptions = args
if not 1 <= owner <= 1000000 or not 0 <= subscriptions <= 6: return [-22]
if slot in self.nodes or any(n['owner'] == owner for n in self.nodes.values()): return [-17]
self.nodes[slot] = dict(owner=owner, subscriptions=subscriptions, state=0,
device=-1, tickets=[-1]*subscriptions, shutdown=0, cleanup=0)
return [0]
if slot not in self.nodes: return [-2]
node = self.nodes[slot]
if op == 'VIEW':
return [0,node['owner'],node['state'],node['subscriptions'],node['device'],node['shutdown'],node['cleanup']] + node['tickets']
if op == 'SHUTDOWN':
self.end(node)
elif op == 'STOP':
self.end(node)
del self.nodes[slot]
elif op == 'CONFIG':
if node['state'] != 0: return [-16]
acquired = []
for kind, index in [(0,0)] + [(1,i) for i in range(node['subscriptions'])]:
ticket = self.acquire(node['owner'], kind, index)
if ticket < 0:
for old in reversed(acquired): self.release(old)
return [-5]
acquired.append(ticket)
node['device'] = acquired[0]
node['tickets'] = acquired[1:]
node['state'] = 1
elif op == 'CLEANUP':
if node['state'] != 1: return [-16]
self.free(node)
node['cleanup'] += 1
node['state'] = 0
elif op in ('ACTIVATE','DEACTIVATE'):
before, after = (1,2) if op == 'ACTIVATE' else (2,1)
if node['state'] != before: return [-16]
for ticket in node['tickets']: self.toggle(ticket, int(after == 2))
node['state'] = after
else:
raise ValueError(op)
return [0]
class Suite:
def __init__(self):
self.model = Model()
self.commands, self.expected, self.labels = [], [], []
def add(self, command, label):
words = command.split(' ')
self.commands.append(command)
self.labels.append(label)
self.expected.append(self.model.run(words[0], list(map(int,words[1:]))))
def observe(self, slot, owner):
self.add('VIEW %d' % slot, 'C05')
self.add('PORT','C04-C05')
self.add('STATS %d' % owner,'C07')
self.add('HISTORY %d %d' % (owner,max(0,len(self.model.events)-12)),'C04-C07')
def suite():
s = Suite()
for command in ['NEW 0 37 2','CONFIG 0','ACTIVATE 0','PUBLISH 37 1 806','VIEW 0','STOP 0','PORT','EVENTS']:
s.add(command,'public-default')
for subscriptions in (0,1,2,6):
for phase in (0,1,2):
owner = 100 + subscriptions*10 + phase
s.add('NEW 0 %d %d' % (owner,subscriptions),'C01')
if phase: s.add('CONFIG 0','C02')
if phase == 2: s.add('ACTIVATE 0','C02')
s.observe(0,owner)
s.add('SHUTDOWN 0','C03')
s.observe(0,owner)
s.add('SHUTDOWN 0','C03-idempotence')
for op in ('CONFIG','ACTIVATE','DEACTIVATE','CLEANUP'): s.add(op+' 0','C02-finalized')
s.add('STOP 0','C03')
s.observe(0,owner)
for failure in range(1,8):
s.add('NEW 0 789 6','C01')
s.add('FAIL %d' % (s.model.attempts + failure),'C04')
s.add('CONFIG 0','C02-rollback')
s.observe(0,789)
s.add('CONFIG 0','C02-recovery')
s.add('ACTIVATE 0','C02')
for index in range(6): s.add('PUBLISH 789 %d %d' % (index,failure*100+index),'C04')
s.add('DEACTIVATE 0','C02')
s.add('CLEANUP 0','C02')
s.add('CONFIG 0','C02')
s.add('STOP 0','C03')
s.observe(0,789)
for slot in range(8):
s.add('NEW %d %d %d' % (slot,500+slot,slot%7),'C01-independence')
s.add('CONFIG %d' % slot,'C02')
if slot%2: s.add('ACTIVATE %d' % slot,'C02')
for command in ['NEW 0 888 2','NEW 0 -1 2','NEW 1 333 7','NEW 8 333 2','NEW -1 333 2','NEW 0 1000001 2','NEW 3 504 1','FAIL -1','HISTORY 0 -1','HISTORY 0 2147483647','HISTORY -1 0','HISTORY 1000001 0','STATS 0','STATS 1000001','PUBLISH 0 0 0','PUBLISH 501 6 0','PUBLISH 501 1 -1','PUBLISH 501 1 1000001']:
s.add(command,'C01-C04-C07-invalid')
for slot in (7,0,5,2,1,6,3,4):
s.add('PUBLISH %d 0 999' % (500+slot),'C04')
s.add('STOP %d' % slot,'C03')
s.observe(slot,500+slot)
rng = random.Random(13420261024)
for cycle in range(80):
slot = rng.randrange(8)
owner = rng.randint(1,1000000)
s.add('NEW %d %d %d' % (slot,owner,rng.randrange(7)),'C01-reuse')
for repeat in range(9):
op = rng.choice(['CONFIG','ACTIVATE','DEACTIVATE','CLEANUP','SHUTDOWN','PUBLISH'])
if op == 'PUBLISH': s.add('PUBLISH %d %d %d' % (owner,rng.randrange(6),rng.randrange(1000001)),'C04-random')
else: s.add('%s %d' % (op,slot),'C02-C03-random')
s.add('VIEW %d' % slot,'C05-random')
s.add('STOP %d' % slot,'C03-reuse')
s.observe(slot,owner)
for slot in (-1,8,0):
for op in ('VIEW','CONFIG','ACTIVATE','DEACTIVATE','CLEANUP','SHUTDOWN','STOP'): s.add('%s %d' % (op,slot),'C01-absence')
s.add('FAIL 0','C04')
s.add('HISTORY 0 %d' % len(s.model.events),'C07-empty')
s.add('EVENTS','C04-complete')
return s
CLEANUP = "import os,shutil,sys; p=sys.argv[1]; s=None\ntry: s=os.lstat(p)\nexcept FileNotFoundError: pass\nif s is not None:\n if __import__('stat').S_ISLNK(s.st_mode): os.unlink(p)\n else: shutil.rmtree(p)\n"
ABSENCE = "import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: raise SystemExit(0)\nraise SystemExit(1)\n"
def integer(value):
return type(value) is int
def validate(meta, cfg, stdout, stderr):
for key in ('version','stage','nonce','argv','deadline','recovery'):
if type(meta.get(key)) is not type(cfg.get(key) if key in cfg else 1) or meta.get(key) != (cfg.get(key) if key in cfg else 1):
raise ValueError('wire binding '+key)
for key in ('supervisor_pid','supervisor_start','leader_pid','leader_start'):
if not integer(meta.get(key)) or meta[key] <= 0: raise ValueError('wire identity '+key)
if meta['supervisor_pid'] == meta['leader_pid']: raise ValueError('wire PID equality')
expected_uid = 65534 if os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534' else os.getuid()
expected_gid = 65534 if os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534' else os.getgid()
expected_groups = [] if os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534' else os.getgroups()
if not integer(meta.get('uid')) or not integer(meta.get('gid')) or meta['uid'] != expected_uid or meta['gid'] != expected_gid: raise ValueError('wire UID/GID')
if type(meta.get('groups')) is not list or any(not integer(x) for x in meta['groups']) or meta['groups'] != expected_groups: raise ValueError('wire groups')
elapsed = meta.get('elapsed')
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0 <= elapsed <= cfg['deadline'] + cfg['recovery'] + 2: raise ValueError('wire elapsed')
for key in ('timeout','leader_reaped','pg_absent','descendants_absent'):
if type(meta.get(key)) is not bool: raise ValueError('wire bool '+key)
if not integer(meta.get('leader_rc')) or not integer(meta.get('controlled_rc')): raise ValueError('wire returncode')
if meta['controlled_rc'] != (124 if meta['timeout'] else meta['leader_rc']): raise ValueError('wire returncode consistency')
for key in ('exceptions','adopted','signaled'):
if type(meta.get(key)) is not list: raise ValueError('wire list '+key)
for key, data in (('stdout',stdout),('stderr',stderr)):
if not integer(meta.get(key+'_length')) or meta[key+'_length'] < 0 or meta[key+'_length'] != len(data) or meta.get(key+'_sha256') != hashlib.sha256(data).hexdigest(): raise ValueError('wire IO '+key)
if meta['exceptions'] or not meta['leader_reaped'] or not meta['pg_absent'] or not meta['descendants_absent']:
raise ValueError('execution facts incomplete')
def execute(stage, argv, cwd, deadline, data=b''):
cfg = dict(stage=stage, nonce=uuid.uuid4().hex, argv=argv, cwd=str(cwd),
deadline=deadline, recovery=RECOVERY, input=base64.b64encode(data).decode())
completed = subprocess.run([sys.executable,'-I','-c',SUPERVISOR,json.dumps(cfg,separators=(',',':'))],capture_output=True)
row = dict(stage=stage, wrapper_rc=completed.returncode, wire_length=len(completed.stdout),
wire_sha256=hashlib.sha256(completed.stdout).hexdigest(), wrapper_stderr_length=len(completed.stderr),
wrapper_stderr_sha256=hashlib.sha256(completed.stderr).hexdigest())
EVIDENCE.append(row)
if completed.returncode != 0: raise ValueError('supervisor nonzero '+stage)
wire = json.loads(completed.stdout)
meta = wire['meta']
row['meta'] = meta
stdout = base64.b64decode(wire['stdout'],validate=True)
stderr = base64.b64decode(wire['stderr'],validate=True)
validate(meta,cfg,stdout,stderr)
if meta['timeout']: raise ValueError('controlled timeout '+stage)
if meta['leader_rc'] != 0: raise ValueError('leader nonzero %s rc=%d' % (stage,meta['leader_rc']))
return stdout
def main():
failures = []
scratch = None
passed = False
try:
matrix = suite()
contents = {name:(Path(sys.argv[1])/name).read_bytes() for name in CANDIDATES}
scratch = Path(tempfile.mkdtemp(prefix='shutdown-hooks-'))
build = scratch/'build'
build.mkdir(mode=0o777)
os.chmod(build,0o777)
for name, raw in contents.items(): (build/name).write_bytes(raw)
for name, raw in CONTEXT.items(): (build/name).write_text(raw)
source = [str(build/name) for name in ('lifecycle.cpp','resource_port.cpp','observer.cpp')]
execute('compiler',['g++','-std=c++17','-O2',*source,'-o',str(build/'station')],build,COMPILE_DEADLINE)
raw = execute('candidate',[str(build/'station')],build,RUN_DEADLINE,('\n'.join(matrix.commands)+'\n').encode())
lines = raw.splitlines()
if len(lines) != len(matrix.expected): raise ValueError('stdout row count actual=%d expected=%d' % (len(lines),len(matrix.expected)))
for index,(line,expected) in enumerate(zip(lines,matrix.expected)):
value = json.loads(line)
if type(value) is not list or any(type(v) is not int for v in value): raise ValueError('stdout JSON integer array row=%d' % index)
if value != expected: raise ValueError('behavior row=%d clause=%s actual=%s expected=%s' % (index,matrix.labels[index],str(value)[:200],str(expected)[:200]))
passed = True
except BaseException as exc:
failures.append(['main',type(exc).__name__,str(exc)])
finally:
if scratch is not None:
try:
execute('cleanup',[sys.executable,'-I','-c',CLEANUP,str(scratch)],'/tmp',CLEANUP_DEADLINE)
except BaseException as exc:
failures.append(['cleanup',type(exc).__name__,str(exc)])
try:
execute('absence',[sys.executable,'-I','-c',ABSENCE,str(scratch)],'/tmp',ABSENCE_DEADLINE)
except BaseException as exc:
failures.append(['absence',type(exc).__name__,str(exc)])
facts = dict(stages=EVIDENCE,failures=failures,rows=len(matrix.expected) if 'matrix' in locals() else 0)
packed = base64.b85encode(zlib.compress(json.dumps(facts,separators=(',',':')).encode(),9)).decode()
sys.stderr.write('EVIDENCE85 '+packed+'\n')
print('PASS' if passed and not failures else 'FAIL '+repr(failures)[:400])
return 0 if passed and not failures else 1
if __name__ == '__main__':
raise SystemExit(main())