rollbridge 0.1.1 → 0.1.4

package/test/proxy.test.js

@@ -0,0 +1,128 @@
+// @ts-check
+
+import assert from "node:assert/strict"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import test from "node:test"
+import {fileURLToPath} from "node:url"
+import RollbridgeDaemon from "../src/daemon.js"
+import {normalizeConfig} from "../src/config.js"
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
+
+/**
+ * @param {string} root - Fixture root used for the control socket.
+ * @param {number} restartDelayMs - Delay before a crashed process is restarted.
+ * @returns {import("../src/config.js").RollbridgeConfig} Normalized config with one proxied web process.
+ */
+function buildConfig(root, restartDelayMs) {
+  return normalizeConfig({
+    application: "rollbridge-proxy-test",
+    control: {path: path.join(root, "rollbridge.sock")},
+    processes: [
+      {
+        command: `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`,
+        health: {intervalMs: 50, path: "/ping", timeoutMs: 3000},
+        id: "web",
+        policy: "proxied",
+        port: {from: 0, to: 0},
+        restartDelayMs
+      }
+    ],
+    proxy: {drainTimeoutMs: 1000, forceStopTimeoutMs: 500, healthPath: "/ping", healthTimeoutMs: 3000, host: "127.0.0.1", port: 0}
+  })
+}
+
+/**
+ * @param {RollbridgeDaemon} daemon - Daemon.
+ * @param {string} pathName - Request path.
+ * @returns {Promise<Response>} Proxy response.
+ */
+async function proxyFetch(daemon, pathName) {
+  return await fetch(`http://127.0.0.1:${daemon.getProxyPort()}${pathName}`)
+}
+
+/**
+ * @param {RollbridgeDaemon} daemon - Daemon.
+ * @param {string} releaseId - Active release id.
+ * @returns {number} The web process pid reported by status.
+ */
+function webPid(daemon, releaseId) {
+  const release = daemon.status().releases.find((candidate) => candidate.releaseId === releaseId)
+
+  assert.ok(release, `Release ${releaseId} should be present`)
+
+  const web = release.processes.find((candidate) => candidate.id === "web")
+
+  assert.ok(web && typeof web.pid === "number", "web process should report a pid")
+
+  return web.pid
+}
+
+/**
+ * @param {() => Promise<boolean> | boolean} callback - Probe.
+ * @returns {Promise<void>} Resolves once the probe returns true.
+ */
+async function waitFor(callback) {
+  const deadline = Date.now() + 3000
+
+  while (Date.now() < deadline) {
+    if (await callback()) return
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+
+  throw new Error("Timed out waiting for condition")
+}
+
+test("proxy returns 502 while the active release web process is down", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-proxy-"))
+  const daemon = new RollbridgeDaemon({config: buildConfig(root, 60000), logger: () => {}})
+
+  await daemon.start()
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: root, revision: "v1"})
+    assert.equal((await proxyFetch(daemon, "/release")).status, 200)
+
+    // Kill the web process group so the active release exits unexpectedly; restart is held off for 60s.
+    process.kill(-webPid(daemon, "v1"), "SIGKILL")
+
+    let lastStatus = 0
+
+    await waitFor(async () => {
+      lastStatus = (await proxyFetch(daemon, "/release")).status
+
+      return lastStatus === 502
+    })
+
+    assert.equal(lastStatus, 502)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
+test("proxy recovers once the crashed web process restarts", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-proxy-"))
+  const daemon = new RollbridgeDaemon({config: buildConfig(root, 300), logger: () => {}})
+
+  await daemon.start()
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: root, revision: "v1"})
+    assert.equal((await proxyFetch(daemon, "/release")).status, 200)
+
+    process.kill(-webPid(daemon, "v1"), "SIGKILL")
+
+    // First confirm the crash actually takes the proxy down (502), so passing requires
+    // observing the outage, then confirm the restart brings the proxy back to 200.
+    await waitFor(async () => (await proxyFetch(daemon, "/release")).status === 502)
+    await waitFor(async () => (await proxyFetch(daemon, "/release")).status === 200)
+    assert.equal((await proxyFetch(daemon, "/release")).status, 200)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})

