@mark1russell7/harness 0.11.2 → 0.11.4

package/build/schema.d.ts

@@ -0,0 +1,19 @@
+import { J as Subject, _ as ImageSource, i as ClientImage, r as Client } from "./cell-Di_YHiuB.js";
+import { z } from "zod";
+//#region src/schema.d.ts
+/**
+ * This schema accepts the source of an image (`ImageSource`). It is a pinned image with its digest,
+ * a build context whose paths stay in it, or an image that the harness ships.
+ */
+export declare const imageSourceSchema: z.ZodType<ImageSource>;
+/** This schema accepts a client image (`ClientImage`): a stock image by its name or the source of an image, and its command. */
+export declare const clientImageSchema: z.ZodType<ClientImage>;
+/** This schema accepts the client of a cell (`Cell.client`): a client that the harness ships by its name, or a client image. */
+export declare const clientSchema: z.ZodType<Client | ClientImage>;
+/**
+ * This schema accepts a subject (`Subject`): its name, the source of its image and its stock base.
+ * It also accepts the command of each of its programs.
+ */
+export declare const subjectSchema: z.ZodType<Subject>;
+//#endregion
+//# sourceMappingURL=schema.d.ts.map

package/build/schema.js

@@ -0,0 +1,56 @@
+import { S as subjectProblems, a as SHIPPED_NAMES, d as imageProblems, t as CLIENT_NAMES } from "./image-BfuXg-5t.js";
+import { z } from "zod";
+//#region src/schema.ts
+/** This function adds each problem that a check finds as an issue of a schema. */
+const issues = (check) => (value, ctx) => {
+	for (const message of check(value)) ctx.addIssue({
+		code: "custom",
+		message
+	});
+};
+/** This schema accepts a command: argv of one text or more. */
+const command = z.array(z.string().min(1)).min(1);
+/** This schema accepts the shape of each kind of image source. The checks of its values come after it. */
+const sourceShape = z.discriminatedUnion("kind", [
+	z.strictObject({
+		kind: z.literal("pinned"),
+		image: z.string()
+	}),
+	z.strictObject({
+		kind: z.literal("build"),
+		name: z.string(),
+		context: z.string(),
+		dockerfile: z.string().optional(),
+		files: z.array(z.string()).optional()
+	}),
+	z.strictObject({
+		kind: z.literal("shipped"),
+		name: z.enum(SHIPPED_NAMES)
+	})
+]);
+/**
+* This schema accepts the source of an image (`ImageSource`). It is a pinned image with its digest,
+* a build context whose paths stay in it, or an image that the harness ships.
+*/
+const imageSourceSchema = sourceShape.superRefine(issues(imageProblems));
+/** This schema accepts a client image (`ClientImage`): a stock image by its name or the source of an image, and its command. */
+const clientImageSchema = z.strictObject({
+	image: z.union([z.string().min(1), imageSourceSchema]),
+	command
+});
+/** This schema accepts the client of a cell (`Cell.client`): a client that the harness ships by its name, or a client image. */
+const clientSchema = z.union([z.enum(CLIENT_NAMES), clientImageSchema]);
+/**
+* This schema accepts a subject (`Subject`): its name, the source of its image and its stock base.
+* It also accepts the command of each of its programs.
+*/
+const subjectSchema = z.strictObject({
+	name: z.string().min(1),
+	image: sourceShape,
+	base: z.string(),
+	programs: z.record(z.string(), command)
+}).superRefine(issues(subjectProblems));
+//#endregion
+export { clientImageSchema, clientSchema, imageSourceSchema, subjectSchema };
+
+//# sourceMappingURL=schema.js.map

