hammerkit 1.27.0-next.2 → 1.27.0-next.20

package/dist/server/run-request.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runRequestSchema = exports.runOptionsSchema = exports.MAX_ARGS_BYTES = exports.MAX_ARGS = void 0;
+exports.runRequestSchema = exports.runOptionsSchema = exports.MAX_ARGS_BYTES = exports.MAX_ARGS = exports.MAX_ENDPOINTS = exports.SERVICE_RUN_NAME_PATTERN = void 0;
 const zod_1 = require("zod");
 const units_1 = require("../utils/units");
 const bundle_1 = require("../remote/bundle");
 const repo_1 = require("./repo");
 const runs_1 = require("./runs");
 const name = zod_1.z.string().min(1).max(200);
+// The name of a service run, one DNS label: the hosts of its endpoints carry it, and a run of
+// the same caller with the same name replaces it
+exports.SERVICE_RUN_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]{0,38}[a-z0-9])?$/;
+// endpoints one service run may publish
+exports.MAX_ENDPOINTS = 5;
 // what one run may pass after `--`
 exports.MAX_ARGS = 100;
 exports.MAX_ARGS_BYTES = 16 * 1024;
@@ -38,6 +43,8 @@ exports.runOptionsSchema = zod_1.z
     cacheReadOnly: zod_1.z.boolean().optional(),
     // as --timeout
     timeout: duration.optional(),
+    // as --max-timeout: caps every task, also one with a longer timeout of its own
+    maxTimeout: duration.optional(),
     // as --no-skip-deps when false
     skipDeps: zod_1.z.boolean().optional(),
     // as the text after `--`: appended to the last command of the one task the run
@@ -75,24 +82,78 @@ exports.runRequestSchema = zod_1.z
                 return repo;
             }),
             ref: name,
+            // the commit the ref has to be at, such as the one a CI job checked out: a ref that
+            // moved since is refused, so the run executes the code that was asked for
+            commit: zod_1.z
+                .string()
+                .regex(/^([0-9a-f]{40}|[0-9a-f]{64})$/, 'expected a full commit hash, 40 or 64 hex digits')
+                .optional(),
         })
             .strict(),
         // the name of a tree announced with POST /v1/sources
         zod_1.z.object({ type: zod_1.z.literal('upload'), snapshot: zod_1.z.string().regex(bundle_1.HASH_PATTERN) }).strict(),
         // a sandbox of the caller's, see POST /v1/sandboxes
         zod_1.z
-            .object({ type: zod_1.z.literal('sandbox'), id: zod_1.z.string().regex(runs_1.SANDBOX_ID_PATTERN, 'expected a sandbox id') })
+            .object({
+            type: zod_1.z.literal('sandbox'),
+            id: zod_1.z.string().regex(runs_1.SANDBOX_ID_PATTERN, 'expected a sandbox id'),
+            // a check: run on a copy of the files a push of the sandbox would commit, so what
+            // passes counts for that commit (remote verify)
+            check: zod_1.z.literal(true).optional(),
+        })
             .strict(),
     ]),
     options: exports.runOptionsSchema.default({}),
+    // a service run: these services of the build file, started as `hammerkit up` starts
+    // them and kept up until `ttl` ends or the run is cancelled, instead of tasks
+    services: zod_1.z.array(name).max(20).default([]),
+    // how long the services stay once they are ready, whether they sleep in between or not;
+    // `runs.up.ttl` when left out. At its end they are removed.
+    ttl: duration.optional(),
+    // how long the services stay up without a request to one of the endpoints, then they
+    // sleep until the next request wakes them; `runs.up.sleepTtl` when left out
+    sleepTtl: duration.optional(),
+    // a second service run of the caller with the same name replaces the first; the branch
+    // of the source when left out
+    name: zod_1.z
+        .string()
+        .regex(exports.SERVICE_RUN_NAME_PATTERN, 'expected lower case letters, digits and -, at most 40, as a DNS label')
+        .optional(),
+    // ports of the run's services published at hosts of their own, behind the server's sign-in
+    endpoints: zod_1.z
+        .array(zod_1.z.object({ service: name, port: zod_1.z.number().int().min(1).max(65535) }).strict())
+        .max(exports.MAX_ENDPOINTS)
+        .default([]),
 })
     .strict()
