code wiki / _hdl_build / nx_pub_plane.nx
nx_pub_plane.nx source
↩ module page · 491 lines · 26316 B
1// nx_pub_plane.nx -- THE PUBLISHING PLANE driver: one command, every site, all discovery artifacts
2// DERIVED from the per-site registry. The organ the operator asked for when they said publishing is
3// "random and arbitrary" and that they want to "focus on work, not on where something was put".
4//
5// nx_pub_plane list [conf] the configured sites (proves the site table parses)
6// nx_pub_plane emit <site> [conf] write <docroot>/{sitemap.xml,robots.txt,llms.txt}
7// nx_pub_plane emitall [conf] every configured site, one pass
8// nx_pub_plane adopt <site> [conf] bring UNREGISTERED docroot entries into the registry
9// (idempotent; the migration step that must run BEFORE
10// the gateway starts refusing, or it refuses live pages)
11// nx_pub_plane check <site> <relpath> [conf] THE GATEWAY: exit 0 publishable, 3 REFUSED
12//
13// Proof lives in the sibling verifier nx_pub_plane_gate.nx (the /api/gate_run route executes
14// VERIFIERS ONLY -- a name ending in gate/test/kat -- which is what keeps that route never-brick).
15// Default site table: knowledge/pub_sites.conf (DATA -- adding a site is a row, never a recompile).
16// license_tier: ORIGINAL No hw writes (Rule 26). expect_exit: 0
17import "nx_pub_lib.nx"
18import "nx_pub_release_lib.nx"
19import "nx_syscalls.nx"
20
21const PP_CONF: i64 = 65536
22const PP_SPANS: i64 = 128
23const PP_PATHCAP: i64 = 1024
24const PP_NAMECAP: i64 = 256
25const PP_SPAN: i64 = 16
26const PP_ARG_A: i64 = 2
27const PP_ARG_B: i64 = 3
28const PP_ARG_C: i64 = 4
29const PP_EXIT_USAGE: i64 = 2
30const PP_EXIT_REFUSED: i64 = 3
31const PP_EXIT_EMIT: i64 = 1
32const PP_EXIT_NOSITE: i64 = 4
33const PP_HASH: i64 = 35
34const PP_OUTCAP: i64 = 1048576
35
36func pp_puts(s: *u8) -> i64 { return pl_puts(s) }
37func pp_werr(s: *u8) -> i64 { return pl_werr(s) }
38func pp_num(v: i64) -> i64 {
39 let b: *u8 = sys_mmap(PP_NAMECAP)
40 let n: i64 = pl_catn(b, 0, v)
41 b[n] = 0 as u8
42 pl_puts(b)
43 sys_munmap(b, PP_NAMECAP)
44 return 0
45}
46func pp_span_puts(q: *u8, s: i64, e: i64) -> i64 {
47 let b: *u8 = sys_mmap(PP_PATHCAP)
48 pl_span_cstr(q, s, e, b)
49 pl_puts(b)
50 sys_munmap(b, PP_PATHCAP)
51 return 0
52}
53
54// emit all three discovery artifacts for ONE resolved site. Returns 0 ok, -1 on any emit failure.
55func pp_emit_site(conf: *u8, spans: *i64, site: *u8) -> i64 {
56 let docroot: *u8 = sys_mmap(PP_PATHCAP)
57 let prefix: *u8 = sys_mmap(PP_PATHCAP)
58 let baseurl: *u8 = sys_mmap(PP_PATHCAP)
59 let title: *u8 = sys_mmap(PP_PATHCAP)
60 let outp: *u8 = sys_mmap(PP_PATHCAP)
61 // PP_SPANS not PP_SPAN: sts_load_honest fills THREE i64 flags -- 16B was a live arena overrun
62 let flags: *i64 = sys_mmap(PP_SPANS) as *i64
63 pl_span_cstr(conf, spans[0], spans[1], docroot)
64 pl_span_cstr(conf, spans[2], spans[3], prefix)
65 pl_span_cstr(conf, spans[4], spans[5], baseurl)
66 pl_span_cstr(conf, spans[6], spans[7], title)
67 var rc: i64 = 0
68 pl_join(outp, docroot, "sitemap.xml" as *u8)
69 let nurl: i64 = pl_sitemap(docroot, prefix, baseurl, outp, flags)
70 if nurl < 0 { rc = 0 - 1 }
71 pl_join(outp, docroot, "robots.txt" as *u8)
72 let nd: i64 = pl_robots(baseurl, conf, spans[8], spans[9], outp)
73 if nd < 0 { rc = 0 - 1 }
74 pl_join(outp, docroot, "llms.txt" as *u8)
75 let nl: i64 = pl_llms(docroot, prefix, baseurl, title, outp)
76 if nl < 0 { rc = 0 - 1 }
77 // SELF-REGISTER what we just wrote, so the plane's own output is never an orphan on its own desk.
78 // Idempotent: already-present paths are left alone, so a human's curated row is never overwritten.
79 var reg_added: i64 = 0
80 if pl_register_asset(prefix, "sitemap.xml" as *u8, "derived from the registry by nx_pub_plane emit" as *u8) == 1 { reg_added = reg_added + 1 }
81 if pl_register_asset(prefix, "robots.txt" as *u8, "derived from the registry by nx_pub_plane emit" as *u8) == 1 { reg_added = reg_added + 1 }
82 if pl_register_asset(prefix, "llms.txt" as *u8, "derived from the registry by nx_pub_plane emit" as *u8) == 1 { reg_added = reg_added + 1 }
83 pp_puts("PUB-EMIT site=" as *u8)
84 pp_puts(site)
85 pp_puts(" urls=" as *u8)
86 pp_num(nurl)
87 pp_puts(" disallow=" as *u8)
88 pp_num(nd)
89 pp_puts(" llms_links=" as *u8)
90 pp_num(nl)
91 pp_puts(" self_registered=" as *u8)
92 pp_num(reg_added)
93 pp_puts(" registry_declared=" as *u8)
94 pp_num(flags[0])
95 pp_puts(" loaded=" as *u8)
96 pp_num(flags[1])
97 // HONESTY: a registry that could not be fully reached must never look like a complete site.
98 if flags[2] > 0 {
99 pp_puts(" UNREACHED_BEYOND_COUNT=" as *u8)
100 pp_num(flags[2])
101 }
102 pp_puts(" -> " as *u8)
103 pp_puts(docroot)
104 pp_puts("\n" as *u8)
105 sys_munmap(docroot, PP_PATHCAP)
106 sys_munmap(prefix, PP_PATHCAP)
107 sys_munmap(baseurl, PP_PATHCAP)
108 sys_munmap(title, PP_PATHCAP)
109 sys_munmap(outp, PP_PATHCAP)
110 return rc
111}
112
113// walk the site table; mode 0 = list, mode 1 = emit each. Returns sites handled, or -1.
114func pp_walk(confpath: *u8, mode: i64) -> i64 {
115 let conf: *u8 = sys_mmap(PP_CONF)
116 let n: i64 = pl_rfile(confpath, conf, PP_CONF)
117 if n <= 0 { return 0 - 1 }
118 let c: *i64 = sys_mmap(PP_SPAN) as *i64
119 let spans: *i64 = sys_mmap(PP_SPANS) as *i64
120 let namb: *u8 = sys_mmap(PP_NAMECAP)
121 var cnt: i64 = 0
122 var bad: i64 = 0
123 var i: i64 = 0
124 while i < n {
125 let le: i64 = pl_le(conf, i, n)
126 var skip: i64 = 0
127 if le <= i { skip = 1 }
128 if skip == 0 { if conf[i] == (PP_HASH as u8) { skip = 1 } }
129 if skip == 0 {
130 if pl_col(conf, i, le, PL_S_SITE, c) == 1 {
131 pl_span_cstr(conf, c[0], c[1], namb)
132 var ok: i64 = 1
133 if pl_col(conf, i, le, PL_S_DOCROOT, c) == 1 { spans[0] = c[0]; spans[1] = c[1] } else { ok = 0 }
134 if pl_col(conf, i, le, PL_S_PREFIX, c) == 1 { spans[2] = c[0]; spans[3] = c[1] } else { ok = 0 }
135 if pl_col(conf, i, le, PL_S_BASEURL, c) == 1 { spans[4] = c[0]; spans[5] = c[1] } else { ok = 0 }
136 if pl_col(conf, i, le, PL_S_TITLE, c) == 1 { spans[6] = c[0]; spans[7] = c[1] } else { ok = 0 }
137 spans[8] = 0
138 spans[9] = 0
139 if pl_col(conf, i, le, PL_S_DISALLOW, c) == 1 { spans[8] = c[0]; spans[9] = c[1] }
140 if ok == 1 {
141 cnt = cnt + 1
142 if mode == 0 {
143 pp_puts("PUB-SITE " as *u8)
144 pp_puts(namb)
145 pp_puts("\tdocroot=" as *u8)
146 pp_span_puts(conf, spans[0], spans[1])
147 pp_puts("\tregistry=" as *u8)
148 pp_span_puts(conf, spans[2], spans[3])
149 pp_puts("\tbase=" as *u8)
150 pp_span_puts(conf, spans[4], spans[5])
151 pp_puts("\n" as *u8)
152 }
153 if mode == 1 { if pp_emit_site(conf, spans, namb) != 0 { bad = bad + 1 } }
154 } else {
155 pp_werr("PUB-FAIL malformed site row (need site/docroot/regprefix/baseurl/title)\n" as *u8)
156 bad = bad + 1
157 }
158 }
159 }
160 i = le + 1
161 }
162 sys_munmap(conf, PP_CONF)
163 sys_munmap(c as *u8, PP_SPAN)
164 sys_munmap(spans as *u8, PP_SPANS)
165 sys_munmap(namb, PP_NAMECAP)
166 if bad > 0 { return 0 - 1 }
167 return cnt
168}
169
170// ---- THE PUBLISHING DESK: one page, EVERY site, every number DERIVED ---------------------------
171// The desk that existed was single-site (it did not know andelinwest existed) and stale by half a day,
172// because it was generated once and never re-derived. This one walks the SITE TABLE, so a site added
173// as a config row appears here with no code change, and every figure comes from pl_status_counts /
174// pl_disk_counts -- the registry plane and a live docroot walk. Nothing on this page is hand-written.
175func pp_board(confpath: *u8, outpath: *u8) -> i64 {
176 let conf: *u8 = sys_mmap(PP_CONF)
177 let n: i64 = pl_rfile(confpath, conf, PP_CONF)
178 if n <= 0 { return 0 - 1 }
179 let out: *u8 = sys_mmap(PP_OUTCAP)
180 let c: *i64 = sys_mmap(PP_SPAN) as *i64
181 let sc: *i64 = sys_mmap(PP_SPANS) as *i64
182 let dc: *i64 = sys_mmap(PP_SPANS) as *i64
183 let docroot: *u8 = sys_mmap(PP_PATHCAP)
184 let prefix: *u8 = sys_mmap(PP_PATHCAP)
185 var o: i64 = 0
186 o = pl_cat(out, o, "<!doctype html>\n<html lang=\"en\"><head><meta charset=\"utf-8\">\n" as *u8)
187 o = pl_cat(out, o, "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n" as *u8)
188 o = pl_cat(out, o, "<title>Publishing desk -- every site, derived from the registry</title>\n" as *u8)
189 o = pl_cat(out, o, "<style>body{font:16px/1.6 system-ui,-apple-system,Segoe UI,sans-serif;color:#16202e;background:#fff;margin:0}main{max-width:960px;margin:0 auto;padding:24px 20px 64px}h1{font-size:1.6rem;margin:0 0 4px}h2{color:#0b2545;margin:32px 0 8px;font-size:1.15rem}.sub{color:#5a6b85;margin:0 0 24px}table{border-collapse:collapse;width:100%;margin:10px 0 4px}th,td{text-align:left;padding:7px 10px;border-bottom:1px solid #e3e9f2}th{color:#5a6b85;font-weight:600;font-size:.85rem;letter-spacing:.02em}td.n{text-align:right;font-variant-numeric:tabular-nums}.k{color:#5a6b85;font-size:.85rem}.warn{color:#a3341f;font-weight:600}.ok{color:#1d6b3f;font-weight:600}.card{border:1px solid #dce3ec;border-left:4px solid #0b2545;border-radius:8px;padding:14px 18px;margin:14px 0;background:#fbfcfe}code{background:#eef2f8;padding:1px 5px;border-radius:3px;font-size:.9em}</style>\n" as *u8)
190 o = pl_cat(out, o, "</head><body><main>\n" as *u8)
191 o = pl_cat(out, o, "<h1>Publishing desk</h1>\n" as *u8)
192 o = pl_cat(out, o, "<p class=sub>Every site in <code>knowledge/pub_sites.conf</code>, with every number read live from that site's registry plane and a walk of its docroot. Adding a site is a config row, not a code change. Nothing on this page is hand-maintained.</p>\n" as *u8)
193 var nsite: i64 = 0
194 var i: i64 = 0
195 while i < n {
196 let le: i64 = pl_le(conf, i, n)
197 var skip: i64 = 0
198 if le <= i { skip = 1 }
199 if skip == 0 { if conf[i] == (PP_HASH as u8) { skip = 1 } }
200 if skip == 0 {
201 if pl_col(conf, i, le, PL_S_SITE, c) == 1 {
202 var ok: i64 = 1
203 var ds: i64 = 0
204 var de: i64 = 0
205 var ps: i64 = 0
206 var pe: i64 = 0
207 var bs: i64 = 0
208 var be: i64 = 0
209 let nameS: i64 = c[0]
210 let nameE: i64 = c[1]
211 if pl_col(conf, i, le, PL_S_DOCROOT, c) == 1 { ds = c[0]; de = c[1] } else { ok = 0 }
212 if pl_col(conf, i, le, PL_S_PREFIX, c) == 1 { ps = c[0]; pe = c[1] } else { ok = 0 }
213 if pl_col(conf, i, le, PL_S_BASEURL, c) == 1 { bs = c[0]; be = c[1] } else { ok = 0 }
214 if ok == 1 {
215 nsite = nsite + 1
216 pl_span_cstr(conf, ds, de, docroot)
217 pl_span_cstr(conf, ps, pe, prefix)
218 pl_status_counts(prefix, sc)
219 pl_disk_counts(docroot, prefix, dc)
220 o = pl_cat(out, o, "<h2>" as *u8)
221 o = pl_span_put(out, o, conf, nameS, nameE)
222 o = pl_cat(out, o, "</h2>\n<p class=k>" as *u8)
223 o = pl_span_put(out, o, conf, bs, be)
224 o = pl_cat(out, o, " · docroot <code>" as *u8)
225 o = pl_span_put(out, o, conf, ds, de)
226 o = pl_cat(out, o, "</code> · registry <code>" as *u8)
227 o = pl_span_put(out, o, conf, ps, pe)
228 o = pl_cat(out, o, "</code></p>\n" as *u8)
229 o = pl_cat(out, o, "<table><tr><th>registry status</th><th>rows</th><th>meaning</th></tr>\n" as *u8)
230 o = pl_cat(out, o, "<tr><td>live</td><td class=n>" as *u8); o = pl_catn(out, o, sc[0])
231 o = pl_cat(out, o, "</td><td class=k>indexable; in sitemap.xml and llms.txt</td></tr>\n" as *u8)
232 o = pl_cat(out, o, "<tr><td>asset</td><td class=n>" as *u8); o = pl_catn(out, o, sc[1])
233 o = pl_cat(out, o, "</td><td class=k>served, never indexed</td></tr>\n" as *u8)
234 o = pl_cat(out, o, "<tr><td>draft</td><td class=n>" as *u8); o = pl_catn(out, o, sc[2])
235 o = pl_cat(out, o, "</td><td class=k>registered, publishable, NOT indexed -- where adoption lands pages</td></tr>\n" as *u8)
236 o = pl_cat(out, o, "<tr><td>withdrawn</td><td class=n>" as *u8); o = pl_catn(out, o, sc[3])
237 o = pl_cat(out, o, "</td><td class=k>must not be served; the edge 404s a removed URL</td></tr>\n" as *u8)
238 o = pl_cat(out, o, "<tr><td>redirect</td><td class=n>" as *u8); o = pl_catn(out, o, sc[4])
239 o = pl_cat(out, o, "</td><td class=k>successor URL in the note column</td></tr>\n" as *u8)
240 o = pl_cat(out, o, "<tr><td>debris</td><td class=n>" as *u8); o = pl_catn(out, o, sc[5])
241 o = pl_cat(out, o, "</td><td class=k>rollback/backup artifacts; refused by the edge</td></tr>\n" as *u8)
242 o = pl_cat(out, o, "<tr><td><strong>total rows</strong></td><td class=n><strong>" as *u8); o = pl_catn(out, o, sc[6])
243 o = pl_cat(out, o, "</strong></td><td class=k>the site's single source of truth</td></tr></table>\n" as *u8)
244 o = pl_cat(out, o, "<table><tr><th>docroot (top level)</th><th>count</th></tr>\n" as *u8)
245 o = pl_cat(out, o, "<tr><td>pages (.html)</td><td class=n>" as *u8); o = pl_catn(out, o, dc[0]); o = pl_cat(out, o, "</td></tr>\n" as *u8)
246 o = pl_cat(out, o, "<tr><td>directories</td><td class=n>" as *u8); o = pl_catn(out, o, dc[1]); o = pl_cat(out, o, "</td></tr>\n" as *u8)
247 o = pl_cat(out, o, "<tr><td>other files</td><td class=n>" as *u8); o = pl_catn(out, o, dc[2]); o = pl_cat(out, o, "</td></tr>\n" as *u8)
248 o = pl_cat(out, o, "<tr><td>.prev rollback artifacts</td><td class=n>" as *u8); o = pl_catn(out, o, dc[3]); o = pl_cat(out, o, "</td></tr>\n" as *u8)
249 o = pl_cat(out, o, "<tr><td>ORPHANS (on disk, in no registry row)</td><td class=n>" as *u8)
250 if dc[4] > 0 { o = pl_cat(out, o, "<span class=warn>" as *u8); o = pl_catn(out, o, dc[4]); o = pl_cat(out, o, "</span>" as *u8) }
251 if dc[4] == 0 { o = pl_cat(out, o, "<span class=ok>0</span>" as *u8) }
252 o = pl_cat(out, o, "</td></tr></table>\n" as *u8)
253 if dc[4] > 0 {
254 o = pl_cat(out, o, "<div class=card>An orphan is a file the site serves that its registry does not describe: it cannot appear in sitemap.xml, no owner is recorded, and nothing decides whether it should exist. Run <code>nx_pub_plane adopt " as *u8)
255 o = pl_span_put(out, o, conf, nameS, nameE)
256 o = pl_cat(out, o, "</code> to register them as <code>draft</code> -- that changes what the registry KNOWS, never what the world SEES.</div>\n" as *u8)
257 }
258 }
259 }
260 }
261 i = le + 1
262 }
263 o = pl_cat(out, o, "<h2>How this page stays true</h2>\n<div class=card>Each figure is re-derived on every emit: statuses from the site's registry plane, disk counts from a live walk of its docroot. There is no cached copy to go stale, and a site that is not in the site table cannot appear here at all. Re-emit with <code>nx_pub_plane board</code>.</div>\n" as *u8)
264 o = pl_cat(out, o, "<p class=k>sites rendered: " as *u8)
265 o = pl_catn(out, o, nsite)
266 o = pl_cat(out, o, "</p>\n</main></body></html>\n" as *u8)
267 let rc: i64 = pl_commit(outpath, out, o)
268 sys_munmap(conf, PP_CONF)
269 sys_munmap(out, PP_OUTCAP)
270 if rc != 0 { return 0 - 1 }
271 return nsite
272}
273
274func main(argc: i64, argv: *i64) -> i64 {
275 if argc < 2 {
276 pp_werr("usage: nx_pub_plane {list [conf] | emit <site> [conf] | emitall [conf] | adopt <site> [conf] | promote <site> <listfile> [conf] | board [out [conf]] | check <site> <relpath> [conf] | register-release <site> <releases/path> <sha256> [conf]}\n" as *u8)
277 sys_exit(PP_EXIT_USAGE)
278 return PP_EXIT_USAGE
279 }
280 let verb: *u8 = argv[1] as *u8
281 let vl: i64 = pl_vlen(verb)
282 if pl_lit_eq(verb,0,vl,"register-release" as *u8) == 1 {
283 if argc < 5 { pp_werr("PUB-FAIL register-release needs <site> <releases/path> <sha256> [conf]\n" as *u8); return PP_EXIT_USAGE }
284 if argc > 6 { return PP_EXIT_USAGE }
285 var release_conf: *u8 = "knowledge/pub_sites.conf" as *u8
286 if argc == 6 { release_conf = argv[5] as *u8 }
287 let cb: *u8 = sys_mmap(PP_CONF)
288 let cs: *i64 = sys_mmap(PP_SPANS) as *i64
289 if pl_site_lookup(release_conf,argv[2] as *u8,cb,cs) != 1 {
290 pp_werr("PUB-FAIL register-release site configuration unavailable\n" as *u8)
291 return PP_EXIT_NOSITE
292 }
293 let cp: *u8 = sys_mmap(cs[3]-cs[2]+1)
294 pl_span_cstr(cb,cs[2],cs[3],cp)
295 let rr: i64 = pr_register(cp,argv[3] as *u8,argv[4] as *u8)
296 pp_puts("PUB-RELEASE operation=register state=" as *u8)
297 if rr == PR_CREATED { pp_puts("registered changed=1" as *u8) } else {
298 if rr == PR_OK { pp_puts("registered changed=0" as *u8) } else { pp_puts("refused" as *u8) }
299 }
300 pp_puts(" code=" as *u8); pp_num(rr)
301 pp_puts(" site=" as *u8); pp_puts(argv[2] as *u8)
302 pp_puts(" path=" as *u8); pp_puts(argv[3] as *u8)
303 pp_puts(" sha256=" as *u8); pp_puts(argv[4] as *u8)
304 pp_puts(" placed=0 reviewed=0\n" as *u8)
305 sys_munmap(cp,cs[3]-cs[2]+1)
306 sys_munmap(cb,PP_CONF); sys_munmap(cs as *u8,PP_SPANS)
307 if rr == PR_CREATED { return 0 }
308 return rr
309 }
310 if pl_lit_eq(verb, 0, vl, "list" as *u8) == 1 {
311 var cf: *u8 = "knowledge/pub_sites.conf" as *u8
312 if argc > PP_ARG_A { cf = argv[PP_ARG_A] as *u8 }
313 let n: i64 = pp_walk(cf, 0)
314 if n < 0 { pp_werr("PUB-FAIL site table unreadable or malformed\n" as *u8); sys_exit(PP_EXIT_NOSITE); return PP_EXIT_NOSITE }
315 pp_puts("PUB-SITES total=" as *u8)
316 pp_num(n)
317 pp_puts("\n" as *u8)
318 sys_exit(0)
319 return 0
320 }
321 if pl_lit_eq(verb, 0, vl, "emitall" as *u8) == 1 {
322 var cf2: *u8 = "knowledge/pub_sites.conf" as *u8
323 if argc > PP_ARG_A { cf2 = argv[PP_ARG_A] as *u8 }
324 let n2: i64 = pp_walk(cf2, 1)
325 if n2 < 0 { pp_werr("PUB-FAIL emitall\n" as *u8); sys_exit(PP_EXIT_EMIT); return PP_EXIT_EMIT }
326 pp_puts("PUB-EMITALL sites=" as *u8)
327 pp_num(n2)
328 pp_puts("\n" as *u8)
329 sys_exit(0)
330 return 0
331 }
332 if pl_lit_eq(verb, 0, vl, "emit" as *u8) == 1 {
333 if argc < PP_ARG_B { pp_werr("PUB-FAIL emit needs <site>\n" as *u8); sys_exit(PP_EXIT_USAGE); return PP_EXIT_USAGE }
334 var cf3: *u8 = "knowledge/pub_sites.conf" as *u8
335 if argc > PP_ARG_B { cf3 = argv[PP_ARG_B] as *u8 }
336 let conf: *u8 = sys_mmap(PP_CONF)
337 let spans: *i64 = sys_mmap(PP_SPANS) as *i64
338 if pl_site_lookup(cf3, argv[PP_ARG_A] as *u8, conf, spans) != 1 {
339 pp_werr("PUB-FAIL no such site in the site table\n" as *u8)
340 sys_exit(PP_EXIT_NOSITE)
341 return PP_EXIT_NOSITE
342 }
343 let rc: i64 = pp_emit_site(conf, spans, argv[PP_ARG_A] as *u8)
344 if rc != 0 { pp_werr("PUB-FAIL emit\n" as *u8); sys_exit(PP_EXIT_EMIT); return PP_EXIT_EMIT }
345 sys_exit(0)
346 return 0
347 }
348 if pl_lit_eq(verb, 0, vl, "board" as *u8) == 1 {
349 var bo: *u8 = "sites/nishifamily/publishing.html" as *u8
350 if argc > PP_ARG_A { bo = argv[PP_ARG_A] as *u8 }
351 var cf6: *u8 = "knowledge/pub_sites.conf" as *u8
352 if argc > PP_ARG_B { cf6 = argv[PP_ARG_B] as *u8 }
353 let nb: i64 = pp_board(cf6, bo)
354 if nb < 0 { pp_werr("PUB-FAIL board emit\n" as *u8); sys_exit(PP_EXIT_EMIT); return PP_EXIT_EMIT }
355 pp_puts("PUB-BOARD sites=" as *u8)
356 pp_num(nb)
357 pp_puts(" -> " as *u8)
358 pp_puts(bo)
359 pp_puts("\n" as *u8)
360 sys_exit(0)
361 return 0
362 }
363 if pl_lit_eq(verb, 0, vl, "adopt" as *u8) == 1 {
364 if argc < PP_ARG_B { pp_werr("PUB-FAIL adopt needs <site>\n" as *u8); sys_exit(PP_EXIT_USAGE); return PP_EXIT_USAGE }
365 var cf5: *u8 = "knowledge/pub_sites.conf" as *u8
366 if argc > PP_ARG_B { cf5 = argv[PP_ARG_B] as *u8 }
367 let conf3: *u8 = sys_mmap(PP_CONF)
368 let spans3: *i64 = sys_mmap(PP_SPANS) as *i64
369 if pl_site_lookup(cf5, argv[PP_ARG_A] as *u8, conf3, spans3) != 1 {
370 pp_werr("PUB-FAIL no such site in the site table\n" as *u8)
371 sys_exit(PP_EXIT_NOSITE)
372 return PP_EXIT_NOSITE
373 }
374 let dr: *u8 = sys_mmap(PP_PATHCAP)
375 let pf: *u8 = sys_mmap(PP_PATHCAP)
376 pl_span_cstr(conf3, spans3[0], spans3[1], dr)
377 pl_span_cstr(conf3, spans3[2], spans3[3], pf)
378 let counts: *i64 = sys_mmap(PP_SPANS) as *i64
379 let nadd: i64 = pl_adopt(dr, pf, counts)
380 // -2 (lossy plane) and -3 (scan cap) already NAMED their cause on stderr; stamping the
381 // generic message over those would misattribute the refusal (the wrong-cause trap).
382 if nadd < 0 {
383 if nadd == 0 - 1 { pp_werr("PUB-FAIL adopt (docroot unreadable or seed failed)\n" as *u8) }
384 sys_exit(PP_EXIT_EMIT)
385 return PP_EXIT_EMIT
386 }
387 pp_puts("PUB-ADOPT site=" as *u8)
388 pp_puts(argv[PP_ARG_A] as *u8)
389 pp_puts(" added=" as *u8)
390 pp_num(nadd)
391 // counts[0] is DRAFT, not live -- adoption never auto-indexes. A label that said "live"
392 // here would misreport the one thing an operator checks after a bulk migration.
393 pp_puts(" draft_pages=" as *u8)
394 pp_num(counts[0])
395 pp_puts(" asset=" as *u8)
396 pp_num(counts[1])
397 pp_puts(" debris=" as *u8)
398 pp_num(counts[2])
399 pp_puts(" already_registered=" as *u8)
400 pp_num(counts[3])
401 pp_puts("\n" as *u8)
402 sys_exit(0)
403 return 0
404 }
405 if pl_lit_eq(verb, 0, vl, "promote" as *u8) == 1 {
406 if argc < PP_ARG_C { pp_werr("PUB-FAIL promote needs <site> <listfile>\n" as *u8); sys_exit(PP_EXIT_USAGE); return PP_EXIT_USAGE }
407 var cf7: *u8 = "knowledge/pub_sites.conf" as *u8
408 if argc > PP_ARG_C { cf7 = argv[PP_ARG_C] as *u8 }
409 let conf4: *u8 = sys_mmap(PP_CONF)
410 let spans4: *i64 = sys_mmap(PP_SPANS) as *i64
411 if pl_site_lookup(cf7, argv[PP_ARG_A] as *u8, conf4, spans4) != 1 {
412 pp_werr("PUB-FAIL no such site in the site table\n" as *u8)
413 sys_exit(PP_EXIT_NOSITE)
414 return PP_EXIT_NOSITE
415 }
416 let pf2: *u8 = sys_mmap(PP_PATHCAP)
417 pl_span_cstr(conf4, spans4[2], spans4[3], pf2)
418 let counts2: *i64 = sys_mmap(PP_SPANS) as *i64
419 let np: i64 = pl_promote(pf2, argv[PP_ARG_B] as *u8, counts2)
420 if np < 0 {
421 // -2 already NAMED its cause (lossy load) on stderr; only the generic io case needs words
422 if np == 0 - 1 { pp_werr("PUB-FAIL promote (list unreadable or seed failed)\n" as *u8) }
423 sys_exit(PP_EXIT_EMIT)
424 return PP_EXIT_EMIT
425 }
426 pp_puts("PUB-PROMOTE site=" as *u8)
427 pp_puts(argv[PP_ARG_A] as *u8)
428 pp_puts(" promoted=" as *u8)
429 pp_num(np)
430 pp_puts(" skipped_not_draft=" as *u8)
431 pp_num(counts2[1])
432 pp_puts(" unmatched_list_rows=" as *u8)
433 pp_num(counts2[2])
434 pp_puts("\n" as *u8)
435 sys_exit(0)
436 return 0
437 }
438 if pl_lit_eq(verb, 0, vl, "sectionize" as *u8) == 1 {
439 if argc < PP_ARG_B { pp_werr("PUB-FAIL sectionize needs <site>\n" as *u8); sys_exit(PP_EXIT_USAGE); return PP_EXIT_USAGE }
440 var cf8: *u8 = "knowledge/pub_sites.conf" as *u8
441 if argc > PP_ARG_B { cf8 = argv[PP_ARG_B] as *u8 }
442 let conf5: *u8 = sys_mmap(PP_CONF)
443 let spans5: *i64 = sys_mmap(PP_SPANS) as *i64
444 if pl_site_lookup(cf8, argv[PP_ARG_A] as *u8, conf5, spans5) != 1 {
445 pp_werr("PUB-FAIL no such site in the site table\n" as *u8)
446 sys_exit(PP_EXIT_NOSITE)
447 return PP_EXIT_NOSITE
448 }
449 let pf3: *u8 = sys_mmap(PP_PATHCAP)
450 pl_span_cstr(conf5, spans5[2], spans5[3], pf3)
451 let counts3: *i64 = sys_mmap(PP_SPANS) as *i64
452 let ns: i64 = pl_sectionize(pf3, counts3)
453 if ns < 0 {
454 if ns == 0 - 1 { pp_werr("PUB-FAIL sectionize (seed failed)\n" as *u8) }
455 sys_exit(PP_EXIT_EMIT)
456 return PP_EXIT_EMIT
457 }
458 pp_puts("PUB-SECTIONIZE site=" as *u8)
459 pp_puts(argv[PP_ARG_A] as *u8)
460 pp_puts(" dir_derived=" as *u8)
461 pp_num(counts3[0])
462 pp_puts(" pages=" as *u8)
463 pp_num(counts3[1])
464 pp_puts("\n" as *u8)
465 sys_exit(0)
466 return 0
467 }
468 if pl_lit_eq(verb, 0, vl, "check" as *u8) == 1 {
469 if argc < PP_ARG_C { pp_werr("PUB-FAIL check needs <site> <relpath>\n" as *u8); sys_exit(PP_EXIT_USAGE); return PP_EXIT_USAGE }
470 var cf4: *u8 = "knowledge/pub_sites.conf" as *u8
471 if argc > PP_ARG_C { cf4 = argv[PP_ARG_C] as *u8 }
472 let conf2: *u8 = sys_mmap(PP_CONF)
473 let spans2: *i64 = sys_mmap(PP_SPANS) as *i64
474 if pl_site_lookup(cf4, argv[PP_ARG_A] as *u8, conf2, spans2) != 1 {
475 pp_werr("PUB-REFUSED unknown site\n" as *u8)
476 sys_exit(PP_EXIT_REFUSED)
477 return PP_EXIT_REFUSED
478 }
479 let pfx: *u8 = sys_mmap(PP_PATHCAP)
480 pl_span_cstr(conf2, spans2[2], spans2[3], pfx)
481 let v: i64 = pl_check(pfx, argv[PP_ARG_B] as *u8)
482 if v == 0 { pp_puts("PUB-CHECK OK " as *u8) } else { pp_puts("PUB-CHECK REFUSED " as *u8) }
483 pp_puts(argv[PP_ARG_B] as *u8)
484 pp_puts("\n" as *u8)
485 sys_exit(v)
486 return v
487 }
488 pp_werr("PUB-FAIL unknown verb\n" as *u8)
489 sys_exit(PP_EXIT_USAGE)
490 return PP_EXIT_USAGE
491}