@mark1russell7/kind 0.10.1 → 0.11.1

package/build/{judge-BD4UVQfy.d.ts → judge-C3mbgYxY.d.ts}

@@ -132,9 +132,12 @@ type Stack = "service" | "grpc";
  * - `ztunnel-restart` deletes the ztunnel pod of each node with its grace. The DaemonSet makes a new pod on each node (T15).
  * - `certificate-expiry` keeps the calls of each client going for the hold. No act of the lab touches a
  *   connection. The lab reads the workload certificates of ztunnel at the fault and at the heal (T15).
+ * - `cannot-serve` makes the route of one replica fail while a flag file is there, for the hold. The
+ *   flag also fails the readiness check of the replica (`flag` of the declaration). Before the
+ *   fault, each client opens its connections again with SIGHUP, thus they spread over the replicas.
  * - `none` injects nothing: a calibration measures the path itself.
  */
-type TriggerKind = "pod-deletion" | "rolling-update" | "node-drain" | "scale-in" | "crash" | "liveness-restart" | "freeze-process" | "rst" | "blackhole" | "peer-gone-without-close" | "app-stall" | "rollout" | "cpu-throttle" | "authorization-policy" | "idle" | "ztunnel-restart" | "certificate-expiry";
+type TriggerKind = "pod-deletion" | "rolling-update" | "node-drain" | "scale-in" | "crash" | "liveness-restart" | "freeze-process" | "rst" | "blackhole" | "peer-gone-without-close" | "app-stall" | "rollout" | "cpu-throttle" | "authorization-policy" | "idle" | "ztunnel-restart" | "certificate-expiry" | "cannot-serve";
 /**
  * A trigger is its kind and the settings of its fault. The parameter `A` is the form of an amount:
  * a quantity in the format `/2`, a number in the format `/1`.
@@ -227,10 +230,27 @@ interface Declaration {
     readonly tick: Quantity;
     readonly threshold: Quantity;
   } | null;
+  /**
+   * This flag is the lame-duck state of the HTTP edge. With true or no value, the edge closes each
+   * connection in band while the service is not ready, thus each caller opens a new connection. On
+   * HTTP/1.1 the signal is `Connection: close`, and on HTTP/2 it is GOAWAY. With false, the edge keeps
+   * each connection open, thus a caller learns only from the endpoints.
+   */
+  readonly lameDuck?: boolean | undefined;
+  /**
+   * This text is the protocol of the HTTP edge and of its clients. `h2c` is HTTP/2 without TLS: the
+   * app listens with `node:http2`, and each client sends its requests as streams on its sessions.
+   * With `http/1.1` or no value, the edge is `node:http`.
+   */
+  readonly protocol?: EdgeProtocol | undefined;
 }
