@platformatic/runtime 0.26.1 → 0.28.1

package/lib/worker.js

@@ -1,8 +1,11 @@
 'use strict'
+
 const { parentPort, workerData } = require('node:worker_threads')
 const FastifyUndiciDispatcher = require('fastify-undici-dispatcher')
 const { Agent, setGlobalDispatcher } = require('undici')
 const { PlatformaticApp } = require('./app')
+const { RuntimeApi } = require('./api')
+
 const loaderPort = globalThis.LOADER_PORT // Added by loader.mjs.
 const globalAgent = new Agent()
 const globalDispatcher = new FastifyUndiciDispatcher({
@@ -10,41 +13,36 @@ const globalDispatcher = new FastifyUndiciDispatcher({
   // setting the domain here allows for fail-fast scenarios
   domain: '.plt.local'
 })
+const pino = require('pino')
+const { isatty } = require('tty')
+
 const applications = new Map()
-let entrypoint
 
 delete globalThis.LOADER_PORT
 setGlobalDispatcher(globalDispatcher)
 
-parentPort.on('message', async (msg) => {
-  for (const app of applications.values()) {
-    await app.handleProcessLevelEvent(msg)
+let transport
 
-    if (msg?.msg === 'plt:start' || msg?.msg === 'plt:restart') {
-      const serviceUrl = new URL(app.appConfig.localUrl)
+/* c8 ignore next 5 */
+if (isatty(1)) {
+  transport = pino.transport({
+    target: 'pino-pretty'
+  })
+}
 
-      globalDispatcher.route(serviceUrl.host, app.server)
-    }
-  }
+const logger = pino(transport)
 
-  switch (msg?.msg) {
-    case 'plt:start':
-      configureDispatcher()
-      parentPort.postMessage({ msg: 'plt:started', url: entrypoint.server.url })
-      break
-    case 'plt:restart':
-      configureDispatcher()
-      parentPort.postMessage({ msg: 'plt:restarted', url: entrypoint.server.url })
-      break
-    case 'plt:stop':
-      process.exit() // Exit the worker thread.
-      break
-    case undefined:
-      // Ignore
-      break
-    default:
-      throw new Error(`unknown message type: '${msg.msg}'`)
-  }
+/* c8 ignore next 4 */
+process.once('uncaughtException', (err) => {
+  logger.error({ err }, 'runtime error')
+  throw err
+})
+
+// Tested by test/cli/start.test.mjs by C8 does not see it.
+/* c8 ignore next 4 */
+process.once('unhandledRejection', (err) => {
+  logger.error({ err }, 'runtime error')
+  throw err
 })
 
 async function main () {
@@ -52,37 +50,15 @@ async function main () {
 
   for (let i = 0; i < services.length; ++i) {
     const service = services[i]
-    const app = new PlatformaticApp(service, loaderPort)
+    const app = new PlatformaticApp(service, loaderPort, logger)
 
     applications.set(service.id, app)
-
-    if (service.entrypoint) {
-      entrypoint = app
-    }
   }
 
-  parentPort.postMessage('plt:init')
-}
-
-function configureDispatcher () {
-  const { services } = workerData.config
-
-  // Setup the local services in the global dispatcher.
-  for (let i = 0; i < services.length; ++i) {
-    const service = services[i]
-    const serviceApp = applications.get(service.id)
-    const serviceUrl = new URL(service.localUrl)
-
-    globalDispatcher.route(serviceUrl.host, serviceApp.server)
-
-    for (let j = 0; j < service.dependencies.length; ++j) {
-      const depConfig = service.dependencies[j]
-      const depApp = applications.get(depConfig.id)
-      const depUrl = new URL(depConfig.url)
+  const runtime = new RuntimeApi(applications, globalDispatcher)
+  runtime.startListening(parentPort)
 
-      globalDispatcher.route(depUrl.host, depApp.server)
-    }
-  }
+  parentPort.postMessage('plt:init')
 }
 
 main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "0.26.1",
+  "version": "0.28.1",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -17,12 +17,12 @@
   },
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
-    "c8": "^7.13.0",
-    "execa": "^7.0.0",
+    "c8": "^8.0.0",
+    "execa": "^7.1.1",
     "snazzy": "^9.0.0",
-    "split2": "^4.1.0",
-    "standard": "^17.0.0",
-    "tsd": "^0.28.0"
+    "split2": "^4.2.0",
+    "standard": "^17.1.0",
+    "tsd": "^0.28.1"
   },
   "dependencies": {
     "@hapi/topo": "^6.0.2",
@@ -30,15 +30,18 @@
     "commist": "^3.2.0",
     "desm": "^1.3.0",
     "es-main": "^1.2.0",
-    "fastify": "^4.17.0",
-    "fastify-undici-dispatcher": "^0.4.0",
+    "fastify": "^4.18.0",
+    "fastify-undici-dispatcher": "^0.4.1",
     "help-me": "^4.2.0",
     "minimist": "^1.2.8",
-    "undici": "^5.20.0",
-    "@platformatic/config": "0.26.1",
-    "@platformatic/service": "0.26.1",
-    "@platformatic/start": "0.26.1",
-    "@platformatic/utils": "0.26.1"
+    "pino": "^8.14.1",
+    "pino-pretty": "^10.0.0",
+    "undici": "^5.22.1",
+    "@platformatic/composer": "0.28.1",
+    "@platformatic/config": "0.28.1",
+    "@platformatic/db": "0.28.1",
+    "@platformatic/service": "0.28.1",
+    "@platformatic/utils": "0.28.1"
   },
   "standard": {
     "ignore": [

package/test/api.test.js

@@ -0,0 +1,294 @@
+'use strict'
+
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { test } = require('node:test')
+
+const { loadConfig } = require('@platformatic/service')
+const { buildServer, platformaticRuntime } = require('..')
+const fixturesDir = join(__dirname, '..', 'fixtures')
+
+// Each test runtime app adds own process listeners
+process.setMaxListeners(100)
+
+test('should get service details', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const serviceDetails = await app.getServiceDetails('with-logger')
+  assert.deepStrictEqual(serviceDetails, {
+    id: 'with-logger',
+    status: 'started',
+    entrypoint: false,
+    localUrl: 'http://with-logger.plt.local',
+    dependencies: []
+  })
+})
+
+test('should get service config', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const serviceConfig = await app.getServiceConfig('with-logger')
+
+  // TODO: should return correct logger config
+  assert.deepStrictEqual(serviceConfig, {
+    $schema: 'https://platformatic.dev/schemas/v0.27.0/service',
+    server: {
+      hostname: '127.0.0.1',
+      port: 0,
+      logger: {},
+      keepAliveTimeout: 5000
+    },
+    service: { openapi: true },
+    plugins: {
+      paths: [
+        join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'plugin.js')
+      ]
+    },
+    watch: false
+  })
+})
+
+test('should fail to get service config if service is not started', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.getServiceConfig('with-logger')
+    assert.fail('should have thrown')
+  } catch (err) {
+    assert.strictEqual(err.message, 'Service with id \'with-logger\' is not started')
+  }
+})
+
+test('should get services topology', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const topology = await app.getServices()
+
+  assert.deepStrictEqual(topology, {
+    entrypoint: 'serviceApp',
+    services: [
+      {
+        id: 'serviceApp',
+        status: 'started',
+        entrypoint: true,
+        localUrl: 'http://serviceApp.plt.local',
+        dependencies: [
+          {
+            id: 'with-logger',
+            url: 'http://with-logger.plt.local',
+            local: true
+          }
+        ]
+      },
+      {
+        id: 'with-logger',
+        status: 'started',
+        entrypoint: false,
+        localUrl: 'http://with-logger.plt.local',
+        dependencies: []
+      },
+      {
+        id: 'multi-plugin-service',
+        status: 'started',
+        entrypoint: false,
+        localUrl: 'http://multi-plugin-service.plt.local',
+        dependencies: []
+      }
+    ]
+  })
+})
+
+test('should stop service by service id', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  {
+    const serviceDetails = await app.getServiceDetails('with-logger')
+    assert.strictEqual(serviceDetails.status, 'started')
+  }
+
+  await app.stopService('with-logger')
+
+  {
+    const serviceDetails = await app.getServiceDetails('with-logger')
+    assert.strictEqual(serviceDetails.status, 'stopped')
+  }
+})
+
+test('should fail to stop service with a wrong id', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.stopService('wrong-service-id')
+    assert.fail('should have thrown')
+  } catch (err) {
+    assert.strictEqual(err.message, 'Service with id \'wrong-service-id\' not found')
+  }
+})
+
+test('should start stopped service by service id', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  await app.stopService('with-logger')
+
+  {
+    const serviceDetails = await app.getServiceDetails('with-logger')
+    assert.strictEqual(serviceDetails.status, 'stopped')
+  }
+
+  await app.startService('with-logger')
+
+  {
+    const serviceDetails = await app.getServiceDetails('with-logger')
+    assert.strictEqual(serviceDetails.status, 'started')
+  }
+})
+
+test('should fail to start service with a wrong id', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.startService('wrong-service-id')
+    assert.fail('should have thrown')
+  } catch (err) {
+    assert.strictEqual(err.message, 'Service with id \'wrong-service-id\' not found')
+  }
+})
+
+test('should fail to start running service', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.startService('with-logger')
+    assert.fail('should have thrown')
+  } catch (err) {
+    assert.strictEqual(err.message, 'application is already started')
+  }
+})
+
+test('should inject request to service', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const res = await app.inject('with-logger', {
+    method: 'GET',
+    url: '/'
+  })
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.strictEqual(res.statusMessage, 'OK')
+
+  assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+  assert.strictEqual(res.headers['content-length'], '17')
+  assert.strictEqual(res.headers.connection, 'keep-alive')
+
+  assert.strictEqual(res.body, '{"hello":"world"}')
+  assert.strictEqual(res.payload, '{"hello":"world"}')
+})
+
+test('should fail inject request is service is not started', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  try {
+    await app.inject('with-logger', { method: 'GET', url: '/' })
+  } catch (err) {
+    assert.strictEqual(err.message, 'Service with id \'with-logger\' is not started')
+  }
+})
+
+test('should handle a lot of runtime api requests', async (t) => {
+  const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+  const config = await loadConfig({}, ['-c', configFile], platformaticRuntime)
+  const app = await buildServer(config.configManager.current)
+
+  await app.start()
+
+  t.after(async () => {
+    await app.close()
+  })
+
+  const promises = []
+  for (let i = 0; i < 100; i++) {
+    promises.push(app.getServiceDetails('with-logger'))
+  }
+
+  await Promise.all(promises)
+})

