@platformatic/runtime 4.0.0-new-config.2 → 4.0.0-new-config.6

package/lib/config.js

@@ -1,28 +1,17 @@
-import { importCapabilityAndConfig, validationOptions } from '@platformatic/basic'
-import {
-  extractModuleFromSchemaUrl,
-  findConfigurationFile,
-  kMetadata,
-  loadConfiguration,
-  loadConfigurationModule,
-  loadModule,
-  omitProperties,
-  runtimeUnwrappablePropertiesList
-} from '@platformatic/foundation'
-import { readdir, readFile } from 'node:fs/promises'
-import { createRequire } from 'node:module'
+import { createDirectory, kMetadata, loadModule } from '@platformatic/foundation'
 import { loadAdditionalApplications } from '@platformatic/foundation/lib/v4/index.js'
-import { isAbsolute, join, resolve as resolvePath } from 'node:path'
+import { createRequire, findPackageJSON } from 'node:module'
+import { dirname, resolve as resolvePath } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 import {
+  ApplicationsPortsOverlapError,
   InspectAndInspectBrkError,
   InspectorHostError,
   InspectorPortError,
-  InvalidArgumentError
+  InvalidArgumentError,
+  MissingDependencyError
 } from './errors.js'
-import { schema } from './schema.js'
-import { upgrade } from './upgrade.js'
 
 // The runtime package's own entry point, which is where the bundled capability copies live.
 const runtimeScopePath = fileURLToPath(new URL('../index.js', import.meta.url))
