@mark1russell7/harness 0.5.0 → 0.7.0

package/image/mongo/npm-lock.json

@@ -0,0 +1,163 @@
+{
+  "name": "loom-harness-mongo-client",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "loom-harness-mongo-client",
+      "dependencies": {
+        "mongodb": "7.7.0"
+      }
+    },
+    "node_modules/@mongodb-js/saslprep": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@mongodb-js/saslprep/-/saslprep-1.6.1.tgz",
+      "integrity": "sha512-D4CQtk9IwjCLAvCf1xvHEod3960q8XMUzfmdRU9qjUNlHnesGuTOvJcOTaPm9koZ1caUKA2aTbszZiAkcmSgmg==",
+      "license": "MIT",
+      "dependencies": {
+        "sparse-bitfield": "^3.0.3"
+      }
+    },
+    "node_modules/@types/webidl-conversions": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/@types/webidl-conversions/-/webidl-conversions-7.0.3.tgz",
+      "integrity": "sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/whatwg-url": {
+      "version": "13.0.0",
+      "resolved": "https://registry.npmjs.org/@types/whatwg-url/-/whatwg-url-13.0.0.tgz",
+      "integrity": "sha512-N8WXpbE6Wgri7KUSvrmQcqrMllKZ9uxkYWMt+mCSGwNc0Hsw9VQTW7ApqI4XNrx6/SaM2QQJCzMPDEXE058s+Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/webidl-conversions": "*"
+      }
+    },
+    "node_modules/bson": {
+      "version": "7.3.3",
+      "resolved": "https://registry.npmjs.org/bson/-/bson-7.3.3.tgz",
+      "integrity": "sha512-oz3LwE3qGEhTCSyhzQRLY3Bj1NLOsjFMf6tcmY5J8M+3R7EVcmoBfSHWvjUK3yXCLDUsGpIuB3aQL4nDZ1EV/g==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/memory-pager": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/memory-pager/-/memory-pager-1.5.0.tgz",
+      "integrity": "sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==",
+      "license": "MIT"
+    },
+    "node_modules/mongodb": {
+      "version": "7.7.0",
+      "resolved": "https://registry.npmjs.org/mongodb/-/mongodb-7.7.0.tgz",
+      "integrity": "sha512-XG1xXEqyouAV8GCb3PuRaujofeXKpAJAPvXYWZgHl6Dz4QHSJ1nRLl0+GpqaLTwKvC0RFE9truOur34RNFY1nw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@mongodb-js/saslprep": "^1.5.0",
+        "bson": "^7.3.2",
+        "mongodb-connection-string-url": "^7.0.2"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@aws-sdk/credential-providers": "^3.806.0",
+        "@mongodb-js/zstd": "^7.0.0",
+        "gcp-metadata": "^7.0.1",
+        "kerberos": "^7.0.0",
+        "mongodb-client-encryption": "^7.2.0",
+        "snappy": "^7.3.2",
+        "socks": "^2.8.6"
+      },
+      "peerDependenciesMeta": {
+        "@aws-sdk/credential-providers": {
+          "optional": true
+        },
+        "@mongodb-js/zstd": {
+          "optional": true
+        },
+        "gcp-metadata": {
+          "optional": true
+        },
+        "kerberos": {
+          "optional": true
+        },
+        "mongodb-client-encryption": {
+          "optional": true
+        },
+        "snappy": {
+          "optional": true
+        },
+        "socks": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/mongodb-connection-string-url": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/mongodb-connection-string-url/-/mongodb-connection-string-url-7.0.2.tgz",
+      "integrity": "sha512-ZoS07RoFqpKYQwAk59qmrx8+jJHNHU30UjlU96QktiGn1ltvDr+vCznLX5DiUBLEpMAHatHNWV1nM/74ul66kA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/whatwg-url": "^13.0.0",
+        "whatwg-url": "^14.1.0"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/sparse-bitfield": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/sparse-bitfield/-/sparse-bitfield-3.0.3.tgz",
+      "integrity": "sha512-kvzhi7vqKTfkh0PZU+2D2PIllw2ymqJKujUcyPMd9Y75Nv4nPbGJZXNhxsgdQab2BmlDct1YnfQCguEvHr7VsQ==",
+      "license": "MIT",
+      "dependencies": {
+        "memory-pager": "^1.0.2"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.1.tgz",
+      "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
+      "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "14.2.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",
+      "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^5.1.0",
+        "webidl-conversions": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}

package/image/mongo/package.json

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

package/image/mongo/stepdown-mongo.mjs

@@ -0,0 +1,37 @@
+// stepdown-mongo HOST:PORT STEP_DOWN_SECS CATCH_UP_SECS
+//
+// A planned step-down of a replica set: replSetStepDown to its primary, as a client sends it. The
+// script connects to the member and pings it first. Then it stamps t0 on CLOCK_MONOTONIC and sends
+// the command. It stamps t1 on the next turn of the event loop after the driver starts the command,
+// when the driver wrote it. Its last line is the stamps, as the injector prints them.
+
+import { MongoClient } from "mongodb";
+
+const now = () => Number(process.hrtime.bigint());
+const [address, stepDownSecs = "60", catchUpSecs = "10"] = process.argv.slice(2);
+const client = new MongoClient(`mongodb://${address}/?directConnection=true`, { serverSelectionTimeoutMS: 10000, monitorCommands: true });
+let written = null;
+const sent = new Promise((resolve) => {
+  client.on("commandStarted", (event) => {
+    if (event.commandName === "replSetStepDown") setImmediate(() => resolve(now()));
+  });
+});
+try {
+  await client.connect();
+  const admin = client.db("admin");
+  await admin.command({ ping: 1 });
+  const t0 = now();
+  const reply = admin.command({ replSetStepDown: Number(stepDownSecs), secondaryCatchUpPeriodSecs: Number(catchUpSecs) });
+  written = await sent;
+  let ok = false;
+  let error = null;
+  try {
+    ok = (await reply).ok === 1;
+  } catch (failure) {
+    // a primary that steps down closes its connections: the reply can be a network error
+    error = failure.message;
+  }
+  process.stdout.write(`${JSON.stringify({ action: "step-down", t0, t1: written, replied: now(), ok, error })}\n`);
+} finally {
+  await client.close().catch(() => undefined);
+}

package/image/node-http/Dockerfile

@@ -0,0 +1,12 @@
+# The Node HTTP clients of the harness: the http.Agent of Node 24.21.0, and an HTTP/1.1 Client of
+# undici 8.12.2. Each runs as a container in the client's network namespace, as the harness's own
+# TCP client does, and prints the same JSON lines. The digest of the image and an npm lockfile pin
+# them. The image is apart from the ioredis image, thus the cells of ioredis keep their image.
+# lab.ts stages the build context: this folder, under harness/image/node-http. 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-http
+COPY harness/image/node-http/package.json ./
+COPY harness/image/node-http/npm-lock.json ./package-lock.json
+RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
+COPY harness/image/node-http/lines.mjs harness/image/node-http/client-agent.mjs harness/image/node-http/client-undici.mjs ./

package/image/node-http/client-agent.mjs

@@ -0,0 +1,163 @@
+// client-agent HOST PORT --mode idle|inflight|gap [--gap-ms N] [--method GET|POST] [--hold-ms N]
+//              [--bytes N] [--go PATH] [--max-s N] [--linger-ms N]
+//              [--timeout-ms N] [--keepalive-msecs N] [--buffer-ms N]
+//
+// The client of the HTTP cells that uses the http.Agent of Node 24.21.0. Without an agent flag it
+// uses http.globalAgent: keep-alive on, a free socket timeout of 5 s, LIFO
+// (lib/internal/http.js:263-265). With a flag, it uses a new Agent with the same options and the
+// flag. Each event is a JSON line, as the TCP client of the harness writes them.
+//
+// The first request is GET /, and the end of its reply is the `ready` line. Then the client holds
+// the connection idle (idle), sends the second request when the file --go appears (inflight), or
+// sends it after the gap (gap). For each request it writes the connection that it went on (the
+// local address and port), whether the agent reused the socket, and the outcome. For each socket it
+// writes the connect, the end of file, the timeout of the agent, and the close.
+
+import http from "node:http";
+import { bootId, commandLine, emit, now, pathOf, sleep, waitFor } from "./lines.mjs";
+
+const usage = "client-agent HOST PORT --mode idle|inflight|gap";
+const cli = commandLine(usage);
+const mode = cli.flag("--mode");
+if (mode !== "idle" && mode !== "inflight" && mode !== "gap") {
+  emit("fail", { why: usage });
+  process.exit(1);
+}
+const method = cli.flag("--method") ?? "GET";
+const second = pathOf({ hold: cli.number("--hold-ms"), bytes: cli.number("--bytes") });
+const max = cli.number("--max-s", 60) * 1000;
+const linger = cli.number("--linger-ms", 500);
+
+// the options of http.globalAgent, and each flag over them
+const custom = cli.has("--timeout-ms") || cli.has("--keepalive-msecs") || cli.has("--buffer-ms");
+const options = { keepAlive: true, scheduling: "lifo", timeout: 5000 };
+if (cli.has("--timeout-ms")) options.timeout = cli.number("--timeout-ms");
+if (cli.has("--keepalive-msecs")) options.keepAliveMsecs = cli.number("--keepalive-msecs");
+if (cli.has("--buffer-ms")) options.agentKeepAliveTimeoutBuffer = cli.number("--buffer-ms");
+const agent = custom ? new http.Agent(options) : http.globalAgent;
+
+emit("start", {
+  boot_id: bootId(),
+  mode,
+  client: "node-http-agent",
+  node: process.version,
+  agent: {
+    global: !custom,
+    keepAlive: agent.keepAlive,
+    timeout: agent.options.timeout ?? 0,
+    keepAliveMsecs: agent.keepAliveMsecs,
+    agentKeepAliveTimeoutBuffer: agent.agentKeepAliveTimeoutBuffer,
+    scheduling: agent.scheduling,
+  },
+});
+
+setTimeout(() => {
+  emit("deadline");
+  process.exit(0);
+}, max);
+
+// the sockets of the agent, each with its number, its local address, and what happened to it
+const sockets = new Map();
+const isFree = (socket) => Object.values(agent.freeSockets).some((list) => list.includes(socket));
+
+/** This function follows a socket of the agent, one time. */
+const track = (socket) => {
+  const known = sockets.get(socket);
+  if (known !== undefined) return known;
+  const entry = { n: sockets.size + 1, local: null, timedOut: false, pooled: false };
+  sockets.set(socket, entry);
+  const connected = () => {
+    entry.local = `${socket.localAddress}:${socket.localPort}`;
+    emit("conn", { n: entry.n, local: entry.local });
+    if (entry.n === 1) emit("connected", { local: entry.local });
+  };
+  if (socket.connecting) socket.once("connect", connected);
+  else connected();
+  // the listeners of the agent come first: after its free handler, the socket is in the pool or destroyed
+  socket.on("free", () => {
+    entry.pooled = isFree(socket);
+    emit(entry.pooled ? "pooled" : "not-pooled", { local: entry.local });
+  });
+  socket.on("timeout", () => {
+    entry.timedOut = entry.pooled;
+  });
+  socket.on("end", () => emit("eof", { local: entry.local }));
+  socket.on("error", (error) => emit("conn-error", { local: entry.local, errno: error.code ?? "ERROR", message: error.message }));
+  socket.on("close", (hadError) => {
+    // the agent destroys a free socket on its own timeout, or on any read: an end of file or a
+    // reset from the peer (lib/_http_agent.js:101-112). The guard hides the end event
+    const by = entry.timedOut ? "client-timer" : hadError ? "error" : entry.pooled ? "peer" : "client";
+    if (by === "peer") emit("eof", { local: entry.local, free: true });
+    emit("closed", { local: entry.local, by });
+  });
+  return entry;
+};
+
+/** This function sends request `i` and waits for its outcome. */
+const request = (i, how, path) =>
+  new Promise((resolve) => {
+    const at = now();
+    const req = http.request({
+      host: cli.host,
+      port: cli.port,
+      method: how,
+      path,
+      agent,
+      headers: how === "POST" ? { "content-length": "1" } : {},
+    });
+    emit("sent", { i }, at);
+    let ended = false;
+    const end = (ok) => {
+      if (ended) return;
+      ended = true;
+      resolve(ok);
+    };
+    req.on("socket", (socket) => {
+      const entry = track(socket);
+      entry.pooled = false;
+      entry.timedOut = false;
+      const show = () => emit("request", { i, local: entry.local, reused: req.reusedSocket });
+      if (socket.connecting) socket.once("connect", show);
+      else show();
+    });
+    req.on("response", (res) => {
+      emit("response", { i, status: res.statusCode, local: `${res.socket.localAddress}:${res.socket.localPort}` });
+      let n = 0;
+      res.on("data", (chunk) => {
+        n += chunk.length;
+        if (i > 1) emit("data", { i, n: chunk.length });
+      });
+      res.on("end", () => {
+        if (i === 1) emit("ready", { reply: `HTTP ${res.statusCode}` });
+        else emit("replied", { i, n: { value: n, unit: "B" } });
+        end(true);
+      });
+      res.on("error", (error) => {
+        emit("error", { i, errno: error.code ?? "ERROR", message: error.message });
+        end(false);
+      });
+    });
+    req.on("error", (error) => {
+      emit("error", { i, errno: error.code ?? "ERROR", message: error.message });
+      end(false);
+    });
+    req.end(how === "POST" ? "x" : undefined);
+  });
+
+const finish = async () => {
+  emit("done", { i: 2 });
+  await sleep(linger);
+  process.exit(0);
+};
+
+if (!(await request(1, "GET", "/"))) process.exit(1);
+if (mode === "inflight") {
+  await waitFor(cli.flag("--go") ?? "/tmp/go");
+  await request(2, method, second);
+  await finish();
+} else if (mode === "gap") {
+  await sleep(cli.number("--gap-ms", 0));
+  await request(2, method, second);
+  await finish();
+}
+// idle: the connection stays in the pool until it ends, or until the deadline

package/image/node-http/client-undici.mjs

@@ -0,0 +1,141 @@
+// client-undici HOST PORT --mode idle|inflight|gap [--gap-ms N] [--method GET|POST] [--hold-ms N]
+//               [--bytes N] [--go PATH] [--max-s N] [--linger-ms N]
+//               [--keepalive-timeout-ms N] [--keepalive-max-timeout-ms N] [--keepalive-threshold-ms N]
+//               [--headers-timeout-ms N] [--body-timeout-ms N] [--connect-timeout-ms N]
+//               [--keepalive-initial-delay-ms N]
+//
+// The client of the HTTP cells that uses an HTTP/1.1 Client of undici 8.12.2, at its defaults
+// with each flag over them. Each event is a JSON line, as the TCP client of the harness writes them.
+//
+// The workload is the workload of client-agent.mjs. A connector around the connector of undici
+// follows each socket. The channel undici:client:sendHeaders tells which socket each request goes
+// on. The disconnect event of the client tells why a socket ended: an end of file (other side
+// closed), a reset, or the keep-alive timer of the client (socket idle timeout).
+
+import diagnostics from "node:diagnostics_channel";
+import { Client, buildConnector } from "undici";
+import { bootId, commandLine, emit, now, pathOf, sleep, waitFor } from "./lines.mjs";
+
+const usage = "client-undici HOST PORT --mode idle|inflight|gap";
+const cli = commandLine(usage);
+const mode = cli.flag("--mode");
+if (mode !== "idle" && mode !== "inflight" && mode !== "gap") {
+  emit("fail", { why: usage });
+  process.exit(1);
+}
+const method = cli.flag("--method") ?? "GET";
+const second = pathOf({ hold: cli.number("--hold-ms"), bytes: cli.number("--bytes") });
+const max = cli.number("--max-s", 60) * 1000;
+const linger = cli.number("--linger-ms", 500);
+
+// the options of the client: undici's defaults, and each flag over them
+const options = {};
+const set = (option, name) => {
+  if (cli.has(name)) options[option] = cli.number(name);
+};
+set("keepAliveTimeout", "--keepalive-timeout-ms");
+set("keepAliveMaxTimeout", "--keepalive-max-timeout-ms");
+set("keepAliveTimeoutThreshold", "--keepalive-threshold-ms");
+set("headersTimeout", "--headers-timeout-ms");
+set("bodyTimeout", "--body-timeout-ms");
+const connect = {};
+if (cli.has("--connect-timeout-ms")) connect.timeout = cli.number("--connect-timeout-ms");
+if (cli.has("--keepalive-initial-delay-ms")) connect.keepAliveInitialDelay = cli.number("--keepalive-initial-delay-ms");
+
+emit("start", { boot_id: bootId(), mode, client: "undici", node: process.version, options, connect });
+
+setTimeout(() => {
+  emit("deadline");
+  process.exit(0);
+}, max);
+
+// the sockets of the client, each with its number, its local address, and its use
+const sockets = new Map();
+let current = null;
+
+/** This function follows a socket of the client, one time. */
+const track = (socket) => {
+  const known = sockets.get(socket);
+  if (known !== undefined) return known;
+  const entry = { n: sockets.size + 1, local: `${socket.localAddress}:${socket.localPort}`, used: false };
+  sockets.set(socket, entry);
+  current = entry;
+  emit("conn", { n: entry.n, local: entry.local });
+  if (entry.n === 1) emit("connected", { local: entry.local });
+  socket.on("end", () => emit("eof", { local: entry.local }));
+  socket.on("error", (error) =>
+    // undici destroys a socket with an error of its own when it closes the socket itself
+    OWN.has(error.code)
+      ? emit("client-close", { local: entry.local, errno: error.code, message: error.message })
+      : emit("conn-error", { local: entry.local, errno: error.code ?? "ERROR", message: error.message }),
+  );
+  socket.on("close", () => emit("closed", { local: entry.local }));
+  return entry;
+};
+
+// the errors of undici for a close by the client itself: no reuse, its keep-alive timer, its deadlines
+const OWN = new Set(["UND_ERR_INFO", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT", "UND_ERR_CONNECT_TIMEOUT"]);
+
+// the default connector of undici with the connect options, around a function that follows each socket
+const connector = buildConnector(connect);
+let requestIndex = 0;
+const client = new Client(`http://${cli.host}:${cli.port}`, {
+  ...options,
+  connect: (opts, callback) =>
+    connector(opts, (error, socket) => {
+      if (error === null && socket !== undefined && socket !== null) track(socket);
+      callback(error, socket);
+    }),
+});
+
+diagnostics.subscribe("undici:client:sendHeaders", ({ socket }) => {
+  const entry = track(socket);
+  emit("request", { i: requestIndex, local: entry.local, reused: entry.used });
+  entry.used = true;
+});
+client.on("disconnect", (_origin, _targets, error) => {
+  // UND_ERR_INFO is a close by the client: no reuse (reset), or its keep-alive timer (socket idle timeout)
+  const by = OWN.has(error?.code) ? "client" : "peer";
+  emit("disconnect", { local: current?.local ?? null, by, errno: error?.code ?? null, message: error?.message ?? null });
+});
+
+/** This function sends request `i` and waits for its outcome. */
+const request = async (i, how, path) => {
+  requestIndex = i;
+  const at = now();
+  const pending = client.request({ path, method: how, body: how === "POST" ? "x" : undefined });
+  emit("sent", { i }, at);
+  try {
+    const { statusCode, body } = await pending;
+    emit("response", { i, status: statusCode });
+    let n = 0;
+    for await (const chunk of body) {
+      n += chunk.length;
+      if (i > 1) emit("data", { i, n: chunk.length });
+    }
+    if (i === 1) emit("ready", { reply: `HTTP ${statusCode}` });
+    else emit("replied", { i, n: { value: n, unit: "B" } });
+    return true;
+  } catch (error) {
+    emit("error", { i, errno: error.code ?? "ERROR", cause: error.cause?.code ?? null, message: error.message });
+    return false;
+  }
+};
+
+const finish = async () => {
+  emit("done", { i: 2 });
+  await sleep(linger);
+  process.exit(0);
+};
+
+if (!(await request(1, "GET", "/"))) process.exit(1);
+if (mode === "inflight") {
+  await waitFor(cli.flag("--go") ?? "/tmp/go");
+  await request(2, method, second);
+  await finish();
+} else if (mode === "gap") {
+  await sleep(cli.number("--gap-ms", 0));
+  await request(2, method, second);
+  await finish();
+}
+// idle: the connection stays open until it ends, or until the deadline

package/image/node-http/lines.mjs

@@ -0,0 +1,59 @@
+// The JSON lines of the Node programs of the HTTP cells: the server and its two Node clients.
+//
+// Each line has `ev` and `t`, as the TCP client of the harness writes them. `t` is
+// process.hrtime, which libuv reads from CLOCK_MONOTONIC: the clock that the prober stamps the
+// records of the kernel with. The arguments are the host and the port, then flags with a value.
+
+import { existsSync, readFileSync } from "node:fs";
+
+/** This function gives the time now, in nanoseconds on CLOCK_MONOTONIC. */
+export const now = () => process.hrtime.bigint();
+
+/** This function writes one line, with the time `at` (the time now when none is given). */
+export const emit = (ev, fields = {}, at = now()) =>
+  process.stdout.write(`${JSON.stringify({ ev, t: Number(at), ...fields })}\n`);
+
+/** This function gives the boot id of the kernel, or null where the file does not exist. */
+export const bootId = () => {
+  try {
+    return readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+  } catch {
+    return null;
+  }
+};
+
+/** This function reads the command line: the host and the port first, then `--name value` pairs. */
+export const commandLine = (usage) => {
+  const argv = process.argv.slice(2);
+  const [host, port] = argv;
+  const flag = (name) => {
+    const at = argv.indexOf(name);
+    return at === -1 ? undefined : argv[at + 1];
+  };
+  const number = (name, otherwise) => {
+    const value = flag(name);
+    return value === undefined ? otherwise : Number(value);
+  };
+  if (host === undefined || port === undefined) {
+    emit("fail", { why: usage });
+    process.exit(1);
+  }
+  return { host, port: Number(port), flag, number, has: (name) => argv.includes(name) };
+};
+
+/** This function waits until the file at `path` exists. It looks each 2 ms, as the ioredis client does. */
+export const waitFor = (path) =>
+  new Promise((resolve) => {
+    const look = setInterval(() => {
+      if (!existsSync(path)) return;
+      clearInterval(look);
+      resolve();
+    }, 2);
+  });
+
+/** This function waits `ms` milliseconds on a Node timer. */
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** This function gives the path of the second request: a held reply, a long body, or the root. */
+export const pathOf = ({ hold, bytes }) =>
+  hold !== undefined ? `/hold?ms=${hold}` : bytes !== undefined ? `/big?bytes=${bytes}` : "/";

package/image/node-http/npm-lock.json

@@ -0,0 +1,22 @@
+{
+  "name": "loom-harness-http-clients",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "loom-harness-http-clients",
+      "dependencies": {
+        "undici": "8.12.2"
+      }
+    },
+    "node_modules/undici": {
+      "version": "8.12.2",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-8.12.2.tgz",
+      "integrity": "sha512-XtuDWVdqTLr3NAxm2ly9/hU6kUsJOgGh1RASzMBbsw6aWCOaQzHdW+QQDfdERjfJ2V5vL5pRPa4RetO9UfivDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=22.19.0"
+      }
+    }
+  }
+}

