rollbridge 0.1.39 → 0.1.41

package/src/config.js

@@ -14,7 +14,7 @@ import {pathToFileURL} from "node:url"
  * @typedef {"proxied" | "companion" | "singleton" | "service"} ProcessPolicy
  * @typedef {{backoffFactor: number, maxDelayMs: number, maxRestarts: number | undefined, windowMs: number}} RestartConfig
  * @typedef {{checkIntervalMs: number, limitBytes: number, warnBytes: number}} MemoryConfig
- * @typedef {{activateCommand?: string, drainCommand?: string, drainTimeoutMs: number, quietCommand?: string, stopCommand?: string}} LifecycleConfig
+ * @typedef {{activateCommand?: string, drainCommand?: string, drainTimeoutMs: number, quietCommand?: string, reactivateCommand?: string, stopCommand?: string}} LifecycleConfig
  * @typedef {number | "indefinite"} StopTimeoutMs
  * @typedef {"persistent" | "handoff"} ServiceDeployStrategy
  * @typedef {{cwd?: string, deployStrategy: ServiceDeployStrategy, env: Record<string, string>, gracefulStopMs: StopTimeoutMs, health?: HealthConfig, id: string, lifecycle: LifecycleConfig, memory?: MemoryConfig, nonBlockingDrain: boolean, outputLines: number, policy: ProcessPolicy, port?: PortRange, replicas: number, restart: RestartConfig, restartDelayMs: number, stopSignal: string, command: string}} ProcessConfig
