@milaboratories/pl-deployments 1.8.0 → 1.8.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@milaboratories/pl-deployments",
-  "version": "1.8.0",
-  "pl-version": "1.30.0",
+  "version": "1.8.2",
+  "pl-version": "1.31.3",
   "description": "MiLaboratories Platforma Backend code service run wrapper",
   "engines": {
     "node": ">=20.16.0"
@@ -53,8 +53,8 @@
     "undici": "~7.5.0",
     "yaml": "^2.7.0",
     "zod": "~3.23.8",
-    "@milaboratories/pl-config": "^1.4.5",
-    "@milaboratories/ts-helpers": "^1.1.5"
+    "@milaboratories/ts-helpers": "^1.1.5",
+    "@milaboratories/pl-config": "^1.4.6"
   },
   "scripts": {
     "type-check": "tsc --noEmit --composite false",

package/src/local/config.test.yaml

@@ -52,6 +52,8 @@ controllers:
 
   runner:
     type: local
+    resources:
+      cpu: 5
     storageRoot: './storages/work'
 
   packageLoader:

package/src/local/pl.test.ts

@@ -1,12 +1,15 @@
-import { test } from 'vitest';
-import type { LocalPlOptions } from './pl';
+import { test, expect } from 'vitest';
 import { localPlatformaInit } from './pl';
 import { ConsoleLoggerAdapter, sleep } from '@milaboratories/ts-helpers';
 import * as fs from 'fs/promises';
 import upath from 'upath';
-import { processStop } from './process';
+import { ProcessOptions, processStop } from './process';
 import * as yaml from 'yaml';
 import * as os from 'os';
+import { mergeDefaultOps } from './pl';
+import type { LocalPlOptions, LocalPlOptionsFull } from './pl';
+import { plProcessOps } from './pl';
+import { describe, it, beforeEach, afterEach } from 'vitest';
 
 test(
   'should start and stop platforma of the current version with hardcoded config',
@@ -37,7 +40,7 @@ test(
 
 test(
   'should close old platforma when starting a new one if the option is set',
-  { timeout: 25000 },
+  { timeout: 35000 },
   async ({ expect }) => {
     const logger = new ConsoleLoggerAdapter();
 
@@ -127,3 +130,314 @@ async function prepareDirForTestConfig() {
 
   return dir;
 }
+
+const mergeDefaultOpsCases: {
+  name: string;
+  input: {
+    ops: LocalPlOptions;
+    numCpu: number;
+  };
+  expected: LocalPlOptionsFull;
+}[] = [
+  {
+    name: 'should set default values when minimal input is provided',
+    input: {
+      ops: { 
+        workingDir: '/test', 
+        config: 'config',
+        plBinary: { type: 'Download', version: '1.29.2' },
+      },
+      numCpu: 4,
+    },
+    expected: {
+      workingDir: '/test',
+      config: 'config',
+      plBinary: { type: 'Download', version: '1.29.2' },
+      spawnOptions: {
+        env: {
+          GOMAXPROCS: '4',
+        },
+      },
+      closeOld: true,
+    },
+  },
+  {
+    name: 'should override outermost options when provided',
+    input: {
+      ops: { 
+        workingDir: '/test', 
+        config: 'config',
+        // we provided plBinary and closeOld, they should appear in the result
+        plBinary: { type: 'Local', path: '/custom/binary' },
+        closeOld: false,
+      },
+      numCpu: 2,      
+    },
+    expected: {
+      workingDir: '/test',
+      config: 'config',
+      spawnOptions: {
+        env: {
+          GOMAXPROCS: '2',
+        },
+      },
+      plBinary: { type: 'Local', path: '/custom/binary' },
+      closeOld: false,
+    },
+  },
+  {
+    name: 'should merge env variables when provided',
+    input: {
+      ops: { 
+        workingDir: '/test', 
+        config: 'config',
+        plBinary: { type: 'Download', version: '1.29.2' },
+        spawnOptions: {
+          env: {
+            NODE_ENV: 'test',
+            DEBUG: 'true',
+          },
+        },
+      },
+      numCpu: 3,
+    },
+    expected: {
+      workingDir: '/test',
+      config: 'config',
+      plBinary: { type: 'Download', version: '1.29.2' },
+      spawnOptions: {
+        env: {
+          GOMAXPROCS: '3',
+          NODE_ENV: 'test',
+          DEBUG: 'true',
+        },
+      },
+      closeOld: true,
+    },
+  },
+  {
+    name: 'should override other spawnOptions properties',
+    input: {
+      ops: {
+        workingDir: '/test',
+        config: 'config',
+        plBinary: { type: 'Download', version: '1.29.2' },
+        spawnOptions: {
+          stdio: 'inherit',
+          detached: true,
+        },
+      },
+      numCpu: 2,
+    },
+    expected: {
+      workingDir: '/test',
+      config: 'config',
+      plBinary: { type: 'Download', version: '1.29.2' },
+      spawnOptions: {
+        env: {
+          GOMAXPROCS: '2',
+        },
+        stdio: 'inherit',
+        detached: true,
+      },
+      closeOld: true,
+    },
+  },
+  {
+    name: 'should handle complex case with multiple overrides',
+    input: {
+      ops: { 
+        workingDir: '/test', 
+        config: 'config',
+        plBinary: { type: 'Local', path: '/custom/binary' },
+        closeOld: false,
+        spawnOptions: {
+          env: {
+            NODE_ENV: 'production',
+            LOG_LEVEL: 'debug',
+          },
+          cwd: '/custom/dir',
+          windowsHide: false,
+        },
+      },
+      numCpu: 6,
+    },
+    expected: {
+      workingDir: '/test',
+      config: 'config',
+      plBinary: { type: 'Local', path: '/custom/binary' },
+      closeOld: false,
+      spawnOptions: {
+        env: {
+          GOMAXPROCS: '6',
+          NODE_ENV: 'production',
+          LOG_LEVEL: 'debug',
+        },
+        cwd: '/custom/dir',
+        windowsHide: false,
+      },
+    },
+  },
+];
+
+test.each(mergeDefaultOpsCases)('mergeDefaultOps: $name', ({ name, input, expected }) => {
+  const result = mergeDefaultOps(input.ops, input.numCpu);
+
+  expect(result).toEqual(expected);
+});
+
+const plProcessOpsCases: {
+  name: string;
+  input: {
+    binaryPath: string;
+    configPath: string;
+    ops: LocalPlOptionsFull;
+    workDir: string;
+  };
+  expected: ProcessOptions;
+}[] = [
+  {
+    name: 'should set basic options with minimal input',
+    input: {
+      binaryPath: '/path/to/binary',
+      configPath: '/path/to/config.yaml',
+      ops: {
+        workingDir: '/work/dir',
+        config: 'config-content',
+        plBinary: { type: 'Download', version: '1.29.2' },
+        spawnOptions: {},
+        closeOld: true,
+      },
+      workDir: '/work/dir',
+    },
+    expected: {
+      cmd: '/path/to/binary',
+      args: ['--config', '/path/to/config.yaml'],
+      opts: {
+        env: {},
+        cwd: '/work/dir',
+        stdio: ['pipe', 'ignore', 'inherit'],
+        windowsHide: true,
+      },
+    },
+  },
+  {
+    name: 'should merge environment variables when provided',
+    input: {
+      binaryPath: '/path/to/binary',
+      configPath: '/config.yaml',
+      ops: {
+        workingDir: '/work',
+        config: 'content',
+        plBinary: { type: 'Download', version: '1.29.2' },
+        spawnOptions: {
+          env: {
+            DEBUG: 'true',
+            LOG_LEVEL: 'info',
+          },
+        },
+        closeOld: true,
+      },
+      workDir: '/work',
+    },
+    expected: {
+      cmd: '/path/to/binary',
+      args: ['--config', '/config.yaml'],
+      opts: {
+        env: { 
+          DEBUG: 'true',
+          LOG_LEVEL: 'info',
+        },
+        cwd: '/work',
+        stdio: ['pipe', 'ignore', 'inherit'],
+        windowsHide: true,
+      },
+    },
+  },
+  {
+    name: 'should override spawn options when provided',
+    input: {
+      binaryPath: '/binary',
+      configPath: '/config.yaml',
+      ops: {
+        workingDir: '/work',
+        config: 'content',
+        plBinary: { type: 'Download', version: '1.29.2' },
+        spawnOptions: {
+          stdio: 'inherit',
+          detached: true,
+          shell: true,
+        },
+        closeOld: true,
+      },
+      workDir: '/work',
+    },
+    expected: {
+      cmd: '/binary',
+      args: ['--config', '/config.yaml'],
+      opts: {
+        env: {},
+        cwd: '/work',
+        stdio: 'inherit',
+        detached: true,
+        shell: true,
+        windowsHide: true,
+      },
+    },
+  },
+  {
+    name: 'should handle complex case with multiple options',
+    input: {
+      binaryPath: '/bin/platforma',
+      configPath: '/etc/platforma/config.yaml',
+      ops: {
+        workingDir: '/var/platforma',
+        config: 'yaml content',
+        plBinary: { type: 'Download', version: '1.29.2' },
+        spawnOptions: {
+          env: {
+            PL_DEBUG: 'true',
+            PL_MODE: 'development',
+            GOMAXPROCS: '4',
+          },
+          stdio: ['ignore', 'pipe', 'pipe'],
+          detached: false,
+          windowsHide: false,
+          uid: 1000,
+          gid: 1000,
+        },
+        closeOld: true,
+      },
+      workDir: '/var/platforma/runtime',
+    },
+    expected: {
+      cmd: '/bin/platforma',
+      args: ['--config', '/etc/platforma/config.yaml'],
+      opts: {
+        env: {
+          PL_DEBUG: 'true',
+          PL_MODE: 'development',
+          GOMAXPROCS: '4',
+        },
+        cwd: '/var/platforma/runtime',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: false,
+        windowsHide: false,
+        uid: 1000,
+        gid: 1000,
+      },
+    },
+  },
+];
+
+test.each(plProcessOpsCases)('plProcessOps: $name', ({ name, input, expected }) => {
+  const result = plProcessOps(
+    input.binaryPath,
+    input.configPath,
+    input.ops,
+    input.workDir,
+    {},
+  );
+
+  expect(result).toEqual(expected);
+});

package/src/local/pl.ts

@@ -17,6 +17,7 @@ import { withTrace } from './trace';
 import upath from 'upath';
 import fsp from 'node:fs/promises';
 import type { Required } from 'utility-types';
+import * as os from 'node:os';
 
 export const LocalConfigYaml = 'config-local.yaml';
 
@@ -134,19 +135,18 @@ export type LocalPlOptions = {
   readonly onCloseAndErrorNoStop?: (pl: LocalPl) => Promise<void>;
 };
 
-type LocalPlOptionsFull = Required<LocalPlOptions, 'plBinary' | 'spawnOptions' | 'closeOld'>;
+export type LocalPlOptionsFull = Required<LocalPlOptions, 'plBinary' | 'spawnOptions' | 'closeOld'>;
 
 /**
  * Starts pl-core, if the option was provided downloads a binary, reads license environments etc.
  */
 export async function localPlatformaInit(logger: MiLogger, _ops: LocalPlOptions): Promise<LocalPl> {
   // filling-in default values
-  const ops = {
-    plBinary: newDefaultPlBinarySource(),
-    spawnOptions: {},
-    closeOld: true,
-    ..._ops,
-  } satisfies LocalPlOptionsFull;
+
+  // Backend could consume a lot of CPU power,
+  // we want to keep at least a couple for UI and other apps to work.
+  const numCpu = Math.max(os.cpus().length - 2, 1);
+  const ops = mergeDefaultOps(_ops, numCpu);
 
   return await withTrace(logger, async (trace, t) => {
     trace('startOptions', { ...ops, config: 'too wordy' });
@@ -164,20 +164,9 @@ export async function localPlatformaInit(logger: MiLogger, _ops: LocalPlOptions)
 
     const plBinPath = upath.join(workDir, 'binaries');
     const baseBinaryPath = await resolveLocalPlBinaryPath(logger, plBinPath, ops.plBinary);
-
     const binaryPath = trace('binaryPath', upath.join('binaries', baseBinaryPath));
 
-    const processOpts: ProcessOptions = {
-      cmd: binaryPath,
-      args: ['--config', configPath],
-      opts: {
-        env: { ...process.env },
-        cwd: workDir,
-        stdio: ['pipe', 'ignore', 'inherit'],
-        windowsHide: true, // hide a terminal on Windows
-        ...ops.spawnOptions,
-      },
-    };
+    const processOpts = plProcessOps(binaryPath, configPath, ops, workDir, process.env);
     trace('processOpts', {
       cmd: processOpts.cmd,
       args: processOpts.args,
@@ -220,3 +209,67 @@ async function localPlatformaReadPidAndStop(
     return t;
   });
 }
+
+/** Gets default options for the whole init process
+ * and overrides them with the provided options. */
+export function mergeDefaultOps(ops: LocalPlOptions, numCpu: number): LocalPlOptionsFull {
+  const result: {
+    plBinary: PlBinarySource;
+    spawnOptions: SpawnOptions;
+    closeOld: boolean;
+  } = {
+    plBinary: newDefaultPlBinarySource(),
+    spawnOptions: {
+      env: {
+        GOMAXPROCS: String(numCpu),
+      },
+    },
+    closeOld: true,
+  };
+
+  if (ops.spawnOptions?.env) {
+    result.spawnOptions.env = { ...result.spawnOptions.env, ...ops.spawnOptions.env };
+  }
+
+  if (ops.spawnOptions) {
+    const withoutEnv = { ...ops.spawnOptions };
+    delete withoutEnv['env'];
+    result.spawnOptions = { ...result.spawnOptions, ...withoutEnv };
+  }
+
+  const withoutSpawnOps = { ...ops };
+  delete withoutSpawnOps['spawnOptions'];
+
+  return { ...result, ...withoutSpawnOps };
+}
+
+/** Gets default options for a platforma local binary
+ * and overrides them with the provided options. */
+export function plProcessOps(
+  binaryPath: any,
+  configPath: string,
+  ops: LocalPlOptionsFull,
+  workDir: string,
+  defaultEnv: Record<string, string | undefined>,
+): ProcessOptions {
+  const result: ProcessOptions = {
+    cmd: binaryPath,
+    args: ['--config', configPath],
+    opts: {
+      env: { ...defaultEnv },
+      cwd: workDir,
+      stdio: ['pipe', 'ignore', 'inherit'],
+      windowsHide: true, // hide a terminal on Windows
+    },
+  };
+
+  if (ops.spawnOptions?.env) {
+    result.opts.env = { ...result.opts.env, ...ops.spawnOptions.env };
+  }
+
+  const withoutEnv = { ...ops.spawnOptions };
+  delete withoutEnv['env'];
+  result.opts = { ...result.opts, ...withoutEnv };
+
+  return result;
+}