code wiki / _hdl_build / nx_host_deploy_test.nx
`nx_host_deploy_test.nx` source

1// nx_host_deploy_test.nx -- one unified, fast, safe deploy. Scenarios:
2//   file-based + transferred + healthy        -> LIVE, no source needed, ease 95  (S-class)
3//   file-based + transferred + unhealthy      -> STAGED (auto-rollback)
4//   compiled + source UNPINNED (current case) -> BLOCKED (cannot build -> never swap -> live protected)
5//   compiled + source pinned + verified + healthy -> LIVE (slower, ease 40)
6// The capability recommends FILE-BASED for ease+speed. Exit 0 on 7/7. license_tier: ORIGINAL
7
8import "nx_host_deploy.nx"
9import "nx_syscalls.nx"
10
11func ht_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
12func ht_num(v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m}; let t: *u8 = sys_mmap(28); var k: i64=0; if m==0 {t[0]=48;k=1}; while m>0 {t[k]=48+(m%10); m=m/10; k=k+1}; var i: i64=0; while i<k {bb[i]=t[k-1-i]; i=i+1}; sys_write(1, bb, k); return 0 }
13
14func main() -> i64 {
15    ht_puts("=== UNIFIED S-CLASS HOSTING + DEPLOY (ease + speed, sovereign) ===\n" as *u8)
16    let fb_live: i64 = hd_verdict(HD_FILE_BASED, 1, 1, 0, 0)        // no source needed
17    let fb_stage: i64 = hd_verdict(HD_FILE_BASED, 1, 0, 0, 0)       // unhealthy -> rollback
18    let cp_blocked: i64 = hd_verdict(HD_COMPILED, 1, 1, 0, 1)       // CURRENT case: source unpinned
19    let cp_live: i64 = hd_verdict(HD_COMPILED, 1, 1, 1, 1)          // source pinned + verified
20
21    ht_puts(" file-based: transferred+healthy -> verdict=" as *u8); ht_num(fb_live); ht_puts(" (2=LIVE)  ease/speed=" as *u8); ht_num(hd_ease_speed(HD_FILE_BASED)); ht_puts("  source-needed=" as *u8); ht_num(1 - hd_source_independent(HD_FILE_BASED)); ht_puts("\n" as *u8)
22    ht_puts(" file-based: unhealthy          -> verdict=" as *u8); ht_num(fb_stage); ht_puts(" (1=STAGED, auto-rolled-back)\n" as *u8)
23    ht_puts(" compiled:   source UNPINNED    -> verdict=" as *u8); ht_num(cp_blocked); ht_puts(" (0=BLOCKED -- the live trap; never swap)  ease/speed=" as *u8); ht_num(hd_ease_speed(HD_COMPILED)); ht_puts("\n" as *u8)
24    ht_puts(" compiled:   source+verified    -> verdict=" as *u8); ht_num(cp_live); ht_puts(" (2=LIVE)\n" as *u8)
25    ht_puts(" RECOMMEND host model = " as *u8); ht_num(hd_recommend()); ht_puts(" (1=FILE_BASED: source-independent, fast, S-class for ease+speed)\n" as *u8)
26
27    let r: *i64 = sys_mmap(8*8) as *i64
28    r[0] = 0; if fb_live == HD_LIVE { if hd_source_independent(HD_FILE_BASED) == 1 { r[0] = 1 } }   // file-based goes live with NO source
29    r[1] = 0; if fb_stage == HD_STAGED { r[1] = 1 }                  // unhealthy -> rolled back, not live
30    r[2] = 0; if cp_blocked == HD_BLOCKED { r[2] = 1 }               // compiled+no-source -> blocked (current reality)
31    r[3] = 0; if cp_live == HD_LIVE { r[3] = 1 }                     // compiled works WITH source+verify
32    r[4] = 0; if hd_ease_speed(HD_FILE_BASED) > hd_ease_speed(HD_COMPILED) { r[4] = 1 }   // file-based is faster/easier
33    r[5] = 0; if hd_recommend() == HD_FILE_BASED { r[5] = 1 }        // the S-class recommendation
34    r[6] = 0; if hd_is_sclass(HD_FILE_BASED, fb_live) == 1 { if hd_is_sclass(HD_COMPILED, cp_live) == 0 { r[6] = 1 } }  // S-class only file-based
35    var pass: i64 = 0; var i: i64 = 0
36    while i < 7 { pass = pass + r[i]; i = i + 1 }
37    ht_puts("----\n passed " as *u8); ht_num(pass); ht_puts("/7\n" as *u8)
38    if pass == 7 { ht_puts(" S-CLASS DEPLOY CAPABILITY: one orchestrated, sovereign, rollback-safe deploy. FILE-BASED = drop-a-file-and-it's-live (no rebuild, no source-loss risk) = the ease+speed answer; COMPILED is supported but blocks safely when the source isn't pinned. The team should host file-based.\n" as *u8); sys_exit(0); return 0 }
39    ht_puts(" FAIL\n" as *u8); sys_exit(1); return 1
40}
nx_host_deploy_test.nx source

`nx_host_deploy_test.nx` source
