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>
294 lines
31 KiB
Python
294 lines
31 KiB
Python
SUPERVISOR="import base64,ctypes,hashlib,json,os,signal,subprocess,sys,time\n\ndef stat_pid(pid):\n try:\n data=open('/proc/%d/stat'%pid,'rb').read()\n except (FileNotFoundError,ProcessLookupError):\n return None\n tail=data[data.rfind(b')')+2:].split()\n return dict(pid=pid,state=tail[0].decode('ascii'),ppid=int(tail[1]),pgid=int(tail[2]),start=int(tail[19]))\n\ndef table():\n result={}\n for name in os.listdir('/proc'):\n if name.isdigit():\n row=stat_pid(int(name))\n if row is not None:result[row['pid']]=row\n return result\n\ndef discover(rows,root,tracked):\n roots={root}\n for pid,start in tracked:\n row=rows.get(pid)\n if row and row['start']==start and row['state'] not in ('Z','X'):roots.add(pid)\n selected=set()\n changed=True\n while changed:\n changed=False\n for pid,row in rows.items():\n if pid!=root and pid not in selected and row['ppid'] in roots:\n selected.add(pid);roots.add(pid);changed=True\n for pid,start in tracked:\n row=rows.get(pid)\n if row and row['start']==start:selected.add(pid)\n return {(pid,rows[pid]['start']) for pid in selected}\n\ndef signal_fresh(token):\n pid,start=token\n row=stat_pid(pid)\n if row and row['start']==start and row['state'] not in ('Z','X'):\n try:os.kill(pid,signal.SIGKILL)\n except ProcessLookupError:pass\n\ndef group_present(rows,pgid):\n return any(row['pgid']==pgid for row in rows.values())\n\ndef main():\n raw_request=sys.stdin.buffer.readline()\n request=json.loads(raw_request)\n begin=time.monotonic();proc=None;tracked=set();errors=[];out=b'';err=b'';timed=False\n payload=b'';leader=None;leader_rc=None;reaped=False;desc_absent=False;pg_absent=False\n own=stat_pid(os.getpid())\n try:\n if ctypes.CDLL(None,use_errno=True).prctl(36,1,0,0,0)!=0:raise OSError(ctypes.get_errno(),'subreaper')\n proc=subprocess.Popen(request['argv'],cwd=request['cwd'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True)\n leader=stat_pid(proc.pid)\n if leader is None:raise RuntimeError('missing leader identity')\n tracked.add((proc.pid,leader['start']))\n payload=base64.b64decode(request['input'],validate=True)\n first=True\n while True:\n tracked |= discover(table(),os.getpid(),tracked)\n remaining=request['deadline']-(time.monotonic()-begin)\n if remaining<=0:\n timed=True\n break\n try:\n out,err=proc.communicate(payload if first else None,timeout=min(.05,remaining))\n leader_rc=proc.returncode;reaped=True\n break\n except subprocess.TimeoutExpired as partial:\n out=partial.output if partial.output is not None else out\n err=partial.stderr if partial.stderr is not None else err\n first=False\n except BaseException as error:\n errors.append(type(error).__name__+':'+str(error))\n finally:\n settle=time.monotonic()+3\n if proc is not None:\n while time.monotonic()<settle:\n try:\n # own Popen status is collected before any adopted waitpid.\n result=proc.poll()\n if result is not None:\n leader_rc=result;reaped=True\n rows=table();tracked|=discover(rows,os.getpid(),tracked)\n for token in sorted(tracked):signal_fresh(token)\n # Draining is required even after poll reaped the leader: descendants may have held its pipes.\n try:\n out,err=proc.communicate(timeout=.03)\n leader_rc=proc.returncode;reaped=True\n except subprocess.TimeoutExpired as partial:\n out=partial.output if partial.output is not None else out\n err=partial.stderr if partial.stderr is not None else err\n if reaped:\n while True:\n try:\n child,_=os.waitpid(-1,os.WNOHANG)\n if child==0:break\n except ChildProcessError:break\n rows=table();current=discover(rows,os.getpid(),tracked)\n tracked|=current\n desc_absent=not current\n pg_absent=not group_present(rows,leader['pgid']) if leader else False\n if reaped and desc_absent and pg_absent:break\n except BaseException as error:\n errors.append(type(error).__name__+':'+str(error))\n time.sleep(.02)\n try:\n rows=table();desc_absent=not discover(rows,os.getpid(),tracked)\n pg_absent=bool(leader) and not group_present(rows,leader['pgid'])\n except BaseException as error:\n errors.append(type(error).__name__+':'+str(error))\n rc=124 if timed else leader_rc if not errors else 125\n result=dict(request_length=len(raw_request),request_sha256=hashlib.sha256(raw_request).hexdigest(),input_length=len(payload),input_sha256=hashlib.sha256(payload).hexdigest(),nonce=request['nonce'],phase=request['phase'],argv=request['argv'],cwd=request['cwd'],deadline=request['deadline'],supervisor_pid=os.getpid(),supervisor_start=own['start'],leader_pid=leader['pid'] if leader else None,leader_start=leader['start'] if leader else None,leader_pgid=leader['pgid'] if leader else None,uid=os.getuid(),gid=os.getgid(),groups=os.getgroups(),leader_returncode=leader_rc,returncode=rc,leader_reaped=reaped,timeout=timed,descendants_absent=desc_absent,pg_absent=pg_absent,exceptions=errors,elapsed=time.monotonic()-begin)\n for name,data in [('stdout',out),('stderr',err)]:\n result[name]=base64.b64encode(data).decode('ascii');result[name+'_length']=len(data);result[name+'_sha256']=hashlib.sha256(data).hexdigest()\n wire=json.dumps(result,separators=(',',':')).encode()\n sys.stdout.buffer.write(wire);sys.stdout.buffer.flush()\nif __name__=='__main__':main()\n"
|
|
CANDIDATES=['codec.c', 'plan.c', 'writer.c', 'parser.c']
|
|
SUPPORT={'stream.h': b'#ifndef STREAM_H\n#define STREAM_H\n#include <stddef.h>\n#include <stdint.h>\n#include <stdio.h>\n#define ROW_LIMIT 32\n#define CHANNEL_LIMIT 8\n#define TEXT_LIMIT 256\n#define PLAN_LIMIT 110\nstruct record { int kind; int channel; int value; int tick; };\nstruct job { int serial; int count; int channels; int lower; int upper; int flags; struct record rows[ROW_LIMIT]; };\nstruct channel { int accepted; int filtered; int notes; long long sum; int minimum; int maximum; int last_tick; int first_tick; int low_tick; int high_tick; int previous; int rising; int falling; int repeated; int regressions; long long movement; long long intervals; int run; int longest_run; };\nstruct report {\n int error; int role; int accepted; int filtered; int invalid; int notes; int barriers;\n long long sum; unsigned checksum; size_t planned[3]; size_t delivered[3];\n struct channel channels[CHANNEL_LIMIT];\n};\nstruct text { char bytes[TEXT_LIMIT]; size_t length; int failed; };\nstruct line { int role; struct text text; };\nstruct plan { struct line lines[PLAN_LIMIT]; int count; };\nstruct ports {\n void *context;\n FILE *(*open)(void *, int, int);\n int (*write)(void *, FILE *, const char *, size_t);\n int (*flush)(void *, FILE *);\n int (*close)(void *, FILE *);\n};\nvoid text_reset(struct text *t);\nint text_char(struct text *t, char c);\nint text_word(struct text *t, const char *s);\nint text_unsigned(struct text *t, unsigned long long n);\nint text_signed(struct text *t, long long n);\nint text_field(struct text *t, long long n);\nint text_end(struct text *t);\nint format_data(struct text *t, const struct job *j, int ordinal, const struct record *r);\nint format_audit(struct text *t, const struct job *j, int ordinal, int status);\nint format_index(struct text *t, const struct job *j, int ordinal, size_t offset, size_t length);\nint format_barrier(struct text *t, const struct job *j, int ordinal, int tick);\nint format_total(struct text *t, const struct job *j, const struct report *r);\nint format_end(struct text *t, const struct job *j, int index, size_t bytes);\nint build_plan(const struct job *j, struct plan *p, struct report *r);\nint read_job(FILE *input, struct job *j, int failures[4]);\nint export_job(const struct job *j, const struct ports *ports, struct report *r);\n#endif\n', 'observer.c': b'#include "stream.h"\n#include <stdlib.h>\n#include <string.h>\nstruct event { char op; int role; int result; size_t length; unsigned char bytes[TEXT_LIMIT]; };\nstruct bench {\n FILE *files[3]; int active[3]; int serial; int failures[4]; int calls[4];\n struct event events[512]; int count;\n};\nstatic void event(struct bench *b,char op,int role,int result,const char *bytes,size_t length)\n{\n if(b->count>=512) return;\n struct event *e=&b->events[b->count++];\n e->op=op;e->role=role;e->result=result;e->length=length<TEXT_LIMIT?length:TEXT_LIMIT;\n if(bytes!=NULL) memcpy(e->bytes,bytes,e->length);\n}\nstatic int identify(struct bench *b,FILE *f)\n{\n for(int role=0;role<3;++role) if(b->active[role]&&b->files[role]==f) return role;\n return -9;\n}\nstatic int failed(struct bench *b,int kind)\n{\n b->calls[kind]+=1;\n return b->failures[kind]>0 && b->calls[kind]==b->failures[kind];\n}\nstatic FILE *port_open(void *context,int role,int serial)\n{\n struct bench *b=context;\n int result=failed(b,0)?-1:0;\n if(role<0||role>2||b->active[role]||serial!=b->serial) result=-9;\n FILE *f=NULL;\n if(result==0) { f=tmpfile();if(f==NULL) result=-8; }\n if(f!=NULL) { b->files[role]=f;b->active[role]=1; }\n event(b,\'O\',role,result,NULL,0);\n return f;\n}\nstatic int port_write(void *context,FILE *f,const char *bytes,size_t length)\n{\n struct bench *b=context;\n int role=identify(b,f);\n int result=failed(b,1)?-1:0;\n if(role<0||bytes==NULL||length>=TEXT_LIMIT) result=-9;\n if(result==0 && fwrite(bytes,1,length,f)!=length) result=-8;\n event(b,\'W\',role,result,bytes,bytes!=NULL?length:0);\n return result;\n}\nstatic int port_flush(void *context,FILE *f)\n{\n struct bench *b=context;\n int role=identify(b,f);\n int result=failed(b,2)?-1:0;\n if(role<0) result=-9;\n if(result==0 && fflush(f)!=0) result=-8;\n event(b,\'F\',role,result,NULL,0);\n return result;\n}\nstatic int port_close(void *context,FILE *f)\n{\n struct bench *b=context;\n int role=identify(b,f);\n int result=failed(b,3)?-1:0;\n if(role<0) result=-9;\n if(role>=0) { b->active[role]=0;if(fclose(f)!=0) result=-8; }\n event(b,\'C\',role,result,NULL,0);\n return result;\n}\nstatic void print_report(const struct report *r,int result)\n{\n printf("\\"report\\":[%d,%d,%d,%d,%d,%d,%d,%d,%lld,%u",result,r->error,r->role,r->accepted,r->filtered,r->invalid,r->notes,r->barriers,r->sum,r->checksum);\n for(int k=0;k<3;++k) printf(",%zu",r->planned[k]);\n for(int k=0;k<3;++k) printf(",%zu",r->delivered[k]);\n printf("],\\"channels\\":[");\n for(int k=0;k<CHANNEL_LIMIT;++k) {\n const struct channel *c=&r->channels[k];\n printf("%s[%d,%d,%d,%lld,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%lld,%lld,%d,%d]",k?",":"",c->accepted,c->filtered,c->notes,c->sum,c->minimum,c->maximum,c->last_tick,c->first_tick,c->low_tick,c->high_tick,c->previous,c->rising,c->falling,c->repeated,c->regressions,c->movement,c->intervals,c->run,c->longest_run);\n }\n printf("]");\n}\nstatic void print_trace(const struct bench *b)\n{\n printf(",\\"trace\\":[");\n for(int k=0;k<b->count;++k) {\n const struct event *e=&b->events[k];\n printf("%s[\\"%c\\",%d,%d,\\"",k?",":"",e->op,e->role,e->result);\n for(size_t i=0;i<e->length;++i) printf("%02x",e->bytes[i]);\n printf("\\"]");\n }\n printf("]");\n}\n\nstatic int observe_export(FILE *input)\n{\n struct job j;struct bench b;struct report r;\n memset(&j,0,sizeof(j));memset(&b,0,sizeof(b));memset(&r,0,sizeof(r));\n int n=read_job(input,&j,b.failures);\n if(n!=1) return n;\n b.serial=j.serial;\n struct ports ports={&b,port_open,port_write,port_flush,port_close};\n int result=export_job(&j,&ports,&r);\n int live=0;\n for(int role=0;role<3;++role) live+=b.active[role];\n printf("{");print_report(&r,result);print_trace(&b);printf(",\\"live\\":%d}\\n",live);\n for(int role=0;role<3;++role) if(b.active[role]) fclose(b.files[role]);\n return 1;\n}\nstatic void observe_parse(FILE *input)\n{\n struct job j;int failures[4];\n int status=read_job(input,&j,failures);\n printf("{\\"status\\":%d,\\"fields\\":[",status);\n if(status==1) {\n printf("%d,%d,%d,%d,%d,%d",j.serial,j.count,j.channels,j.lower,j.upper,j.flags);\n for(int i=0;i<4;++i)printf(",%d",failures[i]);\n for(int i=0;i<j.count;++i)printf(",%d,%d,%d,%d",j.rows[i].kind,j.rows[i].channel,j.rows[i].value,j.rows[i].tick);\n }\n printf("]}\\n");\n}\nstatic int framed(void)\n{\n char header[32];\n while(fgets(header,sizeof(header),stdin)!=NULL) {\n char kind=header[0];long n=strtol(header+2,NULL,10);\n if((kind!=\'E\'&&kind!=\'P\')||n<0||n>60000) return 2;\n unsigned char *bytes=malloc((size_t)n+1);\n if(bytes==NULL) return 2;\n if(fread(bytes,1,(size_t)n,stdin)!=(size_t)n){free(bytes);return 2;}\n FILE *input=tmpfile();\n if(input==NULL){free(bytes);return 2;}\n if(fwrite(bytes,1,(size_t)n,input)!=(size_t)n){free(bytes);fclose(input);return 2;}\n free(bytes);rewind(input);\n int result=1;\n if(kind==\'E\') result=observe_export(input);else observe_parse(input);\n fclose(input);\n if(result!=1) return 2;\n }\n return ferror(stdin)?2:0;\n}\nint main(int argc,char **argv)\n{\n if(argc==2 && strcmp(argv[1],"--framed")==0)return framed();\n if(argc!=1)return 2;\n for(;;) {\n int result=observe_export(stdin);\n if(result==0)return 0;\n if(result<0)return 2;\n }\n}\n'}
|
|
import base64,hashlib,json,math,os,random,re,stat,subprocess,sys,tempfile,time,uuid,zlib
|
|
from pathlib import Path
|
|
COMPILE_DEADLINE=15
|
|
CANDIDATE_DEADLINE=8
|
|
CLEANUP_DEADLINE=6
|
|
ABSENCE_DEADLINE=5
|
|
LAUNCH='import json,sys;exec(json.loads(sys.stdin.buffer.readline())["code"])'
|
|
CLEANUP='import shutil,sys;shutil.rmtree(sys.argv[1]);print(0)'
|
|
ABSENCE='import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: print(0)\nelse: print(1)'
|
|
|
|
def sha(data):return hashlib.sha256(data).hexdigest()
|
|
|
|
def proc_start(pid):
|
|
try:
|
|
with open('/proc/%d/stat'%pid,'rb') as stream:data=stream.read()
|
|
except (FileNotFoundError,ProcessLookupError):return None
|
|
return int(data[data.rfind(b')')+2:].split()[19])
|
|
|
|
def safe_read(root,name):
|
|
directory=os.open('/',os.O_RDONLY|os.O_DIRECTORY)
|
|
try:
|
|
for component in Path(os.path.abspath(root)).parts[1:]:
|
|
child=os.open(component,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW,dir_fd=directory)
|
|
os.close(directory);directory=child
|
|
file=os.open(name,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK,dir_fd=directory)
|
|
try:
|
|
info=os.fstat(file)
|
|
if not stat.S_ISREG(info.st_mode) or info.st_size>1048576:raise ValueError('source type/size')
|
|
data=b''
|
|
while len(data)<=1048576:
|
|
block=os.read(file,min(65536,1048577-len(data)))
|
|
if not block:break
|
|
data+=block
|
|
if len(data)>1048576:raise ValueError('source grew')
|
|
return data
|
|
finally:os.close(file)
|
|
finally:os.close(directory)
|
|
|
|
def model(case):
|
|
serial,count,channels,lower,upper,flags,*fail=case['header'];rows=case['rows']
|
|
c=[[0,0,0,0,0,0,-1]+[0]*12 for _ in range(8)]
|
|
totals=[0]*5;total=0;checksum=0;lines=[];planned=[0]*3;delivered=[0]*3
|
|
good=0<=serial<=1000000 and 1<=channels<=8 and -1000<=lower<=upper<=1000 and flags in (0,1)
|
|
def append(role,text):lines.append((role,(text+'\n').encode('ascii')))
|
|
if good:
|
|
offset=0
|
|
for i,(kind,ch,value,tick) in enumerate(rows):
|
|
valid=kind in (0,1,2) and 0<=tick<=65535 and -32768<=value<=32767 and ((ch==0 and value==0) if kind==2 else 0<=ch<channels)
|
|
status=3 if not valid else 4 if kind==1 else 5 if kind==2 else 1 if lower<=value<=upper else 2
|
|
totals[status-1]+=1
|
|
if status==1:
|
|
q=c[ch]
|
|
if q[0]==0:q[4]=q[5]=value;q[7]=q[8]=q[9]=tick;q[17]=q[18]=1
|
|
else:
|
|
q[4]=min(q[4],value);q[5]=max(q[5],value);q[8]=min(q[8],tick);q[9]=max(q[9],tick)
|
|
diff=value-q[10];dt=tick-q[6];q[16]+=dt;q[14]+=int(dt<0);q[15]+=abs(diff)
|
|
q[11 if diff>0 else 12 if diff<0 else 13]+=1
|
|
q[17]=q[17]+1 if diff==0 else 1;q[18]=max(q[18],q[17])
|
|
q[0]+=1;q[3]+=value;q[6]=tick;q[10]=value
|
|
total+=value;checksum=(checksum+((value+32768)*31+tick)*17+ch+i)%1000003
|
|
elif status==2:c[ch][1]+=1
|
|
elif status==4:c[ch][2]+=1
|
|
length=0
|
|
if status in (1,5):
|
|
text=f'D {serial} {i} {ch} {tick} {value}' if status==1 else f'B {serial} {i} {tick}'
|
|
append(0,text);length=len(lines[-1][1])
|
|
append(1,f'A {serial} {i} {status}')
|
|
if flags and length:append(2,f'I {serial} {i} {offset} {length}')
|
|
offset+=length
|
|
for ch in range(channels):
|
|
q=c[ch];append(1,f'S {serial} {ch} {q[0]} {q[3]} {q[15]} {q[14]} {q[18]}')
|
|
append(0,'T '+' '.join(map(str,[serial,*totals,total,checksum])));offset+=len(lines[-1][1])
|
|
append(1,f'Z {serial} {count}')
|
|
if flags:append(2,f'E {serial} {offset}')
|
|
for role,data in lines:planned[role]+=len(data)
|
|
trace=[];error=0 if good else 1;error_role=-1;active=[];calls=[0]*4
|
|
def call(op,role,data=b''):
|
|
index='OWFC'.index(op);calls[index]+=1;rc=-1 if fail[index]>0 and calls[index]==fail[index] else 0
|
|
trace.append([op,role,rc,data.hex()]);return rc
|
|
def latch(code,role):
|
|
nonlocal error,error_role
|
|
if error==0:error=code;error_role=role
|
|
if good:
|
|
for role in range(3 if flags else 2):
|
|
if call('O',role):latch(10,role);break
|
|
active.append(role)
|
|
if error==0:
|
|
for role,data in lines:
|
|
if call('W',role,data):latch(20,role);break
|
|
delivered[role]+=len(data)
|
|
if error==0:
|
|
for role in active:
|
|
if call('F',role):latch(30,role);break
|
|
for role in reversed(active):
|
|
if call('C',role):latch(40,role)
|
|
return {'report':[0 if error==0 else -1,error,error_role,*totals,total,checksum,*planned,*delivered],'channels':c,'trace':trace,'live':0}
|
|
|
|
def scenarios():
|
|
rng=random.Random(29002026);result=[]
|
|
def add(rows,flags=1,fails=(0,0,0,0),serial=None,channels=3,lower=-10,upper=20):
|
|
result.append(dict(header=[rng.randrange(1000001) if serial is None else serial,len(rows),channels,lower,upper,flags,*fails],rows=rows))
|
|
base=[[0,0,7,1],[0,0,7,0],[0,0,-10,65535],[0,0,20,2],[1,1,999,3],[2,0,0,4],[0,1,21,8],[9,0,0,1],[0,3,0,1]]
|
|
for flags in (0,1):
|
|
add([],flags);add(base,flags)
|
|
for op in range(4):
|
|
for n in range(1,(4 if op!=1 else 34)):
|
|
fail=[0]*4;fail[op]=n;add(base,flags,tuple(fail))
|
|
add(base,flags,(2,1,1,1));add(base,flags,(0,3,1,1));add(base,flags,(0,0,1,1))
|
|
for _ in range(90):
|
|
count=rng.choice([0,1,2,8,32]);channels=rng.randint(1,8);rows=[]
|
|
for i in range(count):
|
|
rows.append([rng.choice([0,0,0,1,2,3]),rng.choice([0,channels-1,channels,-1]),rng.choice([-32769,-1000,-10,0,20,1000,32767,32768]),rng.choice([-1,0,1,65535,65536])])
|
|
add(rows,rng.randrange(2),tuple(rng.choice([0,0,0,1,2,3,999]) for _ in range(4)),channels=channels,lower=-1000,upper=1000)
|
|
for kwargs in [dict(serial=-1),dict(serial=1000001),dict(channels=0),dict(channels=9),dict(lower=-1001),dict(upper=1001),dict(lower=21),dict(flags=2)]:
|
|
add(base,**kwargs)
|
|
for value in [-1000,0,1000]:
|
|
add([[0,0,value,1]]*32,channels=1,lower=value,upper=value)
|
|
return result
|
|
|
|
def input_chunks(cases):
|
|
chunks=[]
|
|
for index,case in enumerate(cases):
|
|
values=case['header']+sum(case['rows'],[])
|
|
if index==0:
|
|
chunks.append(('+'+'0'*5000+str(values[0])+' '+ ' '.join(map(str,values[1:]))+'\n').encode())
|
|
elif index%7==0:
|
|
chunks.append(('\t'.join(('+' if n>=0 else '-')+'000'+str(abs(n)) for n in values)+'\r\n').encode())
|
|
else:chunks.append((' '.join(map(str,values))+'\n').encode())
|
|
return chunks
|
|
|
|
|
|
def parse_reference(blob):
|
|
values=[];position=0
|
|
def token():
|
|
nonlocal position
|
|
while position<len(blob) and blob[position] in b' \t\r\n':position+=1
|
|
if position==len(blob):return None
|
|
start=position
|
|
while position<len(blob) and blob[position] not in b' \t\r\n':position+=1
|
|
text=blob[start:position]
|
|
if re.fullmatch(rb'[+-]?[0-9]+',text) is None:raise ValueError('lexical')
|
|
negative=text.startswith(b'-');digits=text.lstrip(b'+-').lstrip(b'0') or b'0'
|
|
if len(digits)>10:raise ValueError('range')
|
|
value=int(digits)*(-1 if negative else 1)
|
|
if not -2147483648<=value<=2147483647:raise ValueError('range')
|
|
return value
|
|
try:
|
|
first=token()
|
|
if first is None:return dict(status=0,fields=[])
|
|
values.append(first)
|
|
for _ in range(9):
|
|
value=token()
|
|
if value is None:raise ValueError('truncated')
|
|
values.append(value)
|
|
if not 0<=values[1]<=32 or any(n<0 for n in values[6:10]):raise ValueError('header')
|
|
for _ in range(values[1]*4):
|
|
value=token()
|
|
if value is None:raise ValueError('truncated')
|
|
values.append(value)
|
|
return dict(status=1,fields=values)
|
|
except ValueError:return dict(status=-1,fields=[])
|
|
|
|
def parser_cases():
|
|
valid=b'42 1 2 -10 20 1 0 0 0 0\n0 1 -10 65535\n'
|
|
cases=[b'',b' \t\r\n',valid,valid+b'invalid trailing data',b'+00042 0 2 -10 20 1 -0 +0 000 0',b'0 0 0 0 0 0 0 0 0 0']
|
|
cases += [valid[:index] for index in [1,3,8,12,20,len(valid)-8]]
|
|
cases += [valid.replace(b'42',value,1) for value in [b'+',b'-',b'1_0',b'0x10',b'1.0',b'\xff',b'2147483648',b'-2147483649',b'2147483647',b'-2147483648',b'+'+b'0'*5000,b'-'+b'0'*5000,b'0'*5000]]
|
|
cases += [valid.replace(b' ',sep,1) for sep in [b'\v',b'\f',b'\x00',b'\t',b'\r\n']]
|
|
cases += [b'0 '+str(count).encode()+b' 1 0 0 0 0 0 0 0' for count in [-1,33,2147483647]]
|
|
cases += [b'0 0 1 0 0 0 -1 0 0 0',b'0 0 1 0 0 0 0 -1 0 0',b'0 0 1 0 0 0 0 0 -1 0',b'0 0 1 0 0 0 0 0 0 -1']
|
|
return cases
|
|
|
|
def validate_integer(value,positive=False):
|
|
if type(value) is not int or (positive and value<=0):raise ValueError('integer metadata')
|
|
|
|
def validate_wire(wire,request,pid,start,identity,request_bytes,payload):
|
|
if type(wire) is not dict:raise ValueError('wire object')
|
|
for name in ['nonce','phase','argv','cwd','deadline']:
|
|
if wire[name]!=request[name]:raise ValueError('request mismatch '+name)
|
|
for name,data in [('request',request_bytes),('input',payload)]:
|
|
validate_integer(wire[name+'_length'])
|
|
if wire[name+'_length']!=len(data) or wire[name+'_sha256']!=sha(data):raise ValueError('inner actual bytes mismatch '+name)
|
|
if type(wire['deadline']) is not int:raise ValueError('deadline metadata')
|
|
for name in ['supervisor_pid','supervisor_start','leader_pid','leader_start','leader_pgid']:validate_integer(wire[name],True)
|
|
if wire['supervisor_pid']!=pid or wire['supervisor_start']!=start:raise ValueError('actual Popen binding')
|
|
if wire['leader_pid']==pid or wire['leader_pgid']!=wire['leader_pid']:raise ValueError('leader identity')
|
|
for name in ['uid','gid']:validate_integer(wire[name])
|
|
groups=wire['groups']
|
|
if type(groups) is not list or any(type(n) is not int for n in groups):raise ValueError('groups metadata')
|
|
if [wire['uid'],wire['gid'],sorted(groups)]!=identity:raise ValueError('execution identity')
|
|
elapsed=wire['elapsed']
|
|
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0<=elapsed<=request['deadline']+4:raise ValueError('elapsed metadata')
|
|
for name in ['timeout','leader_reaped','descendants_absent','pg_absent']:
|
|
if type(wire[name]) is not bool:raise ValueError('boolean metadata')
|
|
for name in ['returncode','leader_returncode']:validate_integer(wire[name])
|
|
if wire['returncode']!=(124 if wire['timeout'] else wire['leader_returncode'] if not wire['exceptions'] else 125):raise ValueError('returncode inconsistency')
|
|
if type(wire['exceptions']) is not list or any(type(x) is not str for x in wire['exceptions']):raise ValueError('exceptions metadata')
|
|
raw={}
|
|
for name in ['stdout','stderr']:
|
|
size=wire[name+'_length'];validate_integer(size)
|
|
if size<0:raise ValueError('negative IO length')
|
|
data=base64.b64decode(wire[name],validate=True)
|
|
if len(data)!=size or sha(data)!=wire[name+'_sha256']:raise ValueError('IO bytes mismatch')
|
|
raw[name]=data
|
|
if wire['timeout'] or wire['returncode']!=0 or wire['leader_returncode']!=0 or not all(wire[n] for n in ['leader_reaped','descendants_absent','pg_absent']) or wire['exceptions']:raise ValueError('controlled stage failure')
|
|
return raw
|
|
|
|
def run_phase(name,argv,cwd,payload,deadline,logs):
|
|
request=dict(nonce=uuid.uuid4().hex,phase=name,argv=argv,cwd=cwd,input=base64.b64encode(payload).decode(),deadline=deadline)
|
|
request_bytes=(json.dumps(request,separators=(',',':'))+'\n').encode()
|
|
raw=(json.dumps({'code':SUPERVISOR},separators=(',',':'))+'\n').encode()+request_bytes
|
|
actual=[sys.executable,'-I','-c',LAUNCH]
|
|
evidence=dict(phase=name,nonce=request['nonce'],wrapper_argv=actual,wrapper_cwd='/',request_length=len(raw),request_sha256=sha(raw),input_length=len(payload),input_sha256=sha(payload),deadline=deadline,exceptions=[])
|
|
logs.append(evidence);begin=time.monotonic();proc=None
|
|
try:
|
|
proc=subprocess.Popen(actual,cwd='/',stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
|
|
evidence['popen_pid']=proc.pid;evidence['popen_start']=proc_start(proc.pid)
|
|
try:output,diagnostic=proc.communicate(raw,timeout=deadline+5)
|
|
except subprocess.TimeoutExpired as error:
|
|
output=error.output or b'';diagnostic=error.stderr or b''
|
|
evidence.update(wrapper_rc=None,wire_length=len(output),wire_sha256=sha(output),wrapper_stderr_length=len(diagnostic),wrapper_stderr_sha256=sha(diagnostic),outer_timeout=True,inner_cleanup='unknown')
|
|
raise RuntimeError('outer deadline; partial wire retained as length/digest, inner cleanup unknown')
|
|
# Save raw wrapper facts before attempting JSON or field validation.
|
|
evidence.update(wrapper_rc=proc.returncode,wire_length=len(output),wire_sha256=sha(output),wrapper_stderr_length=len(diagnostic),wrapper_stderr_sha256=sha(diagnostic),outer_timeout=False)
|
|
wire=json.loads(output)
|
|
evidence['wire']={k:v for k,v in wire.items() if k not in ('stdout','stderr')} if isinstance(wire,dict) else wire
|
|
if proc.returncode!=0 or diagnostic:raise ValueError('supervisor wrapper nonzero/diagnostic')
|
|
isolated=os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534'
|
|
identity=[65534,65534,[]] if isolated else [os.getuid(),os.getgid(),sorted(os.getgroups())]
|
|
data=validate_wire(wire,request,proc.pid,evidence['popen_start'],identity,request_bytes,payload)
|
|
evidence['inner_cleanup']='confirmed'
|
|
return data['stdout'],data['stderr']
|
|
except BaseException as error:
|
|
evidence['exceptions'].append(type(error).__name__+':'+str(error));raise
|
|
finally:evidence['outer_elapsed']=time.monotonic()-begin
|
|
|
|
def strict_value(actual,expected):
|
|
if type(actual) is not type(expected):return False
|
|
if isinstance(expected,dict):return actual.keys()==expected.keys() and all(strict_value(actual[k],v) for k,v in expected.items())
|
|
if isinstance(expected,list):return len(actual)==len(expected) and all(strict_value(a,b) for a,b in zip(actual,expected))
|
|
return actual==expected
|
|
|
|
def main(candidate):
|
|
logs=[];errors=[];scratch=None;success=False;clean=False;absent=False;observations=0
|
|
try:
|
|
scratch=tempfile.mkdtemp(prefix='resource-streams-')
|
|
isolated=os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534'
|
|
if isolated:os.chown(scratch,65534,65534)
|
|
material={name:safe_read(candidate,name) for name in CANDIDATES}
|
|
work=os.path.join(scratch,'build');os.mkdir(work,0o755)
|
|
if isolated:os.chown(work,65534,65534)
|
|
for name,data in dict(material,**SUPPORT).items():
|
|
path=os.path.join(work,name)
|
|
with open(path,'wb') as stream:stream.write(data)
|
|
if isolated:os.chown(path,65534,65534)
|
|
cases=scenarios();chunks=input_chunks(cases);expected=[model(c) for c in cases]
|
|
parser_inputs=parser_cases();expected.extend(parse_reference(blob) for blob in parser_inputs)
|
|
payload=b''.join(b'E '+str(len(blob)).encode()+b'\n'+blob for blob in chunks)+b''.join(b'P '+str(len(blob)).encode()+b'\n'+blob for blob in parser_inputs)
|
|
argv=['cc','-std=c11','-O2','-Wall','-Wextra','-Werror','-pedantic','-o',os.path.join(work,'app'),'observer.c',*CANDIDATES]
|
|
run_phase('compile',argv,work,b'',COMPILE_DEADLINE,logs)
|
|
output,diagnostic=run_phase('candidate',[os.path.join(work,'app'),'--framed'],work,payload,CANDIDATE_DEADLINE,logs)
|
|
# stderr has no semantic restriction; arbitrary bytes are diagnostic only.
|
|
diagnostic.decode('utf-8','replace')
|
|
rows=output.splitlines()
|
|
if len(rows)!=len(expected):raise ValueError('stdout row count')
|
|
for index,(line,want) in enumerate(zip(rows,expected)):
|
|
got=json.loads(line)
|
|
if not strict_value(got,want):raise ValueError('first raw observation difference row '+str(index))
|
|
observations+=1
|
|
success=True
|
|
except BaseException as error:errors.append(type(error).__name__+':'+str(error))
|
|
finally:
|
|
if scratch is not None:
|
|
try:
|
|
output,_=run_phase('cleanup',[sys.executable,'-I','-c',CLEANUP,scratch],'/',b'',CLEANUP_DEADLINE,logs)
|
|
if output!=b'0\n':raise ValueError('cleanup raw result')
|
|
clean=True
|
|
except BaseException as error:errors.append('cleanup '+type(error).__name__+':'+str(error))
|
|
try:
|
|
output,_=run_phase('absence',[sys.executable,'-I','-c',ABSENCE,scratch],'/',b'',ABSENCE_DEADLINE,logs)
|
|
if output!=b'0\n':raise ValueError('scratch still present')
|
|
absent=True
|
|
except BaseException as error:errors.append('absence '+type(error).__name__+':'+str(error))
|
|
record=dict(stages=logs,exceptions=errors,success=success,cleanup=clean,absence=absent,observations=observations,io_preservation='length and SHA256 only; raw child IO not archived by this checker')
|
|
packed=base64.b64encode(zlib.compress(json.dumps(record,separators=(',',':')).encode(),9)).decode()
|
|
sys.stderr.write('STREAM_EVIDENCE '+packed+'\n')
|
|
passed=success and clean and absent and not errors and all(not s['exceptions'] for s in logs)
|
|
print('PASS' if passed else 'FAIL '+('|'.join(errors) or 'incomplete'))
|
|
return 0 if passed else 1
|
|
if __name__=='__main__':raise SystemExit(main(sys.argv[1]))
|