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>
309 lines
29 KiB
Python
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())
|