package/build/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","names":[],"sources":["../src/schema.ts"],"sourcesContent":["// The entry \"@mark1russell7/harness/schema\": the zod schemas of the data that a caller gives the\n// harness as JSON. These are the source of an image, a client and a subject. The root entry of\n// the package does not import zod.\nimport { z } from \"zod\";\nimport type { Client, ClientImage, ImageSource, Subject } from \"./cell.ts\";\nimport { CLIENT_NAMES, SHIPPED_NAMES, imageProblems, subjectProblems } from \"./image.ts\";\n\n/** This function adds each problem that a check finds as an issue of a schema. */\nconst issues =\n  <T>(check: (value: T) => string[]) =>\n  (value: T, ctx: z.RefinementCtx): void => {\n    for (const message of check(value)) ctx.addIssue({ code: \"custom\", message });\n  };\n\n/** This schema accepts a command: argv of one text or more. */\nconst command = z.array(z.string().min(1)).min(1);\n\n/** This schema accepts the shape of each kind of image source. The checks of its values come after it. */\nconst sourceShape = z.discriminatedUnion(\"kind\", [\n  z.strictObject({ kind: z.literal(\"pinned\"), image: z.string() }),\n  z.strictObject({\n    kind: z.literal(\"build\"),\n    name: z.string(),\n    context: z.string(),\n    dockerfile: z.string().optional(),\n    files: z.array(z.string()).optional(),\n  }),\n  z.strictObject({ kind: z.literal(\"shipped\"), name: z.enum(SHIPPED_NAMES) }),\n]);\n\n/**\n * This schema accepts the source of an image (`ImageSource`). It is a pinned image with its digest,\n * a build context whose paths stay in it, or an image that the harness ships.\n */\nexport const imageSourceSchema: z.ZodType<ImageSource> = sourceShape.superRefine(issues(imageProblems));\n\n/** This schema accepts a client image (`ClientImage`): a stock image by its name or the source of an image, and its command. */\nexport const clientImageSchema: z.ZodType<ClientImage> = z.strictObject({\n  image: z.union([z.string().min(1), imageSourceSchema]),\n  command,\n});\n\n/** This schema accepts the client of a cell (`Cell.client`): a client that the harness ships by its name, or a client image. */\nexport const clientSchema: z.ZodType<Client | ClientImage> = z.union([z.enum(CLIENT_NAMES), clientImageSchema]);\n\n/**\n * This schema accepts a subject (`Subject`): its name, the source of its image and its stock base.\n * It also accepts the command of each of its programs.\n */\nexport const subjectSchema: z.ZodType<Subject> = z\n  .strictObject({\n    name: z.string().min(1),\n    image: sourceShape,\n    base: z.string(),\n    programs: z.record(z.string(), command),\n  })\n  .superRefine(issues(subjectProblems));\n"],"mappings":";;;;AAQA,MAAM,UACA,WACH,OAAU,QAA+B;CACxC,KAAK,MAAM,WAAW,MAAM,KAAK,GAAG,IAAI,SAAS;EAAE,MAAM;EAAU;CAAQ,CAAC;AAC9E;;AAGF,MAAM,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;;AAGhD,MAAM,cAAc,EAAE,mBAAmB,QAAQ;CAC/C,EAAE,aAAa;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAG,OAAO,EAAE,OAAO;CAAE,CAAC;CAC/D,EAAE,aAAa;EACb,MAAM,EAAE,QAAQ,OAAO;EACvB,MAAM,EAAE,OAAO;EACf,SAAS,EAAE,OAAO;EAClB,YAAY,EAAE,OAAO,CAAC,CAAC,SAAS;EAChC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS;CACtC,CAAC;CACD,EAAE,aAAa;EAAE,MAAM,EAAE,QAAQ,SAAS;EAAG,MAAM,EAAE,KAAK,aAAa;CAAE,CAAC;AAC5E,CAAC;;;;;AAMD,MAAa,oBAA4C,YAAY,YAAY,OAAO,aAAa,CAAC;;AAGtG,MAAa,oBAA4C,EAAE,aAAa;CACtE,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC;CACrD;AACF,CAAC;;AAGD,MAAa,eAAgD,EAAE,MAAM,CAAC,EAAE,KAAK,YAAY,GAAG,iBAAiB,CAAC;;;;;AAM9G,MAAa,gBAAoC,EAC9C,aAAa;CACZ,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACtB,OAAO;CACP,MAAM,EAAE,OAAO;CACf,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;AACxC,CAAC,CAAC,CACD,YAAY,OAAO,eAAe,CAAC"}

package/image/hikari/ClientHikari.java

