nx_rank_refresh_integration_gate.nx source
↩ module page · 263 lines · 15461 B
1// Local unbuilt integration harness. Native ranker/scorer, isolated fixture state.
2// argv: runner self existing-parent real-scorer captured-plan captured-matrix timeout-ms capture-bytes rank-budget
3import "nx_gate_verdict.nx"
4import "nx_tool_run.nx"
5import "nx_build_canon_input_lib.nx"
6import "nx_rank_refresh_lib.nx"
7const RIG_PATH: i64 = 4096
8const RIG_PTR: i64 = 8
9const RIG_ARG_SLOTS: i64 = 5
10const RIG_FILE_MODE: i64 = 384
11const RIG_DIR_MODE: i64 = 448
12const RIG_EINVAL: i64 = 0 - 22
13const RIG_SETUP: i64 = 90
14const RIG_SCORER_FAIL: i64 = 42
15const RIG_OK: i64 = 0
16const RIG_DEST_DIR: i64 = 1
17const RIG_LOCK: i64 = 2
18const RIG_BAD_SCORER: i64 = 3
19const RIG_DISPATCH: i64 = 4
20const RIG_GUARD: *u8 = "NISHI-RANK-REFRESH-FIXTURE\n"
21const RIG_OLD: *u8 = "# retained old rank fixture\n"
22const RIG_PLAN: *u8 = "rung|R1|Fixture open rung|rig_missing|Fixture only|Organ|1|-\nver|0.1|M1\nms|M1|Fixture milestone|1|R1\n"
23const RIG_MATRIX: *u8 = "@cols Reference\nFixture|runtime/rig_missing.nx|_ABSENT_:rig_missing|0|2|Fixture only\n"
24const RIG_ZERO_MATRIX: *u8 = "@cols Reference\nFixture|runtime/rig_missing.nx|rig_missing|0|2|Fixture all-present spelling exercises zero-open branch\n"
25
26func rig_len(p: *u8) -> i64 { var n: i64 = 0; while p[n] != (0 as u8) { n = n + 1 } return n }
27func rig_eq(a: *u8, b: *u8) -> i64 {
28 var i: i64 = 0
29 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
30 if b[i] != (0 as u8) { return 0 }
31 return 1
32}
33func rig_num(p: *u8) -> i64 {
34 let n: i64 = rig_len(p)
35 if n == 0 { return 0 - 1 }
36 var i: i64 = 0; var v: i64 = 0
37 while i < n {
38 let c: i64 = p[i] as i64
39 if c < BCI_ZERO { return 0 - 1 }
40 if c > BCI_NINE { return 0 - 1 }
41 let d: i64 = c - BCI_ZERO
42 if v > (BCI_I64_MAX-d)/BCI_DECIMAL_BASE { return 0 - 1 }
43 v = v*BCI_DECIMAL_BASE+d; i = i + 1
44 }
45 return v
46}
47func rig_join(root: *u8, rel: *u8) -> *u8 {
48 if rig_len(root)+rig_len(rel)+2 > RIG_PATH { return 0 as *u8 }
49 let p: *u8 = sys_mmap(RIG_PATH)
50 var o: i64 = gv_cat(p, 0, root)
51 o = gv_cat(p, o, "/" as *u8); o = gv_cat(p, o, rel); p[o] = 0 as u8
52 return p
53}
54func rig_exists(path: *u8) -> i64 {
55 if (path as i64) == 0 { return 0 }
56 let f: i64 = sys_openat_rd(path)
57 if f < 0 { return 0 }
58 sys_close(f); return 1
59}
60// Reject symlinks in every supplied parent component. No descendant is reused.
61func rig_parent(path: *u8) -> i64 {
62 let n: i64 = rig_len(path)
63 if n <= 1 { return 0 }
64 if n >= RIG_PATH { return 0 }
65 if path[0] != (BCI_SLASH as u8) { return 0 }
66 if bci_relative_path(path, 1, n-1, RIG_PATH-2) != 1 { return 0 }
67 let part: *u8 = sys_mmap(RIG_PATH)
68 let probe: *u8 = sys_mmap(RIG_PATH)
69 var i: i64 = 0
70 while i <= n {
71 var edge: i64 = 0
72 if i == n { edge = 1 } else { if i > 0 { if path[i] == (BCI_SLASH as u8) { edge = 1 } } }
73 if edge == 1 {
74 part[i] = 0 as u8
75 if sys_readlinkat(part, probe, RIG_PATH) != RIG_EINVAL { return 0 }
76 }
77 if i < n { part[i] = path[i] }
78 i = i + 1
79 }
80 return 1
81}
82func rig_write(path: *u8, buf: *u8, n: i64) -> i64 {
83 if (path as i64) == 0 { return 0 }
84 let fd: i64 = sys_openat_wr(path, RIG_FILE_MODE)
85 if fd < 0 { return 0 }
86 var w: i64 = 0
87 while w < n {
88 let got: i64 = sys_write(fd, (buf as i64+w) as *u8, n-w)
89 if got <= 0 { sys_close(fd); return 0 }
90 w = w + got
91 }
92 let sync: i64 = sys_fsync(fd)
93 let close: i64 = sys_close(fd)
94 if sync != 0 { return 0 }
95 if close != 0 { return 0 }
96 return rrf_file_equal(path, buf, n)
97}
98func rig_file(root: *u8, rel: *u8, val: *u8) -> i64 { return rig_write(rig_join(root,rel),val,rig_len(val)) }
99func rig_dir(root: *u8, rel: *u8) -> i64 {
100 let p: *u8 = rig_join(root, rel)
101 if (p as i64) == 0 { return 0 }
102 if sys_mkdir(p,RIG_DIR_MODE) != 0 { return 0 }
103 return 1
104}
105func rig_link(root: *u8, rel: *u8, target: *u8) -> i64 {
106 let p: *u8 = rig_join(root,rel)
107 if (p as i64) == 0 { return 0 }
108 if sys_symlinkat(target,p) != 0 { return 0 }
109 return 1
110}
111func rig_guard() -> i64 { return rrf_file_equal("fixture-root.guard" as *u8,RIG_GUARD,rig_len(RIG_GUARD)) }
112func rig_witness(argc: i64, argv: *i64) -> i64 {
113 if rig_guard() != 1 { return RIG_SETUP }
114 let invocation: *u8 = argv[0] as *u8
115 if tr_contains(invocation,rig_len(invocation),"nx_store_put.elf" as *u8) == 1 {
116 if argc == 3 { if rig_eq(argv[1] as *u8,"sponsor-" as *u8) == 1 { if rig_eq(argv[2] as *u8,"load" as *u8) == 1 {
117 if rig_file("." as *u8,"store-load.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
118 return 0
119 } } }
120 if rig_file("." as *u8,"plane-put.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
121 gv_puts("RIG fixture plane put witnessed\n" as *u8); return 0
122 }
123 if tr_contains(invocation,rig_len(invocation),"nx_pm_intake.elf" as *u8) == 1 {
124 if rig_file("." as *u8,"pm-ask.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
125 gv_puts("RIG fixture PM ask witnessed\n" as *u8); return 0
126 }
127 if rig_file("." as *u8,"scorer-fail.witness" as *u8,RIG_GUARD) != 1 { return RIG_SETUP }
128 gv_puts("{\"order\":[0],\"priorities\":[1]}\n" as *u8)
129 return RIG_SCORER_FAIL
130}
131func rig_setup(root: *u8, self: *u8, scorer: *u8, plan: *u8, pn: i64, matrix: *u8, mn: i64, mode: i64) -> i64 {
132 if sys_mkdir(root,RIG_DIR_MODE) != 0 { return 0 }
133 if rig_dir(root,"buildroot" as *u8) != 1 { return 0 }
134 if rig_dir(root,"buildroot/knowledge" as *u8) != 1 { return 0 }
135 if rig_dir(root,"buildroot/knowledge/compare" as *u8) != 1 { return 0 }
136 if rig_dir(root,"buildroot/runtime" as *u8) != 1 { return 0 }
137 if rig_dir(root,"knowledge" as *u8) != 1 { return 0 }
138 if rig_dir(root,"knowledge/status" as *u8) != 1 { return 0 }
139 if rig_file(root,"fixture-root.guard" as *u8,RIG_GUARD) != 1 { return 0 }
140 // cl_estate_path uses this marker before considering production EP_ROOT.
141 if rig_file(root,"daemons.reg" as *u8,"" as *u8) != 1 { return 0 }
142 if rig_file(root,"tool_allowlist.conf" as *u8,"" as *u8) != 1 { return 0 }
143 if rig_file(root,"cap_consent.log" as *u8,"" as *u8) != 1 { return 0 }
144 if rig_file(root,"knowledge/status/organ_kind.conf" as *u8,"" as *u8) != 1 { return 0 }
145 if rig_file(root,"knowledge/status/actlog.jrnl" as *u8,"" as *u8) != 1 { return 0 }
146 if rig_file(root,"knowledge/status/importers.tsv" as *u8,"" as *u8) != 1 { return 0 }
147 if rig_file(root,"knowledge/status/gateadjudicate.rows" as *u8,"" as *u8) != 1 { return 0 }
148 if rig_file(root,"knowledge/status/gateadjudicate.log" as *u8,"" as *u8) != 1 { return 0 }
149 if rig_file(root,"knowledge/status/execsurface.tsv" as *u8,"" as *u8) != 1 { return 0 }
150 if rig_file(root,"knowledge/status/selfsuff.ledger" as *u8,"" as *u8) != 1 { return 0 }
151 if rig_write(rig_join(root,"buildroot/knowledge/compare/deploy.plan" as *u8),plan,pn) != 1 { return 0 }
152 if rig_write(rig_join(root,"buildroot/knowledge/compare/deploy.matrix" as *u8),matrix,mn) != 1 { return 0 }
153 if rig_link(root,"nx_store_put.elf" as *u8,self) != 1 { return 0 }
154 if rig_link(root,"nx_pm_intake.elf" as *u8,self) != 1 { return 0 }
155 var sc: *u8 = scorer
156 if mode == RIG_BAD_SCORER { sc = self }
157 if rig_link(root,"nx_dr_ocm_cli.elf" as *u8,sc) != 1 { return 0 }
158 if mode == RIG_DEST_DIR { if rig_dir(root,"buildroot/knowledge/compare/deploy.rank" as *u8) != 1 { return 0 } }
159 else { if rig_file(root,"buildroot/knowledge/compare/deploy.rank" as *u8,RIG_OLD) != 1 { return 0 } }
160 return 1
161}
162func rig_case(runroot: *u8, name: *u8, runner: *u8, self: *u8, scorer: *u8, plan: *u8, pn: i64, matrix: *u8, mn: i64, mode: i64, expected: i64, timeout: i64, cap: i64, budget: *u8, ctr: *i64) -> i64 {
163 gv_puts("CASE " as *u8); gv_puts(name); gv_puts("\n" as *u8)
164 let root: *u8 = rig_join(runroot,name)
165 let setup: i64 = rig_setup(root,self,scorer,plan,pn,matrix,mn,mode)
166 gv_check_eq("setup" as *u8,setup,1,ctr)
167 if setup != 1 { return 0 }
168 var lockfd: i64 = 0 - 1
169 if mode == RIG_LOCK {
170 lockfd = sys_openat_rdwr(rig_join(root,"buildroot/knowledge/compare/deploy.rank.lock" as *u8),RIG_FILE_MODE)
171 if lockfd < 0 { gv_check_eq("parent lock open" as *u8,0,1,ctr); return 0 }
172 if sys_flock(lockfd,SYS_LOCK_EX | SYS_LOCK_NB) != 0 { sys_close(lockfd); gv_check_eq("parent lock held" as *u8,0,1,ctr); return 0 }
173 }
174 let av: *i64 = sys_mmap(RIG_ARG_SLOTS*RIG_PTR) as *i64
175 av[0] = runner as i64; av[1] = "deploy" as *u8 as i64; av[2] = budget as i64
176 av[3] = "--artifact-only" as *u8 as i64; av[4] = 0
177 if mode == RIG_DISPATCH { av[3] = 0 }
178 let out: *u8 = sys_mmap(cap)
179 let ln: *i64 = sys_mmap(RIG_PTR) as *i64
180 let rc: i64 = tr_run_capture_cwd(runner,av,out,cap,ln,timeout,root)
181 if lockfd >= 0 { sys_close(lockfd) }
182 gv_check_eq("ranker exit" as *u8,rc,expected,ctr)
183 var zero: i64 = 0
184 if (matrix as i64) == (RIG_ZERO_MATRIX as i64) { zero = 1 }
185 gv_check_eq("zero-open branch selection" as *u8,tr_contains(out,ln[0],"RANK: nothing open --" as *u8),zero,ctr)
186 gv_check("capture complete" as *u8,(ln[0]<cap) as i64,ctr)
187 gv_check_eq("capture persisted" as *u8,rig_write(rig_join(root,"ranker.out" as *u8),out,ln[0]),1,ctr)
188 gv_check_eq("sponsor load witnessed" as *u8,rig_exists(rig_join(root,"store-load.witness" as *u8)),1,ctr)
189 var dispatch: i64 = 0
190 if mode == RIG_DISPATCH { dispatch = 1 }
191 gv_check_eq("PM ask witness" as *u8,rig_exists(rig_join(root,"pm-ask.witness" as *u8)),dispatch,ctr)
192 gv_check_eq("plane put witness" as *u8,rig_exists(rig_join(root,"plane-put.witness" as *u8)),dispatch,ctr)
193 let rankpath: *u8 = rig_join(root,"buildroot/knowledge/compare/deploy.rank" as *u8)
194 if expected == 0 {
195 gv_check_eq("successful write diagnostic" as *u8,tr_contains(out,ln[0],"RANK artefact wrote=" as *u8),1,ctr)
196 let rn: *i64 = sys_mmap(RIG_PTR) as *i64
197 let rb: *u8 = sys_read_file(rankpath,rn)
198 gv_check("rank file readable" as *u8,((rb as i64)!=0) as i64,ctr)
199 if (rb as i64) != 0 {
200 let ph: *u8 = sys_mmap(RRF_HEX_BYTES+1); let mh: *u8 = sys_mmap(RRF_HEX_BYTES+1)
201 rrf_hash(plan,pn,ph); rrf_hash(matrix,mn,mh)
202 let metadata: *u8 = sys_mmap(RIG_PATH)
203 var o: i64 = gv_cat(metadata,0,"# inputs_v=1 plan_sha256=" as *u8); o = gv_cat(metadata,o,ph)
204 o = gv_cat(metadata,o," plan_bytes=" as *u8); o = gv_catn(metadata,o,pn)
205 o = gv_cat(metadata,o," matrix_sha256=" as *u8); o = gv_cat(metadata,o,mh)
206 o = gv_cat(metadata,o," matrix_bytes=" as *u8); o = gv_catn(metadata,o,mn)
207 o = gv_cat(metadata,o,"\n" as *u8)
208 gv_check_eq("exact input metadata" as *u8,tr_contains(rb,rn[0],metadata),1,ctr)
209 gv_check_eq("stamp domain" as *u8,tr_contains(rb,rn[0]," domain=deploy " as *u8),1,ctr)
210 gv_check_eq("open rank row emitted" as *u8,tr_contains(rb,rn[0],"\nrank|" as *u8),1-zero,ctr)
211 }
212 } else {
213 gv_check_eq("no successful write diagnostic" as *u8,tr_contains(out,ln[0],"RANK artefact wrote=" as *u8),0,ctr)
214 if mode != RIG_DEST_DIR { gv_check_eq("old artifact preserved" as *u8,rrf_file_equal(rankpath,RIG_OLD,rig_len(RIG_OLD)),1,ctr) }
215 }
216 if mode == RIG_DEST_DIR { gv_check_eq("actual rename failure reached" as *u8,tr_contains(out,ln[0],"RANK ARTEFACT WRITE-FAILED: rename" as *u8),1,ctr) }
217 if mode == RIG_LOCK { gv_check_eq("actual contention refusal" as *u8,tr_contains(out,ln[0],"writer lock unavailable" as *u8),1,ctr) }
218 if mode == RIG_BAD_SCORER { gv_check_eq("failed scorer executed" as *u8,rig_exists(rig_join(root,"scorer-fail.witness" as *u8)),1,ctr) }
219 return 1
220}
221func main(argc: i64, argv: *i64) -> i64 {
222 let inv: *u8 = argv[0] as *u8
223 var witness: i64 = tr_contains(inv,rig_len(inv),"nx_store_put.elf" as *u8)
224 witness = witness + tr_contains(inv,rig_len(inv),"nx_pm_intake.elf" as *u8)
225 witness = witness + tr_contains(inv,rig_len(inv),"nx_dr_ocm_cli.elf" as *u8)
226 if witness > 0 { let rc: i64 = rig_witness(argc,argv); sys_exit(rc); return rc }
227 if argc != 10 { gv_puts("usage: rank-refresh-gate runner self existing-parent real-scorer captured-plan captured-matrix timeout-ms capture-bytes rank-budget\n" as *u8); sys_exit(RIG_SETUP); return RIG_SETUP }
228 let runner: *u8 = argv[1] as *u8; let self: *u8 = argv[2] as *u8; let parent: *u8 = argv[3] as *u8
229 let scorer: *u8 = argv[4] as *u8; let planpath: *u8 = argv[5] as *u8; let matrixpath: *u8 = argv[6] as *u8
230 let timeout: i64 = rig_num(argv[7] as *u8); let cap: i64 = rig_num(argv[8] as *u8); let budget: *u8 = argv[9] as *u8
231 if timeout <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
232 if cap <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
233 if rig_num(budget) <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
234 if rig_parent(parent) != 1 { sys_exit(RIG_SETUP); return RIG_SETUP }
235 var ai: i64 = 1
236 while ai <= 6 {
237 if ai != 3 { let arg: *u8 = argv[ai] as *u8; if arg[0] != (BCI_SLASH as u8) { sys_exit(RIG_SETUP); return RIG_SETUP } if rig_exists(arg) != 1 { sys_exit(RIG_SETUP); return RIG_SETUP } }
238 ai = ai + 1
239 }
240 let pn: *i64 = sys_mmap(RIG_PTR) as *i64; let mn: *i64 = sys_mmap(RIG_PTR) as *i64
241 let plan: *u8 = sys_read_file(planpath,pn); let matrix: *u8 = sys_read_file(matrixpath,mn)
242 if (plan as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
243 if (matrix as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
244 if pn[0] <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
245 if mn[0] <= 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
246 let tag: *u8 = sys_mmap(RIG_PATH)
247 var o: i64 = gv_cat(tag,0,"rank-refresh-" as *u8); o = gv_catn(tag,o,sys_now_ms())
248 let root: *u8 = rig_join(parent,tag)
249 if (root as i64) == 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
250 if sys_mkdir(root,RIG_DIR_MODE) != 0 { sys_exit(RIG_SETUP); return RIG_SETUP }
251 let ctr: *i64 = gv_ctr()
252 gv_head("RANK REFRESH ACTUAL PROCESS INTEGRATION" as *u8)
253 gv_puts("fixture_root=" as *u8); gv_puts(root); gv_puts("\n" as *u8)
254 rig_case(root,"real-success" as *u8,runner,self,scorer,plan,pn[0],matrix,mn[0],RIG_OK,0,timeout,cap,budget,ctr)
255 rig_case(root,"real-write-failure" as *u8,runner,self,scorer,plan,pn[0],matrix,mn[0],RIG_DEST_DIR,7,timeout,cap,budget,ctr)
256 rig_case(root,"zero-open-success" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_ZERO_MATRIX,rig_len(RIG_ZERO_MATRIX),RIG_OK,0,timeout,cap,budget,ctr)
257 rig_case(root,"zero-open-write-failure" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_ZERO_MATRIX,rig_len(RIG_ZERO_MATRIX),RIG_DEST_DIR,7,timeout,cap,budget,ctr)
258 rig_case(root,"scorer-failure" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_BAD_SCORER,4,timeout,cap,budget,ctr)
259 rig_case(root,"lock-contention" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_LOCK,7,timeout,cap,budget,ctr)
260 rig_case(root,"dispatch-positive-control" as *u8,runner,self,scorer,RIG_PLAN,rig_len(RIG_PLAN),RIG_MATRIX,rig_len(RIG_MATRIX),RIG_DISPATCH,0,timeout,cap,budget,ctr)
261 let rc: i64 = gv_verdict("RANK-REFRESH-INTEGRATION",ctr,"actual candidate + real scorer; captured deploy input; isolated PM/plane witnesses; no promotion" as *u8)
262 sys_exit(rc); return rc
263}