@mark1russell7/kind 0.11.6 → 0.11.8

package/README.md

@@ -211,7 +211,7 @@ The plan's `event:clock-jump` has no trigger. A step of CLOCK_REALTIME in the VM
 
 `predict.ts` gives each band from the declaration, the pod settings and the calibration of the propagation:
 
-- **A deletion.** The listener of a leaving pod stays open for its preStop sleep and the hold of `fail readiness`. A connection fails when the rules of its node select the pod after that. `rules.ts` gives O04 with the hold as data, and `lint()` decides it.
+- **A deletion.** The listener of a leaving pod stays open for its preStop sleep and the hold of `fail readiness`. A connection fails when the rules of its node select the pod after that. The entry `@mark1russell7/service/rules` gives O04 with the hold as data, and `lint()` decides it. Kind gives the drain rules of that entry again (`DRAIN_RULES`, `O04`, `O09`, `O10`, `O16`).
 - **The way that a plan stops a pod.** `stopOf(cell)` reads it from the trigger: a deletion, a liveness restart, a crash, or null when the plan stops no pod. `lintCell()` gives each cell only the drain rules that guard its way (`lintStop()` of the service). A plan that stops no pod gets each drain rule. A crash gets no drain rule, and its finding of `stop` depends.
 - **A pause of kube-proxy** keeps the rules of one node for its hold. The window on that node ends one propagation after the pause. A SYN_SENT entry of an earlier run lives up to 122 s, thus the window also opens up to 122 s before the intake. `predictionText` writes each end of a window with its band, for example `the intake + [-122, 4.605] s`.
 - **A reset from a leaving pod** leaves the conntrack entry of its flow in CLOSE for 10 s, with the NAT to that pod. From 0.1.6, a window can give that life (`afterReset`). Then a request outside the window can fail with the outcome of the rule (`reusesReset`). The condition is a reset of the same client on the same port, up to that life before the request. The catalog gives it to a deletion without a hold, in the modes with the NAT in conntrack.

package/build/index.d.ts

@@ -1,8 +1,9 @@
 import { $ as updatesOf, $t as Declaration, A as TriggerV1, An as nodeNames, At as rulesOf, B as RunCheck, Bt as ztunnelPodsOf, C as KindCellResult, Cn as NODE_IMAGES, Ct as outcomesOf, D as PredictionV1, Dn as goDuration, Dt as requestsOf, E as LoadSample, En as cidrRange, 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, Mn as scenarioProblems, Mt as signalsOf, N as upgradeCell, Nt as sliceDropOf, O as RunCheckV1, On as kindConfig, 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, Tn as cidrOverlap, 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, bn as KindConfig, 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, jn as scenario, jt as signalOf, k as RunFactsV1, kn as kubeProxyPatch, 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, wn as NodeImage, wt as podsAt, x as KindCellRecord, xn as KindScenario, xt as isTunnelState, y as FORMAT, yn as KUBE_PROXY_MODES, yt as failuresOf, z as Propagated, zt as tunnelsOf } from "./judge-DnB9wEwC.js";
 import { Quantity } from "@mark1russell7/quantity";
-import { CheckFn, Finding, HealthServer, Poll, Rule, Scenario, ServiceBuilder, ServiceDescription, Stage, StopWay, Timing, TransportImpl, Verdict } from "@mark1russell7/service";
+import { CheckFn, Finding, HealthServer, Poll, Scenario, ServiceBuilder, ServiceDescription, Stage, StopWay, Timing, TransportImpl, Verdict } from "@mark1russell7/service";
 import { BuildImage } from "@mark1russell7/harness";
 import { RedisClient } from "@mark1russell7/service/redis";
