hammerkit 1.27.0-next.3 → 1.27.0-next.4

package/dist/server/server-command.js

@@ -5,6 +5,7 @@ const commander_1 = require("commander");
 const log_1 = require("../log");
 const server_config_1 = require("./server-config");
 const server_1 = require("./server");
+const abort_on_signals_1 = require("../utils/abort-on-signals");
 // Runs this machine as a hammerkit server until interrupted. Like `remote`, it
 // only needs its own config file, not a build file.
 function registerServerCommand(program, environment) {
@@ -13,31 +14,46 @@ function registerServerCommand(program, environment) {
         .description('serve this machine to remote runs (experimental)')
         .addOption(new commander_1.Option('-c, --config <file>', 'server config file').env('HAMMERKIT_SERVER_CONFIG'))
         .action(async (options) => {
+        // SIGHUP reads the entitlements again, so who may do what changes without a
+        // restart; the rest of the config needs one. The server takes it over from the
+        // abort of the CLI, which stops other commands on it, before it starts: a SIGHUP
+        // while it reads its config and starts waits for it. Windows sends SIGHUP when the
+        // console closes, which stops the server there too.
+        let server;
+        let reloadWhenStarted = false;
+        const reload = async (running) => {
+            try {
+                const result = running.reload(await (0, server_config_1.readServerConfig)(environment, options.config));
+                if (result.restart.length > 0) {
+                    environment.stdout.write(`changed but not reloaded, restart for: ${result.restart.join(', ')}\n`);
+                }
+            }
+            catch (e) {
+                environment.stdout.write(`entitlements were not reloaded: ${(0, log_1.getErrorMessage)(e)}\n`);
+            }
+        };
+        const releaseReload = process.platform !== 'win32'
+            ? (0, abort_on_signals_1.takeOverSignal)(process, 'SIGHUP', () => {
+                if (server) {
+                    void reload(server);
+                }
+                else {
+                    reloadWhenStarted = true;
+                }
+            })
+            : () => undefined;
         try {
             if (!options.config) {
                 throw new Error('pass the server config with --config or HAMMERKIT_SERVER_CONFIG');
             }
             const config = await (0, server_config_1.readServerConfig)(environment, options.config);
-            const server = await (0, server_1.startServer)(config, environment, {
+            const running = await (0, server_1.startServer)(config, environment, {
                 log: (line) => environment.stdout.write(`${line}\n`),
             });
-            environment.stdout.write(`hammerkit server listening on ${server.url}\n`);
-            // SIGHUP reads the entitlements again, so who may do what changes without
-            // a restart; the rest of the config needs one
-            const reload = async () => {
-                try {
-                    const result = server.reload(await (0, server_config_1.readServerConfig)(environment, options.config));
-                    if (result.restart.length > 0) {
-                        environment.stdout.write(`changed but not reloaded, restart for: ${result.restart.join(', ')}\n`);
-                    }
-                }
-                catch (e) {
-                    environment.stdout.write(`entitlements were not reloaded: ${(0, log_1.getErrorMessage)(e)}\n`);
-                }
-            };
-            const onReload = () => void reload();
-            if (process.platform !== 'win32') {
-                process.on('SIGHUP', onReload);
+            server = running;
+            environment.stdout.write(`hammerkit server listening on ${running.url}\n`);
+            if (reloadWhenStarted) {
+                void reload(running);
             }
             await new Promise((resolve) => {
                 if (environment.abortCtrl.signal.aborted) {
@@ -45,8 +61,8 @@ function registerServerCommand(program, environment) {
                 }
                 environment.abortCtrl.signal.addEventListener('abort', () => resolve(), { once: true });
             });
-            process.off('SIGHUP', onReload);
-            await server.close();
+            releaseReload();
+            await running.close();
             environment.stdout.write('hammerkit server stopped\n');
         }
         catch (e) {
@@ -55,6 +71,9 @@ function registerServerCommand(program, environment) {
             }
             program.error(`Server was not successful: ${(0, log_1.getErrorMessage)(e)}`, { exitCode: 1 });
         }
+        finally {
+            releaseReload();
+        }
     });
 }
 exports.registerServerCommand = registerServerCommand;

package/dist/utils/abort-on-signals.js

@@ -1,17 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.abortOnSignals = exports.ABORT_SIGNALS = void 0;
+exports.takeOverSignal = exports.abortOnSignals = exports.ABORT_SIGNALS = void 0;
 // Ctrl-C (SIGINT), a CI job being cancelled or a supervisor stopping hammerkit
 // (SIGTERM) and a closed terminal (SIGHUP) all stop the run the same way: abort,
 // so services are removed and local tasks' process groups are killed. Without a
 // handler Node exits on SIGTERM/SIGHUP at once and leaves both behind.
 exports.ABORT_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
-function abortOnSignals(source, abortCtrl) {
-    for (const signal of exports.ABORT_SIGNALS) {
-        source.on(signal, () => {
-            abortCtrl.abort();
-        });
+// signals a running command gives a meaning of its own (the server reloads its
+// entitlements on SIGHUP), per source and counted by how many hold them: they don't
+// abort the run
+const takenOver = new WeakMap();
+function heldOn(source) {
+    let held = takenOver.get(source);
+    if (!held) {
+        held = new Map();
+        takenOver.set(source, held);
     }
+    return held;
+}
+/**
+ * Stops the run on the abort signals, all but those a command took over with
+ * `takeOverSignal`. Returns what removes the listeners again.
+ */
+function abortOnSignals(source, abortCtrl) {
+    const listeners = exports.ABORT_SIGNALS.map((signal) => {
+        const listener = () => {
+            if (!takenOver.get(source)?.get(signal)) {
+                abortCtrl.abort();
+            }
+        };
+        source.on(signal, listener);
+        return { signal, listener };
+    });
+    return () => listeners.forEach(({ signal, listener }) => source.off(signal, listener));
 }
 exports.abortOnSignals = abortOnSignals;
+/**
+ * Calls `handler` on `signal` instead of stopping the run, until the returned function
+ * gives the signal back.
+ */
+function takeOverSignal(source, signal, handler) {
+    const held = heldOn(source);
+    held.set(signal, (held.get(signal) ?? 0) + 1);
+    source.on(signal, handler);
+    let released = false;
+    return () => {
+        if (released) {
+            return;
+        }
+        released = true;
+        source.off(signal, handler);
+        held.set(signal, (held.get(signal) ?? 1) - 1);
+    };
+}
+exports.takeOverSignal = takeOverSignal;
 //# sourceMappingURL=abort-on-signals.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.3",
+  "version": "1.27.0-next.4",
   "keywords": [
     "build",
     "build-tool",