@milaboratories/pl-deployments 2.15.7 → 2.15.9

package/src/local/pl.ts

@@ -1,27 +1,22 @@
-import type { ProcessOptions } from './process';
-import {
-  isProcessAlive,
-  processStop,
-  processWaitStopped,
-  processRun,
-} from './process';
-import type { PlBinarySource } from '../common/pl_binary';
-import { newDefaultPlBinarySource, resolveLocalPlBinaryPath } from '../common/pl_binary';
-import type { MiLogger } from '@milaboratories/ts-helpers';
-import { notEmpty } from '@milaboratories/ts-helpers';
-import type { ChildProcess, SpawnOptions } from 'node:child_process';
-import { filePid, readPid, writePid } from './pid';
-import type { Trace } from './trace';
-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';
-import type { ProxySettings } from '@milaboratories/pl-http';
-import { defaultHttpDispatcher } from '@milaboratories/pl-http';
-import { parseHttpAuth } from '@milaboratories/pl-model-common';
-
-export const LocalConfigYaml = 'config-local.yaml';
+import type { ProcessOptions } from "./process";
+import { isProcessAlive, processStop, processWaitStopped, processRun } from "./process";
+import type { PlBinarySource } from "../common/pl_binary";
+import { newDefaultPlBinarySource, resolveLocalPlBinaryPath } from "../common/pl_binary";
+import type { MiLogger } from "@milaboratories/ts-helpers";
+import { notEmpty } from "@milaboratories/ts-helpers";
+import type { ChildProcess, SpawnOptions } from "node:child_process";
+import { filePid, readPid, writePid } from "./pid";
+import type { Trace } from "./trace";
+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";
+import type { ProxySettings } from "@milaboratories/pl-http";
+import { defaultHttpDispatcher } from "@milaboratories/pl-http";
+import { parseHttpAuth } from "@milaboratories/pl-model-common";
+
+export const LocalConfigYaml = "config-local.yaml";
 
 /**
  * Represents a local running pl-core,
@@ -50,7 +45,7 @@ export class LocalPl {
     await withTrace(this.logger, async (trace, t) => {
       this.wasStopped = false;
       const instance = processRun(this.logger, this.startOptions);
-      instance.on('error', (e: any) => {
+      instance.on("error", (e: any) => {
         this.logger.error(
           `error '${e}', while running platforma, started opts: ${JSON.stringify(this.debugInfo())}`,
         );
@@ -61,7 +56,7 @@ export class LocalPl {
         if (this.onCloseAndErrorNoStop !== undefined && !this.wasStopped)
           void this.onCloseAndErrorNoStop(this);
       });
-      instance.on('close', () => {
+      instance.on("close", () => {
         this.logger.warn(`platforma was closed, started opts: ${JSON.stringify(this.debugInfo())}`);
 
         // keep in mind there are no awaits here, it will be asynchronous
@@ -71,11 +66,11 @@ export class LocalPl {
           void this.onCloseAndErrorNoStop(this);
       });
 
-      trace('started', true);
+      trace("started", true);
 
-      const pidFile = trace('pidFile', filePid(this.workingDir));
-      trace('pid', notEmpty(instance.pid));
-      trace('pidWritten', await writePid(pidFile, notEmpty(instance.pid)));
+      const pidFile = trace("pidFile", filePid(this.workingDir));
+      trace("pid", notEmpty(instance.pid));
+      trace("pidWritten", await writePid(pidFile, notEmpty(instance.pid)));
 
       this.nRuns++;
       this.instance = instance;
@@ -143,7 +138,7 @@ export type LocalPlOptions = {
   readonly onCloseAndErrorNoStop?: (pl: LocalPl) => Promise<void>;
 };
 
-export 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.
@@ -157,12 +152,12 @@ export async function localPlatformaInit(logger: MiLogger, _ops: LocalPlOptions)
   const ops = mergeDefaultOps(_ops, numCpu);
 
   return await withTrace(logger, async (trace, t) => {
-    trace('startOptions', { ...ops, config: 'too wordy' });
+    trace("startOptions", { ...ops, config: "too wordy" });
 
     const workDir = upath.resolve(ops.workingDir);
 
     if (ops.closeOld) {
-      trace('closeOld', await localPlatformaReadPidAndStop(logger, workDir));
+      trace("closeOld", await localPlatformaReadPidAndStop(logger, workDir));
     }
 
     const configPath = upath.join(workDir, LocalConfigYaml);
@@ -170,14 +165,14 @@ export async function localPlatformaInit(logger: MiLogger, _ops: LocalPlOptions)
     logger.info(`writing configuration '${configPath}'...`);
     await fsp.writeFile(configPath, ops.config);
 
-    const plBinPath = upath.join(workDir, 'binaries');
+    const plBinPath = upath.join(workDir, "binaries");
     const baseBinaryPath = await resolveLocalPlBinaryPath({
       logger,
       downloadDir: plBinPath,
       src: ops.plBinary,
       dispatcher: defaultHttpDispatcher(ops.proxy),
     });
-    const binaryPath = trace('binaryPath', upath.join('binaries', baseBinaryPath));
+    const binaryPath = trace("binaryPath", upath.join("binaries", baseBinaryPath));
 
     const env = { ...process.env };
 
@@ -185,7 +180,7 @@ export async function localPlatformaInit(logger: MiLogger, _ops: LocalPlOptions)
       const url = new URL(ops.proxy.url);
       if (ops.proxy.auth) {
         const parsed = parseHttpAuth(ops.proxy.auth);
-        if (parsed.scheme !== 'Basic') {
+        if (parsed.scheme !== "Basic") {
           throw new Error(`\
 Unsupported auth scheme: ${parsed.scheme}. \
 Only Basic auth is supported by the backend.`);
@@ -198,7 +193,7 @@ Only Basic auth is supported by the backend.`);
     }
 
     const processOpts = plProcessOps(binaryPath, configPath, ops, workDir, env);
-    trace('processOpts', {
+    trace("processOpts", {
       cmd: processOpts.cmd,
       args: processOpts.args,
       cwd: processOpts.opts.cwd,
@@ -227,18 +222,18 @@ async function localPlatformaReadPidAndStop(
   workingDir: string,
 ): Promise<Record<string, any>> {
   return await withTrace(logger, async (trace, t) => {
-    const file = trace('pidFilePath', filePid(workingDir));
+    const file = trace("pidFilePath", filePid(workingDir));
 
-    const oldPid = trace('pid', await readPid(file));
-    const alive = trace('wasAlive', await isProcessAlive(oldPid));
+    const oldPid = trace("pid", await readPid(file));
+    const alive = trace("wasAlive", await isProcessAlive(oldPid));
 
     if (oldPid !== undefined && alive) {
-      trace('stopped', processStop(oldPid));
+      trace("stopped", processStop(oldPid));
       try {
-        trace('waitStopped', await processWaitStopped(oldPid, 15_000)); // larger, that 10s we provide to backend in config.
-      } catch (_e) {
-        trace('forceStopped', processStop(oldPid, true));
-        trace('waitForceStopped', await processWaitStopped(oldPid, 5_000));
+        trace("waitStopped", await processWaitStopped(oldPid, 15_000)); // larger, that 10s we provide to backend in config.
+      } catch {
+        trace("forceStopped", processStop(oldPid, true));
+        trace("waitForceStopped", await processWaitStopped(oldPid, 5_000));
       }
     }
 
@@ -269,12 +264,12 @@ export function mergeDefaultOps(ops: LocalPlOptions, numCpu: number): LocalPlOpt
 
   if (ops.spawnOptions) {
     const withoutEnv = { ...ops.spawnOptions };
-    delete withoutEnv['env'];
+    delete withoutEnv["env"];
     result.spawnOptions = { ...result.spawnOptions, ...withoutEnv };
   }
 
   const withoutSpawnOps = { ...ops };
-  delete withoutSpawnOps['spawnOptions'];
+  delete withoutSpawnOps["spawnOptions"];
 
   return { ...result, ...withoutSpawnOps };
 }
@@ -290,11 +285,11 @@ export function plProcessOps(
 ): ProcessOptions {
   const result: ProcessOptions = {
     cmd: binaryPath,
-    args: ['--config', configPath],
+    args: ["--config", configPath],
     opts: {
       env: { ...defaultEnv },
       cwd: workDir,
-      stdio: ['pipe', 'ignore', 'inherit'],
+      stdio: ["pipe", "ignore", "inherit"],
       windowsHide: true, // hide a terminal on Windows
     },
   };
@@ -304,7 +299,7 @@ export function plProcessOps(
   }
 
   const withoutEnv = { ...ops.spawnOptions };
-  delete withoutEnv['env'];
+  delete withoutEnv["env"];
   result.opts = { ...result.opts, ...withoutEnv };
 
   return result;

package/src/local/process.ts

@@ -1,8 +1,8 @@
-import type { SpawnOptions, ChildProcess } from 'node:child_process';
-import { spawn } from 'node:child_process';
-import { execSync } from 'node:child_process';
-import type { MiLogger } from '@milaboratories/ts-helpers';
-import { sleep } from '@milaboratories/ts-helpers';
+import type { SpawnOptions, ChildProcess } from "node:child_process";
+import { spawn } from "node:child_process";
+import { execSync } from "node:child_process";
+import type { MiLogger } from "@milaboratories/ts-helpers";
+import { sleep } from "@milaboratories/ts-helpers";
 
 export type ProcessOptions = {
   cmd: string;
@@ -15,7 +15,7 @@ export function processRun(logger: MiLogger, opts: ProcessOptions): ChildProcess
 cmd: ${JSON.stringify([opts.cmd, ...opts.args])}
 wd: ${opts.opts.cwd}`);
 
-  logger.info('  spawning child process');
+  logger.info("  spawning child process");
   return spawn(opts.cmd, opts.args, opts.opts);
 }
 
@@ -26,47 +26,47 @@ export async function isProcessAlive(pid: number) {
 
     // Check we look at 'platforma' to not kill wrong process.
     const processName = getProcessName(pid);
-    if (process.platform === 'win32') {
-      return processName === 'platforma.exe'; // process name does not contain path to the file.
+    if (process.platform === "win32") {
+      return processName === "platforma.exe"; // process name does not contain path to the file.
     }
 
     // Linux and Mac OS X behave differently (so can different Linux distributions).
     // Process name can contain original path to the binary file or just its name.
-    return processName.endsWith('/platforma') || processName === 'platforma';
-  } catch (_e) {
+    return processName.endsWith("/platforma") || processName === "platforma";
+  } catch {
     return false;
   }
 }
 
 function getProcessName(pid: number): string {
   try {
-    if (process.platform === 'win32') {
+    if (process.platform === "win32") {
       // Windows: use tasklist command
-      const output = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: 'utf8' });
-      const lines = output.trim().split('\n');
-      if (lines.length > 0 && lines[0].includes(',')) {
-        const parts = lines[0].split(',');
+      const output = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: "utf8" });
+      const lines = output.trim().split("\n");
+      if (lines.length > 0 && lines[0].includes(",")) {
+        const parts = lines[0].split(",");
         if (parts.length >= 1) {
           // Remove quotes and get the executable name
-          const exeName = parts[0].replace(/^"|"$/g, '').trim();
+          const exeName = parts[0].replace(/^"|"$/g, "").trim();
           return exeName;
         }
       }
     } else {
       // Unix-like systems: use ps command
-      const output = execSync(`ps -p ${pid} -o comm=`, { encoding: 'utf8' });
+      const output = execSync(`ps -p ${pid} -o comm=`, { encoding: "utf8" });
       const processName = output.trim();
       return processName;
     }
-  } catch (_error) {
+  } catch {
     // If we can't get the process name, return empty string
-    return '';
+    return "";
   }
-  return '';
+  return "";
 }
 
 export function processStop(pid: number, force: boolean = false) {
-  return process.kill(pid, force ? 'SIGKILL' : 'SIGINT');
+  return process.kill(pid, force ? "SIGKILL" : "SIGINT");
 }
 
 export async function processWaitStopped(pid: number, maxMs: number) {

package/src/local/trace.ts

@@ -1,4 +1,4 @@
-import type { MiLogger } from '@milaboratories/ts-helpers';
+import type { MiLogger } from "@milaboratories/ts-helpers";
 
 /** Records all inputs and outputs of one's choice, so if the error happened
  * one can check how it was by just printing this structure. */

