@platformatic/runtime 3.4.1 → 3.5.1

package/lib/worker/messaging.js

@@ -0,0 +1,182 @@
+import { executeWithTimeout, kTimeout } from '@platformatic/foundation'
+import { ITC, generateResponse, sanitize } from '@platformatic/itc'
+import { MessagingError } from '../errors.js'
+import { RoundRobinMap } from './round-robin-map.js'
+import { kITC, kWorkersBroadcast } from './symbols.js'
+
+const kPendingResponses = Symbol('plt.messaging.pendingResponses')
+
+export class MessagingITC extends ITC {
+  #timeout
+  #listener
+  #closeResolvers
+  #broadcastChannel
+  #workers
+  #sources
+
+  constructor (id, runtimeConfig) {
+    super({
+      throwOnMissingHandler: true,
+      name: `${id}-messaging`
+    })
+
+    this.#timeout = runtimeConfig.messagingTimeout
+    this.#workers = new RoundRobinMap()
+    this.#sources = new Set()
+
+    // Start listening on the BroadcastChannel for the list of applications
+    this.#broadcastChannel = new BroadcastChannel(kWorkersBroadcast)
+    this.#broadcastChannel.onmessage = this.#updateWorkers.bind(this)
+
+    this.listen()
+  }
+
+  _setupListener (listener) {
+    this.#listener = listener
+  }
+
+  handle (message, handler) {
+    if (typeof message === 'object') {
+      for (const [name, fn] of Object.entries(message)) {
+        super.handle(name, fn)
+      }
+    } else {
+      super.handle(message, handler)
+    }
+  }
+
+  async send (application, name, message, options) {
+    // Get the next worker for the application
+    const worker = this.#workers.next(application)
+
+    if (!worker) {
+      throw new MessagingError(application, 'No workers available')
+    }
+
+    if (!worker.channel) {
+      // Use twice the value here as a fallback measure. The target handler in the main thread is forwarding
+      // the request to the worker, using executeWithTimeout with the user set timeout value.
+      const channel = await executeWithTimeout(
+        globalThis[kITC].send('getWorkerMessagingChannel', { application: worker.application, worker: worker.worker }),
+        this.#timeout * 2
+      )
+
+      /* c8 ignore next 3 - Hard to test */
+      if (channel === kTimeout) {
+        throw new MessagingError(application, 'Timeout while waiting for a communication channel.')
+      }
+
+      worker.channel = channel
+      this.#setupChannel(channel)
+
+      channel[kPendingResponses] = new Map()
+      channel.on('close', this.#handlePendingResponse.bind(this, channel))
+    }
+
+    const context = { ...options }
+    context.channel = worker.channel
+    context.application = worker.application
+    context.trackResponse = true
+
+    const response = await executeWithTimeout(super.send(name, message, context), this.#timeout)
+
+    if (response === kTimeout) {
+      throw new MessagingError(application, 'Timeout while waiting for a response.')
+    }
+
+    return response
+  }
+
+  async addSource (channel) {
+    this.#sources.add(channel)
+    this.#setupChannel(channel)
+
+    // This has been closed on the other side.
+    // Pending messages will be silently discarded by Node (as postMessage does not throw) so we don't need to handle them.
+    channel.on('close', () => {
+      this.#sources.delete(channel)
+    })
+  }
+
+  _send (request, context) {
+    const { channel, transferList } = context
+
+    if (context.trackResponse) {
+      const application = context.application
+      channel[kPendingResponses].set(request.reqId, { application, request })
+    }
+
+    channel.postMessage(sanitize(request, transferList), { transferList })
+  }
+
+  _createClosePromise () {
+    const { promise, resolve, reject } = Promise.withResolvers()
+    this.#closeResolvers = { resolve, reject }
+    return promise
+  }
+
+  _close () {
+    this.#closeResolvers.resolve()
+    this.#broadcastChannel.close()
+
+    for (const source of this.#sources) {
+      source.close()
+    }
+
+    for (const worker of this.#workers.values()) {
+      worker.channel?.close()
+    }
+
+    this.#sources.clear()
+  }
+
+  #setupChannel (channel) {
+    // Setup the message for processing
+    channel.on('message', event => {
+      this.#listener(event, { channel })
+    })
+  }
+
+  #updateWorkers (event) {
+    // Gather all existing channels by thread, it will make them reusable
+    const existingChannels = new Map()
+    for (const source of this.#workers.values()) {
+      existingChannels.set(source.thread, source.channel)
+    }
+
+    // Create a brand new map
+    this.#workers = new RoundRobinMap()
+
+    const instances = []
+    for (const [application, workers] of event.data) {
+      const count = workers.length
+      const next = Math.floor(Math.random() * count)
+
+      instances.push({ id: application, next, workers: count })
+
+      for (let i = 0; i < count; i++) {
+        const worker = workers[i]
+        const channel = existingChannels.get(worker.thread)
+
+        // Note i is not the worker index as in runtime, but the index in the list of current alive workers for the application
+        this.#workers.set(`${application}:${i}`, { ...worker, channel })
+      }
+    }
+
+    this.#workers.configure(instances)
+  }
+
+  #handlePendingResponse (channel) {
+    for (const { application, request } of channel[kPendingResponses].values()) {
+      this._emitResponse(
+        generateResponse(
+          request,
+          new MessagingError(application, 'The communication channel was closed before receiving a response.'),
+          null
+        )
+      )
+    }
+
+    channel[kPendingResponses].clear()
+  }
+}

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

