@platformatic/runtime 2.0.0-alpha.1 → 2.0.0-alpha.3

package/lib/schema.js

@@ -3,19 +3,19 @@
 
 const telemetry = require('@platformatic/telemetry').schema
 const { schemas: { server } } = require('@platformatic/utils')
+
 const pkg = require('../package.json')
-const version = 'v' + pkg.version
 const platformaticRuntimeSchema = {
-  $id: `https://platformatic.dev/schemas/${version}/runtime`,
+  $id: `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
   type: 'object',
   properties: {
     $schema: {
-      type: 'string'
+      type: 'string',
     },
     preload: {
       type: 'string',
-      resolvePath: true
+      resolvePath: true,
     },
     autoload: {
       type: 'object',
@@ -24,106 +24,106 @@ const platformaticRuntimeSchema = {
       properties: {
         path: {
           type: 'string',
-          resolvePath: true
+          resolvePath: true,
         },
         exclude: {
           type: 'array',
           default: [],
           items: {
-            type: 'string'
-          }
+            type: 'string',
+          },
         },
         mappings: {
           type: 'object',
           additionalProperties: {
             type: 'object',
             additionalProperties: false,
-            required: ['id', 'config'],
+            required: ['id'],
             properties: {
               id: {
-                type: 'string'
+                type: 'string',
               },
               config: {
-                type: 'string'
+                type: 'string',
               },
               useHttp: {
-                type: 'boolean'
-              }
-            }
-          }
-        }
-      }
+                type: 'boolean',
+              },
+            },
+          },
+        },
+      },
     },
     telemetry,
     server,
     entrypoint: {
-      type: 'string'
+      type: 'string',
     },
-    hotReload: {
+    watch: {
       anyOf: [
         {
-          type: 'boolean'
+          type: 'boolean',
         },
         {
-          type: 'string'
-        }
-      ]
+          type: 'string',
+        },
+      ],
     },
     inspectorOptions: {
       type: 'object',
       properties: {
         host: {
-          type: 'string'
+          type: 'string',
         },
         port: {
-          type: 'number'
+          type: 'number',
         },
         breakFirstLine: {
-          type: 'boolean'
+          type: 'boolean',
         },
-        hotReloadDisabled: {
-          type: 'boolean'
-        }
-      }
+        watchDisabled: {
+          type: 'boolean',
+        },
+      },
     },
     undici: {
       type: 'object',
       properties: {
         agentOptions: {
           type: 'object',
-          additionalProperties: true
+          additionalProperties: true,
         },
         interceptors: {
           anyOf: [{
             type: 'array',
             items: {
-              $ref: '#/$defs/undiciInterceptor'
-            }
+              $ref: '#/$defs/undiciInterceptor',
+            },
           }, {
             type: 'object',
             properties: {
               Client: {
                 type: 'array',
                 items: {
-                  $ref: '#/$defs/undiciInterceptor'
-                }
+                  $ref: '#/$defs/undiciInterceptor',
+                },
               },
               Pool: {
                 type: 'array',
                 items: {
-                  $ref: '#/$defs/undiciInterceptor'
-                }
+                  $ref: '#/$defs/undiciInterceptor',
+                },
               },
               Agent: {
                 type: 'array',
                 items: {
-                  $ref: '#/$defs/undiciInterceptor'
-                }
-              }
-            }
-          }]
-        }
-      }
+                  $ref: '#/$defs/undiciInterceptor',
+                },
+              },
+            },
+          }],
+        },
+      },
     },
     managementApi: {
       anyOf: [
@@ -136,14 +136,14 @@ const platformaticRuntimeSchema = {
               maxSize: {
                 type: 'number',
                 minimum: 5,
-                default: 200
-              }
-            }
+                default: 200,
+              },
+            },
           },
-          additionalProperties: false
-        }
+          additionalProperties: false,
+        },
       ],
-      default: true
+      default: true,
     },
     metrics: {
       anyOf: [
@@ -154,8 +154,8 @@ const platformaticRuntimeSchema = {
             port: {
               anyOf: [
                 { type: 'integer' },
-                { type: 'string' }
-              ]
+                { type: 'string' },
+              ],
             },
             hostname: { type: 'string' },
             endpoint: { type: 'string' },
@@ -163,53 +163,56 @@ const platformaticRuntimeSchema = {
               type: 'object',
               properties: {
                 username: { type: 'string' },
-                password: { type: 'string' }
+                password: { type: 'string' },
               },
               additionalProperties: false,
-              required: ['username', 'password']
+              required: ['username', 'password'],
             },
             labels: {
               type: 'object',
-              additionalProperties: { type: 'string' }
-            }
+              additionalProperties: { type: 'string' },
+            },
           },
-          additionalProperties: false
-        }
-      ]
+          additionalProperties: false,
+        },
+      ],
     },
     restartOnError: {
       default: true,
       anyOf: [
         { type: 'boolean' },
-        { type: 'string' }
-      ]
+        {
+          type: 'number',
+          minimum: 100,
+        },
+      ],
     },
     services: {
       type: 'array',
       items: {
         type: 'object',
-        required: ['id', 'path', 'config'],
+        required: ['id', 'path'],
         properties: {
           id: {
-            type: 'string'
+            type: 'string',
           },
           path: {
             type: 'string',
-            resolvePath: true
+            resolvePath: true,
           },
           config: {
-            type: 'string'
+            type: 'string',
           },
           useHttp: {
-            type: 'boolean'
-          }
-        }
-      }
-    }
+            type: 'boolean',
+          },
+        },
+      },
+    },
   },
   anyOf: [
     { required: ['autoload', 'entrypoint'] },
-    { required: ['services', 'entrypoint'] }
+    { required: ['services', 'entrypoint'] },
   ],
   additionalProperties: false,
   $defs: {
@@ -217,16 +220,16 @@ const platformaticRuntimeSchema = {
       type: 'object',
       properties: {
         module: {
-          type: 'string'
+          type: 'string',
         },
         options: {
           type: 'object',
-          additionalProperties: true
-        }
+          additionalProperties: true,
+        },
       },
-      required: ['module', 'options']
-    }
-  }
+      required: ['module', 'options'],
+    },
+  },
 }
 
 module.exports.schema = platformaticRuntimeSchema

package/lib/start.js

@@ -1,46 +1,22 @@
 'use strict'
 
-const { once } = require('node:events')
 const inspector = require('node:inspector')
-const { join, resolve, dirname } = require('node:path')
 const { writeFile } = require('node:fs/promises')
-const { pathToFileURL } = require('node:url')
-const { Worker } = require('node:worker_threads')
+const { join, resolve, dirname } = require('node:path')
+
 const { printConfigValidationErrors } = require('@platformatic/config')
 const closeWithGrace = require('close-with-grace')
-const { loadConfig } = require('./load-config')
-const { startManagementApi } = require('./management-api')
-const { startPrometheusServer } = require('./prom-server.js')
-const { parseInspectorOptions, wrapConfigInRuntimeConfig } = require('./config')
-const { RuntimeApiClient, getRuntimeLogsDir } = require('./api-client.js')
-const errors = require('./errors')
-const pkg = require('../package.json')
 const pino = require('pino')
 const pretty = require('pino-pretty')
 
-const kLoaderFile = pathToFileURL(join(__dirname, 'loader.mjs')).href
-const kWorkerFile = join(__dirname, 'worker.js')
-const kWorkerExecArgv = [
-  '--no-warnings',
-  '--experimental-loader',
-  kLoaderFile
-]
-
-function startWorker ({ config, dirname, runtimeLogsDir }, env) {
-  const worker = new Worker(kWorkerFile, {
-    /* c8 ignore next */
-    execArgv: config.hotReload ? kWorkerExecArgv : [],
-    transferList: config.loggingPort ? [config.loggingPort] : [],
-    workerData: { config, dirname, runtimeLogsDir },
-    env
-  })
-
-  return worker
-}
+const pkg = require('../package.json')
+const { parseInspectorOptions, wrapConfigInRuntimeConfig } = require('./config')
+const { Runtime } = require('./runtime')
+const errors = require('./errors')
+const { getRuntimeLogsDir, loadConfig } = require('./utils')
 
 async function buildRuntime (configManager, env) {
   env = env || process.env
-  const config = configManager.current
 
   if (inspector.url()) {
     throw new errors.NodeInspectorFlagsNotSupportedError()
@@ -50,80 +26,24 @@ async function buildRuntime (configManager, env) {
     parseInspectorOptions(configManager)
   }
 
-  if (config.hotReload) {
-    config.loaderFile = kLoaderFile
-  }
-
   const dirname = configManager.dirname
   const runtimeLogsDir = getRuntimeLogsDir(dirname, process.pid)
 
-  // The configManager cannot be transferred to the worker, so remove it.
-  delete config.configManager
-
-  let worker = startWorker({ config, dirname, runtimeLogsDir }, env)
-
-  let managementApi = null
-
-  if (config.hotReload) {
-    /* c8 ignore next 3 */
-    process.on('SIGUSR2', () => {
-      worker.postMessage({ signal: 'SIGUSR2' })
-    })
-
-    /* c8 ignore next 3 */
-    configManager.on('update', () => {
-      // TODO(cjihrig): Need to clean up and restart the worker.
-    })
-  }
-
-  function setupExit () {
-    worker.on('exit', (code) => {
-      // runtimeApiClient.started can be false if a stop command was issued
-      // via the management API.
-      if (config.restartOnError === false || !runtimeApiClient.started) {
-        // We must stop those here in case the `closeWithGrace` callback
-        // was not called.
-        configManager.fileWatcher?.stopWatching()
-        managementApi?.close()
-        return
-      }
-
-      worker = startWorker({ config, dirname, runtimeLogsDir }, env)
-      setupExit()
-
-      once(worker, 'message').then((msg) => {
-        runtimeApiClient.setWorker(worker).catch(() => {
-          // TODO: currently we restart if the worker fails to start intermitently
-          // should we limit this to a number of retries?
-        })
-      })
-    })
-  }
-
-  setupExit()
-
-  await once(worker, 'message') // plt:init
+  const runtime = new Runtime(configManager, runtimeLogsDir, env)
 
-  const runtimeApiClient = new RuntimeApiClient(
-    worker,
-    configManager,
-    runtimeLogsDir
-  )
+  /* c8 ignore next 3 */
+  process.on('SIGUSR2', async () => {
+    runtime.logger.info('Received SIGUSR2, restarting all services ...')
 
-  if (config.managementApi) {
-    managementApi = await startManagementApi(runtimeApiClient, configManager)
-    runtimeApiClient.managementApi = managementApi
-    runtimeApiClient.on('start', () => {
-      runtimeApiClient.startCollectingMetrics()
-    })
-  }
-  if (config.metrics) {
-    runtimeApiClient.on('start', async () => {
-      await startPrometheusServer(runtimeApiClient, config.metrics)
-    })
-  }
+    try {
+      await runtime.restart()
+    } catch (err) {
+      runtime.logger.error({ err }, 'Failed to restart services.')
+    }
+  })
 
-  return runtimeApiClient
+  await runtime.init()
+  return runtime
 }
 
 async function start (args) {
@@ -155,15 +75,15 @@ async function setupAndStartRuntime (config) {
   let runtime = await buildRuntime(runtimeConfig)
 
   let address = null
-  let startErr = null
+  const startErr = null
   const originalPort = runtimeConfig.current.server?.port || 0
   while (address === null) {
     try {
       address = await runtime.start()
     } catch (err) {
-      startErr = err
       if (err.code === 'EADDRINUSE') {
         await runtime.close()
+
         if (runtimeConfig.current?.server?.port > MAX_PORT) throw err
         runtimeConfig.current.server.port++
         runtime = await buildRuntime(runtimeConfig)
@@ -173,10 +93,12 @@ async function setupAndStartRuntime (config) {
     }
   }
   if (startErr?.code === 'PLT_RUNTIME_EADDR_IN_USE') {
-    const logger = pino(pretty({
-      translateTime: 'SYS:HH:MM:ss',
-      ignore: 'hostname,pid'
-    }))
+    const logger = pino(
+      pretty({
+        translateTime: 'SYS:HH:MM:ss',
+        ignore: 'hostname,pid',
+      })
+    )
     logger.warn(`Port: ${originalPort} is already in use!`)
     logger.warn(`Starting service on port: ${runtimeConfig.current.server.port}`)
   }
@@ -192,7 +114,7 @@ async function startCommand (args) {
     const runtime = startResult.runtime
     const res = startResult.address
 
-    closeWithGrace(async (event) => {
+    closeWithGrace(async event => {
       if (event.err instanceof Error) {
         console.error(event.err)
       }
@@ -203,21 +125,21 @@ async function startCommand (args) {
   } catch (err) {
     if (err.code === 'PLT_CONFIG_NO_CONFIG_FILE_FOUND' && args.length === 1) {
       const config = {
-        $schema: `https://platformatic.dev/schemas/v${pkg.version}/service`,
+        $schema: `https://schemas.platformatic.dev/@platformatic/service/${pkg.version}.json`,
         server: {
           hostname: '127.0.0.1',
           port: 3042,
           logger: {
-            level: 'info'
-          }
+            level: 'info',
+          },
         },
         plugins: {
-          paths: [args[0]]
+          paths: [args[0]],
         },
         service: {
-          openapi: true
+          openapi: true,
         },