@@ -0,0 +1,424 @@
+// client-hikari HOST PORT --mode idle|inflight|stream [--interval-ms N] [--max-s N] [--go PATH]
+//               [--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
+// the JVM reads from it on Linux). 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 HikariCP, pgjdbc and Java, the mode and the options.
+// - connecting: the start of the pool and of its first connection. Its stamp is the stamp of the
+//   first sent line.
+// - socket: each connection that the client borrows, with its local address, at its first borrow.
+// - connected: the first socket. The TCP client of the harness names its own socket so.
+// - pool: each change of the counts of the pool: total, active, idle and waiting.
+// - 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.
+// - done, deadline: the end of the client.
+//
+// The modes are those of the pg client. idle sends one query, closes its connection (the
+// 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.
+//
+// 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,
+// and HikariCP and pgjdbc give the others.
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import com.zaxxer.hikari.HikariPoolMXBean;
+import java.io.FileDescriptor;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.net.Socket;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import org.postgresql.core.PGStream;
+import org.postgresql.jdbc.PgConnection;
+
+public final class ClientHikari {
+  private static final PrintStream OUT = new PrintStream(new FileOutputStream(FileDescriptor.out), false, StandardCharsets.UTF_8);
+  private static final Object LOCK = new Object();
+  private static final Set<String> SEEN = ConcurrentHashMap.newKeySet();
+  private static volatile boolean stopped = false;
+  private static volatile HikariDataSource pool;
+  private static volatile String connected;
+  private static String host;
+  private static String port;
+  private static String query;
+  private static HikariConfig config;
+
+  private ClientHikari() {}
+
+  private static long now() {
+    return System.nanoTime();
+  }
+
+  /** This function writes one line: its event, its stamp, and the JSON fields after them. */
+  private static void emit(String ev, long t, String fields) {
+    String line = "{\"ev\":" + q(ev) + ",\"t\":" + t + (fields.isEmpty() ? "" : "," + fields) + "}\n";
+    synchronized (LOCK) {
+      OUT.print(line);
+      OUT.flush();
+    }
+  }
+
+  private static void emit(String ev, String fields) {
+    emit(ev, now(), fields);
+  }
+
+  /** This function gives a text as a JSON string, or null. */
+  private static String q(String text) {
+    if (text == null) return "null";
+    StringBuilder out = new StringBuilder("\"");
+    for (char c : text.toCharArray()) {
+      switch (c) {
+        case '"' -> out.append("\\\"");
+        case '\\' -> out.append("\\\\");
+        case '\n' -> out.append("\\n");
+        case '\r' -> out.append("\\r");
+        case '\t' -> out.append("\\t");
+        default -> {
+          if (c < 0x20) out.append(String.format("\\u%04x", (int) c));
+          else out.append(c);
+        }
+      }
+    }
+    return out.append('"').toString();
+  }
+
+  private static String flag(List<String> argv, String name, String otherwise) {
+    int at = argv.indexOf(name);
+    return at == -1 || at + 1 >= argv.size() ? otherwise : argv.get(at + 1);
+  }
+
+  // ---- the options: a flat JSON object of names to numbers, texts, true, false or null
+
+  private static Map<String, String> parseObject(String text) {
+    Map<String, String> out = new LinkedHashMap<>();
+    int[] at = {0};
+    skip(text, at);
+    expect(text, at, '{');
+    skip(text, at);
+    if (peek(text, at) == '}') return out;
+    for (;;) {
+      skip(text, at);
+      String name = parseString(text, at);
+      skip(text, at);
+      expect(text, at, ':');
+      skip(text, at);
+      String value = parseValue(text, at);
+      if (value != null) out.put(name, value);
+      skip(text, at);
+      char next = text.charAt(at[0]++);
+      if (next == '}') return out;
+      if (next != ',') throw new IllegalArgumentException("the options are not a flat JSON object: " + text);
+    }
+  }
+
+  private static char peek(String text, int[] at) {
+    return text.charAt(at[0]);
+  }
+
+  private static void skip(String text, int[] at) {
+    while (at[0] < text.length() && Character.isWhitespace(text.charAt(at[0]))) at[0]++;
+  }
+
+  private static void expect(String text, int[] at, char c) {
+    if (text.charAt(at[0]++) != c) throw new IllegalArgumentException("the options are not a flat JSON object: " + text);
+  }
+
+  private static String parseString(String text, int[] at) {
+    expect(text, at, '"');
+    StringBuilder out = new StringBuilder();
+    for (;;) {
+      char c = text.charAt(at[0]++);
+      if (c == '"') return out.toString();
+      if (c == '\\') {
+        char e = text.charAt(at[0]++);
+        switch (e) {
+          case 'n' -> out.append('\n');
+          case 't' -> out.append('\t');
+          case 'r' -> out.append('\r');
+          case 'u' -> {
+            out.append((char) Integer.parseInt(text.substring(at[0], at[0] + 4), 16));
+            at[0] += 4;
+          }
+          default -> out.append(e);
+        }
+      } else out.append(c);
+    }
+  }
+
+  private static String parseValue(String text, int[] at) {
+    char c = peek(text, at);
+    if (c == '"') return parseString(text, at);
+    int from = at[0];
+    while (at[0] < text.length() && ",} \t\r\n".indexOf(text.charAt(at[0])) == -1) at[0]++;
+    String word = text.substring(from, at[0]);
+    if (word.equals("null")) return null;
+    // a whole number in a JSON number of the cell (30000.0) is a whole number for a setter of HikariConfig
+    if (word.endsWith(".0")) return word.substring(0, word.length() - 2);
+    return word;
+  }
+
+  // ---- the error of a query as data
+
+  private static Throwable rootOf(Throwable error) {
+    Throwable at = error;
+    while (at.getCause() != null && at.getCause() != at) at = at.getCause();
+    return at;
+  }
+
+  /** This function gives the first SQLException in the causes of an error: the start of a pool wraps the one of pgjdbc. */
+  private static SQLException sqlOf(Throwable error) {
+    for (Throwable at = error; at != null; at = at.getCause() == at ? null : at.getCause()) {
+      if (at instanceof SQLException sql) return sql;
+    }
+    return null;
+  }
+
+  private static String failure(Throwable error) {
+    SQLException sql = sqlOf(error);
+    String state = sql == null ? null : sql.getSQLState();
+    Integer code = sql == null ? null : sql.getErrorCode();
+    Throwable root = rootOf(error);
+    return "\"name\":" + q(error.getClass().getSimpleName())
+        + ",\"sqlState\":" + q(state)
+        + ",\"code\":" + (code == null ? "null" : code)
+        + ",\"message\":" + q(error.getMessage())
+        + ",\"cause\":" + (root == error ? "null" : "{\"name\":" + q(root.getClass().getSimpleName()) + ",\"message\":" + q(root.getMessage()) + "}");
+  }
+
+  /** This function gives the errno of an error: the SQLState of pgjdbc or HikariCP, or the message. */
+  private static String errnoOf(Throwable error) {
+    SQLException sql = sqlOf(error);
+    if (sql != null && sql.getSQLState() != null) return sql.getSQLState();
+    return error.getMessage();
+  }
+
+  // ---- 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) {
+    try {
+      PgConnection pg = connection.unwrap(PgConnection.class);
+      Object executor = pg.getQueryExecutor();
+      Field field = null;
+      for (Class<?> at = executor.getClass(); at != null && field == null; at = at.getSuperclass()) {
+        try {
+          field = at.getDeclaredField("pgStream");
+        } catch (NoSuchFieldException absent) {
+          // the field is on a superclass
+        }
+      }
+      if (field == null) return null;
+      field.setAccessible(true);
+      Socket socket = ((PGStream) field.get(executor)).getSocket();
+      return socket.getLocalAddress().getHostAddress() + ":" + socket.getLocalPort();
+    } catch (Exception error) {
+      return null;
+    }
+  }
+
+  private static void seen(Connection connection) {
+    String local = localOf(connection);
+    if (local == null || !SEEN.add(local)) return;
+    emit("socket", "\"role\":\"pool\",\"local\":" + q(local));
+    if (connected == null) {
+      connected = local;
+      emit("connected", "\"local\":" + q(local));
+    }
+  }
+
+  // ---- the counts of the pool, each 5 ms: a line for each change
+
+  private static void watchPool() {
+    Thread watcher = new Thread(() -> {
+      String last = "";
+      while (!stopped) {
+        HikariDataSource ds = pool;
+        if (ds != null) {
+          try {
+            HikariPoolMXBean bean = ds.getHikariPoolMXBean();
+            if (bean != null) {
+              String counts = "\"total\":" + bean.getTotalConnections()
+                  + ",\"active\":" + bean.getActiveConnections()
+                  + ",\"idle\":" + bean.getIdleConnections()
+                  + ",\"waiting\":" + bean.getThreadsAwaitingConnection();
+              if (!counts.equals(last)) {
+                emit("pool", counts);
+                last = counts;
+              }
+            }
+          } catch (RuntimeException closed) {
+            // the pool closed
+          }
+        }
+        try {
+          Thread.sleep(5);
+        } catch (InterruptedException stop) {
+          return;
+        }
+      }
+    }, "pool-watcher");
+    watcher.setDaemon(true);
+    watcher.start();
+  }
+
+  // ---- the end of the client
+
+  private static void stop(int code) {
+    synchronized (LOCK) {
+      if (stopped) return;
+      stopped = true;
+    }
+    emit("done", "");
+    HikariDataSource ds = pool;
+    if (ds != null) {
+      Thread closer = new Thread(ds::close, "pool-closer");
+      closer.setDaemon(true);
+      closer.start();
+      try {
+        closer.join(1000);
+      } catch (InterruptedException stopNow) {
+        // the exit goes on
+      }
+    }
+    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. */
+  private static Throwable operate(int n) {
+    long at = now();
+    if (n == 1) emit("connecting", at, "\"at\":" + q(host + ":" + port));
+    emit("sent", at, "\"n\":" + n);
+    try {
+      // the first query starts the pool: its check of initializationFailTimeout makes the first connection
+      if (pool == null) pool = new HikariDataSource(config);
+      long rows = 0;
+      try (Connection connection = pool.getConnection()) {
+        seen(connection);
+        try (Statement statement = connection.createStatement()) {
+          if (statement.execute(query)) {
+            try (ResultSet result = statement.getResultSet()) {
+              while (result.next()) rows += 1;
+            }
+          } else rows = statement.getUpdateCount();
+        }
+      }
+      emit("ack", "\"n\":" + n + ",\"rows\":" + rows);
+      return null;
+    } catch (Throwable error) {
+      emit("fail", "\"n\":" + n + "," + failure(error));
+      return error;
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    List<String> argv = List.of(args);
+    String mode = flag(argv, "--mode", null);
+    if (args.length < 2 || mode == null || !List.of("idle", "inflight", "stream").contains(mode)) {
+      emit("fail", "\"why\":\"client-hikari HOST PORT --mode idle|inflight|stream\"");
+      Runtime.getRuntime().halt(1);
+    }
+    host = args[0];
+    port = args[1];
+    long interval = Long.parseLong(flag(argv, "--interval-ms", "50"));
+    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");
+    boolean before = argv.contains("--before");
+    Map<String, String> options = parseObject(flag(argv, "--options", "{}"));
+
+    String bootId;
+    try {
+      bootId = Files.readString(Path.of("/proc/sys/kernel/random/boot_id")).trim();
+    } catch (Exception absent) {
+      bootId = null;
+    }
+    StringBuilder given = new StringBuilder("{");
+    for (Map.Entry<String, String> each : options.entrySet()) {
+      if (given.length() > 1) given.append(',');
+      given.append(q(each.getKey())).append(':').append(q(each.getValue()));
+    }
+    given.append('}');
+    String hikari = HikariDataSource.class.getPackage().getImplementationVersion();
+    emit("start", "\"boot_id\":" + q(bootId)
+        + ",\"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);
+
+    Properties properties = new Properties();
+    for (Map.Entry<String, String> each : options.entrySet()) properties.setProperty(each.getKey(), each.getValue());
+    config = new HikariConfig(properties);
+    config.setJdbcUrl("jdbc:postgresql://" + host + ":" + port + "/postgres");
+    config.setUsername("postgres");
+    config.setPoolName("cell");
+
+    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+      // SIGTERM: the end of the client, with exit code 0, as the pg client gives
+      synchronized (LOCK) {
+        if (stopped) return;
+        stopped = true;
+      }
+      emit("done", "");
+      Runtime.getRuntime().halt(0);
+    }, "sigterm"));
+    Thread deadline = new Thread(() -> {
+      try {
+        Thread.sleep(max);
+      } catch (InterruptedException stop) {
+        return;
+      }
+      emit("deadline", "");
+      stop(0);
+    }, "deadline");
+    deadline.setDaemon(true);
+    deadline.start();
+    watchPool();
+
+    if (mode.equals("stream")) {
+      emit("ready", "\"at\":" + q(host + ":" + port));
+      for (int n = 1; !stopped; n += 1) {
+        operate(n);
+        Thread.sleep(interval);
+      }
+      return;
+    }
+    // the first query makes the connection of the pool. Its reply is the last data before the fault
+    Throwable failed = operate(1);
+    if (failed != null) {
+      emit("error", "\"errno\":" + q(errnoOf(failed)) + ",\"message\":" + q(failed.getMessage()));
+      stop(before ? 0 : 1);
+      return;
+    }
+    // the connection went back to the pool at the end of the query: it is idle there
+    emit("ready", "\"reply\":\"ack\"");
+    if (mode.equals("inflight")) {
+      while (!Files.exists(go)) Thread.sleep(2);
+      Throwable error = operate(2);
+      if (error == null) emit("data", "\"n\":2");
+      else emit("error", "\"errno\":" + q(errnoOf(error)) + ",\"message\":" + q(error.getMessage()));
+    }
+    Thread.sleep(Long.MAX_VALUE);
+  }
+}