+/** An edge protocol is the protocol of the HTTP edge of the service: HTTP/1.1, or HTTP/2 without TLS (`h2c`). */
+type EdgeProtocol = "http/1.1" | "h2c";
 /**
  * A workload is the clients: one pod on each node, each with requests to the ClusterIP. The HTTP client
- * opens a new connection for each request. The gRPC client sends each call on its one channel.
+ * opens a new connection for each request, or it keeps `connections` open. On HTTP/2 (`protocol` of
+ * the declaration), each connection is a session, and each request is a stream on it. The gRPC client
+ * sends each call on its one channel.
  */
 interface Workload {
   /** This time is the interval between two requests of one client. The clients do not wait for an answer. */
@@ -240,6 +260,12 @@ interface Workload {
    * gRPC has no deadline at the defaults of grpc-js, thus the client cancels it at this time.
    */
   readonly timeout: Quantity;
+  /**
+   * This count is the keep-alive connections of each HTTP client. Each request goes on the next
+   * connection in turn. With no value, the client opens a new connection for each request. A client
+   * of HTTP/2 keeps this count of sessions, and it needs the count.
+   */
+  readonly connections?: number | undefined;
 }
 /**
  * A band is a range of times after a reference event of the run. The format `/1` gives each end
@@ -1015,5 +1041,5 @@ declare const quantileOf: (sorted: readonly number[], p: number) => number;
  */
 declare const medianInterval: (sorted: readonly number[]) => [number, number];
 //#endregion
-export { updatesOf as $, Declaration as $t, TriggerV1 as A, scenario as An, rulesOf as At, RunCheck as B, ztunnelPodsOf as Bt, KindCellResult as C, NodeImage as Cn, outcomesOf as Ct, PredictionV1 as D, kindConfig as Dn, requestsOf as Dt, LoadSample as E, goDuration as En, recordsOf as Et, KIND_NOISE as F, slicesOf as Ft, judgeKind as G, PORT as Gt, checkRun as H, CLIENT as Ht, KindDecision as I, socketsOf as It, propagationOf as J, bandOf as Jt, observationAfter as K, REDIS as Kt, KindVerdict as L, stoppingOf as Lt, upgrade as M, signalsOf as Mt, upgradeCell as N, sliceDropOf as Nt, RunCheckV1 as O, kubeProxyPatch as On, restartOf as Ot, Deleted as P, sliceEmptyOf as Pt, unitOf as Q, Band as Qt, LAST_SLACK as R, transitionOf as Rt, KindCellRecordV1 as S, NODE_IMAGES as Sn, kernelCounts as St, KindVerdictV1 as T, cidrRange as Tn, podsOf as Tt, deletionsOf as U, HEALTH_PORT as Ut, RunFacts as V, ztunnelReplaced as Vt, factsOf as W, LOG_LABEL as Wt, referenceOf as X, secondsOf as Xt, propagationSource as Y, seconds as Yt, reusesReset as Z, showBand as Zt, ClusterManifest as _, Workload as _n, dropOf as _t, STAGES as a, MeshMode as an, RecordLine as at, FORMAT_V1 as b, KindScenario as bn, intakeOf as bt, readRecord as c, RedisDeclaration as cn, SliceLine as ct, calibrationOf as d, ResetReuse as dn, TunnelLine as dt, KindCell as en, Endpoint as et, cellsTable as f, Stack as fn, ZtunnelPodLine as ft, BandV1 as g, WindowPrediction as gn, deletionOf as gt, timeSpread as h, TriggerKind as hn, byNode as ht, quantileOf as i, MeshFlavor as in, PropagationSource as it, judge as j, scenarioProblems as jn, signalOf as jt, RunFactsV1 as k, nodeNames as kn, restartsAt as kt, Judged as l, Reference as ln, SocketLine as lt, predictionText as m, Trigger as mn, byClients as mt, medianInterval as n, KubeletProbe as nn, Line as nt, kindCellRecordSchema as o, PodSettings as on, Request as ot, medianText as p, Template as pn, backendsAt as pt, observationEnd as q, SERVER as qt, middle as r, Mesh as rn, PodLine as rt, kindCellRecordV1Schema as s, Prediction as sn, RulesLine as st, RELATIVE as t, KindRun as tn, HBONE_PORT as tt, TimeSpread as u, Replica as un, TCP_STATE as ut, EnvironmentManifest as v, KUBE_PROXY_MODES as vn, emptyOf as vt, KindCellV1 as w, cidrOverlap as wn, podsAt as wt, KindCellRecord as x, KubeProxyMode as xn, isTunnelState as xt, FORMAT as y, KindConfig as yn, failuresOf as yt, Propagated as z, tunnelsOf as zt };
-//# sourceMappingURL=judge-BD4UVQfy.d.ts.map
+export { updatesOf as $, Declaration as $t, TriggerV1 as A, nodeNames as An, rulesOf as At, RunCheck as B, ztunnelPodsOf as Bt, KindCellResult as C, NODE_IMAGES as Cn, outcomesOf as Ct, PredictionV1 as D, goDuration as Dn, requestsOf as Dt, LoadSample as E, cidrRange as En, recordsOf as Et, KIND_NOISE as F, slicesOf as Ft, judgeKind as G, PORT as Gt, checkRun as H, CLIENT as Ht, KindDecision as I, socketsOf as It, propagationOf as J, bandOf as Jt, observationAfter as K, REDIS as Kt, KindVerdict as L, stoppingOf as Lt, upgrade as M, scenarioProblems as Mn, signalsOf as Mt, upgradeCell as N, sliceDropOf as Nt, RunCheckV1 as O, kindConfig as On, restartOf as Ot, Deleted as P, sliceEmptyOf as Pt, unitOf as Q, Band as Qt, LAST_SLACK as R, transitionOf as Rt, KindCellRecordV1 as S, KubeProxyMode as Sn, kernelCounts as St, KindVerdictV1 as T, cidrOverlap as Tn, podsOf as Tt, deletionsOf as U, HEALTH_PORT as Ut, RunFacts as V, ztunnelReplaced as Vt, factsOf as W, LOG_LABEL as Wt, referenceOf as X, secondsOf as Xt, propagationSource as Y, seconds as Yt, reusesReset as Z, showBand as Zt, ClusterManifest as _, WindowPrediction as _n, dropOf as _t, STAGES as a, MeshFlavor as an, RecordLine as at, FORMAT_V1 as b, KindConfig as bn, intakeOf as bt, readRecord as c, Prediction as cn, SliceLine as ct, calibrationOf as d, Replica as dn, TunnelLine as dt, EdgeProtocol as en, Endpoint as et, cellsTable as f, ResetReuse as fn, ZtunnelPodLine as ft, BandV1 as g, TriggerKind as gn, deletionOf as gt, timeSpread as h, Trigger as hn, byNode as ht, quantileOf as i, Mesh as in, PropagationSource as it, judge as j, scenario as jn, signalOf as jt, RunFactsV1 as k, kubeProxyPatch as kn, restartsAt as kt, Judged as l, RedisDeclaration as ln, SocketLine as lt, predictionText as m, Template as mn, byClients as mt, medianInterval as n, KindRun as nn, Line as nt, kindCellRecordSchema as o, MeshMode as on, Request as ot, medianText as p, Stack as pn, backendsAt as pt, observationEnd as q, SERVER as qt, middle as r, KubeletProbe as rn, PodLine as rt, kindCellRecordV1Schema as s, PodSettings as sn, RulesLine as st, RELATIVE as t, KindCell as tn, HBONE_PORT as tt, TimeSpread as u, Reference as un, TCP_STATE as ut, EnvironmentManifest as v, Workload as vn, emptyOf as vt, KindCellV1 as w, NodeImage as wn, podsAt as wt, KindCellRecord as x, KindScenario as xn, isTunnelState as xt, FORMAT as y, KUBE_PROXY_MODES as yn, failuresOf as yt, Propagated as z, tunnelsOf as zt };
+//# sourceMappingURL=judge-C3mbgYxY.d.ts.map

package/build/judge.d.ts

@@ -1,2 +1,2 @@
-import { $ as updatesOf, $t as Declaration, A as TriggerV1, At as rulesOf, B as RunCheck, Bt as ztunnelPodsOf, C as KindCellResult, Ct as outcomesOf, D as PredictionV1, Dt as requestsOf, E as LoadSample, Et as recordsOf, F as KIND_NOISE, Ft as slicesOf, G as judgeKind, Gt as PORT, H as checkRun, Ht as CLIENT, I as KindDecision, It as socketsOf, J as propagationOf, Jt as bandOf, K as observationAfter, Kt as REDIS, L as KindVerdict, Lt as stoppingOf, M as upgrade, Mt as signalsOf, N as upgradeCell, Nt as sliceDropOf, O as RunCheckV1, Ot as restartOf, P as Deleted, Pt as sliceEmptyOf, Q as unitOf, Qt as Band, R as LAST_SLACK, Rt as transitionOf, S as KindCellRecordV1, St as kernelCounts, T as KindVerdictV1, Tt as podsOf, U as deletionsOf, Ut as HEALTH_PORT, V as RunFacts, Vt as ztunnelReplaced, W as factsOf, Wt as LOG_LABEL, X as referenceOf, Xt as secondsOf, Y as propagationSource, Yt as seconds, Z as reusesReset, Zt as showBand, _ as ClusterManifest, _n as Workload, _t as dropOf, a as STAGES, an as MeshMode, at as RecordLine, b as FORMAT_V1, bt as intakeOf, c as readRecord, cn as RedisDeclaration, ct as SliceLine, d as calibrationOf, dn as ResetReuse, dt as TunnelLine, en as KindCell, et as Endpoint, f as cellsTable, fn as Stack, ft as ZtunnelPodLine, g as BandV1, gn as WindowPrediction, gt as deletionOf, h as timeSpread, hn as TriggerKind, ht as byNode, i as quantileOf, in as MeshFlavor, it as PropagationSource, j as judge, jt as signalOf, k as RunFactsV1, kt as restartsAt, l as Judged, ln as Reference, lt as SocketLine, m as predictionText, mn as Trigger, mt as byClients, n as medianInterval, nn as KubeletProbe, nt as Line, o as kindCellRecordSchema, on as PodSettings, ot as Request, p as medianText, pn as Template, pt as backendsAt, q as observationEnd, qt as SERVER, r as middle, rn as Mesh, rt as PodLine, s as kindCellRecordV1Schema, sn as Prediction, st as RulesLine, t as RELATIVE, tn as KindRun, tt as HBONE_PORT, u as TimeSpread, un as Replica, ut as TCP_STATE, v as EnvironmentManifest, vt as emptyOf, w as KindCellV1, wt as podsAt, x as KindCellRecord, xn as KubeProxyMode, xt as isTunnelState, y as FORMAT, yt as failuresOf, z as Propagated, zt as tunnelsOf } from "./judge-BD4UVQfy.js";
-export { type Band, type BandV1, CLIENT, type ClusterManifest, type Declaration, type Deleted, Endpoint, type EnvironmentManifest, FORMAT, FORMAT_V1, HBONE_PORT, HEALTH_PORT, type Judged, KIND_NOISE, type KindCell, type KindCellRecord, type KindCellRecordV1, type KindCellResult, type KindCellV1, type KindDecision, type KindRun, type KindVerdict, type KindVerdictV1, type KubeProxyMode, type KubeletProbe, LAST_SLACK, LOG_LABEL, Line, type LoadSample, type Mesh, type MeshFlavor, type MeshMode, PORT, PodLine, type PodSettings, type Prediction, type PredictionV1, type Propagated, PropagationSource, REDIS, RELATIVE, RecordLine, type RedisDeclaration, type Reference, type Replica, Request, type ResetReuse, RulesLine, type RunCheck, type RunCheckV1, type RunFacts, type RunFactsV1, SERVER, STAGES, SliceLine, SocketLine, type Stack, TCP_STATE, type Template, type TimeSpread, type Trigger, type TriggerKind, type TriggerV1, TunnelLine, type WindowPrediction, type Workload, ZtunnelPodLine, backendsAt, bandOf, byClients, byNode, calibrationOf, cellsTable, checkRun, deletionOf, deletionsOf, dropOf, emptyOf, factsOf, failuresOf, intakeOf, isTunnelState, judge, judgeKind, kernelCounts, kindCellRecordSchema, kindCellRecordV1Schema, medianInterval, medianText, middle, observationAfter, observationEnd, outcomesOf, podsAt, podsOf, predictionText, propagationOf, propagationSource, quantileOf, readRecord, recordsOf, referenceOf, requestsOf, restartOf, restartsAt, reusesReset, rulesOf, seconds, secondsOf, showBand, signalOf, signalsOf, sliceDropOf, sliceEmptyOf, slicesOf, socketsOf, stoppingOf, timeSpread, transitionOf, tunnelsOf, unitOf, updatesOf, upgrade, upgradeCell, ztunnelPodsOf, ztunnelReplaced };
+import { $ as updatesOf, $t as Declaration, A as TriggerV1, At as rulesOf, B as RunCheck, Bt as ztunnelPodsOf, C as KindCellResult, Ct as outcomesOf, D as PredictionV1, Dt as requestsOf, E as LoadSample, Et as recordsOf, F as KIND_NOISE, Ft as slicesOf, G as judgeKind, Gt as PORT, H as checkRun, Ht as CLIENT, I as KindDecision, It as socketsOf, J as propagationOf, Jt as bandOf, K as observationAfter, Kt as REDIS, L as KindVerdict, Lt as stoppingOf, M as upgrade, Mt as signalsOf, N as upgradeCell, Nt as sliceDropOf, O as RunCheckV1, Ot as restartOf, P as Deleted, Pt as sliceEmptyOf, Q as unitOf, Qt as Band, R as LAST_SLACK, Rt as transitionOf, S as KindCellRecordV1, Sn as KubeProxyMode, St as kernelCounts, T as KindVerdictV1, Tt as podsOf, U as deletionsOf, Ut as HEALTH_PORT, V as RunFacts, Vt as ztunnelReplaced, W as factsOf, Wt as LOG_LABEL, X as referenceOf, Xt as secondsOf, Y as propagationSource, Yt as seconds, Z as reusesReset, Zt as showBand, _ as ClusterManifest, _n as WindowPrediction, _t as dropOf, a as STAGES, an as MeshFlavor, at as RecordLine, b as FORMAT_V1, bt as intakeOf, c as readRecord, cn as Prediction, ct as SliceLine, d as calibrationOf, dn as Replica, dt as TunnelLine, en as EdgeProtocol, et as Endpoint, f as cellsTable, fn as ResetReuse, ft as ZtunnelPodLine, g as BandV1, gn as TriggerKind, gt as deletionOf, h as timeSpread, hn as Trigger, ht as byNode, i as quantileOf, in as Mesh, it as PropagationSource, j as judge, jt as signalOf, k as RunFactsV1, kt as restartsAt, l as Judged, ln as RedisDeclaration, lt as SocketLine, m as predictionText, mn as Template, mt as byClients, n as medianInterval, nn as KindRun, nt as Line, o as kindCellRecordSchema, on as MeshMode, ot as Request, p as medianText, pn as Stack, pt as backendsAt, q as observationEnd, qt as SERVER, r as middle, rn as KubeletProbe, rt as PodLine, s as kindCellRecordV1Schema, sn as PodSettings, st as RulesLine, t as RELATIVE, tn as KindCell, tt as HBONE_PORT, u as TimeSpread, un as Reference, ut as TCP_STATE, v as EnvironmentManifest, vn as Workload, vt as emptyOf, w as KindCellV1, wt as podsAt, x as KindCellRecord, xt as isTunnelState, y as FORMAT, yt as failuresOf, z as Propagated, zt as tunnelsOf } from "./judge-C3mbgYxY.js";
+export { type Band, type BandV1, CLIENT, type ClusterManifest, type Declaration, type Deleted, type EdgeProtocol, Endpoint, type EnvironmentManifest, FORMAT, FORMAT_V1, HBONE_PORT, HEALTH_PORT, type Judged, KIND_NOISE, type KindCell, type KindCellRecord, type KindCellRecordV1, type KindCellResult, type KindCellV1, type KindDecision, type KindRun, type KindVerdict, type KindVerdictV1, type KubeProxyMode, type KubeletProbe, LAST_SLACK, LOG_LABEL, Line, type LoadSample, type Mesh, type MeshFlavor, type MeshMode, PORT, PodLine, type PodSettings, type Prediction, type PredictionV1, type Propagated, PropagationSource, REDIS, RELATIVE, RecordLine, type RedisDeclaration, type Reference, type Replica, Request, type ResetReuse, RulesLine, type RunCheck, type RunCheckV1, type RunFacts, type RunFactsV1, SERVER, STAGES, SliceLine, SocketLine, type Stack, TCP_STATE, type Template, type TimeSpread, type Trigger, type TriggerKind, type TriggerV1, TunnelLine, type WindowPrediction, type Workload, ZtunnelPodLine, backendsAt, bandOf, byClients, byNode, calibrationOf, cellsTable, checkRun, deletionOf, deletionsOf, dropOf, emptyOf, factsOf, failuresOf, intakeOf, isTunnelState, judge, judgeKind, kernelCounts, kindCellRecordSchema, kindCellRecordV1Schema, medianInterval, medianText, middle, observationAfter, observationEnd, outcomesOf, podsAt, podsOf, predictionText, propagationOf, propagationSource, quantileOf, readRecord, recordsOf, referenceOf, requestsOf, restartOf, restartsAt, reusesReset, rulesOf, seconds, secondsOf, showBand, signalOf, signalsOf, sliceDropOf, sliceEmptyOf, slicesOf, socketsOf, stoppingOf, timeSpread, transitionOf, tunnelsOf, unitOf, updatesOf, upgrade, upgradeCell, ztunnelPodsOf, ztunnelReplaced };

package/build/judge.js

@@ -1 +1 @@
-export { ut as CLIENT, u as FORMAT, d as FORMAT_V1, N as HBONE_PORT, dt as HEALTH_PORT, h as KIND_NOISE, g as LAST_SLACK, ft as LOG_LABEL, pt as PORT, mt as REDIS, k as RELATIVE, ht as SERVER, t as STAGES, P as TCP_STATE, F as backendsAt, gt as bandOf, I as byClients, L as byNode, a as calibrationOf, o as cellsTable, _ as checkRun, R as deletionOf, v as deletionsOf, z as dropOf, B as emptyOf, y as factsOf, V as failuresOf, H as intakeOf, U as isTunnelState, f as judge, b as judgeKind, W as kernelCounts, n as kindCellRecordSchema, r as kindCellRecordV1Schema, A as medianInterval, s as medianText, j as middle, x as observationAfter, S as observationEnd, G as outcomesOf, K as podsAt, q as podsOf, c as predictionText, C as propagationOf, w as propagationSource, M as quantileOf, i as readRecord, J as recordsOf, T as referenceOf, Y as requestsOf, X as restartOf, Z as restartsAt, E as reusesReset, Q as rulesOf, _t as seconds, vt as secondsOf, yt as showBand, $ as signalOf, et as signalsOf, tt as sliceDropOf, nt as sliceEmptyOf, rt as slicesOf, it as socketsOf, at as stoppingOf, l as timeSpread, ot as transitionOf, st as tunnelsOf, D as unitOf, O as updatesOf, p as upgrade, m as upgradeCell, ct as ztunnelPodsOf, lt as ztunnelReplaced } from "./judge-BbLWVTYj.js";
+export { ut as CLIENT, u as FORMAT, d as FORMAT_V1, N as HBONE_PORT, dt as HEALTH_PORT, h as KIND_NOISE, g as LAST_SLACK, ft as LOG_LABEL, pt as PORT, mt as REDIS, k as RELATIVE, ht as SERVER, t as STAGES, P as TCP_STATE, F as backendsAt, gt as bandOf, I as byClients, L as byNode, a as calibrationOf, o as cellsTable, _ as checkRun, R as deletionOf, v as deletionsOf, z as dropOf, B as emptyOf, y as factsOf, V as failuresOf, H as intakeOf, U as isTunnelState, f as judge, b as judgeKind, W as kernelCounts, n as kindCellRecordSchema, r as kindCellRecordV1Schema, A as medianInterval, s as medianText, j as middle, x as observationAfter, S as observationEnd, G as outcomesOf, K as podsAt, q as podsOf, c as predictionText, C as propagationOf, w as propagationSource, M as quantileOf, i as readRecord, J as recordsOf, T as referenceOf, Y as requestsOf, X as restartOf, Z as restartsAt, E as reusesReset, Q as rulesOf, _t as seconds, vt as secondsOf, yt as showBand, $ as signalOf, et as signalsOf, tt as sliceDropOf, nt as sliceEmptyOf, rt as slicesOf, it as socketsOf, at as stoppingOf, l as timeSpread, ot as transitionOf, st as tunnelsOf, D as unitOf, O as updatesOf, p as upgrade, m as upgradeCell, ct as ztunnelPodsOf, lt as ztunnelReplaced } from "./judge-Bb4ebE9V.js";

package/image/app.mjs

@@ -6,6 +6,7 @@
 // service: the lab has no transport of its own.
 import { existsSync, readFileSync } from "node:fs";
 import http from "node:http";
+import http2 from "node:http2";
 import { handle, httpTransport, pathOf, probeServer } from "@mark1russell7/service/http";
 import { redisClient } from "@mark1russell7/service/redis";
 import { CONTROLLER, ROUTE, compose } from "./compose.ts";
@@ -53,7 +54,8 @@ const redis =
         { clock, record },
       );
 
