@mark1russell7/harness 0.11.1 → 0.11.2

package/image/pg/Dockerfile

@@ -0,0 +1,11 @@
+# The harness's PostgreSQL client: node-postgres (pg 8.23.1 with pg-pool 3.14.0) on Node 24.21.0. 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, with the events of the pool beside them.
+# lab.ts stages the build context: this folder, under harness/image/pg. 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/pg
+COPY harness/image/pg/package.json ./
+COPY harness/image/pg/npm-lock.json ./package-lock.json
+RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
+COPY harness/image/pg/client-pg.mjs ./

package/image/pg/client-pg.mjs

@@ -0,0 +1,162 @@
+// client-pg HOST PORT --mode idle|inflight|stream [--interval-ms N] [--max-s N] [--go PATH]
+//           [--query TEXT] [--before] [--options JSON]
+//
+// The client of a PostgreSQL cell: node-postgres (pg 8.23.1 with pg-pool 3.14.0) on Node 24.21.0.
+// Each event is a JSON line with `ev` and `t`, the time on CLOCK_MONOTONIC in nanoseconds
+// (process.hrtime, which libuv reads from it). The prober stamps the records of the kernel on the
+// same clock, and the injector stamps each fault on it.
+//
+// The lines:
+// - start: the versions of pg, pg-pool and Node, the mode and the options of the pool.
+// - socket, socket-end, socket-error: each socket of the pool, with its local address.
+// - connected: the first socket. The TCP client of the harness names its own socket so.
+// - pool: each event of the pool: connect, acquire, release, remove, and error with its errno.
+// - ready: the reply to the first query: the connection is idle in the pool (idle, inflight), or
+//   the stream starts (stream).
+// - sent, ack, fail: each query by its sequence number, with its error.
+// - data, error: the end of the query in flight, as the TCP client of the harness tells it. In idle
+//   mode, an error of the pool for the first socket is an error line too: the pool removes it.
+// - done, deadline: the end of the client.
+//
+// The modes: idle sends one query, gives the client back to the pool, then holds until --max-s.
+// inflight sends one query, waits for the file --go, sends one more query into the fault, and holds
+// after its end. stream sends a query each --interval-ms after the reply before, until --max-s or
+// SIGTERM. --before starts the client into a fault that holds already: its first connect meets it.
+
+import { readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
+
+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 || !["idle", "inflight", "stream"].includes(mode)) {
+  emit("fail", { why: "client-pg HOST PORT --mode idle|inflight|stream" });
+  process.exit(1);
+}
+const interval = Number(flag("--interval-ms") ?? 50);
+const max = Number(flag("--max-s") ?? 120) * 1000;
+const go = flag("--go") ?? "/tmp/go";
+const query = flag("--query") ?? "SELECT 1";
+const before = argv.includes("--before");
+// the options of the pool. A cell gives each option that it changes, and pg-pool gives the others
+const options = JSON.parse(flag("--options") ?? "{}");
+
+const { default: pg } = await import("pg");
+const versionOf = (name) => JSON.parse(readFileSync(new URL(`./node_modules/${name}/package.json`, import.meta.url), "utf8")).version;
+
+const bootId = () => {
+  try {
+    return readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+  } catch {
+    return null;
+  }
+};
+emit("start", { boot_id: bootId(), client: "pg", driver: versionOf("pg"), pool: versionOf("pg-pool"), node: process.versions.node, mode, query, options });
+
+const pool = new pg.Pool({ host, port: Number(port), user: "postgres", database: "postgres", ...options });
+
+/** This function gives the error of pg as data: its name, its code, its severity and its message. */
+const failure = (error) =>
+  error === undefined || error === null
+    ? null
+    : { name: error.name, code: error.code ?? null, errno: error.errno ?? null, severity: error.severity ?? null, message: error.message };
+/** This function gives the errno of an error: the code of the socket (ECONNRESET), the SQLSTATE of the server, or the message of pg. */
+const errnoOf = (error) => error?.code ?? error?.message ?? null;
+
+// ---- each socket of the pool: pg-pool emits connect after the first ReadyForQuery of a new client
+let connected = null;
+const localOf = (client) => {
+  const socket = client?.connection?.stream;
+  return socket?.localPort === undefined ? null : `${socket.localAddress}:${socket.localPort}`;
+};
+pool.on("connect", (client) => {
+  const socket = client.connection.stream;
+  const local = localOf(client);
+  emit("socket", { role: "pool", local });
+  emit("pool", { event: "connect", local });
+  if (connected === null && local !== null) {
+    connected = local;
+    emit("connected", { local });
+  }
+  socket.once("close", (hadError) => emit("socket-end", { role: "pool", local, error: hadError }));
+  socket.once("error", (error) => emit("socket-error", { role: "pool", local, errno: errnoOf(error), message: error.message }));
+});
+pool.on("acquire", (client) => emit("pool", { event: "acquire", local: localOf(client) }));
+pool.on("release", (error, client) => emit("pool", { event: "release", local: localOf(client), failure: failure(error) }));
+// the pool removes a client: after its idle timer, its lifetime or an error. A driver band names the close CLOSED
+pool.on("remove", (client) => emit("pool", { event: "remove", name: "CLOSED", local: localOf(client) }));
+// an idle client that fails: the pool removes it and emits error. Without this listener, Node throws
+pool.on("error", (error, client) => {
+  const local = localOf(client);
+  emit("pool", { event: "error", local, failure: failure(error) });
+  // the socket of the client in idle mode: its error is the detection, as for the TCP client
+  if (mode === "idle" && local !== null && local === connected) emit("error", { errno: errnoOf(error) });
+});
+
+// ---- the end of the client
+let stopped = false;
+const stop = (code = 0) => {
+  if (stopped) return;
+  stopped = true;
+  emit("done");
+  pool.end().finally(() => setTimeout(() => process.exit(code), 50));
+};
+process.on("SIGTERM", () => stop(0));
+setTimeout(() => {
+  emit("deadline");
+  stop(0);
+}, max);
+
+/** This function sends query n through the pool. Its stamp is before the call. It gives null for a reply, or the error. */
+const operate = async (n) => {
+  const at = now();
+  const reply = pool.query(query);
+  emit("sent", { n }, at);
+  try {
+    const result = await reply;
+    emit("ack", { n, rows: result.rowCount ?? null });
+    return null;
+  } catch (error) {
+    emit("fail", { n, ...failure(error) });
+    return error;
+  }
+};
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+if (mode === "stream") {
+  emit("ready", { at: `${host}:${port}` });
+  for (let n = 1; !stopped; n += 1) {
+    await operate(n);
+    await sleep(interval);
+  }
+} else {
+  // the first query makes the connection of the pool. Its reply is the last data before the fault
+  const failed = await operate(1);
+  if (failed !== null) {
+    emit("error", { errno: errnoOf(failed), message: failed.message });
+    stop(before ? 0 : 1);
+  } else {
+    // pool.query gives the client back to the pool at its reply: the connection is idle there
+    emit("ready", { reply: "ack" });
+    if (mode === "inflight") {
+      await new Promise((resolve) => {
+        const wait = setInterval(() => {
+          if (!existsSync(go)) return;
+          clearInterval(wait);
+          resolve();
+        }, 2);
+      });
+      const error = await operate(2);
+      if (error === null) emit("data", { n: 2 });
+      else emit("error", { errno: errnoOf(error), message: error.message });
+    }
+  }
+}