-    .refine((request) => request.tasks.length > 0 || (request.options.filter ?? []).length > 0, {
+    .refine((request) => request.services.length > 0 || request.tasks.length > 0 || (request.options.filter ?? []).length > 0, {
     message: 'name at least one task, or filter by labels',
     path: ['tasks'],
 })
+    .refine((request) => request.services.length === 0 || request.tasks.length === 0, {
+    message: 'a run names tasks or services, not both',
+    path: ['services'],
+})
+    .refine((request) => request.services.length === 0 ||
+    ((request.options.filter ?? []).length === 0 && (request.options.exclude ?? []).length === 0), { message: 'a service run names its services, labels do not select them', path: ['options', 'filter'] })
+    .refine((request) => request.services.length === 0 || (request.options.args ?? []).length === 0, {
+    message: 'a service run takes no arguments',
+    path: ['options', 'args'],
+})
+    .refine((request) => request.services.length > 0 ||
+    (request.ttl === undefined &&
+        request.sleepTtl === undefined &&
+        request.name === undefined &&
+        request.endpoints.length === 0), { message: 'ttl, sleepTtl, name and endpoints are for a run of services', path: ['services'] })
+    .refine((request) => new Set(request.endpoints.map((endpoint) => `${endpoint.service}:${endpoint.port}`)).size ===
+    request.endpoints.length, { message: 'an endpoint is named twice', path: ['endpoints'] })
     .refine((request) => (request.options.args ?? []).length === 0 || request.tasks.length === 1, {
     message: 'arguments go to one task, name exactly one in tasks',
     path: ['options', 'args'],
+})
+    .refine((request) => request.source.type !== 'sandbox' || !request.source.check || (request.options.args ?? []).length === 0, { message: 'a check runs the task as the build file says, it takes no arguments', path: ['options', 'args'] })
+    .refine((request) => request.source.type !== 'sandbox' || !request.source.check || request.services.length === 0, {
+    message: 'a check runs tasks, a run of services keeps them up and passes nothing',
+    path: ['services'],
 });
 //# sourceMappingURL=run-request.js.map

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,8 @@ 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");
+const check_keys_1 = require("../optimizer/check-keys");
 // 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 +61,17 @@ 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(),
+    // the run's results count as checks: report each task's check key before it runs
+    check: zod_1.z.boolean().optional(),
 })
     .strict();
 // The ceiling of the run, combined here and not in the server: the lower of two allow lists
@@ -68,6 +81,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 +142,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
@@ -117,15 +186,27 @@ cancelled, emit) {
         const options = input.options;
         const execOptions = {
             logMode: 'live',
-            cacheDefault: options.cache ?? 'checksum',
+            // a check takes a cached result only for the same files, never for the same dates
+            cacheDefault: input.check && options.cache === 'modify-date' ? 'checksum' : options.cache ?? 'checksum',
             cacheReadOnly: options.cacheReadOnly ?? false,
             timeout: options.timeout ? (0, units_1.parseDuration)(options.timeout) : null,
+            maxTimeout: options.maxTimeout ? (0, units_1.parseDuration)(options.maxTimeout) : null,
             skipDeps: options.skipDeps !== false,
             network: getRunNetwork(input),
             // 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)) {
+        const scopes = (0, run_plan_1.getRunScopes)(input.tasks, options, input.up?.services);
+        if (input.check) {
+            // the files as they are before any task wrote to them, a second task's too: a first
+            // one that formats or generates into src would key it by files no commit holds
+            for (const { scope } of scopes) {
+                for (const [task, { key }] of Object.entries(await (0, check_keys_1.getCheckKeys)(input.entry, environment, scope))) {
+                    emit({ type: 'key', task, key });
+                }
+            }
+        }
+        for (const { name, scope } of scopes) {
             const { ctx, scope: parsed } = await (0, schema_parser_1.createParseContext)(input.entry, environment, {
                 directory: input.directory,
             });
@@ -134,17 +215,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`);
                 }
@@ -217,9 +325,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) {
@@ -230,10 +342,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
@@ -260,8 +391,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) {