@mark1russell7/harness 0.0.0-stage → 0.1.0

package/image/native/src/bin/inject.rs

@@ -0,0 +1,91 @@
+//! inject blackhole PEER | inject clear PEER [--at NS] | inject rst PEER | inject clear-rst PEER
+//!
+//! A cell's fault, applied inside the network namespace this sidecar shares with the target, so
+//! the target's image stays stock. Each lands in one iptables-restore commit,
+//! bracketed by CLOCK_MONOTONIC stamps taken in the VM: a docker exec from Windows lands 190 ms late
+//! at the median, and the bracket does not care.
+//!
+//! - blackhole: both directions drop, so nothing comes back;
+//! - rst: the peer's next segment is answered with a reset, so its next send fails at once. A
+//!   REJECT resets only the sender of the matched segment: the target's process
+//!   never hears of it.
+//!
+//! `--at NS` holds the commit until that instant on CLOCK_MONOTONIC, the clock every stamp is on.
+//! A stall's end is timed that way, from inside the VM: the exec only has to arrive before it, and
+//! its 190 ms never reach the stall's length.
+
+use prober::monotonic_ns;
+use serde_json::json;
+use std::error::Error;
+use std::io::Write;
+use std::net::Ipv4Addr;
+use std::process::{Command, Stdio};
+
+/// sleeps until an instant on CLOCK_MONOTONIC, or returns at once if it has passed
+fn until(at: u64) -> Result<(), Box<dyn Error>> {
+    let deadline = libc::timespec {
+        // the fields' own types: musl is moving time_t to 64 bits
+        tv_sec: (at / 1_000_000_000) as _,
+        tv_nsec: (at % 1_000_000_000) as _,
+    };
+    loop {
+        // SAFETY: a valid timespec, and no remainder is asked for with an absolute time
+        let code = unsafe {
+            libc::clock_nanosleep(
+                libc::CLOCK_MONOTONIC,
+                libc::TIMER_ABSTIME,
+                &deadline,
+                std::ptr::null_mut(),
+            )
+        };
+        match code {
+            0 => return Ok(()),
+            libc::EINTR => continue,
+            other => return Err(format!("clock_nanosleep failed: {other}").into()),
+        }
+    }
+}
+
+fn run() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let action = args.first().ok_or("say blackhole, clear, rst or clear-rst")?.as_str();
+    // parsed, never pasted: only an address reaches the rules
+    let peer: Ipv4Addr = args.get(1).ok_or("and the peer's address")?.parse()?;
+    let at: Option<u64> = match args.get(2).map(String::as_str) {
+        None => None,
+        Some("--at") => Some(args.get(3).ok_or("--at takes an instant in ns")?.parse()?),
+        Some(other) => return Err(format!("unknown option {other}").into()),
+    };
+    let rules = match action {
+        "blackhole" | "clear" => {
+            let op = if action == "blackhole" { "-I" } else { "-D" };
+            format!("{op} INPUT -s {peer}/32 -j DROP\n{op} OUTPUT -d {peer}/32 -j DROP\n")
+        }
+        "rst" | "clear-rst" => {
+            let op = if action == "rst" { "-I" } else { "-D" };
+            format!("{op} INPUT -s {peer}/32 -p tcp -j REJECT --reject-with tcp-reset\n")
+        }
+        other => return Err(format!("unknown action {other}").into()),
+    };
+    let script = format!("*filter\n{rules}COMMIT\n");
+    if let Some(at) = at {
+        until(at)?;
+    }
+    let t0 = monotonic_ns();
+    let mut child = Command::new("iptables-restore").arg("--noflush").stdin(Stdio::piped()).spawn()?;
+    child.stdin.take().ok_or("iptables-restore took no stdin")?.write_all(script.as_bytes())?;
+    let status = child.wait()?;
+    let t1 = monotonic_ns();
+    if !status.success() {
+        return Err(format!("iptables-restore exited {status}").into());
+    }
+    println!("{}", json!({ "action": action, "peer": peer.to_string(), "t0": t0, "t1": t1 }));
+    Ok(())
+}
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("inject: {error}");
+        std::process::exit(1);
+    }
+}

package/image/node/Dockerfile