package/src/ssh/__tests__/common-utils.ts

@@ -1,33 +1,32 @@
-import type { StartedTestContainer } from 'testcontainers';
-import { GenericContainer } from 'testcontainers';
-import { readFileSync, existsSync } from 'node:fs';
-import path from 'node:path';
-import type { ConnectConfig } from 'ssh2';
-import fs from 'node:fs';
+import type { StartedTestContainer } from "testcontainers";
+import { GenericContainer } from "testcontainers";
+import { readFileSync, existsSync } from "node:fs";
+import path from "node:path";
+import type { ConnectConfig } from "ssh2";
+import fs from "node:fs";
 
 const SSH_PORT = [22, 3001];
 
-export const testAssetsPath = path.resolve(__dirname, '..', '..', '..', 'test-assets');
+export const testAssetsPath = path.resolve(__dirname, "..", "..", "..", "test-assets");
 
-const publicKeyPath = path.resolve(testAssetsPath, 'public-key.pem');
-const privateKeyPath = path.resolve(testAssetsPath, 'private-key.pem');
+const publicKeyPath = path.resolve(testAssetsPath, "public-key.pem");
+const privateKeyPath = path.resolve(testAssetsPath, "private-key.pem");
 if (!existsSync(publicKeyPath) || !existsSync(privateKeyPath)) {
-  console.error('SSH keys does not exist, see pl-deployments/README.md and regenerate them');
+  console.error("SSH keys does not exist, see pl-deployments/README.md and regenerate them");
   process.exit(1);
 }
 
 export function readPrivateKey(): string {
-  return readFileSync(privateKeyPath, { encoding: 'utf-8' });
+  return readFileSync(privateKeyPath, { encoding: "utf-8" });
 }
 
 export async function initContainer(name: string): Promise<StartedTestContainer> {
   const imageName = `pl-ssh-test-container-${name}:1.0.0`;
   const containerName = `pl-ssh-test-${name}`;
 
-  console.log('No worries, creating a new container');
+  console.log("No worries, creating a new container");
 
-  const container = await GenericContainer
-    .fromDockerfile(path.resolve(__dirname, '..', '..', '..'))
+  const container = await GenericContainer.fromDockerfile(path.resolve(__dirname, "..", "..", ".."))
     .withCache(true)
     .build(imageName, { deleteOnExit: false });
 
@@ -46,7 +45,7 @@ export function getContainerHostAndPort(container: StartedTestContainer) {
 }
 
 function logToFile(message: string) {
-  const logFileName = 'log.txt';
+  const logFileName = "log.txt";
   const logFilePath = path.join(testAssetsPath, logFileName);
 
   const timestamp = new Date().toISOString();
@@ -54,20 +53,23 @@ function logToFile(message: string) {
 
   fs.appendFile(logFilePath, logMessage, (err) => {
     if (err) {
-      console.error('Error writing to log file:', err);
+      console.error("Error writing to log file:", err);
     }
   });
 }
 
-export function getConnectionForSsh(container: StartedTestContainer, debug: boolean = false): ConnectConfig {
+export function getConnectionForSsh(
+  container: StartedTestContainer,
+  debug: boolean = false,
+): ConnectConfig {
   const hostData = getContainerHostAndPort(container);
   const privateKey = readPrivateKey();
   const config = {
     host: hostData.host,
     port: hostData.port,
-    username: 'pl-doctor',
+    username: "pl-doctor",
     privateKey: privateKey,
-    passphrase: 'password',
+    passphrase: "password",
     debug: debug ? logToFile : undefined,
   };
   logToFile(JSON.stringify(config, null, 4));