rollbridge 0.1.7 → 0.1.8

package/package.json

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

package/src/daemon.js

@@ -821,7 +821,7 @@ export function releasesToPrune(releases, policy, now) {
 }
 
 /**
- * @typedef {{alive: boolean, application?: string, activeReleaseId?: string | null}} ControlSocketInspection
+ * @typedef {{alive: boolean, application?: string, activeReleaseId?: string | null, proxy?: {host: string, port: number}}} ControlSocketInspection
  */
 
 /**
@@ -874,7 +874,7 @@ export async function inspectControlSocket(socketPath, timeoutMs = 1000) {
 
       const status = parseControlStatus(buffer.slice(0, newlineIndex))
 
-      finish(status ? {activeReleaseId: status.activeReleaseId, alive: true, application: status.application} : {alive: true})
+      finish(status ? {activeReleaseId: status.activeReleaseId, alive: true, application: status.application, proxy: status.proxy} : {alive: true})
     })
     socket.once("error", (error) => {
       if (settled) return
@@ -896,7 +896,7 @@ export async function inspectControlSocket(socketPath, timeoutMs = 1000) {
 /**
  * Parses a control status response line into a Rollbridge identity, if it is one.
  * @param {string} line - JSON response line.
- * @returns {{application: string, activeReleaseId: string | null} | undefined} Identity, or undefined when unrecognized.
+ * @returns {{application: string, activeReleaseId: string | null, proxy: {host: string, port: number} | undefined} | undefined} Identity, or undefined when unrecognized.
  */
 function parseControlStatus(line) {
   /** @type {JsonValue} */
@@ -911,5 +911,7 @@ function parseControlStatus(line) {
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined
   if (typeof parsed.application !== "string") return undefined
 
-  return {activeReleaseId: typeof parsed.activeReleaseId === "string" ? parsed.activeReleaseId : null, application: parsed.application}
+  const proxy = "proxy" in parsed && parsed.proxy && typeof parsed.proxy === "object" && !Array.isArray(parsed.proxy) && typeof parsed.proxy.host === "string" && typeof parsed.proxy.port === "number" ? {host: parsed.proxy.host, port: parsed.proxy.port} : undefined
+
+  return {activeReleaseId: typeof parsed.activeReleaseId === "string" ? parsed.activeReleaseId : null, application: parsed.application, proxy}
 }

package/src/doctor.js

@@ -26,7 +26,7 @@ export async function runEnvironmentChecks(config) {
 
   checks.push(controlSocketCheck(config, socketInspection))
   checks.push(await controlSocketDirectoryCheck(config))
-  checks.push(await proxyPortCheck(config))
+  checks.push(await proxyPortCheck(config, socketInspection))
 
   if (config.statePath !== undefined) {
     // A live daemon persists its own (live) pids into the state file, so they are not orphans.
@@ -79,7 +79,7 @@ async function orphanCheck(statePath, daemonRunning) {
 
 /**
  * @param {string} socketPath - Control socket path.
- * @returns {Promise<{alive: boolean, application?: string} | {error: string}>} Probe result, or the probe error.
+ * @returns {Promise<import("./daemon.js").ControlSocketInspection | {error: string}>} Probe result, or the probe error.
  */
 async function inspectControlSocketSafely(socketPath) {
   try {
@@ -91,7 +91,7 @@ async function inspectControlSocketSafely(socketPath) {
 
 /**
  * @param {import("./config.js").RollbridgeConfig} config - Normalized config.
- * @param {{alive: boolean, application?: string} | {error: string}} inspection - Control socket probe result.
+ * @param {import("./daemon.js").ControlSocketInspection | {error: string}} inspection - Control socket probe result.
  * @returns {DoctorCheck} Control socket reachability check.
  */
 function controlSocketCheck(config, inspection) {
@@ -109,6 +109,10 @@ function controlSocketCheck(config, inspection) {
     return {detail: `another process is already listening on ${socketPath}; the daemon would fail to bind it`, name: "control socket", ok: false}
   }
 
+  if (inspection.application === config.application) {
+    return {detail: `Rollbridge daemon for "${inspection.application}" is running on ${socketPath}`, name: "control socket", ok: true}
+  }
+
   return {detail: `a Rollbridge daemon for "${inspection.application}" is already running on ${socketPath}; stop it before starting another`, name: "control socket", ok: false}
 }
 
@@ -131,9 +135,10 @@ async function controlSocketDirectoryCheck(config) {
 
 /**
  * @param {import("./config.js").RollbridgeConfig} config - Normalized config.
- * @returns {Promise<DoctorCheck>} Whether the proxy port can be bound.
+ * @param {import("./daemon.js").ControlSocketInspection | {error: string}} inspection - Control socket probe result.
+ * @returns {Promise<DoctorCheck>} Whether the proxy port can be bound or is owned by the running daemon.
  */
-async function proxyPortCheck(config) {
+async function proxyPortCheck(config, inspection) {
   const address = `${config.proxy.host}:${config.proxy.port}`
   const bind = await canBindPort(config.proxy.host, config.proxy.port)
 
@@ -141,6 +146,10 @@ async function proxyPortCheck(config) {
     return {detail: `${address} is available`, name: "proxy port", ok: true}
   }
 
+  if (!("error" in inspection) && inspection.application === config.application && inspection.proxy?.host === config.proxy.host && inspection.proxy.port === config.proxy.port) {
+    return {detail: `${address} is already held by the running Rollbridge daemon`, name: "proxy port", ok: true}
+  }
+
   return {detail: `${address} is unavailable (${bind.code})`, name: "proxy port", ok: false}
 }
 

package/test/doctor.test.js

@@ -188,7 +188,7 @@ test("runEnvironmentChecks reports a missing control socket directory", async ()
   assert.match(directoryCheck.detail, /missing or not writable/)
 })
 
-test("runEnvironmentChecks fails when a Rollbridge daemon already holds the socket and port", async () => {
+test("runEnvironmentChecks passes when the running Rollbridge daemon holds the socket and port", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-doctor-"))
   const config = buildConfig({controlPath: path.join(root, "rollbridge.sock"), proxyPort: await freePort()})
   const daemon = new RollbridgeDaemon({config, logger: () => {}})
@@ -199,11 +199,33 @@ test("runEnvironmentChecks fails when a Rollbridge daemon already holds the sock
     const checks = await runEnvironmentChecks(config)
     const socketCheck = checkNamed(checks, "control socket")
 
-    // A daemon already running means `rollbridge daemon` would fail to bind, so doctor must fail too.
-    assert.equal(socketCheck.ok, false)
-    assert.match(socketCheck.detail, /a Rollbridge daemon for "doctor-test" is already running/)
+    assert.equal(socketCheck.ok, true)
+    assert.match(socketCheck.detail, /Rollbridge daemon for "doctor-test" is running/)
+    assert.equal(checkNamed(checks, "proxy port").ok, true)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
+test("runEnvironmentChecks fails when the running daemon does not own the configured proxy port", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-doctor-"))
+  const config = buildConfig({controlPath: path.join(root, "rollbridge.sock"), proxyPort: await freePort()})
+  const changedConfigPort = await freePort()
+  const changedConfig = buildConfig({controlPath: config.control.path, proxyPort: changedConfigPort})
+  const server = net.createServer()
+  const daemon = new RollbridgeDaemon({config, logger: () => {}})
+
+  await daemon.start()
+  await new Promise((resolve) => server.listen(changedConfigPort, "127.0.0.1", () => resolve(undefined)))
+
+  try {
+    const checks = await runEnvironmentChecks(changedConfig)
+
+    assert.equal(checkNamed(checks, "control socket").ok, true)
     assert.equal(checkNamed(checks, "proxy port").ok, false)
   } finally {
+    await new Promise((resolve) => server.close(() => resolve(undefined)))
     await daemon.shutdown()
     await fs.rm(root, {force: true, recursive: true})
   }