@mark1russell7/kind 0.11.1 → 0.11.3

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

@@ -2,6 +2,7 @@ import { Extent, Quantity } from "@mark1russell7/quantity";
 import { z } from "zod";
 import { Coupling, Gate, Poll, Stage, Timing } from "@mark1russell7/service";
 import { RedisKnobs } from "@mark1russell7/service/redis";
+import { SessionCheckKnobs } from "@mark1russell7/service/http-client";
 //#region src/scenario.d.ts
 /** A kube-proxy mode is the dataplane of each node: iptables (the default of kind), IPVS or nftables. */
 type KubeProxyMode = "iptables" | "ipvs" | "nftables";
@@ -121,6 +122,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 +184,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 {
@@ -266,6 +275,12 @@ interface Workload {
    * of HTTP/2 keeps this count of sessions, and it needs the count.
    */
   readonly connections?: number | undefined;
+  /**
+   * These knobs give each session of a client of HTTP/2 the session check of the service
+   * (`sessionCheck` of `@mark1russell7/service/http-client`). A stream timeout or a PING with no ACK
+   * then closes the session, and the next stream opens a new one. Without them, a session has no check.
+   */
+  readonly sessionCheck?: SessionCheckKnobs | undefined;
 }
 /**
  * A band is a range of times after a reference event of the run. The format `/1` gives each end
@@ -1042,4 +1057,4 @@ 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, 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
+//# sourceMappingURL=judge-yWlioigZ.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, 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";
+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-yWlioigZ.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-Bb4ebE9V.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-BHygFh4Z.js";

package/image/client.mjs

@@ -4,10 +4,12 @@
 // 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.
+// session of HTTP/2, and each request is a stream on the next session in turn. With SESSION_CHECK,
+// each session has the session check of the service: a stream timeout or a PING with no ACK closes it.
 import http from "node:http";
 import http2 from "node:http2";
 import net from "node:net";
+import { sessionCheck } from "@mark1russell7/service/http-client";
 
 const [host, port] = (process.env.TARGET ?? "").split(":");
 const every = Number(process.env.EVERY_MS ?? 20);
@@ -18,6 +20,8 @@ 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);
+// the knobs of the session check, or null for a session with no check
+const checkKnobs = h2 && process.env.SESSION_CHECK !== undefined ? JSON.parse(process.env.SESSION_CHECK) : null;
 
 // 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
@@ -27,14 +31,27 @@ 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
+// kube-proxy picks a backend for that new connection. The old session ends the streams that it has.
+// The check of a session hears each frame of the peer: its SETTINGS, its PINGs, and each response
 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 held = { session, socket, usable: true, check: null };
   const drop = () => {
     held.usable = false;
+    held.check?.stop();
   };
+  if (checkKnobs !== null) {
+    held.check = sessionCheck(session, {
+      knobs: checkKnobs,
+      onClose: (cause) => {
+        held.usable = false;
+        say({ ev: "client", what: "session-check", t: now(), why: cause, lp: portOf(socket) });
+      },
+    });
+    session.on("remoteSettings", () => held.check.heard());
+    session.on("ping", () => held.check.heard());
+  }
   session.on("goaway", drop);
   session.on("close", drop);
   session.on("error", drop);
@@ -157,10 +174,13 @@ const fireH2 = () => {
   let held = null;
   let stream = null;
   let again = false;
+  // the end of the current stream for the check of its session: one time, at its timeout or otherwise
+  let endStream = null;
   const finish = (o, extra = {}) => {
     if (done) return;
     done = true;
     clearTimeout(timer);
+    endStream?.(false);
     lp ??= portOf(held?.socket);
     say({ ev: "req", t, d: Math.round((now() - t) * 1000) / 1000, o, ...extra, lp, ...(again ? { r: 1 } : {}) });
   };
@@ -169,6 +189,7 @@ const fireH2 = () => {
     if (!again && untaken(error, stream)) {
       again = true;
       held.usable = false;
+      endStream?.(false);
       send();
       return;
     }
@@ -188,13 +209,24 @@ const fireH2 = () => {
       return;
     }
     const mine = stream;
+    const check = held.check;
+    let counted = false;
+    check?.opened();
+    endStream = (timedOut) => {
+      if (counted) return;
+      counted = true;
+      if (timedOut) check?.timedOut();
+      else check?.ended();
+    };
     let status = 0;
     let body = "";
     mine.setEncoding("utf8");
     mine.on("response", (headers) => {
+      check?.heard();
       status = Number(headers[":status"]);
     });
     mine.on("data", (chunk) => {
+      check?.heard();
       body += chunk;
     });
     mine.on("end", () => {
@@ -213,10 +245,12 @@ const fireH2 = () => {
   const timer = setTimeout(() => {
     lp ??= portOf(held?.socket);
     stream?.close(http2.constants.NGHTTP2_CANCEL);
+    // a stream that times out closes its session, when the session has a check
+    endStream?.(true);
     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" });
+say({ ev: "client", what: "start", t: now(), target: `${host}:${port}`, every, timeout, connections, protocol: h2 ? "h2c" : "http/1.1", ...(checkKnobs !== null ? { sessionCheck: checkKnobs } : {}) });
 setInterval(h2 ? fireH2 : fire, every);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/kind",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "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.19",
+    "@mark1russell7/service": "^0.5.20",
     "testcontainers": "12.2.0"
   },
   "peerDependencies": {