package/image/node-http/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "loom-harness-http-clients",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "undici": "8.12.2"
+  }
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/harness",
-  "version": "0.5.0",
-  "description": "A fault-injection harness for connection timers: a cell runs a client against a stock target in Docker, through a topology of routers and proxies or a replicated group under Sentinels, injects a fault, measures the kernel's own records and judges a prediction.",
+  "version": "0.7.0",
+  "description": "A fault-injection harness for connection timers: a cell runs a client against a stock target in Docker, through a topology of routers and proxies, a replicated group under Sentinels or a replica set, injects a fault, measures the kernel's own records and judges a prediction. HTTP clients of Go, Node and undici race the keep-alive of a Node server, and the MongoDB driver meets the faults of a replica set.",
   "keywords": [
     "fault-injection",
     "chaos-engineering",
@@ -47,6 +47,20 @@
     "image/node/observer.mjs",
     "image/node/package.json",
     "image/node/npm-lock.json",
+    "image/go-http/Dockerfile",
+    "image/go-http/go.mod",
+    "image/go-http/main.go",
+    "image/node-http/Dockerfile",
+    "image/node-http/package.json",
+    "image/node-http/npm-lock.json",
+    "image/node-http/lines.mjs",
+    "image/node-http/client-agent.mjs",
+    "image/node-http/client-undici.mjs",
+    "image/mongo/Dockerfile",
+    "image/mongo/client-mongo.mjs",
+    "image/mongo/stepdown-mongo.mjs",
+    "image/mongo/package.json",
+    "image/mongo/npm-lock.json",
     "image/router/Dockerfile",
     "image/router/mbx.sh",
     "image/router/ctwatch.py",