@mark1russell7/harness 0.11.23 → 0.11.24

package/README.md

@@ -250,7 +250,8 @@ ioredis sets the keepalive of its socket itself, after it connects. Thus a cell
 - **A close of the server** (`server-close`) makes the server close the connection of each client, with `Target.close`: `CLIENT KILL` for Redis.
 - **A stall of the application** (`app-stall`) injects nothing. The server process holds the reply, because the request asks for it (`HttpProbe.hold`), and its kernel stays up.
 - **An event at a proxy** (`hop-event`, `Cell.event`) is a signal to the program of the proxy, or a query on its console. Examples are a reload of the configuration, a stop of a proxy and PAUSE on the console of PgBouncer.
-  - A signal goes to each process of `ProxyHop.program`: HUP, TERM or INT (`HopSignal`). A sidecar in the network and process namespaces of the proxy sends it (`inject signal NAME HUP`). The lab starts that sidecar at the first signal.
+  - A signal goes to each process of `ProxyHop.program`: HUP, TERM, INT, STOP or CONT (`HopSignal`). A sidecar in the network and process namespaces of the proxy sends it (`inject signal NAME HUP`). The lab starts that sidecar at the first signal.
+  - STOP blocks the event loop of the proxy: its processes stop, and its kernel keeps each socket. With a hold (`Cell.hold`), CONT thaws it at that time after the stop, from inside the VM (`--at`). The lift thaws a proxy that its hold did not thaw.
   - A query goes from the injector of the proxy to its console on 127.0.0.1, as a user that the console trusts (`inject query`). The injector speaks the simple query of the PostgreSQL protocol. Its stamps bracket the query and its ReadyForQuery. After the run, the harness sends the `undo` of the query, for example RESUME after PAUSE.
   - Without `inFlight`, the event comes first, and the request meets it. With `inFlight`, the request goes first, and the event comes while it is in flight. A run whose order is not that order is void.
 - **A fault on a group** acts on the part that `Cell.faultAt` names by its role:

package/build/{cell-Dn1TvJcA.d.ts → cell-wInJC-GH.d.ts}

@@ -130,8 +130,12 @@ interface ProxyHop {
 /**
  * A signal of a hop event. HUP reloads the configuration of a pooler. TERM stops a proxy, as a stop of
  * its container does. INT stops docker-proxy, as Docker does when it removes a port binding.
+ *
+ * STOP blocks the event loop of a proxy: its processes stop, and its kernel keeps each socket. Thus
+ * ACKs go on, and the data of each peer waits in its receive queue. With the hold of the cell
+ * (`Cell.hold`), CONT thaws it at the end of the hold, from inside the VM.
  */
-type HopSignal = "HUP" | "TERM" | "INT";
+type HopSignal = "HUP" | "TERM" | "INT" | "STOP" | "CONT";
 /**
  * An event at a proxy hop (`hop-event`). A signal goes to each process of the program of the hop
  * (`ProxyHop.program`). A query goes to the console of the hop from its own namespace, as a user
@@ -1128,4 +1132,4 @@ interface RunTopology {
 }
 //#endregion
 export { Subject as $, Prediction as A, RequestPrediction as B, KernelRecord as C, MiddleboxForm as D, MiddleboxExpectation as E, Recovers as F, RunPart as G, RttRange as H, Reference as I, SentinelStage as J, RunTopology as K, ReplicaSet as L, ProxyHop as M, ProxyTime as N, Observer as O, Reconnects as P, StageBand as Q, ReplicaSetStage as R, ImageSource as S, MiddleboxEvent as T, Run as U, RouterHop as V, RunGroup as W, ShippedImage as X, Shipped as Y, Stage as Z, Hop as _, Cluster as a, latestEndOf as at, HopSignal as b, DriverBand as c, FaultPlace as d, Target as et, Group as f, HarnessImage as g, GroupRole as h, ClientImage as i, isHopPlace as it, ProbeEvent as j, PinnedImage as k, DriverStep as l, GroupPrediction as m, Cell as n, Toxic as nt, ClusterClientAt as o, GroupPlace as p, SentinelEvent as q, Client as r, WsProbe as rt, ClusterStage as s, BuildImage as t, Topology as tt, Fault as u, HopEvent as v, LineMatch as w, HttpProbe as x, HopPlace as y, Replies as z };
-//# sourceMappingURL=cell-Dn1TvJcA.d.ts.map
+//# sourceMappingURL=cell-wInJC-GH.d.ts.map

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as Subject, A as Prediction, B as RequestPrediction, C as KernelRecord, D as MiddleboxForm, E as MiddleboxExpectation, F as Recovers, G as RunPart, H as RttRange, I as Reference, J as SentinelStage, K as RunTopology, L as ReplicaSet, M as ProxyHop, N as ProxyTime, O as Observer, P as Reconnects, Q as StageBand, R as ReplicaSetStage, S as ImageSource, T as MiddleboxEvent, U as Run, V as RouterHop, W as RunGroup, X as ShippedImage, Y as Shipped, Z as Stage, _ as Hop, a as Cluster, at as latestEndOf, b as HopSignal, c as DriverBand, d as FaultPlace, et as Target, f as Group, g as HarnessImage, h as GroupRole, i as ClientImage, it as isHopPlace, j as ProbeEvent, k as PinnedImage, l as DriverStep, m as GroupPrediction, n as Cell, nt as Toxic, o as ClusterClientAt, p as GroupPlace, q as SentinelEvent, r as Client, rt as WsProbe, s as ClusterStage, t as BuildImage, tt as Topology, u as Fault, v as HopEvent, w as LineMatch, x as HttpProbe, y as HopPlace, z as Replies } from "./cell-Dn1TvJcA.js";
+import { $ as Subject, A as Prediction, B as RequestPrediction, C as KernelRecord, D as MiddleboxForm, E as MiddleboxExpectation, F as Recovers, G as RunPart, H as RttRange, I as Reference, J as SentinelStage, K as RunTopology, L as ReplicaSet, M as ProxyHop, N as ProxyTime, O as Observer, P as Reconnects, Q as StageBand, R as ReplicaSetStage, S as ImageSource, T as MiddleboxEvent, U as Run, V as RouterHop, W as RunGroup, X as ShippedImage, Y as Shipped, Z as Stage, _ as Hop, a as Cluster, at as latestEndOf, b as HopSignal, c as DriverBand, d as FaultPlace, et as Target, f as Group, g as HarnessImage, h as GroupRole, i as ClientImage, it as isHopPlace, j as ProbeEvent, k as PinnedImage, l as DriverStep, m as GroupPrediction, n as Cell, nt as Toxic, o as ClusterClientAt, p as GroupPlace, q as SentinelEvent, r as Client, rt as WsProbe, s as ClusterStage, t as BuildImage, tt as Topology, u as Fault, v as HopEvent, w as LineMatch, x as HttpProbe, y as HopPlace, z as Replies } from "./cell-wInJC-GH.js";
 import { Quantity } from "@mark1russell7/quantity";
 import "testcontainers";
 //#region src/application.d.ts
@@ -941,9 +941,10 @@ interface Lab {
    * This method applies an event at a proxy hop (`HopEvent`), or its undo. A signal goes from a
    * sidecar in the network and process namespaces of the hop. The lab starts that sidecar at the
    * first signal of the hop. A query goes from the injector of the hop to its console on 127.0.0.1. The
-   * injector stamps each one. An event with no undo gives null for its undo.
+   * injector stamps each one. An event with no undo gives null for its undo. A signal can wait for an
+   * instant on CLOCK_MONOTONIC (`at`), as the thaw at the end of a hold does.
    */
-  event(event: HopEvent, undo?: boolean): Promise<{
+  event(event: HopEvent, undo?: boolean, at?: number): Promise<{
     t0: number;
     t1: number;
   } | null>;

package/build/index.js

@@ -2803,7 +2803,7 @@ const openLab = async (target, kind = "tcp", topology) => {
 					...when
 				]);
 			},