@@ -0,0 +1,62 @@
+export class RoundRobinMap extends Map {
+  #instances
+
+  constructor (iterable, instances = {}) {
+    super(iterable)
+    this.#instances = instances
+  }
+
+  get configuration () {
+    return { ...this.#instances }
+  }
+
+  configure (applications) {
+    this.#instances = {}
+
+    for (const application of applications) {
+      this.#instances[application.id] = { next: application.next ?? 0, count: application.workers }
+    }
+  }
+
+  getCount (application) {
+    if (!this.#instances[application]) {
+      return null
+    }
+
+    return this.#instances[application].count
+  }
+
+  setCount (application, count) {
+    if (!this.#instances[application]) {
+      throw new Error(`Application ${application} is not configured.`)
+    }
+
+    this.#instances[application].count = count
+  }
+
+  next (application) {
+    if (!this.#instances[application]) {
+      return null
+    }
+
+    let worker
+    let { next, count } = this.#instances[application]
+
+    // Try count times to get the next worker. This is to handle the case where a worker is being restarted.
+    for (let i = 0; i < count; i++) {
+      const current = next++
+      if (next >= count) {
+        next = 0
+      }
+
+      worker = this.get(`${application}:${current}`)
+
+      if (worker) {
+        break
+      }
+    }
+
+    this.#instances[application].next = next
+    return worker
+  }
+}

package/lib/worker/shared-context.js

@@ -0,0 +1,22 @@
+import { kITC } from './symbols.js'
+
+export class SharedContext {
+  constructor () {
+    this.sharedContext = null
+  }
+
+  update (context, options = {}) {
+    return globalThis[kITC].send('updateSharedContext', { ...options, context })
+  }
+
+  get () {
+    if (this.sharedContext === null) {
+      this.sharedContext = globalThis[kITC].send('getSharedContext')
+    }
+    return this.sharedContext
+  }
+
+  _set (context) {
+    this.sharedContext = context
+  }
+}

package/lib/worker/symbols.js

@@ -1,7 +1,16 @@
-'use strict'
+export const kConfig = Symbol.for('plt.runtime.config')
+export const kId = Symbol.for('plt.runtime.id') // This is also used to detect if we are running in a Platformatic runtime thread
+export const kFullId = Symbol.for('plt.runtime.fullId')
+export const kApplicationId = Symbol.for('plt.runtime.application.id')
+export const kWorkerId = Symbol.for('plt.runtime.worker.id')
+export const kITC = Symbol.for('plt.runtime.itc')
+export const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
+export const kWorkerStatus = Symbol('plt.runtime.worker.status')
+export const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
+export const kLastELU = Symbol.for('plt.runtime.worker.lastELU')
 
-const kConfig = Symbol.for('plt.runtime.config')
-const kId = Symbol.for('plt.runtime.id') // This is also used to detect if we are running in a Platformatic runtime thread
-const kITC = Symbol.for('plt.runtime.itc')
+// This string marker should be safe to use since it belongs to Unicode private area
+export const kStderrMarker = '\ue002'
 
-module.exports = { kConfig, kId, kITC }
+// Note that this is used to create a BroadcastChannel so it must be a string
+export const kWorkersBroadcast = 'plt.runtime.workers'

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.4.1",
+  "version": "3.5.1",
   "description": "",
   "main": "index.js",
-  "bin": {
-    "plt-runtime": "./runtime.mjs"
-  },
-  "author": "Matteo Collina <hello@matteocollina.com>",
+  "type": "module",
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
@@ -17,71 +15,82 @@
   },
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
+    "@fastify/compress": "^8.0.0",
     "@fastify/express": "^4.0.0",
     "@fastify/formbody": "^8.0.0",