-        watch: true
+        watch: true,
       }
       const toWrite = join(dirname(resolve(args[0])), 'platformatic.service.json')
       console.log(`No config file found, creating ${join(dirname(args[0]), 'platformatic.service.json')}`)
@@ -229,7 +151,7 @@ async function startCommand (args) {
       console.error(`Missing config file!
   Be sure to have a config file with one of the following names:
 
-  ${err.filenames.map((s) => ' * ' + s).join('\n')}
+  ${err.filenames.map(s => ' * ' + s).join('\n')}
 
   In alternative run "npm create platformatic@latest" to generate a basic plt service config.`)
       process.exit(1)

package/lib/streams/message-port-writable.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const { Writable } = require('node:stream')
+
+class MessagePortWritable extends Writable {
+  #port
+  #metadata
+
+  constructor (options) {
+    const { port, metadata, ...opts } = options
+
+    super({ ...opts, decodeStrings: false })
+    this.#port = port
+    this.#metadata = metadata
+  }
+
+  // Since this is only invoked by pino, we only receive strings
+  _write (chunk, encoding, callback) {
+    this.#port.postMessage({ metadata: this.#metadata, logs: [chunk.toString(encoding ?? 'utf-8')] })
+
+    // Important: do not remove nextTick otherwise _writev will never be used
+    process.nextTick(callback)
+  }
+
+  // Since this is only invoked by pino, we only receive strings
+  _writev (chunks, callback) {
+    this.#port.postMessage({ metadata: this.#metadata, logs: chunks.map(c => c.chunk.toString(c.encoding ?? 'utf-8')) })
+
+    // Important: do not remove nextTick otherwise _writev will never be used
+    process.nextTick(callback)
+  }
+
+  _final (callback) {
+    this.#port.close()
+    callback()
+  }
+
+  _destroy (err, callback) {
+    this.#port.close()
+    callback(err)
+  }
+}
+
+module.exports = { MessagePortWritable }

package/lib/streams/pino-writable.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { Writable } = require('node:stream')
+const inspect = require('node:util')
+
+class PinoWritable extends Writable {
+  #write
+
+  constructor (options) {
+    const { pino, level, ...opts } = options
+
+    super({ ...opts, decodeStrings: false })
+    this.#write = pino[level].bind(pino)
+  }
+
+  _write (chunk, encoding, callback) {
+    this.#write({ raw: encoding === 'buffer' ? inspect(chunk) : chunk.toString(encoding ?? 'utf-8') })
+    callback()
+  }
+
+  // We don't define _writev as we have to serialize messages one by one so batching wouldn't make any sense.
+}
+
+function createPinoWritable (pino, level) {
+  const writable = new PinoWritable({ pino, level })
+  writable.write = writable.write.bind(writable)
+  return writable
+}
+
+module.exports = { PinoWritable, createPinoWritable }

package/lib/upgrade.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const { join } = require('path')
+const { join } = require('node:path')
+
 const pkg = require('../package.json')
 
 module.exports = async function upgrade (config, version) {
@@ -10,7 +11,7 @@ module.exports = async function upgrade (config, version) {
     version,
     path: join(__dirname, 'versions'),
     input: config,
-    logger: this.logger.child({ name: '@platformatic/runtime' })
+    logger: this.logger.child({ name: '@platformatic/runtime' }),
   })
 
   let result
@@ -19,7 +20,7 @@ module.exports = async function upgrade (config, version) {
     result = updated.result
   }
 
-  result.$schema = `https://platformatic.dev/schemas/v${pkg.version}/runtime`
+  result.$schema = `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`
 
   return result
 }