+import { DRAIN_RULES, O04, O09, O10, O16 } from "@mark1russell7/service/rules";
 //#region src/backends.d.ts
 /** A service rule names the Service whose backends the agent reads: its namespace, its name, and its ClusterIP and port for IPVS. */
 interface ServiceRule {
@@ -680,24 +681,6 @@ interface LearnWindow {
 export declare const learnWindow: (declaration: Declaration, readiness: KubeletProbe, propagation: Propagation, workload: Workload) => LearnWindow;
 //#endregion
 //#region src/rules.d.ts
-/**
- * These are the rules of the ordering law that a drain in Kubernetes meets, as data. The caller of
- * `lint()` gives the rules, thus they are here and not in the service.
- */
-/**
- * O04 with the hold of the service. The listener of a pod stays open through the preStop sleep and
- * then through the hold of `fail readiness`. Thus the sum of the two must cover the propagation of
- * the endpoints. The rule of the research is the case without a hold.
- */
-export declare const O04: Rule;
-/** O09 is W8: readiness detection plus propagation is no longer than liveness detection plus the preStop sleep. */
-export declare const O09: Rule;
-/** O10: the preStop sleep plus the drain of the process fits in the grace period. */
-export declare const O10: Rule;
-/** O16: the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep. */
-export declare const O16: Rule;
-/** These are the rules of the drain. A kind cell gets the rules that guard the way that its plan stops a pod. */
-export declare const DRAIN_RULES: readonly Rule[];
 /**
  * This function gives the scenario of a cell for `lint()`: the preStop sleep, the grace, the probe
  * period and the propagation. The probe windows are the period times the threshold of each probe.
@@ -817,5 +800,5 @@ export declare const toolPath: (tool: Tool, key?: string, cache?: string) => str
  */
 export declare const ensureTool: (tool: Tool, key?: string, cache?: string) => Promise<string>;
 //#endregion
-export { type Band, type BandV1, CLIENT, type Cluster, type ClusterHosts, type ClusterManifest, type Credentials, type Declaration, type Deleted, type DeletionWindow, type EdgeProtocol, type EdsSpec, Endpoint, type EnvironmentManifest, FORMAT, FORMAT_V1, type FaultPlan, HBONE_PORT, HEALTH_PORT, type Judged, KIND_NOISE, KUBE_PROXY_MODES, type KindCell, type KindCellRecord, type KindCellRecordV1, type KindCellResult, type KindCellV1, type KindConfig, type KindDecision, type KindLab, type KindRun, type KindScenario, type KindVerdict, type KindVerdictV1, type KubeProxyMode, type KubeletProbe, LAST_SLACK, LOG_LABEL, type LdsSpec, type LeafCertificate, type LearnWindow, Line, type ListenerCounts, type LoadSample, type Mesh, type MeshFlavor, type MeshImages, type MeshMode, NODE_IMAGES, type NodeImage, PORT, type Parts, PodLine, type PodSettings, type Prediction, type PredictionV1, type Propagated, type Propagation, PropagationSource, REDIS, RELATIVE, RecordLine, type RedisDeclaration, type Reference, type Replica, Request, type ResetReuse, RulesLine, type RunCheck, type RunCheckV1, type RunFacts, type RunFactsV1, type RunOptions, SERVER, STAGES, type ServiceRule, SliceLine, SocketLine, type Stack, type Stamp, type Step, TCP_STATE, type Target, type Template, type TimeSpread, type Tool, type Trigger, type TriggerKind, type TriggerV1, TunnelLine, type Verdicts, type WindowPrediction, type Workload, ZtunnelPodLine, backendsAt, bandOf, byClients, byNode, calibrationOf, cellsTable, checkRun, cidrOverlap, cidrRange, deletionOf, deletionsOf, dropOf, emptyOf, factsOf, failuresOf, goDuration, intakeOf, isTunnelState, judge, judgeKind, kernelCounts, kindCellRecordSchema, kindCellRecordV1Schema, kindConfig, kubeProxyPatch, medianInterval, medianText, middle, nodeNames, observationAfter, observationEnd, outcomesOf, podsAt, podsOf, predictionText, propagationOf, propagationSource, quantileOf, readRecord, recordsOf, referenceOf, requestsOf, restartOf, restartsAt, reusesReset, rulesOf, scenario, scenarioProblems, seconds, secondsOf, showBand, signalOf, signalsOf, sliceDropOf, sliceEmptyOf, slicesOf, socketsOf, stoppingOf, timeSpread, transitionOf, tunnelsOf, unitOf, updatesOf, upgrade, upgradeCell, ztunnelPodsOf, ztunnelReplaced };
+export { type Band, type BandV1, CLIENT, type Cluster, type ClusterHosts, type ClusterManifest, type Credentials, DRAIN_RULES, type Declaration, type Deleted, type DeletionWindow, type EdgeProtocol, type EdsSpec, Endpoint, type EnvironmentManifest, FORMAT, FORMAT_V1, type FaultPlan, HBONE_PORT, HEALTH_PORT, type Judged, KIND_NOISE, KUBE_PROXY_MODES, type KindCell, type KindCellRecord, type KindCellRecordV1, type KindCellResult, type KindCellV1, type KindConfig, type KindDecision, type KindLab, type KindRun, type KindScenario, type KindVerdict, type KindVerdictV1, type KubeProxyMode, type KubeletProbe, LAST_SLACK, LOG_LABEL, type LdsSpec, type LeafCertificate, type LearnWindow, Line, type ListenerCounts, type LoadSample, type Mesh, type MeshFlavor, type MeshImages, type MeshMode, NODE_IMAGES, type NodeImage, O04, O09, O10, O16, PORT, type Parts, PodLine, type PodSettings, type Prediction, type PredictionV1, type Propagated, type Propagation, PropagationSource, REDIS, RELATIVE, RecordLine, type RedisDeclaration, type Reference, type Replica, Request, type ResetReuse, RulesLine, type RunCheck, type RunCheckV1, type RunFacts, type RunFactsV1, type RunOptions, SERVER, STAGES, type ServiceRule, SliceLine, SocketLine, type Stack, type Stamp, type Step, TCP_STATE, type Target, type Template, type TimeSpread, type Tool, type Trigger, type TriggerKind, type TriggerV1, TunnelLine, type Verdicts, type WindowPrediction, type Workload, ZtunnelPodLine, backendsAt, bandOf, byClients, byNode, calibrationOf, cellsTable, checkRun, cidrOverlap, cidrRange, deletionOf, deletionsOf, dropOf, emptyOf, factsOf, failuresOf, goDuration, intakeOf, isTunnelState, judge, judgeKind, kernelCounts, kindCellRecordSchema, kindCellRecordV1Schema, kindConfig, kubeProxyPatch, medianInterval, medianText, middle, nodeNames, observationAfter, observationEnd, outcomesOf, podsAt, podsOf, predictionText, propagationOf, propagationSource, quantileOf, readRecord, recordsOf, referenceOf, requestsOf, restartOf, restartsAt, reusesReset, rulesOf, scenario, scenarioProblems, seconds, secondsOf, showBand, signalOf, signalsOf, sliceDropOf, sliceEmptyOf, slicesOf, socketsOf, stoppingOf, timeSpread, transitionOf, tunnelsOf, unitOf, updatesOf, upgrade, upgradeCell, ztunnelPodsOf, ztunnelReplaced };
 //# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -12,6 +12,7 @@ import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { harnessImage, imageOf } from "@mark1russell7/harness";
 import { redisClient } from "@mark1russell7/service/redis";
+import { DRAIN_RULES, DRAIN_RULES as DRAIN_RULES$1, O04, O09, O10, O16 } from "@mark1russell7/service/rules";
 //#region src/backends.ts
 const hexIp = (hex) => [
 	0,
@@ -2653,130 +2654,6 @@ const learnWindow = (declaration, readiness, propagation, workload) => {
 };
 //#endregion
 //#region src/rules.ts
-/**
-* These are the rules of the ordering law that a drain in Kubernetes meets, as data. The caller of
-* `lint()` gives the rules, thus they are here and not in the service.
-*/
-/**
-* O04 with the hold of the service. The listener of a pod stays open through the preStop sleep and
-* then through the hold of `fail readiness`. Thus the sum of the two must cover the propagation of
-* the endpoints. The rule of the research is the case without a hold.
-*/
-const O04 = {
-	id: "O04",
-	rule: "the preStop sleep plus the hold of fail readiness is at least the endpoint propagation",
-	window: "new connections reach a pod whose listener is closed",
-	expr: {
-		lhs: { terms: [{
-			knob: "prestop_sleep",
-			coef: 1,
-			at: "pod"
-		}, {
-			knob: "readiness_hold",
-			coef: 1,
-			at: "process"
-		}] },
-		op: ">=",
-		rhs: { terms: [{
-			knob: "propagation_bound",
-			coef: 1,
-			at: "cluster"
-		}] }
-	}
-};
-/** O09 is W8: readiness detection plus propagation is no longer than liveness detection plus the preStop sleep. */
-const O09 = {
-	id: "O09",
-	rule: "readiness detection plus endpoint propagation is no longer than liveness detection plus the preStop sleep",
-	window: "traffic reaches a container that its liveness probe kills",
-	expr: {
-		lhs: { terms: [{
-			knob: "readiness_detection_window",
-			coef: 1,
-			at: "pod"
-		}, {
-			knob: "propagation_bound",
-			coef: 1,
-			at: "cluster"
-		}] },
-		op: "<=",
-		rhs: { terms: [{
-			knob: "liveness_detection_window",
-			coef: 1,
-			at: "pod"
-		}, {
-			knob: "prestop_sleep",
-			coef: 1,
-			at: "pod"
-		}] }
-	}
-};
-/** O10: the preStop sleep plus the drain of the process fits in the grace period. */
-const O10 = {
-	id: "O10",
-	rule: "the preStop sleep plus the shutdown of the process fits in the grace period",
-	window: "work in flight at SIGKILL is cut, and each connection closes at once",
-	expr: {
-		lhs: { terms: [{
-			knob: "prestop_sleep",
-			coef: 1,
-			at: "pod"
-		}, {
-			knob: "process_drain_time",
-			coef: 1,
-			at: "process"
-		}] },
-		op: "<=",
-		rhs: { terms: [{
-			knob: "termination_grace",
-			coef: 1,
-			at: "pod"
-		}] }
-	}
-};
-/** O16: the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep. */
-const O16 = {
-	id: "O16",
-	rule: "the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep",
-	window: "handlers are cut before they answer, or the drain itself gets SIGKILL",
-	expr: {
-		lhs: { terms: [{
-			knob: "cooperative_window",
-			coef: 1,
-			at: "process"
-		}] },
-		op: "<",
-		rhs: { terms: [{
-			knob: "process_drain_time",
-			coef: 1,
-			at: "process"
-		}] }
-	},
-	expr_more: [{
-		lhs: { terms: [{
-			knob: "process_drain_time",
-			coef: 1,
-			at: "process"
-		}] },
-		op: "<",
-		rhs: { terms: [{
-			knob: "termination_grace",
-			coef: 1,
-			at: "pod"
-		}, {
-			knob: "prestop_sleep",
-			coef: -1,
-			at: "pod"
-		}] }
-	}]
-};
-/** These are the rules of the drain. A kind cell gets the rules that guard the way that its plan stops a pod. */
-const DRAIN_RULES = [
-	O04,
-	O09,
-	O10,
-	O16
-];
 const seconds$1 = (amount) => valueIn(amount, "s");
 const s = (value) => ({
 	value,
@@ -2835,7 +2712,7 @@ const stopOf = (cell) => {
 const lintCell = (description, cell, propagation) => {
 	const way = stopOf(cell);
 	const scenario = scenarioOf(cell, propagation);
-	return way === null ? lint(description, scenario, DRAIN_RULES) : lintStop(description, scenario, DRAIN_RULES, way);
+	return way === null ? lint(description, scenario, DRAIN_RULES$1) : lintStop(description, scenario, DRAIN_RULES$1, way);
 };
 /** This function gives the verdict of each drain rule, by its identifier. */
 const verdictsOf = (findings) => Object.fromEntries(findings.map((finding) => [finding.rule, finding.verdict]));