rollbridge 0.1.11 → 0.1.12

package/README.md

@@ -543,8 +543,12 @@ so its output goes to the journal (`journalctl -u rollbridge`). Key directives:
 The daemon is long-lived and survives deploys. **Deploy with
 `rollbridge deploy` (or `rollbridge deploy --ensure-daemon`), not
 `systemctl restart`** — pointing `--config` at a stable, daemon-wide file while
-release paths are passed per deploy. Use `command -v rollbridge` to find the
-absolute CLI path for `ExecStart`.
+release paths are passed per deploy. The daemon reloads compatible process and
+lifecycle config before each deploy, so updated graceful-stop deadlines govern
+the release being retired without interrupting the stable proxy. Listener and
+process-topology changes still require a daemon restart; see
+[`docs/config.md`](docs/config.md#config-reloads). Use `command -v rollbridge`
+to find the absolute CLI path for `ExecStart`.
 
 See [`docs/logging.md`](docs/logging.md) for where the daemon's JSON logs go
 (stdout / journald / the `--daemon-log-path` file) and how to rotate them — the

package/docs/cli.md

@@ -72,6 +72,14 @@ traffic to it, then drains and stops the previous release. Prints
 If the new release fails to start or health-check, the previous release stays
 active and the command errors.
 
+Before each deploy, the daemon reloads the config path it was started with.
+Compatible process and lifecycle changes apply to the new release and govern
+how the previous release retires, including updated `nonBlockingDrain`,
+`stopSignal`, `lifecycle`, and `gracefulStopMs` settings. The daemon adopts the
+new config only after the replacement release starts successfully. Changes to
+daemon-owned listeners or process topology fail the deploy with a restart
+instruction; see [Config reloads](config.md#config-reloads).
+
 - `--release-path <path>` (**required**) — path to the prepared release
   directory; available to process templates as `{{releasePath}}`.
 - `--release-id <id>` — identifier for the release. Defaults to `--revision`,

package/docs/config.md

@@ -17,6 +17,28 @@ export default {
 }
 ```
 
+## Config reloads
+
+The daemon reloads the config file it was started with before every deploy and
+rollback. Compatible changes apply to the replacement release, daemon-wide
+service restart definitions, and the retirement of the previous release. This
+means changes to process commands, environment, health checks, lifecycle hooks,
+`nonBlockingDrain`, stop signals, graceful-stop timeouts, restart policies, and
+memory supervision do not require restarting the stable proxy daemon. Updated
+retirement settings also apply to processes that were started by the previous
+release.
+
+The replacement config is adopted only after the new release starts and passes
+its health check. Invalid config, an incompatible change, or a failed release
+leaves the previous config and release active.
+
+Settings that own daemon listeners or change the managed-process topology still
+require a daemon restart: `application`, `control`, `statePath`, `proxy.host`,
+`proxy.port`, `proxy.upstreamHost`, and changes to process ids, count, `policy`,
+`deployStrategy`, `replicas`, or `port`. A deploy with one of these changes
+fails before starting the replacement and names the settings that require a
+restart.
+
 ## Top-level fields
 
 | Field | Type | Default | Description |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollbridge",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Zero-downtime process supervisor and local traffic switcher for deploy-managed apps.",
   "keywords": [
     "deploy",

package/src/cli.js

@@ -33,7 +33,7 @@ export async function runCli(argv) {
     .action(async (options) => {
       const configPath = await resolveConfigPath(options.config)
       const config = await loadConfig(configPath)
-      const daemon = new RollbridgeDaemon({config})
+      const daemon = new RollbridgeDaemon({config, configPath})
 
       await daemon.start()
 

package/src/config.js

@@ -1,6 +1,8 @@
 // @ts-check
 
 import fs from "node:fs/promises"
+import {createHash} from "node:crypto"
+import {createRequire} from "node:module"
 import os from "node:os"
 import path from "node:path"
 import {pathToFileURL} from "node:url"
@@ -27,6 +29,7 @@ import {pathToFileURL} from "node:url"
 
 const PROCESS_POLICIES = new Set(["proxied", "companion", "singleton", "service"])
 const DEFAULT_CONFIG_FILENAMES = ["rollbridge.js"]
+const commonJsRequire = createRequire(import.meta.url)
 
 /**
  * Imports a JavaScript config module without validating it.
@@ -38,7 +41,13 @@ const DEFAULT_CONFIG_FILENAMES = ["rollbridge.js"]
  */
 export async function parseConfigFile(configPath) {
   const absolutePath = path.resolve(configPath)
-  const moduleNamespace = await import(pathToFileURL(absolutePath).href)
+  const configUrl = pathToFileURL(absolutePath)
+  const configSource = await fs.readFile(absolutePath)
+
+  configUrl.searchParams.set("rollbridgeConfig", createHash("sha256").update(configSource).digest("hex"))
+  delete commonJsRequire.cache[commonJsRequire.resolve(absolutePath)]
+
+  const moduleNamespace = await import(configUrl.href)
   const exported = moduleNamespace.default
 
   if (exported === undefined) {

package/src/daemon.js

@@ -3,7 +3,9 @@
 import fs from "node:fs/promises"
 import http from "node:http"
 import net from "node:net"
+import {isDeepStrictEqual} from "node:util"
 import httpProxy from "http-proxy"
+import {loadConfig} from "./config.js"
 import EventLog from "./event-log.js"
 import ReleaseGroup from "./release-group.js"
 import {clearState, isProcessAlive, liveProcesses, readState, writeState} from "./state-store.js"
@@ -23,10 +25,12 @@ export default class RollbridgeDaemon {
   /**
    * @param {object} args - Options.
    * @param {import("./config.js").RollbridgeConfig} args.config - Rollbridge config.
+   * @param {string} [args.configPath] - Config file path to reload before deploys.
    * @param {(message: string, data?: Record<string, JsonValue>) => void} [args.logger] - Logger.
    */
-  constructor({config, logger}) {
+  constructor({config, configPath, logger}) {
     this.config = config
+    this.configPath = configPath
     this.eventLog = new EventLog(EVENT_HISTORY_LIMIT)
 
     const baseLogger = logger || ((message, data = {}) => console.log(JSON.stringify({at: new Date().toISOString(), data, message})))
@@ -319,9 +323,13 @@ export default class RollbridgeDaemon {
   async deploy({releaseId, releasePath, revision}) {
     if (this.stopping) throw new Error("Rollbridge is shutting down")
 
+    const nextConfig = this.configPath ? await loadConfig(this.configPath) : this.config
+
+    this.assertReloadCompatible(nextConfig)
+
     const newReleaseId = releaseId || revision || new Date().toISOString().replace(/[^0-9]/g, "")
     const release = new ReleaseGroup({
-      config: this.config,
+      config: nextConfig,
       logger: this.logger,
       releaseId: newReleaseId,
       releasePath,
@@ -343,6 +351,7 @@ export default class RollbridgeDaemon {
 
     const previousRelease = this.activeRelease
 
+    this.config = nextConfig
     this.releases.set(release.releaseId, release)
     release.activate()
     this.activeRelease = release
@@ -352,7 +361,7 @@ export default class RollbridgeDaemon {
     await this.replaceSingletons(release)
 
     if (previousRelease) {
-      void this.drainAndPrune(previousRelease)
+      void this.drainAndPrune(previousRelease, nextConfig)
     }
 
     this.persistState()
@@ -363,6 +372,45 @@ export default class RollbridgeDaemon {
     }
   }
 
+  /**
+   * Rejects config changes that require rebinding daemon-owned resources or changing process topology.
+   * @param {import("./config.js").RollbridgeConfig} nextConfig - Freshly loaded config.
+   * @returns {void}
+   */
+  assertReloadCompatible(nextConfig) {
+    /** @type {string[]} */
+    const restartRequired = []
+
+    if (nextConfig.application !== this.config.application) restartRequired.push("application")
+    if (!isDeepStrictEqual(nextConfig.control, this.config.control)) restartRequired.push("control")
+    if (nextConfig.statePath !== this.config.statePath) restartRequired.push("statePath")
+
+    if (nextConfig.proxy.host !== this.config.proxy.host) restartRequired.push("proxy.host")
+    if (nextConfig.proxy.port !== this.config.proxy.port) restartRequired.push("proxy.port")
+    if (nextConfig.proxy.upstreamHost !== this.config.proxy.upstreamHost) restartRequired.push("proxy.upstreamHost")
+
+    if (nextConfig.processes.length !== this.config.processes.length) {
+      restartRequired.push("processes")
+    } else {
+      for (const processConfig of this.config.processes) {
+        const nextProcessConfig = nextConfig.processes.find((candidate) => candidate.id === processConfig.id)
+
+        if (!nextProcessConfig ||
+          nextProcessConfig.policy !== processConfig.policy ||
+          nextProcessConfig.deployStrategy !== processConfig.deployStrategy ||
+          nextProcessConfig.replicas !== processConfig.replicas ||
+          !isDeepStrictEqual(nextProcessConfig.port, processConfig.port)) {
+          restartRequired.push("processes")
+          break
+        }
+      }
+    }
+
+    if (restartRequired.length > 0) {
+      throw new Error(`Config changes to ${restartRequired.join(", ")} cannot be applied live; restart the Rollbridge daemon before deploying.`)
+    }
+  }
+
   /**
    * Rolls back to a previously-active release by re-running the deploy flow on its
    * retained metadata: it re-starts the target release, health-checks it, switches
@@ -418,7 +466,7 @@ export default class RollbridgeDaemon {
   async ensureServices(release, startedServices) {
     await release.allocatePorts()
 
-    for (const processConfig of this.config.processes) {
+    for (const processConfig of release.config.processes) {
       if (processConfig.policy !== "service" || processConfig.deployStrategy === "handoff") continue
       if (this.services.has(processConfig.id)) continue
 
@@ -473,20 +521,7 @@ export default class RollbridgeDaemon {
 
       const nextDefinition = release.buildProcess(processConfig, {shouldRestart: () => !this.stopping})
 
-      service.updateDefinition({
-        command: nextDefinition.command,
-        cwd: nextDefinition.cwd,
-        env: nextDefinition.env,
-        lifecycle: nextDefinition.lifecycle,
-        logger: nextDefinition.logger,
-        memory: nextDefinition.memory,
-        outputLines: nextDefinition.outputLines,
-        restart: nextDefinition.restart,
-        restartDelayMs: nextDefinition.restartDelayMs,
-        shouldRestart: nextDefinition.shouldRestart,
-        stopSignal: nextDefinition.stopSignal,
-        stopTimeoutMs: nextDefinition.stopTimeoutMs
-      })
+      service.updateDefinition(nextDefinition)
     }
   }
 
@@ -611,11 +646,12 @@ export default class RollbridgeDaemon {
   /**
    * Drains and stops a retired release in the background, then prunes stopped releases.
    * @param {ReleaseGroup} release - Release to drain and stop.
+   * @param {import("./config.js").RollbridgeConfig} [config] - Refreshed config governing retirement.
    * @returns {Promise<void>} Resolves once drained, stopped, and pruned.
    */
-  async drainAndPrune(release) {
+  async drainAndPrune(release, config = this.config) {
     try {
-      await release.drainAndStop(this.config.proxy.drainTimeoutMs)
+      await release.drainAndStop(config.proxy.drainTimeoutMs, config)
       this.logger("release drained", {releaseId: release.releaseId})
     } catch (error) {
       this.logger("release drain failed", {error: error instanceof Error ? error.message : String(error), releaseId: release.releaseId})

package/src/release-group.js

@@ -232,6 +232,34 @@ export default class ReleaseGroup extends EventEmitter {
     })
   }
 
+  /**
+   * Applies refreshed process definitions before retiring this release.
+   * @param {import("./config.js").RollbridgeConfig} config - Current deployment config.
+   * @returns {void}
+   */
+  refreshProcessDefinitions(config) {
+    this.config = config
+    this.handoffServiceIds.clear()
+    this.nonBlockingDrainIds.clear()
+
+    for (const processConfig of config.processes) {
+      const instances = this.getProcesses(processConfig.id)
+
+      for (let index = 0; index < instances.length; index += 1) {
+        const instance = instances[index]
+        const nextDefinition = this.buildProcess(processConfig, {
+          count: processConfig.replicas,
+          index,
+          instanceId: instance.id
+        })
+
+        instance.process.updateDefinition(nextDefinition)
+        if (processConfig.policy === "service" && processConfig.deployStrategy === "handoff") this.handoffServiceIds.add(instance.id)
+        if (processConfig.nonBlockingDrain) this.nonBlockingDrainIds.add(instance.id)
+      }
+    }
+  }
+
   /**
    * @param {import("./config.js").ProcessConfig} processConfig - Process config.
    * @param {{count: number, index: number}} replica - Replica index and total count.
@@ -325,13 +353,15 @@ export default class ReleaseGroup extends EventEmitter {
   /**
    * Starts draining and stops once existing connections close or timeout.
    * @param {number} timeoutMs - Drain timeout.
+   * @param {import("./config.js").RollbridgeConfig} [config] - Refreshed config governing retirement.
    * @returns {Promise<void>} Resolves when stopped.
    */
-  async drainAndStop(timeoutMs) {
+  async drainAndStop(timeoutMs, config = this.config) {
     if (this.state === "stopped") return
 
     this.state = "draining"
     this.drainStartedAt = new Date().toISOString()
+    this.refreshProcessDefinitions(config)
 
     // Stop nonBlockingDrain processes (e.g. job workers) immediately and in the background, so
     // their lifecycle drain runs as soon as the release is retired — in parallel with the

package/test/config-path.test.js

@@ -5,7 +5,7 @@ import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import test from "node:test"
-import {resolveConfigPath} from "../src/config.js"
+import {loadConfig, resolveConfigPath} from "../src/config.js"
 import {runCli} from "../src/cli.js"
 
 const validConfig = {
@@ -65,6 +65,21 @@ test("resolveConfigPath throws an actionable error when no default config exists
   }
 })
 
+test("loadConfig reloads a changed CommonJS module", async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-cfgpath-"))
+  const configPath = await writeConfigModule(dir)
+
+  try {
+    assert.equal((await loadConfig(configPath)).application, "demo")
+
+    await fs.writeFile(configPath, `module.exports = ${JSON.stringify({...validConfig, application: "updated"}, null, 2)}\n`)
+
+    assert.equal((await loadConfig(configPath)).application, "updated")
+  } finally {
+    await fs.rm(dir, {force: true, recursive: true})
+  }
+})
+
 test("validate CLI command resolves the default config when --config is omitted", async () => {
   const dir = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-cfgpath-"))
   const originalCwd = process.cwd()

package/test/rollbridge.test.js

@@ -102,6 +102,96 @@ test("failed health check leaves the previous release active", async () => {
   }
 })
 
+test("deploy reloads process config and retires the previous worker with the refreshed timeout", async () => {
+  const fixture = await createFixture({nonBlockingDrainWorker: true, workerStopDelayMs: 10000})
+  const initialConfig = normalizeConfig({
+    ...fixture.config,
+    processes: fixture.config.processes.map((processConfig) => processConfig.id === "worker"
+      ? {...processConfig, gracefulStopMs: "indefinite"}
+      : processConfig)
+  })
+  const configPath = await writeConfigFile(initialConfig, fixture.root)
+  const daemon = new RollbridgeDaemon({config: initialConfig, configPath, logger: () => {}})
+
+  try {
+    await daemon.start()
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const refreshedConfig = normalizeConfig({
+      ...initialConfig,
+      processes: initialConfig.processes.map((processConfig) => processConfig.id === "worker"
+        ? {...processConfig, gracefulStopMs: 50}
+        : processConfig)
+    })
+
+    await writeConfigFile(refreshedConfig, fixture.root)
+    await daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"})
+    await waitFor(() => statusRelease(daemon, "v1").processes.find((processStatus) => processStatus.id === "worker")?.state === "stopped", 1000)
+
+    assert.equal(daemon.config.processes.find((processConfig) => processConfig.id === "worker")?.gracefulStopMs, 50)
+    assert.equal(await fetchText(daemon, "/release"), "v2")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("deploy rejects a reloaded config that changes the running proxy", async () => {
+  const fixture = await createFixture()
+  const configPath = await writeConfigFile(fixture.config, fixture.root)
+  const daemon = new RollbridgeDaemon({config: fixture.config, configPath, logger: () => {}})
+
+  try {
+    await daemon.start()
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+    await writeConfigFile(normalizeConfig({
+      ...fixture.config,
+      proxy: {...fixture.config.proxy, host: "0.0.0.0"}
+    }), fixture.root)
+
+    await assert.rejects(
+      () => daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"}),
+      /proxy\.host.*restart the Rollbridge daemon/
+    )
+    assert.equal(daemon.status().activeReleaseId, "v1")
+    assert.equal(await fetchText(daemon, "/release"), "v1")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("a failed deploy does not adopt reloaded process config", async () => {
+  const fixture = await createFixture()
+  const configPath = await writeConfigFile(fixture.config, fixture.root)
+  const daemon = new RollbridgeDaemon({config: fixture.config, configPath, logger: () => {}})
+
+  try {
+    await daemon.start()
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const failingConfig = normalizeConfig({
+      ...fixture.config,
+      processes: fixture.config.processes.map((processConfig) => processConfig.id === "web"
+        ? {...processConfig, health: {...processConfig.health, path: "/not-ready", timeoutMs: 100}}
+        : processConfig)
+    })
+
+    await writeConfigFile(failingConfig, fixture.root)
+    await assert.rejects(
+      () => daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"}),
+      /Health check failed/
+    )
+
+    assert.equal(daemon.config.processes.find((processConfig) => processConfig.id === "web")?.health?.path, "/ping")
+    assert.equal(daemon.status().activeReleaseId, "v1")
+    assert.equal(await fetchText(daemon, "/release"), "v1")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
 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)
@@ -1276,10 +1366,9 @@ async function processEvents(logPath) {
  * @returns {Promise<string>} Written config path.
  */
 async function writeConfigFile(config, root) {
-  const configPath = path.join(root, "rollbridge.js")
+  const configPath = path.join(root, "rollbridge.mjs")
 
-  // 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`)
+  await fs.writeFile(configPath, `export default ${JSON.stringify(config, null, 2)}\n`)
 
   return configPath
 }