package/lib/utils.js

@@ -1,10 +1,58 @@
 'use strict'
+
+const { createHash } = require('node:crypto')
+const { tmpdir } = require('node:os')
+const { join } = require('node:path')
+
+const {
+  Store,
+  loadConfig: pltConfigLoadConfig,
+  loadEmptyConfig: pltConfigLoadEmptyConfig,
+} = require('@platformatic/config')
+
+const { platformaticRuntime } = require('./config')
+
 function getArrayDifference (a, b) {
   return a.filter(element => {
     return !b.includes(element)
   })
 }
 
+function getServiceUrl (id) {
+  return `http://${id}.plt.local`
+}
+
+function getRuntimeTmpDir (runtimeDir) {
+  const platformaticTmpDir = join(tmpdir(), 'platformatic', 'applications')
+  const runtimeDirHash = createHash('md5').update(runtimeDir).digest('hex')
+  return join(platformaticTmpDir, runtimeDirHash)
+}
+
+function getRuntimeLogsDir (runtimeDir, runtimePID) {
+  const runtimeTmpDir = getRuntimeTmpDir(runtimeDir)
+  return join(runtimeTmpDir, runtimePID.toString(), 'logs')
+}
+
+async function loadConfig (minimistConfig, args, overrides, replaceEnv = true) {
+  const { default: platformaticBasic } = await import('@platformatic/basic')
+  const store = new Store()
+  store.add(platformaticRuntime)
+  store.add(platformaticBasic)
+
+  return pltConfigLoadConfig(minimistConfig, args, store, overrides, replaceEnv)
+}
+
+async function loadEmptyConfig (path, overrides, replaceEnv = true) {
+  const { default: platformaticBasic } = await import('@platformatic/basic')
+
+  return pltConfigLoadEmptyConfig(path, platformaticBasic, overrides, replaceEnv)
+}
+
 module.exports = {
-  getArrayDifference
+  getArrayDifference,
+  getRuntimeLogsDir,
+  getRuntimeTmpDir,
+  getServiceUrl,
+  loadConfig,
+  loadEmptyConfig,
 }