nx_compare_receipt_gate_t138.nx source
↩ module page · 138 lines · 7562 B
1// nx_compare_receipt_gate_t138.nx -- Verifies transaction consistency and data integrity in a receipt comparison system.
2import "nx_compare_receipt_lib.nx"
3import "nx_gate_verdict.nx"
4func rt_path(root:*u8, name:*u8)->*u8 {
5 let b:*u8=rgr_alloc(rgr_len(root)+rgr_len(name)+2)
6 var o:i64=rgr_copy(b,0,root);o=rgr_copy(b,o,"/" as *u8);rgr_copy(b,o,name);return b
7}
8func rt_same(path:*u8, expected:*u8, n:i64)->i64 {
9 let len:*i64=sys_mmap(8) as *i64
10 let got:*u8=sys_read_file(path,len)
11 if (got as i64)<=0 {return 0}
12 var ok:i64=1
13 if len[0]!=n {ok=0}
14 var i:i64=0
15 while i<n && ok==1 {if got[i]!=expected[i] {ok=0} i=i+1}
16 sys_free_file(got,len[0]);return ok
17}
18func rt_tx()->*RgrTx {return rgr_alloc(13*8) as *RgrTx}
19func rt_seed(path:*u8,b:*u8,n:i64)->i64 {
20 let fd:i64=sys_openat_exclusive(path,420)
21 if fd<0 {return fd}
22 var rc:i64=rgr_write_all(fd,b,n)
23 if rc==0 {rc=sys_fsync(fd)}
24 let cc:i64=sys_close(fd)
25 if rc==0 {rc=cc}
26 return rc
27}
28func main()->i64 {
29 let ctr:*i64=gv_ctr();gv_head("COMPARE-RECEIPT-TRANSACTION")
30 let root:*u8=rgr_alloc(128)
31 var o:i64=rgr_copy(root,0,"/tmp/nx_compare_receipt_t138-" as *u8)
32 rgr_decimal(root,o,sys_now_realtime_us())
33 gv_check("isolated unique fixture directory",sys_mkdir(root,493)==0,ctr)
34 ja_puts("fixture_root=" as *u8);ja_puts(root);ja_puts("\n" as *u8)
35 let journal:*u8=rt_path(root,"comparepub.jrnl" as *u8)
36 let target:*u8=rt_path(root,"api.json" as *u8)
37 let old:*u8="1700000000\tlegacy-target\t12\t15\tSHRANK\n"
38 let repeats:i64=1048576/rgr_len(old)+2
39 let oldn:i64=repeats*rgr_len(old)
40 let history:*u8=rgr_alloc(oldn)
41 var i:i64=0
42 while i<oldn {history[i]=old[i%rgr_len(old)];i=i+1}
43 gv_check("representative history exceeds old 1MiB cap",oldn>1048576 && rt_seed(journal,history,oldn)==0,ctr)
44 let body:*u8="{\"fixture\":true}\n"
45 gv_check("prior artifact seeded",rt_seed(target,"old\n" as *u8,4)==0,ctr)
46 let tx:*RgrTx=rt_tx()
47 let rc:i64=rgr_transact(tx,journal,target,body,rgr_len(body),200,1700000001,"success" as *u8,0)
48 gv_check("durable intent artifact completion above 1MiB",rc==0 && tx.published==1 && tx.available>=tx.required,ctr)
49 gv_check("artifact exact emitter bytes",rt_same(target,body,rgr_len(body))==1,ctr)
50 let len:*i64=sys_mmap(8) as *i64
51 let all:*u8=sys_read_file(journal,len)
52 var exact:i64=1
53 if (all as i64)<=0 {exact=0}
54 if len[0]!=(oldn+tx.rowlen) {exact=0}
55 i=0
56 while i<oldn && exact==1 {if all[i]!=history[i] {exact=0} i=i+1}
57 gv_check("every historical byte remains exact",exact==1,ctr)
58 i=0
59 while i<tx.rowlen && exact==1 {if all[oldn+i]!=tx.row[i] {exact=0} i=i+1}
60 let expect:*u8=rgr_alloc(rgr_len(target)+128)
61 o=rgr_copy(expect,0,"1700000001\t" as *u8);o=rgr_copy(expect,o,target)
62 o=rgr_copy(expect,o,"\t17\t200\tSHRANK\n" as *u8)
63 var rowok:i64=1
64 if tx.rowlen!=o {rowok=0}
65 i=0
66 while i<o && rowok==1 {if expect[i]!=tx.row[i] {rowok=0} i=i+1}
67 gv_check("legacy completion row unchanged including SHRANK",exact==1 && rowok==1,ctr)
68 let intent:*u8=sys_read_file(tx.intentpath,len)
69 var complete:i64=0
70 if (intent as i64)>0 {
71 let marker:*u8="state=COMPLETED\n"
72 i=0
73 while i+rgr_len(marker)<=len[0] {
74 var j:i64=0
75 while j<rgr_len(marker) && intent[i+j]==marker[j] {j=j+1}
76 if j==rgr_len(marker) {complete=1}
77 i=i+1
78 }
79 }
80 gv_check("intent retains durable completion state",complete==1,ctr)
81 gv_check("checked descriptor release",rgr_release(tx)==0,ctr)
82 let collision:*RgrTx=rt_tx()
83 let cr:i64=rgr_transact(collision,journal,target,"replace\n" as *u8,8,16,1700000002,"success" as *u8,0)
84 gv_check("exclusive transaction collision refuses before publish",cr==RGR_E_INTENT && collision.published==0 && rt_same(target,body,17)==1,ctr)
85 rgr_release(collision)
86 let blocked:*RgrTx=rt_tx()
87 let lock:i64=ja_lock(journal)
88 let lr:i64=rgr_prepare(blocked,journal,target,body,17,16,1700000002,"locked" as *u8,0)
89 gv_check("archive-shared lock contention refuses before journal open",lock>=0 && lr==RGR_E_LOCK && blocked.published==0,ctr)
90 rgr_release(blocked);ja_unlock(lock)
91 let full:*RgrTx=rt_tx()
92 let fr:i64=rgr_transact(full,journal,target,"replace\n" as *u8,8,16,1700000002,"reserve" as *u8,RGR_I64_MAX)
93 gv_check("physical reserve exhaustion refuses before publish",fr==RGR_E_CAPACITY && full.published==0 && rt_same(target,body,17)==1,ctr)
94 rgr_release(full)
95 gv_check("capacity multiplication overflow refuses",rgr_capacity_numbers(RGR_I64_MAX,2,0,1)<0,ctr)
96 gv_check("capacity unknown malformed and negative reserve refuse",rgr_capacity_numbers(0,10,0,1)<0 && rgr_capacity_numbers(1,0-1,0,1)<0 && rgr_capacity_numbers(1,10,0-1,1)<0,ctr)
97 gv_check("capacity equality and one byte over have exact boundary",rgr_capacity_numbers(4096,3,4096,8192)==12288 && rgr_capacity_numbers(4096,3,4096,8193)<0,ctr)
98 let missing:*RgrTx=rt_tx()
99 let mr:i64=rgr_transact(missing,"/missing-receipt-t138/no/journal" as *u8,target,body,17,16,1700000002,"missing" as *u8,0)
100 gv_check("missing intent owner refuses with prior artifact available",mr==RGR_E_LOCK && missing.published==0 && rt_same(target,body,17)==1,ctr)
101 rgr_release(missing)
102 let bad:*u8=rt_path(root,"torn.jrnl" as *u8)
103 rt_seed(bad,"unfinished" as *u8,10)
104 let torn:*RgrTx=rt_tx()
105 let tr:i64=rgr_transact(torn,bad,target,body,17,16,1700000002,"torn" as *u8,0)
106 gv_check("torn historical row refuses without truncating evidence",tr==RGR_E_TAIL && rt_same(bad,"unfinished" as *u8,10)==1,ctr)
107 rgr_release(torn)
108 let disk:i64=sys_openat_wr("/dev/full" as *u8,420)
109 gv_check("real ENOSPC cannot become successful write",disk>=0 && rgr_write_all(disk,body,17)==(0-28),ctr)
110 sys_close(disk)
111 let nullfd:i64=sys_openat_wr("/dev/null" as *u8,420)
112 gv_check("real unsupported fsync reports failure",nullfd>=0 && sys_fsync(nullfd)<0,ctr)
113 sys_close(nullfd)
114 let pipe:*i64=sys_mmap(8) as *i64
115 let pr:i64=sys_pipe2(pipe,O_NONBLOCK)
116 let rd:i64=pipe[0]&0xffffffff
117 let wd:i64=(pipe[0]/4294967296)&0xffffffff
118 // FIONBIO is the Linux ioctl ABI, not a policy limit. Verify before any potentially blocking write.
119 let nonblock:*i64=sys_mmap(8) as *i64;nonblock[0]=1
120 let wb:i64=sys_ioctl(wd,0x5421,nonblock as i64)
121 let rb:i64=sys_ioctl(rd,0x5421,nonblock as i64)
122 var short:i64=0
123 var observed:i64=0
124 if pr==0 && wb==0 && rb==0 {short=rgr_write_all(wd,history,oldn);observed=sys_read(rd,history,oldn)}
125 gv_check("real short write then EAGAIN never reports full success",pr==0 && short<0 && observed>0 && observed<oldn,ctr)
126 sys_close(rd);sys_close(wd)
127 let failtx:*RgrTx=rt_tx()
128 let fp:i64=rgr_prepare(failtx,journal,target,"new-visible\n" as *u8,12,16,1700000003,"completion-fail" as *u8,0)
129 let pub:*i64=sys_mmap(16) as *i64
130 let aw:i64=rgr_write_atomic(target,"new-visible\n" as *u8,12,pub,(pub as i64+8) as *i64)
131 failtx.published=pub[0]
132 sys_close(failtx.intentfd)
133 let fc:i64=rgr_complete(failtx)
134 failtx.intentfd=0-1
135 gv_check("completion failure keeps published artifact and explicit failure",fp==0 && aw==0 && fc==RGR_E_COMPLETE && failtx.published==1 && rt_same(target,"new-visible\n" as *u8,12)==1,ctr)
136 rgr_release(failtx)
137 return gv_verdict("COMPARE-RECEIPT-TRANSACTION",ctr,"Private native filesystem fixtures. No live publish/archive; no automatic crash replay or quota guarantee.")
138}