@mark1russell7/kind 0.11.11 → 0.11.12

package/build/judge.d.ts

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

package/build/judge.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/kind",
-  "version": "0.11.11",
+  "version": "0.11.12",
   "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",

package/src/compose.ts

@@ -1,7 +1,7 @@
 // The composition of the service of a kind cell. The app of the image and `lint()` compose the same
 // service from the same declaration: the image copies this file, and Node strips its types. Thus
 // this file imports only packages and types.
-import type { CheckFn, HealthServer, ServiceBuilder, TransportImpl } from "@mark1russell7/service";
+import type { CheckFn, Coupling, Health, HealthServer, ProbeAnswer, ServiceBuilder, TransportImpl } from "@mark1russell7/service";
 import { service } from "@mark1russell7/service";
 import type { RedisClient } from "@mark1russell7/service/redis";
 import type { Declaration } from "./cell.ts";
@@ -22,6 +22,38 @@ export const FLAG_CHECK = "self.flag";
 /** This name is the watchdog of the event loop. */
 export const WATCHDOG = "self.event-loop";
 
+/**
+ * This function gives the health server of the shared gate (S6, candidate E). Its readiness probe
+ * leaves out each check of `dependency`, a dependency that each replica shares. The controller still
+ * reads each check, thus the service still refuses each request at once with a 503. The other
+ * probes, and the readiness of a controller, answer as before.
+ *
+ * The probe passes when the service is started and not in the drain, and liveness does not fail
+ * readiness through a coupling. Each readiness check of another dependency, or of no dependency,
+ * must also be released.
+ */
+export const sharedGate = (server: HealthServer, dependency: string, couplings: readonly Coupling[]): HealthServer => {
+  const gated = (health: Health): Health => ({
+    verdict: () => health.verdict(),
+    metrics: () => health.metrics(),
+    subscribe: (listener) => health.subscribe(listener),
+    forceFail: (name, on) => health.forceFail(name, on),
+    drain: () => health.drain(),
+    stop: () => health.stop(),
+    probe(kind, controller): ProbeAnswer {
+      const answer = health.probe(kind, controller);
+      if (kind !== "readiness" || controller !== undefined) return answer;
+      const verdict = health.verdict();
+      const coupled = couplings.some((coupling) => coupling.from === "liveness" && coupling.to === "readiness") && !verdict.alive;
+      const checks = Object.values(verdict.checks).every((check) => check.gates !== "readiness" || check.dependency === dependency || check.tripped !== true);
+      const dependencies = Object.entries(verdict.dependencies).every(([name, up]) => name === dependency || up);
+      const pass = verdict.started && !verdict.draining && !coupled && checks && dependencies;
+      return { ...answer, status: pass ? 200 : 503, body: { ...answer.body, status: pass ? "pass" : "fail" } };
+    },
+  });
+  return { listen: (health) => server.listen(gated(health)), close: () => server.close() };
+};
+
 /**
  * This function composes the service of a declaration: its policies, its couplings, its checks,
  * one server, one controller and each stage of the shutdown. A declaration with Redis needs the
@@ -64,7 +96,10 @@ export const compose = (name: string, declaration: Declaration, parts: Parts = {
   const controller = svc.controller(CONTROLLER);
   if (declaration.redis !== null) controller.requires(parts.redis!.name);
   controller.route(ROUTE, { idempotent: true });
-  if (parts.health !== undefined) svc.healthServer(parts.health);
+  // the shared gate keeps the checks of Redis out of the readiness that the kubelet reads
+  if (declaration.sharedGate === true && declaration.redis === null) throw new Error(`${name} has the shared gate, but it declares no Redis`);
+  if (parts.health !== undefined)
+    svc.healthServer(declaration.sharedGate === true ? sharedGate(parts.health, parts.redis!.name, declaration.couplings) : parts.health);
   for (const [stage, cap] of declaration.phases) svc.phase(stage, cap);
   return svc;
 };