@mark1russell7/harness 0.12.3 → 0.13.0

package/build/index.js

@@ -35,6 +35,37 @@ const INJECT = NOISE;
 /** This function gives the δ_abs of a cell: its own, or `NOISE` for a cell that gives none. */
 const noiseOf = (cell) => cell.noise ?? NOISE;
 /**
+* This function gives the pairing window of a run (SYS-25). On a runner of GitHub, the jitter of
+* a program can be longer than the δ_abs of 1 ms. Thus each run measures it before its fault
+* (`Run.jitter`), and its own measurement widens its window. A run without a jitter record is
+* from before SYS-25. It reads as a bound of null, thus its window is δ_abs. The decision of
+* 2026-10-19 keeps the rule of one miss: a pair that a window misses is still a finding.
+*/
+const pairingOf = (cell, run) => {
+	const noise = noiseOf(cell);
+	const bound = run.jitter?.bound ?? null;
+	return {
+		bound,
+		delta: bound !== null && valueIn(bound, "s") > valueIn(noise, "s") ? bound : noise
+	};
+};
+/**
+* This function sums the pairings of the measurements of a cell. It gives the longest bound and
+* the longest window. It also counts the pairings whose window is longer than δ_abs (`noise`). It
+* is null when no measurement has a pairing.
+*/
+const pairingsOf = (runs, noise = NOISE) => {
+	const pairings = runs.flatMap((run) => run.pairing === void 0 ? [] : [run.pairing]);
+	if (pairings.length === 0) return null;
+	const longest = (values) => values.reduce((most, each) => valueIn(each, "s") > valueIn(most, "s") ? each : most);
+	const bounds = pairings.flatMap((pairing) => pairing.bound === null ? [] : [pairing.bound]);
+	return {
+		bound: bounds.length === 0 ? null : longest(bounds),
+		delta: longest(pairings.map((pairing) => pairing.delta)),
+		widened: pairings.filter((pairing) => valueIn(pairing.delta, "s") > valueIn(noise, "s")).length
+	};
+};
+/**
 * This function tells if a timer firing came late enough to void a run. A firing two jiffies or
 * more behind its wheel slot came late because the host stopped a vCPU. With the HZ of the run,
 * the rule is in time: the delay must also reach δ_abs, because each band already includes that
@@ -483,12 +514,12 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 *   These are the runs 39390222333 and 39903020657 of the client repository.
 *
 * The bound is 1.5 ms: the maximum and a margin of 0.48 ms. The pairing of a drop with its act
-* uses it, or δ_abs when δ_abs is longer. The band of a drop adds it to its high bound (the WS
-* catalog of the cells). Read the records again after a change to the subject, to Node or to
+* uses it, or the pairing window of the run when that window is longer. The band of a drop adds
+* it to its high bound (the WS catalog of the cells). Read the records again after a change to the subject, to Node or to
 * the runners.
 */
 const DROP_HANDLING = quantity(1.5, "ms");
-/** This function gives the window of the act of a drop after its line, in seconds: `DROP_HANDLING`, or δ_abs when δ_abs is longer. */
+/** This function gives the window of the act of a drop, in seconds: `DROP_HANDLING`, or the pairing window (`delta`) when it is longer. */
 const dropWindow = (delta) => Math.max(valueIn(DROP_HANDLING, "s"), valueIn(delta, "s"));
 /** This function gives the interval between two instants on the one clock, in seconds to the microsecond. */
 const between$3 = (from, to) => quantity(Math.round((to - from) / 1e3) / 1e6, "s");
