rollbridge 0.1.1

package/test/rollbridge.test.js

@@ -0,0 +1,444 @@
+// @ts-check
+
+import assert from "node:assert/strict"
+import fs from "node:fs/promises"
+import net from "node:net"
+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"
+import {sendControlCommand} from "../src/control-client.js"
+import {runCli} from "../src/cli.js"
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const binPath = path.join(currentDir, "..", "bin", "rollbridge")
+const dependentAppPath = path.join(currentDir, "fixtures", "dependent-app.js")
+const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
+const serviceAppPath = path.join(currentDir, "fixtures", "service-app.js")
+const singletonAppPath = path.join(currentDir, "fixtures", "singleton-app.js")
+
+test("deploy switches new HTTP traffic while old WebSockets drain", async () => {
+  const fixture = await createFixture()
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+    assert.equal(await fetchText(daemon, "/release"), "v1")
+
+    const websocket = await openWebSocket(daemon)
+
+    await daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"})
+    assert.equal(await fetchText(daemon, "/release"), "v2")
+
+    const drainingRelease = statusRelease(daemon, "v1")
+    assert.equal(drainingRelease.state, "draining")
+    assert.equal(drainingRelease.connections.websocket, 1)
+
+    websocket.close()
+    await waitFor(async () => statusRelease(daemon, "v1").state === "stopped")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("failed health check leaves the previous release active", async () => {
+  const fixture = await createFixture()
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "good", releasePath: fixture.root, revision: "good"})
+
+    await assert.rejects(
+      () => daemon.deploy({releaseId: "bad", releasePath: fixture.root, revision: "bad"}),
+      /Health check failed/
+    )
+
+    assert.equal(await fetchText(daemon, "/release"), "good")
+    assert.equal(daemon.status().activeReleaseId, "good")
+  } 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)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+    await waitFor(async () => (await processEvents(fixture.singletonLogPath)).some((event) => event.event === "start" && event.releaseId === "v1"))
+
+    await daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"})
+    await waitFor(async () => {
+      const events = await processEvents(fixture.singletonLogPath)
+
+      return events.some((event) => event.event === "stop" && event.releaseId === "v1") &&
+        events.some((event) => event.event === "start" && event.releaseId === "v2")
+    })
+
+    const status = daemon.status()
+
+    assert.equal(status.singletons.length, 1)
+    assert.equal(status.singletons[0].process.state, "running")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("service processes start before releases and restart with the latest deploy template", async () => {
+  const fixture = await createFixture({includeService: true, webDependsOnService: true})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+    await waitFor(async () => (await processEvents(fixture.serviceLogPath)).some((event) => event.event === "start" && event.releaseId === "v1"))
+
+    const firstServiceStatus = daemon.status().services[0].process
+
+    assert.ok(firstServiceStatus.pid, "service should have a pid")
+    assert.match(firstServiceStatus.command, /v1/)
+
+    await daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"})
+
+    const secondServiceStatus = daemon.status().services[0].process
+
+    assert.equal(secondServiceStatus.pid, firstServiceStatus.pid)
+    assert.match(secondServiceStatus.command, /v2/)
+
+    process.kill(-Number(secondServiceStatus.pid), "SIGTERM")
+    await waitFor(async () => {
+      const events = await processEvents(fixture.serviceLogPath)
+
+      return events.some((event) => event.event === "start" && event.releaseId === "v2")
+    })
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("control socket accepts deploy and status commands", async () => {
+  const fixture = await createFixture()
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await sendControlCommand({
+      command: {
+        command: "deploy",
+        releaseId: "control-v1",
+        releasePath: fixture.root,
+        revision: "control-v1"
+      },
+      path: fixture.config.control.path
+    })
+
+    const status = await sendControlCommand({
+      command: {command: "status"},
+      path: fixture.config.control.path
+    })
+
+    assert.equal(status.activeReleaseId, "control-v1")
+    assert.equal(await fetchText(daemon, "/release"), "control-v1")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("starting a second daemon on a live control socket reports the running daemon", async () => {
+  const fixture = await createFixture()
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const second = new RollbridgeDaemon({config: fixture.config, logger: () => {}})
+
+    await assert.rejects(
+      () => second.prepareControlSocketPath(),
+      (error) => {
+        assert.ok(error instanceof Error)
+        assert.match(error.message, /A Rollbridge daemon for application "rollbridge-test" is already running/)
+        assert.match(error.message, /active release: v1/)
+        assert.match(error.message, /rollbridge shutdown/)
+
+        return true
+      }
+    )
+
+    // The original daemon keeps its socket and still answers control commands.
+    const status = await sendControlCommand({command: {command: "status"}, path: fixture.config.control.path})
+    assert.equal(status.application, "rollbridge-test")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("a control socket held by a non-Rollbridge process reports a generic conflict", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-test-"))
+  const socketPath = path.join(root, "busy.sock")
+  const connections = /** @type {Set<import("node:net").Socket>} */ (new Set())
+  const stranger = net.createServer((socket) => {
+    // Accept connections but never answer, so the probe falls through to its timeout.
+    connections.add(socket)
+    socket.on("error", () => {})
+    socket.on("close", () => connections.delete(socket))
+  })
+
+  await new Promise((resolve) => stranger.listen(socketPath, () => resolve(undefined)))
+
+  const config = normalizeConfig({
+    application: "rollbridge-test",
+    control: {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: () => {}})
+
+  try {
+    await assert.rejects(
+      () => daemon.prepareControlSocketPath(),
+      /The control socket .* is already in use by another process/
+    )
+  } finally {
+    for (const socket of connections) socket.destroy()
+    await new Promise((resolve) => stranger.close(() => resolve(undefined)))
+    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)
+  const logPath = path.join(fixture.root, "daemon.log")
+  const pidPath = path.join(fixture.root, "daemon.pid")
+
+  try {
+    await runCli([
+      "node",
+      binPath,
+      "deploy",
+      "--ensure-daemon",
+      "--config",
+      configPath,
+      "--release-path",
+      fixture.root,
+      "--release-id",
+      "ensured-v1",
+      "--daemon-log-path",
+      logPath,
+      "--daemon-pid-path",
+      pidPath
+    ])
+
+    const status = await sendControlCommand({
+      command: {command: "status"},
+      path: fixture.config.control.path
+    })
+
+    const proxy = /** @type {{port: number}} */ (status.proxy)
+
+    assert.equal(status.activeReleaseId, "ensured-v1")
+    assert.match(await fs.readFile(pidPath, "utf8"), /\d+/)
+    assert.equal(await fetchTextFromPort(proxy.port, "/release"), "ensured-v1")
+  } finally {
+    try {
+      await sendControlCommand({
+        command: {command: "shutdown"},
+        path: fixture.config.control.path
+      })
+    } catch (_error) {
+      // The daemon may have failed before it accepted commands.
+    }
+
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+/**
+ * @param {{includeService?: boolean, includeSingleton?: boolean, webDependsOnService?: boolean}} [options] - Fixture options.
+ * @returns {Promise<{config: import("../src/config.js").RollbridgeConfig, root: string, serviceLogPath: string, singletonLogPath: string}>} Fixture data.
+ */
+async function createFixture(options = {}) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-test-"))
+  const serviceLogPath = path.join(root, "service.log")
+  const singletonLogPath = path.join(root, "singleton.log")
+  /** @type {Array<Record<string, import("../src/json.js").JsonValue>>} */
+  const processes = []
+
+  if (options.includeService) {
+    processes.push({
+      command: `${JSON.stringify(process.execPath)} ${JSON.stringify(serviceAppPath)} --release={{releaseId}}`,
+      env: {
+        ROLLBRIDGE_SERVICE_LOG: serviceLogPath
+      },
+      id: "beacon",
+      policy: "service",
+      port: {from: 0, to: 0},
+      restartDelayMs: 50
+    })
+  }
+
+  processes.push({
+    command: options.webDependsOnService
+      ? `${JSON.stringify(process.execPath)} ${JSON.stringify(dependentAppPath)}`
+      : `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`,
+    health: {
+      intervalMs: 50,
+      path: "/ping",
+      timeoutMs: 3000
+    },
+    id: "web",
+    policy: "proxied",
+    port: {from: 0, to: 0}
+  })
+
+  if (options.includeSingleton) {
+    processes.push({
+      command: `${JSON.stringify(process.execPath)} ${JSON.stringify(singletonAppPath)}`,
+      env: {
+        ROLLBRIDGE_SINGLETON_LOG: singletonLogPath
+      },
+      id: "jobs-main",
+      policy: "singleton"
+    })
+  }
+
+  const config = normalizeConfig({
+    application: "rollbridge-test",
+    control: {
+      path: path.join(root, "rollbridge.sock")
+    },
+    processes,
+    proxy: {
+      drainTimeoutMs: 1000,
+      forceStopTimeoutMs: 500,
+      healthPath: "/ping",
+      healthTimeoutMs: 3000,
+      host: "127.0.0.1",
+      port: 0
+    }
+  })
+
+  return {config, root, serviceLogPath, singletonLogPath}
+}
+
+/**
+ * @param {import("../src/config.js").RollbridgeConfig} config - Config.
+ * @returns {Promise<RollbridgeDaemon>} Started daemon.
+ */
+async function startDaemon(config) {
+  const daemon = new RollbridgeDaemon({config, logger: () => {}})
+
+  await daemon.start()
+
+  return daemon
+}
+
+/**
+ * @param {RollbridgeDaemon} daemon - Daemon.
+ * @param {string} pathName - Path.
+ * @returns {Promise<string>} Response text.
+ */
+async function fetchText(daemon, pathName) {
+  return await fetchTextFromPort(Number(daemon.getProxyPort()), pathName)
+}
+
+/**
+ * @param {number} port - Port.
+ * @param {string} pathName - Path.
+ * @returns {Promise<string>} Response text.
+ */
+async function fetchTextFromPort(port, pathName) {
+  const response = await fetch(`http://127.0.0.1:${port}${pathName}`)
+
+  assert.equal(response.status, 200)
+
+  return (await response.text()).trim()
+}
+
+/**
+ * @param {RollbridgeDaemon} daemon - Daemon.
+ * @returns {Promise<WebSocket>} Open WebSocket.
+ */
+async function openWebSocket(daemon) {
+  const websocket = new WebSocket(`ws://127.0.0.1:${daemon.getProxyPort()}/socket`)
+
+  await new Promise((resolve, reject) => {
+    websocket.addEventListener("open", () => resolve(undefined), {once: true})
+    websocket.addEventListener("error", () => reject(new Error("WebSocket open failed")), {once: true})
+  })
+
+  return websocket
+}
+
+/**
+ * @param {RollbridgeDaemon} daemon - Daemon.
+ * @param {string} releaseId - Release id.
+ * @returns {import("../src/release-group.js").ReleaseStatus} Release status.
+ */
+function statusRelease(daemon, releaseId) {
+  const status = daemon.status()
+  const release = status.releases.find((candidate) => candidate.releaseId === releaseId)
+
+  assert.ok(release, `Release ${releaseId} should be present`)
+
+  return release
+}
+
+/**
+ * @param {string} logPath - Log path.
+ * @returns {Promise<Array<{event: string, pid: number, releaseId: string}>>} Events.
+ */
+async function processEvents(logPath) {
+  try {
+    const text = await fs.readFile(logPath, "utf8")
+
+    return text
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line))
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return []
+    }
+
+    throw error
+  }
+}
+
+/**
+ * @param {import("../src/config.js").RollbridgeConfig} config - Config.
+ * @param {string} root - Fixture root.
+ * @returns {Promise<string>} Written config path.
+ */
+async function writeConfigFile(config, root) {
+  const configPath = path.join(root, "rollbridge.js")
+
+  // CommonJS so the module loads from a temp dir (no package.json) on any supported Node version.
+  await fs.writeFile(configPath, `module.exports = ${JSON.stringify(config, null, 2)}\n`)
+
+  return configPath
+}
+
+/**
+ * @param {() => Promise<boolean> | boolean} callback - Probe callback.
+ * @returns {Promise<void>} Resolves when callback 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")
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "lib": ["ES2024", "DOM"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "noEmit": true,
+    "skipLibCheck": true,
+    "target": "ES2024",
+    "types": ["node"]
+  },
+  "include": ["bin/**/*", "scripts/**/*", "src/**/*", "test/**/*"]
+}