@mark1russell7/harness 0.14.4 → 0.15.0

package/README.md

@@ -206,6 +206,7 @@ From 0.11.20, the harness builds each image with the CLI of Docker (`docker buil
   - the kernel program of the prober, compiled against the BTF of the kernel that builds it, and its Rust collector.
   - `client`, the TCP client of a cell. Rust's `std::net` sets no socket option by itself, thus the measurement gets the timers of the namespace. The client also samples `TCP_INFO` each 2 ms, a second vantage on its socket. It waits in `poll()`, which does not lock the socket. A keepalive timer that finds its socket held tries again HZ/20 later.
   - In a stream, a reply of the `client` is whole at its CRLF, or after the length of a bulk string. The client then writes a `replied` line.
+  - `load`, the open-loop driver of an HTTP/1.1 server (SYS-93). Its plan (`systems-load/1`) is a list of streams, each with a key, a schedule (`rigor-schedule/1`) and its requests. Each stream has its own connection, thus a slow reply delays only its own stream. A send does not wait for a reply. A response is whole after its `Content-Length` or its last chunk. The `sent` and `replied` lines name the stream (`k`) and the arrival (`i`), and a `replied` line names the status.
   - `inject`, which applies a fault in one `iptables-restore` commit, with monotonic stamps around the commit. Thus the start of a fault is known in the VM. A `docker exec` from Windows comes 190 ms late at the median. With `--via DEV`, the rules go in the FORWARD chain, on the device toward one side.
   - `inject` also sends a signal to a process by its name (`signal`), and one command to a server of the Redis protocol (`resp`). Stamps bracket each.
 - **The Node client image** (`image/node`) is a driver client: ioredis 6.0.0 on Node 24.21.0. The digest of the image and an npm lockfile pin them. `client-ioredis.mjs` prints the lines of the TCP client on the same clock, and it adds the status changes of ioredis as `status` lines. The same image holds the client of a group in Sentinel mode (`client-sentinel.mjs`) and the observer of its Sentinels (`observer.mjs`).

package/build/{cell-DZm8zXN4.d.ts → cell-biffSiEJ.d.ts}

@@ -1,4 +1,5 @@
 import { Quantity } from "@mark1russell7/quantity";
+import { Profile, Schedule, ScheduleOptions } from "@mark1russell7/rigor-chaos";
 import { KernelRecord } from "@mark1russell7/prober";
 //#region src/cell.d.ts
 /**
@@ -360,6 +361,57 @@ interface Kafka {
   readonly minInsync: number;
   /** This count is the number of writers of the client, each with one write at a time. */
   readonly writers: number;
+  /** This record makes each run a run of two members of a consumer group, with one member stopped. Without it, the client is a producer. */
+  readonly pause?: KafkaPause;
+}
+/**
+ * A Kafka pause is one run of two members of a consumer group, on a topic with two partitions. The
+ * fault stops the process of the first member while it holds a batch, and the hold of the cell ends
+ * that stop. Each setting of a member comes from `Cell.driverOptions`.
+ */
+interface KafkaPause {
+  /** This name is the protocol of the group: the broker keeps the session under `consumer`, and the client sets it under `classic`. */
+  readonly protocol: "consumer" | "classic";
+  /** This time is how long the first member holds each batch before it commits. */
+  readonly process: Quantity;
+  /** This choice is what the first member does after the stop. It commits at once, or it polls until it has a new epoch and then commits. */
+  readonly afterPause: "commit" | "rejoin";
+  /** This count is the number of records in each partition before the members start. */
+  readonly fill: number;
+  /** This time is from the start of the processing of a batch to the stop. */
+  readonly stopAfter: Quantity;
+}
+/** A pause band is the band of one time of a paused consumer, from the stop. */
+interface PauseBand {
+  readonly low: Quantity;
+  readonly high: Quantity;
+}
+/**
+ * A pause prediction is the law of a paused consumer. A null fence tells that the stop is too short.
+ * The group then does not fence the member, and the other member does not get its partition.
+ */
+interface PausePrediction {
+  readonly fence: PauseBand | null;
+  /** This band is the first report of the partition by the other member. Null tells that this cell has no band for it. */
+  readonly takeover: PauseBand | null;
+  /**
+   * This choice is the result of the commit after the stop:
+   * - `fails`: a commit before any poll fails with `CommitFailedException`.
+   * - `acknowledged`: the commit succeeds, and the epoch of the member does not change.
+   * - `rejoin`: the member gets a new epoch, the same commit succeeds, and the committed offset moves back.
+   */
+  readonly thaw: "fails" | "acknowledged" | "rejoin";
+  /** This time bounds the new epoch of `rejoin`, from the end of the stop. */
+  readonly rejoinWithin?: Quantity;
+}
+/** A run pause is what a run of a paused consumer records beyond the lines of the stopped member. */
+interface RunPause {
+  /** These are the lines of the other member. */
+  readonly other: readonly ProbeEvent[];
+  /** These are the log lines of the brokers that tell that a member left this group. */
+  readonly fences: readonly string[];
+  /** This name is the group of the run. */
+  readonly group: string;
 }
 /**
  * A cluster stage is one step of the timeline of a cluster after a fault. A line of the log of a
@@ -789,6 +841,15 @@ type Prediction = {
    * when a held port comes back. A value outside it is a finding of its run.
    */
   readonly ports?: PortsPrediction;
+  /**
+   * This record is the law of a conntrack table: its flows, a connect that finds no entry, and the
+   * return of a slot. A value outside it is a finding of its run.
+   */
+  readonly conntrack?: ConntrackPrediction;
+  /** This record is the law of a paused consumer (`Kafka.pause`). A run outside it is a finding of its run. */
+  readonly pause?: PausePrediction;
+  /** These are the limits of an open-loop cell (`Cell.probe.plan`). Without them, its load is a measurement. */
+  readonly load?: LoadPrediction;
 };
 /** A queue band is a time from one line of a queue cell to another line, with its two bounds. */
 interface QueueBand {
@@ -888,6 +949,90 @@ interface PortsPrediction {
   /** This count is the segments that the sockets of the client send again. */
   readonly retransmissions?: number;
 }
+/**
+ * This prediction is the law of a conntrack table. It reads the lines of the ctfull client. The client
+ * holds flows on its loopback until the count of its namespace reads the limit, then it does its plan.
+ */
+interface ConntrackPrediction {
+  /** This count is the limit of the table: the flows that the client holds, and the count that it reads then. */
+  readonly max: number;
+  /** This count is what the namespace of the target reads while the client holds its flows. */
+  readonly neighbor?: number;
+  /** This record is the law of a connect that finds no entry: its end, and the rise of the two counters of the kernel. */
+  readonly refused?: {
+    readonly within: QueueBand;
+    readonly errno: string;
+    readonly drops: number;
+    readonly retransFail: number;
+  };
+  /** This band is the time from the `closing` line to the first fall of the count, and to its zero. */
+  readonly drained?: QueueBand;
+  /**
+   * This record is the law of a scan under pressure. It has the lowest count, the count after the
+   * connect, and the times of that connect. With `highest`, the lowest count is a band from `lowest` to
+   * `highest`. Then the count after the connect is one more than the lowest count of the run.
+   */
+  readonly pressure?: {
+    readonly lowest: number;
+    readonly highest?: number;
+    readonly after: number;
+    readonly points: readonly QueueBand[];
+  };
+}
+/**
+ * This setting is one sysctl of the namespace of the host, for the time of an environment. The harness
+ * reads the value before it, reads the value that it set, and restores the first value at the end.
+ */
+interface HostSysctl {
+  readonly name: string;
+  readonly value: string;
+  /** The harness does not set the value when this sysctl of the host reads above `atMost`. The cell is then void. */
+  readonly guard?: {
+    readonly name: string;
+    readonly atMost: number;
+  };
+}
+/** A load plan is the schedule of an open-loop client as data: the rate over time, and how the arrivals fall. */
+interface LoadPlan {
+  readonly profile: Profile;
+  readonly options: ScheduleOptions;
+}
+/**
+ * A load stream is one connection of the client `load`: its key, its schedule and its requests.
+ * Arrival i sends request i modulo the count of requests. Each stream has its own connection, thus
+ * a slow stream does not delay the arrivals of another stream.
+ */
+interface LoadStream {
+  /** This text names the stream in each line of the client (`k`). Two streams of a cell do not have the same key. */
+  readonly key: string;
+  readonly plan: LoadPlan;
+  /** These texts are whole HTTP/1.1 requests, each with its head and its body. */
+  readonly requests: readonly string[];
+}
+/** A run stream is the schedule that one stream of the client `load` had in a run. */
+interface RunStream {
+  readonly key: string;
+  readonly schedule: Schedule;
+}
+/** A load band is a limit on one quantile of the latency of an open-loop cell, over the arrivals of its counted runs. */
+interface LoadBand {
+  /** This number is the quantile, from 0 to 1. */
+  readonly quantile: number;
+  readonly low?: Quantity;
+  readonly high: Quantity;
+}
+/** A load prediction tells how close to its schedule a client stays, and where the latency lands. */
+interface LoadPrediction {
+  /** This time is the largest lag of a send behind its planned time. A later send is a finding of its run. */
+  readonly lag: Quantity;
+  readonly bands: readonly LoadBand[];
+  /**
+   * This share is the limit on the failed arrivals of the counted runs, from 0 to 1. An arrival fails
+   * when the client did not send it, when it has no reply, or when its reply has the status of a
+   * failure. The verdict reads the Wilson interval at 0.95, thus a limit of 0.01 needs 381 arrivals.
+   */
+  readonly failures?: number;
+}
 /** A target is the server that a cell connects to: a stock image. */
 interface Target {
   /** This image is a stock image, pinned by digest. */
@@ -1003,7 +1148,7 @@ interface Subject {
  * (`http-agent`) and an HTTP/1.1 `Client` of undici (`undici`). The MongoDB driver is `mongodb`, node-postgres is `pg`, and HikariCP over pgjdbc is `hikari`.
  * The client of amqplib is `amqp`, and the client of grpc-js is `grpc`. The WebSocket client of `@procedures/client` is a program of its subject (`ClientImage`).
  */
-type Client = "tcp" | "ioredis" | "go-http" | "http-agent" | "undici" | "mongodb" | "pg" | "hikari" | "amqp" | "grpc";
+type Client = "tcp" | "ioredis" | "go-http" | "http-agent" | "undici" | "mongodb" | "pg" | "hikari" | "amqp" | "grpc" | "load";
 /**
  * A WebSocket probe is the workload and the settings of the WebSocket client of
  * `@procedures/client`, the `client` program of its subject. The cell gives each setting, thus the client takes
@@ -1071,7 +1216,15 @@ interface ClientImage {
   /** This image is a stock image by its name, pinned by digest, or the source of the image of a subject. */
   readonly image: string | ImageSource;
   readonly command: readonly string[];
+  /**
+   * These capabilities are added to the default set of the container of the client. A read of the
+   * statistics of conntrack over netlink needs NET_ADMIN in the namespace of the client.
+   */
+  readonly capabilities?: readonly ClientCapability[] | undefined;
 }
+/** These are the capabilities that a client image can get. */
+declare const CLIENT_CAPABILITIES: readonly ["NET_ADMIN"];
+type ClientCapability = (typeof CLIENT_CAPABILITIES)[number];
 /**
  * An observer is the side whose detection a cell measures. The client is one observer. The
  * server is another observer. It is the hold of the target on the connection of the client, at
@@ -1096,8 +1249,13 @@ interface Cell {
      * This mode tells if the client is idle after its first reply, or sends a request into the
      * fault. In a stream, it sends `count` requests into it, each `interval` after the reply before.
      * An HTTP client in a `gap` sends its second request a gap after its first reply, by itself.
+     * On a `schedule`, it sends each request at its time in `plan`, and a send does not wait for a reply.
      */
-    readonly mode: "idle" | "inflight" | "stream" | "gap";
+    readonly mode: "idle" | "inflight" | "stream" | "gap" | "schedule";
+    /** This plan is the schedule of the requests in the mode `schedule`. */
+    readonly plan?: LoadPlan;
+    /** These streams are the plan of the client `load` in the mode `schedule`, in place of `plan`. */
+    readonly streams?: readonly LoadStream[];
     /** This count is the number of requests of a stream. */
     readonly count?: number;
     /** This time is the pause after each reply of a stream, before the next request. */
@@ -1194,6 +1352,14 @@ interface Cell {
   readonly latency?: Quantity;
   /** These commands run in the target before a client connects, each as argv: for example, a large value to read. */
   readonly targetSetup?: readonly (readonly string[])[];
+  /** These commands run in the namespaces of the client and the target, each as argv, after the first connection of the environment. */
+  readonly namespaceSetup?: readonly (readonly string[])[];
+  /**
+   * These are sysctls of the host, which a cell needs because only the host can write them. The value
+   * applies to each container of the host, thus a shard runs them on its own runner. A host that does
+   * not have one makes the cell void (rule 8 of the environments).
+   */
+  readonly hostSysctls?: readonly HostSysctl[];
   readonly prediction: Prediction;
   /** This side is the side whose detection the cell measures. Without it, the side is the client. */
   readonly observer?: Observer;
@@ -1400,8 +1566,16 @@ interface Run {
   readonly group?: RunGroup;
   /** These are the lines of a target that writes them (`Target.lines`), from the start to the end of the run. */
   readonly server?: readonly ProbeEvent[];
+  /** This text tells what the environment of the run could not do for its cell. The run is void. */
+  readonly missing?: string;
+  /** This record is the other member and the broker logs of a run of a paused consumer. */
+  readonly pause?: RunPause;
   /** This record is the fabric of a cell with `Topology.fabric`. */
   readonly fabric?: RunFabric;
+  /** This schedule is the one that the client of an open-loop cell had: each planned time stays with its record. */
+  readonly schedule?: Schedule;
+  /** These schedules are the ones that the streams of the client `load` had. */
+  readonly streams?: readonly RunStream[];
 }
 /** A run route is one change of a route at a leaf of a fabric, on the monotonic clock. */
 interface RunRoute {
@@ -1513,5 +1687,5 @@ interface RunTopology {
   }>>;
 }
 //#endregion
-export { Replies as $, LineCount as A, Prediction as B, HopSignal as C, latestEndOf as Ct, Jitter as D, ImageSource as E, Observer as F, QueueConnection as G, ProxyHop as H, Outcomes as I, Reconnects as J, QueueEnd as K, Pair as L, MiddleboxEvent as M, MiddleboxExpectation as N, Kafka as O, MiddleboxForm as P, ReplicaSetStage as Q, PinnedImage as R, HopPlace as S, isHopPlace as St, HttpProbe as T, ProxyTime as U, ProbeEvent as V, QueueBand as W, Reference as X, Recovers as Y, ReplicaSet as Z, GroupPlace as _, Subject as _t, Cluster as a, RunDrill as at, Hop as b, Toxic as bt, CountBand as c, RunPart as ct, DriverStep as d, SentinelEvent as dt, RequestPrediction as et, Fabric as f, SentinelStage as ft, Group as g, StageBand as gt, FaultPlace as h, Stage as ht, ClientImage as i, RunBackup as it, LineMatch as j, KernelRecord as k, Drill as l, RunRoute as lt, Fault as m, ShippedImage as mt, Cell as n, RttRange as nt, ClusterClientAt as o, RunFabric as ot, FabricManifest as p, Shipped as pt, QueuePrediction as q, Client as r, Run as rt, ClusterStage as s, RunGroup as st, BuildImage as t, RouterHop as tt, DriverBand as u, RunTopology as ut, GroupPrediction as v, Target as vt, HopWrite as w, HopEvent as x, WsProbe as xt, GroupRole as y, Topology as yt, PortsPrediction as z };
-//# sourceMappingURL=cell-DZm8zXN4.d.ts.map
+export { ProxyHop as $, ImageSource as A, Subject as At, LoadStream as B, Hop as C, RunTopology as Ct, HopWrite as D, ShippedImage as Dt, HopSignal as E, Shipped as Et, LineCount as F, isHopPlace as Ft, Outcomes as G, MiddleboxExpectation as H, LineMatch as I, latestEndOf as It, PausePrediction as J, Pair as K, LoadBand as L, Kafka as M, Topology as Mt, KafkaPause as N, Toxic as Nt, HostSysctl as O, Stage as Ot, KernelRecord as P, WsProbe as Pt, ProbeEvent as Q, LoadPlan as R, GroupRole as S, RunStream as St, HopPlace as T, SentinelStage as Tt, MiddleboxForm as U, MiddleboxEvent as V, Observer as W, PortsPrediction as X, PinnedImage as Y, Prediction as Z, Fault as _, RunFabric as _t, ClientCapability as a, Reconnects as at, GroupPlace as b, RunPause as bt, ClusterClientAt as c, ReplicaSet as ct, CountBand as d, RequestPrediction as dt, ProxyTime as et, Drill as f, RouterHop as ft, FabricManifest as g, RunDrill as gt, Fabric as h, RunBackup as ht, Client as i, QueuePrediction as it, Jitter as j, Target as jt, HttpProbe as k, StageBand as kt, ClusterStage as l, ReplicaSetStage as lt, DriverStep as m, Run as mt, CLIENT_CAPABILITIES as n, QueueConnection as nt, ClientImage as o, Recovers as ot, DriverBand as p, RttRange as pt, PauseBand as q, Cell as r, QueueEnd as rt, Cluster as s, Reference as st, BuildImage as t, QueueBand as tt, ConntrackPrediction as u, Replies as ut, FaultPlace as v, RunGroup as vt, HopEvent as w, SentinelEvent as wt, GroupPrediction as x, RunRoute as xt, Group as y, RunPart as yt, LoadPrediction as z };
+//# sourceMappingURL=cell-biffSiEJ.d.ts.map

package/build/{image-EZ8ioZ3L.js → image-BxVTFZ1o.js}

@@ -1,3 +1,4 @@
+import { valueIn } from "@mark1russell7/quantity";
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -6,6 +7,22 @@ import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpa
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
+//#region src/cell.ts
+/** These are the capabilities that a client image can get. */
+const CLIENT_CAPABILITIES = ["NET_ADMIN"];
+/** This function tells if a fault place is a hop of a topology. */
+const isHopPlace = (place) => typeof place === "object" && "hop" in place;
+/**
+* This function tells if the request of a client goes before the fault of its cell. That is so for a
+* hop event that comes while the request is in flight (`HopEvent.inFlight`). Then a request after the fault is void.
+*/
+const requestFirst = (cell) => cell.fault === "hop-event" && cell.event?.inFlight === true;
+/**
+* This function gives the latest end of a band in seconds, from the reply of the client. It is
+* the high bound, after the latest reference of the band (`startsBy`).
+*/
+const latestEndOf = (prediction) => valueIn(prediction.high, "s") + (prediction.startsBy === void 0 ? 0 : valueIn(prediction.startsBy, "s"));
+//#endregion
 //#region src/locks.ts
 /**
 * These are the names of the lockfiles that the harness records. A `go.mod` is the lockfile of a Go
@@ -292,6 +309,10 @@ const SHIPPED_CLIENTS = {
 	grpc: {
 		image: shipped("grpc"),
 		command: ["node", "/opt/harness/grpc/client-grpc.mjs"]
+	},
+	load: {
+		image: shipped("harness"),
+		command: ["/opt/harness/load"]
 	}
 };
 /** These are the names of the clients that the harness ships. */
@@ -641,6 +662,6 @@ const targetSourceOf = (target) => target.subject ?? target.image;
 /** This function gives the image that a target operates: the image of its subject, or its stock image. */
 const targetImageOf = (target) => imageOf(targetSourceOf(target));
 //#endregion
-export { unlockedManifests as A, programOf as C, subjectProblems as D, subjectClient as E, jarVersions as F, locksOf as I, npmVersions as L, LOCK_NAMES as M, cargoVersions as N, targetImageOf as O, goVersions as P, versionsOf as R, planOf as S, shippedSource as T, kafkaClientImage as _, SHIPPED_NAMES as a, nodeHttpImage as b, buildRecordOf as c, harnessImage as d, harnessVersion as f, inContext as g, imageProblems as h, SHIPPED_CLIENTS as i, unpinnedBases as j, targetSourceOf as k, goHttpImage as l, imageOf as m, PINNED as n, amqpClientImage as o, hikariClientImage as p, REPOSITORY as r, basesOf as s, CLIENT_NAMES as t, grpcClientImage as u, mongoClientImage as v, routerImage as w, pgClientImage as x, nodeClientImage as y };
+export { unlockedManifests as A, isHopPlace as B, programOf as C, subjectProblems as D, subjectClient as E, jarVersions as F, requestFirst as H, locksOf as I, npmVersions as L, LOCK_NAMES as M, cargoVersions as N, targetImageOf as O, goVersions as P, versionsOf as R, planOf as S, shippedSource as T, latestEndOf as V, kafkaClientImage as _, SHIPPED_NAMES as a, nodeHttpImage as b, buildRecordOf as c, harnessImage as d, harnessVersion as f, inContext as g, imageProblems as h, SHIPPED_CLIENTS as i, unpinnedBases as j, targetSourceOf as k, goHttpImage as l, imageOf as m, PINNED as n, amqpClientImage as o, hikariClientImage as p, REPOSITORY as r, basesOf as s, CLIENT_NAMES as t, grpcClientImage as u, mongoClientImage as v, routerImage as w, pgClientImage as x, nodeClientImage as y, CLIENT_CAPABILITIES as z };
 
-//# sourceMappingURL=image-EZ8ioZ3L.js.map
+//# sourceMappingURL=image-BxVTFZ1o.js.map