@milaboratories/pl-deployments 1.2.2 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-deployments",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "pl-version": "1.24.0",
   "description": "MiLaboratories Platforma Backend code service run wrapper",
   "types": "./dist/index.d.ts",
@@ -29,11 +29,11 @@
     "@types/jest": "^29.5.14",
     "@types/node": "~20.16.15",
     "@types/ssh2": "^1.15.1",
-    "eslint": "^9.16.0",
+    "eslint": "^9.21.0",
     "jest": "^29.7.0",
     "prettier": "^3.4.1",
-    "testcontainers": "^10.16.0",
-    "ts-jest": "^29.2.5",
+    "testcontainers": "^10.18.0",
+    "ts-jest": "^29.2.6",
     "tsconfig-paths": "^4.2.0",
     "typescript": "~5.5.4",
     "utility-types": "^3.11.0",
@@ -47,11 +47,11 @@
     "upath": "^2.0.1",
     "ssh2": "^1.16.0",
     "tar": "^7.4.3",
-    "undici": "~7.2.3",
+    "undici": "~7.4.0",
     "yaml": "^2.6.1",
     "zod": "~3.23.8",
-    "@milaboratories/ts-helpers": "^1.1.4",
-    "@milaboratories/pl-config": "^1.4.3"
+    "@milaboratories/pl-config": "^1.4.3",
+    "@milaboratories/ts-helpers": "^1.1.4"
   },
   "scripts": {
     "type-check": "tsc --noEmit --composite false",

package/src/common/pl_binary_download.ts

@@ -153,7 +153,7 @@ export async function downloadArchive(
 
     return state;
   } catch (e: unknown) {
-    const msg = `downloadArchive: error ${JSON.stringify(e)} occurred, state: ${JSON.stringify(state)}`;
+    const msg = `downloadArchive: ${JSON.stringify(e)}, state: ${JSON.stringify(state)}`;
     logger.error(msg);
     throw new Error(msg);
   }

package/src/ssh/__tests__/ssh-docker.test.ts

@@ -220,7 +220,7 @@ describe('sshConnect', () => {
   });
 
   it('should timeout if the server is unreachable', async () => {
-    await expect(SshClient.init(new ConsoleLoggerAdapter(), { ...getConnectionForSsh(testContainer), port: 3233 })).rejects.toThrow('ssh.connect: error occurred: AggregateError');
+    await expect(SshClient.init(new ConsoleLoggerAdapter(), { ...getConnectionForSsh(testContainer), port: 3233 })).rejects.toThrow('ssh.connect: AggregateError');
   });
 });
 

package/src/ssh/pl.test.ts

@@ -0,0 +1,26 @@
+import { parseGlibcVersion } from './pl';
+import { describe, it, expect } from 'vitest';
+
+describe('parseGlibcVersion', () => {
+  it('correctly parses glibc version from ldd output', () => {
+    // Standard GNU libc outputs
+    expect(parseGlibcVersion('ldd (GNU libc) 2.28')).toBe(2.28);
+    expect(parseGlibcVersion('ldd (GNU libc) 2.39')).toBe(2.39);
+
+    // Ubuntu-style output
+    expect(parseGlibcVersion('ldd (Ubuntu GLIBC 2.31-0ubuntu9.9) 2.31')).toBe(2.31);
+
+    // Debian-style output
+    expect(parseGlibcVersion('ldd (Debian GLIBC 2.28-10) 2.28')).toBe(2.28);
+
+    // Different formatting with extra text
+    expect(parseGlibcVersion('ldd version 2.35, Copyright (C) 2022 Free Software Foundation, Inc.')).toBe(2.35);
+  });
+
+  it('throws error when glibc version cannot be parsed', () => {
+    // Invalid outputs
+    expect(() => parseGlibcVersion('ldd: command not found')).toThrow();
+    expect(() => parseGlibcVersion('some random output')).toThrow();
+    expect(() => parseGlibcVersion('')).toThrow();
+  });
+});

package/src/ssh/pl.ts

@@ -9,7 +9,7 @@ import * as plpath from './pl_paths';
 import { getDefaultPlVersion } from '../common/pl_version';
 
 import net from 'net';
-import type { PlLicenseMode, SshPlConfigGenerationResult } from '@milaboratories/pl-config';
+import type { PlConfig, PlLicenseMode, SshPlConfigGenerationResult } from '@milaboratories/pl-config';
 import { generateSshPlConfigs, getFreePort } from '@milaboratories/pl-config';
 import type { SupervisorStatus } from './supervisord';
 import { supervisorStatus, supervisorStop as supervisorCtlShutdown, generateSupervisordConfig, supervisorCtlStart } from './supervisord';
@@ -17,6 +17,8 @@ import type { ConnectionInfo, SshPlPorts } from './connection_info';
 import { newConnectionInfo, parseConnectionInfo, stringifyConnectionInfo } from './connection_info';
 import type { PlBinarySourceDownload } from '../common/pl_binary';
 
