nx_ioconfirm_integration_gate.nx source
↩ module page · 236 lines · 11922 B
1// LOCAL UNBUILT selective fixture harness. No production output paths are accepted.
2// args: producer existing-absolute-parent case timeout-ms capture-bytes samples gap-ms max-age-s
3import "nx_gate_verdict.nx"
4import "nx_tool_run.nx"
5import "nx_build_canon_input_lib.nx"
6import "nx_atomic_rewrite.nx"
7const IG_PATH: i64 = 4096
8const IG_FILE_MODE: i64 = 384
9const IG_DIR_MODE: i64 = 448
10const IG_EINVAL: i64 = 0 - 22
11const IG_SETUP: i64 = 90
12const IG_PTR: i64 = 8
13const IG_ARG_SLOTS: i64 = 6
14// Mirror the inspected sampler's accepted shape; no new sampling policy.
15const IG_SAMPLE_MAX: i64 = 15
16// Keep paths below the legacy writer's fixed512-byte parent and1024-byte temp buffers.
17const IG_PARENT_MAX: i64 = 320
18const IG_OLD: *u8 = "ts=1\nncpu=1\nblocked_confirmed=1\nproducer=fixture-old\n"
19const IG_NEW: *u8 = "fixture-new-complete-snapshot\n"
20func ig_len(p: *u8) -> i64 { var n: i64 = 0; while p[n] != (0 as u8) { n = n + 1 } return n }
21func ig_eq(a: *u8, b: *u8) -> i64 {
22 var i: i64 = 0
23 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
24 if b[i] != (0 as u8) { return 0 }
25 return 1
26}
27func ig_num(p: *u8) -> i64 {
28 let n: i64 = ig_len(p)
29 if n == 0 { return 0 - 1 }
30 var i: i64 = 0; var v: i64 = 0
31 while i < n {
32 let c: i64 = p[i] as i64
33 if c < BCI_ZERO { return 0 - 1 }
34 if c > BCI_NINE { return 0 - 1 }
35 let d: i64 = c - BCI_ZERO
36 if v > (BCI_I64_MAX-d)/BCI_DECIMAL_BASE { return 0 - 1 }
37 v = v*BCI_DECIMAL_BASE+d; i = i + 1
38 }
39 return v
40}
41func ig_join(root: *u8, rel: *u8) -> *u8 {
42 if ig_len(root)+ig_len(rel)+2 > IG_PATH { return 0 as *u8 }
43 let p: *u8 = sys_mmap(IG_PATH)
44 var o: i64 = gv_cat(p, 0, root)
45 o = gv_cat(p, o, "/" as *u8); o = gv_cat(p, o, rel); p[o] = 0 as u8
46 return p
47}
48func ig_exists(path: *u8) -> i64 {
49 if (path as i64) == 0 { return 0 }
50 let f: i64 = sys_openat_rd(path)
51 if f < 0 { return 0 }
52 sys_close(f); return 1
53}
54// Reject symlinks in every supplied parent component. No descendant is reused.
55func ig_parent(path: *u8) -> i64 {
56 let n: i64 = ig_len(path)
57 if n <= 1 { return 0 }
58 if n >= IG_PATH { return 0 }
59 if path[0] != (BCI_SLASH as u8) { return 0 }
60 if bci_relative_path(path, 1, n-1, IG_PATH-2) != 1 { return 0 }
61 let part: *u8 = sys_mmap(IG_PATH)
62 let probe: *u8 = sys_mmap(IG_PATH)
63 var i: i64 = 0
64 while i <= n {
65 var edge: i64 = 0
66 if i == n { edge = 1 } else { if i > 0 { if path[i] == (BCI_SLASH as u8) { edge = 1 } } }
67 if edge == 1 {
68 part[i] = 0 as u8
69 if sys_readlinkat(part, probe, IG_PATH) != IG_EINVAL { return 0 }
70 }
71 if i < n { part[i] = path[i] }
72 i = i + 1
73 }
74 return 1
75}
76// Independent read-loop oracle, deliberately separate from the subject's ar_same_file.
77func ig_file_equal(path: *u8, bytes: *u8, n: i64) -> i64 {
78 if n < 0 { return 0 }
79 if n >= IG_PATH { return 0 }
80 let fd: i64 = sys_openat_rd(path)
81 if fd < 0 { return 0 }
82 let buf: *u8 = sys_mmap(IG_PATH)
83 var got: i64 = 0
84 var done: i64 = 0
85 var good: i64 = 1
86 while done == 0 {
87 let r: i64 = sys_read(fd,(buf as i64+got) as *u8,n+1-got)
88 if r < 0 { good = 0; done = 1 } else {
89 if r == 0 { done = 1 } else { got = got+r; if got > n { done = 1 } }
90 }
91 }
92 if sys_close(fd) != 0 { good = 0 }
93 if got != n { good = 0 }
94 if good == 1 { var i: i64 = 0; while i < n { if buf[i] != bytes[i] { good = 0 } i = i+1 } }
95 sys_munmap(buf,IG_PATH)
96 return good
97}
98func ig_write(path: *u8, buf: *u8, n: i64) -> i64 {
99 if (path as i64) == 0 { return 0 }
100 let fd: i64 = sys_openat_wr(path, IG_FILE_MODE)
101 if fd < 0 { return 0 }
102 var w: i64 = 0
103 while w < n {
104 let got: i64 = sys_write(fd, (buf as i64+w) as *u8, n-w)
105 if got <= 0 { sys_close(fd); return 0 }
106 w = w + got
107 }
108 // Fixture visibility check only; persistence barriers belong to the subject under test.
109 let close: i64 = sys_close(fd)
110 if close != 0 { return 0 }
111 return ig_file_equal(path, buf, n)
112}
113func ig_selector(s: *u8) -> i64 {
114 if ig_eq(s,"legacy-positive" as *u8) == 1 { return 1 }
115 if ig_eq(s,"checked-positive" as *u8) == 1 { return 2 }
116 if ig_eq(s,"empty-preserves-old" as *u8) == 1 { return 3 }
117 if ig_eq(s,"temp-directory" as *u8) == 1 { return 4 }
118 if ig_eq(s,"rename-failure" as *u8) == 1 { return 5 }
119 if ig_eq(s,"lock-contention" as *u8) == 1 { return 6 }
120 if ig_eq(s,"producer-beat-read" as *u8) == 1 { return 7 }
121 return 0
122}
123func ig_writer(root: *u8, mode: i64, ctr: *i64) -> i64 {
124 let path: *u8 = ig_join(root,"status" as *u8)
125 if mode == 5 {
126 gv_check_eq("destination directory setup" as *u8,sys_mkdir(path,IG_DIR_MODE),0,ctr)
127 let marker: *u8 = ig_join(root,"status/retained-marker" as *u8)
128 if ig_write(marker,IG_OLD,ig_len(IG_OLD)) != 1 { return IG_SETUP }
129 gv_check_eq("checked rename refused" as *u8,atomic_rewrite_checked(path,IG_NEW,ig_len(IG_NEW)),AR_CHECK_RENAME,ctr)
130 gv_check_eq("destination directory preserved" as *u8,ig_file_equal(marker,IG_OLD,ig_len(IG_OLD)),1,ctr)
131 return 0
132 }
133 if ig_write(path,IG_OLD,ig_len(IG_OLD)) != 1 { return IG_SETUP }
134 if mode == 1 { gv_check_eq("legacy atomic writer positive" as *u8,atomic_rewrite(path,IG_NEW,ig_len(IG_NEW)),0,ctr) }
135 if mode == 2 { gv_check_eq("checked writer positive" as *u8,atomic_rewrite_checked(path,IG_NEW,ig_len(IG_NEW)),0,ctr) }
136 if mode == 3 { gv_check_eq("empty rejection" as *u8,atomic_rewrite_checked(path,IG_NEW,0),AR_CHECK_EMPTY,ctr) }
137 if mode == 4 {
138 if sys_mkdir(ig_join(root,"status.nxtmp" as *u8),IG_DIR_MODE) != 0 { return IG_SETUP }
139 gv_check_eq("temp directory open refusal" as *u8,atomic_rewrite_checked(path,IG_NEW,ig_len(IG_NEW)),AR_CHECK_OPEN,ctr)
140 }
141 var expected: *u8 = IG_OLD
142 if mode <= 2 { expected = IG_NEW }
143 gv_check_eq("exact status bytes" as *u8,ig_file_equal(path,expected,ig_len(expected)),1,ctr)
144 return 0
145}
146func ig_producer(root: *u8, producer: *u8, mode: i64, timeout: i64, cap: i64, samples: *u8, gap: *u8, maxage: *u8, ctr: *i64) -> i64 {
147 let path: *u8 = ig_join(root,"status" as *u8)
148 if ig_write(path,IG_OLD,ig_len(IG_OLD)) != 1 { return IG_SETUP }
149 var lockfd: i64 = 0 - 1
150 if mode == 6 {
151 lockfd = sys_openat_rdwr(ig_join(root,"status.lock" as *u8),IG_FILE_MODE)
152 if lockfd < 0 { return IG_SETUP }
153 if sys_flock(lockfd,SYS_LOCK_EX | SYS_LOCK_NB) != 0 { sys_close(lockfd); return IG_SETUP }
154 }
155 let av: *i64 = sys_mmap(IG_ARG_SLOTS*IG_PTR) as *i64
156 av[0] = producer as i64; av[1] = "beat" as *u8 as i64
157 av[2] = samples as i64; av[3] = gap as i64; av[4] = path as i64; av[5] = 0
158 let out: *u8 = sys_mmap(cap)
159 let ln: *i64 = sys_mmap(IG_PTR) as *i64
160 let start: i64 = sys_now_ms()
161 let rc: i64 = tr_run_capture_cwd(producer,av,out,cap,ln,timeout,root)
162 let elapsed: i64 = sys_now_ms()-start
163 if lockfd >= 0 { sys_close(lockfd) }
164 let timing: *u8 = sys_mmap(IG_PATH)
165 var o: i64 = gv_cat(timing,0,"producer_elapsed_ms=" as *u8)
166 o = gv_catn(timing,o,elapsed); o = gv_cat(timing,o,"\n" as *u8); timing[o] = 0 as u8
167 gv_puts(timing)
168 gv_check_eq("timing persisted" as *u8,ig_write(ig_join(root,"timing.txt" as *u8),timing,o),1,ctr)
169 gv_check("capture below capacity" as *u8,(ln[0]<cap) as i64,ctr)
170 gv_check_eq("producer capture retained" as *u8,ig_write(ig_join(root,"producer.out" as *u8),out,ln[0]),1,ctr)
171 if mode == 6 {
172 gv_check_eq("busy exit" as *u8,rc,5,ctr)
173 gv_check_eq("busy diagnostic" as *u8,tr_contains(out,ln[0],"IOCONFIRM-BEAT verdict=BUSY reason=writer-lock-unavailable" as *u8),1,ctr)
174 gv_check_eq("no measured receipt" as *u8,tr_contains(out,ln[0],"verdict=MEASURED" as *u8),0,ctr)
175 gv_check_eq("old status retained" as *u8,ig_file_equal(path,IG_OLD,ig_len(IG_OLD)),1,ctr)
176 // Source places BUSY return before ioa_measure_median. Timing is recorded, not a pressure claim.
177 return 0
178 }
179 gv_check_eq("single beat exit" as *u8,rc,0,ctr)
180 gv_check_eq("measured receipt" as *u8,tr_contains(out,ln[0],"\nverdict=MEASURED\n" as *u8),1,ctr)
181 if rc != 0 { return 0 }
182 let sn: *i64 = sys_mmap(IG_PTR) as *i64
183 let status: *u8 = sys_read_file(path,sn)
184 if (status as i64) == 0 { return IG_SETUP }
185 gv_check("published status nonempty" as *u8,(sn[0]>0) as i64,ctr)
186 gv_check_eq("producer field" as *u8,tr_contains(status,sn[0],"\nproducer=nx_ioconfirm\n" as *u8),1,ctr)
187 let receipt: *u8 = sys_mmap(IG_PATH)
188 var ro: i64 = gv_cat(receipt,0,"IOCONFIRM-BEAT wrote=" as *u8)
189 ro = gv_catn(receipt,ro,sn[0]); ro = gv_cat(receipt,ro," of=" as *u8)
190 ro = gv_catn(receipt,ro,sn[0]); ro = gv_cat(receipt,ro," " as *u8); receipt[ro] = 0 as u8
191 gv_check_eq("receipt byte counts match actual snapshot" as *u8,tr_contains(out,ln[0],receipt),1,ctr)
192 gv_check_eq("snapshot evidence retained" as *u8,ig_write(ig_join(root,"snapshot.txt" as *u8),status,sn[0]),1,ctr)
193 av[1] = "read" as *u8 as i64; av[2] = path as i64; av[3] = maxage as i64; av[4] = 0
194 let rrc: i64 = tr_run_capture_cwd(producer,av,out,cap,ln,timeout,root)
195 gv_check_eq("existing read exit" as *u8,rrc,0,ctr)
196 gv_check("read capture below capacity" as *u8,(ln[0]<cap) as i64,ctr)
197 gv_check_eq("existing read freshness" as *u8,tr_contains(out,ln[0]," verdict=FRESH\n" as *u8),1,ctr)
198 gv_check_eq("read capture retained" as *u8,ig_write(ig_join(root,"reader.out" as *u8),out,ln[0]),1,ctr)
199 gv_check_eq("reader did not mutate snapshot" as *u8,ig_file_equal(path,status,sn[0]),1,ctr)
200 return 0
201}
202func main(argc: i64, argv: *i64) -> i64 {
203 if argc != 9 { gv_puts("usage: ioconfirm-integration producer existing-absolute-parent case timeout-ms capture-bytes samples gap-ms max-age-s\n" as *u8); return IG_SETUP }
204 let producer: *u8 = argv[1] as *u8; let parent: *u8 = argv[2] as *u8
205 let selector: *u8 = argv[3] as *u8; let mode: i64 = ig_selector(selector)
206 let timeout: i64 = ig_num(argv[4] as *u8); let cap: i64 = ig_num(argv[5] as *u8)
207 let samples: *u8 = argv[6] as *u8; let gap: *u8 = argv[7] as *u8; let age: *u8 = argv[8] as *u8
208 if mode == 0 { return IG_SETUP }
209 if timeout <= 0 { return IG_SETUP }
210 if cap <= 0 { return IG_SETUP }
211 if cap > IG_PATH { return IG_SETUP }
212 if ig_num(samples) <= 0 { return IG_SETUP }
213 if ig_num(samples) > IG_SAMPLE_MAX { return IG_SETUP }
214 if ig_num(gap) <= 0 { return IG_SETUP }
215 if ig_num(gap) > BCI_I64_MAX/IG_SAMPLE_MAX { return IG_SETUP }
216 if ig_num(age) <= 0 { return IG_SETUP }
217 if ig_len(parent) > IG_PARENT_MAX { return IG_SETUP }
218 if ig_parent(parent) != 1 { return IG_SETUP }
219 if producer[0] != (BCI_SLASH as u8) { return IG_SETUP }
220 if ig_exists(producer) != 1 { return IG_SETUP }
221 let tag: *u8 = sys_mmap(IG_PATH)
222 var o: i64 = gv_cat(tag,0,"ioconfirm-fixture-" as *u8)
223 o = gv_catn(tag,o,sys_now_ms()); tag[o] = 0 as u8
224 let root: *u8 = ig_join(parent,tag)
225 if (root as i64) == 0 { return IG_SETUP }
226 // mkdir must succeed: never reuse an existing fixture, including timestamp collision.
227 if sys_mkdir(root,IG_DIR_MODE) != 0 { return IG_SETUP }
228 let ctr: *i64 = gv_ctr()
229 gv_head("IOCONFIRM SELECTIVE NATIVE INTEGRATION" as *u8)
230 gv_puts("fixture_root=" as *u8); gv_puts(root); gv_puts("\ncase=" as *u8); gv_puts(selector); gv_puts("\n" as *u8)
231 var rc: i64 = 0
232 if mode <= 5 { rc = ig_writer(root,mode,ctr) } else { rc = ig_producer(root,producer,mode,timeout,cap,samples,gap,age,ctr) }
233 gv_check_eq("fixture operations completed" as *u8,rc,0,ctr)
234 let result: i64 = gv_verdict("IOCONFIRM-INTEGRATION",ctr,"selected native fixture only; setup writes have no fsync; publication barriers unchanged; no deployment" as *u8)
235 sys_exit(result); return result
236}