hammerkit 1.27.0-next.8 → 2.0.0-next.1

package/dist/server/executor.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HostExecutor = exports.volumeScope = exports.cacheNamespace = exports.defaultWorker = void 0;
+exports.HostExecutor = exports.removeServiceRunVolumes = exports.serviceRunScopes = exports.volumeScope = exports.cacheNamespace = exports.defaultWorker = void 0;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
+const checks_1 = require("./checks");
 const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
@@ -11,6 +12,7 @@ const resolve_git_source_1 = require("../includes/resolve-git-source");
 const git_checkout_1 = require("./git-checkout");
 const run_plan_1 = require("./run-plan");
 const work_network_1 = require("../planner/work-network");
+const execute_docker_1 = require("../executer/execute-docker");
 // `.git` as a file system may read it: any case, and a name Windows reads without its
 // trailing dots and spaces, or by its short name
 function isGitDirectory(segment) {
@@ -35,19 +37,65 @@ exports.defaultWorker = defaultWorker;
 // share one, those of an upload or a sandbox only their owner's. Somebody who can only
 // upload, or an agent on a sandbox, can not leave an entry for a run from a reviewed
 // repository to find.
+//
+// A check on a sandbox runs on a copy of the files a commit of them would hold, so it is a
+// run of the repository like a ref run of that commit, and shares its cache: what its
+// owner may write in the sandbox is not part of it. It leaves entries a run from main can
+// find, keyed by the files it ran on, as a ref run of a branch does: so only a caller who
+// may push a branch of the repository and run from it may check (server.ts).
 function cacheNamespace(run) {
-    const key = run.source.type === 'ref' ? `ref\0${run.source.repo}` : `${run.source.type}\0${run.owner.iss}\0${run.owner.sub}`;
-    return `${run.source.type}-${(0, crypto_1.createHash)('sha256').update(key).digest('hex').slice(0, 24)}`;
+    const repository = run.source.type === 'ref' || (run.source.type === 'sandbox' && run.source.check);
+    const key = repository
+        ? `ref\0${run.source.repo}`
+        : `${run.source.type}\0${run.owner.iss}\0${run.owner.sub}`;
+    return `${repository ? 'ref' : run.source.type}-${(0, crypto_1.createHash)('sha256').update(key).digest('hex').slice(0, 24)}`;
 }
 exports.cacheNamespace = cacheNamespace;
 // The docker volumes of a run's services are its caller's, within the cache's source trust:
 // two callers of one repository share a cache, a task is keyed by what it reads, but not the
-// data their services keep.
-function volumeScope(run) {
+// data their services keep. A service run's are its own: they stay while it sleeps and go
+// when it ends (removeServiceRunVolumes). They carry the server's key (see serviceRunScopes),
+// so a server sweeps its own only, next to another one on the same docker.
+function volumeScope(run, server = '') {
+    if (run.up) {
+        return `${serviceRunScopes(server)}${(0, crypto_1.createHash)('sha256').update(run.id).digest('hex').slice(0, 24)}`;
+    }
     const key = `${cacheNamespace(run)}\0${run.owner.iss}\0${run.owner.sub}`;
     return `${run.source.type}-${(0, crypto_1.createHash)('sha256').update(key).digest('hex').slice(0, 24)}`;
 }
 exports.volumeScope = volumeScope;
+// the start of the volume scopes of the service runs of a server, by the directory its runs
+// work in
+function serviceRunScopes(server) {
+    return `up-${(0, crypto_1.createHash)('sha256').update(server).digest('hex').slice(0, 8)}-`;
+}
+exports.serviceRunScopes = serviceRunScopes;
+// the volume of a service of a service run, with the scope of its run (see scopeServiceVolumes)
+const SERVICE_RUN_VOLUME = /^hammerkit-(up-[0-9a-f]{8}-[0-9a-f]{24})-/;
+/**
+ * Removes the docker volumes of the services of service runs whose scope `remove` names: of
+ * one run that ended, or at a start, of every run but those that sleep with their volumes.
+ * One a container still uses stays, and is said.
+ */
+async function removeServiceRunVolumes(docker, remove, log) {
+    const listed = await docker.listVolumes({ filters: { name: ['hammerkit-up-'] } });
+    const removed = [];
+    for (const volume of listed.Volumes ?? []) {
+        const scope = SERVICE_RUN_VOLUME.exec(volume.Name)?.[1];
+        if (!scope || !remove(scope)) {
+            continue;
+        }
+        try {
+            await docker.getVolume(volume.Name).remove();
+            removed.push(volume.Name);
+        }
+        catch (e) {
+            log(`the volume ${volume.Name} could not be removed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return removed;
+}
+exports.removeServiceRunVolumes = removeServiceRunVolumes;
 /**
  * Runs the tasks of a run on this machine with the engine of `hammerkit run`, in a
  * process of its own.
@@ -65,6 +113,56 @@ exports.volumeScope = volumeScope;
 class HostExecutor {
     constructor(options) {
         this.options = options;
+        // the directories of the executions that run now
+        this.directories = new Set();
+    }
+    // the docker daemon the runs' services are on, as their processes reach it
+    docker() {
+        return (0, execute_docker_1.createDockerClient)(this.options.planning.environment.processEnvs.DOCKER_HOST);
+    }
+    // the volumes of a service run's services, which its end removes
+    async removeVolumes(run, context) {
+        const scope = volumeScope(run, this.options.directory);
+        const say = (text) => {
+            this.options.log?.(`run=${run.id} ${text}`);
+            context?.emit({ type: 'log', task: 'hammerkit', stream: 'stderr', text });
+        };
+        try {
+            await removeServiceRunVolumes(this.docker(), (candidate) => candidate === scope, say);
+        }
+        catch (e) {
+            say(`the volumes of the services could not be removed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    /** A service run that slept with its volumes ended without waking: they go. */
+    async forget(run) {
+        if (run.up && !this.options.placement) {
+            await this.removeVolumes(run);
+        }
+    }
+    /**
+     * At the start of the server: the volumes of service runs go, but of those that sleep with
+     * them. A server without docker has none.
+     */
+    restored(runs) {
+        if (this.options.placement) {
+            return;
+        }
+        const own = serviceRunScopes(this.options.directory);
+        const kept = new Set(runs.filter((run) => run.up).map((run) => volumeScope(run, this.options.directory)));
+        const log = (line) => this.options.log?.(line);
+        removeServiceRunVolumes(this.docker(), (scope) => scope.startsWith(own) && !kept.has(scope), log)
+            .then((removed) => {
+            if (removed.length > 0) {
+                log(`removed ${removed.length} volumes of service runs from before the server started`);
+            }
+        })
+            .catch((e) => {
+            const code = e.code;
+            if (code !== 'ENOENT' && code !== 'ECONNREFUSED') {
+                log(`the volumes of earlier service runs could not be removed: ${e instanceof Error ? e.message : e}`);
+            }
+        });
     }
     async execute(run, context) {
         const { definitions, planning, repos } = this.options;
@@ -110,7 +208,8 @@ class HostExecutor {
             abort();
         }
         context.signal.addEventListener('abort', abort, { once: true });
-        const root = (0, path_1.join)(this.options.directory, run.id);
+        // a service run that moves executes beside itself, each in a directory of its own
+        const root = this.directoryOf(run);
         let attachment;
         try {
             // where the process of the run starts: the checkout of a ref, or for a sandbox the
@@ -121,13 +220,42 @@ class HostExecutor {
             let claim;
             // the files of the sandbox the tasks work on
             let work;
-            if (source.type === 'ref') {
+            if (source.type === 'sandbox' && source.check) {
+                // a check works on the files a push of the sandbox commits, copied out of it: never
+                // on the sandbox, whose ignored files (node_modules, outputs) its owner writes
+                const { registry, network } = sandboxes;
+                cwd = (0, path_1.join)(root, 'source');
+                try {
+                    await registry.exportTree(source.id, source.tree, cwd, abortCtrl.signal);
+                }
+                catch (e) {
+                    throw new Error(`the files of the sandbox ${source.id} could not be copied for the check, submit it again: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                // a repository of its own, as a checkout of the commit is: the root of the project,
+                // which the paths of the tasks' keys are relative to, is the one of git
+                await (0, git_checkout_1.git)(['init', '--quiet', cwd], {}, abortCtrl.signal, `the check of sandbox ${source.id}`, 'init');
+                context.emit({
+                    type: 'log',
+                    task: 'hammerkit',
+                    stream: 'stdout',
+                    text: `check of sandbox ${source.id} of ${source.repo}: files ${source.tree}, fetched at ${source.commit}`,
+                });
+                await this.writeBundle(cwd, bundle.files);
+                input = {
+                    entry: (0, path_1.join)(cwd, version.entry),
+                    ...(planning.policy.network ? { network: (0, work_network_1.toNetworkSchema)(planning.policy.network) } : {}),
+                    sandboxNetwork: network,
+                };
+            }
+            else if (source.type === 'ref') {
                 cwd = (0, path_1.join)(root, 'source');
                 const { repo, ref, commit: pinned } = source;
                 const credentials = await repos.credentials(repo);
                 let commit;
                 try {
-                    commit = await (0, git_checkout_1.checkoutRef)(repos.url(repo), ref, cwd, credentials.env, abortCtrl.signal, pinned);
+                    // a woken service run starts the commit it started first, where the ref is now or not
+                    const fetched = run.wakes ? pinned : ref;
+                    commit = await (0, git_checkout_1.checkoutRef)(repos.url(repo), fetched, cwd, credentials.env, abortCtrl.signal, pinned);
                 }
                 catch (e) {
                     throw repos.scrub(e, credentials.values);
@@ -187,27 +315,51 @@ class HostExecutor {
                     tasks: run.tasks,
                     options: run.options,
                     accounts: run.accounts,
-                    volumeScope: volumeScope(run),
+                    volumeScope: volumeScope(run, this.options.directory),
+                    ...((0, checks_1.isCheckRun)(run) ? { check: true } : {}),
                     catalog: planning.environment.hosted?.catalog,
+                    ...(run.up
+                        ? {
+                            up: {
+                                services: run.up.services,
+                                endpoints: run.up.endpoints.map(({ service, port }) => ({ service, port })),
+                            },
+                        }
+                        : {}),
                     ...(placed ? { kubernetes: placed.kubernetes } : {}),
+                    ...(!placed && this.options.capabilityRuntime ? { capabilityRuntime: this.options.capabilityRuntime } : {}),
                 }, cwd, { ...this.processEnvironment(home, cache), ...placed?.env }, context, abortCtrl.signal);
             }
             finally {
                 if (placement && placed) {
                     await placement.release(run, context);
                 }
+                else if (run.up && !context.keep?.()) {
+                    // the services are gone with the process, their volumes stay only while the run sleeps
+                    await this.removeVolumes(run, context);
+                }
             }
         }
         finally {
             context.signal.removeEventListener('abort', abort);
             attachment?.release?.();
             await this.removeRunDirectory(run, root, context);
+            this.directories.delete(root);
             if (source.type === 'sandbox') {
                 // what the run wrote counts against the owner's limits, from their next run or create
                 sandboxes?.registry.measure(source.id).catch(() => undefined);
             }
         }
     }
+    directoryOf(run) {
+        for (let execution = 1;; execution++) {
+            const root = (0, path_1.join)(this.options.directory, execution === 1 ? run.id : `${run.id}-${execution}`);
+            if (!this.directories.has(root)) {
+                this.directories.add(root);
+                return root;
+            }
+        }
+    }
     // A task of the run may still hold a file of its directory for a moment after the run
     // ended, which Windows refuses to remove. A directory that stays is reported, to the run
     // by its error code and to the operator with its path; it does not change how the run ended.
@@ -282,6 +434,9 @@ class HostExecutor {
                     if (message.kind === 'event') {
                         context.emit(message.event);
                     }
+                    else if (message.kind === 'up') {
+                        context.up?.(message.targets);
+                    }
                     else if (message.kind === 'result') {
                         result = message;
                         // nothing left to tell the process