@magland/mochi 0.3.1

package/dist/runner/manual-run.js

@@ -0,0 +1,272 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManualSession = void 0;
+const os = __importStar(require("os"));
+const actions_1 = require("./actions");
+const client_1 = require("./client");
+const docker_1 = require("./docker");
+const externals_1 = require("./externals");
+const job_1 = require("./job");
+// `mochi job run`: the process behind a pasted command. It redeems the
+// command for a session, then takes the run's manual jobs one at a time,
+// showing each job's steps and asking before executing anything, and exits
+// when the run has nothing left for it. Execution itself is the runner's own
+// path (executeSpec), so a job runs here exactly as it would on a registered
+// runner; what differs is how the lease was come by, and that a person
+// approved the steps.
+const ACQUIRE_BACKOFF_MAX = 60_000;
+class ManualSession {
+    opts;
+    session = '';
+    redeemed = null;
+    stopping = false;
+    polling = null;
+    ran = [];
+    workDir;
+    actions;
+    externals;
+    constructor(opts) {
+        this.opts = opts;
+        this.workDir = opts.workDir ?? (0, job_1.defaultWorkDir)();
+        const actionCache = opts.cacheDir ? `${opts.cacheDir}/actions` : (0, actions_1.defaultActionCacheDir)();
+        const externalsCache = opts.cacheDir ? `${opts.cacheDir}/externals` : (0, externals_1.defaultExternalsDir)();
+        this.actions = new actions_1.ActionStore(actionCache, opts.actionsUrl, opts.actionCache);
+        this.externals = new externals_1.Externals(externalsCache);
+    }
+    /** Finish the job in hand, then leave; a second call is the caller's business. */
+    stop() {
+        this.stopping = true;
+        this.polling?.abort();
+    }
+    /** True when any job this session executed concluded failure. */
+    sawFailure() {
+        return this.ran.some((r) => r.conclusion === 'failure');
+    }
+    async redeem() {
+        let res;
+        try {
+            res = await fetch(`${this.opts.host}/api/manual/redeem`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ token: this.opts.token, host: os.hostname() }),
+            });
+        }
+        catch (e) {
+            throw new Error(`could not reach ${this.opts.host}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        if (!res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            throw new Error(body.error ?? `the server answered ${res.status}`);
+        }
+        return (await res.json());
+    }
+    preview(spec) {
+        const image = (0, client_1.imageForLabels)({ ...client_1.DEFAULT_IMAGES, ...this.opts.images }, spec.runsOn);
+        console.log('');
+        console.log(`  ${spec.address.collection}/${spec.address.repo}  run #${spec.runNumber}  job "${spec.name}"  at ${spec.sha.slice(0, 8)} on ${spec.ref}`);
+        console.log(`  image: ${image}  (engine: ${(0, docker_1.containerEngine)()})`);
+        if (spec.matrix)
+            console.log(`  matrix: ${JSON.stringify(spec.matrix)}`);
+        const steps = spec.steps;
+        steps.forEach((s, i) => {
+            const n = String(i + 1).padStart(3);
+            if (s.uses) {
+                console.log(`${n}  uses: ${s.uses}${s.name ? `  (${s.name})` : ''}`);
+            }
+            else if (s.run !== undefined) {
+                const lines = s.run.split('\n').filter((l) => l.trim() !== '');
+                console.log(`${n}  run: ${lines[0] ?? ''}${s.name ? `  (${s.name})` : ''}`);
+                for (const extra of lines.slice(1, 20))
+                    console.log(`          ${extra}`);
+                if (lines.length > 21)
+                    console.log(`          ... ${lines.length - 21} more lines`);
+            }
+            else {
+                console.log(`${n}  (empty step)`);
+            }
+        });
+        console.log('');
+    }
+    async release(spec) {
+        const a = spec.address;
+        try {
+            await fetch(`${this.opts.host}/api/manual/jobs/${encodeURIComponent(a.collection)}/${encodeURIComponent(a.repo)}/${a.run}/${encodeURIComponent(a.job)}/release`, {
+                method: 'POST',
+                headers: { authorization: `Bearer ${this.session}`, 'x-mochi-lease': spec.lease },
+            });
+        }
+        catch {
+            // The lease expires on its own; a release that could not be delivered
+            // costs a minute, not a job... except that an expired manual lease
+            // fails the job, so say so rather than leaving it to be discovered.
+            console.error('  could not hand the job back; the vault will fail it when the lease expires');
+        }
+    }
+    async acquire() {
+        const poll = new AbortController();
+        this.polling = poll;
+        try {
+            const res = await fetch(`${this.opts.host}/api/manual/acquire`, {
+                method: 'POST',
+                headers: { authorization: `Bearer ${this.session}`, 'content-type': 'application/json' },
+                body: JSON.stringify({ job: this.opts.jobFilter ?? undefined }),
+                signal: poll.signal,
+            });
+            if (res.status === 204)
+                return { kind: 'wait' };
+            if (res.status === 410) {
+                return { kind: 'done', body: (await res.json().catch(() => ({}))) };
+            }
+            if (!res.ok) {
+                const body = (await res.json().catch(() => ({})));
+                throw new Error(body.error ?? `acquire failed with ${res.status}`);
+            }
+            return { kind: 'job', spec: (await res.json()) };
+        }
+        catch (e) {
+            if (this.stopping)
+                return { kind: 'wait' };
+            throw e;
+        }
+        finally {
+            this.polling = null;
+        }
+    }
+    /**
+     * Run the session to its end. Returns 0 when everything this session ran
+     * succeeded (or it ran nothing), 1 when something it ran failed, so a
+     * scripted `--yes` use gets an exit status worth checking.
+     */
+    async run() {
+        const redeemed = await this.redeem();
+        this.redeemed = redeemed;
+        this.session = redeemed.sessionToken;
+        console.log(`mochi job run: ${redeemed.collection}/${redeemed.repo} run #${redeemed.run.number} "${redeemed.run.workflowName}"`);
+        console.log(`  server:  ${this.opts.host}`);
+        console.log(`  commit:  ${redeemed.run.sha.slice(0, 8)} on ${redeemed.run.refName}`);
+        console.log(`  workdir: ${this.workDir}`);
+        const manualJobs = redeemed.jobs;
+        const waiting = manualJobs.filter((j) => j.status === 'queued');
+        console.log(`  manual jobs: ${manualJobs.map((j) => `${j.name}${j.status === 'completed' ? ` (${j.conclusion})` : ''}`).join(', ') || 'none'}`);
+        if (this.opts.jobFilter) {
+            const matches = manualJobs.some((j) => j.key === this.opts.jobFilter || j.id === this.opts.jobFilter || j.name === this.opts.jobFilter);
+            // A glob can match without equalling, so this is a hint, not a refusal;
+            // the server's answer is the authority and arrives on the first acquire.
+            if (!matches)
+                console.log(`  note: --job ${this.opts.jobFilter} names none of them exactly; globs are matched by the vault`);
+        }
+        if (waiting.length === 0)
+            console.log('  nothing is waiting right now; jobs may yet become eligible as others finish');
+        let backoff = 1000;
+        let saidWaiting = false;
+        for (;;) {
+            if (this.stopping) {
+                console.log('Stopped. Unclaimed manual jobs stay waiting; the run page mints a fresh command for them.');
+                break;
+            }
+            let got;
+            try {
+                got = await this.acquire();
+                backoff = 1000;
+            }
+            catch (e) {
+                console.error(`  ${e instanceof Error ? e.message : e}; retrying in ${Math.round(backoff / 1000)}s`);
+                await new Promise((r) => setTimeout(r, backoff));
+                backoff = Math.min(backoff * 2, ACQUIRE_BACKOFF_MAX);
+                continue;
+            }
+            if (got.kind === 'wait') {
+                if (!this.stopping && !saidWaiting) {
+                    console.log('  waiting: the next manual job is blocked on jobs running elsewhere...');
+                    saidWaiting = true;
+                }
+                continue;
+            }
+            if (got.kind === 'done') {
+                this.summarize(got.body);
+                break;
+            }
+            saidWaiting = false;
+            const spec = got.spec;
+            if (!this.opts.yes) {
+                this.preview(spec);
+                const steps = spec.steps.length;
+                const ok = await this.opts.confirm(`Run ${steps === 1 ? 'this step' : `these ${steps} steps`} on ${os.hostname()}? [y/N] `);
+                if (!ok) {
+                    await this.release(spec);
+                    console.log('Declined; the job goes back to waiting for a command.');
+                    break;
+                }
+            }
+            const result = await (0, client_1.executeSpec)(spec, {
+                host: this.opts.host,
+                token: this.session,
+                runnerName: `a manual session on ${os.hostname()}`,
+                imageFor: (labels) => (0, client_1.imageForLabels)({ ...client_1.DEFAULT_IMAGES, ...this.opts.images }, labels),
+                workDir: this.workDir,
+                network: this.opts.network,
+                actions: this.actions,
+                externals: this.externals,
+            });
+            this.ran.push({ name: spec.name, conclusion: result.conclusion });
+        }
+        return this.sawFailure() ? 1 : 0;
+    }
+    summarize(body) {
+        console.log('');
+        if (this.ran.length > 0) {
+            for (const r of this.ran)
+                console.log(`  ${r.name}: ${r.conclusion}`);
+        }
+        const run = body.run;
+        if (run?.status === 'completed') {
+            console.log(`Run #${run.number} finished: ${run.conclusion ?? 'completed'}`);
+        }
+        else if (body.reason) {
+            console.log(`Nothing more for this session: ${body.reason}`);
+            if (run)
+                console.log(`Run #${run.number} is ${run.status}; other jobs may still be running elsewhere.`);
+        }
+        else {
+            console.log('Nothing more for this session.');
+        }
+        const n = this.redeemed;
+        if (n) {
+            console.log(`  ${this.opts.host}/${encodeURIComponent(n.collection)}/${encodeURIComponent(n.repo)}/actions/runs/${n.run.number}`);
+        }
+    }
+}
+exports.ManualSession = ManualSession;