@@ -563,9 +594,9 @@ const closeOrExit = (line, left, exit, delta = NOISE) => {
 };
 /**
 * This function tells how a drop differs from the way that its prediction gives, or gives null.
-* A close closes the socket at once: in the handling time of the program (`DROP_HANDLING`), or in
-* δ_abs (`delta`) when δ_abs is longer. A close frame is a write, and the program does not close
-* the socket at the drop. A peer that answers the close frame can close it, and that is no finding.
+* A close closes the socket at once, in the handling time of the program (`DROP_HANDLING`). If
+* the pairing window of the run (`delta`) is longer, that window is the limit. A close frame is a
+* write, and the program does not close the socket at the drop. A peer that answers the close frame can close it, and that is no finding.
 */
 const dropFinding = (expected, drop, left, delta = NOISE, exited) => {
 	const noise = dropWindow(delta);
@@ -578,7 +609,25 @@ const dropFinding = (expected, drop, left, delta = NOISE, exited) => {
 	return soon ? "the program closed its socket at the drop, where a close frame leaves it open" : null;
 };
 const isWrite = (record) => record.ev === "tx";
-/** This function gives each ping of the program on the connection of the run, with the kernel's stamp of its write. */
+/**
+* This function measures the jitter of a program from its acts before `until`, the start of the
+* fault. An act is a `write` line or a `ping` line on the connection. Its delay goes from the line
+* to the first write of data on the socket after it, before the next act and before `until`. An
+* act with no such write does not count. The bound is the longest delay, to the microsecond.
+*/
+const jitterOfLines = (lines, socket, local, until) => {
+	const acts = lines.filter((line) => (line.ev === "write" || line.ev === "ping") && line.t < until && onConnection(line, local));
+	const delays = acts.flatMap((line, at) => {
+		const next = Math.min(acts[at + 1]?.t ?? until, until);
+		const write = socket.find((record) => isWrite(record) && (record.seg?.len.value ?? 0) > 0 && record.mono >= line.t && record.mono < next);
+		return write === void 0 ? [] : [write.mono - line.t];
+	});
+	return {
+		acts: delays.length,
+		bound: delays.length === 0 ? null : quantity(Math.round(Math.max(...delays) / 1e3) / 1e3, "ms")
+	};
+};
+/** This function gives each ping of the program on the connection, with the kernel's stamp of its write in the pairing window (`delta`). */
 const pingsOf = (lines, socket, local, delta = NOISE) => lines.filter((line) => line.ev === "ping" && onConnection(line, local)).map((line) => eventOf(socket, line, isWrite, delta));
 /**
 * This function gives the first ping that got no answer: no segment with data reached the socket
@@ -589,7 +638,7 @@ const firstUnanswered = (pings, socket, until = Number.POSITIVE_INFINITY) => pin
 * This function gives the first drop of the connection by its program. The kernel stamps it as the
 * write of a close frame. Or it stamps the change of the socket out of ESTABLISHED: a close or an
 * abort. That stamp comes in the handling time of the program after the drop line
-* (`DROP_HANDLING`), or in δ_abs (`delta`) when δ_abs is longer.
+* (`DROP_HANDLING`). If the pairing window of the run (`delta`) is longer, that window is the limit.
 */
 const dropOf = (lines, socket, local, delta = NOISE) => {
 	const line = lines.find((each) => each.ev === "drop" && onConnection(each, local));
@@ -1680,7 +1729,11 @@ const crossingsOf = (run, hop, toClient, toTarget) => {
 *   than the one that the prediction gives is a finding.
 */
 const measure = (cell, run) => {
-	const read = measureSocket(cell, run);
+	const socketRead = measureSocket(cell, run);
+	const read = run.jitter === void 0 ? socketRead : {
+		...socketRead,
+		pairing: pairingOf(cell, run)
+	};
 	const expected = cell.prediction.request;
 	if (cell.probe.http === void 0 && expected === void 0) return read;
 	const request = requestOf(run.events);
@@ -1696,6 +1749,24 @@ const measure = (cell, run) => {
 		finding
 	};
 };
+/**
+* This function measures the jitter of the program of the observer in a run, from its records
+* (`Jitter`). The acts count up to the start of the fault, or up to the reply of the client when
+* the fault has no stamp. A run with no lines of a program, or no socket of the observer, has no act.
+*/
+const jitterOf = (cell, run) => {
+	const lines = programLines(cell, run);
+	const ready = run.events.find((event) => event.ev === "ready");
+	const place = lines.length === 0 || ready === void 0 ? void 0 : socketOf(cell, run);
+	if (ready === void 0 || place === void 0) return {
+		acts: 0,
+		bound: null
+	};
+	const socket = run.kernel.filter((record) => record.netns === place.netns && record.cookie === place.cookie);
+	const local = run.events.find((event) => event.ev === "connected")?.["local"];
+	const named = cell.observer === "server" ? socket.find((record) => record.dst !== void 0)?.dst ?? local : local;
+	return jitterOfLines(lines, socket, named, run.fault?.t0 ?? ready.t);
+};
 /** This function tells how a request reading differs from its prediction, or gives null. */
 const requestFinding = (expected, read) => {
 	if (read === null) return `the second request never went out, where it should meet: ${requestWords(expected)}`;
@@ -1847,7 +1918,8 @@ const measureSocket = (cell, run) => {
 	const lines = programLines(cell, run);
 	const named = server ? socket.find((record) => record.dst !== void 0)?.dst ?? local : local;
 	const kernelEnded = reported?.mono ?? closeWait?.mono ?? own?.mono ?? seen?.t;
-	const first = dropOf(lines, socket, named, noiseOf(cell));
+	const paired = pairingOf(cell, run).delta;
+	const first = dropOf(lines, socket, named, paired);
 	const drop = first !== void 0 && (kernelEnded === void 0 || first.at <= kernelEnded) ? first : void 0;
 	const dropped = drop !== void 0;
 	const outcome = dropped ? { kind: "dropped" } : reported !== void 0 ? {
@@ -1860,7 +1932,7 @@ const measureSocket = (cell, run) => {
 	const ended = drop?.at ?? kernelEnded;
 	const noticed = reported !== void 0 && seen !== void 0 && !dropped ? between(reported.mono, seen.t) : null;
 	const { prediction } = cell;
-	const pings = pingsOf(lines, socket, named, noiseOf(cell));
+	const pings = pingsOf(lines, socket, named, paired);
 	const before = run.fault?.t1 ?? ready.t;
 	const referenceAt = (from) => {
 		if (from === "request-sent") return request.t;
@@ -2052,7 +2124,7 @@ const measureSocket = (cell, run) => {
 		left: closed,
 		exited: void 0
 	} : closeOrExit(drop.line, closed, exitOf(run, cookie), noiseOf(cell));
-	const how = prediction.drop === void 0 || drop === void 0 || left === void 0 ? null : dropFinding(prediction.drop, drop, left, noiseOf(cell), exited);
+	const how = prediction.drop === void 0 || drop === void 0 || left === void 0 ? null : dropFinding(prediction.drop, drop, left, paired, exited);
 	const found = [
 		matches ? null : `it ended with ${words}, not ${prediction.errno}`,
 		late,
@@ -3048,15 +3120,19 @@ const sentinelConfig = (group, primary) => [
 ].join("\n");
 /**
 * This function gives the peers that a fault on a part cuts it from, by their addresses. `all` is
-* each other part and the client, `group` is the other parts, and `clients` is the client. The
-* observer is not a peer, thus the timeline of the group stays whole.
+* each other part and the client, `group` is the other parts, and `clients` is the client. `one`
+* and `one-way` are the first other member. The observer is not a peer, thus the timeline of the
+* group stays whole.
 */
 const peersOf = (parts, client, part, cuts) => {
 	const others = [...Object.entries(parts.members), ...Object.entries(parts.sentinels)].filter(([name]) => name !== part).map(([, at]) => at.ip);
 	if (cuts === "clients") return [client];
 	if (cuts === "group") return others;
+	if (cuts === "one" || cuts === "one-way") return Object.entries(parts.members).filter(([name]) => name !== part).slice(0, 1).map(([, at]) => at.ip);
 	return [...others, client];
 };
+/** This function gives the direction of the rules of a cut: `one-way` drops only the segments from the part. */
+const directionOf = (cuts) => cuts === "one-way" ? ["--direction", "out"] : [];
 /** This function reads the flat reply of a command line client into its fields: name, value, name, value. */
 const fieldsOf = (text) => {
 	const out = [];
@@ -3391,6 +3467,7 @@ const openGroupLab = async (group, options = {}) => {
 					"/opt/harness/inject",
 					kind,
 					peers,
+					...directionOf(cuts),
 					...after(at)
 				]);
 			},
@@ -3400,6 +3477,7 @@ const openGroupLab = async (group, options = {}) => {
 					"/opt/harness/inject",
 					kind === "rst" ? "clear-rst" : "clear",
 					peers,
+					...directionOf(cuts),
 					...after(at)
 				]);
 			},
@@ -5575,14 +5653,18 @@ const inEnvironment = async (cell, environment, count, say) => {
 		if (latency !== null) await lab.netem(latency, "target");
 		await lab.warm();
 		const manifest = await lab.manifest(await lab.sysctl(cell.sysctls), settings, targetSysctls);
+		const timed = (run) => ({
+			...run,
+			jitter: jitterOf(cell, run)
+		});
 		const warmup = {
-			...await once(lab, cell, environment, -1, endsEnvironment(cell)),
+			...timed(await once(lab, cell, environment, -1, endsEnvironment(cell))),
 			warmup: true
 		};
 		say(line(cell, warmup, measure(cell, warmup)));
 		const runs = [];
 		for (let index = 0; index < count; index += 1) {
-			const run = await once(lab, cell, environment, index);
+			const run = timed(await once(lab, cell, environment, index));
 			runs.push(run);
 			say(line(cell, run, measure(cell, run)));
 		}
@@ -5734,6 +5816,6 @@ const runCell = async (cell, say = () => {}) => {
 	}
 };
 //#endregion
-export { CLIENT_NAMES, CLUSTER_STAGES, CONVERGE_MS, DROP_HANDLING, GIVES_AWAY, INJECT, KEPT, LINGER_MS, LISTING, MEMBER_MARKS, MONITOR_DOWN, NODE_MARKS, NOISE, PINNED, PUMP, PUMP_SLACK, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, REPOSITORY, SHIPPED_CLIENTS, SHIPPED_NAMES, STAGES, STATUS_SCRIPT, STEPS, STEP_DOWN, amqpClientImage, callOf, clockOffsetOf, closeOrExit, clusterArgs, clusterConf, clusterCutOf, clusterHostsOf, clusterOnce, clusterStagesOf, clusterViewOf, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, dropFinding, dropOf, endpointAfter, errorsOf, exitOf, fieldOf, fieldsOf, firstUnanswered, goHttpImage, groupOnce, groupVerdictOf, grpcClientImage, harnessImage, hikariClientImage, hzOf, imageOf, imageProblems, inContext, infoOf, initiateScript, isHopPlace, judge, lagsOf, latestEndOf, leftAfter, logNameOf, matches, measure, measureDriver, measureGroup, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, monotonicOf, nodeClientImage, nodeCommand, nodeHttpImage, nodeLineOf, nodeNameOf, nodesOnMonotonic, noiseOf, onMonotonic, openClusterLab, openGroupLab, openLab, openReplicaSetLab, peersOf, pgClientImage, pingsOf, plainOf, planOf, programLines, programOf, quantileOf, reconnectFinding, reconnectOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, restamped, routerImage, routesOf, runCell, sentinelConfig, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, statusViewOf, subjectClient, subjectProblems, subscriptionsOf, targetImageOf, targetSourceOf, templated, toolJsonOf, toxicBody, unlockedManifests, unpinnedBases, verdictOf, viewOf, writesOf };
+export { CLIENT_NAMES, CLUSTER_STAGES, CONVERGE_MS, DROP_HANDLING, GIVES_AWAY, INJECT, KEPT, LINGER_MS, LISTING, MEMBER_MARKS, MONITOR_DOWN, NODE_MARKS, NOISE, PINNED, PUMP, PUMP_SLACK, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, REPOSITORY, SHIPPED_CLIENTS, SHIPPED_NAMES, STAGES, STATUS_SCRIPT, STEPS, STEP_DOWN, amqpClientImage, callOf, clockOffsetOf, closeOrExit, clusterArgs, clusterConf, clusterCutOf, clusterHostsOf, clusterOnce, clusterStagesOf, clusterViewOf, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, dropFinding, dropOf, endpointAfter, errorsOf, exitOf, fieldOf, fieldsOf, firstUnanswered, goHttpImage, groupOnce, groupVerdictOf, grpcClientImage, harnessImage, hikariClientImage, hzOf, imageOf, imageProblems, inContext, infoOf, initiateScript, isHopPlace, jitterOf, jitterOfLines, judge, lagsOf, latestEndOf, leftAfter, logNameOf, matches, measure, measureDriver, measureGroup, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, monotonicOf, nodeClientImage, nodeCommand, nodeHttpImage, nodeLineOf, nodeNameOf, nodesOnMonotonic, noiseOf, onMonotonic, openClusterLab, openGroupLab, openLab, openReplicaSetLab, pairingOf, pairingsOf, peersOf, pgClientImage, pingsOf, plainOf, planOf, programLines, programOf, quantileOf, reconnectFinding, reconnectOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, restamped, routerImage, routesOf, runCell, sentinelConfig, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, statusViewOf, subjectClient, subjectProblems, subscriptionsOf, targetImageOf, targetSourceOf, templated, toolJsonOf, toxicBody, unlockedManifests, unpinnedBases, verdictOf, viewOf, writesOf };
 
 //# sourceMappingURL=index.js.map