hammerkit 1.27.0-next.13 → 1.27.0-next.15

package/dist/server/run-worker.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.workerMain = exports.taskCauses = exports.runTasks = exports.getRunNetwork = exports.workerInputSchema = void 0;
+exports.workerMain = exports.readInput = exports.taskCauses = exports.runTasks = exports.getEndpointTargets = exports.publishEndpoints = exports.getRunNetwork = exports.workerInputSchema = void 0;
 const readline_1 = require("readline");
 const zod_1 = require("zod");
 const cli_1 = require("../cli");
@@ -21,6 +21,7 @@ const network_schema_1 = require("../schema/network-schema");
 const work_network_1 = require("../planner/work-network");
 const run_plan_1 = require("./run-plan");
 const runs_1 = require("./runs");
+const resources_1 = require("../kubernetes/resources");
 // one log line of a task is cut here, the registry caps how many events a run keeps
 const MAX_LOG_TEXT = 8 * 1024;
 /**
@@ -59,6 +60,15 @@ exports.workerInputSchema = zod_1.z
         .string()
         .regex(/^[a-z]+-[0-9a-f]{24}$/)
         .optional(),
+    // a service run: the services it keeps up instead of tasks, and the ports the server
+    // reaches as endpoints
+    up: zod_1.z
+        .object({
+        services: zod_1.z.array(zod_1.z.string()).min(1),
+        endpoints: zod_1.z.array(zod_1.z.object({ service: zod_1.z.string(), port: zod_1.z.number().int() }).strict()),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 // The ceiling of the run, combined here and not in the server: the lower of two allow lists
@@ -68,6 +78,60 @@ function getRunNetwork(input) {
     return input.sandboxNetwork ? (0, work_network_1.limitNetwork)((0, work_network_1.parseWorkNetwork)(input.sandboxNetwork), runs) : runs;
 }
 exports.getRunNetwork = getRunNetwork;
+/**
+ * The ports of the services of a service run as the server publishes them: on a host the
+ * ports of endpoints go to a free port of the loopback interface, where only the server
+ * reaches them, and no other port goes to the host, whatever the build file says (`up`
+ * would publish them on every interface, where two runs collide). On a cluster nothing is
+ * published, the server reaches the Service of each.
+ */
+function publishEndpoints(workTree, endpoints, cluster) {
+    for (const service of Object.values(workTree.services)) {
+        if (!('ports' in service.data)) {
+            continue;
+        }
+        service.data.ports = service.data.ports.map((port) => !cluster &&
+            endpoints.some((endpoint) => endpoint.service === service.name && endpoint.port === port.containerPort)
+            ? { containerPort: port.containerPort, hostPort: 0, hostIp: '127.0.0.1' }
+            : { containerPort: port.containerPort, hostPort: null });
+    }
+}
+exports.publishEndpoints = publishEndpoints;
+// Where the server reaches each endpoint, once every service the run keeps up is ready;
+// null until then.
+function getEndpointTargets(workTree, up, kubernetes) {
+    const services = Object.values(workTree.services).filter((service) => up.services.includes(service.name));
+    if (services.length < up.services.length || services.some((service) => service.state.current.type !== 'running')) {
+        return null;
+    }
+    const targets = [];
+    for (const endpoint of up.endpoints) {
+        const service = services.find((candidate) => candidate.name === endpoint.service);
+        const state = service?.state.current;
+        if (!service || state?.type !== 'running') {
+            return null;
+        }
+        if (kubernetes) {
+            targets.push({
+                service: endpoint.service,
+                port: endpoint.port,
+                address: { host: `${(0, resources_1.getResourceName)(service, kubernetes)}.${kubernetes.namespace}.svc`, port: endpoint.port },
+            });
+            continue;
+        }
+        const published = state.published?.find((candidate) => candidate.containerPort === endpoint.port);
+        if (!published) {
+            throw new Error(`${endpoint.service} is up, but its port ${endpoint.port} was not published`);
+        }
+        targets.push({
+            service: endpoint.service,
+            port: endpoint.port,
+            address: { host: published.host, port: published.port },
+        });
+    }
+    return targets;
+}
+exports.getEndpointTargets = getEndpointTargets;
 /**
  * Executes the tasks of a run with the engine of `hammerkit run`. The caller says which
  * process this is in: it reports what happens through `emit` and stops when `abortCtrl`
@@ -75,7 +139,9 @@ exports.getRunNetwork = getRunNetwork;
  */
 async function runTasks(input, cwd, processEnvs, abortCtrl, 
 // whether the run was stopped from outside; the engine aborts too when a task fails
-cancelled, emit) {
+cancelled, emit, 
+// a service run: its services are ready, at these addresses
+up) {
     const secrets = (0, redact_1.createSecretRegistry)();
     const status = (0, work_item_status_1.statusConsole)((0, empty_writable_1.emptyWritable)(), secrets);
     // the process starts in a directory of the server, the tasks work on the run's files
@@ -126,7 +192,7 @@ cancelled, emit) {
             // why a task was not taken from the cache goes into its result
             explain: true,
         };
