hammerkit 1.27.0-next.26 → 1.27.0-next.28

package/dist/main.js

@@ -8,6 +8,7 @@ const redact_1 = require("./utils/redact");
 const empty_writable_1 = require("./utils/empty-writable");
 const run_program_1 = require("./run-program");
 const abort_on_signals_1 = require("./utils/abort-on-signals");
+const terminal_prompt_1 = require("./utils/terminal-prompt");
 const abortCtrl = new AbortController();
 (0, abort_on_signals_1.abortOnSignals)(process, abortCtrl);
 let settled = false;
@@ -32,6 +33,7 @@ const secrets = (0, redact_1.createSecretRegistry)();
     stdout: process.stdout,
     stderr: process.stderr,
     stdoutColumns: process.stdout.columns,
+    prompt: (0, terminal_prompt_1.getTerminalPrompt)(process.env, abortCtrl.signal),
 }, process.argv, false).then(() => {
     settled = true;
 }, () => {

package/dist/remote/remote-work-commands.js

@@ -17,6 +17,7 @@ const units_1 = require("../utils/units");
 const service_tools_1 = require("../harness/service-tools");
 const path_1 = require("path");
 const check_keys_1 = require("../optimizer/check-keys");
+const terminal_prompt_1 = require("../utils/terminal-prompt");
 function describeOutcome(planned) {
     switch (planned.outcome) {
         case 'published':
@@ -174,6 +175,125 @@ function registerWorkCommands(remote, context) {
         const token = await (0, token_source_1.getTokenSource)(environment, chosen.name, chosen.server).token();
         return { ...chosen, token };
     };
+    // publishes the bundle with where it comes from and says what it is now: published,
+    // already published, or only proposed
+    const publishBundle = async (serverName, server, token, bundle, annotations) => {
+        const answer = await (0, server_client_1.callServer)(server, token, 'POST', '/v1/definitions', {
+            ...bundle,
+            annotations,
+        });
+        const version = answer.body;
+        const files = Object.keys(bundle.files).length;
+        // a proposal that already waits answers 200 like a published version, with its state
+        const proposed = answer.status === 202 || version.state !== undefined;
+        const verb = answer.status === 202
+            ? 'proposed'
+            : proposed
+                ? 'already proposed'
+                : answer.status === 201
+                    ? 'published'
+                    : 'already published';
+        environment.stdout.write(`${verb} to ${serverName}: ${(0, server_client_1.printable)(version.hash)} (${files} ${files === 1 ? 'file' : 'files'})\n`);
+        const names = [...(version.tasks ?? []), ...(version.services ?? [])];
+        environment.stdout.write(`tasks and services: ${names.map(server_client_1.printable).join(', ') || 'none'}\n`);
+        for (const line of annotationLines(version.annotations, 'from')) {
+            environment.stdout.write(`${line.trimStart()}\n`);
+        }
+        if (proposed) {
+            environment.stdout.write(`it can not run before somebody who may publish approves it, until ${(0, server_client_1.printable)(version.expiresAt)}\n`);
+        }
+        return { version, proposed };
+    };
+    // what publishing the bundle would do, undefined from a server that can't say (before 1.27)
+    const planBundle = async (server, token, bundle) => {
+        try {
+            return (await (0, server_client_1.callServer)(server, token, 'POST', '/v1/definitions/plan', bundle)).body;
+        }
+        catch (e) {
+            if (e instanceof server_client_1.ServerError && e.status === 404) {
+                return undefined;
+            }
+            throw e;
+        }
+    };
+    // The build file a run or up names, and what `--publish` may publish: the hash of the
+    // build file here, unless `--build` or HAMMERKIT_BUILD names a version.
+    const runDefinition = async (options) => {
+        const named = options.build ?? environment.processEnvs.HAMMERKIT_BUILD;
+        if (named !== undefined) {
+            if (options.publish) {
+                throw new Error(`--publish publishes the build file here, it does not go with ${options.build !== undefined ? '--build' : 'HAMMERKIT_BUILD'}`);
+            }
+            if (!bundle_1.HASH_PATTERN.test(named)) {
+                throw new Error(`${(0, server_client_1.printable)(named)} is not the hash of a published version (sha256:...)`);
+            }
+            return { definition: named };
+        }
+        const local = await (0, collect_bundle_1.collectBundle)(buildFile, environment);
+        return { definition: (0, bundle_1.hashBundle)(local), local };
+    };
+    // Submits a run of a published version. When the server does not have the build file
+    // here, it is published first: with --publish at once, else when the person at the
+    // terminal says so. Without a terminal and without --publish the run fails and says how
+    // to publish it, so CI never waits on a question.
+    const submitPublishing = async (target, request, local, publish) => {
+        const { serverName, server, connection } = target;
+        try {
+            return await (0, sandbox_client_1.submitRun)(connection, request);
+        }
+        catch (e) {
+            const status = e.status;
+            if (!local || status !== 400 || !/no published build file/.test(String(e))) {
+                throw e;
+            }
+        }
+        const definition = request.definition;
+        const notPublished = `the build file here is not published on ${serverName} (${definition})`;
+        const token = await connection.token();
+        if (!publish) {
+            if (!environment.prompt) {
+                throw new Error(`${notPublished}, publish it first with: hammerkit remote publish ${serverName}, or pass --publish`);
+            }
+            // a server before 1.27 can't say what publishing would do: it is asked all the same,
+            // and refuses then what the caller may not do
+            const planned = await planBundle(server, token, local);
+            if (planned && planned.outcome === null) {
+                throw new Error(`${notPublished}, and you may only run published build files (builds: run): ` +
+                    `somebody who may publish publishes it with: hammerkit remote publish ${serverName}`);
+            }
+            if (planned?.outcome !== 'already published') {
+                const files = Object.keys(local.files).length;
+                environment.stdout.write(`${notPublished}, ${files} ${files === 1 ? 'file' : 'files'}\n`);
+                if (planned) {
+                    const names = [...(planned.tasks ?? []), ...(planned.services ?? [])];
+                    environment.stdout.write(`tasks and services: ${names.map(server_client_1.printable).join(', ') || 'none'}\n`);
+                }
+                const proposing = planned?.outcome === 'proposed';
+                if (proposing) {
+                    environment.stdout.write(`${describeOutcome(planned)}\n`);
+                }
+                const answer = await environment.prompt(proposing ? `propose it to ${serverName} now? [y/N] ` : `publish it to ${serverName} now and go on? [y/N] `);
+                if (environment.abortCtrl.signal.aborted) {
+                    throw new Error(`stopped, nothing was published`);
+                }
+                if (!(0, terminal_prompt_1.isYes)(answer)) {
+                    throw new Error(`${notPublished}, nothing was published`);
+                }
+            }
+        }
+        const annotations = await (0, annotations_1.collectAnnotations)(buildFile, Object.keys(local.files));
+        const { version, proposed } = await publishBundle(serverName, server, token, local, annotations).catch((e) => {
+            throw e instanceof server_client_1.ServerError && e.status === 403 ? new Error(`${notPublished}, ${e.message}`) : e;
+        });
+        if (version.hash !== definition) {
+            throw new Error(`${serverName} published ${(0, server_client_1.printable)(version.hash)}, not ${definition} as computed here, nothing was started`);
+        }
+        if (proposed) {
+            throw new Error(`${definition} is only proposed on ${serverName}, nothing was started: ` +
+                'run this again once somebody who may publish approves it');
+        }
+        return (0, sandbox_client_1.submitRun)(connection, request);
+    };
     remote
         .command('publish [server]')
         .description('publish the build file and the files it includes to a server, runs refer to it by its hash')
@@ -198,23 +318,7 @@ function registerWorkCommands(remote, context) {
         }
         const annotations = (0, annotations_1.applyAnnotations)(await (0, annotations_1.collectAnnotations)(buildFile, Object.keys(bundle.files)), options.annotation ?? []);
         const { name: serverName, server, token } = await connect(name);
-        const answer = await (0, server_client_1.callServer)(server, token, 'POST', '/v1/definitions', {
-            ...bundle,
-            annotations,
-        });
-        const version = answer.body;
-        const files = Object.keys(bundle.files).length;
-        const proposed = answer.status === 202;
-        const verb = proposed ? 'proposed' : answer.status === 201 ? 'published' : 'already published';
-        environment.stdout.write(`${verb} to ${serverName}: ${(0, server_client_1.printable)(version.hash)} (${files} ${files === 1 ? 'file' : 'files'})\n`);
-        const names = [...(version.tasks ?? []), ...(version.services ?? [])];
-        environment.stdout.write(`tasks and services: ${names.map(server_client_1.printable).join(', ') || 'none'}\n`);
-        for (const line of annotationLines(version.annotations, 'from')) {
-            environment.stdout.write(`${line.trimStart()}\n`);
-        }
-        if (proposed) {
-            environment.stdout.write(`it can not run before somebody who may publish approves it, until ${(0, server_client_1.printable)(version.expiresAt)}\n`);
-        }
+        await publishBundle(serverName, server, token, bundle, annotations);
     }));
     remote
         .command('run <tasks...>')
@@ -229,12 +333,9 @@ function registerWorkCommands(remote, context) {
         .addOption(new commander_1.Option('--timeout <duration>', 'as --timeout of run: for tasks without their own, such as 30m'))
         .addOption(new commander_1.Option('--max-timeout <duration>', 'as --max-timeout of run: for every task, also one with its own timeout'))
         .addOption(new commander_1.Option('--detach', 'submit the run and exit, without following it: for a check that CI verifies later'))
+        .addOption(new commander_1.Option('--publish', 'publish the build file here first when the server does not have it, without asking; for CI and scripts'))
         .action(guarded('Remote run was not successful', async (tasks, options) => {
-        const named = options.build ?? environment.processEnvs.HAMMERKIT_BUILD;
-        const definition = named ?? (0, bundle_1.hashBundle)(await (0, collect_bundle_1.collectBundle)(buildFile, environment));
-        if (!bundle_1.HASH_PATTERN.test(definition)) {
-            throw new Error(`${(0, server_client_1.printable)(definition)} is not the hash of a published version (sha256:...)`);
-        }
+        const { definition, local } = await runDefinition(options);
         const source = await refSource(options);
         const ref = source.ref;
         const { name: serverName, server } = await getServer(options.server);
@@ -248,21 +349,7 @@ function registerWorkCommands(remote, context) {
         if (passthrough.length > 0) {
             runOptions.args = passthrough;
         }
-        let submitted;
-        try {
-            submitted = await (0, sandbox_client_1.submitRun)(connection, {
-                definition,
-                tasks,
-                source,
-                options: runOptions,
-            });
-        }
-        catch (e) {
-            if (e.status === 400 && !named && /no published build file/.test(String(e))) {
-                throw new Error(`the build file here is not published on ${serverName} (${definition}), publish it first`);
-            }
-            throw e;
-        }
+        const submitted = await submitPublishing({ serverName, server, connection }, { definition, tasks, source, options: runOptions }, local, !!options.publish);
         const at = submitted.source.type === 'ref' ? ` at ${(0, server_client_1.printable)(submitted.source.commit)}` : '';
         environment.stdout.write(`${(0, server_client_1.printable)(submitted.id)} on ${serverName}: ${tasks.map(server_client_1.printable).join(', ')} from ${(0, server_client_1.printable)(ref)}${at}\n`);
         if (options.detach) {
@@ -314,17 +401,14 @@ function registerWorkCommands(remote, context) {
         .addOption(new commander_1.Option('--ref <ref>', 'the branch or tag to start; the branch checked out here when left out'))
         .addOption(new commander_1.Option('--commit <sha>', 'the commit the ref has to be at; the commit checked out here when --ref is left out'))
         .addOption(new commander_1.Option('--env <name>', 'the environment of the build file, as --env of run'))
+        .addOption(new commander_1.Option('--publish', 'publish the build file here first when the server does not have it, without asking; for CI and scripts'))
         .action(guarded('Remote up was not successful', async (services, options) => {
-        const named = options.build ?? environment.processEnvs.HAMMERKIT_BUILD;
-        const definition = named ?? (0, bundle_1.hashBundle)(await (0, collect_bundle_1.collectBundle)(buildFile, environment));
-        if (!bundle_1.HASH_PATTERN.test(definition)) {
-            throw new Error(`${(0, server_client_1.printable)(definition)} is not the hash of a published version (sha256:...)`);
-        }
+        const { definition, local } = await runDefinition(options);
         const endpoints = (options.endpoint ?? []).map(service_tools_1.parseEndpoint);
         const source = await refSource(options);
         const { name: serverName, server } = await getServer(options.server);
         const connection = { url: server.url, ...(0, token_source_1.getTokenSource)(environment, serverName, server) };
-        const submitted = await (0, sandbox_client_1.submitRun)(connection, {
+        const submitted = await submitPublishing({ serverName, server, connection }, {
             definition,
             services,
             endpoints,
@@ -333,7 +417,7 @@ function registerWorkCommands(remote, context) {
             ...(options.name ? { name: options.name } : {}),
             source,
             options: options.env ? { env: options.env } : {},
-        });
+        }, local, !!options.publish);
         environment.stdout.write(`${(0, server_client_1.printable)(submitted.id)} on ${serverName}: ${services.map(server_client_1.printable).join(', ')} from ${(0, server_client_1.printable)(source.ref)}${submitted.source.type === 'ref' ? ` at ${(0, server_client_1.printable)(submitted.source.commit)}` : ''}\n`);
         const followed = await (0, sandbox_client_1.followRun)(connection, submitted, {
             signal: environment.abortCtrl.signal,

package/dist/server/endpoints.js

@@ -288,6 +288,9 @@ class EndpointGateway {
             return page(res, 503, 'Starting', `<p>The services of this endpoint are ${run.wakes ? 'waking up' : 'starting'} (${escape(run.state)}), this page reloads until they are up.</p>`);
         }
         if (run.state === 'asleep') {
+            // it may wake on a later request, once there is a place for it
+            res.setHeader('refresh', '30');
+            res.setHeader('retry-after', '30');
             return page(res, 503, 'Asleep', `<p>The services of this endpoint sleep and can not wake now: ${escape(refused ?? 'try again')}.</p>`);
         }
         const why = run.stoppedBy === 'ttl'

package/dist/server/runs.js

@@ -124,6 +124,11 @@ class RunRegistry {
                     this.expireLater(entry);
                 }
             }
+            else if (run.state === 'asleep') {
+                // its time ran out while the server was down: it ends now, and gives its place back
+                run.stoppedBy ?? (run.stoppedBy = 'ttl');
+                this.finish(entry, 'succeeded');
+            }
             else if (run.state === 'queued' || run.state === 'running') {
                 this.finish(entry, 'failed', `the server stopped while the run was ${run.state}, submit it again`);
             }
@@ -146,7 +151,7 @@ class RunRegistry {
         }
         this.checkLimits(owner, waiting);
         if (spec.up) {
-            this.checkUpLimits(owner);
+            this.checkUpLimits(owner, spec.up.name);
             this.checkHosts(owner, spec.up);
         }
         const run = {
@@ -515,20 +520,59 @@ class RunRegistry {
             throw new QuotaError(`you have ${limits.queued} runs in the queue, wait for one to start or cancel one`);
         }
     }
-    // Service runs that are not over, of the caller and of everybody, against what may be:
-    // one that is asleep counts, it wakes without asking for a place.
-    checkUpLimits(owner) {
+    // Service runs that are starting or up, of the caller and of everybody, against what may
+    // be. One that is asleep does not count: it asks for a place when it wakes (visit). The runs
+    // of a caller with one name take one place: the newest replaces the others once it is up,
+    // and an older one that gets up after it goes (markUp), so a new run of a name the caller
+    // has does not need another. Several of one name that are still starting share it too:
+    // what they take while they start is held by runs.limits.running and maxConcurrent.
+    checkUpLimits(owner, name) {
+        // what a caller keeps asleep is held by a limit of its own: a run that sleeps may keep the
+        // volumes of its services. A run of a name the caller has a run of (asleep, up or
+        // starting) replaces it, it is not one more.
+        const asleep = this.options.up?.asleep;
+        if (asleep !== undefined) {
+            const open = [...this.entries.values()].filter((entry) => entry.run.up && !isFinal(entry.run.state) && this.owns(owner, entry));
+            const sleeping = new Set(open.filter((entry) => entry.run.state === 'asleep').map((entry) => entry.run.up?.name));
+            if (!open.some((entry) => entry.run.up?.name === name) && sleeping.size >= asleep) {
+                throw new QuotaError(`you have ${asleep} service runs asleep, stop one or wait for its end`);
+            }
+        }
+        const full = this.upLimitReached(owner, name);
+        if (full === 'caller') {
+            throw new QuotaError(`you have ${this.options.up?.perCaller} service runs starting or up, stop one or wait for its end`);
+        }
+        if (full === 'server') {
+            throw new RunError(`the server has ${this.options.up?.total} service runs starting or up, try again later`);
+        }
+    }
+    // Whose limit a service run of the caller with this name would go over, if any
+    upLimitReached(owner, name) {
         const limits = this.options.up;
         if (!limits) {
-            return;
+            return undefined;
         }
-        const open = [...this.entries.values()].filter((entry) => entry.run.up && !isFinal(entry.run.state));
-        if (open.filter((entry) => this.owns(owner, entry)).length >= limits.perCaller) {
-            throw new QuotaError(`you have ${limits.perCaller} service runs starting, up or asleep, stop one or wait for its end`);
+        const places = new Set();
+        const mine = new Set();
+        for (const entry of this.entries.values()) {
+            if (!entry.run.up || isFinal(entry.run.state) || entry.run.state === 'asleep') {
+                continue;
+            }
+            places.add(JSON.stringify([entry.run.owner.iss, entry.run.owner.sub, entry.run.up.name]));
+            if (this.owns(owner, entry)) {
+                mine.add(entry.run.up.name);
+            }
+        }
+        if (mine.has(name)) {
+            return undefined;
+        }
+        if (mine.size >= limits.perCaller) {
+            return 'caller';
         }
-        if (open.length >= limits.total) {
-            throw new RunError(`the server has ${limits.total} service runs starting, up or asleep, try again later`);
+        if (places.size >= limits.total) {
+            return 'server';
         }
+        return undefined;
     }
     // A host is one run's, or a run's that replaces it (same owner and name) once it is up:
     // two labels that come out the same are refused, they would reach each other's services.
@@ -666,6 +710,18 @@ class RunRegistry {
                 this.stop(other, `replaced by ${entry.run.id}`);
             }
         }
+        // A newer run of the name that is up or asleep already (this one waited for an approval
+        // while it got up) is what the owner started last: this one goes, so the runs of a name,
+        // which take one place of runs.up.limits, never hold more than one set of services.
+        const newer = entries
+            .slice(entries.indexOf(entry) + 1)
+            .find((other) => other.run.up?.name === spec.name &&
+            this.owns(entry.run.owner, other) &&
+            (other.run.state === 'up' || other.run.state === 'asleep'));
+        if (newer) {
+            entry.run.stoppedBy = 'replaced';
+            this.stop(entry, `replaced by ${newer.run.id}`);
+        }
         this.dispatch();
     }
     // Stops a service run at its expiry, and puts one that is up to sleep at its sleepsAt. A
@@ -719,9 +775,9 @@ class RunRegistry {
     }
     /**
      * A request to an endpoint of a service run: one that is up stays up for its sleepTtl from
-     * now, one that is asleep is started again (it holds its place of runs.up.limits while it
-     * sleeps), if `mayWake` finds its owner may still run it: else it ends. Answers why it was
-     * not woken, or undefined.
+     * now, one that is asleep is started again, if `mayWake` finds its owner may still run it
+     * (else it ends) and there is a place of runs.up.limits for it (else it sleeps on, and the
+     * next request asks again). Answers why it was not woken, or undefined.
      */
     visit(id, mayWake) {
         const entry = this.entries.get(id);
@@ -746,6 +802,13 @@ class RunRegistry {
             this.finish(entry, 'failed', refused);
             return refused;
         }
+        const full = this.upLimitReached(entry.run.owner, entry.run.up.name);
+        if (full === 'caller') {
+            return 'its owner has as many service runs starting or up as they may, it wakes once one of them stops or sleeps';
+        }
+        if (full === 'server') {
+            return 'the server has as many service runs starting or up as it may, it wakes once one of them stops or sleeps';
+        }
         this.clearTimer(entry);
         entry.abort = new AbortController();
         entry.released = false;

package/dist/server/server-config.js

@@ -525,6 +525,9 @@ exports.serverConfigSchema = zod_1.z
                 .object({
                 // service runs one caller has starting or up at a time; one more is 429
                 up: zod_1.z.number().int().min(1).default(3),
+                // service runs one caller has asleep, which take no place of `up`; a new run
+                // when there are this many is 429
+                asleep: zod_1.z.number().int().min(1).default(10),
             })
                 .strict()
                 .default({}),

package/dist/server/server.js

@@ -707,6 +707,7 @@ async function startServer(config, environment, options = {}) {
         up: {
             maxTtl: (0, units_1.parseDuration)(config.runs.up.maxTtl),
             perCaller: config.runs.up.limits.up,
+            asleep: config.runs.up.limits.asleep,
             total: config.runs.up.total,
         },
         store: new run_store_1.FileRunStore((0, path_1.join)(storage, 'records')),

package/dist/utils/terminal-prompt.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isYes = exports.getTerminalPrompt = exports.terminalPrompt = void 0;
+const readline_1 = require("readline");
+/**
+ * Asks the person at the terminal one question and answers the line they typed, or
+ * undefined when the input ended or the signal stopped the command first (Ctrl-C).
+ * The terminal stays in its own line mode, so Ctrl-C is a signal as anywhere else.
+ */
+function terminalPrompt(input, output, signal) {
+    return (question) => new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve(undefined);
+            return;
+        }
+        const lines = (0, readline_1.createInterface)({ input, output, terminal: false });
+        let answer;
+        const stop = () => lines.close();
+        signal.addEventListener('abort', stop, { once: true });
+        lines.once('close', () => {
+            signal.removeEventListener('abort', stop);
+            if (answer === undefined) {
+                // what was asked ends on a line of its own
+                output.write('\n');
+            }
+            resolve(answer);
+        });
+        lines.question(question, (line) => {
+            answer = line;
+            lines.close();
+        });
+    });
+}
+exports.terminalPrompt = terminalPrompt;
+/**
+ * The prompt of the CLI: only when somebody sits at a terminal to answer it, never in
+ * CI, where a question would wait until the job times out.
+ */
+function getTerminalPrompt(processEnvs, signal, stdio = process) {
+    if (!stdio.stdin.isTTY || !stdio.stdout.isTTY || isSet(processEnvs.CI)) {
+        return undefined;
+    }
+    return terminalPrompt(stdio.stdin, stdio.stdout, signal);
+}
+exports.getTerminalPrompt = getTerminalPrompt;
+function isSet(value) {
+    return value !== undefined && value !== '' && value !== '0' && value.toLowerCase() !== 'false';
+}
+function isYes(answer) {
+    return /^\s*y(es)?\s*$/i.test(answer ?? '');
+}
+exports.isYes = isYes;
+//# sourceMappingURL=terminal-prompt.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hammerkit",
   "description": "Containerized build tool with incremental caching that runs the same build file locally, in Docker and on Kubernetes.",
-  "version": "1.27.0-next.26",
+  "version": "1.27.0-next.28",
   "keywords": [
     "build",
     "build-tool",