@mark1russell7/kind 0.7.0 → 0.8.1

package/build/{judge-B1nSdbS0.d.ts → judge-gpC49mVw.d.ts}

@@ -118,13 +118,17 @@ type Stack = "service" | "grpc";
  * - `crash` stops the process of the service with SIGKILL from the node.
  * - `liveness-restart` fails the liveness check of one replica, and the kubelet restarts it.
  * - `freeze-process` stops a process with SIGSTOP from the node: kube-proxy on one node (T07), or Redis (T18).
- * - `rst` and `blackhole` are the rules of the injector of the harness in the namespace of Redis.
+ * - `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`).
  * - `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.
  * - `cpu-throttle` sets `cpu.max` in the cgroup of one replica.
  * - `authorization-policy` applies an AuthorizationPolicy of Istio that denies the clients, for the hold (T15).
  * - `idle` stops the calls of each client with SIGUSR1, and starts them again with SIGUSR2 after the hold: a gap (T15).
+ *   The gap can have a stateful middlebox in each replica (`middlebox`), or a new channel that each
+ *   client closes before the gap (`close`).
  * - `ztunnel-restart` deletes the ztunnel pod of each node with its grace. The DaemonSet makes a new pod on each node (T15).
  * - `none` injects nothing: a calibration measures the path itself.
  */
@@ -150,6 +154,29 @@ interface Trigger<A = Quantity> {
    * and denies no call.
    */
   readonly account?: string | undefined;
+  /**
+   * This time is the idle timeout of a stateful middlebox in the network namespace of each replica
+   * (T15). The middlebox is there from before the fault to the end of the run. It forgets a flow of
+   * the mesh leg after this time with no segment. Then it drops each later segment of the flow: the
+   * silent-drop form of a router. Each segment of the flow refreshes the timeout, thus the PING of
+   * ztunnel can keep an idle flow. Conntrack of the namespace stays as it is (`middleboxCommands`).
+   */
+  readonly middlebox?: Quantity | undefined;
+  /** This count is `net.ipv4.tcp_retries2` in the network namespace of each client pod for the run (T15): the HBONE socket of its ztunnel is there. */
+  readonly retries?: number | undefined;
+  /**
+   * This flag stops the calls of each client before the fault, and starts them again after the heal
+   * (T15 `blackhole`). Thus no data of the app is on the mesh leg in the fault. The PING of ztunnel
+   * is the first segment that gets no answer.
+   */
+  readonly quiet?: boolean | undefined;
+  /**
+   * This flag gives each client a new channel at the fault of `idle` (T15). The client closes its
+   * channel before the fault. At the fault it opens a new channel and calls on it for a short time,
+   * then it closes it. Thus the HBONE connection of the client carries no stream in the gap, and its
+   * last use is at the fault. The heal opens a new channel again.
+   */
+  readonly close?: boolean | undefined;
 }
 /** A kubelet probe is the period, the failure threshold and the timeout of one probe of the pod. */
 interface KubeletProbe {
@@ -257,6 +284,8 @@ interface ResetReuse<A = Quantity> {
  * - `ends`: the socket of each client ends in the band after the reference `from`. With no band, no
  *   socket of a client ends in the run. Then the first request of each client after the heal goes on
  *   the socket of its last request before the fault. With `window`, the failed requests also start in that window.
+ *   With `of: "tunnel"`, the HBONE connection of the ztunnel of each client ends in the band instead.
+ *   With `answer`, the close of the peer in that band is an answer to the close of the client.
  * - `measured`: no document bounds the outcome. The run keeps the measurement.
  */
 type Prediction<A = Quantity> = {
@@ -290,6 +319,20 @@ type Prediction<A = Quantity> = {
   readonly band: Band<A> | null;
   /** This window is where the failed requests start, or none when the prediction does not test them. */
   readonly window?: WindowPrediction<A> | undefined;
+  /**
+   * This text names what ends. `socket`, the default, is the socket of the channel of each client.
+   * `tunnel` is the HBONE connection of the ztunnel of each client to the replica of its last answer
+   * before the heal (T15 ambient). Its side of the client must close it: the peer does not close
+   * first. Then the first request of each client after the heal must succeed, on a new tunnel.
+   */
+  readonly of?: "socket" | "tunnel" | undefined;
+  /**
+   * This band is where the peer can answer the close of the side of the client with its own
+   * close, after `from` (only with `of: "tunnel"`). A change of a tunnel from ESTABLISHED to
+   * CLOSE_WAIT in it agrees: the FIN of the peer came first, but as an answer. Before it, the
+   * peer closed first. Without it, only FIN_WAIT1 agrees.
+   */
+  readonly answer?: Band<A> | undefined;
   readonly why: string;
 } | {
   readonly kind: "measured";
@@ -536,7 +579,33 @@ interface SocketLine {
   readonly n: string;
   readonly lp: number | null;
   readonly err?: string | null;
-}
+  /** This address is the local address of the socket at its connect: the address of the client pod. Lines before 0.8.0 do not have it. */
+  readonly la?: string | null;
+}
+/** This port is the HBONE port of ztunnel in each pod of the ambient mesh of Istio 1.31.3: the mesh leg ends there. */
+declare const HBONE_PORT = 15008;
+/** These are the states of a TCP socket of Linux that a tunnel line names (include/net/tcp_states.h of Linux v6.17, lines 12–28). */
+declare const TCP_STATE: {
+  readonly established: 1;
+  readonly finWait1: 4;
+  readonly closeWait: 8;
+};
+/**
+ * A tunnel line is a change of the state of a TCP socket with the HBONE port at one end, from the
+ * prober (`kernel.state`). `src` and `dst` are each an address and a port, `a.b.c.d:port`. The stamp
+ * `t` is in ms on CLOCK_MONOTONIC.
+ */
+interface TunnelLine {
+  readonly t: number;
+  readonly src: string;
+  readonly dst: string;
+  readonly old: number;
+  readonly new: number;
+}
+/** This function tells if a kernel record is a change of the state of a socket of the HBONE port. */
+declare const isTunnelState: (record: Readonly<Record<string, unknown>>) => boolean;
+/** This function gives the tunnel lines of a run, in sequence of their stamps. */
+declare const tunnelsOf: (lines: readonly Line[]) => TunnelLine[];
 declare const requestsOf: (lines: readonly Line[]) => Request[];
 declare const podsOf: (lines: readonly Line[]) => PodLine[];
 declare const slicesOf: (lines: readonly Line[], svc: string) => SliceLine[];
@@ -944,5 +1013,5 @@ declare const quantileOf: (sorted: readonly number[], p: number) => number;
  */
 declare const medianInterval: (sorted: readonly number[]) => [number, number];
 //#endregion
-export { updatesOf as $, MeshFlavor as $t, TriggerV1 as A, sliceEmptyOf as At, RunCheck as B, PORT as Bt, KindCellResult as C, kubeProxyPatch as Cn, requestsOf as Ct, PredictionV1 as D, signalOf as Dt, LoadSample as E, scenarioProblems as En, rulesOf as Et, KIND_NOISE as F, ztunnelPodsOf as Ft, judgeKind as G, secondsOf as Gt, checkRun as H, SERVER as Ht, KindDecision as I, ztunnelReplaced as It, propagationOf as J, Declaration as Jt, observationAfter as K, showBand as Kt, KindVerdict as L, CLIENT as Lt, upgrade as M, socketsOf as Mt, upgradeCell as N, stoppingOf as Nt, RunCheckV1 as O, signalsOf as Ot, Deleted as P, transitionOf as Pt, unitOf as Q, Mesh as Qt, LAST_SLACK as R, HEALTH_PORT as Rt, KindCellRecordV1 as S, kindConfig as Sn, recordsOf as St, KindVerdictV1 as T, scenario as Tn, restartsAt as Tt, deletionsOf as U, bandOf as Ut, RunFacts as V, REDIS as Vt, factsOf as W, seconds as Wt, referenceOf as X, KindRun as Xt, propagationSource as Y, KindCell as Yt, reusesReset as Z, KubeletProbe as Zt, ClusterManifest as _, NODE_IMAGES as _n, intakeOf as _t, STAGES as a, Replica as an, Request as at, FORMAT_V1 as b, cidrRange as bn, podsAt as bt, readRecord as c, Template as cn, SocketLine as ct, calibrationOf as d, WindowPrediction as dn, byClients as dt, MeshMode as en, Endpoint as et, cellsTable as f, Workload as fn, byNode as ft, BandV1 as g, KubeProxyMode as gn, failuresOf as gt, timeSpread as h, KindScenario as hn, emptyOf as ht, quantileOf as i, Reference as in, RecordLine as it, judge as j, slicesOf as jt, RunFactsV1 as k, sliceDropOf as kt, Judged as l, Trigger as ln, ZtunnelPodLine as lt, predictionText as m, KindConfig as mn, dropOf as mt, medianInterval as n, Prediction as nn, PodLine as nt, kindCellRecordSchema as o, ResetReuse as on, RulesLine as ot, medianText as p, KUBE_PROXY_MODES as pn, deletionOf as pt, observationEnd as q, Band as qt, middle as r, RedisDeclaration as rn, PropagationSource as rt, kindCellRecordV1Schema as s, Stack as sn, SliceLine as st, RELATIVE as t, PodSettings as tn, Line as tt, TimeSpread as u, TriggerKind as un, backendsAt as ut, EnvironmentManifest as v, NodeImage as vn, kernelCounts as vt, KindCellV1 as w, nodeNames as wn, restartOf as wt, KindCellRecord as x, goDuration as xn, podsOf as xt, FORMAT as y, cidrOverlap as yn, outcomesOf as yt, Propagated as z, LOG_LABEL as zt };
-//# sourceMappingURL=judge-B1nSdbS0.d.ts.map
+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-gpC49mVw.d.ts.map

package/build/judge.d.ts

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

package/build/judge.js

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

package/image/client-grpc.mjs

@@ -17,6 +17,8 @@
 // Each socket of the channel also gives a line `sock` at its connect and at its close (client-lines.ts).
 // SIGUSR1 stops the calls, and SIGUSR2 starts them again: the gap of the trigger `idle`. A listener of
 // SIGUSR1 replaces the start of the inspector of Node at that signal. The channel stays open in the gap.
+// SIGHUP stops the calls and closes the channel (internal-channel.ts:839-861). Then the next SIGUSR2
+// opens a new channel. The connect line of a socket also gives its local address (`la`).
 import net from "node:net";
 import { followSocket, gapOf } from "./client-lines.ts";
 
@@ -42,6 +44,12 @@ const portOf = (socket) => {
   socket?._handle?.getsockname?.(out);
   return typeof out.port === "number" ? out.port : null;
 };
+// the local address of a socket, or null once its handle is closed
+const addressOf = (socket) => {
+  const out = {};
+  socket?._handle?.getsockname?.(out);
+  return typeof out.address === "string" ? out.address : null;
+};
 
 // grpc-js connects with net.connect (transport.ts:830), on the module object that this patch changes.
 // It loads after the patch. With an address and no host name, connect() comes before net.connect
@@ -54,13 +62,19 @@ net.connect = function (...args) {
   socket.once("connect", () => {
     lp = portOf(socket) ?? lp;
   });
-  followSocket(socket, () => portOf(socket), say, now);
+  followSocket(socket, () => portOf(socket), say, now, () => addressOf(socket));
   return socket;
 };
 
-const gap = gapOf((signal, listener) => process.on(signal, listener), say, now);
-
 const grpc = await import("@grpc/grpc-js");
+const open = () => new grpc.Client(`${host}:${port}`, grpc.credentials.createInsecure(), {});
+let client = open();
+const gap = gapOf((signal, listener) => process.on(signal, listener), say, now, {
+  close: () => client.close(),
+  open: () => {
+    client = open();
+  },
+});
 
 // ---- the messages of grpc.health.v1, encoded by hand: the request of the service "", and the status of the reply
 const encodeRequest = () => Buffer.alloc(0);
@@ -77,8 +91,6 @@ const outcomeOf = (error) => {
   return "error";
 };
 
-const client = new grpc.Client(`${host}:${port}`, grpc.credentials.createInsecure(), {});
-
 const fire = () => {
   if (gap.stopped) return;
   const t = now();

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/kind",
-  "version": "0.7.0",
+  "version": "0.8.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.3",
     "@mark1russell7/quantity": "^0.2.0",
-    "@mark1russell7/service": "^0.5.9",
+    "@mark1russell7/service": "^0.5.10",
     "testcontainers": "12.2.0"
   },
   "peerDependencies": {

package/src/client-lines.ts

@@ -20,8 +20,11 @@ export type Say = (line: Readonly<Record<string, unknown>>) => void;
  *
  * A prediction `ends` reads the close line: the end of the socket of the channel. A FIN of the peer
  * and a reset each end it.
+ *
+ * With `address`, the connect line also gives the local address of the socket (`la`): the address of
+ * the pod. A prediction of the tunnels finds the HBONE connection of the ztunnel of the pod by it.
  */
-export const followSocket = (socket: WatchedSocket, port: () => number | null, say: Say, now: () => number): void => {
+export const followSocket = (socket: WatchedSocket, port: () => number | null, say: Say, now: () => number, address?: () => string | null): void => {
   let lp = port();
   let error: string | null = null;
   socket.once("error", (failure) => {
@@ -29,32 +32,60 @@ export const followSocket = (socket: WatchedSocket, port: () => number | null, s
   });
   socket.once("connect", () => {
     lp = port() ?? lp;
-    say({ ev: "sock", what: "connect", t: now(), lp });
+    say({ ev: "sock", what: "connect", t: now(), lp, ...(address === undefined ? {} : { la: address() }) });
   });
   socket.once("close", (hadError) => {
     say({ ev: "sock", what: "close", t: now(), lp, err: hadError ? (error ?? "error") : null });
   });
 };
 
-/** A gap is the state of the calls of a client: `stopped` from SIGUSR1 to the next SIGUSR2. */
+/**
+ * A gap is the state of the calls of a client. It is `stopped` from SIGUSR1 or SIGHUP to the next
+ * SIGUSR2. It is `closed` from SIGHUP to the next SIGUSR2.
+ */
 export interface Gap {
   readonly stopped: boolean;
+  readonly closed: boolean;
 }
 
+/** A channel is the part of the channel of a client that a gap closes and opens again. */
+export interface Channel {
+  close(): void;
+  open(): void;
+}
+
+/** These are the signals of a gap. */
+export type GapSignal = "SIGUSR1" | "SIGUSR2" | "SIGHUP";
+
 /**
  * This function stops the calls of a client at SIGUSR1, and it starts them again at SIGUSR2. That is
  * the gap of the trigger `idle`. Each signal writes a line `gap` with the stamp of `now`, also when it
  * changes nothing. The channel and its socket stay open in the gap.
+ *
+ * With a `channel`, SIGHUP also stops the calls and closes the channel (`close`). Then the next
+ * SIGUSR2 opens a new channel before it starts the calls (`open`, a line `gap` with `open: true`).
  */
-export const gapOf = (on: (signal: "SIGUSR1" | "SIGUSR2", listener: () => void) => unknown, say: Say, now: () => number): Gap => {
-  const gap = { stopped: false };
+export const gapOf = (on: (signal: GapSignal, listener: () => void) => unknown, say: Say, now: () => number, channel?: Channel): Gap => {
+  const gap = { stopped: false, closed: false };
   on("SIGUSR1", () => {
     gap.stopped = true;
     say({ ev: "gap", what: "stop", t: now() });
   });
   on("SIGUSR2", () => {
+    const open = gap.closed && channel !== undefined;
+    if (open) {
+      channel.open();
+      gap.closed = false;
+    }
     gap.stopped = false;
-    say({ ev: "gap", what: "start", t: now() });
+    say({ ev: "gap", what: "start", t: now(), ...(open ? { open: true } : {}) });
   });
+  if (channel !== undefined)
+    on("SIGHUP", () => {
+      gap.stopped = true;
+      if (!gap.closed) channel.close();
+      gap.closed = true;
+      say({ ev: "gap", what: "close", t: now() });
+    });
   return gap;
 };