@platformatic/runtime 3.0.0-alpha.5 → 3.0.0-alpha.8

package/lib/worker/itc.js

@@ -1,16 +1,22 @@
-'use strict'
-
-const { once } = require('node:events')
-const { parentPort, workerData } = require('node:worker_threads')
-
-const { ITC } = require('@platformatic/itc')
-const { ensureLoggableError } = require('@platformatic/foundation')
-const { Unpromise } = require('@watchable/unpromise')
-
-const errors = require('../errors')
-const { updateUndiciInterceptors } = require('./interceptors')
-const { kITC, kId, kServiceId, kWorkerId } = require('./symbols')
-const { MessagingITC } = require('./messaging')
+import { ensureLoggableError } from '@platformatic/foundation'
+import { ITC } from '@platformatic/itc'
+import { Unpromise } from '@watchable/unpromise'
+import { once } from 'node:events'
+import { parentPort, workerData } from 'node:worker_threads'
+import {
+  ApplicationExitedError,
+  FailedToPerformCustomHealthCheckError,
+  FailedToPerformCustomReadinessCheckError,
+  FailedToRetrieveGraphQLSchemaError,
+  FailedToRetrieveHealthError,
+  FailedToRetrieveMetaError,
+  FailedToRetrieveMetricsError,
+  FailedToRetrieveOpenAPISchemaError,
+  WorkerExitedError
+} from '../errors.js'
+import { updateUndiciInterceptors } from './interceptors.js'
+import { MessagingITC } from './messaging.js'
+import { kApplicationId, kITC, kId, kWorkerId } from './symbols.js'
 
 async function safeHandleInITC (worker, fn) {
   try {
@@ -27,9 +33,9 @@ async function safeHandleInITC (worker, fn) {
 
     if (typeof exitCode === 'number') {
       if (typeof worker[kWorkerId] !== 'undefined') {
-        throw new errors.WorkerExitedError(worker[kWorkerId], worker[kServiceId], exitCode)
+        throw new WorkerExitedError(worker[kWorkerId], worker[kApplicationId], exitCode)
       } else {
-        throw new errors.ServiceExitedError(worker[kId], exitCode)
+        throw new ApplicationExitedError(worker[kId], exitCode)
       }
     } else {
       ac.abort()
@@ -49,22 +55,22 @@ async function safeHandleInITC (worker, fn) {
   }
 }
 
-async function sendViaITC (worker, name, message, transferList) {
-  return safeHandleInITC(worker, () => worker[kITC].send(name, message, { transferList }))
-}
-
-async function waitEventFromITC (worker, event) {
-  return safeHandleInITC(worker, () => once(worker[kITC], event))
-}
-
 async function closeITC (dispatcher, itc, messaging) {
   await dispatcher.interceptor.close()
   itc.close()
   messaging.close()
 }
 
-function setupITC (app, service, dispatcher, sharedContext) {
-  const messaging = new MessagingITC(app.appConfig.id, workerData.config)
+export async function sendViaITC (worker, name, message, transferList) {
+  return safeHandleInITC(worker, () => worker[kITC].send(name, message, { transferList }))
+}
+
+export async function waitEventFromITC (worker, event) {
+  return safeHandleInITC(worker, () => once(worker[kITC], event))
+}
+
+export function setupITC (controller, application, dispatcher, sharedContext) {
+  const messaging = new MessagingITC(controller.appConfig.id, workerData.config)
 
   Object.assign(globalThis.platformatic ?? {}, {
     messaging: {
@@ -74,55 +80,61 @@ function setupITC (app, service, dispatcher, sharedContext) {
   })
 
   const itc = new ITC({
-    name: app.appConfig.id + '-worker',
+    name: controller.appConfig.id + '-worker',
     port: parentPort,
     handlers: {
       async start () {
-        const status = app.getStatus()
+        const status = controller.getStatus()
 
         if (status === 'starting') {
-          await once(app, 'start')
+          await once(controller, 'start')
         } else {
-          // This gives a chance to a stackable to perform custom logic
+          // This gives a chance to a capability to perform custom logic
           globalThis.platformatic.events.emit('start')
 
           try {
-            await app.start()
+            await controller.start()
           } catch (e) {
-            await app.stop(true)
-            await closeITC(dispatcher, itc, messaging)
+            await controller.stop(true)
+
+            // Reply to the runtime that the start failed, so it can cleanup
+            once(itc, 'application:worker:start:processed').then(() => {
+              closeITC(dispatcher, itc, messaging).catch(() => {})
+            })
 
             throw ensureLoggableError(e)
           }
         }
 
-        if (service.entrypoint) {
-          await app.listen()
+        if (application.entrypoint) {
+          await controller.listen()
         }
 
-        dispatcher.replaceServer(await app.stackable.getDispatchTarget())
-        return service.entrypoint ? app.stackable.getUrl() : null
+        dispatcher.replaceServer(await controller.capability.getDispatchTarget())
+        return application.entrypoint ? controller.capability.getUrl() : null
       },
 
-      async stop () {
-        const status = app.getStatus()
+      async stop ({ force, dependents }) {
+        const status = controller.getStatus()
 
-        if (status === 'starting') {
-          await once(app, 'start')
+        if (!force && status === 'starting') {
+          await once(controller, 'start')
         }
 
-        if (status.startsWith('start')) {
-          // This gives a chance to a stackable to perform custom logic
+        if (force || status.startsWith('start')) {
+          // This gives a chance to a capability to perform custom logic
           globalThis.platformatic.events.emit('stop')
 
-          await app.stop()
+          await controller.stop(force, dependents)
         }
 
-        await closeITC(dispatcher, itc, messaging)
+        once(itc, 'application:worker:stop:processed').then(() => {
+          closeITC(dispatcher, itc, messaging).catch(() => {})
+        })
       },
 
       async build () {
-        return app.stackable.build()
+        return controller.capability.build()
       },
 
       async removeFromMesh () {
@@ -130,7 +142,7 @@ function setupITC (app, service, dispatcher, sharedContext) {
       },
 
       inject (injectParams) {
-        return app.stackable.inject(injectParams)
+        return controller.capability.inject(injectParams)
       },
 
       async updateUndiciInterceptors (undiciConfig) {
@@ -138,87 +150,83 @@ function setupITC (app, service, dispatcher, sharedContext) {
       },
 
       async updateWorkersCount (data) {
-        const { serviceId, workers } = data
-        const worker = workerData.config.serviceMap.get(serviceId)
-        if (worker) {
-          worker.workers = workers
-        }
-        workerData.serviceConfig.workers = workers
+        const { workers } = data
+        workerData.applicationConfig.workers = workers
         workerData.worker.count = workers
       },
 
       getStatus () {
-        return app.getStatus()
+        return controller.getStatus()
       },
 
-      getServiceInfo () {
-        return app.stackable.getInfo()
+      getApplicationInfo () {
+        return controller.capability.getInfo()
       },
 
-      async getServiceConfig () {
-        const current = await app.stackable.getConfig()
+      async getApplicationConfig () {
+        const current = await controller.capability.getConfig()
         // Remove all undefined keys from the config
         return JSON.parse(JSON.stringify(current))
       },
 
-      async getServiceEnv () {
+      async getApplicationEnv () {
         // Remove all undefined keys from the config
-        return JSON.parse(JSON.stringify({ ...process.env, ...(await app.stackable.getEnv()) }))
+        return JSON.parse(JSON.stringify({ ...process.env, ...(await controller.capability.getEnv()) }))
       },
 
-      async getServiceOpenAPISchema () {
+      async getApplicationOpenAPISchema () {
         try {
-          return await app.stackable.getOpenapiSchema()
+          return await controller.capability.getOpenapiSchema()
         } catch (err) {
-          throw new errors.FailedToRetrieveOpenAPISchemaError(service.id, err.message)
+          throw new FailedToRetrieveOpenAPISchemaError(application.id, err.message)
         }
       },
 
-      async getServiceGraphQLSchema () {
+      async getApplicationGraphQLSchema () {
         try {
-          return await app.stackable.getGraphqlSchema()
+          return await controller.capability.getGraphqlSchema()
         } catch (err) {
-          throw new errors.FailedToRetrieveGraphQLSchemaError(service.id, err.message)
+          throw new FailedToRetrieveGraphQLSchemaError(application.id, err.message)
         }
       },
 
-      async getServiceMeta () {
+      async getApplicationMeta () {
         try {
-          return await app.stackable.getMeta()
+          return await controller.capability.getMeta()
         } catch (err) {
-          throw new errors.FailedToRetrieveMetaError(service.id, err.message)
+          throw new FailedToRetrieveMetaError(application.id, err.message)
         }
       },
 
       async getMetrics (format) {
         try {
-          return await app.getMetrics({ format })
+          return await controller.getMetrics({ format })
         } catch (err) {
-          throw new errors.FailedToRetrieveMetricsError(service.id, err.message)
+          throw new FailedToRetrieveMetricsError(application.id, err.message)
         }
       },
 
       async getHealth () {
         try {
-          return await app.getHealth()
+          return await controller.getHealth()
         } catch (err) {
-          throw new errors.FailedToRetrieveHealthError(service.id, err.message)
+          throw new FailedToRetrieveHealthError(application.id, err.message)
         }
       },
 
       async getCustomHealthCheck () {
         try {
-          return await app.stackable.getCustomHealthCheck()
+          return await controller.capability.getCustomHealthCheck()
         } catch (err) {
-          throw new errors.FailedToPerformCustomHealthCheckError(service.id, err.message)
+          throw new FailedToPerformCustomHealthCheckError(application.id, err.message)
         }
       },
 
       async getCustomReadinessCheck () {
         try {
-          return await app.stackable.getCustomReadinessCheck()
+          return await controller.capability.getCustomReadinessCheck()
         } catch (err) {
-          throw new errors.FailedToPerformCustomReadinessCheckError(service.id, err.message)
+          throw new FailedToPerformCustomReadinessCheckError(application.id, err.message)
         }
       },
 
@@ -232,12 +240,10 @@ function setupITC (app, service, dispatcher, sharedContext) {
     }
   })
 
-  app.on('changed', () => {
+  controller.on('changed', () => {
     itc.notify('changed')
   })
 
   itc.listen()
   return itc
 }
-
-module.exports = { sendViaITC, setupITC, waitEventFromITC }

package/lib/worker/main.js

@@ -1,37 +1,33 @@
-'use strict'
-
-const { EventEmitter } = require('node:events')
-const { hostname } = require('node:os')
-const { resolve } = require('node:path')
-const { workerData, threadId } = require('node:worker_threads')
-const { pathToFileURL } = require('node:url')
-const inspector = require('node:inspector')
-const diagnosticChannel = require('node:diagnostics_channel')
-const { ServerResponse } = require('node:http')
-
-const {
+import {
+  buildPinoFormatters,
+  buildPinoTimestamp,
   disablePinoDirectWrite,
-  executeWithTimeout,
   ensureLoggableError,
-  getPrivateSymbol,
-  buildPinoFormatters,
-  buildPinoTimestamp
-} = require('@platformatic/foundation')
-const dotenv = require('dotenv')
-const pino = require('pino')
-const { fetch } = require('undici')
-
-const { PlatformaticApp } = require('./app')
-const { SharedContext } = require('./shared-context')
-const { setupITC } = require('./itc')
-const { setDispatcher } = require('./interceptors')
-const { kId, kITC, kStderrMarker } = require('./symbols')
+  executeWithTimeout,
+  getPrivateSymbol
+} from '@platformatic/foundation'
+import dotenv from 'dotenv'
+import { subscribe } from 'node:diagnostics_channel'
+import { EventEmitter } from 'node:events'
+import { ServerResponse } from 'node:http'
+import inspector from 'node:inspector'
+import { hostname } from 'node:os'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { threadId, workerData } from 'node:worker_threads'
+import pino from 'pino'
+import { fetch } from 'undici'
+import { Controller } from './controller.js'
+import { setDispatcher } from './interceptors.js'
+import { setupITC } from './itc.js'
+import { SharedContext } from './shared-context.js'
+import { kId, kITC, kStderrMarker } from './symbols.js'
 
 function handleUnhandled (app, type, err) {
   const label =
     workerData.worker.count > 1
-      ? `worker ${workerData.worker.index} of the service "${workerData.serviceConfig.id}"`
-      : `service "${workerData.serviceConfig.id}"`
+      ? `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
+      : `application "${workerData.applicationConfig.id}"`
 
   globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
 
@@ -72,7 +68,7 @@ function createLogger () {
 
   const pinoOptions = {
     level: 'trace',
-    name: workerData.serviceConfig.id,
+    name: workerData.applicationConfig.id,
     ...workerData.config.logger
   }
 
@@ -112,16 +108,16 @@ async function main () {
 
   const config = workerData.config
 
-  await performPreloading(config, workerData.serviceConfig)
+  await performPreloading(config, workerData.applicationConfig)
 
-  const service = workerData.serviceConfig
+  const application = workerData.applicationConfig
 
-  // Load env file and mixin env vars from service config
+  // Load env file and mixin env vars from application config
   let envfile
-  if (service.envfile) {
-    envfile = resolve(workerData.dirname, service.envfile)
+  if (application.envfile) {
+    envfile = resolve(workerData.dirname, application.envfile)
   } else {
-    envfile = resolve(workerData.serviceConfig.path, '.env')
+    envfile = resolve(workerData.applicationConfig.path, '.env')
   }
 
   globalThis.platformatic.logger.debug({ envfile }, 'Loading envfile...')
@@ -133,17 +129,17 @@ async function main () {
   if (config.env) {
     Object.assign(process.env, config.env)
   }
-  if (service.env) {
-    Object.assign(process.env, service.env)
+  if (application.env) {
+    Object.assign(process.env, application.env)
   }
 
   const { threadDispatcher } = await setDispatcher(config)
 
-  // If the service is an entrypoint and runtime server config is defined, use it.
+  // If the application is an entrypoint and runtime server config is defined, use it.
   let serverConfig = null
-  if (config.server && service.entrypoint) {
+  if (config.server && application.entrypoint) {
     serverConfig = config.server
-  } else if (service.useHttp) {
+  } else if (application.useHttp) {
     serverConfig = {
       port: 0,
       hostname: '127.0.0.1',
@@ -166,14 +162,14 @@ async function main () {
     const res = await fetch(url)
     const [{ devtoolsFrontendUrl }] = await res.json()
 
-    console.log(`For ${service.id} debugger open the following in chrome: "${devtoolsFrontendUrl}"`)
+    console.log(`For ${application.id} debugger open the following in chrome: "${devtoolsFrontendUrl}"`)
   }
 
   // Create the application
-  const app = new PlatformaticApp(
-    service,
+  const controller = new Controller(
+    application,
     workerData.worker.count > 1 ? workerData.worker.index : undefined,
-    service.telemetry,
+    application.telemetry,
     config.logger,
     serverConfig,
     config.metrics,
@@ -181,14 +177,14 @@ async function main () {
     !!config.watch
   )
 
-  process.on('uncaughtException', handleUnhandled.bind(null, app, 'uncaught exception'))
-  process.on('unhandledRejection', handleUnhandled.bind(null, app, 'unhandled rejection'))
+  process.on('uncaughtException', handleUnhandled.bind(null, controller, 'uncaught exception'))
+  process.on('unhandledRejection', handleUnhandled.bind(null, controller, 'unhandled rejection'))
 
-  await app.init()
+  await controller.init()
 
-  if (service.entrypoint && config.basePath) {
-    const meta = await app.stackable.getMeta()
-    if (!meta.composer.wantsAbsoluteUrls) {
+  if (application.entrypoint && config.basePath) {
+    const meta = await controller.capability.getMeta()
+    if (!meta.gateway.wantsAbsoluteUrls) {
       stripBasePath(config.basePath)
     }
   }
@@ -201,18 +197,16 @@ async function main () {
   }
 
   // Setup interaction with parent port
-  const itc = setupITC(app, service, threadDispatcher, sharedContext)
+  const itc = setupITC(controller, application, threadDispatcher, sharedContext)
   globalThis[kITC] = itc
 
-  // Get the dependencies
-  const dependencies = await app.getBootstrapDependencies()
-  itc.notify('init', { dependencies })
+  itc.notify('init')
 }
 
 function stripBasePath (basePath) {
   const kBasePath = Symbol('kBasePath')
 
-  diagnosticChannel.subscribe('http.server.request.start', ({ request, response }) => {
+  subscribe('http.server.request.start', ({ request, response }) => {
     if (request.url.startsWith(basePath)) {
       request.url = request.url.slice(basePath.length)
 

package/lib/worker/messaging.js

@@ -1,14 +1,12 @@
-'use strict'
-
-const { executeWithTimeout, kTimeout } = require('@platformatic/foundation')
-const { ITC, generateResponse, sanitize } = require('@platformatic/itc')
-const errors = require('../errors')
-const { RoundRobinMap } = require('./round-robin-map')
-const { kWorkersBroadcast, kITC } = require('./symbols')
+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')
 
-class MessagingITC extends ITC {
+export class MessagingITC extends ITC {
   #timeout
   #listener
   #closeResolvers
@@ -26,7 +24,7 @@ class MessagingITC extends ITC {
     this.#workers = new RoundRobinMap()
     this.#sources = new Set()
 
-    // Start listening on the BroadcastChannel for the list of services
+    // Start listening on the BroadcastChannel for the list of applications
     this.#broadcastChannel = new BroadcastChannel(kWorkersBroadcast)
     this.#broadcastChannel.onmessage = this.#updateWorkers.bind(this)
 
@@ -47,25 +45,25 @@ class MessagingITC extends ITC {
     }
   }
 
-  async send (service, name, message, options) {
-    // Get the next worker for the service
-    const worker = this.#workers.next(service)
+  async send (application, name, message, options) {
+    // Get the next worker for the application
+    const worker = this.#workers.next(application)
 
     if (!worker) {
-      throw new errors.MessagingError(service, 'No workers available')
+      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', { service: worker.service, worker: worker.worker }),
+        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 errors.MessagingError(service, 'Timeout while waiting for a communication channel.')
+        throw new MessagingError(application, 'Timeout while waiting for a communication channel.')
       }
 
       worker.channel = channel
@@ -77,13 +75,13 @@ class MessagingITC extends ITC {
 
     const context = { ...options }
     context.channel = worker.channel
-    context.service = worker.service
+    context.application = worker.application
     context.trackResponse = true
 
     const response = await executeWithTimeout(super.send(name, message, context), this.#timeout)
 
     if (response === kTimeout) {
-      throw new errors.MessagingError(service, 'Timeout while waiting for a response.')
+      throw new MessagingError(application, 'Timeout while waiting for a response.')
     }
 
     return response
@@ -104,8 +102,8 @@ class MessagingITC extends ITC {
     const { channel, transferList } = context
 
     if (context.trackResponse) {
-      const service = context.service
-      channel[kPendingResponses].set(request.reqId, { service, request })
+      const application = context.application
+      channel[kPendingResponses].set(request.reqId, { application, request })
     }
 
     channel.postMessage(sanitize(request, transferList), { transferList })
@@ -150,18 +148,18 @@ class MessagingITC extends ITC {
     this.#workers = new RoundRobinMap()
 
     const instances = []
-    for (const [service, workers] of event.data) {
+    for (const [application, workers] of event.data) {
       const count = workers.length
       const next = Math.floor(Math.random() * count)
 
-      instances.push({ id: service, next, workers: 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 service
-        this.#workers.set(`${service}:${i}`, { ...worker, channel })
+        // 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 })
       }
     }
 
@@ -169,11 +167,11 @@ class MessagingITC extends ITC {
   }
 
   #handlePendingResponse (channel) {
-    for (const { service, request } of channel[kPendingResponses].values()) {
+    for (const { application, request } of channel[kPendingResponses].values()) {
       this._emitResponse(
         generateResponse(
           request,
-          new errors.MessagingError(service, 'The communication channel was closed before receiving a response.'),
+          new MessagingError(application, 'The communication channel was closed before receiving a response.'),
           null
         )
       )
@@ -182,5 +180,3 @@ class MessagingITC extends ITC {
     channel[kPendingResponses].clear()
   }
 }
-
-module.exports = { MessagingITC }