@@ -0,0 +1,11 @@
+# The harness's Node client: ioredis 6.0.0 on Node 24.21.0, the releases the corpus's claims about
+# ioredis and Node's keepalive name. It runs as a container in the client's
+# network namespace, as the harness's own TCP client does, and prints the same JSON lines.
+# lab.ts stages the build context: this folder, under harness/image/node. The lockfile is
+# npm-lock.json here, because npm leaves each package-lock.json out of a published tarball.
+FROM node:24.21.0-alpine@sha256:ebfe2f90462722a7a4de65e91990e97fe0d401c70e0e762c5b53302f905ec1c1
+WORKDIR /opt/harness/node
+COPY harness/image/node/package.json ./
+COPY harness/image/node/npm-lock.json ./package-lock.json
+RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
+COPY harness/image/node/client-ioredis.mjs ./

package/image/node/client-ioredis.mjs

@@ -0,0 +1,105 @@
+// client-ioredis HOST PORT --mode idle|inflight [--keepalive-ms N] [--go PATH] [--max-s N]
+//
+// A cell's client one layer up: an ioredis 6.0.0 connection, every event a JSON line stamped on
+// CLOCK_MONOTONIC (process.hrtime, which libuv reads from it), the clock the prober stamps the
+// kernel's records with. Its lines are the harness's TCP client's, so the harness reads both the
+// same way (image/native/src/bin/client.rs), with ioredis's own status changes
+// beside them as `status` lines.
+//
+// ioredis sets the socket's keepalive itself, once it connects: setKeepAlive(true, keepAlive), and
+// Node fixes the probe interval and count. It sets no other timer the kernel would see. Both modes
+// send a PING and read its reply first; that reply is the last segment received. idle: then hold
+// the connection until it fails. inflight: then wait for the file --go to appear, send a PING into
+// the fault, and wait.
+
+import { existsSync, readFileSync } from "node:fs";
+import Redis from "ioredis";
+
+const now = () => process.hrtime.bigint();
+const emit = (ev, fields = {}, at = now()) =>
+  process.stdout.write(`${JSON.stringify({ ev, t: Number(at), ...fields })}\n`);
+
+const argv = process.argv.slice(2);
+const flag = (name) => {
+  const at = argv.indexOf(name);
+  return at === -1 ? undefined : argv[at + 1];
+};
+const [host, port] = argv;
+const mode = flag("--mode");
+if (host === undefined || port === undefined || (mode !== "idle" && mode !== "inflight")) {
+  emit("fail", { why: "client-ioredis HOST PORT --mode idle|inflight" });
+  process.exit(1);
+}
+const keepAlive = Number(flag("--keepalive-ms") ?? 30000);
+const go = flag("--go") ?? "/tmp/go";
+const max = Number(flag("--max-s") ?? 60) * 1000;
+
+emit("start", {
+  boot_id: readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim(),
+  mode,
+  client: "ioredis",
+});
+
+// one connection, whose end is what is measured: ioredis would reconnect, so the client ends first
+const redis = new Redis({ host, port: Number(port), keepAlive, lazyConnect: true });
+for (const status of ["connect", "ready", "close", "reconnecting", "end"]) {
+  redis.on(status, () => emit("status", { status }));
+}
+
+let ended = false;
+const end = (code = 0) => {
+  if (ended) return;
+  ended = true;
+  // a moment for ioredis's own close to be written after the error that caused it
+  setTimeout(() => {
+    redis.disconnect(false);
+    process.exit(code);
+  }, 50);
+};
+redis.on("error", (error) => {
+  emit("error", { errno: error.code ?? error.errno ?? "unknown", message: error.message });
+  end();
+});
+redis.on("close", () => {
+  if (!ended) emit("eof");
+  end();
+});
+setTimeout(() => {
+  emit("deadline");
+  end();
+}, max);
+
+/** a PING, stamped before it is written: the kernel can answer before the call returns */
+const ping = () => {
+  const at = now();
+  const reply = redis.ping();
+  emit("sent", {}, at);
+  return reply;
+};
+
+redis.once("connect", () => {
+  const { localAddress, localPort } = redis.stream;
+  emit("connected", { local: `${localAddress}:${localPort}` });
+});
+
+try {
+  await redis.connect();
+  const reply = await ping();
+  emit("ready", { reply: `+${reply}\r\n` });
+} catch (error) {
+  // a connection that never became ready: what ended it was written as it happened
+  if (!ended) emit("fail", { why: error.message });
+  end(1);
+}
+
+if (mode === "inflight") {
+  const wait = setInterval(() => {
+    if (!existsSync(go)) return;
+    clearInterval(wait);
+    // into the fault: its reply never comes, or comes once the target thaws
+    ping().then(
+      (late) => emit("data", { n: late.length, text: late }),
+      () => undefined,
+    );
+  }, 2);
+}