@@ -83,6 +72,10 @@ function parseWorkers (config, prefix, defaultWorkers = { static: 1, dynamic: fa
     config.workers = {}
   }
 
+  // What this entry asked for, before the defaults are folded in.
+  const declaredMinimum = config.workers.minimum
+  const declaredStatic = config.workers.static
+
   // Fill missing values from defaults
   for (const key of ['minimum', 'maximum', 'static', 'dynamic']) {
     if (typeof config.workers[key] === 'undefined' && typeof defaultWorkers[key] !== 'undefined') {
@@ -97,6 +90,16 @@ function parseWorkers (config, prefix, defaultWorkers = { static: 1, dynamic: fa
     config.workers.maximum = t
   }
 
+  /*
+    `static` is how many workers the application starts with, and an entry that declared its own
+    `minimum` has already said. The runtime-wide default -- which is 1 unless the project set one --
+    must not override it: `{ dynamic: true, minimum: 2 }` otherwise starts a single worker and
+    leaves the autoscaler to climb to the floor the entry asked for.
+  */
+  if (typeof declaredStatic === 'undefined' && typeof declaredMinimum !== 'undefined') {
+    config.workers.static = declaredMinimum
+  }
+
   if (typeof config.workers.static === 'undefined') {
     config.workers.static = config.workers.minimum
   }
@@ -132,49 +135,6 @@ export function autoDetectPprofCapture (config) {
   return config
 }
 
-export async function wrapInRuntimeConfig (config, context) {
-  let applicationId = 'main'
-  try {
-    const packageJson = JSON.parse(await readFile(join(config[kMetadata].root, 'package.json'), 'utf-8'))
-    applicationId = packageJson?.name ?? 'main'
-
-    if (applicationId.startsWith('@')) {
-      applicationId = applicationId.split('/')[1]
-    }
-  } catch (err) {
-    // on purpose, the package.json might be missing
-  }
-
-  const production = context?.isProduction ?? context?.production
-
-  const runtimeConfig = config.runtime ?? {}
-
-  // Important: do not change the order of the properties in this object
-  /* c8 ignore next */
-  const wrapped = {
-    $schema: schema.$id,
-    watch: !production,
-    ...omitProperties(runtimeConfig, runtimeUnwrappablePropertiesList),
-    applications: [
-      {
-        id: applicationId,
-        path: config[kMetadata].root,
-        config: config[kMetadata].path,
-        ...(runtimeConfig.application ?? {})
-      }
-    ]
-  }
-
-  return loadConfiguration(wrapped, context?.schema ?? schema, {
-    validationOptions,
-    transform,
-    upgrade,
-    replaceEnv: true,
-    root: config[kMetadata].root,
-    ...context
-  })
-}
-
 export function parseInspectorOptions (config, inspect, inspectBreak) {
   const hasInspect = inspect != null
   const hasInspectBrk = inspectBreak != null
@@ -229,16 +189,6 @@ export function parseInspectorOptions (config, inspect, inspectBreak) {
 export async function prepareAddedApplications (config, entries, existingIds = []) {
   const metadata = config[kMetadata]
 
-  if (!metadata?.v4) {
-    const prepared = []
-
-    for (const entry of entries) {
-      prepared.push(await prepareApplication(config, entry, config.workers))
-    }
-
-    return prepared
-  }
-
   const { applications } = await loadAdditionalApplications({
     configPath: metadata.path,
     entries,
@@ -247,6 +197,8 @@ export async function prepareAddedApplications (config, entries, existingIds = [
     command: metadata.v4.command,
     mode: metadata.v4.mode,
     production: metadata.v4.production,
+    realEnv: metadata.v4.realEnv,
+    customEnvFile: metadata.v4.customEnvFile,
     // The runtime is the fallback scope for capability resolution, the same as at boot.
     runtimeScope: runtimeScopePath
   })
@@ -260,58 +212,98 @@ export async function prepareAddedApplications (config, entries, existingIds = [
   return prepared
 }
 
-export async function prepareApplication (config, application, defaultWorkers) {
-  // We need to have absolute paths here, ot the `loadConfig` will fail
-  // Make sure we don't resolve if env var was not replaced
-  if (application.path && !isAbsolute(application.path) && !application.path.match(/^\{.*\}$/)) {
-    application.path = resolvePath(config[kMetadata].root, application.path)
+const hostnameWildcards = new Set(['0.0.0.0', '::', '[::]'])
+
+// The listener an application declares in its own configuration, when it can be determined without
+// starting it. A port coming from an environment variable which was not replaced, an ephemeral port
+// and a missing server block all yield null, in which case only the start time check applies.
+function declaredListener (applicationConfig) {
+  const server = applicationConfig?.server
+
+  if (!server) {
+    return null
   }
 
-  if (application.path && application.config) {
-    application.config = resolvePath(application.path, application.config)
+  const port = Number(server.port)
+
+  if (!Number.isInteger(port) || port <= 0) {
+    return null
   }
 
-  // Skip capability detection for external services (url without path)
-  // These services will have their path resolved later in runtime.js #setupApplication
-  // Attempting to detect capability here would cause slow glob operations on the cwd
-  if (application.url && !application.path) {
-    application.type = 'unknown'
-  } else {
-    try {
-      let pkg
+  return { port, hostname: server.hostname, perWorker: server.portAssignment === 'perWorkerIncrement' }
+}
 
-      if (application.config) {
-        const applicationConfig = await loadConfiguration(application.config)
-        pkg = await loadConfigurationModule(application.path, applicationConfig)
+// Two declared listeners can only be compared when both hostnames are known. When a hostname is
+// omitted the capability picks its own default, so unless the other side is a wildcard - which
+// overlaps with anything - the comparison is left to the start time check.
+function declaredListenersOverlap (first, second) {
+  const hostname = first.hostname?.toLowerCase()
+  const otherHostname = second.hostname?.toLowerCase()
 
-        application.type = extractModuleFromSchemaUrl(applicationConfig, true).module
-        application.skipTelemetryHooks = pkg.skipTelemetryHooks
-      } else {
-        const { moduleName, capability } = await importCapabilityAndConfig(application.path)
-        pkg = capability
+  // A wildcard overlaps with any other hostname, known or not
+  if (hostnameWildcards.has(hostname) || hostnameWildcards.has(otherHostname)) {
+    return true
+  }
 
-        application.type = moduleName
-      }
+  // Both applications rely on the same capability default, so they do collide
+  if (typeof hostname === 'undefined' && typeof otherHostname === 'undefined') {
+    return true
+  }
+
+  // Only one of the two defaults is unknown, so nothing can be concluded here
+  if (typeof hostname === 'undefined' || typeof otherHostname === 'undefined') {
+    return false
+  }
 
-      application.skipTelemetryHooks = pkg.skipTelemetryHooks
+  return hostname === otherHostname
+}
 
-      // This is needed to work around Rust bug on dylibs:
-      // https://github.com/rust-lang/rust/issues/91979
-      // https://github.com/rollup/rollup/issues/5761
-      const _require = createRequire(application.path)
-      for (const m of pkg.modulesToLoad ?? []) {
-        const toLoad = _require.resolve(m)
-        loadModule(_require, toLoad).catch(() => {})
-      }
-    } catch (err) {
-      // This should not happen, it happens on running some unit tests if we prepare the runtime
-      // when not all the applications configs are available. Given that we are running this only
-      // to ddetermine the type of the application, it's safe to ignore this error and default to unknown
-      application.type = 'unknown'
+function describeDeclaredPorts (listener) {
+  const { port, last } = listener
+  return port === last ? `port ${port}` : `ports ${port}-${last}, one per worker`
+}
+
+// Rejects applications whose declared ports overlap before any of them is started, so that the
+// failure does not depend on which worker happens to report its URL first. This is best effort:
+// applications whose port cannot be determined here are checked when their workers start.
+function verifyApplicationsPorts (applications) {
+  const listeners = []
+
+  for (const application of applications) {
+    // v4 keeps the validated capability configuration on the application (resolvedConfig), so the
+    // declared listener is read from it directly rather than being stashed on a symbol during a
+    // separate config-loading pass, as the v3 path did.
+    const listener = declaredListener(application.resolvedConfig)
+
+    // Dynamic scaling changes how many ports the application ends up using, so leave it to the start time check
+    if (!listener || application.workers?.dynamic) {
+      continue
     }
+
+    const workers = listener.perWorker ? (application.workers?.static ?? 1) : 1
+    listeners.push({ ...listener, id: application.id, last: listener.port + workers - 1 })
   }
 
-  return finalizeApplication(config, application, defaultWorkers)
+  for (let i = 0; i < listeners.length; i++) {
+    for (let j = i + 1; j < listeners.length; j++) {
+      const first = listeners[i]
+      const second = listeners[j]
+
+      const port = Math.max(first.port, second.port)
+
+      if (port > Math.min(first.last, second.last) || !declaredListenersOverlap(first, second)) {
+        continue
+      }
+
+      throw new ApplicationsPortsOverlapError(
+        first.id,
+        describeDeclaredPorts(first),
+        second.id,
+        describeDeclaredPorts(second),
+        port
+      )
+    }
+  }
 }
 
 // Everything an application needs regardless of how its capability was determined. v3 discovers
@@ -337,7 +329,7 @@ export function finalizeApplication (config, application, defaultWorkers) {
 
 /*
   The v4 preparation. The loader resolved the path, selected the capability and imported its schema
-  subpath — which carries skipTelemetryHooks and modulesToLoad — all main-side, before any worker
+  subpath — which carries skipTracingHooks and modulesToLoad — all main-side, before any worker
   existed. So there is nothing to discover here, and in particular no application config file to
   re-read: that is the whole point of evaluating configuration exactly once per load.
 */
@@ -346,14 +338,37 @@ export async function prepareV4Application (config, application, defaultWorkers)
   // capability payload as data and never re-reads a file.
   application.resolvedConfig = application.config ?? {}
   application.config = undefined
+
+  /*
+    A module application names an npm package as its capability instead of describing one in a file.
+    The package is resolved from the runtime root, and its own directory (sourcePath) is kept
+    separate from the application's writable root (path) — which the module treats as a working
+    directory and which need not exist yet. Keyed on moduleApplication, not module: a regular
+    application also carries a module (its detected capability), and must not be resolved this way.
+  */
+  if (application.moduleApplication) {
+    if (!application.path) {
+      throw new InvalidArgumentError(`Application "${application.id}" must define path when module is set`)
+    }
+
+    try {
+      application.sourcePath = dirname(findPackageJSON(application.module, resolvePath(config[kMetadata].root, 'noop.js')))
+    } catch (error) {
+      throw new MissingDependencyError(application.module, { cause: error })
+    }
+
+    application.moduleRoot = config[kMetadata].root
+    await createDirectory(application.path)
+  }
+
   application.type = application.module ?? 'unknown'
-  application.skipTelemetryHooks = application.capabilityMetadata?.skipTelemetryHooks ?? false
+  application.skipTracingHooks = application.capabilityMetadata?.skipTracingHooks ?? false
 
   // This is needed to work around a Rust bug on dylibs, as in the v3 path.
   const modulesToLoad = application.capabilityMetadata?.modulesToLoad ?? []
 
   if (modulesToLoad.length > 0 && application.path) {
-    const _require = createRequire(application.path)
+    const _require = createRequire(application.sourcePath ?? application.path)
 
     for (const m of modulesToLoad) {
       try {
@@ -368,130 +383,6 @@ export async function prepareV4Application (config, application, defaultWorkers)
   return finalizeApplication(config, application, defaultWorkers)
 }
 
-function isApplicationEnabled (application, environment) {
-  const { enabled } = application
-
-  if (typeof enabled === 'undefined') {
-    return true
-  }
-
-  if (typeof enabled === 'string') {
-    return enabled !== 'false'
-  }
-
-  if (typeof enabled === 'object' && enabled !== null) {
-    return enabled[environment] ?? true
-  }
-
-  return enabled
-}
-
-export async function transform (config, _, context) {
-  const production = context?.isProduction ?? context?.production
-  const environment = production ? 'production' : 'development'
-  const applications = [...(config.applications ?? []), ...(config.services ?? []), ...(config.web ?? [])]
-
-  const watchType = typeof config.watch
-  if (watchType === 'string') {
-    config.watch = config.watch === 'true'
-  } else if (watchType === 'undefined') {
-    config.watch = !production
-  }
-
-  // Migrate the old verticalScaler property, only applied if the new settings are not set, otherwise workers takes precedence
-  // TODO: Remove in the next major version
-  if (config.verticalScaler) {
-    config.workers ??= {}
-    config.workers.total ??= config.verticalScaler.maxTotalWorkers
-    config.workers.dynamic ??= config.verticalScaler.enabled
-    config.workers.minimum ??= config.verticalScaler.minWorkers ?? 1
-    config.workers.maximum ??= config.verticalScaler.maxWorkers ?? config.verticalScaler.maxTotalWorkers ?? 1
-    config.workers.maxMemory ??= config.verticalScaler.maxTotalMemory
-
-    if (config.verticalScaler.cooldownSec) {
-      config.workers.cooldown ??= config.verticalScaler.cooldownSec * 1000
-    }
-    if (config.verticalScaler.gracePeriod) {
-      config.workers.gracePeriod ??= config.verticalScaler.gracePeriod
-    }
-    if (config.verticalScaler.scaleUpELU) {
-      config.workers.scaleUpELU ??= config.verticalScaler.scaleUpELU
-    }
-    if (config.verticalScaler.scaleDownELU) {
-      config.workers.scaleDownELU ??= config.verticalScaler.scaleDownELU
-    }
-
-    if (config.verticalScaler.applications) {
-      for (const appId in config.verticalScaler.applications) {
-        let appConfig = applications.find((app) => app.id === appId)
-        if (!appConfig) {
-          appConfig = { id: appId, workers: {} }
-          applications.push(appConfig)
-        }
-
-        const scaleConfig = config.verticalScaler.applications[appId]
-        const workersConfig = appConfig.workers ??= {}
-
-        workersConfig.minimum ??= scaleConfig.minWorkers ?? config.workers.minimum
-        workersConfig.maximum ??= scaleConfig.maxWorkers ?? config.workers.maximum
-
-        if (scaleConfig.scaleUpELU) {
-          workersConfig.scaleUpELU ??= scaleConfig.scaleUpELU
-        }
-        if (scaleConfig.scaleDownELU) {
-          workersConfig.scaleDownELU ??= scaleConfig.scaleDownELU
-        }
-      }
-    }
-
-    config.verticalScaler = undefined
-  }
-
-  if (config.autoload) {
-    const { exclude = [], mappings = {} } = config.autoload
-    let { path } = config.autoload
-
-    path = resolvePath(config[kMetadata].root, path)
-    const entries = await readdir(path, { withFileTypes: true })
-
-    for (let i = 0; i < entries.length; ++i) {
-      const entry = entries[i]
-
-      if (exclude.includes(entry.name) || !entry.isDirectory()) {
-        continue
-      }
-
-      const mapping = mappings[entry.name] ?? {}
-      const id = mapping.id ?? entry.name
-      const entryPath = join(path, entry.name)
-
-      let config
-      const configFilename = mapping.config ?? (await findConfigurationFile(entryPath))
-
-      if (typeof configFilename === 'string') {
-        config = join(entryPath, configFilename)
-      }
-
-      const application = { id, config, path: entryPath, ...mapping }
-      const existingApplicationId = applications.findIndex(application => application.id === id)
-
-      if (existingApplicationId !== -1) {
-        applications[existingApplicationId] = { ...application, ...applications[existingApplicationId] }
-      } else {
-        applications.push(application)
-      }
-    }
-  }
-
-  for (let i = applications.length - 1; i >= 0; --i) {
-    if (!isApplicationEnabled(applications[i], environment)) {
-      applications.splice(i, 1)
-    }
-  }
-
-  return finalizeConfiguration(config, applications, context, production, prepareApplication)
-}
-
 // The half of the transform the loader does not own: inspector options, worker counts, the
 // per-application preparation, and the runtime-level normalizations. v4 reaches this directly,
 // having already expanded autoload and resolved enabled in the eval worker.
@@ -507,6 +398,8 @@ export async function finalizeConfiguration (config, applications, context, prod
     await prepare(config, applications[i], defaultWorkers)
   }
 
+  verifyApplicationsPorts(applications)
+
   if (typeof config.metrics === 'boolean') {
     config.metrics = {
       enabled: config.metrics,

package/lib/errors.js

@@ -15,6 +15,10 @@ export const AddressInUseError = createError(
   `${ERROR_PREFIX}_EADDR_IN_USE`,
   'Port %d is already in use by applications "%s" and "%s"'
 )
+export const ApplicationsPortsOverlapError = createError(
+  `${ERROR_PREFIX}_APPLICATIONS_PORTS_OVERLAP`,
+  'The applications "%s" (%s) and "%s" (%s) are both configured to listen on port %d. Applications cannot share a port: change one of the ports or make them listen on different hostnames.'
+)
 export const WorkerAddressInUseError = createError(
   `${ERROR_PREFIX}_WORKER_EADDR_IN_USE`,
   'Port %d is already in use by another worker of the application "%s". Multiple workers can share a port only when the reusePort feature is available in your OS, otherwise set "server.portAssignment" to "perWorkerIncrement" in the application configuration or use a single worker.'
@@ -103,6 +107,10 @@ export const NoConfigFileFoundError = createError(
   "No config file found for application '%s'"
 )
 export const MissingDependencyError = createError(`${ERROR_PREFIX}_MISSING_DEPENDENCY`, 'Missing dependency: "%s"')
+export const InvalidApplicationModuleError = createError(
+  `${ERROR_PREFIX}_INVALID_APPLICATION_MODULE`,
+  'Application module "%s" must export a create function'
+)
 export const InspectAndInspectBrkError = createError(
   `${ERROR_PREFIX}_INSPECT_AND_INSPECT_BRK`,
   '--inspect and --inspect-brk cannot be used together'
@@ -232,3 +240,7 @@ export const WorkerInterceptorJoinTimeoutError = createError(
   `${ERROR_PREFIX}_WORKER_INTERCEPTOR_JOIN_TIMEOUT`,
   'The %s failed to join the mesh network in %dms.'
 )
+export const MixedServingStateError = createError(
+  `${ERROR_PREFIX}_MIXED_SERVING_STATE`,
+  'The workers of the application "%s" disagree about how it serves: %s. One application is one thing; workers that disagree about whether it serves HTTP would have the mesh route a share of requests to a worker that destroys them.'
+)