@mark1russell7/harness 0.11.4 → 0.11.6

package/build/schema.d.ts

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

package/image/hikari/ClientHikari.java

@@ -16,7 +16,8 @@
 // - 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.
+// - data, error: the end of the query in flight, as the TCP client of the harness tells it. In idle
+//   mode, the close of the socket of the first connection is an error line too: the pool closed it.
 // - done, deadline: the end of the client.
 //
 // The modes are those of the pg client. idle sends one query, closes its connection (the
@@ -60,6 +61,7 @@ public final class ClientHikari {
   private static volatile boolean stopped = false;
   private static volatile HikariDataSource pool;
   private static volatile String connected;
+  private static volatile Socket observed;
   private static String host;
   private static String port;
   private static String query;
@@ -216,8 +218,8 @@ public final class ClientHikari {
 
   // ---- each connection that the client borrows: its socket, read from pgjdbc
 
-  /** This function gives the local address of the socket of a connection, or null. */
-  private static String localOf(Connection connection) {
+  /** This function gives the socket of a connection, from the PGStream of pgjdbc, or null. */
+  private static Socket socketOf(Connection connection) {
     try {
       PgConnection pg = connection.unwrap(PgConnection.class);
       Object executor = pg.getQueryExecutor();
@@ -231,23 +233,50 @@ public final class ClientHikari {
       }
       if (field == null) return null;
       field.setAccessible(true);
-      Socket socket = ((PGStream) field.get(executor)).getSocket();
-      return socket.getLocalAddress().getHostAddress() + ":" + socket.getLocalPort();
+      return ((PGStream) field.get(executor)).getSocket();
     } catch (Exception error) {
       return null;
     }
   }
 
   private static void seen(Connection connection) {
-    String local = localOf(connection);
-    if (local == null || !SEEN.add(local)) return;
+    Socket socket = socketOf(connection);
+    if (socket == null) return;
+    String local = socket.getLocalAddress().getHostAddress() + ":" + socket.getLocalPort();
+    if (!SEEN.add(local)) return;
     emit("socket", "\"role\":\"pool\",\"local\":" + q(local));
     if (connected == null) {
       connected = local;
+      observed = socket;
       emit("connected", "\"local\":" + q(local));
     }
   }
 
+  /**
+   * This function watches the socket of the first connection in idle mode, each 2 ms. The pool
+   * closes it when a check finds it dead: pgjdbc closes the socket after a read timeout or an I/O
+   * error. That close is the detection of an idle cell, thus it writes an error line.
+   */
+  private static void watchIdle() {
+    Socket socket = observed;
+    if (socket == null) return;
+    Thread watcher = new Thread(() -> {
+      while (!stopped) {
+        if (socket.isClosed()) {
+          emit("error", "\"errno\":\"CLOSED\",\"local\":" + q(connected));
+          return;
+        }
+        try {
+          Thread.sleep(2);
+        } catch (InterruptedException stop) {
+          return;
+        }
+      }
+    }, "idle-watcher");
+    watcher.setDaemon(true);
+    watcher.start();
+  }
+
   // ---- the counts of the pool, each 5 ms: a line for each change
 
   private static void watchPool() {
@@ -332,6 +361,35 @@ public final class ClientHikari {
     }
   }
 
+  /**
+   * This function loads the code of a connect and of the start of a pool before the first line, on
+   * the loopback of the namespace. A new JVM loads each class at its first use, and that load would
+   * be in the band of a cell that starts into a fault. A pool with no check and no idle connection
+   * 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.
+   */
+  private static void warmUp() {
+    HikariConfig empty = new HikariConfig();
+    empty.setJdbcUrl("jdbc:postgresql://127.0.0.1:1/warmup");
+    empty.setUsername("warmup");
+    empty.setPoolName("warmup");
+    empty.setInitializationFailTimeout(-1);
+    empty.setMinimumIdle(0);
+    // the pool starts and closes with no connection
+    new HikariDataSource(empty).close();
+    Properties refused = new Properties();
+    refused.setProperty("user", "warmup");
+    try {
+      new org.postgresql.Driver().connect("jdbc:postgresql://127.0.0.1:1/warmup", refused);
+    } catch (SQLException expected) {
+      // the refusal is the purpose of the connect
+    }
+    java.util.UUID.randomUUID();
+  }
+
   public static void main(String[] args) throws Exception {
     List<String> argv = List.of(args);
     String mode = flag(argv, "--mode", null);
@@ -347,6 +405,7 @@ public final class ClientHikari {
     query = flag(argv, "--query", "SELECT 1");
     boolean before = argv.contains("--before");
     Map<String, String> options = parseObject(flag(argv, "--options", "{}"));
+    warmUp();
 
     String bootId;
     try {
@@ -413,6 +472,7 @@ public final class ClientHikari {
     }
     // the connection went back to the pool at the end of the query: it is idle there
     emit("ready", "\"reply\":\"ack\"");
+    if (mode.equals("idle")) watchIdle();
     if (mode.equals("inflight")) {
       while (!Files.exists(go)) Thread.sleep(2);
       Throwable error = operate(2);

package/package.json

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