package/test/release-group.test.js

@@ -0,0 +1,58 @@
+// @ts-check
+
+import assert from "node:assert/strict"
+import test from "node:test"
+import ReleaseGroup from "../src/release-group.js"
+import {normalizeConfig} from "../src/config.js"
+
+/**
+ * @param {import("../src/json.js").JsonValue} webProcess - The single proxied process definition.
+ * @returns {ReleaseGroup} A release group ready for buildProcess.
+ */
+function buildRelease(webProcess) {
+  const config = normalizeConfig({
+    application: "demo",
+    control: {path: "/tmp/rollbridge-release-group.sock"},
+    processes: [webProcess],
+    proxy: {host: "127.0.0.1", port: 0}
+  })
+
+  return new ReleaseGroup({config, logger: () => {}, releaseId: "v1", releasePath: "/tmp/rel", revision: "v1"})
+}
+
+test("templates interpolate values from the daemon environment", () => {
+  const release = buildRelease({
+    command: "run --token {{env.ROLLBRIDGE_ENV_TEST}}",
+    env: {DOWNSTREAM_TOKEN: "{{env.ROLLBRIDGE_ENV_TEST}}"},
+    id: "web",
+    policy: "proxied",
+    port: {from: 0, to: 0}
+  })
+
+  process.env.ROLLBRIDGE_ENV_TEST = "from-daemon"
+
+  try {
+    const managed = release.buildProcess(release.config.processes[0])
+
+    assert.equal(managed.command, "run --token from-daemon")
+    assert.equal(managed.env.DOWNSTREAM_TOKEN, "from-daemon")
+  } finally {
+    delete process.env.ROLLBRIDGE_ENV_TEST
+  }
+})
+
+test("a referenced daemon environment variable that is unset fails fast", () => {
+  const release = buildRelease({
+    command: "run {{env.ROLLBRIDGE_ENV_MISSING}}",
+    id: "web",
+    policy: "proxied",
+    port: {from: 0, to: 0}
+  })
+
+  delete process.env.ROLLBRIDGE_ENV_MISSING
+
+  assert.throws(
+    () => release.buildProcess(release.config.processes[0]),
+    /Missing template value for \{\{env.ROLLBRIDGE_ENV_MISSING\}\}/
+  )
+})

package/test/release-retention.test.js

