@mark1russell7/harness 0.11.5 → 0.11.6

package/README.md

@@ -162,6 +162,7 @@ The harness ships eight images, each as a shipped source (`ImageSource`). The ta
 - **The HikariCP client image** (`image/hikari`) is HikariCP 7.1.0 over pgjdbc 42.7.13 on Temurin 21.0.12.1. The digests of the two stages and the SHA-256 of each jar pin them. The probe is `{ driver: { name: "hikari", query } }`.
   - `ClientHikari.java` makes one `HikariDataSource` with the properties of the cell (`Cell.driverOptions`). A name with the prefix `dataSource.` is a property of pgjdbc.
   - It prints the lines of the pg client on the same clock. Each socket comes from the `PGStream` of its connection, and a `pool` line gives each change of the counts of the pool. The errno of a failure is the SQLState of pgjdbc.
+  - Before its first line, it loads the classes of a connect and of a pool on the loopback of its namespace. It also starts the SecureRandom that HikariCP reads for the UUID of each new connection. A new JVM loads each class at its first use. Thus a cell that starts into a fault does not time that load.
 - **The MongoDB client image** (`image/mongo`) is the driver mongodb 7.7.0 on Node 24.21.0. The digest of the image and an npm lockfile pin them. `client-mongo.mjs` prints the lines of the TCP client on the same clock:
   - Each socket of the driver is a `socket` line with its role: `monitor`, `rtt` or `pool`. The stack of the call that makes the socket gives the role.
   - The events of the driver are `sdam` lines (the heartbeats and the changes of each server), `cmap` lines (the pools) and `command` lines (each try of an operation).

package/image/hikari/ClientHikari.java

@@ -361,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);
@@ -376,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 {

package/package.json

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