| ... | @@ -0,0 +1,208 @@ |
| 1 | import { execFile, spawn } from "node:child_process"; |
| 2 | import { createHash } from "node:crypto"; |
| 3 | import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs"; |
| 4 | import { connect, createServer } from "node:net"; |
| 5 | import { basename } from "node:path"; |
| 6 | import { setTimeout as sleep } from "node:timers/promises"; |
| 7 | import { promisify } from "node:util"; |
| 8 | |
| 9 | const { SOURCE_URL, BRANCH, PORT } = process.env; |
| 10 | const WORK = "/work"; |
| 11 | const REPO = `${WORK}/repo.git`; |
| 12 | const POLL_MS = 500; |
| 13 | const DRAIN_MS = 500; |
| 14 | const RETRY_FAILED_MS = 15000; |
| 15 | |
| 16 | const out = promisify(execFile); |
| 17 | const log = (...args) => console.log("[deploy]", ...args); |
| 18 | const run = (cmd, args, opts = {}, ok = [0]) => |
| 19 | new Promise((resolve, reject) => |
| 20 | spawn(cmd, args, { stdio: "inherit", ...opts }) |
| 21 | .once("error", reject) |
| 22 | .once("exit", (code) => (ok.includes(code) ? resolve() : reject(new Error(`${basename(cmd)} ${args[0]} exited with ${code}`)))), |
| 23 | ); |
| 24 | const git = (...args) => out("git", ["--git-dir", REPO, ...args]).then((result) => result.stdout.trim()); |
| 25 | |
| 26 | let live = null; |
| 27 | let wanted = null; |
| 28 | let recentModules = null; |
| 29 | const releases = new Set(); |
| 30 | let failed = { rev: null, at: 0 }; |
| 31 | |
| 32 | createServer((client) => { |
| 33 | const target = live; |
| 34 | if (!target) return client.destroy(); |
| 35 | const upstream = connect(target.port, "127.0.0.1"); |
| 36 | target.sockets.add(client); |
| 37 | client.setNoDelay(true); |
| 38 | upstream.setNoDelay(true); |
| 39 | const end = () => { |
| 40 | client.destroy(); |
| 41 | upstream.destroy(); |
| 42 | target.sockets.delete(client); |
| 43 | }; |
| 44 | client.pipe(upstream).pipe(client); |
| 45 | client.on("error", end).on("close", end); |
| 46 | upstream.on("error", end).on("close", end); |
| 47 | }).listen(Number(PORT)); |
| 48 | |
| 49 | async function remoteHead() { |
| 50 | const response = await fetch(`${SOURCE_URL}/info/refs?service=git-upload-pack`, { signal: AbortSignal.timeout(5000) }); |
| 51 | if (!response.ok) throw new Error(`${SOURCE_URL} answered ${response.status}`); |
| 52 | return (await response.text()).match(new RegExp(`([0-9a-f]{40}) refs/heads/${BRANCH}(?=\\0|\\n)`))?.[1] ?? null; |
| 53 | } |
| 54 | |
| 55 | async function install(dir, modules) { |
| 56 | const staging = `${modules}.partial`; |
| 57 | rmSync(staging, { recursive: true, force: true }); |
| 58 | mkdirSync(staging, { recursive: true }); |
| 59 | for (const file of ["package.json", "package-lock.json"]) copyFileSync(`${dir}/${file}`, `${staging}/${file}`); |
| 60 | await run("npm", ["ci", "--ignore-scripts", "--no-audit", "--no-fund", "--loglevel=error"], { cwd: staging }); |
| 61 | const { packages } = JSON.parse(readFileSync(`${staging}/package-lock.json`)); |
| 62 | const native = Object.entries(packages) |
| 63 | .filter(([path, pkg]) => path && pkg.hasInstallScript) |
| 64 | .map(([path]) => path.split("node_modules/").pop()); |
| 65 | if (native.length) await run("npm", ["rebuild", "--loglevel=error", ...native], { cwd: staging }); |
| 66 | renameSync(staging, modules); |
| 67 | } |
| 68 | |
| 69 | async function healthy(port, proc, current) { |
| 70 | for (const deadline = Date.now() + 90000; Date.now() < deadline; await sleep(100)) { |
| 71 | if (proc.exitCode !== null || proc.signalCode !== null) throw new Error("server exited during startup"); |
| 72 | current(); |
| 73 | const ok = await fetch(`http://127.0.0.1:${port}/api/ping`, { signal: AbortSignal.timeout(1000) }).then((response) => response.ok, () => false); |
| 74 | if (ok) return; |
| 75 | } |
| 76 | throw new Error("server did not become healthy"); |
| 77 | } |
| 78 | |
| 79 | const freePort = () => |
| 80 | new Promise((resolve) => { |
| 81 | const probe = createServer().listen(0, "127.0.0.1", () => { |
| 82 | const { port } = probe.address(); |
| 83 | probe.close(() => resolve(port)); |
| 84 | }); |
| 85 | }); |
| 86 | |
| 87 | function sweep() { |
| 88 | const used = { rel: new Set(), modules: new Set([recentModules]) }; |
| 89 | for (const release of releases) { |
| 90 | used.rel.add(release.rev); |
| 91 | if (release.modules) used.modules.add(basename(release.modules)).add(`${basename(release.modules)}.partial`); |
| 92 | } |
| 93 | for (const [name, keep] of Object.entries(used)) { |
| 94 | for (const entry of readdirSync(`${WORK}/${name}`)) if (!keep.has(entry)) rmSync(`${WORK}/${name}/${entry}`, { recursive: true, force: true }); |
| 95 | } |
| 96 | } |
| 97 | |
| 98 | function retire(old) { |
| 99 | setTimeout(() => { |
| 100 | for (const socket of old.sockets) socket.destroy(); |
| 101 | old.proc.kill("SIGTERM"); |
| 102 | setTimeout(() => old.proc.kill("SIGKILL"), 5000).unref(); |
| 103 | }, DRAIN_MS); |
| 104 | } |
| 105 | |
| 106 | async function deploy() { |
| 107 | const target = wanted; |
| 108 | const current = () => { |
| 109 | if (wanted !== target) throw new Error("superseded by a newer push"); |
| 110 | }; |
| 111 | let release; |
| 112 | let last = performance.now(); |
| 113 | const start = last; |
| 114 | const laps = []; |
| 115 | const lap = (name) => { |
| 116 | const now = performance.now(); |
| 117 | laps.push(`${name} ${Math.round(now - last)}ms`); |
| 118 | last = now; |
| 119 | }; |
| 120 | |
| 121 | try { |
| 122 | await run("git", ["--git-dir", REPO, "fetch", "--quiet", "--depth", "1", "--no-tags", SOURCE_URL, `refs/heads/${BRANCH}`]); |
| 123 | const rev = await git("rev-parse", "FETCH_HEAD"); |
| 124 | if (rev === live?.rev) return; |
| 125 | const [committedAt, subject] = (await git("log", "-1", "--format=%ct%n%s", rev)).split("\n"); |
| 126 | log(`deploying ${rev.slice(0, 7)} ${subject}`); |
| 127 | lap("fetch"); |
| 128 | |
| 129 | release = { rev, dir: `${WORK}/rel/${rev}`, modules: null, port: 0, proc: null, sockets: new Set() }; |
| 130 | releases.add(release); |
| 131 | rmSync(release.dir, { recursive: true, force: true }); |
| 132 | mkdirSync(release.dir, { recursive: true }); |
| 133 | await run("bash", ["-c", 'set -o pipefail; git --git-dir "$0" archive "$1" | tar -x -C "$2"', REPO, rev, release.dir]); |
| 134 | lap("extract"); |
| 135 | |
| 136 | const lock = createHash("sha256"); |
| 137 | for (const file of ["package.json", "package-lock.json"]) lock.update(readFileSync(`${release.dir}/${file}`)); |
| 138 | release.modules = `${WORK}/modules/${lock.digest("hex").slice(0, 16)}`; |
| 139 | const cached = existsSync(release.modules); |
| 140 | if (!cached) await install(release.dir, release.modules); |
| 141 | symlinkSync(`${release.modules}/node_modules`, `${release.dir}/node_modules`); |
| 142 | lap(cached ? "deps cached" : "deps installed"); |
| 143 | |
| 144 | await run(`${release.dir}/node_modules/.bin/tsc`, ["-p", "tsconfig.json", "--declaration", "false", "--declarationMap", "false", "--incremental", "false"], { cwd: release.dir }); |
| 145 | writeFileSync(`${release.dir}/.rev`, JSON.stringify({ rev, shortRev: rev.slice(0, 7), lastModified: Number(committedAt) })); |
| 146 | lap("build"); |
| 147 | |
| 148 | current(); |
| 149 | release.port = await freePort(); |
| 150 | // The server keeps jwt.key and other state in its working directory. |
| 151 | release.proc = spawn(process.execPath, ["--enable-source-maps", `${release.dir}/dist/bundle/start.js`], { |
| 152 | cwd: "/data", |
| 153 | stdio: "inherit", |
| 154 | env: { ...process.env, PORT: String(release.port) }, |
| 155 | }); |
| 156 | release.proc.once("exit", (code, signal) => { |
| 157 | if (live === release) { |
| 158 | live = null; |
| 159 | log(`server ${rev.slice(0, 7)} exited (${code ?? signal})`); |
| 160 | } |
| 161 | releases.delete(release); |
| 162 | sweep(); |
| 163 | }); |
| 164 | try { |
| 165 | await healthy(release.port, release.proc, current); |
| 166 | } catch (error) { |
| 167 | release.proc.kill("SIGKILL"); |
| 168 | throw error; |
| 169 | } |
| 170 | lap("start"); |
| 171 | |
| 172 | const old = live; |
| 173 | live = release; |
| 174 | recentModules = basename(release.modules); |
| 175 | if (old) retire(old); |
| 176 | log(`live ${rev.slice(0, 7)} in ${((performance.now() - start) / 1000).toFixed(1)}s: ${laps.join(", ")}`); |
| 177 | } catch (error) { |
| 178 | log(`${target.slice(0, 7)} failed: ${error.message}`); |
| 179 | failed = { rev: target, at: Date.now() }; |
| 180 | if (release) releases.delete(release); |
| 181 | sweep(); |
| 182 | } |
| 183 | } |
| 184 | |
| 185 | mkdirSync(`${WORK}/rel`, { recursive: true }); |
| 186 | mkdirSync(`${WORK}/modules`, { recursive: true }); |
| 187 | await run("git", ["init", "--quiet", "--bare", REPO]); |
| 188 | process.on("SIGTERM", () => process.exit(0)); |
| 189 | |
| 190 | (async () => { |
| 191 | let problem = ""; |
| 192 | for (;; await sleep(POLL_MS)) { |
| 193 | try { |
| 194 | const head = await remoteHead(); |
| 195 | if (!head) throw new Error(`${SOURCE_URL} has no branch ${BRANCH}`); |
| 196 | wanted = head; |
| 197 | problem = ""; |
| 198 | } catch (error) { |
| 199 | if (error.message !== problem) log((problem = error.message)); |
| 200 | } |
| 201 | } |
| 202 | })(); |
| 203 | |
| 204 | for (;;) { |
| 205 | const retry = wanted === failed.rev && !live && Date.now() - failed.at > RETRY_FAILED_MS; |
| 206 | if (wanted && wanted !== live?.rev && (wanted !== failed.rev || retry)) await deploy(); |
| 207 | else await sleep(100); |
| 208 | } |