package/test/app.test.js

@@ -3,10 +3,20 @@
 const assert = require('node:assert')
 const { join } = require('node:path')
 const { test } = require('node:test')
+const { utimes } = require('node:fs/promises')
 const { PlatformaticApp } = require('../lib/app')
 const fixturesDir = join(__dirname, '..', 'fixtures')
+const pino = require('pino')
+const split = require('split2')
+
+function getLoggerAndStream () {
+  const stream = split(JSON.parse)
+  const logger = pino(stream)
+  return { logger, stream }
+}
 
 test('logs errors during startup', async (t) => {
+  const { logger, stream } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'serviceAppThrowsOnStart')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -16,9 +26,8 @@ test('logs errors during startup', async (t) => {
     entrypoint: true,
     hotReload: true
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
-  t.mock.method(console, 'error', () => {})
   t.mock.method(process, 'exit', () => { throw new Error('exited') })
 
   await assert.rejects(async () => {
@@ -26,11 +35,18 @@ test('logs errors during startup', async (t) => {
   }, /exited/)
   assert.strictEqual(process.exit.mock.calls.length, 1)
   assert.strictEqual(process.exit.mock.calls[0].arguments[0], 1)
-  assert.strictEqual(console.error.mock.calls.length, 1)
-  assert.strictEqual(console.error.mock.calls[0].arguments[0].message, 'boom')
+
+  stream.end()
+  const lines = []
+  for await (const line of stream) {
+    lines.push(line)
+  }
+  const lastLine = lines[lines.length - 1]
+  assert.strictEqual(lastLine.msg, 'boom')
 })
 
 test('errors when starting an already started application', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -43,7 +59,7 @@ test('errors when starting an already started application', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(app.stop.bind(app))
   await app.start()
@@ -53,6 +69,7 @@ test('errors when starting an already started application', async (t) => {
 })
 
 test('errors when stopping an already stopped application', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -65,7 +82,7 @@ test('errors when stopping an already stopped application', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   await assert.rejects(async () => {
     await app.stop()
@@ -73,6 +90,7 @@ test('errors when stopping an already stopped application', async (t) => {
 })
 
 test('does not restart while restarting', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -85,7 +103,7 @@ test('does not restart while restarting', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(app.stop.bind(app))
   await app.start()
@@ -101,6 +119,7 @@ test('does not restart while restarting', async (t) => {
 })
 
 test('restarts on SIGUSR2', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -113,7 +132,7 @@ test('restarts on SIGUSR2', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(app.stop.bind(app))
   await app.start()
@@ -123,6 +142,7 @@ test('restarts on SIGUSR2', async (t) => {
 })
 
 test('stops on signals other than SIGUSR2', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -135,7 +155,7 @@ test('stops on signals other than SIGUSR2', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(async () => {
     try {
@@ -151,6 +171,7 @@ test('stops on signals other than SIGUSR2', async (t) => {
 })
 
 test('stops on uncaught exceptions', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -163,7 +184,7 @@ test('stops on uncaught exceptions', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(async () => {
     try {
@@ -193,8 +214,9 @@ test('supports configuration overrides', async (t) => {
   }
 
   await t.test('throws on non-string config paths', async (t) => {
+    const { logger } = getLoggerAndStream()
     config._configOverrides = new Map([[null, 5]])
-    const app = new PlatformaticApp(config, null)
+    const app = new PlatformaticApp(config, null, logger)
 
     t.after(async () => {
       try {
@@ -210,8 +232,9 @@ test('supports configuration overrides', async (t) => {
   })
 
   await t.test('ignores invalid config paths', async (t) => {
+    const { logger } = getLoggerAndStream()
     config._configOverrides = new Map([['foo.bar.baz', 5]])
-    const app = new PlatformaticApp(config, null)
+    const app = new PlatformaticApp(config, null, logger)
 
     t.after(async () => {
       try {
@@ -225,11 +248,12 @@ test('supports configuration overrides', async (t) => {
   })
 
   await t.test('sets valid config paths', async (t) => {
+    const { logger } = getLoggerAndStream()
     config._configOverrides = new Map([
       ['server.keepAliveTimeout', 1],
       ['server.port', 0]
     ])
-    const app = new PlatformaticApp(config, null)
+    const app = new PlatformaticApp(config, null, logger)
 
     t.after(async () => {
       try {
@@ -243,3 +267,42 @@ test('supports configuration overrides', async (t) => {
     assert.strictEqual(app.config.configManager.current.server.keepAliveTimeout, 1)
   })
 })
+
+test('restarts on config change without overriding the configManager', { only: true }, async (t) => {
+  const { logger, stream } = getLoggerAndStream()
+  const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
+  const configFile = join(appPath, 'platformatic.service.json')
+  const config = {
+    id: 'serviceApp',
+    config: configFile,
+    path: appPath,
+    entrypoint: true,
+    hotReload: true,
+    dependencies: [],
+    dependents: [],
+    localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
+  }
+  const app = new PlatformaticApp(config, null, logger)
+
+  t.after(async function () {
+    try {
+      await app.stop()
+    } catch (err) {
+      console.error(err)
+    }
+  })
+  await app.start()
+  const configManager = app.config.configManager
+  await utimes(configFile, new Date(), new Date())
+  let first = false
+  for await (const log of stream) {
+    // Wait for the server to restart, it will print a line containing "Server listening"
+    if (log.msg.includes('listening')) {
+      if (first) {
+        break
+      }
+      first = true
+    }
+  }
+  assert.strictEqual(configManager, app.server.platformatic.configManager)
+})