@@ -0,0 +1,107 @@
+// @ts-check
+
+import assert from "node:assert/strict"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import test from "node:test"
+import {fileURLToPath} from "node:url"
+import RollbridgeDaemon, {releasesToPrune} from "../src/daemon.js"
+import {normalizeConfig} from "../src/config.js"
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
+
+test("releasesToPrune keeps the most recent stopped releases and never active or draining ones", () => {
+  const releases = [
+    {releaseId: "active", state: "active", stoppedAt: undefined},
+    {releaseId: "draining", state: "draining", stoppedAt: undefined},
+    {releaseId: "v3", state: "stopped", stoppedAt: "2026-05-22T00:00:03.000Z"},
+    {releaseId: "v2", state: "stopped", stoppedAt: "2026-05-22T00:00:02.000Z"},
+    {releaseId: "v1", state: "stopped", stoppedAt: "2026-05-22T00:00:01.000Z"}
+  ]
+
+  const remove = releasesToPrune(releases, {keep: 1, maxAgeMs: 0}, Date.parse("2026-05-22T00:00:10.000Z"))
+
+  assert.deepEqual([...remove].sort(), ["v1", "v2"])
+})
+
+test("releasesToPrune keeps the later-deployed release when stoppedAt ties", () => {
+  const sameTime = "2026-05-22T00:00:05.000Z"
+  // Deploy order (oldest first): v1 then v2, both stopped in the same millisecond.
+  const releases = [
+    {releaseId: "v1", state: "stopped", stoppedAt: sameTime},
+    {releaseId: "v2", state: "stopped", stoppedAt: sameTime}
+  ]
+
+  const remove = releasesToPrune(releases, {keep: 1, maxAgeMs: 0}, Date.parse("2026-05-22T00:00:10.000Z"))
+
+  assert.deepEqual(remove, ["v1"])
+})
+
+test("releasesToPrune prunes stopped releases older than maxAgeMs", () => {
+  const now = Date.parse("2026-05-22T00:01:00.000Z")
+  const releases = [
+    {releaseId: "fresh", state: "stopped", stoppedAt: new Date(now - 1000).toISOString()},
+    {releaseId: "old", state: "stopped", stoppedAt: new Date(now - 60000).toISOString()}
+  ]
+
+  const remove = releasesToPrune(releases, {keep: 100, maxAgeMs: 30000}, now)
+
+  assert.deepEqual(remove, ["old"])
+})
+
+test("the daemon prunes stopped releases beyond the retention count across deploys", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-retention-"))
+  const config = normalizeConfig({
+    application: "rollbridge-retention-test",
+    control: {path: path.join(root, "rollbridge.sock")},
+    processes: [
+      {
+        command: `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`,
+        health: {intervalMs: 50, path: "/ping", timeoutMs: 3000},
+        id: "web",
+        policy: "proxied",
+        port: {from: 0, to: 0}
+      }
+    ],
+    proxy: {drainTimeoutMs: 200, forceStopTimeoutMs: 200, host: "127.0.0.1", port: 0},
+    releaseRetention: {keep: 1}
+  })
+  const daemon = new RollbridgeDaemon({config, logger: () => {}})
+
+  await daemon.start()
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: root, revision: "v1"})
+    await daemon.deploy({releaseId: "v2", releasePath: root, revision: "v2"})
+    await daemon.deploy({releaseId: "v3", releasePath: root, revision: "v3"})
+
+    // Older stopped releases are pruned once they drain; keep:1 retains only the most recent stopped one.
+    await waitFor(() => !daemon.status().releases.some((release) => release.releaseId === "v1"))
+
+    const ids = daemon.status().releases.map((release) => release.releaseId)
+
+    assert.ok(ids.includes("v3"), `active release should be retained, got ${JSON.stringify(ids)}`)
+    assert.ok(!ids.includes("v1"), `oldest stopped release should be pruned, got ${JSON.stringify(ids)}`)
+    assert.ok(ids.length <= 2, `expected at most the active release plus one stopped, got ${JSON.stringify(ids)}`)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
+/**
+ * @param {() => boolean} callback - Probe.
+ * @returns {Promise<void>} Resolves once the probe returns true.
+ */
+async function waitFor(callback) {
+  const deadline = Date.now() + 3000
+
+  while (Date.now() < deadline) {
+    if (callback()) return
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+
+  throw new Error("Timed out waiting for condition")
+}

package/test/rollbridge.test.js

@@ -64,6 +64,57 @@ test("failed health check leaves the previous release active", async () => {
   }
 })
 
