rollbridge 0.1.39 → 0.1.40

package/test/release-group.test.js

@@ -7,9 +7,10 @@ import {normalizeConfig} from "../src/config.js"
 
 /**
  * @param {import("../src/json.js").JsonValue} webProcess - The single proxied process definition.
+ * @param {() => boolean} [shouldStart] - Whether process starts remain allowed.
  * @returns {ReleaseGroup} A release group ready for buildProcess.
  */
-function buildRelease(webProcess) {
+function buildRelease(webProcess, shouldStart = () => true) {
   const config = normalizeConfig({
     application: "demo",
     control: {path: "/tmp/rollbridge-release-group.sock"},
@@ -17,7 +18,7 @@ function buildRelease(webProcess) {
     proxy: {host: "127.0.0.1", port: 0}
   })
 
-  return new ReleaseGroup({config, logger: () => {}, releaseId: "v1", releasePath: "/tmp/rel", revision: "v1"})
+  return new ReleaseGroup({config, logger: () => {}, releaseId: "v1", releasePath: "/tmp/rel", revision: "v1", shouldStart})
 }
 
 test("templates interpolate values from the daemon environment", () => {
@@ -78,3 +79,19 @@ test("a referenced daemon environment variable that is unset fails fast", () =>
     /Missing template value for \{\{env.ROLLBRIDGE_ENV_MISSING\}\}/
   )
 })
+
+test("committed generation restoration does not start after shutdown begins", async () => {
+  const release = buildRelease({command: "run web", id: "web", policy: "proxied", port: {from: 0, to: 0}}, () => false)
+  const process = release.buildProcess(release.config.processes[0])
+  let starts = 0
+
+  release.state = "draining"
+  process.start = async () => {
+    starts += 1
+    throw new Error("process started after shutdown")
+  }
+  release.processes.set("web", process)
+
+  await assert.rejects(() => release.restartCommittedGeneration(), /shutting down/)
+  assert.equal(starts, 0)
+})

package/test/release-runtime-retention.test.js

@@ -10,6 +10,7 @@ import path from "node:path"
 import test from "node:test"
 import {fileURLToPath} from "node:url"
 import {sendControlCommand} from "../src/control-client.js"
+import GuardianClient from "../src/guardian-client.js"
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const dummyAppPath = path.join(repoRoot, "test", "fixtures", "dummy-app.js")
@@ -23,12 +24,14 @@ test("detached daemon survives deletion of the release-local Rollbridge installa
   const logPath = path.join(root, "daemon.log")
   const pidPath = path.join(root, "daemon.pid")
   const runtimePath = path.join(root, "runtime")
+  const statePath = path.join(root, "state.json")
 
   try {
     await Promise.all([prepareRelease(releaseA, true), prepareRelease(releaseB, true)])
     await fs.writeFile(configPath, `export default ${JSON.stringify({
       application: "runtime-retention-test",
       control: {path: socketPath},
+      ownerRecovery: {reconnectGraceMs: 50},
       processes: [{
         command: `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`,
         health: {intervalMs: 25, path: "/ping", timeoutMs: 3000},
@@ -36,7 +39,8 @@ test("detached daemon survives deletion of the release-local Rollbridge installa
         policy: "proxied",
         port: {from: 0, to: 0}
       }],
-      proxy: {drainTimeoutMs: 100, forceStopTimeoutMs: 100, host: "127.0.0.1", port: 0}
+      proxy: {drainTimeoutMs: 100, forceStopTimeoutMs: 100, host: "127.0.0.1", port: 0},
+      statePath
     }, null, 2)}\n`)
 
     await runReleaseCli(releaseA, [
@@ -52,7 +56,7 @@ test("detached daemon survives deletion of the release-local Rollbridge installa
       "--daemon-runtime-path", runtimePath
     ])
 
-    await fs.rm(path.join(releaseA, "node_modules"), {recursive: true})
+    await fs.rm(releaseA, {recursive: true})
 
     const status = await sendControlCommand({command: {command: "status"}, path: socketPath})
     const proxyPort = /** @type {{port: number}} */ (status.proxy).port
@@ -66,14 +70,67 @@ test("detached daemon survives deletion of the release-local Rollbridge installa
     assert.ok(!runtime.path.startsWith(releaseA), `runtime must be outside release A: ${runtime.path}`)
     assert.equal(response.status, 200)
     assert.equal(await response.text(), "deferred runtime loaded\n")
+    assert.equal(typeof status.daemonPid, "number")
+    const daemonPid = /** @type {number} */ (status.daemonPid)
+
+    process.kill(daemonPid, "SIGKILL")
+    const recoveredPid = await waitForChangedPid(pidPath, daemonPid)
+    const recovered = await sendControlCommand({command: {command: "status"}, path: socketPath})
+
+    assert.equal(recovered.daemonPid, recoveredPid)
+    assert.equal(recovered.activeReleaseId, "B")
   } finally {
     try {
       await sendControlCommand({command: {command: "shutdown"}, path: socketPath})
     } catch {
       const pid = Number.parseInt(await fs.readFile(pidPath, "utf8").catch(() => ""), 10)
-      if (Number.isInteger(pid)) process.kill(pid, "SIGKILL")
+      if (Number.isInteger(pid)) killProcessIfAlive(pid)
     }
+    await stopGuardian(statePath)
+
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
+test("ensure-daemon resolves an explicit relative config before changing to its durable directory", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-runtime-relative-config-"))
+  const release = path.join(root, "release")
+  const configDirectory = path.join(release, "configs")
+  const configPath = path.join(configDirectory, "rollbridge.js")
+  const pidPath = path.join(root, "daemon.pid")
+  const socketPath = path.join(root, "control.sock")
+  const statePath = path.join(root, "state.json")
+
+  try {
+    await prepareRelease(release, false)
+    await fs.mkdir(configDirectory)
+    await fs.writeFile(configPath, `export default ${JSON.stringify({
+      ...basicConfig(path.relative(configDirectory, socketPath)),
+      ownerRecovery: {reconnectGraceMs: 50},
+      processes: [{
+        command: `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`,
+        health: {intervalMs: 25, path: "/ping", timeoutMs: 3000},
+        id: "web",
+        policy: "proxied",
+        port: {from: 0, to: 0}
+      }],
+      statePath: path.relative(configDirectory, statePath)
+    }, null, 2)}\n`)
+    await runReleaseCli(release, [
+      "deploy", "--ensure-daemon", "--config", path.relative(release, configPath),
+      "--release-path", release, "--release-id", "relative-config",
+      "--daemon-log-path", path.join(root, "daemon.log"), "--daemon-pid-path", pidPath,
+      "--daemon-runtime-path", path.join(root, "runtime"), "--daemon-start-timeout-ms", "1000"
+    ])
+    const status = await sendControlCommand({command: {command: "status"}, path: socketPath})
+
+    assert.equal(status.activeReleaseId, "relative-config")
+  } finally {
+    await sendControlCommand({command: {command: "shutdown"}, path: socketPath}).catch(() => undefined)
+    await stopGuardian(statePath)
+    const pid = Number.parseInt(await fs.readFile(pidPath, "utf8").catch(() => ""), 10)
 
+    if (Number.isInteger(pid)) killProcessIfAlive(pid)
     await fs.rm(root, {force: true, recursive: true})
   }
 })
@@ -349,7 +406,7 @@ function basicConfig(socketPath) {
  */
 async function runReleaseCli(releasePath, args) {
   const binPath = path.join(releasePath, "node_modules", "rollbridge", "bin", "rollbridge")
-  const child = spawn(process.execPath, [binPath, ...args], {stdio: ["ignore", "pipe", "pipe"]})
+  const child = spawn(process.execPath, [binPath, ...args], {cwd: releasePath, stdio: ["ignore", "pipe", "pipe"]})
   let output = ""
 
   child.stdout.setEncoding("utf8").on("data", (chunk) => { output += chunk })
@@ -358,3 +415,63 @@ async function runReleaseCli(releasePath, args) {
 
   if (code !== 0) throw new Error(output)
 }
+
+/**
+ * @param {string} pidPath - Daemon PID file.
+ * @param {number} previousPid - Exited daemon PID.
+ * @returns {Promise<number>} Recovered daemon PID.
+ */
+async function waitForChangedPid(pidPath, previousPid) {
+  const deadline = Date.now() + 5000
+
+  while (Date.now() < deadline) {
+    const pid = Number.parseInt(await fs.readFile(pidPath, "utf8").catch(() => ""), 10)
+
+    if (Number.isInteger(pid) && pid !== previousPid) return pid
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+  throw new Error(`Timed out waiting for ${pidPath} to publish a recovered daemon PID`)
+}
+
+/** @param {number} pid - Exact fixture process PID. */
+function killProcessIfAlive(pid) {
+  try {
+    process.kill(pid, "SIGKILL")
+  } catch (error) {
+    if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ESRCH") throw error
+  }
+}
+
+/** @param {string} statePath - Owner-recovery state path. */
+async function stopGuardian(statePath) {
+  try {
+    const state = JSON.parse(await fs.readFile(statePath, "utf8"))
+    const identity = state.recovery?.guardian
+    const pid = identity?.pid
+
+    if (identity?.socketPath && identity.token) {
+      const client = new GuardianClient(identity)
+
+      try {
+        await client.connect()
+        for (const entry of await client.inventory()) {
+          if (entry.status.pid) {
+            try { process.kill(-entry.status.pid, "SIGKILL") } catch (error) {
+              if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ESRCH") throw error
+            }
+          }
+        }
+      } finally {
+        client.disconnect()
+      }
+    }
+    if (typeof pid === "number") {
+      const command = (await fs.readFile(`/proc/${pid}/cmdline`, "utf8")).replaceAll("\0", " ")
+
+      if (!command.includes("process-guardian.js") || !command.includes(statePath)) throw new Error(`Refusing to stop unverified fixture guardian pid ${pid}`)
+      process.kill(pid, "SIGKILL")
+    }
+  } catch (error) {
+    if (!error || typeof error !== "object" || !("code" in error) || !["ENOENT", "ESRCH"].includes(String(error.code))) throw error
+  }
+}

package/test/rollbridge.test.js

@@ -525,6 +525,27 @@ test("opt-in generation lifecycle retires the old generation before activating a
   }
 })
 
+test("manual restart reaches the active handoff coordinator and restores its lifecycle role", async () => {
+  const fixture = await createFixture({handoffService: true, handoffServiceActivate: true, webDependsOnService: true})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+    const before = statusRelease(daemon, "v1").processes.find((processStatus) => processStatus.id === "beacon")?.pid
+    const result = await daemon.restartProcesses({processId: "beacon"})
+    const after = statusRelease(daemon, "v1").processes.find((processStatus) => processStatus.id === "beacon")?.pid
+
+    assert.deepEqual(result, {restarted: ["beacon"]})
+    assert.ok(before)
+    assert.ok(after)
+    assert.notEqual(after, before)
+    assert.deepEqual(await lifecycleEvents(fixture.lifecycleLogPath), ["activate:v1", "retire:v1", "activate:v1"])
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
 test("generation commit is durable before awaited post-transition work", async () => {
   const fixture = await createFixture({handoffService: true, handoffServiceActivate: true, includeSingleton: true, webDependsOnService: true})
   const daemon = await startDaemon(fixture.config)

package/test/support/process.js

@@ -0,0 +1,41 @@
+// @ts-check
+
+import fs from "node:fs"
+
+/**
+ * Reports whether an exact fixture process can still run. Linux keeps exited children in
+ * procfs until they are reaped, so kill(2) alone cannot distinguish a zombie from a live process.
+ * @param {number} pid - Exact fixture process PID.
+ * @returns {boolean} Whether the process can still run.
+ */
+export function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0)
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ESRCH") return false
+    throw error
+  }
+
+  if (process.platform !== "linux") return true
+
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8")
+    const state = stat.slice(stat.lastIndexOf(")") + 2).split(" ")[0]
+
+    return state !== "Z" && state !== "X"
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return false
+    throw error
+  }
+}
+
+/**
+ * @param {number} pid - Exact fixture process PID.
+ * @param {number} [timeoutMs] - Bounded exit wait.
+ */
+export async function waitForProcessExit(pid, timeoutMs = 5000) {
+  const deadline = Date.now() + timeoutMs
+
+  while (isProcessRunning(pid) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 10))
+  if (isProcessRunning(pid)) throw new Error(`Timed out waiting for process ${pid} to exit`)
+}