-    "borp": "^0.17.0",
+    "autocannon": "^8.0.0",
     "c8": "^10.0.0",
+    "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
-    "execa": "^8.0.1",
+    "execa": "^9.0.0",
     "express": "^4.18.3",
-    "fast-jwt": "^4.0.0",
+    "fast-jwt": "^5.0.0",
     "get-port": "^7.1.0",
+    "inspector-client": "^0.2.0",
     "json-schema-to-typescript": "^15.0.0",
-    "neostandard": "^0.11.1",
+    "neostandard": "^0.12.0",
     "pino-abstract-transport": "^2.0.0",
     "split2": "^4.2.0",
-    "tsd": "^0.31.0",
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.4.1",
-    "@platformatic/db": "3.4.1",
-    "@platformatic/service": "3.4.1",
-    "@platformatic/sql-graphql": "3.4.1",
-    "@platformatic/sql-mapper": "3.4.1"
+    "@platformatic/db": "3.5.1",
+    "@platformatic/gateway": "3.5.1",
+    "@platformatic/composer": "3.5.1",
+    "@platformatic/node": "3.5.1",
+    "@platformatic/service": "3.5.1",
+    "@platformatic/sql-graphql": "3.5.1",
+    "@platformatic/wattpm-pprof-capture": "3.5.1",
+    "@platformatic/sql-mapper": "3.5.1"
   },
   "dependencies": {
+    "@fastify/accepts": "^5.0.0",
+    "@fastify/basic-auth": "^6.0.0",
     "@fastify/error": "^4.0.0",
     "@fastify/websocket": "^11.0.0",
-    "@hapi/topo": "^6.0.2",
-    "@platformatic/http-metrics": "^0.2.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@platformatic/undici-cache-memory": "^0.8.1",
     "@watchable/unpromise": "^1.0.2",
-    "boring-name-generator": "^1.0.3",
     "change-case-all": "^2.1.0",
-    "close-with-grace": "^2.0.0",
-    "commist": "^3.2.0",
+    "close-with-grace": "^2.2.0",
+    "colorette": "^2.0.20",
+    "cron": "^4.1.0",
     "debounce": "^2.0.0",
-    "desm": "^1.3.1",
+    "dotenv": "^16.4.5",
     "dotenv-tool": "^0.1.1",
-    "es-main": "^1.3.0",
     "fastest-levenshtein": "^1.0.16",
     "fastify": "^5.0.0",
     "graphql": "^16.8.1",
     "help-me": "^5.0.0",
     "minimist": "^1.2.8",
-    "pino": "^8.19.0",
-    "pino-pretty": "^11.0.0",
-    "pino-roll": "^2.0.0",
+    "pino": "^9.9.0",
+    "pino-pretty": "^13.0.0",
     "prom-client": "^15.1.2",
     "semgrator": "^0.3.0",
-    "tail-file-stream": "^0.2.0",
-    "undici": "^6.9.0",
-    "undici-thread-interceptor": "^0.7.0",
+    "sonic-boom": "^4.2.0",
+    "undici": "^7.0.0",
+    "undici-thread-interceptor": "^0.14.0",
     "ws": "^8.16.0",
-    "@platformatic/generators": "3.4.1",
-    "@platformatic/basic": "3.4.1",
-    "@platformatic/config": "3.4.1",
-    "@platformatic/itc": "3.4.1",
-    "@platformatic/ts-compiler": "3.4.1",
-    "@platformatic/telemetry": "3.4.1",
-    "@platformatic/utils": "3.4.1"
+    "@platformatic/basic": "3.5.1",
+    "@platformatic/generators": "3.5.1",
+    "@platformatic/foundation": "3.5.1",
+    "@platformatic/itc": "3.5.1",
+    "@platformatic/telemetry": "3.5.1",
+    "@platformatic/metrics": "3.5.1"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
   "scripts": {
-    "test": "npm run lint && borp --concurrency=1 --timeout=180000 && tsd",
-    "coverage": "npm run lint && borp -X fixtures -X test -C --concurrency=1 --timeout=180000 && tsd",
+    "test": "npm run test:main && npm run test:api && npm run test:cli && npm run test:start && npm run test:multiple-workers",
+    "test:main": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/versions/*.test.js",
+    "test:api": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/api/*.test.js test/management-api/*.test.js",
+    "test:cli": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/cli/*.test.js test/cli/**/*.test.js",
+    "test:start": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/start/*.test.js",
+    "test:multiple-workers": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/multiple-workers/*.test.js",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
-    "build": "pnpm run gen-schema && pnpm run gen-types",
+    "build": "npm run gen-schema && npm run gen-types",
     "lint": "eslint"
   }
 }