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>
368 lines
25 KiB
Python
368 lines
25 KiB
Python
SUPERVISOR = "import base64\nimport ctypes\nimport hashlib\nimport json\nimport lzma\nimport os\nimport selectors\nimport signal\nimport subprocess\nimport sys\nimport time\nimport uuid\n\n\ndef proc_stat(pid):\n try:\n with open('/proc/%d/stat' % pid) as stream:\n fields=stream.read().rsplit(')',1)[1].split()\n return (int(fields[1]),int(fields[2]),int(fields[19]),fields[0])\n except (FileNotFoundError,ProcessLookupError):\n return None\n\n\ndef proc_table():\n result={}\n for name in os.listdir('/proc'):\n if name.isascii() and name.isdigit():\n row=proc_stat(int(name))\n if row is not None:\n result[int(name)]=row\n return result\n\n\ndef members(table,supervisor,tracked):\n # Only the actual supervisor and still live same-start tokens authorize roots.\n roots={supervisor}\n for pid,start in tracked:\n row=table.get(pid)\n if row and row[2]==start and row[3] not in ('Z','X'):\n roots.add(pid)\n result=set(roots)-{supervisor}\n changed=True\n while changed:\n changed=False\n for pid,row in table.items():\n if pid!=supervisor and pid not in result and row[0] in roots:\n result.add(pid)\n roots.add(pid)\n changed=True\n return {pid:table[pid] for pid in result if pid in table}\n\n\ndef credentials(pid):\n values={}\n with open('/proc/%d/status' % pid) as stream:\n for line in stream:\n if ':' in line:\n key,value=line.split(':',1)\n values[key]=value\n return {'uid':int(values['Uid'].split()[0]),'gid':int(values['Gid'].split()[0]),\n 'groups':list(map(int,values['Groups'].split()))}\n\n\ndef execute(config,payload):\n started=time.monotonic()\n supervisor=os.getpid()\n meta={'stage':config['stage'],'nonce':config['nonce'],'argv':config['argv'],\n 'cwd':config['cwd'],'deadline':config['deadline'],'supervisor_pid':supervisor,\n 'supervisor_start':proc_stat(supervisor)[2], 'identity':credentials(supervisor),\n 'leader_pid':None,'leader_start':None,'leader_identity':None,\n 'leader_rc':None,'reaped':False,'timeout':False,'controlled_rc':None,\n 'exceptions':[],'tracked':[],'signals':[],'adopted':[],\n 'owned_absent':False,'pg_absent':False,'elapsed':None,\n 'input_len':len(payload),'input_sha':hashlib.sha256(payload).hexdigest()}\n tracked=set()\n child=None\n selector=selectors.DefaultSelector()\n output=bytearray()\n errors=bytearray()\n input_bytes=b'G'+payload\n sent=0\n pipes=set()\n table={}\n def record(error):\n meta['exceptions'].append(type(error).__name__+':'+repr(error))\n def poll_leader():\n if child is not None:\n rc=child.poll()\n if rc is not None:\n meta['leader_rc']=rc\n meta['reaped']=True\n def discover():\n nonlocal table\n table=proc_table()\n found=members(table,supervisor,tracked)\n tracked.update((pid,row[2]) for pid,row in found.items())\n return found\n def fresh_signal(found):\n for pid,old in found.items():\n fresh=proc_stat(pid)\n if fresh is None or fresh[2]!=old[2] or fresh[3] in ('Z','X'):\n continue\n try:\n os.kill(pid,signal.SIGKILL)\n meta['signals'].append([pid,fresh[2],signal.SIGKILL])\n except ProcessLookupError:\n continue\n def reap_adopted(found):\n poll_leader()\n for pid,row in found.items():\n if child is not None and pid==child.pid:\n continue\n if row[0]!=supervisor:\n continue\n fresh=proc_stat(pid)\n if fresh is None or fresh[2]!=row[2] or fresh[0]!=supervisor:\n continue\n waited,status=os.waitpid(pid,os.WNOHANG)\n if waited:\n meta['adopted'].append([pid,row[2],status])\n def pump(wait):\n nonlocal sent\n for key,events in selector.select(wait):\n fd=key.fd\n if key.data=='in':\n try:\n count=os.write(fd,input_bytes[sent:sent+65536])\n sent+=count\n if sent==len(input_bytes):\n selector.unregister(fd)\n child.stdin.close()\n except BrokenPipeError:\n selector.unregister(fd)\n child.stdin.close()\n else:\n try:\n data=os.read(fd,65536)\n except BlockingIOError:\n continue\n if data:\n (output if key.data=='out' else errors).extend(data)\n else:\n selector.unregister(fd)\n pipes.discard(fd)\n (child.stdout if key.data=='out' else child.stderr).close()\n try:\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 gate='import os,sys; os.read(0,1); os.execvp(sys.argv[1],sys.argv[1:])'\n child=subprocess.Popen([sys.executable,'-I','-c',gate,*config['argv']],\n cwd=config['cwd'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,start_new_session=True)\n meta['leader_pid']=child.pid\n identity=proc_stat(child.pid)\n if identity is None:\n raise RuntimeError('gated leader disappeared')\n meta['leader_start']=identity[2]\n meta['leader_identity']=credentials(child.pid)\n tracked.add((child.pid,identity[2]))\n for stream,kind,event in [(child.stdin,'in',selectors.EVENT_WRITE),\n (child.stdout,'out',selectors.EVENT_READ),\n (child.stderr,'err',selectors.EVENT_READ)]:\n os.set_blocking(stream.fileno(),False)\n selector.register(stream,event,kind)\n if kind!='in':\n pipes.add(stream.fileno())\n deadline=started+config['deadline']\n while True:\n poll_leader()\n found=discover()\n reap_adopted(found)\n if meta['reaped'] and not pipes:\n break\n if time.monotonic()>=deadline:\n meta['timeout']=True\n break\n pump(min(0.01,max(0,deadline-time.monotonic())))\n except BaseException as error:\n record(error)\n finally:\n recovery_end=time.monotonic()+6\n while time.monotonic()<recovery_end:\n found=None\n # Each operation preserves failures and retries inside the original bound.\n try:\n poll_leader()\n except BaseException as error:\n record(error)\n try:\n found=discover()\n except BaseException as error:\n record(error)\n if found is not None:\n try:\n fresh_signal(found)\n except BaseException as error:\n record(error)\n try:\n reap_adopted(found)\n except BaseException as error:\n record(error)\n try:\n pump(0.002)\n except BaseException as error:\n record(error)\n try:\n poll_leader()\n remaining=discover()\n if meta['reaped'] and not remaining and not pipes:\n break\n except BaseException as error:\n record(error)\n try:\n poll_leader()\n remaining=discover()\n meta['owned_absent']=not remaining\n # PG claim is restricted to the owned PID/start closure, not global PG identity.\n meta['pg_absent']=not any(row[3] not in ('Z','X') for row in remaining.values())\n except BaseException as error:\n record(error)\n try:\n selector.close()\n except BaseException as error:\n record(error)\n meta['tracked']=sorted([list(item) for item in tracked])\n meta['elapsed']=time.monotonic()-started\n meta['controlled_rc']=124 if meta['timeout'] else meta['leader_rc']\n for name,value in [('stdout',output),('stderr',errors)]:\n meta[name+'_len']=len(value)\n meta[name+'_sha']=hashlib.sha256(value).hexdigest()\n return {'meta':meta,'stdout':base64.b64encode(output).decode(),\n 'stderr':base64.b64encode(errors).decode()}\n\n\ndef main():\n config=json.loads(sys.argv[1])\n payload=sys.stdin.buffer.read()\n wire=execute(config,payload)\n packed=json.dumps(wire,separators=(',',':'),sort_keys=True).encode()\n sys.stdout.buffer.write(packed)\n sys.stdout.buffer.flush()\n\nif __name__=='__main__':\n main()\n"
|
|
import base64
|
|
import hashlib
|
|
import json
|
|
import lzma
|
|
import math
|
|
import os
|
|
from pathlib import Path
|
|
import random
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import uuid
|
|
|
|
COMPILE_SECONDS=20
|
|
CANDIDATE_SECONDS=8
|
|
CLEANUP_SECONDS=5
|
|
ABSENCE_SECONDS=5
|
|
CLEANUP_CODE='import shutil,sys; shutil.rmtree(sys.argv[1])'
|
|
ABSENCE_CODE='import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: raise SystemExit(0)\nraise SystemExit(1)'
|
|
|
|
|
|
def make_cases():
|
|
cases=[]
|
|
def add(catalog,sources):
|
|
cases.append((catalog,sources))
|
|
def entry(data=b'a=2\n',fail=0,read=-1,chunk=3):
|
|
return [fail,read,chunk,data]
|
|
add({0:entry(b'alpha=2\n'),1:entry(b'beta=3\n',fail=1)},[(0,2,0),(1,3,0)])
|
|
add({0:entry(b'alpha=2\n'),1:entry(b'beta=3\n')},[(0,2,0),(1,3,0)])
|
|
add({},[])
|
|
for data in [b'',b'\n',b'\n\n',b' \t\r',b'# ignored',b'a=0',b'a=-0\n',
|
|
b' key = +00009 \r\n\t# skip\nkey=-2',b'abcdefghijkl=-1000000\n',
|
|
b'z=1000000\n',b'x='+b'0'*3900+b'9',b'a=2\nb=3\n',
|
|
b'A=1\n',b'a=\n',b'a=+\n',b'a=1_0\n',b'a=1000001\n',
|
|
b'a=1\x00\n',b'a=1\v\n',b'a=1\f',b'a=1=2\n',b'=2\n',
|
|
b'abcdefghijklm=2',b'a = -000001\r',b'a=3\na=4\na=-5']:
|
|
add({0:entry(data,chunk=(len(cases)%64)+1)},[(0,-3,0)])
|
|
for fail_at in range(8):
|
|
catalog={i:entry(('k=%d\n'%i).encode(),fail=i==fail_at,chunk=i+1) for i in range(8)}
|
|
add(catalog,[(i,i-4,0) for i in range(8)])
|
|
for at in [0,1,4,8,9]:
|
|
add({0:entry(b'a=1\nb=2\n',read=at),1:entry(b'c=4')},[(0,2,0),(1,-1,1)])
|
|
add({0:entry(b'a=1'),1:entry(b'b=2\n'),2:entry(b'c=3\n',fail=1)},[(0,1,1),(1,2,0),(2,3,0)])
|
|
add({0:entry(b'a=1'),1:entry(b'b=2\n')},[(0,1,1),(1,2,1),(0,-4,0),(1,0,0)])
|
|
add({0:entry(b'a=1\nb=2\n')},[(0,i-3,int(i%3==0)) for i in range(8)])
|
|
rng=random.Random(12520261024)
|
|
for _ in range(5):
|
|
catalog={}
|
|
for key in range(4):
|
|
parts=[]
|
|
for _ in range(rng.randrange(1,9)):
|
|
value=rng.randrange(-1000000,1000001)
|
|
parts.append(('%s=%+d'%(rng.choice(['a','bravo','calib','z']),value)).encode())
|
|
data=b'\n'.join(parts)+(b'\n' if rng.randrange(2) else b'')
|
|
catalog[key]=entry(data,chunk=rng.randrange(1,65))
|
|
sources=[(rng.randrange(4),rng.randrange(-20,21),rng.randrange(2)) for _ in range(rng.randrange(1,9))]
|
|
add(catalog,sources)
|
|
return cases
|
|
|
|
|
|
def parse_item(data,scale):
|
|
lines=data.split(b'\n')
|
|
if lines[-1:]==[b'']:
|
|
lines.pop()
|
|
item=[len(lines),0,0,0]
|
|
for line in lines:
|
|
clean=line.strip(b' \t\r')
|
|
if not clean or clean.startswith(b'#'):
|
|
continue
|
|
if clean.count(b'=')!=1:
|
|
return None
|
|
key,value=(part.strip(b' \t\r') for part in clean.split(b'='))
|
|
if not re.fullmatch(rb'[a-z]{1,12}',key) or not re.fullmatch(rb'[+-]?[0-9]+',value):
|
|
return None
|
|
negative=value.startswith(b'-')
|
|
normalized=value.lstrip(b'+-').lstrip(b'0') or b'0'
|
|
if len(normalized)>7:
|
|
return None
|
|
number=int(normalized)*(-1 if negative else 1)
|
|
if not -1000000<=number<=1000000:
|
|
return None
|
|
item[1]+=1
|
|
item[2]+=number*scale
|
|
keyhash=0
|
|
for byte in key:
|
|
keyhash=(keyhash*33+byte)%1000000007
|
|
item[3]=(item[3]*131+keyhash+(number+1000000)*17)%1000000007
|
|
return item
|
|
|
|
|
|
def oracle(case):
|
|
catalog,sources=case
|
|
next_handle=100
|
|
borrowed={}
|
|
for index,source in enumerate(sources):
|
|
if source[2]:
|
|
borrowed[index]=next_handle
|
|
next_handle+=1
|
|
events=[]
|
|
owned=[]
|
|
status=0
|
|
failed=-1
|
|
for index,(key,scale,is_borrowed) in enumerate(sources):
|
|
if is_borrowed:
|
|
continue
|
|
if catalog[key][0]:
|
|
events.append([2,key,-1])
|
|
status=1
|
|
failed=index
|
|
break
|
|
events.append([1,key,next_handle])
|
|
owned.append(next_handle)
|
|
next_handle+=1
|
|
items=[]
|
|
if status==0:
|
|
for index,(key,scale,is_borrowed) in enumerate(sources):
|
|
fail,read,chunk,data=catalog[key]
|
|
if 0<=read<=len(data):
|
|
status=2
|
|
failed=index
|
|
break
|
|
item=parse_item(data,scale)
|
|
if item is None:
|
|
status=3
|
|
failed=index
|
|
break
|
|
items.append(item)
|
|
events.extend([3,handle,0] for handle in reversed(owned))
|
|
if status:
|
|
return [status,failed,0,0,0,0,[],events,0,len(borrowed),0,0]
|
|
totals=[sum(item[i] for item in items) for i in range(3)]
|
|
return [0,-1,len(owned),*totals,items,events,0,len(borrowed),0,0]
|
|
|
|
|
|
def encode_input(cases):
|
|
lines=[str(len(cases))]
|
|
for catalog,sources in cases:
|
|
lines.append('%d %d'%(len(catalog),len(sources)))
|
|
for key,(fail,read,chunk,data) in catalog.items():
|
|
lines.append('%d %d %d %d %s'%(key,fail,read,chunk,data.hex() or '-'))
|
|
lines.extend('%d %d %d'%source for source in sources)
|
|
return ('\n'.join(lines)+'\n').encode()
|
|
|
|
|
|
def integer(value,minimum=None):
|
|
return type(value) is int and (minimum is None or value>=minimum)
|
|
|
|
|
|
def identity(value,expected):
|
|
return (type(value) is dict and set(value)=={'uid','gid','groups'} and
|
|
integer(value['uid'],0) and integer(value['gid'],0) and
|
|
type(value['groups']) is list and all(integer(x,0) for x in value['groups']) and
|
|
value['uid']==expected['uid'] and value['gid']==expected['gid'] and
|
|
sorted(value['groups'])==sorted(expected['groups']))
|
|
|
|
|
|
def validate(wire,config,payload,expected):
|
|
if type(wire) is not dict or set(wire)!={'meta','stdout','stderr'}:
|
|
raise ValueError('wire fields')
|
|
meta=wire['meta']
|
|
required={'stage','nonce','argv','cwd','deadline','supervisor_pid','supervisor_start','identity',
|
|
'leader_pid','leader_start','leader_identity','leader_rc','reaped','timeout','controlled_rc',
|
|
'exceptions','tracked','signals','adopted','owned_absent','pg_absent','elapsed',
|
|
'input_len','input_sha','stdout_len','stdout_sha','stderr_len','stderr_sha'}
|
|
if type(meta) is not dict or set(meta)!=required:
|
|
raise ValueError('metadata fields')
|
|
for key in ('stage','nonce','argv','cwd','deadline'):
|
|
if meta[key]!=config[key]:
|
|
raise ValueError('metadata binding '+key)
|
|
if type(meta['deadline']) is not int:
|
|
raise ValueError('deadline type')
|
|
for key in ('supervisor_pid','supervisor_start','leader_pid','leader_start'):
|
|
if not integer(meta[key],1):
|
|
raise ValueError('process token '+key)
|
|
if meta['supervisor_pid']==meta['leader_pid']:
|
|
raise ValueError('leader supervisor collision')
|
|
if not identity(meta['identity'],expected) or not identity(meta['leader_identity'],expected):
|
|
raise ValueError('identity')
|
|
elapsed=meta['elapsed']
|
|
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0<=elapsed<=config['deadline']+8:
|
|
raise ValueError('elapsed')
|
|
for key in ('reaped','timeout','owned_absent','pg_absent'):
|
|
if type(meta[key]) is not bool:
|
|
raise ValueError('boolean '+key)
|
|
if not integer(meta['leader_rc']) or not integer(meta['controlled_rc']):
|
|
raise ValueError('return code types')
|
|
if meta['controlled_rc']!=(124 if meta['timeout'] else meta['leader_rc']):
|
|
raise ValueError('controlled return code')
|
|
for key,width in (('tracked',2),('signals',3),('adopted',3)):
|
|
if type(meta[key]) is not list or any(type(row) is not list or len(row)!=width or
|
|
any(not integer(v,0) for v in row) or row[0]<=0 or row[1]<=0
|
|
for row in meta[key]):
|
|
raise ValueError('inventory '+key)
|
|
if [meta['leader_pid'],meta['leader_start']] not in meta['tracked']:
|
|
raise ValueError('leader tracking')
|
|
if type(meta['exceptions']) is not list or any(type(x) is not str for x in meta['exceptions']):
|
|
raise ValueError('exception presence')
|
|
if not integer(meta['input_len'],0) or meta['input_len']!=len(payload) or meta['input_sha']!=hashlib.sha256(payload).hexdigest():
|
|
raise ValueError('input binding')
|
|
decoded=[]
|
|
for name in ('stdout','stderr'):
|
|
if type(wire[name]) is not str:
|
|
raise ValueError('IO encoding')
|
|
data=base64.b64decode(wire[name],validate=True)
|
|
if not integer(meta[name+'_len'],0) or len(data)!=meta[name+'_len'] or hashlib.sha256(data).hexdigest()!=meta[name+'_sha']:
|
|
raise ValueError('IO binding '+name)
|
|
decoded.append(data)
|
|
ok=(meta['leader_rc']==0 and meta['controlled_rc']==0 and meta['reaped'] and
|
|
not meta['timeout'] and meta['owned_absent'] and meta['pg_absent'] and not meta['exceptions'])
|
|
return ok,decoded
|
|
|
|
|
|
def run_stage(stage,argv,cwd,deadline,payload,evidence):
|
|
config={'stage':stage,'nonce':uuid.uuid4().hex,'argv':argv,'cwd':str(cwd),'deadline':deadline}
|
|
row={'config':config,'wrapper_rc':None,'wire_len':None,'wire_sha':None,'wire':None,'wrapper_stderr':None,
|
|
'wire_encoding':'utf8','ok':False,'error':None}
|
|
evidence.append(row)
|
|
expected={'uid':65534,'gid':65534,'groups':[]} if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534' else {'uid':os.getuid(),'gid':os.getgid(),'groups':os.getgroups()}
|
|
try:
|
|
result=subprocess.run([sys.executable,'-I','-c',SUPERVISOR,json.dumps(config,separators=(',',':'))],
|
|
input=payload,capture_output=True,timeout=deadline+12)
|
|
# Preserve real wrapper status and raw bytes before parsing any wire.
|
|
row['wrapper_rc']=result.returncode
|
|
row['wire_len']=len(result.stdout)
|
|
row['wire_sha']=hashlib.sha256(result.stdout).hexdigest()
|
|
try:
|
|
row['wire']=result.stdout.decode('utf-8','strict')
|
|
except UnicodeDecodeError:
|
|
row['wire_encoding']='base64'
|
|
row['wire']=base64.b64encode(result.stdout).decode()
|
|
row['wrapper_stderr']=base64.b64encode(result.stderr).decode()
|
|
if result.returncode!=0:
|
|
raise ValueError('supervisor exit '+str(result.returncode))
|
|
wire=json.loads(result.stdout)
|
|
if json.dumps(wire,separators=(',',':'),sort_keys=True).encode()==result.stdout:
|
|
row['wire_encoding']='canonical-json'
|
|
row['wire']=wire
|
|
ok,decoded=validate(wire,config,payload,expected)
|
|
if row['wire_encoding']=='canonical-json':
|
|
transformed=dict(wire)
|
|
periodic=False
|
|
for name,data in zip(('stdout','stderr'),decoded):
|
|
if len(data)>=1024:
|
|
block=data[:256]
|
|
repeats,tail=divmod(len(data),256)
|
|
if data==block*repeats+(data[-tail:] if tail else b''):
|
|
transformed[name]={'period_b64':base64.b64encode(block).decode(),
|
|
'repeat':repeats,'tail_b64':base64.b64encode(data[-tail:] if tail else b'').decode()}
|
|
periodic=True
|
|
if periodic:
|
|
row['wire_encoding']='canonical-json-periodic'
|
|
row['wire']=transformed
|
|
row['ok']=ok
|
|
if not ok:
|
|
row['error']='controlled rc/timeout/exception/reaping/absence failure'
|
|
return ok,decoded[0]
|
|
except BaseException as error:
|
|
row['error']=type(error).__name__+':'+repr(error)
|
|
return False,b''
|
|
|
|
|
|
def observations(raw):
|
|
text=raw.decode('utf-8','strict')
|
|
decoder=json.JSONDecoder()
|
|
values=[]
|
|
position=0
|
|
def numeric_tree(value):
|
|
if type(value) is int:
|
|
return True
|
|
return type(value) is list and all(numeric_tree(v) for v in value)
|
|
while position<len(text):
|
|
if text[position] in ' \t\r\n':
|
|
position+=1
|
|
continue
|
|
value,position=decoder.raw_decode(text,position)
|
|
if not numeric_tree(value) or type(value) is not list:
|
|
raise ValueError('observation JSON integer arrays')
|
|
values.append(value)
|
|
return values
|
|
|
|
|
|
def main():
|
|
evidence=[]
|
|
failures=[]
|
|
scratch=None
|
|
success=False
|
|
cleanup=False
|
|
absent=False
|
|
try:
|
|
context=json.loads(Path(__file__).with_name('context.json').read_text())
|
|
candidate=(Path(sys.argv[1])/'src/resource_job.cpp').read_bytes()
|
|
cases=make_cases()
|
|
wanted=[oracle(case) for case in cases]
|
|
payload=encode_input(cases)
|
|
scratch=Path(tempfile.mkdtemp(prefix='resource-open-stack-'))
|
|
work=scratch/'work'
|
|
work.mkdir(mode=0o777)
|
|
os.chmod(work,0o777)
|
|
materials={name:data.encode() for name,data in context.items()}
|
|
materials['src/resource_job.cpp']=candidate
|
|
materials['cases.txt']=payload
|
|
for name,data in materials.items():
|
|
destination=work/name
|
|
destination.parent.mkdir(parents=True,exist_ok=True)
|
|
destination.write_bytes(data)
|
|
for directory in [work,*[p for p in work.rglob('*') if p.is_dir()]]:
|
|
os.chmod(directory,0o777)
|
|
for path in [p for p in work.rglob('*') if p.is_file()]:
|
|
os.chmod(path,0o644)
|
|
built,_=run_stage('compiler',['g++','-std=c++17','-O2','-Wall','-Wextra','-Wpedantic','-Iinclude',
|
|
'src/resource_job.cpp','src/finite_store.cpp','src/observe.cpp','-o','resource-observe'],
|
|
work,COMPILE_SECONDS,b'',evidence)
|
|
if not built:
|
|
failures.append('compiler failed')
|
|
else:
|
|
ran,raw=run_stage('candidate',[str(work/'resource-observe')],work,CANDIDATE_SECONDS,payload,evidence)
|
|
if not ran:
|
|
failures.append('candidate controlled failure')
|
|
else:
|
|
actual=observations(raw)
|
|
if actual!=wanted:
|
|
index=next((i for i in range(min(len(actual),len(wanted))) if actual[i]!=wanted[i]),min(len(actual),len(wanted)))
|
|
failures.append('normal observation mismatch at case '+str(index))
|
|
else:
|
|
success=True
|
|
except BaseException as error:
|
|
failures.append(type(error).__name__+':'+repr(error))
|
|
finally:
|
|
if scratch is not None:
|
|
try:
|
|
cleanup,_=run_stage('cleanup',[sys.executable,'-I','-c',CLEANUP_CODE,str(scratch)],
|
|
'/tmp',CLEANUP_SECONDS,b'',evidence)
|
|
except BaseException as error:
|
|
failures.append('cleanup '+repr(error))
|
|
try:
|
|
absent,_=run_stage('absence',[sys.executable,'-I','-c',ABSENCE_CODE,str(scratch)],
|
|
'/tmp',ABSENCE_SECONDS,b'',evidence)
|
|
except BaseException as error:
|
|
failures.append('absence '+repr(error))
|
|
passed=success and cleanup and absent and not failures and all(row['ok'] and row['error'] is None for row in evidence)
|
|
record={'scratch':str(scratch) if scratch is not None else None,'success':success,'cleanup':cleanup,
|
|
'absent':absent,'failures':failures,'stages':evidence,'passed':passed}
|
|
def pack(value):
|
|
return base64.b85encode(lzma.compress(json.dumps(value,separators=(',',':'),sort_keys=True).encode(),preset=9)).decode()
|
|
packed=pack(record)
|
|
if len(packed)>3850:
|
|
# Preserve complete metadata even for incompressible diagnostic IO; never alter verdict.
|
|
for row in record['stages']:
|
|
if row['wire_encoding'] in ('canonical-json','canonical-json-periodic'):
|
|
wire=row['wire']
|
|
row['wire_encoding']='metadata-and-io-digests'
|
|
row['wire']={'meta':wire['meta']}
|
|
record['raw_io_omitted_for_log_capacity']=True
|
|
packed=pack(record)
|
|
print('EVIDENCE125:'+packed,file=sys.stderr)
|
|
if passed:
|
|
print('PASS')
|
|
return 0
|
|
print('FAIL: '+('; '.join(failures) if failures else 'cleanup, absence or stage metadata rejected'))
|
|
return 1
|
|
|
|
|
|
if __name__=='__main__':
|
|
raise SystemExit(main())
|