@platformatic/runtime 3.71.1-alpha.0 → 4.0.0-alpha.1

package/lib/worker/interceptors.js

@@ -6,14 +6,14 @@ import {
   getOnHttpCacheMiss,
   getOnHttpCacheRequest
 } from '@platformatic/globals'
-import { createTelemetryThreadInterceptorHooks } from '@platformatic/telemetry'
+import { createTelemetryThreadInterceptorHooks } from '@platformatic/tracing'
 import { createRequire } from 'node:module'
 import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { parentPort, workerData } from 'node:worker_threads'
-import { Agent, Client, Pool } from 'undici'
-import { wire } from 'undici-thread-interceptor'
-import { createChannelCreationHook } from '../policies.js'
+import { workerData } from 'node:worker_threads'
+import { Agent, Client, Pool, setGlobalDispatcher } from 'undici'
+import { createInterceptor } from 'undici-thread-interceptor'
+import { createTargetPermissionHook } from '../policies.js'
 import { RemoteCacheStore, httpCacheInterceptor } from './http-cache.js'
 
 const kPlatformaticGlobalDispatcher = Symbol.for('platformatic.undici.globalDispatcher')
@@ -43,8 +43,11 @@ export function refreshGlobalDispatcher () {
 }
 
 export async function setDispatcher (runtimeConfig) {
-  const threadDispatcher = createThreadInterceptor(runtimeConfig)
-  const threadInterceptor = threadDispatcher.interceptor
+  const tracingHooks = runtimeConfig.tracing ? createTelemetryThreadInterceptorHooks() : {}
+  const threadDispatcher = createThreadInterceptor(runtimeConfig, tracingHooks)
+  const threadInterceptor = threadDispatcher
+
+  await threadDispatcher.ready
 
   let cacheInterceptor = null
   if (runtimeConfig.httpCache) {
@@ -65,30 +68,29 @@ export async function setDispatcher (runtimeConfig) {
       [threadInterceptor, ...userInterceptors, cacheInterceptor].filter(Boolean)
     )
 
-    markAsPlatformaticDispatcher(dispatcher)
-    mirrorGlobalDispatcherForBuiltinFetch(dispatcher, createLegacyDispatcher(dispatcher))
+    installGlobalDispatcher(dispatcher)
     return dispatcher
   }
 
   composeRuntimeDispatcher = installDispatcher
   installDispatcher(new Agent(dispatcherOpts))
 
-  return { threadDispatcher }
-}
-
-function createLegacyDispatcher (dispatcher) {
-  const legacyDispatcher = globalThis[Symbol.for('undici.globalDispatcher.1')]
-  const currentDispatcher = globalThis[Symbol.for('undici.globalDispatcher.2')]
-
-  if (legacyDispatcher && legacyDispatcher !== currentDispatcher && legacyDispatcher.constructor?.name === 'Dispatcher1Wrapper') {
-    try {
-      return new legacyDispatcher.constructor(dispatcher)
-    } catch {
-      return dispatcher
+  return {
+    threadDispatcher: {
+      interceptor: threadDispatcher,
+      server: null,
+      serverHooks: tracingHooks.serverHooks
     }
   }
+}
 
-  return dispatcher
+export function installGlobalDispatcher (dispatcher) {
+  markAsPlatformaticDispatcher(dispatcher)
+  setGlobalDispatcher(dispatcher)
+  mirrorGlobalDispatcherForBuiltinFetch(
+    dispatcher,
+    globalThis[Symbol.for('undici.globalDispatcher.1')]
+  )
 }
 
 export async function updateUndiciInterceptors (undiciConfig) {
@@ -215,19 +217,17 @@ async function getDispatcherOpts (undiciConfig) {
   return dispatcherOpts
 }
 
-function createThreadInterceptor (runtimeConfig) {
-  const telemetry = runtimeConfig.telemetry
-
-  const telemetryHooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
-
-  const threadDispatcher = wire({
-    // Specifying the domain is critical to avoid flooding the DNS
-    // with requests for a domain that's never going to exist.
+function createThreadInterceptor (runtimeConfig, tracingHooks) {
+  const threadDispatcher = createInterceptor({
+    meshId: workerData.meshId,
     domain: '.plt.local',
-    port: parentPort,
-    timeout: runtimeConfig.applicationTimeout,
-    onChannelCreation: createChannelCreationHook(runtimeConfig),
-    ...telemetryHooks
+    connectTimeout: runtimeConfig.applicationTimeout,
+    bootstrapTimeout: runtimeConfig.applicationTimeout,
+    allowTarget: createTargetPermissionHook({
+      ...runtimeConfig,
+      applicationId: workerData.applicationConfig.id
+    }),
+    ...tracingHooks
   })
   return threadDispatcher
 }

package/lib/worker/itc.js

@@ -1,13 +1,22 @@
-import { ensureLoggableError, executeInParallel, executeWithTimeout, kTimeout } from '@platformatic/foundation'
-import { getEvents, getLogger, getMessaging, updateGlobals } from '@platformatic/globals'
+import { servingState } from '@platformatic/basic'
+import {
+  ensureError,
+  ensureLoggableError,
+  executeInParallel,
+  executeWithTimeout,
+  kTimeout
+} from '@platformatic/foundation'
+import { consumeCloseCallbacks, getEvents, getLogger, getMessaging, updateGlobals } from '@platformatic/globals'
 import { ITC, initializeITCTelemetry } from '@platformatic/itc'
 import { Unpromise } from '@watchable/unpromise'
 import { once } from 'node:events'
 import { createRequire } from 'node:module'
 import { Duplex } from 'node:stream'
 import { parentPort, workerData } from 'node:worker_threads'
+import { createServer } from 'undici-thread-interceptor'
 import {
   ApplicationExitedError,
+  ApplicationShutdownError,
   FailedToPerformCustomHealthCheckError,
   FailedToPerformCustomReadinessCheckError,
   FailedToRetrieveGraphQLSchemaError,
@@ -15,12 +24,13 @@ import {
   FailedToRetrieveMetaError,
   FailedToRetrieveMetricsError,
   FailedToRetrieveOpenAPISchemaError,
+  RuntimeAbortedError,
   WorkerExitedError,
   exitCodes
 } from '../errors.js'
 import { updateUndiciInterceptors } from './interceptors.js'
 import { MessagingITC } from './messaging.js'
-import { kApplicationId, kITC, kId, kWorkerId } from './symbols.js'
+import { kApplicationId, kITC, kId, kWorkerExitCode, kWorkerId } from './symbols.js'
 
 function startSubprocessRepl (port, childManager, clientWs, controller) {
   // Start the REPL in the child process
@@ -78,14 +88,18 @@ async function safeHandleInITC (worker, fn) {
   try {
     // Make sure to catch when the worker exits, otherwise we're stuck forever
     const ac = new AbortController()
-    let exitCode
-
-    const response = await Unpromise.race([
-      fn(),
-      once(worker, 'exit', { signal: ac.signal }).then(([code]) => {
-        exitCode = code
-      })
-    ])
+    // A worker which already exited will not emit the exit event again
+    let exitCode = worker[kWorkerExitCode]
+    let response
+
+    if (typeof exitCode !== 'number') {
+      response = await Unpromise.race([
+        fn(),
+        once(worker, 'exit', { signal: ac.signal }).then(([code]) => {
+          exitCode = code
+        })
+      ])
+    }
 
     if (typeof exitCode === 'number') {
       if (typeof worker[kWorkerId] !== 'undefined' && exitCode !== exitCodes.PROCESS_UNHANDLED_ERROR) {
@@ -103,22 +117,142 @@ async function safeHandleInITC (worker, fn) {
       throw error
     }
 
-    if (error.handlerErrorCode && !error.handlerError.code) {
-      error.handlerError.code = error.handlerErrorCode
+    const handlerError = ensureError(error.handlerError)
+    if (error.handlerErrorCode && !handlerError.code) {
+      handlerError.code = error.handlerErrorCode
     }
 
-    throw error.handlerError
+    throw handlerError
   }
 }
 
-async function closeITC (dispatcher, itc, messaging) {
+async function closeResource (close, errors) {
   try {
-    await dispatcher.interceptor.close()
-    itc.close()
-    messaging.close()
+    await close()
+  } catch (error) {
+    errors.push(error)
+  }
+}
+
+async function stopApplication (context, force, dependents, shutdownTimeout) {
+  const { controller, dispatcher, itc, messaging } = context
+  const errors = []
+  let controllerError
+
+  if (force || controller.getStatus().startsWith('start')) {
+    try {
+      getEvents().emit('stop')
+    } catch (error) {
+      errors.push(error)
+    }
+
+    try {
+      await controller.stop(force, dependents, shutdownTimeout)
+    } catch (error) {
+      controllerError = error
+      errors.push(error)
+    }
+  }
+
+  errors.push(...(await runShutdownCallbacks()))
+  // Keep communication usable while signal handlers drain. Only idle channels
+  // are unreferenced; pending mesh and messaging operations keep the worker alive.
+  const drained = once(process, 'beforeExit')
+  dispatcher.interceptor.unref()
+  dispatcher.server?.unref()
+  messaging.unref()
+  itc.port.unref()
+  await drained
+  itc.port.ref()
+  await closeResource(() => closeApplicationChannels(dispatcher, messaging), errors)
+
+  if (errors.length > 0) {
+    if (errors.length === 1 && errors[0] === controllerError && controllerError?.code) {
+      throw controllerError
+    }
+    throw new ApplicationShutdownError(errors)
+  }
+}
+
+async function stopController (context, force, dependents, shutdownTimeout, stopProcessed) {
+  try {
+    if (context.controller.getStatus() === 'starting') {
+      // The start handler reports its own error and shares cleanup with us.
+      await context.controllerStartPromise.catch(() => {})
+    }
+    if (!context.applicationStopPromise) {
+      const { promise, resolve, reject } = Promise.withResolvers()
+      context.applicationStopPromise = promise
+      stopApplication(context, force, dependents, shutdownTimeout).then(resolve, reject)
+    }
+    await context.applicationStopPromise
   } finally {
+    // The acknowledgement only gates transport closure. Application work has already
+    // drained before the response, including work scheduled by SIGINT after failed startup.
+    stopProcessed.then(() => {
+      context.internalClosePromise ??= closeITC(context.itc)
+      context.internalClosePromise.catch(err => {
+        context.logger.error({ err: ensureLoggableError(err) }, 'Failed to close the worker ITC after stop.')
+      })
+    })
+  }
+}
+
+async function runShutdownCallbacks () {
+  const errors = []
+  const callbacks = consumeCloseCallbacks().reverse()
+
+  for (const callback of callbacks) {
+    try {
+      await callback()
+    } catch (error) {
+      errors.push(error)
+    }
+  }
+
+  const signalListeners = process.listeners('SIGINT')
+  for (const listener of signalListeners) {
+    process.removeListener('SIGINT', listener)
+  }
+
+  for (const listener of signalListeners) {
+    try {
+      // Like a signal emission, ignore return values without consuming rejected promises.
+      listener.call(process, 'SIGINT')
+    } catch (error) {
+      errors.push(error)
+    }
+  }
+
+  return errors
+}
+
+export async function closeApplicationChannels (dispatcher, messaging) {
+  const errors = []
+
+  await closeResource(() => dispatcher.interceptor.close(), errors)
+  await closeResource(() => dispatcher.server?.close(), errors)
+  await closeResource(() => messaging.close(), errors)
+
+  if (errors.length > 0) {
+    throw new ApplicationShutdownError(errors)
+  }
+}
+
+export async function closeITC (itc) {
+  const errors = []
+  // ITC closes the transport after all active handlers have sent their responses.
+  await closeResource(() => itc.close(), errors)
+
+  try {
     const events = getEvents()
     events.emit('exit')
+  } catch (error) {
+    errors.push(error)
+  }
+
+  if (errors.length > 0) {
+    throw new ApplicationShutdownError(errors)
   }
 }
 
@@ -169,7 +303,18 @@ export async function setupITC (controller, application, dispatcher, sharedConte
 
   // ITC handlers run concurrently, so later start/stop requests must wait for
   // the actual in-flight start operation rather than a controller event.
-  let controllerStartPromise
+  const context = {
+    controller,
+    dispatcher,
+    itc: null,
+    messaging,
+    logger,
+    controllerStartPromise: null,
+    controllerStopPromise: null,
+    abortStart: false,
+    applicationStopPromise: null,
+    internalClosePromise: null
+  }
 
   const itc = new ITC({
     name: controller.applicationConfig.id + '-worker',
@@ -179,37 +324,58 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         const status = controller.getStatus()
 
         if (status === 'starting') {
-          await controllerStartPromise
+          await context.controllerStartPromise
         } else {
           // This gives a chance to a capability to perform custom logic
           const events = getEvents()
           events.emit('start')
 
           try {
-            controllerStartPromise = controller.start()
-            await controllerStartPromise
+            context.controllerStartPromise = controller.start()
+            await context.controllerStartPromise
+            if (context.abortStart) {
+              throw new RuntimeAbortedError()
+            }
           } catch (e) {
-            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(err => {
-                logger.error(
-                  { err: ensureLoggableError(err) },
-                  'Failed to close the worker ITC after a failed start.'
-                )
-              })
-            })
-
-            throw ensureLoggableError(e)
+            const startProcessed = once(itc, 'application:worker:start:processed')
+            try {
+              await stopController(context, true, [], undefined, startProcessed)
+            } catch (error) {
+              logger.error(
+                { err: ensureLoggableError(error) },
+                'Errors occurred while cleaning up a failed application start.'
+              )
+            }
+
+            // Errors are structured cloned when sent to the runtime, which drops all their custom properties (like the
+            // port and the address of listen errors): send a plain object instead so that the runtime can inspect them.
+            // eslint-disable-next-line no-throw-literal
+            throw { name: e.name, ...ensureLoggableError(e) }
           }
         }
 
-        if (application.entrypoint) {
-          await controller.listen()
+        const dispatchTarget = await controller.capability.getDispatchTarget()
+        if (dispatchTarget == null) {
+          await new Promise(() => {})
         }
 
-        dispatcher.replaceServer(await controller.capability.getDispatchTarget())
+        const serverTarget = dispatcher.serverHooks?.run
+          ? wrapDispatchTarget(dispatchTarget, dispatcher.serverHooks.run)
+          : dispatchTarget
+
+        dispatcher.server = createServer({
+          meshId: workerData.meshId,
+          serverId: workerData.worker.id,
+          domain: `${application.id}.plt.local`,
+          server: serverTarget,
+          bootstrapTimeout: workerData.config.applicationTimeout,
+          metadata: {
+            applicationId: application.id,
+            workerId: workerData.worker.id
+          },
+          ...dispatcher.serverHooks
+        })
+        await dispatcher.server.ready
 
         const scheduledTasks =
           typeof controller.capability.getScheduledTasks === 'function'
@@ -217,38 +383,28 @@ export async function setupITC (controller, application, dispatcher, sharedConte
             : []
 
         return {
-          url: application.entrypoint ? controller.capability.getUrl() : null,
+          url: controller.getUrl(),
           scheduledTasks
         }
       },
 
-      async stop ({ force, dependents }) {
-        try {
-          const status = controller.getStatus()
+      async stop ({ force, dependents, shutdownTimeout }) {
+        if (context.controllerStopPromise) {
+          return context.controllerStopPromise
+        }
+        context.abortStart = !!force
 
-          if (!force && status === 'starting') {
-            await controllerStartPromise
-          }
+        const stopProcessed = once(itc, 'application:worker:stop:processed')
 
-          if (force || status.startsWith('start')) {
-            // This gives a chance to a capability to perform custom logic
-            const events = getEvents()
-            events.emit('stop')
+        context.controllerStopPromise = stopController(
+          context,
+          force,
+          dependents,
+          shutdownTimeout,
+          stopProcessed
+        )
 
-            await controller.stop(force, dependents)
-          }
-        } finally {
-          // Always schedule cleanup, even when stop throws. Otherwise the worker
-          // keeps open handles and runtime shutdown hangs until the grace timeout.
-          once(itc, 'application:worker:stop:processed').then(() => {
-            closeITC(dispatcher, itc, messaging).catch(err => {
-              logger.error(
-                { err: ensureLoggableError(err) },
-                'Failed to close the worker ITC after stop.'
-              )
-            })
-          })
-        }
+        return context.controllerStopPromise
       },
 
       async getDependencies () {
@@ -260,7 +416,8 @@ export async function setupITC (controller, application, dispatcher, sharedConte
       },
 
       async removeFromMesh () {
-        return dispatcher.interceptor.close()
+        await dispatcher.server?.close()
+        dispatcher.server = null
       },
 
       inject (injectParams) {
@@ -292,6 +449,12 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         return controller.capability.getInfo()
       },
 
+      // How this worker serves, which only the worker can answer: for a worker-classified
+      // capability it depends on what the application's factory returned in this worker.
+      getServingState () {
+        return controller.capability?.getServingState?.() ?? servingState.inactive
+      },
+
       async getApplicationConfig () {
         const current = await controller.capability.getConfig()
         // Remove all undefined keys from the config
@@ -401,11 +564,11 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         const session = new Session()
         session.connect()
 
-        session.on('HeapProfiler.addHeapSnapshotChunk', (m) => {
+        session.on('HeapProfiler.addHeapSnapshotChunk', m => {
           port.postMessage({ type: 'chunk', chunk: m.params.chunk })
         })
 
-        session.post('HeapProfiler.takeHeapSnapshot', null, (err) => {
+        session.post('HeapProfiler.takeHeapSnapshot', null, err => {
           session.disconnect()
           if (err) {
             port.postMessage({ type: 'error', message: err.message })
@@ -496,6 +659,25 @@ export async function setupITC (controller, application, dispatcher, sharedConte
     itc.notify('changed')
   })
 
+  context.itc = itc
+
   itc.listen()
   return itc
 }
+
+function wrapDispatchTarget (target, run) {
+  if (typeof target.inject === 'function') {
+    return {
+      inject: (req, callback) => run(req, () => target.inject(req, callback)),
+      server: target.server,
+      emit: target.emit?.bind(target),
+      listenerCount: target.listenerCount?.bind(target)
+    }
+  }
+
+  if (typeof target.emit === 'function') {
+    return target
+  }
+
+  return target
+}