package/image/node/npm-lock.json

@@ -0,0 +1,96 @@
+{
+  "name": "loom-harness-ioredis-client",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "loom-harness-ioredis-client",
+      "dependencies": {
+        "ioredis": "6.0.0"
+      }
+    },
+    "node_modules/@ioredis/commands": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@ioredis/commands/-/commands-2.0.0.tgz",
+      "integrity": "sha512-vrx0AE/T0h7cRZwfo1M39Cr+ZhZrkf0V8mQN75wucKCxCLD9l/VX6no3gFvrLqD1IlG/1LtzWovqEw3t0Vr9zg==",
+      "license": "MIT"
+    },
+    "node_modules/cluster-key-slot": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/cluster-key-slot/-/cluster-key-slot-1.1.1.tgz",
+      "integrity": "sha512-rwHwUfXL40Chm1r08yrhU3qpUvdVlgkKNeyeGPOxnW8/SyVDvgRaed/Uz54AqWNaTCAThlj6QAs3TZcKI0xDEw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/denque": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
+      "integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/ioredis": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/ioredis/-/ioredis-6.0.0.tgz",
+      "integrity": "sha512-f+Dtubxfpf6KYFq7WVXJoOLn0bk4TJrMrN9SzeE+jrWrCWj7XX3fA6vkryafhADX+GMymRxgDJDOI33COkJc0w==",
+      "license": "MIT",
+      "dependencies": {
+        "@ioredis/commands": "2.0.0",
+        "cluster-key-slot": "1.1.1",
+        "debug": "4.4.3",
+        "denque": "2.1.0",
+        "redis-errors": "1.2.0",
+        "standard-as-callback": "2.1.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/ioredis"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/redis-errors": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/redis-errors/-/redis-errors-1.2.0.tgz",
+      "integrity": "sha512-1qny3OExCf0UvUV/5wpYKf2YwPcOqXzkwKKSmKHiE6ZMQs5heeE/c8eXK+PNllPvmjgAbfnsbpkGZWy8cBpn9w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/standard-as-callback": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/standard-as-callback/-/standard-as-callback-2.1.0.tgz",
+      "integrity": "sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==",
+      "license": "MIT"
+    }
+  }
+}

package/image/node/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "loom-harness-ioredis-client",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "ioredis": "6.0.0"
+  }
+}

package/package.json

@@ -1,6 +1,79 @@
 {
+  "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/harness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "A fault-injection harness for connection timers: a cell runs a client against a stock target in Docker, injects a fault, measures the kernel's own records and judges a prediction.",
+  "keywords": [
+    "fault-injection",
+    "chaos-engineering",
+    "tcp",
+    "keepalive",
+    "timeouts",
+    "testcontainers",
+    "docker",
+    "ebpf"
+  ],
+  "homepage": "https://mark1russell7.github.io/systems/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mark1russell7/systems.git",
+    "directory": "packages/harness"
+  },
+  "bugs": {
+    "url": "https://github.com/mark1russell7/systems/issues"
+  },
+  "license": "MIT",
+  "author": "Mark Russell (https://github.com/mark1russell7)",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "build",
+    "image/Dockerfile",
+    "image/native/Cargo.toml",
+    "image/native/Cargo.lock",
+    "image/native/src",
+    "image/node/Dockerfile",
+    "image/node/client-ioredis.mjs",
+    "image/node/package.json",
+    "image/node/npm-lock.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.19"
+  },
+  "dependencies": {
+    "@mark1russell7/prober": "^0.1.0",
+    "@mark1russell7/quantity": "^0.1.0",
+    "testcontainers": "12.2.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.1.0"
+  },
+  "devDependencies": {
+    "@mark1russell7/cue": "github:mark1russell7/cue",
+    "@types/node": "^26.6.4",
+    "tsdown": "^0.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3",
+    "zod": "^4.6.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.json --noEmit --emitDeclarationOnly false && tsc -p tsconfig.test.json"
+  }
 }