@mark1russell7/harness 0.11.2 → 0.11.3

package/build/index.js

@@ -1,10 +1,6 @@
+import { C as targetSourceOf, S as targetImageOf, T as unpinnedBases, _ as proceduresImage, a as SHIPPED_NAMES, b as subjectClient, c as harnessImage, d as inContext, f as mongoClientImage, g as planOf, h as pgClientImage, i as SHIPPED_CLIENTS, l as imageOf, m as nodeHttpImage, n as PINNED, o as SUBJECTS, p as nodeClientImage, r as REPOSITORY, s as goHttpImage, t as CLIENT_NAMES, u as imageProblems, v as programOf, w as unlockedManifests, x as subjectProblems, y as routerImage } from "./image-Q_fs3rCC.js";
 import { quantity, valueIn } from "@mark1russell7/quantity";
 import { createHash } from "node:crypto";
-import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
-import { createRequire } from "node:module";
-import { tmpdir } from "node:os";
-import { dirname, join, relative } from "node:path";
-import { fileURLToPath } from "node:url";
 //#region src/cell.ts
 /** This function tells if a fault place is a hop of a topology. */
 const isHopPlace = (place) => typeof place === "object" && "hop" in place;
@@ -1898,151 +1894,8 @@ const measureSocket = (cell, run) => {
 };
 //#endregion
 //#region src/lab.ts
-/**
-* These are the roots of the two packages that the images read: this package, and the prober
-* that Node resolves for it. In a workspace, they are two folders side by side. From npm, the
-* prober is a link, and a Docker build context does not follow a link. Thus each image builds
-* from a context that the harness copies from the two roots.
-*/
-const ROOTS = {
-	harness: fileURLToPath(new URL("..", import.meta.url)),
-	prober: dirname(realpathSync(createRequire(import.meta.url).resolve("@mark1russell7/prober/package.json")))
-};
-/** This function gives the path of a part of an image, which is `<package>/<path>` in the context. */
-const pathOf = (part) => {
-	const [root, ...rest] = part.split("/");
-	const base = ROOTS[root];
-	if (base === void 0) throw new Error(`${part} is in no package that the images read`);
-	return join(base, ...rest);
-};
 /** This function loads Testcontainers when a lab first opens. Code that only measures and judges does not load it. */
 const containers = () => import("testcontainers");
