@mark1russell7/harness 0.11.6 → 0.11.8

package/build/schema.d.ts

@@ -1,4 +1,4 @@
-import { J as Subject, _ as ImageSource, i as ClientImage, r as Client } from "./cell-lSCgFB54.js";
+import { J as Subject, _ as ImageSource, i as ClientImage, r as Client } from "./cell-7HFQIHlK.js";
 import { z } from "zod";
 //#region src/schema.d.ts
 /**

package/image/hikari/ClientHikari.java

@@ -1,5 +1,5 @@
 // client-hikari HOST PORT --mode idle|inflight|stream [--interval-ms N] [--max-s N] [--go PATH]
-//               [--query TEXT] [--before] [--options JSON]
+//               [--query TEXT] [--inflight-query TEXT] [--before] [--options JSON]
 //
 // The client of a HikariCP cell: HikariCP 7.1.0 over pgjdbc 42.7.13, on Java 21. Each event is a
 // JSON line with `ev` and `t`, the time on CLOCK_MONOTONIC in nanoseconds (System.nanoTime, which
@@ -24,7 +24,8 @@
 // connection goes 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. --before starts the client into a fault that holds
-// already: the start of its pool meets it.
+// already: the start of its pool meets it. --inflight-query is the text of the query in flight
+// (query 2 of inflight), and --query is the text of each other query.
 //
 // The options are one flat JSON object. A name with the prefix `dataSource.` is a property of
 // pgjdbc. Each other name is a property of HikariConfig. A cell gives each option that it changes,
@@ -53,6 +54,8 @@ import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import org.postgresql.core.PGStream;
 import org.postgresql.jdbc.PgConnection;
+import org.postgresql.util.PSQLException;
+import org.postgresql.util.ServerErrorMessage;
 
 public final class ClientHikari {
   private static final PrintStream OUT = new PrintStream(new FileOutputStream(FileDescriptor.out), false, StandardCharsets.UTF_8);
@@ -65,6 +68,7 @@ public final class ClientHikari {
   private static String host;
   private static String port;
   private static String query;
+  private static String inflightQuery;
   private static HikariConfig config;
 
   private ClientHikari() {}
@@ -334,8 +338,13 @@ public final class ClientHikari {
     Runtime.getRuntime().halt(code);
   }
 
-  /** This function sends query n through the pool. Its stamp is before the borrow. It gives null for a reply, or the error. */
+  /** This function sends query n through the pool, with the text of each query. Its stamp is before the borrow. It gives null for a reply, or the error. */
   private static Throwable operate(int n) {
+    return operate(n, query);
+  }
+
+  /** This function sends query n through the pool, with its text. Its stamp is before the borrow. It gives null for a reply, or the error. */
+  private static Throwable operate(int n, String text) {
     long at = now();
     if (n == 1) emit("connecting", at, "\"at\":" + q(host + ":" + port));
     emit("sent", at, "\"n\":" + n);
@@ -346,7 +355,7 @@ public final class ClientHikari {
       try (Connection connection = pool.getConnection()) {
         seen(connection);
         try (Statement statement = connection.createStatement()) {
-          if (statement.execute(query)) {
+          if (statement.execute(text)) {
             try (ResultSet result = statement.getResultSet()) {
               while (result.next()) rows += 1;
             }
@@ -368,8 +377,10 @@ public final class ClientHikari {
    * makes no connection: it loads the classes of the pool. It also sets the login timeout of
    * DriverManager, thus pgjdbc then connects in a task of an executor (Driver.java:303-311,
    * :730-739). A connect to port 1 of the loopback after it is refused at once: it loads that
-   * connect of pgjdbc and its errors. HikariCP gives each new connection a random UUID (PoolBase.java:363), and the
-   * first one starts the SecureRandom of the JVM.
+   * connect of pgjdbc and its errors. HikariCP gives each new connection a random UUID
+   * (PoolBase.java:363), and the first one starts the SecureRandom of the JVM. An error of the
+   * server that pgjdbc parses loads the classes of an ERROR of a statement, for example of its
+   * timeout.
    */
   private static void warmUp() {
     HikariConfig empty = new HikariConfig();
@@ -388,6 +399,10 @@ public final class ClientHikari {
       // the refusal is the purpose of the connect
     }
     java.util.UUID.randomUUID();
+    // the fields of an ErrorResponse, each a code and a text with a NUL after it
+    PSQLException cancelled = new PSQLException(new ServerErrorMessage("SERROR\0VERROR\0C57014\0Mwarm-up\0"));
+    errnoOf(cancelled);
+    failure(cancelled);
   }
 
   public static void main(String[] args) throws Exception {
@@ -403,6 +418,7 @@ public final class ClientHikari {
     long max = Long.parseLong(flag(argv, "--max-s", "120")) * 1000;
     Path go = Path.of(flag(argv, "--go", "/tmp/go"));
     query = flag(argv, "--query", "SELECT 1");
+    inflightQuery = flag(argv, "--inflight-query", query);
     boolean before = argv.contains("--before");
     Map<String, String> options = parseObject(flag(argv, "--options", "{}"));
     warmUp();
@@ -424,7 +440,7 @@ public final class ClientHikari {
         + ",\"client\":\"hikari\",\"driver\":" + q(org.postgresql.util.DriverInfo.DRIVER_VERSION)
         + ",\"pool\":" + q(hikari == null ? "7.1.0" : hikari)
         + ",\"java\":" + q(System.getProperty("java.version"))
-        + ",\"mode\":" + q(mode) + ",\"query\":" + q(query) + ",\"options\":" + given);
+        + ",\"mode\":" + q(mode) + ",\"query\":" + q(query) + ",\"inflight_query\":" + q(inflightQuery) + ",\"options\":" + given);
 
     Properties properties = new Properties();
     for (Map.Entry<String, String> each : options.entrySet()) properties.setProperty(each.getKey(), each.getValue());
@@ -475,7 +491,7 @@ public final class ClientHikari {
     if (mode.equals("idle")) watchIdle();
     if (mode.equals("inflight")) {
       while (!Files.exists(go)) Thread.sleep(2);
-      Throwable error = operate(2);
+      Throwable error = operate(2, inflightQuery);
       if (error == null) emit("data", "\"n\":2");
       else emit("error", "\"errno\":" + q(errnoOf(error)) + ",\"message\":" + q(error.getMessage()));
     }

package/image/pg/client-pg.mjs

@@ -1,5 +1,5 @@
 // client-pg HOST PORT --mode idle|inflight|stream [--interval-ms N] [--max-s N] [--go PATH]
-//           [--query TEXT] [--before] [--options JSON]
+//           [--query TEXT] [--inflight-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
@@ -24,6 +24,9 @@
 // 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.
+// --inflight-query is the text of the query in flight (query 2 of inflight), and --query is the
+// text of each other query. Thus a slow query in flight does not delay the reply that makes the
+// client ready.
 
 import { readFileSync } from "node:fs";
 import { existsSync } from "node:fs";
@@ -46,6 +49,7 @@ 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 inflightQuery = flag("--inflight-query") ?? query;
 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") ?? "{}");
@@ -60,7 +64,7 @@ const bootId = () => {
     return null;
   }
 };
-emit("start", { boot_id: bootId(), client: "pg", driver: versionOf("pg"), pool: versionOf("pg-pool"), node: process.versions.node, mode, query, options });
+emit("start", { boot_id: bootId(), client: "pg", driver: versionOf("pg"), pool: versionOf("pg-pool"), node: process.versions.node, mode, query, inflight_query: inflightQuery, options });
 
 const pool = new pg.Pool({ host, port: Number(port), user: "postgres", database: "postgres", ...options });
 
@@ -116,10 +120,10 @@ setTimeout(() => {
   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) => {
+/** This function sends query n through the pool, with the text of n. Its stamp is before the call. It gives null for a reply, or the error. */
+const operate = async (n, text = query) => {
   const at = now();
-  const reply = pool.query(query);
+  const reply = pool.query(text);
   // a band of a cell that starts into a fault counts from the start of the first connect
   if (n === 1) emit("connecting", { at: `${host}:${port}` }, at);
   emit("sent", { n }, at);
@@ -158,7 +162,7 @@ if (mode === "stream") {
           resolve();
         }, 2);
       });
-      const error = await operate(2);
+      const error = await operate(2, inflightQuery);
       if (error === null) emit("data", { n: 2 });
       else emit("error", { errno: errnoOf(error), message: error.message });
     }

package/image/router/ctwatch.py

@@ -4,9 +4,10 @@
 Each line is {"ev": "ct", "t": <CLOCK_MONOTONIC ns>, "type": "NEW|UPDATE|DESTROY", "state": ...,
 "orig": "src:sport>dst:dport", "reply": "..."}. The stamp is the time that this process read the
 event, which is within a millisecond of the kernel. A listing every PUMP seconds evicts the expired
-entries that it walks past, thus a DESTROY follows an expiry within PUMP plus two listings. A
-listing that takes longer than SLOW seconds writes a "pump-slow" line with its start and its
-length: near it, that bound of the lag does not hold.
+entries that it walks past, thus a DESTROY follows an expiry within PUMP plus two listings, and
+the slack of the sleep and of the read (PUMP_SLACK of the harness, 5 ms). A listing that takes
+longer than SLOW seconds writes a "pump-slow" line with its start and its length: near it, that
+bound of the lag does not hold.
 
   ctwatch.py [--pump SECONDS] [--slow SECONDS]
 """

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/harness",
-  "version": "0.11.6",
+  "version": "0.11.8",
   "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",