@milaboratories/pl-deployments 2.15.7 → 2.15.9

package/src/ssh/ssh_errors.test.ts

@@ -1,90 +1,90 @@
-import { describe, test, expect } from 'vitest';
-import { SFTPError, SSHError, SFTPUploadError } from './ssh_errors';
+import { describe, test, expect } from "vitest";
+import { SFTPError, SSHError, SFTPUploadError } from "./ssh_errors";
 
-test('error chain unwrapping works', () => {
-  const err = new Error('Failure');
-  const uploadErr = new SFTPUploadError(err, 'localPath', 'remotePath');
+test("error chain unwrapping works", () => {
+  const err = new Error("Failure");
+  const uploadErr = new SFTPUploadError(err, "localPath", "remotePath");
   const finalErr = new Error(`Problem: ${uploadErr.message}`, { cause: uploadErr });
 
   expect(SFTPUploadError.from(finalErr)).toBe(uploadErr);
   expect(SFTPError.from(finalErr)).toBeDefined();
   expect(SSHError.from(finalErr)).toBeDefined();
-})
+});
 
-describe('SSHError', () => {
-  test('should add prefix to error message', () => {
-    const err = new SSHError('Test error');
-    expect(err.message).toBe('SSHError: Test error');
+describe("SSHError", () => {
+  test("should add prefix to error message", () => {
+    const err = new SSHError("Test error");
+    expect(err.message).toBe("SSHError: Test error");
   });
 
-  test('should respect cause option', () => {
-    const cause = new Error('Cause error');
-    const err = new SSHError('Test error', { cause });
+  test("should respect cause option", () => {
+    const cause = new Error("Cause error");
+    const err = new SSHError("Test error", { cause });
     expect(err.cause).toBe(cause);
-  })
+  });
 
-  test('should preserve original error as cause', () => {
-    const cause = new Error('Cause error');
+  test("should preserve original error as cause", () => {
+    const cause = new Error("Cause error");
     const err = new SSHError(cause);
     expect(err.cause).toBe(cause);
-  })
+  });
 });
 
-describe('SFTPError.wrap()', () => {
-  test('should return undefined when err is undefined', () => {
+describe("SFTPError.wrap()", () => {
+  test("should return undefined when err is undefined", () => {
     const result = SFTPError.wrap(undefined);
     expect(result).toBeUndefined();
   });
 
-  test('should return the same error when err is already an SFTPError', () => {
-    const sftpErr = new SFTPError('Failure');
+  test("should return the same error when err is already an SFTPError", () => {
+    const sftpErr = new SFTPError("Failure");
     const result = SFTPError.wrap(sftpErr);
     expect(result).toBe(sftpErr);
   });
 
-  test('should wrap a regular Error in SFTPError', () => {
-    const regularErr = new Error('Some error message');
+  test("should wrap a regular Error in SFTPError", () => {
+    const regularErr = new Error("Some error message");
     const result = SFTPError.wrap(regularErr);
 
     expect(result).toBeInstanceOf(SFTPError);
     expect(result).not.toBe(regularErr);
-    expect(result?.code).toBe('Some error message');
+    expect(result?.code).toBe("Some error message");
     expect(result?.cause).toBe(regularErr);
   });
 
-  test('should return existing SFTPError when err has SFTPError in cause chain', () => {
-    const originalSftpErr = new SFTPError('Permission denied');
-    const wrappedErr = new Error('Outer error', { cause: originalSftpErr });
+  test("should return existing SFTPError when err has SFTPError in cause chain", () => {
+    const originalSftpErr = new SFTPError("Permission denied");
+    const wrappedErr = new Error("Outer error", { cause: originalSftpErr });
     const result = SFTPError.wrap(wrappedErr);
 
     expect(result).toBe(originalSftpErr);
   });
 
-  test('should wrap SSHError that is not SFTPError', () => {
-    const sshErr = new SSHError('SSH connection failed');
+  test("should wrap SSHError that is not SFTPError", () => {
+    const sshErr = new SSHError("SSH connection failed");
     const result = SFTPError.wrap(sshErr);
 
     expect(result).toBeInstanceOf(SFTPError);
     expect(result).not.toBe(sshErr);
-    expect(result?.code).toBe('SSHError: SSH connection failed');
+    expect(result?.code).toBe("SSHError: SSH connection failed");
     expect(result?.cause).toBe(sshErr);
   });
 
-  test('should wrap error with SFTPError deep in cause chain', () => {
-    const originalSftpErr = new SFTPError('File not found');
-    const intermediateErr1 = new Error('Intermediate 1', { cause: originalSftpErr });
-    const intermediateErr2 = new Error('Intermediate 2', { cause: intermediateErr1 });
-    const finalErr = new Error('Final error', { cause: intermediateErr2 });
+  test("should wrap error with SFTPError deep in cause chain", () => {
+    const originalSftpErr = new SFTPError("File not found");
+    const intermediateErr1 = new Error("Intermediate 1", { cause: originalSftpErr });
+    const intermediateErr2 = new Error("Intermediate 2", { cause: intermediateErr1 });
+    const finalErr = new Error("Final error", { cause: intermediateErr2 });
     const result = SFTPError.wrap(finalErr);
 
     expect(result).toBe(originalSftpErr);
   });
 
-  test('should preserve error message when wrapping', () => {
-    const err = new Error('Custom error message');
+  test("should preserve error message when wrapping", () => {
+    const err = new Error("Custom error message");
     const result = SFTPError.wrap(err);
 
-    expect(result?.code).toBe('Custom error message');
-    expect(result?.message).toContain('Custom error message');
+    expect(result?.code).toBe("Custom error message");
+    expect(result?.message).toContain("Custom error message");
   });
 });

package/src/ssh/ssh_errors.ts

@@ -1,9 +1,9 @@
-import { findNamedErrorInCauses } from '@milaboratories/ts-helpers';
+import { findNamedErrorInCauses } from "@milaboratories/ts-helpers";
 
 const MAX_UNWRAP_DEPTH = 10;
 
 export class SSHError extends Error {
-  name = 'SSHError';
+  name = "SSHError";
 
   constructor(message: string, opts?: { cause: Error });
   constructor(err: Error);
@@ -21,7 +21,7 @@ export class SSHError extends Error {
 }
 
 export class SFTPError extends SSHError {
-  name = 'SFTPError';
+  name = "SFTPError";
 
   constructor(
     public readonly code: string, // raw SFTP error code, i.e. from OpenSSH server
@@ -48,19 +48,21 @@ export class SFTPError extends SSHError {
     // OpenSSH server returns this message in case of general failure.
     // See https://github.com/openssh/openssh-portable/blob/1cc936b2fabffeac7fff14ca1070d7d7a317ab7b/sftp-server.c#L244
     // See https://github.com/openssh/openssh-portable/blob/1cc936b2fabffeac7fff14ca1070d7d7a317ab7b/sftp-common.c#L195
-    return this.code === 'Failure';
+    return this.code === "Failure";
   }
 }
 
 export class SFTPUploadError extends SSHError {
-  name = 'SFTPUploadError';
+  name = "SFTPUploadError";
 
   constructor(
     err: Error,
     public readonly localPath: string,
     public readonly remotePath: string,
   ) {
-    super(`ssh.uploadFile: ${err.message}, localPath: ${localPath}, remotePath: ${remotePath}`, { cause: SFTPError.wrap(err) });
+    super(`ssh.uploadFile: ${err.message}, localPath: ${localPath}, remotePath: ${remotePath}`, {
+      cause: SFTPError.wrap(err),
+    });
   }
 
   static from(err: unknown): SFTPUploadError | undefined {

package/src/ssh/supervisord.ts

@@ -1,26 +1,20 @@
 /** Provides helper functions to work with supervisord */
 
-import type { MiLogger } from '@milaboratories/ts-helpers';
-import * as plpath from './pl_paths';
-import type { SshClient, SshExecResult } from './ssh';
-import { randomBytes } from 'node:crypto';
+import type { MiLogger } from "@milaboratories/ts-helpers";
+import * as plpath from "./pl_paths";
+import type { SshClient, SshExecResult } from "./ssh";
+import { randomBytes } from "node:crypto";
 
-export async function supervisorCtlStart(
-  sshClient: SshClient,
-  remoteHome: string, arch: string,
-) {
-  const result = await supervisorExec(sshClient, remoteHome, arch, '--daemon');
+export async function supervisorCtlStart(sshClient: SshClient, remoteHome: string, arch: string) {
+  const result = await supervisorExec(sshClient, remoteHome, arch, "--daemon");
 
   if (result.stderr) {
     throw new Error(`Can not run ssh Platforma ${result.stderr}`);
   }
 }
 
-export async function supervisorStop(
-  sshClient: SshClient,
-  remoteHome: string, arch: string,
-) {
-  const result = await supervisorExec(sshClient, remoteHome, arch, 'ctl shutdown');
+export async function supervisorStop(sshClient: SshClient, remoteHome: string, arch: string) {
+  const result = await supervisorExec(sshClient, remoteHome, arch, "ctl shutdown");
 
   if (result.stderr) {
     throw new Error(`Can not stop ssh Platforma ${result.stderr}`);
@@ -51,23 +45,26 @@ export function isSupervisordRunning(status: SupervisorStatus) {
 export async function supervisorStatus(
   logger: MiLogger,
   sshClient: SshClient,
-  remoteHome: string, arch: string,
+  remoteHome: string,
+  arch: string,
 ): Promise<SupervisorStatus> {
   let result: SshExecResult;
   try {
-    result = await supervisorExec(sshClient, remoteHome, arch, 'ctl status');
+    result = await supervisorExec(sshClient, remoteHome, arch, "ctl status");
   } catch (e: unknown) {
     return { execError: String(e) };
   }
 
   if (result.stderr) {
-    logger.info(`supervisord ctl status: stderr occurred: ${result.stderr}, stdout: ${result.stdout}`);
+    logger.info(
+      `supervisord ctl status: stderr occurred: ${result.stderr}, stdout: ${result.stdout}`,
+    );
 
     return { rawResult: result };
   }
 
-  const platforma = isProgramRunning(result.stdout, 'platforma');
-  const minio = isProgramRunning(result.stdout, 'minio');
+  const platforma = isProgramRunning(result.stdout, "platforma");
+  const minio = isProgramRunning(result.stdout, "minio");
   const status: SupervisorStatus = {
     rawResult: result,
     platforma,
@@ -75,11 +72,11 @@ export async function supervisorStatus(
   };
 
   if (!status.minio) {
-    logger.warn('Minio is not running on the server');
+    logger.warn("Minio is not running on the server");
   }
 
   if (!status.platforma) {
-    logger.warn('Platforma is not running on the server');
+    logger.warn("Platforma is not running on the server");
   }
 
   return status;
@@ -94,7 +91,7 @@ export function generateSupervisordConfig(
   platformaConfigPath: string,
   plPath: string,
 ) {
-  const password = randomBytes(16).toString('hex');
+  const password = randomBytes(16).toString("hex");
   const freePort = supervisorRemotePort;
 
   return `
@@ -137,8 +134,10 @@ export function generateSupervisordConfigWithMinio(
   minioPath: string,
   plPath: string,
 ) {
-  const minioEnvStr = Object.entries(minioEnvs).map(([key, value]) => `${key}="${value}"`).join(',');
-  const password = randomBytes(16).toString('hex');
+  const minioEnvStr = Object.entries(minioEnvs)
+    .map(([key, value]) => `${key}="${value}"`)
+    .join(",");
+  const password = randomBytes(16).toString("hex");
   const freePort = supervisorRemotePort;
 
   return `
@@ -175,7 +174,8 @@ autorestart=true
 
 export async function supervisorExec(
   sshClient: SshClient,
-  remoteHome: string, arch: string,
+  remoteHome: string,
+  arch: string,
   command: string,
 ) {
   const supervisorCmd = plpath.supervisorBin(remoteHome, arch);
@@ -187,13 +187,13 @@ export async function supervisorExec(
 
 function isProgramRunning(output: string, programName: string) {
   // eslint-disable-next-line no-control-regex
-  const stripAnsi = (str: string) => str.replace(/\x1B\[[0-9;]*m/g, '');
+  const stripAnsi = (str: string) => str.replace(/\x1B\[[0-9;]*m/g, "");
 
   const cleanedOutput = stripAnsi(output);
 
-  return cleanedOutput.split('\n').some((line) => {
+  return cleanedOutput.split("\n").some((line) => {
     const [name, status] = line.trim().split(/\s{2,}/); // Split string by 2 spaces.
 
-    return name === programName && status === 'Running';
+    return name === programName && status === "Running";
   });
 }