@platformatic/runtime 3.61.0 → 3.61.1

package/config.d.ts

@@ -196,6 +196,10 @@ export type PlatformaticRuntimeConfig = {
   server?: {
     hostname?: string;
     port?: number | string;
+    /**
+     * Configures how entrypoint server worker ports are assigned. When set to shared, all workers listen on the same port. When set to perWorkerIncrement, each worker will use its own port, starting from port (worker 0).
+     */
+    portAssignment?: "shared" | "perWorkerIncrement";
     /**
      * The maximum length of the queue of pending connections
      */

package/lib/runtime.js

@@ -155,6 +155,7 @@ export class Runtime extends EventEmitter {
   #restartingWorkers
   #dynamicWorkersScaler
   #nextWorkerIndex
+  #workerPortOffsets
 
   #sharedHttpCache
   #scheduler
@@ -196,6 +197,7 @@ export class Runtime extends EventEmitter {
     this.#restartingApplications = new Set()
     this.#restartingWorkers = new Map()
     this.#nextWorkerIndex = new Map()
+    this.#workerPortOffsets = new Map() // fullWorkerId => portOffset
     this.#sharedHttpCache = null
     this.#applicationsConfigsPatches = new Map()
 
@@ -544,12 +546,19 @@ export class Runtime extends EventEmitter {
 
   async addApplications (applications, start = false) {
     const setupInvocations = []
+    // Per-worker ports do not need SO_REUSEPORT because each worker binds a different port.
+    const usesPerWorkerPorts = this.#config.server?.portAssignment === 'perWorkerIncrement'
 
     const toStart = []
     for (const application of applications) {
       const workers = application.workers
 
-      if ((workers.static > 1 || workers.minimum > 1) && application.entrypoint && !features.node.reusePort) {
+      if (
+        (workers.static > 1 || workers.minimum > 1) &&
+        application.entrypoint &&
+        !features.node.reusePort &&
+        !usesPerWorkerPorts
+      ) {
         this.logger.warn(
           `"${application.id}" is set as the entrypoint, but reusePort is not available in your OS; setting workers to 1 instead of ${workers.static}`
         )
@@ -1833,6 +1842,7 @@ export class Runtime extends EventEmitter {
     const setupInvocations = []
 
     for (let i = 0; i < workers; i++) {
+      this.#workerPortOffsets.set(`${id}:${i}`, i)
       setupInvocations.push([config, applicationConfig, workers, id, i])
     }
 
@@ -1860,6 +1870,12 @@ export class Runtime extends EventEmitter {
       inspectorOptions.port = inspectorOptions.port + this.#workers.size + 1
     }
 
+    let serverConfigOverride
+    if (this.#config.server?.portAssignment === 'perWorkerIncrement') {
+      const portOffset = this.#workerPortOffsets.get(workerId)
+      serverConfigOverride = { port: Number(this.#config.server.port) + portOffset }
+    }
+
     if (config.telemetry) {
       applicationConfig.telemetry = {
         ...config.telemetry,
@@ -1923,12 +1939,21 @@ export class Runtime extends EventEmitter {
     const maxYoungGenerationSizeMb = maxYoungGeneration ? Math.floor(maxYoungGeneration / (1024 * 1024)) : undefined
     const codeRangeSizeMb = codeRangeSize ? Math.floor(codeRangeSize / (1024 * 1024)) : undefined
 
+    const workerConfig = {
+      ...config,
+      preload
+    }
+
+    if (config.server && serverConfigOverride) {
+      workerConfig.server = {
+        ...config.server,
+        ...serverConfigOverride
+      }
+    }
+
     const worker = new Worker(kWorkerFile, {
       workerData: {
-        config: {
-          ...config,
-          preload
-        },
+        config: workerConfig,
         applicationConfig: {
           ...applicationConfig,
           isProduction: this.#isProduction,
@@ -1977,6 +2002,7 @@ export class Runtime extends EventEmitter {
       worker[kWorkerStatus] = 'exited'
       this.emitAndNotify('application:worker:exited', eventPayload)
 
+      const portOffset = this.#workerPortOffsets.get(worker[kFullId]) ?? index
       this.#cleanupWorker(worker)
 
       if (this.#status === 'stopping') {
@@ -2001,7 +2027,7 @@ export class Runtime extends EventEmitter {
               this.logger.warn(`The ${errorLabel} will be restarted in ${restartOnError}ms ...`)
             }
 
-            this.#restartCrashedWorker(config, applicationConfig, workersCount, applicationId, index, false, 0).catch(
+            this.#restartCrashedWorker(config, applicationConfig, workersCount, applicationId, index, false, 0, portOffset).catch(
               err => {
                 this.logger.error({ err: ensureLoggableError(err) }, `${errorLabel} could not be restarted.`)
               }
@@ -2486,6 +2512,7 @@ export class Runtime extends EventEmitter {
     } catch (err) {
       const error = ensureError(err)
       worker[kITC].notify('application:worker:start:processed')
+      const portOffset = this.#workerPortOffsets.get(worker[kFullId]) ?? index
 
       // TODO: handle port allocation error here
       if (error.code === 'EADDRINUSE' || error.code === 'EACCES') throw error
@@ -2532,7 +2559,7 @@ export class Runtime extends EventEmitter {
         )
       }
 
-      await this.#restartCrashedWorker(config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt)
+      await this.#restartCrashedWorker(config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt, portOffset)
     }
   }
 
@@ -2601,6 +2628,7 @@ export class Runtime extends EventEmitter {
 
   #cleanupWorker (worker) {
     clearTimeout(worker[kHealthCheckTimer])
+    this.#workerPortOffsets.delete(worker[kFullId])
 
     const currentWorker = this.#workers.get(worker[kFullId])
 
@@ -2629,7 +2657,7 @@ export class Runtime extends EventEmitter {
     return index
   }
 
-  async #restartCrashedWorker (config, applicationConfig, workersCount, id, oldIndex, silent, bootstrapAttempt) {
+  async #restartCrashedWorker (config, applicationConfig, workersCount, id, oldIndex, silent, bootstrapAttempt, portOffset) {
     // Use oldIndex for tracking to prevent duplicate restarts of the same crashed worker
     const restartKey = `${id}:${oldIndex}`
 
@@ -2650,18 +2678,22 @@ export class Runtime extends EventEmitter {
         }
 
         // Get a new unique index for the restarted worker
-        const index = this.#getNextWorkerIndex(id)
+        const newIndex = this.#getNextWorkerIndex(id)
+        const newWorkerId = `${id}:${newIndex}`
+        this.#workerPortOffsets.set(newWorkerId, portOffset)
 
         try {
-          await this.#setupWorker(config, applicationConfig, workersCount, id, index)
-          await this.#startWorker(config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt)
+          await this.#setupWorker(config, applicationConfig, workersCount, id, newIndex)
+          await this.#startWorker(config, applicationConfig, workersCount, id, newIndex, silent, bootstrapAttempt)
           this.#incrementApplicationRestartCount(id)
 
           this.logger.info(
-            `The ${this.#workerExtendedLabel(id, index, workersCount)} has been successfully restarted ...`
+            `The ${this.#workerExtendedLabel(id, newIndex, workersCount)} has been successfully restarted ...`
           )
           resolve()
         } catch (err) {
+          this.#workerPortOffsets.delete(newWorkerId)
+
           // The runtime was stopped while the restart was happening, ignore any error.
           if (!this.#status.startsWith('start')) {
             resolve()
@@ -2690,6 +2722,8 @@ export class Runtime extends EventEmitter {
     const newIndex = this.#getNextWorkerIndex(applicationId)
     const newWorkerId = `${applicationId}:${newIndex}`
     const newLabel = this.#workerExtendedLabel(applicationId, newIndex, workersCount)
+    const portOffset = this.#workerPortOffsets.get(`${applicationId}:${oldIndex}`)
+    this.#workerPortOffsets.set(newWorkerId, portOffset)
 
     const stopBeforeStart =
       applicationConfig.entrypoint &&
@@ -2705,15 +2739,15 @@ export class Runtime extends EventEmitter {
       configForNewWorker = { ...config, server: { ...config.server, port: this.#entrypointPort } }
     }
 
-    if (stopBeforeStart) {
-      await this.#removeWorker(workersCount, applicationId, oldIndex, worker, silent, oldLabel)
-    }
-
     try {
       if (!silent) {
         this.logger.debug(`Preparing to start ${newLabel} as replacement for ${oldLabel} ...`)
       }
 
+      if (stopBeforeStart) {
+        await this.#removeWorker(workersCount, applicationId, oldIndex, worker, silent, oldLabel)
+      }
+
       // Create a new worker with a new index, preserving any pinned port when stopBeforeStart is required.
       newWorker = await this.#setupWorker(configForNewWorker, applicationConfig, workersCount, applicationId, newIndex, false)
 
@@ -2732,6 +2766,7 @@ export class Runtime extends EventEmitter {
 
       this.#workers.set(newWorkerId, newWorker)
     } catch (e) {
+      this.#workerPortOffsets.delete(newWorkerId)
       newWorker?.terminate?.()
       throw e
     }
@@ -3286,16 +3321,25 @@ export class Runtime extends EventEmitter {
 
     if (currentWorkers < workers) {
       report.started = []
+      let pendingWorkerId
+
       try {
         for (let i = currentWorkers; i < workers; i++) {
           const newIndex = this.#getNextWorkerIndex(applicationId)
+          pendingWorkerId = `${applicationId}:${newIndex}`
+          this.#workerPortOffsets.set(pendingWorkerId, i)
+
           await this.#setupWorker(config, applicationConfig, workers, applicationId, newIndex)
           await this.#startWorker(config, applicationConfig, workers, applicationId, newIndex, false, 0)
+
+          pendingWorkerId = undefined
           report.started.push(newIndex)
           startedWorkersCount++
         }
         report.success = true
       } catch (err) {
+        pendingWorkerId && this.#workerPortOffsets.delete(pendingWorkerId)
+
         if (startedWorkersCount < 1) {
           this.logger.error({ err }, 'Cannot start application workers, no worker started')
         } else {
@@ -3310,21 +3354,32 @@ export class Runtime extends EventEmitter {
       // keep the current workers count until all the application workers are all stopped
       report.stopped = []
       try {
-        // Get actual worker keys and sort by index descending to stop most recent first (snapshot to avoid mutation during iteration)
-        const workerKeys = [...this.#workers.getKeys(applicationId)]
-        const workerIndices = workerKeys
+        const workersToStop = currentWorkers - workers
+        const allInOnePort = this.#config.server?.portAssignment !== 'perWorkerIncrement'
+        const workerIdsToStop = this.#workers
+          .getKeys(applicationId)
           .map(key => parseInt(key.split(':')[1], 10))
-          .sort((a, b) => b - a) // descending order
 
-        const workersToStop = currentWorkers - workers
-        for (let i = 0; i < workersToStop && i < workerIndices.length; i++) {
-          const workerIndex = workerIndices[i]
+        if (allInOnePort) {
+          // Stop most recent workers first.
+          workerIdsToStop.sort((a, b) => b - a)
+        } else {
+          // When port increment is enabled, disable the workers with the highest ports.
+          workerIdsToStop.sort((a, b) => {
+            const offsetA = this.#workerPortOffsets.get(`${applicationId}:${a}`) ?? a
+            const offsetB = this.#workerPortOffsets.get(`${applicationId}:${b}`) ?? b
+            return offsetB - offsetA
+          })
+        }
+
+        for (const workerIndex of workerIdsToStop.splice(0, workersToStop)) {
           const worker = this.#workers.get(`${applicationId}:${workerIndex}`)
           await sendViaITC(worker, 'removeFromMesh')
           await this.#stopWorker(currentWorkers, applicationId, workerIndex, false, worker, [])
           report.stopped.push(workerIndex)
           stoppedWorkersCount++
         }
+
         report.success = true
       } catch (err) {
         if (stoppedWorkersCount < 1) {

package/lib/worker/round-robin-map.js

@@ -43,7 +43,7 @@ export class RoundRobinMap extends Map {
   }
 
   getKeys (application) {
-    return this.#instances[application]?.keys ?? []
+    return [...(this.#instances[application]?.keys ?? [])]
   }
 
   next (application) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.61.0",
+  "version": "3.61.1",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -39,14 +39,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.61.0",
-    "@platformatic/db": "3.61.0",
-    "@platformatic/gateway": "3.61.0",
-    "@platformatic/node": "3.61.0",
-    "@platformatic/service": "3.61.0",
-    "@platformatic/sql-graphql": "3.61.0",
-    "@platformatic/wattpm-pprof-capture": "3.61.0",
-    "@platformatic/sql-mapper": "3.61.0"
+    "@platformatic/db": "3.61.1",
+    "@platformatic/gateway": "3.61.1",
+    "@platformatic/service": "3.61.1",
+    "@platformatic/node": "3.61.1",
+    "@platformatic/composer": "3.61.1",
+    "@platformatic/sql-graphql": "3.61.1",
+    "@platformatic/wattpm-pprof-capture": "3.61.1",
+    "@platformatic/sql-mapper": "3.61.1"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -77,13 +77,13 @@
     "undici": "^7.27.2",
     "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.61.0",
-    "@platformatic/generators": "3.61.0",
-    "@platformatic/foundation": "3.61.0",
-    "@platformatic/globals": "3.61.0",
-    "@platformatic/itc": "3.61.0",
-    "@platformatic/telemetry": "3.61.0",
-    "@platformatic/metrics": "3.61.0"
+    "@platformatic/basic": "3.61.1",
+    "@platformatic/foundation": "3.61.1",
+    "@platformatic/globals": "3.61.1",
+    "@platformatic/itc": "3.61.1",
+    "@platformatic/metrics": "3.61.1",
+    "@platformatic/telemetry": "3.61.1",
+    "@platformatic/generators": "3.61.1"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.61.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.61.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -1889,6 +1889,14 @@
             }
           ]
         },
+        "portAssignment": {
+          "type": "string",
+          "enum": [
+            "shared",
+            "perWorkerIncrement"
+          ],
+          "description": "Configures how entrypoint server worker ports are assigned. When set to shared, all workers listen on the same port. When set to perWorkerIncrement, each worker will use its own port, starting from port (worker 0)."
+        },
         "backlog": {
           "type": "integer",
           "description": "The maximum length of the queue of pending connections"