@mark1russell7/harness 0.9.0 → 0.10.0

package/README.md

@@ -208,6 +208,7 @@ Each run starts from kernels that keep nothing from the run before it (`lab.forg
   - Each wait goes from a `reconnecting` line, where the program starts its timer, to its next `dial` line, where it makes the socket. A wait outside its band, widened by δ_abs, is a finding. A try that did not come is a finding too.
   - The kernel gives the time from the detection to the first SYN of a new socket (`syn`). It also gives the time to the first new socket in ESTABLISHED (`established`).
   - It also gives the time from each `dial` line to its SYN (`connects`): the work of the program before connect(2).
+  - A measurement-only prediction can give `reconnects` too. The end of its connection has no band, but each wait has one. A wait outside its band is a finding of its run, and the verdict names that run. The decision stays `measured`.
 - **A call in flight of a WebSocket client** (`callOf`). The run gives its error or its reply, and the time from the detection to its end.
 - **A stream.** In a stream (`probe.mode` is `stream`), the client sends `count` requests. The run keeps the time from each send to the last byte of its reply (`samples`). A record without `replied` lines gives the time to the first data.
 - **Reordering.** A measurement-only run also gives what reordering, duplicates and losses did (`reordering`). At the client, it counts the arrivals beyond a hole and the arrivals of data that it had already, against `rcv_nxt`. From the sender, it gives the most SACKed and lost segments, the DSACKs, the fast retransmissions, and the reordering degree and count of the kernel.

package/build/index.d.ts

@@ -426,7 +426,8 @@ interface Reconnects {
  * A cell whose outcome is a distribution, for example under netem loss, has no band. Its
  * prediction is `detects: null` with the reason, and its runs are measurements only. A
  * measurement-only cell that names a reference (`from`) also records the time from it to the end
- * of the connection, or to the last data.
+ * of the connection, or to the last data. It can also give the waits of the reconnect after that
+ * end (`reconnects`).
  *
  * For a group cell, the band is the first write that a primary accepts after the fault, and its
  * errno is `OK`. `group` tells which primary, and the stages of the group on the way.
@@ -491,6 +492,11 @@ type Prediction = {
   readonly ends?: "own-close";
   readonly group?: GroupPrediction;
   readonly request?: RequestPrediction;
+  /**
+   * These are the waits of the reconnect after the end of the connection, from the document of
+   * the client. The end has no band, but each wait has one. A wait outside its band is a finding of its run.
+   */
+  readonly reconnects?: Reconnects;
 };
 /** A target is the server that a cell connects to: a stock image. */
 interface Target {

package/build/index.js

@@ -329,13 +329,15 @@ const verdictOfBand = (prediction, runs, delta = NOISE) => {
 			}
 			const outcomes = [...kinds].map(([kind, n]) => `${n} ${kind}`).join(", ");
 			const timed = times.length === 0 ? "no time" : `median ${s(middle(times)).value} s from ${prediction.from}, range [${s(times[0]).value}, ${s(times.at(-1)).value}] s`;
+			const missed = outside.filter((each) => counted.some((run) => name(run) === each.run && run.reconnect !== void 0));
+			const late = missed.length === 0 ? "" : ` ${missed.length} runs had a wait of the reconnect outside its band.`;
 			return {
 				...empty,
 				decision: "measured",
 				band: null,
-				outside: [],
+				outside: missed,
 				median: times.length === 0 ? null : s(middle(times)),
-				why: `${counted.length} runs measured: ${outcomes}; ${timed}. ${prediction.why}`
+				why: `${counted.length} runs measured: ${outcomes}; ${timed}.${late} ${prediction.why}`
 			};
 		}
 		const samples = counted.flatMap((run) => (run.samples ?? []).map((sample) => valueIn(sample, "s"))).sort((a, b) => a - b);
@@ -1674,10 +1676,14 @@ const measureSocket = (cell, run) => {
 				toward: "target"
 			}
 		}, run)) };
+		const reconnect = prediction.reconnects === void 0 || ended === void 0 ? void 0 : reconnectOf(run, ended, cookie, drop?.line.t ?? ended);
+		const late = reconnect === void 0 || prediction.reconnects === void 0 ? null : reconnectFinding(prediction.reconnects, reconnect, noiseOf(cell));
 		return {
 			...base,
 			...nothing,
 			...chain,
+			...reconnect === void 0 ? {} : { reconnect },
+			finding: late,
 			outcome: ended !== void 0 ? outcome : { kind: "answered" },
 			...from === void 0 || until === void 0 ? {} : { elapsed: between(from, until) },
 			noticed: prediction.from === void 0 ? null : noticed,
@@ -4154,7 +4160,7 @@ const probeArgs = (cell, lab) => {
 	];
 	if (probe.ws !== void 0) {
 		const { ws } = probe;
-		const waits = (prediction.detects === true ? prediction.reconnects?.waits ?? [] : []).reduce((sum, wait) => sum + valueIn(wait.high, "s"), 0);
+		const waits = (prediction.detects !== false ? prediction.reconnects?.waits ?? [] : []).reduce((sum, wait) => sum + valueIn(wait.high, "s"), 0);
 		args.push("--websocket", ws.socket);
 		args.push("--heartbeat", ws.heartbeat === null ? "off" : "on");
 		if (ws.heartbeat !== null) args.push("--heartbeat-interval-ms", String(valueIn(ws.heartbeat.interval, "ms")), "--heartbeat-timeout-ms", String(valueIn(ws.heartbeat.timeout, "ms")), "--heartbeat-misses", String(ws.heartbeat.misses));
@@ -4531,7 +4537,7 @@ const once = async (lab, cell, environment, index, dry = false) => {
 				if (toxicFirst) await lab.toxic(null);
 			}
 			if (cell.fault === "freeze-process" && !server && cell.probe.mode !== "idle") await probe.until(["data"], 5e3).catch(() => void 0);
-			const expected = cell.prediction.detects === true ? cell.prediction.reconnects : void 0;
+			const expected = cell.prediction.detects !== false ? cell.prediction.reconnects : void 0;
 			if (expected !== void 0) {
 				const waits = expected.waits.reduce((sum, wait) => sum + valueIn(wait.high, "s"), 0);
 				await dials(probe, 1 + expected.waits.length, waits * 2e3 + 5e3);