+test("wildcard proxy bind host targets release processes through loopback", async () => {
+  const fixture = await createFixture({proxyHost: "0.0.0.0"})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const status = daemon.status()
+    const release = statusRelease(daemon, "v1")
+
+    assert.ok(daemon.activeRelease, "expected active release")
+    assert.equal(status.proxy.host, "0.0.0.0")
+    assert.equal(status.proxy.upstreamHost, "127.0.0.1")
+    assert.equal(daemon.activeRelease.proxyTarget().target, `http://127.0.0.1:${release.ports.web}`)
+    assert.equal(await fetchText(daemon, "/release"), "v1")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("failed release startup logs process output before cleanup", async () => {
+  const fixture = await createFixture({webCommand: `${JSON.stringify(process.execPath)} -e "console.log('startup stdout'); console.error('startup stderr'); const http = require('node:http'); http.createServer((_request, response) => { response.writeHead(500); response.end('bad') }).listen(Number(process.env.ROLLBRIDGE_PORT), '127.0.0.1')"`, webHealthTimeoutMs: 500})
+  /** @type {Array<{data?: Record<string, import("../src/json.js").JsonValue>, message: string}>} */
+  const logs = []
+  const daemon = new RollbridgeDaemon({
+    config: fixture.config,
+    logger: (message, data = {}) => logs.push({data, message})
+  })
+
+  await daemon.start()
+
+  try {
+    await assert.rejects(
+      () => daemon.deploy({releaseId: "bad", releasePath: fixture.root, revision: "bad"}),
+      /Health check failed/
+    )
+
+    const processStatusLog = logs.find((entry) => entry.message === "release startup process status" && entry.data?.processId === "web")
+
+    assert.ok(processStatusLog, "expected failed web process diagnostics to be logged")
+    assert.ok(processStatusLog.data, "expected diagnostic data")
+    assert.ok(Array.isArray(processStatusLog.data.logs), "expected retained process output in diagnostics")
+    assert.ok(processStatusLog.data.logs.some((entry) => typeof entry === "object" && entry && "line" in entry && entry.line === "startup stdout"))
+    assert.ok(processStatusLog.data.logs.some((entry) => typeof entry === "object" && entry && "line" in entry && entry.line === "startup stderr"))
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
 test("singleton processes restart without overlap during deploy", async () => {
   const fixture = await createFixture({includeSingleton: true})
   const daemon = await startDaemon(fixture.config)
@@ -213,6 +264,29 @@ test("a control socket held by a non-Rollbridge process reports a generic confli
   }
 })
 
+test("applies the configured control socket permission mode", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-test-"))
+  const socketPath = path.join(root, "rollbridge.sock")
+  const config = normalizeConfig({
+    application: "rollbridge-test",
+    control: {mode: "660", path: socketPath},
+    processes: [{command: "true", id: "web", policy: "proxied", port: {from: 0, to: 0}}],
+    proxy: {host: "127.0.0.1", port: 0}
+  })
+  const daemon = new RollbridgeDaemon({config, logger: () => {}})
+
+  await daemon.start()
+
+  try {
+    const stats = await fs.stat(socketPath)
+
+    assert.equal(stats.mode & 0o777, 0o660)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
 test("deploy can ensure the daemon before sending the release command", async () => {
   const fixture = await createFixture()
   const configPath = await writeConfigFile(fixture.config, fixture.root)
@@ -262,7 +336,7 @@ test("deploy can ensure the daemon before sending the release command", async ()
 })
 
 /**
- * @param {{includeService?: boolean, includeSingleton?: boolean, webDependsOnService?: boolean}} [options] - Fixture options.
+ * @param {{includeService?: boolean, includeSingleton?: boolean, proxyHost?: string, webCommand?: string, webDependsOnService?: boolean, webHealthTimeoutMs?: number}} [options] - Fixture options.
  * @returns {Promise<{config: import("../src/config.js").RollbridgeConfig, root: string, serviceLogPath: string, singletonLogPath: string}>} Fixture data.
  */
 async function createFixture(options = {}) {
@@ -286,13 +360,13 @@ async function createFixture(options = {}) {
   }
 
   processes.push({
-    command: options.webDependsOnService
+    command: options.webCommand || (options.webDependsOnService
       ? `${JSON.stringify(process.execPath)} ${JSON.stringify(dependentAppPath)}`
-      : `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`,
+      : `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`),
     health: {
       intervalMs: 50,
       path: "/ping",
-      timeoutMs: 3000
+      timeoutMs: options.webHealthTimeoutMs || 3000
     },
     id: "web",
     policy: "proxied",
@@ -321,7 +395,7 @@ async function createFixture(options = {}) {
       forceStopTimeoutMs: 500,
       healthPath: "/ping",
       healthTimeoutMs: 3000,
-      host: "127.0.0.1",
+      host: options.proxyHost || "127.0.0.1",
       port: 0
     }
   })