rollbridge 0.1.43 → 0.1.45

package/package.json

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

package/src/daemon.js

@@ -505,7 +505,10 @@ export default class RollbridgeDaemon {
       if (!transfer?.config || !transfer.snapshot) throw new Error("Committed owner published incomplete replacement state")
       const unresolvedTransition = transfer.snapshot.generationTransition
 
-      if (unresolvedTransition && unresolvedTransition.phase !== "committed" && unresolvedTransition.configDigest !== this.ownerRecoveryConfigDigest()) {
+      const transferredTransitionConfigDigest = transfer.config ? ownerConfigDigest(transfer.config) : undefined
+      if (unresolvedTransition && unresolvedTransition.phase !== "committed" &&
+        unresolvedTransition.configDigest !== this.ownerRecoveryConfigDigest() &&
+        unresolvedTransition.configDigest !== transferredTransitionConfigDigest) {
         throw new Error(`Owner replacement cannot change config authority while unresolved generation transition ${unresolvedTransition.candidateReleaseId} remains at ${unresolvedTransition.phase}`)
       }
       const registeredProcesses = new Map((await this.guardian.inventory()).map(({key, provenance}) => [key, provenance]))
@@ -1914,7 +1917,14 @@ export default class RollbridgeDaemon {
    * @param {{config: import("./config.js").RollbridgeConfig, releaseId: string, releasePath: string, revision: string}} candidate - Requested identity.
    */
   assertExactGenerationTransition(transition, candidate) {
-    if (transition.candidateReleaseId !== candidate.releaseId || transition.candidateReleasePath !== candidate.releasePath || transition.candidateRevision !== candidate.revision || transition.configDigest !== ownerConfigDigest(candidate.config)) {
+    const retainedCandidate = this.releases.get(transition.candidateReleaseId)
+    const retainedAuthorityMatches = transition.phase !== "committed" &&
+      retainedCandidate?.releasePath === transition.candidateReleasePath &&
+      retainedCandidate.revision === transition.candidateRevision &&
+      ownerConfigDigest(retainedCandidate.config) === transition.configDigest
+    const requestedAuthorityMatches = ownerConfigDigest(candidate.config) === transition.configDigest
+
+    if (transition.candidateReleaseId !== candidate.releaseId || transition.candidateReleasePath !== candidate.releasePath || transition.candidateRevision !== candidate.revision || (!requestedAuthorityMatches && !retainedAuthorityMatches)) {
       throw new Error(`Release generation transition for ${transition.candidateReleaseId} is unresolved at ${transition.phase}; only the exact same release, path, revision, and config authority may resume it`)
     }
   }

package/src/managed-process.js

@@ -531,7 +531,7 @@ export default class ManagedProcess extends EventEmitter {
     const child = this.child
     const pid = this.pid
 
-    if (!child?.pid || child.pid !== pid || (this.state !== "quiesced" && this.state !== "running")) {
+    if (!child?.pid || child.pid !== pid || (this.state !== "failed" && this.state !== "quiesced" && this.state !== "running")) {
       throw new Error(`Process ${this.id} is not retained for reactivation`)
     }
     await this.runReactivationHook(pid)

package/src/release-group.js

@@ -290,10 +290,19 @@ export default class ReleaseGroup extends EventEmitter {
     if (!coordinator) throw new Error(`Generation activation process ${processConfig.id} is not retained for release ${this.releaseId}`)
     const generationIds = new Set([...this.handoffServiceIds, ...this.nonBlockingDrainIds])
 
+    /** @param {import("./managed-process.js").default} processInstance - Retained generation process. */
+    const reactivate = async (processInstance) => {
+      const {pid, state} = processInstance.status()
+
+      if (pid !== undefined) await processInstance.reactivateStrict()
+      else if (state === "stopped" || state === "failed") await processInstance.start("crash", "active")
+      else throw new Error(`Generation process is ${state}; refusing active-role restoration`)
+    }
+
     for (const [id, processInstance] of this.processes) {
-      if (generationIds.has(id) && processInstance !== coordinator.process) await processInstance.reactivateStrict()
+      if (generationIds.has(id) && processInstance !== coordinator.process) await reactivate(processInstance)
     }
-    await coordinator.process.reactivateStrict()
+    await reactivate(coordinator.process)
     this.state = "active"
     this.activatedAt = new Date().toISOString()
     this.drainStartedAt = undefined

package/test/managed-process.test.js

@@ -532,6 +532,31 @@ test("reactivateStrict restores a retained quiesced process only after activatio
   }
 })
 
+test("reactivateStrict retries a failed active-role startup against the retained child", async () => {
+  const managed = buildLongLived(() => false)
+  let attempts = 0
+
+  managed.lifecycle = {activateCommand: "jobs activate", drainTimeoutMs: 0}
+  managed.runHook = async () => {
+    attempts += 1
+    return attempts === 1 ? new Error("startup activation raced readiness") : undefined
+  }
+
+  try {
+    await assert.rejects(() => managed.start("deploy", "active"), /startup activation raced readiness/)
+    const failed = managed.status()
+
+    assert.equal(failed.state, "failed")
+    assert.ok(failed.pid)
+    await managed.reactivateStrict()
+    assert.equal(managed.status().state, "running")
+    assert.equal(managed.status().lifecycleRole, "active")
+    assert.equal(managed.status().pid, failed.pid)
+  } finally {
+    await managed.stop()
+  }
+})
+
 test("quiesce waits for active-role restoration before retiring a restarted process", async () => {
   const managed = buildLongLived(() => false)
   const hooks = /** @type {string[]} */ ([])

package/test/rollbridge.test.js

@@ -700,8 +700,12 @@ test("candidate activation failure reports restoration failure and exact recover
 
     assert.ok(failedCandidate)
     await failedCandidate.stop()
-    assert.equal(failedCandidate.state, "stopped")
     incumbentCoordinator.reactivateStrict = reactivate
+    await incumbentCoordinator.stop()
+    assert.equal(failedCandidate.state, "stopped")
+    assert.equal(incumbentCoordinator.status().state, "stopped")
+    daemon.config = structuredClone(daemon.config)
+    daemon.config.processes[0].lifecycle.activateTimeoutMs = (daemon.config.processes[0].lifecycle.activateTimeoutMs ?? 30000) + 1
     const recovery = await sendControlCommand({
       command: {
         command: "recover-generation-transition",