-// the flag file fails the check of the liveness restart: the agent writes it in the root of the container
+// the flag file fails the check of the liveness restart: the agent writes it in the root of the container.
+// With failsRoute of the config (cannot-serve), the flag also fails the route
 const FLAG = process.env.LAB_FLAG ?? "/tmp/lab-fail";
 const flag = () => (existsSync(FLAG) ? "error" : "ok");
 
@@ -65,10 +67,14 @@ const KNOBS = { server_idle_close: s(6), server_idle_sweep_interval: s(1), serve
 
 // the server transport: the transport gets the lifecycle at its start, thus a request before the end
 // of the startup gets the refusal of the service (503, retryable), and Connection: close while the
-// service is not ready
-const server = http.createServer();
+// service is not ready. With the protocol h2c of the declaration, the edge is a server of HTTP/2
+// without TLS, and the close of a connection is a GOAWAY on its session (the candidate C of S2)
+const server = declaration.protocol === "h2c" ? http2.createServer() : http.createServer();
 server.on("listening", () => say({ ev: "app", what: "listening", port: config.port }));
-const transport = httpTransport(server, KNOBS, { listen: { port: config.port }, clock });
+// lameDuck false of the declaration keeps each connection open while the service is not ready: then a
+// caller learns only from the endpoints (the candidate A of S2). The default is the lame duck
+const edge = declaration.lameDuck === false ? { keepAlive: () => true } : {};
+const transport = httpTransport(server, KNOBS, { listen: { port: config.port }, clock, ...edge });
 // each request of the port is the one route. A failure of the route answers 503, as the lab always
 // did: the T07 and T18 cells count the 503s, and T18 predicts them while Redis is down. Each 503 gets
 // Retry-After from the rule of the transport
@@ -77,6 +83,7 @@ transport.mount(
     CONTROLLER,
     () => ROUTE,
     async (_req, signal) => {
+      if (config.failsRoute === true && existsSync(FLAG)) throw new Error("the replica cannot serve");
       if (redis !== undefined) {
         const sent = await redis.send("GET", ["lab"], { signal });
         if (sent.outcome !== "ok") throw new Error(`redis ${sent.outcome}: ${sent.error}`);

package/image/client.mjs

@@ -1,8 +1,13 @@
 // A client of a kind cell: an open loop of requests to the ClusterIP of the service, each on a new
-// connection, thus kube-proxy picks a backend for each one. Each request is one JSON line with its
-// start on CLOCK_MONOTONIC, its duration, its outcome (ok, 503, refused, reset, timeout,
-// unreachable, or another error) and its local port (`lp`).
+// connection, thus kube-proxy picks a backend for each one. With CONNECTIONS, the client keeps that
+// count of keep-alive connections, and each request goes on the next one in turn. kube-proxy picks a
+// backend only for a new connection. SIGHUP opens new connections. Each request is one JSON line with
+// its start on CLOCK_MONOTONIC, its duration, its outcome (ok, 503, refused, reset, timeout,
+// unreachable, or another error) and its local port (`lp`). With PROTOCOL h2c, each connection is a
+// session of HTTP/2, and each request is a stream on the next session in turn.
 import http from "node:http";
+import http2 from "node:http2";
+import net from "node:net";
 
 const [host, port] = (process.env.TARGET ?? "").split(":");
 const every = Number(process.env.EVERY_MS ?? 20);
@@ -10,6 +15,50 @@ const timeout = Number(process.env.TIMEOUT_MS ?? 1000);
 const pod = process.env.POD_NAME ?? "client";
 const node = process.env.NODE_NAME ?? "";
 const now = () => Number(process.hrtime.bigint()) / 1e6;
+const h2 = process.env.PROTOCOL === "h2c";
+// a client of HTTP/2 needs at least one session
+const connections = process.env.CONNECTIONS === undefined ? (h2 ? 1 : 0) : Number(process.env.CONNECTIONS);
+
+// each agent holds one keep-alive connection. A `Connection: close` of the server ends it after its
+// answer, and the next request on the agent opens a new connection
+const agentsOf = () => Array.from({ length: connections }, () => new http.Agent({ keepAlive: true, maxSockets: 1 }));
+let agents = h2 ? [] : agentsOf();
+let turn = 0;
+
+// each slot of HTTP/2 holds one session on its own socket, thus the client knows its local port. A
+// GOAWAY, a close or an error of the session makes the slot open a new session at its next stream.
+// kube-proxy picks a backend for that new connection. The old session ends the streams that it has
+const sessionOf = () => {
+  const socket = net.connect({ host, port: Number(port) });
+  const session = http2.connect(`http://${host}:${port}`, { createConnection: () => socket });
+  const held = { session, socket, usable: true };
+  const drop = () => {
+    held.usable = false;
+  };
+  session.on("goaway", drop);
+  session.on("close", drop);
+  session.on("error", drop);
+  return held;
+};
+let slots = h2 ? Array.from({ length: connections }, sessionOf) : [];
+const slotAt = (at) => {
+  if (!slots[at].usable) slots[at] = sessionOf();
+  return slots[at];
+};
+
+// SIGHUP: new agents or sessions for the next requests. The old ones go after the timeout, thus each
+// request on them ends first
+process.on("SIGHUP", () => {
+  const old = agents;
+  const oldSlots = slots;
+  if (h2) slots = Array.from({ length: connections }, sessionOf);
+  else agents = agentsOf();
+  say({ ev: "client", what: "reconnect", t: now() });
+  setTimeout(() => {
+    for (const agent of old) agent.destroy();
+    for (const held of oldSlots) held.session.destroy();
+  }, timeout + 100);
+});
 
 let pending = [];
 const flush = () => {
@@ -37,6 +86,8 @@ const portOf = (socket) => {
   return typeof out.port === "number" ? out.port : null;
 };
 
+const outcomeOfStatus = (status) => (status === 200 ? "ok" : status === 503 ? "503" : `status-${status}`);
+
 const fire = () => {
   const t = now();
   let done = false;
@@ -51,13 +102,17 @@ const fire = () => {
     lp ??= portOf(socket);
     say({ ev: "req", t, d: Math.round((now() - t) * 1000) / 1000, o, ...extra, lp });
   };
-  const req = http.request({ host, port: Number(port), path: "/work", agent: false, headers: { connection: "close" } }, (res) => {
+  const options =
+    connections === 0
+      ? { agent: false, headers: { connection: "close" } }
+      : { agent: agents[turn++ % connections] };
+  const req = http.request({ host, port: Number(port), path: "/work", ...options }, (res) => {
     let body = "";
     res.setEncoding("utf8");
     res.on("data", (chunk) => {
       body += chunk;
     });
-    res.on("end", () => finish(res.statusCode === 200 ? "ok" : res.statusCode === 503 ? "503" : `status-${res.statusCode}`, { b: body.slice(0, 64) }));
+    res.on("end", () => finish(outcomeOfStatus(res.statusCode), { b: body.slice(0, 64) }));
     res.on("error", (error) => finish(outcomeOf(error), { e: error.code ?? String(error) }));
   });
   const timer = setTimeout(() => {
@@ -73,12 +128,95 @@ const fire = () => {
     // connect() comes in the tick before this event, thus the handle has the port here, a refused
     // connection's too: in 200 refusals, each port was here and none at setImmediate
     lp = portOf(opened);
-    opened.once("connect", () => {
-      lp ??= portOf(opened);
-    });
+    // a kept connection is already connected: a listener on it does not fire, and stays
+    if (opened.connecting)
+      opened.once("connect", () => {
+        lp ??= portOf(opened);
+      });
   });
   req.end();
 };
 
-say({ ev: "client", what: "start", t: now(), target: `${host}:${port}`, every, timeout });
-setInterval(fire, every);
+// a stream that the server did not take: REFUSED_STREAM, a stream above the last one of a GOAWAY, or
+// a stream on a session that closed before it went. RFC 9113 (section 8.7) lets the client send it
+// again, and the client does that once, on a new session
+const REFUSED = http2.constants.NGHTTP2_REFUSED_STREAM;
+const untaken = (error, stream) =>
+  stream?.rstCode === REFUSED ||
+  /REFUSED_STREAM/.test(String(error?.message ?? "")) ||
+  error?.code === "ERR_HTTP2_GOAWAY_SESSION" ||
+  error?.code === "ERR_HTTP2_INVALID_SESSION";
+
+// one request of HTTP/2: a stream on the next session in turn. Each stream writes the same line as a
+// request of HTTP/1.1, and `r` tells that the client sent it again
+const fireH2 = () => {
+  const t = now();
+  const at = turn++ % connections;
+  let done = false;
+  let lp = null;
+  let held = null;
+  let stream = null;
+  let again = false;
+  const finish = (o, extra = {}) => {
+    if (done) return;
+    done = true;
+    clearTimeout(timer);
+    lp ??= portOf(held?.socket);
+    say({ ev: "req", t, d: Math.round((now() - t) * 1000) / 1000, o, ...extra, lp, ...(again ? { r: 1 } : {}) });
+  };
+  const failed = (error) => {
+    if (done) return;
+    if (!again && untaken(error, stream)) {
+      again = true;
+      held.usable = false;
+      send();
+      return;
+    }
+    finish(outcomeOf(error), { e: error?.code ?? String(error) });
+  };
+  const send = () => {
+    held = slotAt(at);
+    lp = portOf(held.socket);
+    if (held.socket.connecting)
+      held.socket.once("connect", () => {
+        lp ??= portOf(held.socket);
+      });
+    try {
+      stream = held.session.request({ ":path": "/work" });
+    } catch (error) {
+      failed(error);
+      return;
+    }
+    const mine = stream;
+    let status = 0;
+    let body = "";
+    mine.setEncoding("utf8");
+    mine.on("response", (headers) => {
+      status = Number(headers[":status"]);
+    });
+    mine.on("data", (chunk) => {
+      body += chunk;
+    });
+    mine.on("end", () => {
+      if (mine === stream && status !== 0) finish(outcomeOfStatus(status), { b: body.slice(0, 64) });
+    });
+    mine.on("error", (error) => {
+      if (mine === stream) failed(error);
+    });
+    mine.on("close", () => {
+      if (mine !== stream || done) return;
+      if (status !== 0) finish(outcomeOfStatus(status), { b: body.slice(0, 64) });
+      else failed(Object.assign(new Error(`the stream closed with code ${mine.rstCode}`), { code: mine.rstCode === REFUSED ? "REFUSED_STREAM" : "ECONNRESET" }));
+    });
+    mine.end();
+  };
+  const timer = setTimeout(() => {
+    lp ??= portOf(held?.socket);
+    stream?.close(http2.constants.NGHTTP2_CANCEL);
+    finish("timeout", { e: "LAB_TIMEOUT" });
+  }, timeout);
+  send();
+};
+
+say({ ev: "client", what: "start", t: now(), target: `${host}:${port}`, every, timeout, connections, protocol: h2 ? "h2c" : "http/1.1" });
+setInterval(h2 ? fireH2 : fire, every);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/kind",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "description": "Kubernetes in Docker as a lab for connection timers: a kind cluster from a scenario, faults in the namespaces of its pods, observations on the one monotonic clock of the VM, and predictions from the ordering law. Its judge entry reads and judges a raw record without Docker.",
   "keywords": [
     "kubernetes",
@@ -67,7 +67,7 @@
   "dependencies": {
     "@mark1russell7/harness": "^0.12.4",
     "@mark1russell7/quantity": "^0.2.0",
-    "@mark1russell7/service": "^0.5.16",
+    "@mark1russell7/service": "^0.5.19",
     "testcontainers": "12.2.0"
   },
   "peerDependencies": {