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

1import "nx_gate_gn.nx"
2// nx_ha_replication_gate.nx -- hermetic gate for CAP-HA-REPLICATION. Proves append advances position, ship catches
3// the replica up byte-exact, lag tracks the gap, incremental ship works, and a diverged replica is detected.
4// Sovereign: nx_syscalls + nx_ha_replication. expect_exit: 0
5import "nx_syscalls.nx"
6import "nx_ha_replication.nx"
7import "nx_gate_verdict.nx"
8
9func gp(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
10func g_trunc(path: *u8) -> i64 { let fd: i64=sys_openat_wr(path, 0x1a4); if fd>=0 { sys_close(fd) } return 0 }
11
12func main(argc: i64, argv: *i64) -> i64 {
13    gp("=== nx_ha_replication_gate (log-shipping replication -- kill the DATA SPOF) ===\n" as *u8)
14    let P: *u8 = "/tmp/rep_primary.log" as *u8
15    let S: *u8 = "/tmp/rep_standby.log" as *u8
16    g_trunc(P); g_trunc(S)
17    var pass: i64 = 0; var fail: i64 = 0
18
19    rep_append(P, "rec1\n" as *u8, 5)
20    let p2: i64 = rep_append(P, "rec2\n" as *u8, 5)
21
22    // T1 lag = full primary (standby empty)
23    if rep_lag(P, S) == 10 { if p2 == 10 { pass=pass+1; gp("  T1 append advances pos; lag=10 (standby empty) PASS\n" as *u8) } else { fail=fail+1; gp("  T1 FAIL pos\n" as *u8) } } else { fail=fail+1; gp("  T1 FAIL lag=" as *u8); gn(rep_lag(P,S)); gp("\n" as *u8) }
24
25    // T2 ship from 0 -> caught up byte-exact
26    let sh: i64 = rep_ship(P, S, 0)
27    if sh == 10 { if rep_lag(P, S) == 0 { if rep_in_sync(P, S) == 1 { pass=pass+1; gp("  T2 ship 10 -> lag 0, byte-exact in-sync PASS\n" as *u8) } else { fail=fail+1; gp("  T2 FAIL not in sync\n" as *u8) } } else { fail=fail+1; gp("  T2 FAIL lag\n" as *u8) } } else { fail=fail+1; gp("  T2 FAIL shipped=" as *u8); gn(sh); gp("\n" as *u8) }
28
29    // T3 incremental: append rec3, ship only the delta
30    rep_append(P, "rec3\n" as *u8, 5)
31    if rep_lag(P, S) == 5 { let sh2: i64 = rep_ship(P, S, 10); if sh2 == 5 { if rep_lag(P, S) == 0 { if rep_in_sync(P, S) == 1 { pass=pass+1; gp("  T3 incremental ship (delta 5) -> in-sync PASS\n" as *u8) } else { fail=fail+1; gp("  T3 FAIL sync\n" as *u8) } } else { fail=fail+1; gp("  T3 FAIL lag\n" as *u8) } } else { fail=fail+1; gp("  T3 FAIL delta=" as *u8); gn(sh2); gp("\n" as *u8) } } else { fail=fail+1; gp("  T3 FAIL pre-lag\n" as *u8) }
32
33    // T4 (NEG) a diverged replica (standby ahead / tampered) is detected
34    let jfd: i64 = sys_openat_append(S, 0x1a4); if jfd >= 0 { sys_write(jfd, "JUNK" as *u8, 4); sys_close(jfd) }
35    if rep_in_sync(P, S) == 0 { pass=pass+1; gp("  T4 diverged replica -> NOT in-sync (detected) PASS\n" as *u8) } else { fail=fail+1; gp("  T4 FAIL undetected\n" as *u8) }
36
37    gp("RESULT pass=" as *u8); gn(pass); gp(" fail=" as *u8); gn(fail)
38    // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
39    // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
40    // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
41    let ctr__dry: *i64 = gv_ctr()
42    ctr__dry[0] = pass
43    ctr__dry[1] = pass + fail
44    let rc__dry: i64 = gv_verdict("HA-REPLICATION-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
45    sys_exit(rc__dry)
46    return rc__dry
47}
nx_ha_replication_gate.nx source

`nx_ha_replication_gate.nx` source