-			async event(event, undo = false) {
+			async event(event, undo = false, at) {
 				const hop = hopNamed(event.hop);
 				if (hop.hop.kind !== "proxy") throw new Error(`the hop ${event.hop} is a router: an event goes to a proxy`);
 				if ("signal" in event) {
@@ -2816,11 +2816,13 @@ const openLab = async (target, kind = "tcp", topology) => {
 						hopSignallers.set(event.hop, sidecar);
 						opened.push(sidecar);
 					}
+					const when = at === void 0 ? [] : ["--at", String(Math.round(at))];
 					return stamped(sidecar, [
 						"/opt/harness/inject",
 						"signal",
 						program,
-						event.signal
+						event.signal,
+						...when
 					]);
 				}
 				const query = undo ? event.console.undo : event.console.query;
@@ -5324,9 +5326,23 @@ const once = async (lab, cell, environment, index, dry = false) => {
 					case "server-close":
 						await lab.serverClose();
 						return null;
-					case "hop-event":
+					case "hop-event": {
 						if (cell.event === void 0) throw new Error(`${cell.name} names no event`);
-						return lab.event(cell.event);
+						const stamp = await lab.event(cell.event);
+						if ("signal" in cell.event && cell.event.signal === "STOP" && cell.hold !== void 0 && stamp !== null) {
+							const thaw = {
+								hop: cell.event.hop,
+								signal: "CONT"
+							};
+							thawing = lab.event(thaw, false, stamp.t0 + valueIn(cell.hold, "s") * 1e9).then((thawed) => {
+								if (thawed === null) throw new Error(`the hop ${thaw.hop} gave no stamp for CONT`);
+								heal = thawed;
+								return thawed;
+							});
+							thawing.catch(() => void 0);
+						}
+						return stamp;
+					}
 					default: return lab.fault("blackhole", faultAt);
 				}
 			};
@@ -5346,6 +5362,15 @@ const once = async (lab, cell, environment, index, dry = false) => {
 					case "app-stall":
 					case "none": return;
 					case "hop-event":
+						if (cell.event !== void 0 && "signal" in cell.event && cell.event.signal === "STOP") {
+							const thaw = {
+								hop: cell.event.hop,
+								signal: "CONT"
+							};
+							if (thawing !== null) await thawing.catch(() => lab.event(thaw));
+							else await lab.event(thaw);
+							return;
+						}
 						if (cell.event !== void 0) await lab.event(cell.event, true);
 						return;
 					case "unreachable": return lab.lift("reject", faultAt, { code: cell.icmp ?? "host" });