package/image/pg/npm-lock.json

@@ -0,0 +1,160 @@
+{
+  "name": "loom-harness-pg-client",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "loom-harness-pg-client",
+      "dependencies": {
+        "pg": "8.23.1",
+        "pg-pool": "3.14.0"
+      }
+    },
+    "node_modules/pg": {
+      "version": "8.23.1",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.23.1.tgz",
+      "integrity": "sha512-aL96AHANtWjPLDOLqnhx+ngp9+UK7ETEU8VJrDCGvsSSi/mGLcWYsS6Herg7lmaBJe4uwrfqsa7gTEFaSizDoQ==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-connection-string": "^2.14.1",
+        "pg-pool": "^3.14.0",
+        "pg-protocol": "^1.16.1",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      },
+      "engines": {
+        "node": ">= 16.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.4.1"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.4.1.tgz",
+      "integrity": "sha512-6PQbsFWZcp9EmJEwy5cGQ2La+AMWpP46lgbb8X+U/XsHIUweYDNCpeuKck5RxL2MdVFi7krbbEi5nX4Zh7JhrQ==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/pg-connection-string": {
+      "version": "2.14.1",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.14.1.tgz",
+      "integrity": "sha512-qR3kGNPBLpCNtz0evbKA0Y/MRFXwSSdT+pTJvYp/bXTcReZbvX1kzF0IyTc1QnxqF7AZbOeBhNL8R5mYQZV/MA==",
+      "license": "MIT"
+    },
+    "node_modules/pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.14.0",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.14.0.tgz",
+      "integrity": "sha512-gKtPkFdQPU3DksooVLi9LsjZxrsBUZIpa+7aVx+LV5pNh0KzP4Zleud2po+ConrxbuXGBJ6Hfer6hdgpIBpBaw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.16.1",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.16.1.tgz",
+      "integrity": "sha512-p9VOFMiHB/ZbJATetbg+99PxssTVSQRnyuPSQ67mN1+1KBOjZaZ83ZQzltnxPhJwSsC3nwVjJ10DVJlerbFzLg==",
+      "license": "MIT"
+    },
+    "node_modules/pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "postgres-array": "~2.0.0",
+        "postgres-bytea": "~1.0.0",
+        "postgres-date": "~1.0.4",
+        "postgres-interval": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
+    "node_modules/postgres-array": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz",
+      "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-date": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-interval": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    }
+  }
+}

package/image/pg/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "loom-harness-pg-client",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "pg": "8.23.1",
+    "pg-pool": "3.14.0"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/harness",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "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. The WebSocket client of @procedures/client drops a silent connection on its own heartbeat, and the harness times that detection and the reconnect from the program's lines and the kernel's stamps.",
   "keywords": [
     "fault-injection",
@@ -61,6 +61,10 @@
     "image/mongo/stepdown-mongo.mjs",
     "image/mongo/package.json",
     "image/mongo/npm-lock.json",
+    "image/pg/Dockerfile",
+    "image/pg/client-pg.mjs",
+    "image/pg/package.json",
+    "image/pg/npm-lock.json",
     "image/procedures/Dockerfile",
     "image/procedures/package.json",
     "image/procedures/npm-lock.json",