@mark1russell7/kind 0.11.0 → 0.11.2

package/build/{judge-4bzoeGIb.d.ts → judge-DrMgsOZ0.d.ts}

@@ -121,6 +121,7 @@ type Stack = "service" | "grpc";
  * - `rst` and `blackhole` are the rules of the injector of the harness in the namespace of Redis. In
  *   T15 they are in the namespace of each replica. A black hole of T15 can stop the calls of the
  *   clients before the fault (`quiet`). It can also set `tcp_retries2` of each client pod (`retries`).
+ *   A black hole with `partition` is in the namespace of the target replica only, with the client pods as peers.
  * - `peer-gone-without-close` drops the segments of Redis, and then Redis goes away.
  * - `app-stall` blocks the event loop of one replica.
  * - `rollout` is a rolling update while Redis is down.
@@ -182,6 +183,13 @@ interface Trigger<A = Quantity> {
    * last use is at the fault. The heal opens a new channel again.
    */
   readonly close?: boolean | undefined;
+  /**
+   * This flag puts a black hole between the clients and the target replica (T07 `blackhole` of S2).
+   * The rules go in the namespace of the target only, with each client pod as a peer. The kubelet
+   * still reaches the replica from its node, thus its readiness and its endpoint stay. The prepare
+   * gives each client new connections first, as `cannot-serve` does.
+   */
+  readonly partition?: boolean | undefined;
 }
 /** A kubelet probe is the period, the failure threshold and the timeout of one probe of the pod. */
 interface KubeletProbe {
@@ -231,16 +239,26 @@ interface Declaration {
     readonly threshold: Quantity;
   } | null;
   /**
-   * This flag is the lame-duck state of the HTTP edge. With true or no value, the edge sends
-   * `Connection: close` while the service is not ready, thus each caller opens a new connection.
-   * With false, the edge keeps each connection open, thus a caller learns only from the endpoints.
+   * 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, or it keeps `connections` open. 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. */
@@ -252,7 +270,8 @@ interface Workload {
   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.
+   * 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;
 }
@@ -1030,5 +1049,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-4bzoeGIb.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-DrMgsOZ0.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-4bzoeGIb.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-DrMgsOZ0.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-DdeJ1qVd.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-C09uZiha.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";
@@ -66,8 +67,9 @@ 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 }));
 // 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

package/image/client.mjs

@@ -3,8 +3,11 @@
 // 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`).
+// 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);
@@ -12,21 +15,48 @@ 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 connections = process.env.CONNECTIONS === undefined ? 0 : Number(process.env.CONNECTIONS);
+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 = agentsOf();
+let agents = h2 ? [] : agentsOf();
 let turn = 0;
-// SIGHUP: new agents for the next requests. The old agents go after the timeout, thus each request
-// on them ends first
+
+// 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;
-  agents = agentsOf();
+  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);
 });
 
@@ -56,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;
@@ -80,7 +112,7 @@ const fire = () => {
     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(() => {
@@ -105,5 +137,86 @@ const fire = () => {
   req.end();
 };
 
-say({ ev: "client", what: "start", t: now(), target: `${host}:${port}`, every, timeout, connections });
-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.11.0",
+  "version": "0.11.2",
   "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.18",
+    "@mark1russell7/service": "^0.5.19",
     "testcontainers": "12.2.0"
   },
   "peerDependencies": {