package/image/hikari/Dockerfile

@@ -0,0 +1,19 @@
+# The harness's client of HikariCP 7.1.0 over pgjdbc 42.7.13, on Temurin 21.0.12.1. It runs as a
+# container in the client's network namespace, as the harness's own TCP client does. It prints the
+# same JSON lines, with the state of the pool beside them.
+# lab.ts stages the build context: this folder, under harness/image/hikari. The build gets each jar
+# from Maven Central and checks its SHA-256 (jars.sha256), thus a build cannot get another jar.
+FROM eclipse-temurin:21.0.12.1_1-jdk-alpine@sha256:0bfc69a4758a86710e5c474032d28400a8bd00874766f9e8b1642ac2fd293159 AS build
+WORKDIR /build
+COPY harness/image/hikari/jars.sha256 ./
+RUN wget -q https://repo1.maven.org/maven2/com/zaxxer/HikariCP/7.1.0/HikariCP-7.1.0.jar \
+ && wget -q https://repo1.maven.org/maven2/org/postgresql/postgresql/42.7.13/postgresql-42.7.13.jar \
+ && wget -q https://repo1.maven.org/maven2/org/slf4j/slf4j-api/2.0.17/slf4j-api-2.0.17.jar \
+ && sha256sum -c jars.sha256
+COPY harness/image/hikari/ClientHikari.java ./
+RUN javac --release 21 -cp "HikariCP-7.1.0.jar:postgresql-42.7.13.jar:slf4j-api-2.0.17.jar" -d classes ClientHikari.java
+
+FROM eclipse-temurin:21.0.12.1_1-jre-alpine@sha256:51ab5e3302e7141ce665ca3ea85e8b5cd648eafbc3c0c90dd79d6537684e4555
+WORKDIR /opt/harness/hikari
+COPY --from=build /build/HikariCP-7.1.0.jar /build/postgresql-42.7.13.jar /build/slf4j-api-2.0.17.jar ./lib/
+COPY --from=build /build/classes ./classes