@@ -67,8 +67,12 @@ export async function parseConfigFile(configPath) {
  */
 export async function loadConfig(configPath) {
   const {absolutePath, rawConfig} = await parseConfigFile(configPath)
+  const config = normalizeConfig(rawConfig, absolutePath)
+  const configDirectory = path.dirname(absolutePath)
 
-  return normalizeConfig(rawConfig, absolutePath)
+  config.control.path = path.resolve(configDirectory, config.control.path)
+  if (config.statePath) config.statePath = path.resolve(configDirectory, config.statePath)
+  return config
 }
 
 /**
@@ -342,7 +346,7 @@ function normalizeLifecycle(value, key, issues) {
   if (value === undefined || value === null) return {drainTimeoutMs: 0}
 
   if (!isPlainObject(value)) {
-    issues.push({fix: `Set ${key} to a mapping with optional activateCommand, quietCommand, drainCommand, stopCommand, and drainTimeoutMs.`, message: `${key} must be an object`})
+    issues.push({fix: `Set ${key} to a mapping with optional activateCommand, quietCommand, reactivateCommand, drainCommand, stopCommand, and drainTimeoutMs.`, message: `${key} must be an object`})
 
     return {drainTimeoutMs: 0}
   }
@@ -351,10 +355,11 @@ function normalizeLifecycle(value, key, issues) {
   /** @type {LifecycleConfig} */
   const lifecycle = {drainTimeoutMs: nonNegativeOrDefault(drainTimeoutMs, `${key}.drainTimeoutMs`, issues, 0, false)}
 
-  if (value.activateCommand !== undefined) lifecycle.activateCommand = normalizeString(value.activateCommand, `${key}.activateCommand`, issues)
-  if (value.quietCommand !== undefined) lifecycle.quietCommand = normalizeString(value.quietCommand, `${key}.quietCommand`, issues)
-  if (value.drainCommand !== undefined) lifecycle.drainCommand = normalizeString(value.drainCommand, `${key}.drainCommand`, issues)
-  if (value.stopCommand !== undefined) lifecycle.stopCommand = normalizeString(value.stopCommand, `${key}.stopCommand`, issues)
+  if (value.activateCommand !== undefined) lifecycle.activateCommand = normalizeString(value.activateCommand, `${key}.activateCommand`, issues, {nonEmpty: true})
+  if (value.quietCommand !== undefined) lifecycle.quietCommand = normalizeString(value.quietCommand, `${key}.quietCommand`, issues, {nonEmpty: true})
+  if (value.reactivateCommand !== undefined) lifecycle.reactivateCommand = normalizeString(value.reactivateCommand, `${key}.reactivateCommand`, issues, {nonEmpty: true})
+  if (value.drainCommand !== undefined) lifecycle.drainCommand = normalizeString(value.drainCommand, `${key}.drainCommand`, issues, {nonEmpty: true})
+  if (value.stopCommand !== undefined) lifecycle.stopCommand = normalizeString(value.stopCommand, `${key}.stopCommand`, issues, {nonEmpty: true})
 
   if (lifecycle.drainCommand !== undefined && lifecycle.drainTimeoutMs <= 0) {
     issues.push({fix: `Set ${key}.drainTimeoutMs to a positive number to bound ${key}.drainCommand; with 0 the drain step is skipped and the command never runs.`, message: `${key}.drainCommand requires a positive ${key}.drainTimeoutMs`})
@@ -372,6 +377,7 @@ function normalizeLifecycle(value, key, issues) {
  */
 function validateActivationLifecycle(processes, ownerRecovery, statePath, issues) {
   const activated = processes.filter((processConfig) => processConfig.lifecycle.activateCommand !== undefined)
+  const reactivated = processes.filter((processConfig) => processConfig.lifecycle.reactivateCommand !== undefined)
 
   if (activated.length > 1) {
     issues.push({fix: "Configure lifecycle.activateCommand on only one release-generation coordinator.", message: "Config may define at most one lifecycle.activateCommand"})
@@ -386,6 +392,23 @@ function validateActivationLifecycle(processes, ownerRecovery, statePath, issues
     }
   }
 
+  for (const processConfig of reactivated) {
+    if (processConfig.policy !== "companion" || !processConfig.nonBlockingDrain) {
+      issues.push({fix: `Set lifecycle.reactivateCommand only on a nonBlockingDrain companion; "${processConfig.id}" is ${processConfig.policy} with nonBlockingDrain: ${processConfig.nonBlockingDrain}.`, message: `Process "${processConfig.id}" can only set lifecycle.reactivateCommand on a nonBlockingDrain companion`})
+    }
+    if (!processConfig.lifecycle.quietCommand) {
+      issues.push({fix: `Add lifecycle.quietCommand to "${processConfig.id}" so worker reactivation has a paired retirement command.`, message: `Process "${processConfig.id}" lifecycle.reactivateCommand requires lifecycle.quietCommand`})
+    }
+  }
+
+  if (activated.length > 0) {
+    for (const processConfig of processes) {
+      if (processConfig.nonBlockingDrain && processConfig.lifecycle.quietCommand && !processConfig.lifecycle.reactivateCommand) {
+        issues.push({fix: `Add lifecycle.reactivateCommand to "${processConfig.id}" so failed candidate recovery reverses its external quiet hook.`, message: `Process "${processConfig.id}" lifecycle.quietCommand requires lifecycle.reactivateCommand during generation activation recovery`})
+      }
+    }
+  }
+
   if (activated.length > 0 && (!ownerRecovery || !statePath)) {
     issues.push({fix: "Configure statePath and ownerRecovery for durable release-generation transition recovery.", message: "lifecycle.activateCommand requires ownerRecovery and statePath"})
   }
@@ -849,7 +872,7 @@ function normalizePortRange(value, key, issues) {
  * @param {JsonValue} value - Raw value.
  * @param {string} key - Config key.
  * @param {ConfigIssue[]} issues - Issue collector.
- * @param {{default?: string}} [options] - Options.
+ * @param {{default?: string, nonEmpty?: boolean}} [options] - Options.
  * @returns {string} Normalized string, or a placeholder when invalid.
  */
 function normalizeString(value, key, issues, options = {}) {
@@ -867,6 +890,10 @@ function normalizeString(value, key, issues, options = {}) {
     return options.default ?? ""
   }
 
+  if (options.nonEmpty && !value.trim()) {
+    issues.push({fix: `Set ${key} to a non-empty command string.`, message: `${key} must not be empty`})
+  }
+
   return value
 }