-/** This image holds the prober, the TCP client, the injector and the namespace admin. */
-const HARNESS = {
-	name: "loom-harness",
-	dockerfile: "harness/image/Dockerfile",
-	from: [
-		"harness/image/Dockerfile",
-		"harness/image/native",
-		"prober/bpf",
-		"prober/native",
-		"prober/fixtures"
-	]
-};
-/** This image holds the Node client: ioredis 6.0.0 on Node 24.21.0. */
-const NODE = {
-	name: "loom-harness-node",
-	dockerfile: "harness/image/node/Dockerfile",
-	from: ["harness/image/node"]
-};
-/** This image holds the Go HTTP client: the http.Transport of Go 1.27.2. */
-const GO_HTTP = {
-	name: "loom-harness-go-http",
-	dockerfile: "harness/image/go-http/Dockerfile",
-	from: ["harness/image/go-http"]
-};
-/** This image holds the Node HTTP clients: the http.Agent of Node 24.21.0, and undici 8.12.2. */
-const NODE_HTTP = {
-	name: "loom-harness-node-http",
-	dockerfile: "harness/image/node-http/Dockerfile",
-	from: ["harness/image/node-http"]
-};
-/** This image holds the MongoDB client: the driver mongodb 7.7.0 on Node 24.21.0, and its step-down script. */
-const MONGO = {
-	name: "loom-harness-mongo",
-	dockerfile: "harness/image/mongo/Dockerfile",
-	from: ["harness/image/mongo"]
-};
-/** This image holds the PostgreSQL client: node-postgres (pg 8.23.1 with pg-pool 3.14.0) on Node 24.21.0. */
-const PG = {
-	name: "loom-harness-pg",
-	dockerfile: "harness/image/pg/Dockerfile",
-	from: ["harness/image/pg"]
-};
-/** This image holds `@procedures/client` 0.7.0 on Node 24.21.0: its WebSocket client as a client of the harness, and the script of its server. */
-const PROCEDURES = {
-	name: "loom-harness-procedures",
-	dockerfile: "harness/image/procedures/Dockerfile",
-	from: ["harness/image/procedures"]
-};
-/** This image is the router of a middlebox chain: NAT and conntrack, with a form for a forgotten flow. */
-const ROUTER = {
-	name: "loom-harness-router",
-	dockerfile: "harness/image/router/Dockerfile",
-	from: ["harness/image/router"]
-};
-/** This function gives each file under a path, in a stable sequence, but not the output of a local build. */
-const sources = (path) => {
-	if (statSync(path).isFile()) return [path];
-	return readdirSync(path, { withFileTypes: true }).filter((entry) => entry.name !== "target" && entry.name !== "node_modules").flatMap((entry) => sources(join(path, entry.name))).sort();
-};
-/** This function gives each file of an image, with its path in the build context. */
-const filesOf = (image) => image.from.flatMap((part) => {
-	const base = pathOf(part);
-	return sources(base).map((file) => ({
-		file,
-		at: join(part, relative(base, file)).replaceAll("\\", "/")
-	}));
-});
-/** This function gives the tag of an image from its content. Thus a changed probe or client cannot operate as an old one. */
-const imageTag = (image) => {
-	const hash = createHash("sha256");
-	for (const { file, at } of filesOf(image)) {
-		hash.update(at);
-		hash.update(readFileSync(file));
-	}
-	return `${image.name}:${hash.digest("hex").slice(0, 12)}`;
-};
-/** This function copies the files of an image into a new build context, and gives its path. */
-const stage = (image) => {
-	const context = mkdtempSync(join(tmpdir(), `${image.name}-`));
-	for (const { file, at } of filesOf(image)) {
-		mkdirSync(dirname(join(context, at)), { recursive: true });
-		copyFileSync(file, join(context, at));
-	}
-	return context;
-};
-const built = /* @__PURE__ */ new Map();
-/** This function builds an image one time for each process. Docker keeps its layers between runs. */
-const build = (image) => {
-	let tag = built.get(image.name);
-	if (tag === void 0) {
-		tag = (async () => {
-			const name = imageTag(image);
-			const { GenericContainer } = await containers();
-			const context = stage(image);
-			try {
-				await GenericContainer.fromDockerfile(context, image.dockerfile).build(name, { deleteOnExit: false });
-			} finally {
-				rmSync(context, {
-					recursive: true,
-					force: true
-				});
-			}
-			return name;
-		})();
-		built.set(image.name, tag);
-	}
-	return tag;
-};
-/** This function gives the image of the harness. */
-const harnessImage = () => build(HARNESS);
-/** This function gives the image of the Node client. */
-const nodeClientImage = () => build(NODE);
-/** This function gives the image of the router. */
-const routerImage = () => build(ROUTER);
-/** This function gives the image of the Go HTTP client. */
-const goHttpImage = () => build(GO_HTTP);
-/** This function gives the image of the Node HTTP clients. */
-const nodeHttpImage = () => build(NODE_HTTP);
-/** This function gives the image of the MongoDB client. */
-const mongoClientImage = () => build(MONGO);
-/** This function gives the image of the PostgreSQL client. */
-const pgClientImage = () => build(PG);
-/** This function gives the image of `@procedures/client`: its WebSocket client and its server. */
-const proceduresImage = () => build(PROCEDURES);
-/** This function gives the image that a target operates: its stock image, or an image of the harness (`Target.harness`). */
-const targetImageOf = (target) => target.harness === "procedures" ? proceduresImage() : Promise.resolve(target.image);
 /**
 * This time is the interval of the listing of a router, when its hop does not set one. A listing
 * evicts each expired flow that it walks past, and the DESTROY event of that flow follows.
@@ -2209,47 +2062,19 @@ const netnsOf = async (container) => {
 	if (inode === void 0) throw new Error(`not a network namespace: ${link}`);
 	return Number(inode);
 };
-/** This function gives the image and the command of the client of each run, and its kind for the manifest. */
-const clientOf = async (kind, image) => {
-	if (typeof kind === "object") return {
-		clientImage: kind.image,
-		command: kind.command,
-		clientKind: "image"
-	};
-	if (kind === "ioredis") return {
-		clientImage: await nodeClientImage(),
-		command: ["node", "/opt/harness/node/client-ioredis.mjs"],
-		clientKind: kind
-	};
-	if (kind === "go-http") return {
-		clientImage: await goHttpImage(),
-		command: ["/opt/harness/client-go"],
-		clientKind: kind
-	};
-	if (kind === "http-agent" || kind === "undici") return {
-		clientImage: await nodeHttpImage(),
-		command: ["node", `/opt/harness/node-http/client-${kind === "undici" ? "undici" : "agent"}.mjs`],
-		clientKind: kind
-	};
-	if (kind === "mongodb") return {
-		clientImage: await mongoClientImage(),
-		command: ["node", "/opt/harness/mongo/client-mongo.mjs"],
-		clientKind: kind
-	};
-	if (kind === "pg") return {
-		clientImage: await pgClientImage(),
-		command: ["node", "/opt/harness/pg/client-pg.mjs"],
-		clientKind: kind
-	};
-	if (kind === "procedures-ws") return {
-		clientImage: await proceduresImage(),
-		command: ["node", "/opt/harness/procedures/client-ws.mjs"],
-		clientKind: kind
-	};
+/**
+* This function gives the image and the command of the client of each run, its kind for the
+* manifest, and the source of its image. A client by its name is a client that the harness ships
+* (`SHIPPED_CLIENTS`). A client image gives its own image and command.
+*/
+const clientOf = async (kind) => {
+	const client = typeof kind === "string" ? Object.hasOwn(SHIPPED_CLIENTS, kind) ? SHIPPED_CLIENTS[kind] : void 0 : kind;
+	if (client === void 0) throw new Error(`the harness ships no client ${String(kind)}`);
 	return {
-		clientImage: image,
-		command: ["/opt/harness/client"],
-		clientKind: kind
+		clientImage: await imageOf(client.image),
+		command: client.command,
+		clientKind: typeof kind === "string" ? kind : "image",
+		...typeof client.image === "string" ? {} : { source: client.image }
 	};
 };
 /** This function gives the device of a route from its line in `ip -o route get`: "10.0.0.2 dev eth0 src …". */
@@ -2280,7 +2105,7 @@ const deviceOf = (route) => {
 */
 const openLab = async (target, kind = "tcp", topology) => {
 	const image = await harnessImage();
-	const { clientImage, command, clientKind } = await clientOf(kind, image);
+	const { clientImage, command, clientKind, source } = await clientOf(kind);
 	const hops = topology?.hops ?? [];
 	const { GenericContainer, Network, Wait, getContainerRuntimeClient } = await containers();
 	const runtime = await getContainerRuntimeClient();
@@ -2853,7 +2678,10 @@ const openLab = async (target, kind = "tcp", topology) => {
 					docker: `${runtime.info.containerRuntime.serverVersion} on ${runtime.info.containerRuntime.operatingSystem}`,
 					target: {
 						image: targetImage,
-						...target.harness === void 0 ? {} : {
+						...target.subject !== void 0 ? {
+							subject: target.subject,
+							base: target.image
+						} : target.harness === void 0 ? {} : {
 							harness: target.harness,
 							base: target.image
 						},
@@ -2874,7 +2702,8 @@ const openLab = async (target, kind = "tcp", topology) => {
 					},
 					client: {
 						kind: clientKind,
-						image: clientImage
+						image: clientImage,
+						...source === void 0 ? {} : { source }
 					},
 					netns,
 					sysctls,
@@ -4783,6 +4612,6 @@ const runCell = async (cell, say = () => {}) => {
 	}
 };
 //#endregion
-export { CONVERGE_MS, INJECT, KEPT, LINGER_MS, LISTING, MEMBER_MARKS, NOISE, PUMP, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, STAGES, STATUS_SCRIPT, STEPS, STEP_DOWN, callOf, clockOffsetOf, closeOrExit, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, dropFinding, dropOf, endpointAfter, errorsOf, exitOf, fieldOf, fieldsOf, firstUnanswered, goHttpImage, groupOnce, groupVerdictOf, harnessImage, hzOf, infoOf, initiateScript, isHopPlace, judge, lagsOf, latestEndOf, leftAfter, matches, measure, measureDriver, measureGroup, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, nodeClientImage, nodeHttpImage, noiseOf, onMonotonic, openGroupLab, openLab, openReplicaSetLab, peersOf, pgClientImage, pingsOf, proceduresImage, programLines, quantileOf, reconnectFinding, reconnectOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, routerImage, routesOf, runCell, sentinelConfig, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, statusViewOf, subscriptionsOf, targetImageOf, templated, toxicBody, verdictOf, viewOf, writesOf };
+export { CLIENT_NAMES, CONVERGE_MS, INJECT, KEPT, LINGER_MS, LISTING, MEMBER_MARKS, NOISE, PINNED, PUMP, QUIET_MS, RELATIVE, REPLICA_SET_STAGES, REPOSITORY, SHIPPED_CLIENTS, SHIPPED_NAMES, STAGES, STATUS_SCRIPT, STEPS, STEP_DOWN, SUBJECTS, callOf, clockOffsetOf, closeOrExit, crossingsOf, cutOf, deadlineOf, delayVoids, deviceOf, dropFinding, dropOf, endpointAfter, errorsOf, exitOf, fieldOf, fieldsOf, firstUnanswered, goHttpImage, groupOnce, groupVerdictOf, harnessImage, hzOf, imageOf, imageProblems, inContext, infoOf, initiateScript, isHopPlace, judge, lagsOf, latestEndOf, leftAfter, matches, measure, measureDriver, measureGroup, medianInterval, memberCommand, memberConfig, memberLineOf, mongoClientImage, nodeClientImage, nodeHttpImage, noiseOf, onMonotonic, openGroupLab, openLab, openReplicaSetLab, peersOf, pgClientImage, pingsOf, planOf, proceduresImage, programLines, programOf, quantileOf, reconnectFinding, reconnectOf, referenceOf, reorderingOf, replicaSetArgs, replicaSetOnce, replicaSetStagesOf, requestOf, requestWords, routerImage, routesOf, runCell, sentinelConfig, socketAt, socketOf, socketsOf, spread, spreadOf, stagesOf, statusViewOf, subjectClient, subjectProblems, subscriptionsOf, targetImageOf, targetSourceOf, templated, toxicBody, unlockedManifests, unpinnedBases, verdictOf, viewOf, writesOf };
 
 //# sourceMappingURL=index.js.map