package/image/hikari/jars.sha256

@@ -0,0 +1,3 @@
+2be45c641b841e81df87292e181f2c203500c5f0e9a1676f135927387f3cf40b  HikariCP-7.1.0.jar
+6e0e4cc2d8cae902084f8a2b18728b073a6fd9d1f87c9d8bff8f298c18185b93  postgresql-42.7.13.jar
+7b751d952061954d5abfed7181c1f645d336091b679891591d63329c622eb832  slf4j-api-2.0.17.jar

package/image/pg/client-pg.mjs

@@ -8,6 +8,8 @@
 //
 // The lines:
 // - start: the versions of pg, pg-pool and Node, the mode and the options of the pool.
+// - connecting: the first query, which makes the first connection of the pool. Its stamp is the
+//   stamp of the first sent line. The pool arms its connect timer in that call.
 // - 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.
@@ -118,6 +120,8 @@ setTimeout(() => {
 const operate = async (n) => {
   const at = now();
   const reply = pool.query(query);
+  // 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);
   try {
     const result = await reply;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/harness",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "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",
@@ -33,6 +33,10 @@
       "types": "./build/index.d.ts",
       "default": "./build/index.js"
     },
+    "./schema": {
+      "types": "./build/schema.d.ts",
+      "default": "./build/schema.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -65,6 +69,9 @@
     "image/pg/client-pg.mjs",
     "image/pg/package.json",
     "image/pg/npm-lock.json",
+    "image/hikari/Dockerfile",
+    "image/hikari/ClientHikari.java",
+    "image/hikari/jars.sha256",
     "image/procedures/Dockerfile",
     "image/procedures/package.json",
     "image/procedures/npm-lock.json",