-        for (const { name, scope } of (0, run_plan_1.getRunScopes)(input.tasks, options)) {
+        for (const { name, scope } of (0, run_plan_1.getRunScopes)(input.tasks, options, input.up?.services)) {
             const { ctx, scope: parsed } = await (0, schema_parser_1.createParseContext)(input.entry, environment, {
                 directory: input.directory,
             });
@@ -135,17 +201,44 @@ cancelled, emit) {
             if (input.volumeScope && !input.kubernetes) {
                 (0, hosted_volumes_1.scopeServiceVolumes)(workTree, input.volumeScope);
             }
+            if (input.up) {
+                publishEndpoints(workTree, input.up.endpoints, !!input.kubernetes);
+            }
             const cli = (0, cli_1.getCli)(workTree, environment);
-            if (cli.tasks().length === 0) {
+            if (cli.tasks().length === 0 && (!input.up || cli.services().length === 0)) {
                 throw new Error(`no tasks found for ${name}`);
             }
-            const execution = cli.exec({ ...execOptions, workers: cli.defaultWorkers() });
+            const execution = input.up
+                ? cli.up({ ...execOptions, workers: cli.defaultWorkers(), daemon: false, wait: 'ready' })
+                : cli.exec({ ...execOptions, workers: cli.defaultWorkers() });
             const seen = new Map();
-            const report = () => reportTasks(emit, execution.state.current, seen, (text) => secrets.redact(text));
+            let ready = false;
+            const report = () => {
+                reportTasks(emit, execution.state.current, seen, (text) => secrets.redact(text));
+                if (input.up && up && !ready) {
+                    const targets = getEndpointTargets(execution.state.current, input.up, input.kubernetes);
+                    if (targets) {
+                        ready = true;
+                        up(targets);
+                    }
+                }
+            };
             const watch = execution.state.on('run-events', report);
             try {
                 const result = await execution.start();
                 report();
+                // on a cluster the services stay in their Deployments once they are ready, until
+                // the namespace of the run goes
+                if (input.up && input.kubernetes && ready && result.success && !abortCtrl.signal.aborted) {
+                    await new Promise((resolve) => abortCtrl.signal.addEventListener('abort', () => resolve(), { once: true }));
+                    return;
+                }
+                if (input.up && ready) {
+                    if (!abortCtrl.signal.aborted) {
+                        throw new Error('the services stopped on their own');
+                    }
+                    return;
+                }
                 if (!result.success) {
                     throw new Error(cancelled() ? 'the run was cancelled' : `${name} failed`);
                 }
@@ -218,9 +311,13 @@ redact) {
 // The run is the first line of the standard input. The server keeps it open and writes
 // `cancel` on it to stop the run: that works the same on every platform, where a signal
 // on Windows ends the process without letting it stop its tasks.
+// `onEnd` is told when the input ends before the run does: the server is gone.
 function readInput(stdin, cancel) {
     const lines = (0, readline_1.createInterface)({ input: stdin, crlfDelay: Infinity });
     let first;
+    let closing = false;
+    let ended = false;
+    let onEnd;
     const input = new Promise((resolve) => {
         lines.on('line', (line) => {
             if (first === undefined) {
@@ -231,10 +328,29 @@ function readInput(stdin, cancel) {
                 cancel();
             }
         });
-        lines.on('close', () => resolve(first ?? ''));
+        lines.on('close', () => {
+            resolve(first ?? '');
+            if (!closing) {
+                ended = true;
+                onEnd?.();
+            }
+        });
     });
-    return { input, close: () => lines.close() };
+    return {
+        input,
+        close: () => {
+            closing = true;
+            lines.close();
+        },
+        onEnd: (listener) => {
+            onEnd = listener;
+            if (ended) {
+                listener();
+            }
+        },
+    };
 }
+exports.readInput = readInput;
 /**
  * The process of one run: reads its input, executes the tasks in the current directory
  * and reports as lines of JSON. It exits 0 when it could say how the run ended, and the
@@ -261,8 +377,13 @@ async function workerMain(stdin, stdout, processEnvs, cwd, abortCtrl) {
         say({ kind: 'result', ok: false, error: `the run could not be read: ${e instanceof Error ? e.message : e}` });
         return;
     }
+    if (input.up) {
+        // services stay until they are stopped: without the server that would stop them, at
+        // their ttl or on a cancel, nothing would
+        reader.onEnd(stop);
+    }
     try {
-        await runTasks(input, cwd, processEnvs, abortCtrl, () => cancelled, (event) => say({ kind: 'event', event }));
+        await runTasks(input, cwd, processEnvs, abortCtrl, () => cancelled, (event) => say({ kind: 'event', event }), (targets) => say({ kind: 'up', targets }));
         say({ kind: 'result', ok: true });
     }
     catch (e) {