+const minRequiredGlibcVersion = 2.28;
+
 export class SshPl {
   private initState: PlatformaInitState = {};
   constructor(
@@ -67,7 +69,7 @@ export class SshPl {
         return await this.checkIsAliveWithInterval();
       }
     } catch (e: unknown) {
-      const msg = `SshPl.start: error occurred ${e}`;
+      const msg = `SshPl.start: ${e}`;
       this.logger.error(msg);
       throw new Error(msg);
     }
@@ -85,7 +87,7 @@ export class SshPl {
         return await this.checkIsAliveWithInterval(undefined, undefined, false);
       }
     } catch (e: unknown) {
-      const msg = `PlSsh.stop: error occurred ${e}`;
+      const msg = `PlSsh.stop: ${e}`;
       this.logger.error(msg);
       throw new Error(msg);
     }
@@ -115,6 +117,8 @@ export class SshPl {
   public async platformaInit(options: SshPlConfig): Promise<ConnectionInfo> {
     const state: PlatformaInitState = { localWorkdir: options.localWorkdir };
 
+    const { onProgress } = options;
+
     try {
       // merge options with default ops.
       const ops: SshPlConfig = {
@@ -122,10 +126,22 @@ export class SshPl {
         ...options,
       };
       state.plBinaryOps = ops.plBinary;
+
+      await onProgress?.('Detecting server architecture...');
       state.arch = await this.getArch();
+      await onProgress?.('Server architecture detected.');
+
+      await onProgress?.('Fetching user home directory...');
       state.remoteHome = await this.getUserHomeDirectory();
+      await onProgress?.('User home directory retrieved.');
+
+      await onProgress?.('Checking platform status...');
       state.alive = await this.isAlive();
 
+      if (state.alive.allAlive) {
+        await onProgress?.('All required services are running.');
+      }
+
       if (state.alive.allAlive) {
         state.userCredentials = await this.getUserCredentials(state.remoteHome);
         if (!state.userCredentials) {
@@ -136,15 +152,26 @@ export class SshPl {
         state.needRestart = !(sameGA && samePlVersion);
         this.logger.info(`SshPl.platformaInit: need restart? ${state.needRestart}`);
 
-        if (!state.needRestart)
+        if (!state.needRestart) {
+          await onProgress?.('Server setup completed.');
           return state.userCredentials;
+        }
 
+        await onProgress?.('Stopping services...');
         await this.stop();
       }
 
+      await onProgress?.('Downloading and uploading required binaries...');
+
+      const glibcVersion = await getGlibcVersion(this.logger, this.sshClient);
+      if (glibcVersion < minRequiredGlibcVersion)
+        throw new Error(`glibc version ${glibcVersion} is too old. Version ${minRequiredGlibcVersion} or higher is required for Platforma.`);
+
       const downloadRes = await this.downloadBinariesAndUploadToTheServer(
         ops.localWorkdir, ops.plBinary!, state.remoteHome, state.arch,
       );
+      await onProgress?.('All required binaries have been downloaded and uploaded.');
+
       state.binPaths = { ...downloadRes, history: undefined };
       state.downloadedBinaries = downloadRes.history;
 
@@ -154,6 +181,7 @@ export class SshPl {
         throw new Error(`SshPl.platformaInit: remote ports are not defined`);
       }
 
+      await onProgress?.('Generating server configuration...');
       const config = await generateSshPlConfigs({
         logger: this.logger,
         workingDir: plpath.workDir(state.remoteHome),
@@ -172,9 +200,13 @@ export class SshPl {
         },
         licenseMode: ops.license,
         useGlobalAccess: notEmpty(ops.useGlobalAccess),
+        plConfigPostprocessing: ops.plConfigPostprocessing,
       });
       state.generatedConfig = { ...config, filesToCreate: { skipped: 'it is too wordy' } };
 
+      await onProgress?.('Server configuration generated.');
+
+      await onProgress?.('Generating folder structure...');
       for (const [filePath, content] of Object.entries(config.filesToCreate)) {
         await this.sshClient.writeFileOnTheServer(filePath, content);
         this.logger.info(`Created file ${filePath}`);
@@ -184,7 +216,9 @@ export class SshPl {
         await this.sshClient.ensureRemoteDirCreated(dir);
         this.logger.info(`Created directory ${dir}`);
       }
+      await onProgress?.('Folder structure created.');
 
+      await onProgress?.('Writing supervisord configuration...');
       const supervisorConfig = generateSupervisordConfig(
         config.minioConfig.storageDir,
         config.minioConfig.envs,
@@ -199,7 +233,9 @@ export class SshPl {
       if (!writeResult) {
         throw new Error(`Can not write supervisord config on the server ${plpath.workDir(state.remoteHome)}`);
       }
+      await onProgress?.('Supervisord configuration written.');
 
+      await onProgress?.('Saving connection information...');
       state.connectionInfo = newConnectionInfo(
         config.plUser,
         config.plPassword,
@@ -211,14 +247,18 @@ export class SshPl {
         plpath.connectionInfo(state.remoteHome),
         stringifyConnectionInfo(state.connectionInfo),
       );
+      await onProgress?.('Connection information saved.');
 
+      await onProgress?.('Starting Platforma on the server...');
       await this.start();
       state.started = true;
       this.initState = state;
 
+      await onProgress?.('Platforma has been started successfully.');
+
       return state.connectionInfo;
     } catch (e: unknown) {
-      const msg = `SshPl.platformaInit: error occurred: ${e}, state: ${JSON.stringify(state)}`;
+      const msg = `SshPl.platformaInit: ${e}, state: ${JSON.stringify(state)}`;
       this.logger.error(msg);
 
       throw new Error(msg);
@@ -259,7 +299,7 @@ export class SshPl {
         downloadedPl: plpath.platformaBin(remoteHome, arch.arch),
       };
     } catch (e: unknown) {
-      const msg = `SshPl.downloadBinariesAndUploadToServer: error ${e} occurred, state: ${JSON.stringify(state)}`;
+      const msg = `SshPl.downloadBinariesAndUploadToServer: ${e}, state: ${JSON.stringify(state)}`;
       this.logger.error(msg);
       throw e;
     }
@@ -312,13 +352,19 @@ export class SshPl {
     await this.sshClient.uploadFile(state.localArchivePath, state.remoteArchivePath);
     state.uploadDone = true;
 
+    try {
+      await this.sshClient.exec('hash tar');
+    } catch (_) {
+      throw new Error(`tar is not installed on the server. Please install it before running Platforma.`);
+    }
+
     // TODO: Create a proper archive to avoid xattr warnings
     const untarResult = await this.sshClient.exec(
       `tar --warning=no-all -xvf ${state.remoteArchivePath} --directory=${state.remoteDir}`,
     );
 
     if (untarResult.stderr)
-      throw Error(`downloadAndUntar: untar: stderr occurred: ${untarResult.stderr}, stdout: ${untarResult.stdout}`);
+      throw new Error(`downloadAndUntar: untar: stderr occurred: ${untarResult.stderr}, stdout: ${untarResult.stdout}`);
 
     state.untarDone = true;
 
@@ -441,6 +487,10 @@ export type SshPlConfig = {
   license: PlLicenseMode;
   useGlobalAccess?: boolean;
   plBinary?: PlBinarySourceDownload;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  onProgress?: (...args: any) => Promise<any>;
+  plConfigPostprocessing?: (config: PlConfig) => PlConfig;
 };
 
 const defaultSshPlConfig: Pick<
@@ -489,3 +539,30 @@ type PlatformaInitState = {
   connectionInfo?: ConnectionInfo;
   started?: boolean;
 };
+
+/**
+ * Gets the glibc version on the remote system
+ * @returns The glibc version as a number
+ * @throws Error if version cannot be determined
+ */
+async function getGlibcVersion(logger: MiLogger, sshClient: SshClient): Promise <number> {
+  try {
+    const { stdout, stderr } = await sshClient.exec('ldd --version | head -n 1');
+    if (stderr) {
+      throw new Error(`Failed to check glibc version: ${stderr}`);
+    }
+    return parseGlibcVersion(stdout);
+  } catch (e: unknown) {
+    logger.error(`glibc version check failed: ${e}`);
+    throw e;
+  }
+}
+
+export function parseGlibcVersion(output: string): number {
+  const versionMatch = output.match(/\d+\.\d+/);
+  if (!versionMatch) {
+    throw new Error(`Could not parse glibc version from: ${output}`);
+  }
+
+  return parseFloat(versionMatch[0]);
+}

package/src/ssh/ssh.ts

@@ -79,7 +79,7 @@ export class SshClient {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       this.client.exec(command, (err: any, stream: ClientChannel) => {
         if (err) {
-          return reject(`ssh.exec: ${command}, error occurred: ${err}`);
+          return reject(`ssh.exec: ${command}: ${err}`);
         }
 
         let stdout = '';
@@ -89,7 +89,7 @@ export class SshClient {
           if (code === 0) {
             resolve({ stdout, stderr });
           } else {
-            reject(new Error(`Command ${command} exited with code ${code}`));
+            reject(new Error(`Command ${command} exited with code ${code}, stdout: ${stdout}, stderr: ${stderr}`));
           }
         }).on('data', (data: ArrayBuffer) => {
           stdout += data.toString();
@@ -419,7 +419,7 @@ export class SshClient {
       return new Promise((resolve, reject) => {
         sftp.readFile(remotePath, (err, buffer) => {
           if (err) {
-            return reject(new Error(`ssh.readFile: err occurred ${err}`));
+            return reject(new Error(`ssh.readFile: ${err}`));
           }
           resolve(buffer.toString());
         });
@@ -495,7 +495,7 @@ export class SshClient {
             resolve(undefined);
           })
           .catch((err) => {
-            const msg = `uploadFileUsingExistingSftp: error ${err} occurred`;
+            const msg = `uploadFileUsingExistingSftp: ${err}`;
             this.logger.error(msg);
             reject(new Error(msg));
           });
@@ -666,7 +666,7 @@ async function connect(
 
     client.on('error', (err: unknown) => {
       onError(err);
-      reject(new Error(`ssh.connect: error occurred: ${err}`));
+      reject(new Error(`ssh.connect: ${err}`));
     });
 
     client.on('close', () => {