code wiki / _hdl_build / nx_reconcile_ops.nx
nx_reconcile_ops.nx source
↩ module page · 264 lines · 14131 B
1// nx_reconcile_ops.nx -- gov lane F752 + zero-mysteries rung-1. Ops reconciler v1: diff the DECLARED
2// state (daemons.reg fleet + mgmt_snap.json supervisor fleet + desired_state.tsv) against LIVE procs
3// (/proc walk) = the observe+compare half of the K8s reconcile loop. CORRECT half = file debts; this
4// organ is READ-ONLY by construction (never kills procs -- the supervisor is crown-jewel; Rule 26).
5// Names the two-fleet split mechanically: reg rows whose health-port is absent from the snap + vice
6// versa (match = health-port equality, v1 declared); counts live nx_hostctl supervise procs vs the
7// declared desired count (knowledge/registry/desired_state.tsv, absent -> default 2 flagged).
8// nx_reconcile_ops run [daemons.reg] [snapfile] [desired.tsv] [outlog]
9// ENVELOPE (scale-law, declared in output): fleet tables 192 rows each; file windows 256KB; /proc
10// pids 4096; unmatched-name display 24/side. exit: 0 GREEN | 3 DRIFT | 4 ABSENT-INPUT | 2 usage.
11// license_tier: ORIGINAL expect_exit: 0
12import "nx_syscalls.nx"
13const K_MAGIC_32700: i64 = 32700
14const K_MAGIC_262144: i64 = 262144
15const K_MAGIC_32768: i64 = 32768
16const K_MAGIC_8192: i64 = 8192
17const K_MAGIC_8000: i64 = 8000
18const K_MAGIC_65536: i64 = 65536
19const K_MAGIC_4096: i64 = 4096
20const K_MAGIC_4095: i64 = 4095
21
22func ro_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
23func ro_b(rep: *u8, pos: i64, s: *u8) -> i64 { var p: i64 = pos; var i: i64 = 0; while s[i] != (0 as u8) { if p < K_MAGIC_32700 { rep[p] = s[i]; p = p + 1 } i = i + 1 } return p }
24func ro_bn(rep: *u8, pos: i64, v: i64) -> i64 { var p: i64 = pos; var m: i64 = v; if m < 0 { if p < K_MAGIC_32700 { rep[p] = 45 as u8; p = p + 1 } m = 0 - m } let t: *u8 = sys_mmap(28); var k: i64 = 0; if m == 0 { t[0] = 48 as u8; k = 1 } while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 } var i: i64 = 0; while i < k { if p < K_MAGIC_32700 { rep[p] = t[k - 1 - i]; p = p + 1 } i = i + 1 } return p }
25func ro_reads(path: *u8, buf: *u8, cap: i64) -> i64 {
26 let fd: i64 = sys_openat_rd(path)
27 if fd < 0 { return 0 - 1 }
28 var n: i64 = 0
29 var go: i64 = 1
30 while go == 1 { let r: i64 = sys_read(fd, (buf as i64 + n) as *u8, cap - n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap { go = 0 } }
31 sys_close(fd)
32 return n
33}
34func ro_find(buf: *u8, n: i64, pat: *u8) -> i64 {
35 var pl: i64 = 0
36 while pat[pl] != (0 as u8) { pl = pl + 1 }
37 if pl == 0 { return 0 }
38 var hit: i64 = 0
39 var i: i64 = 0
40 while i + pl <= n {
41 var k: i64 = 0
42 var m: i64 = 1
43 while k < pl { if buf[i + k] != pat[k] { m = 0; k = pl } else { k = k + 1 } }
44 if m == 1 { hit = 1; i = n } else { i = i + 1 }
45 }
46 return hit
47}
48func ro_isdigit(c: i64) -> i64 { if c < 48 { return 0 } if c > 57 { return 0 } return 1 }
49
50func main(argc: i64, argv: *i64) -> i64 {
51 if argc < 2 { ro_w(2, "usage: nx_reconcile_ops run [daemons.reg] [snapfile] [desired.tsv] [outlog]\n" as *u8); sys_exit(2); return 2 }
52 var regpath: *u8 = "daemons.reg" as *u8
53 var snappath: *u8 = "mgmt_snap.json" as *u8
54 var despath: *u8 = "knowledge/registry/desired_state.tsv" as *u8
55 var outpath: *u8 = "knowledge/status/reconcile_ops.log" as *u8
56 if argc >= 3 { regpath = argv[2] as *u8 }
57 if argc >= 4 { snappath = argv[3] as *u8 }
58 if argc >= 5 { despath = argv[4] as *u8 }
59 if argc >= 6 { outpath = argv[5] as *u8 }
60 let win: i64 = K_MAGIC_262144
61 let regbuf: *u8 = sys_mmap(win + 16)
62 let snapbuf: *u8 = sys_mmap(win + 16)
63 let rn: i64 = ro_reads(regpath, regbuf, win)
64 let sn: i64 = ro_reads(snappath, snapbuf, win)
65 let rep: *u8 = sys_mmap(K_MAGIC_32768)
66 var rp: i64 = 0
67 if rn < 0 { rp = ro_b(rep, rp, "RECONCILE-OPS verdict=ABSENT-INPUT reg unreadable\n" as *u8); sys_write(1, rep, rp); sys_exit(4); return 4 }
68 if sn < 0 { rp = ro_b(rep, rp, "RECONCILE-OPS verdict=ABSENT-INPUT snap unreadable\n" as *u8); sys_write(1, rep, rp); sys_exit(4); return 4 }
69 // ---- parse daemons.reg: name | cwd | argv | health_port | arm | probe ----
70 let cap: i64 = 192
71 let regport: *i64 = sys_mmap(cap * 8) as *i64
72 let regoff: *i64 = sys_mmap(cap * 8) as *i64
73 let nameblob: *u8 = sys_mmap(K_MAGIC_32768)
74 var nb: i64 = 0
75 var regn: i64 = 0
76 var regdrop: i64 = 0
77 var i: i64 = 0
78 while i < rn {
79 var e: i64 = i
80 while e < rn { if regbuf[e] == (10 as u8) { let z: i64 = e; e = rn + 1000 + z } else { e = e + 1 } }
81 if e > rn { e = e - rn - 1000 }
82 let c0: i64 = regbuf[i]
83 if c0 != 35 { if c0 > 32 {
84 // field0 name: up to first '|', trimmed
85 var j: i64 = i
86 var pend: i64 = 0 - 1
87 while j < e { if regbuf[j] == (124 as u8) { pend = j; j = e } else { j = j + 1 } }
88 if pend > i {
89 var last: i64 = pend - 1
90 while last > i { if regbuf[last] == (32 as u8) { last = last - 1 } else { let z2: i64 = last; last = 0 - 2 - z2 } }
91 if last < 0 { last = 0 - 2 - last }
92 if regn < cap {
93 regoff[regn] = nb
94 var t: i64 = i
95 while t <= last { if nb < K_MAGIC_32700 { nameblob[nb] = regbuf[t]; nb = nb + 1 } t = t + 1 }
96 nameblob[nb] = 0 as u8
97 nb = nb + 1
98 // health_port = field 3: skip to 3rd '|', then digits
99 var pipes: i64 = 0
100 var k: i64 = i
101 var port: i64 = 0
102 while k < e {
103 if regbuf[k] == (124 as u8) { pipes = pipes + 1 }
104 else { if pipes == 3 { let cc: i64 = regbuf[k]; if ro_isdigit(cc) == 1 { port = port * 10 + (cc - 48) } } }
105 if pipes >= 4 { k = e } else { k = k + 1 }
106 }
107 regport[regn] = port
108 regn = regn + 1
109 } else { regdrop = regdrop + 1 }
110 }
111 } }
112 i = e + 1
113 }
114 // ---- parse snap: lines 'SVC <name> <port> <state...>' ----
115 let snapport: *i64 = sys_mmap(cap * 8) as *i64
116 let snapoff: *i64 = sys_mmap(cap * 8) as *i64
117 var snapn: i64 = 0
118 var snapdrop: i64 = 0
119 i = 0
120 while i < sn {
121 var e2: i64 = i
122 while e2 < sn { if snapbuf[e2] == (10 as u8) { let z3: i64 = e2; e2 = sn + 1000 + z3 } else { e2 = e2 + 1 } }
123 if e2 > sn { e2 = e2 - sn - 1000 }
124 if i + 4 < e2 { if snapbuf[i] == (83 as u8) { if snapbuf[i+1] == (86 as u8) { if snapbuf[i+2] == (67 as u8) { if snapbuf[i+3] == (32 as u8) {
125 var j2: i64 = i + 4
126 if snapn < cap {
127 snapoff[snapn] = nb
128 while j2 < e2 { if snapbuf[j2] == (32 as u8) { let z4: i64 = j2; j2 = e2 + 1000 + z4 } else { if nb < K_MAGIC_32700 { nameblob[nb] = snapbuf[j2]; nb = nb + 1 } j2 = j2 + 1 } }
129 if j2 > e2 { j2 = j2 - e2 - 1000 }
130 nameblob[nb] = 0 as u8
131 nb = nb + 1
132 var port2: i64 = 0
133 var k2: i64 = j2 + 1
134 while k2 < e2 { let c2: i64 = snapbuf[k2]; if ro_isdigit(c2) == 1 { port2 = port2 * 10 + (c2 - 48); k2 = k2 + 1 } else { let z5: i64 = k2; k2 = e2 + 1000 + z5 } }
135 snapport[snapn] = port2
136 snapn = snapn + 1
137 } else { snapdrop = snapdrop + 1 }
138 } } } } }
139 i = e2 + 1
140 }
141 // ---- desired supervise count ----
142 var desired: i64 = 2
143 var dessrc: *u8 = "default-2-manifest-ABSENT" as *u8
144 let desbuf: *u8 = sys_mmap(K_MAGIC_8192)
145 let dn: i64 = ro_reads(despath, desbuf, K_MAGIC_8000)
146 if dn > 0 {
147 var di: i64 = 0
148 while di + 15 < dn {
149 var m2: i64 = 1
150 let pat2: *u8 = "supervise_procs" as *u8
151 var pk: i64 = 0
152 while pk < 15 { if desbuf[di + pk] != pat2[pk] { m2 = 0; pk = 15 } else { pk = pk + 1 } }
153 if m2 == 1 {
154 var dv: i64 = 0
155 var dj: i64 = di + 15
156 var seen: i64 = 0
157 while dj < dn { let dc: i64 = desbuf[dj]; if ro_isdigit(dc) == 1 { dv = dv * 10 + (dc - 48); seen = 1; dj = dj + 1 } else { if seen == 1 { let z6: i64 = dj; dj = dn + 1000 + z6 } else { if dc == 10 { let z7: i64 = dj; dj = dn + 1000 + z7 } else { dj = dj + 1 } } } }
158 if seen == 1 { desired = dv; dessrc = "manifest" as *u8 }
159 di = dn
160 } else { di = di + 1 }
161 }
162 }
163 // ---- /proc walk: count live supervise procs + nx_ procs ----
164 var supv: i64 = 0
165 var nxprocs: i64 = 0
166 var pids: i64 = 0
167 let pfd: i64 = sys_openat_rd("/proc" as *u8)
168 if pfd >= 0 {
169 let dbuf: *u8 = sys_mmap(K_MAGIC_65536)
170 let pathb: *u8 = sys_mmap(64)
171 let cbuf: *u8 = sys_mmap(K_MAGIC_4096)
172 pathb[0] = 47 as u8; pathb[1] = 112 as u8; pathb[2] = 114 as u8; pathb[3] = 111 as u8; pathb[4] = 99 as u8; pathb[5] = 47 as u8
173 var going: i64 = 1
174 while going == 1 {
175 let nd: i64 = sys_getdents64(pfd, dbuf, K_MAGIC_65536)
176 if nd <= 0 { going = 0 } else {
177 var p: i64 = 0
178 while p < nd {
179 let lo: i64 = dbuf[p + 16]
180 let hi: i64 = dbuf[p + 17]
181 let rl: i64 = lo + hi * 256
182 if rl <= 0 { p = nd } else {
183 let n0: i64 = dbuf[p + 19]
184 if ro_isdigit(n0) == 1 { if pids < K_MAGIC_4096 {
185 pids = pids + 1
186 var q: i64 = 6
187 var w: i64 = p + 19
188 var cgo: i64 = 1
189 while cgo == 1 { let ch: i64 = dbuf[w]; if ch == 0 { cgo = 0 } else { if q < 30 { pathb[q] = ch as u8; q = q + 1 } w = w + 1 } }
190 pathb[q] = 47 as u8; pathb[q+1] = 99 as u8; pathb[q+2] = 109 as u8; pathb[q+3] = 100 as u8; pathb[q+4] = 108 as u8; pathb[q+5] = 105 as u8; pathb[q+6] = 110 as u8; pathb[q+7] = 101 as u8; pathb[q+8] = 0 as u8
191 let cfd: i64 = sys_openat_rd(pathb)
192 if cfd >= 0 {
193 let cn: i64 = sys_read(cfd, cbuf, K_MAGIC_4095)
194 sys_close(cfd)
195 if cn > 0 {
196 var z8: i64 = 0
197 while z8 < cn { if cbuf[z8] == (0 as u8) { cbuf[z8] = 32 as u8 } z8 = z8 + 1 }
198 if ro_find(cbuf, cn, "nx_" as *u8) == 1 { nxprocs = nxprocs + 1 }
199 if ro_find(cbuf, cn, "nx_hostctl" as *u8) == 1 { if ro_find(cbuf, cn, "supervise" as *u8) == 1 { supv = supv + 1 } }
200 }
201 }
202 } }
203 p = p + rl
204 }
205 }
206 }
207 }
208 sys_close(pfd)
209 }
210 // ---- diff: port-equality match (v1, declared) ----
211 var matched: i64 = 0
212 var regonly: i64 = 0
213 var snaponly: i64 = 0
214 rp = ro_b(rep, rp, "RECONCILE-OPS reg_rows=" as *u8); rp = ro_bn(rep, rp, regn)
215 rp = ro_b(rep, rp, " snap_rows=" as *u8); rp = ro_bn(rep, rp, snapn)
216 rp = ro_b(rep, rp, " match=health-port-equality-v1 dropped_reg=" as *u8); rp = ro_bn(rep, rp, regdrop)
217 rp = ro_b(rep, rp, " dropped_snap=" as *u8); rp = ro_bn(rep, rp, snapdrop)
218 rp = ro_b(rep, rp, "\nREG-ONLY (declared in daemons.reg, NOT in supervisor snap): " as *u8)
219 var a: i64 = 0
220 var shown: i64 = 0
221 while a < regn {
222 var hit2: i64 = 0
223 var b2: i64 = 0
224 while b2 < snapn { if snapport[b2] == regport[a] { if regport[a] != 0 { hit2 = 1; b2 = snapn } else { b2 = b2 + 1 } } else { b2 = b2 + 1 } }
225 if hit2 == 1 { matched = matched + 1 } else {
226 regonly = regonly + 1
227 if shown < 24 { rp = ro_b(rep, rp, (nameblob as i64 + regoff[a]) as *u8); rp = ro_b(rep, rp, ":" as *u8); rp = ro_bn(rep, rp, regport[a]); rp = ro_b(rep, rp, " " as *u8); shown = shown + 1 }
228 }
229 a = a + 1
230 }
231 rp = ro_b(rep, rp, "\nSNAP-ONLY (supervised, NOT declared in daemons.reg): " as *u8)
232 var b3: i64 = 0
233 var shown2: i64 = 0
234 while b3 < snapn {
235 var hit3: i64 = 0
236 var a3: i64 = 0
237 while a3 < regn { if regport[a3] == snapport[b3] { if snapport[b3] != 0 { hit3 = 1; a3 = regn } else { a3 = a3 + 1 } } else { a3 = a3 + 1 } }
238 if hit3 == 0 {
239 snaponly = snaponly + 1
240 if shown2 < 24 { rp = ro_b(rep, rp, (nameblob as i64 + snapoff[b3]) as *u8); rp = ro_b(rep, rp, ":" as *u8); rp = ro_bn(rep, rp, snapport[b3]); rp = ro_b(rep, rp, " " as *u8); shown2 = shown2 + 1 }
241 }
242 b3 = b3 + 1
243 }
244 rp = ro_b(rep, rp, "\nSUPERVISE live=" as *u8); rp = ro_bn(rep, rp, supv)
245 rp = ro_b(rep, rp, " desired=" as *u8); rp = ro_bn(rep, rp, desired)
246 rp = ro_b(rep, rp, " src=" as *u8); rp = ro_b(rep, rp, dessrc)
247 rp = ro_b(rep, rp, "\nPROC-CENSUS nx_procs=" as *u8); rp = ro_bn(rep, rp, nxprocs)
248 rp = ro_b(rep, rp, " pids_scanned=" as *u8); rp = ro_bn(rep, rp, pids)
249 rp = ro_b(rep, rp, " (cap 4096)\nSUMMARY matched=" as *u8); rp = ro_bn(rep, rp, matched)
250 rp = ro_b(rep, rp, " reg_only=" as *u8); rp = ro_bn(rep, rp, regonly)
251 rp = ro_b(rep, rp, " snap_only=" as *u8); rp = ro_bn(rep, rp, snaponly)
252 var drift: i64 = 0
253 if regonly > 0 { drift = 1 }
254 if snaponly > 0 { drift = 1 }
255 if supv != desired { drift = 1 }
256 if drift == 1 { rp = ro_b(rep, rp, "\nVERDICT=DRIFT (declared SSOT split across 2 fleet lists and/or supervise-count drift; CORRECT half = unify registries + file debts, read-only organ never kills)\n" as *u8) }
257 else { rp = ro_b(rep, rp, "\nVERDICT=GREEN declared==live\n" as *u8) }
258 sys_write(1, rep, rp)
259 let ofd: i64 = sys_openat_append(outpath, 420)
260 if ofd >= 0 { sys_write(ofd, rep, rp); sys_close(ofd) }
261 if drift == 1 { sys_exit(3); return 3 }
262 sys_exit(0)
263 return 0
264}