@milaboratories/pl-deployments 2.15.7 → 2.15.9

package/dist/ssh/pl.js

@@ -15,7 +15,7 @@ class SshPl {
     logger;
     sshClient;
     username;
-    initState = { step: 'init' };
+    initState = { step: "init" };
     constructor(logger, sshClient, username) {
         this.logger = logger;
         this.sshClient = sshClient;
@@ -47,7 +47,7 @@ class SshPl {
         return await supervisorStatus(this.logger, this.sshClient, remoteHome, arch.arch);
     }
     /** Starts all the services on the server.
-      * Idempotent semantic: we could call it several times. */
+     * Idempotent semantic: we could call it several times. */
     async start(shouldUseMinio) {
         const arch = await this.getArch();
         const remoteHome = await this.getUserHomeDirectory();
@@ -60,7 +60,7 @@ class SshPl {
         }
         catch (e) {
             let msg = `SshPl.start: ${e}`;
-            let logs = '';
+            let logs = "";
             try {
                 logs = await this.sshClient.readFile(platformaCliLogs(remoteHome));
                 msg += `, platforma cli logs: ${logs}`;
@@ -73,7 +73,7 @@ class SshPl {
         }
     }
     /** Stops all the services on the server.
-      * Idempotent semantic: we could call it several times. */
+     * Idempotent semantic: we could call it several times. */
     async stop() {
         const arch = await this.getArch();
         const remoteHome = await this.getUserHomeDirectory();
@@ -110,7 +110,7 @@ class SshPl {
      * generates all the configs, creates necessary dirs,
      * and finally starts all the services. */
     async platformaInit(options) {
-        const state = { localWorkdir: options.localWorkdir, step: 'init' };
+        const state = { localWorkdir: options.localWorkdir, step: "init" };
         const { onProgress } = options;
         // merge options with default ops.
         const ops = {
@@ -123,12 +123,12 @@ class SshPl {
             await this.doStepDetectHome(state, onProgress);
             const needRestartPlatforma = await this.doStepReadExistedConfig(state, ops, onProgress);
             if (!needRestartPlatforma) {
-                await onProgress?.('Platforma is already running. Skipping initialization.');
+                await onProgress?.("Platforma is already running. Skipping initialization.");
                 return state.existedSettings;
             }
             await this.doStepStopExistedPlatforma(state, onProgress);
             await this.doStepCheckDbLock(state, onProgress);
-            await onProgress?.('Installation platforma...');
+            await onProgress?.("Installation platforma...");
             await this.doStepDownloadBinaries(state, onProgress, ops);
             await this.doStepFetchPorts(state);
             await this.doStepGenerateNewConfig(state, onProgress, ops);
@@ -145,33 +145,36 @@ class SshPl {
         }
     }
     async doStepStopExistedPlatforma(state, onProgress) {
-        state.step = 'stopExistedPlatforma';
+        state.step = "stopExistedPlatforma";
         if (!isAllAlive(state.alive, state.shouldUseMinio ?? false)) {
             return;
         }
-        await onProgress?.('Stopping services...');
+        await onProgress?.("Stopping services...");
         await this.stop();
     }
     removeSensitiveData(state) {
         const stateCopy = { ...state };
-        stateCopy.generatedConfig = { ...stateCopy.generatedConfig, filesToCreate: { skipped: 'sanitized' } };
+        stateCopy.generatedConfig = {
+            ...stateCopy.generatedConfig,
+            filesToCreate: { skipped: "sanitized" },
+        };
         return stateCopy;
     }
     async doStepStartPlatforma(state, onProgress) {
-        state.step = 'startPlatforma';
-        await onProgress?.('Starting Platforma on the server...');
+        state.step = "startPlatforma";
+        await onProgress?.("Starting Platforma on the server...");
         await this.start(state.shouldUseMinio ?? false);
         state.started = true;
         this.initState = state;
-        await onProgress?.('Platforma has been started successfully.');
+        await onProgress?.("Platforma has been started successfully.");
     }
     async doStepSaveNewConnectionInfo(state, onProgress, ops) {
-        state.step = 'saveNewConnectionInfo';
+        state.step = "saveNewConnectionInfo";
         const config = state.generatedConfig;
-        await onProgress?.('Saving connection information...');
+        await onProgress?.("Saving connection information...");
         state.connectionInfo = newConnectionInfo(config.plUser, config.plPassword, state.ports, notEmpty(ops.useGlobalAccess), ops.plBinary.version, state.shouldUseMinio ?? false);
         await this.sshClient.writeFileOnTheServer(connectionInfo(state.remoteHome), stringifyConnectionInfo(state.connectionInfo));
-        await onProgress?.('Connection information saved.');
+        await onProgress?.("Connection information saved.");
     }
     async doStepCheckDbLock(state, onProgress) {
         const removeLockFile = async (lockFilePath) => {
@@ -185,32 +188,32 @@ class SshPl {
                 throw new Error(msg);
             }
         };
-        state.step = 'checkDbLock';
-        await onProgress?.('Checking for DB lock...');
+        state.step = "checkDbLock";
+        await onProgress?.("Checking for DB lock...");
         const lockFilePath = platformaDbLock(state.remoteHome);
         const lockFileExists = await this.sshClient.checkFileExists(lockFilePath);
         if (!lockFileExists) {
-            await onProgress?.('No DB lock found. Proceeding...');
+            await onProgress?.("No DB lock found. Proceeding...");
             return;
         }
         this.logger.info(`DB lock file found at ${lockFilePath}. Checking which process holds it...`);
         const lockProcessInfo = await this.findLockHolder(lockFilePath);
         if (!lockProcessInfo) {
-            this.logger.warn('Lock file exists but no process is holding it. Removing stale lock file...');
+            this.logger.warn("Lock file exists but no process is holding it. Removing stale lock file...");
             await removeLockFile(lockFilePath);
             return;
         }
         this.logger.info(`Found process ${lockProcessInfo.pid} (user: ${lockProcessInfo.user}) holding DB lock`);
         if (lockProcessInfo.user !== this.username) {
-            const msg = `DB lock is held by process ${lockProcessInfo.pid} `
-                + `owned by user '${lockProcessInfo.user}', but current user is '${this.username}'. `
-                + 'Cannot kill process owned by different user.';
+            const msg = `DB lock is held by process ${lockProcessInfo.pid} ` +
+                `owned by user '${lockProcessInfo.user}', but current user is '${this.username}'. ` +
+                "Cannot kill process owned by different user.";
             this.logger.error(msg);
             throw new Error(msg);
         }
         this.logger.info(`Process ${lockProcessInfo.pid} belongs to current user ${this.username}. Killing it...`);
         await this.killRemoteProcess(lockProcessInfo.pid);
-        this.logger.info('Process holding DB lock has been terminated.');
+        this.logger.info("Process holding DB lock has been terminated.");
         // Verify lock file is gone or can be removed
         const lockStillExists = await this.sshClient.checkFileExists(lockFilePath);
         if (lockStillExists) {
@@ -218,8 +221,8 @@ class SshPl {
         }
     }
     async doStepConfigureSupervisord(state, onProgress) {
-        await onProgress?.('Writing supervisord configuration...');
-        state.step = 'configureSupervisord';
+        await onProgress?.("Writing supervisord configuration...");
+        state.step = "configureSupervisord";
         const config = state.generatedConfig;
         let supervisorConfig;
         if (state.shouldUseMinio) {
@@ -232,12 +235,12 @@ class SshPl {
         if (!writeResult) {
             throw new Error(`Can not write supervisord config on the server ${workDir(state.remoteHome)}`);
         }
-        await onProgress?.('Supervisord configuration written.');
+        await onProgress?.("Supervisord configuration written.");
     }
     async doStepCreateFoldersAndSaveFiles(state, onProgress) {
-        state.step = 'createFoldersAndSaveFiles';
+        state.step = "createFoldersAndSaveFiles";
         const config = state.generatedConfig;
-        await onProgress?.('Generating folder structure...');
+        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}`);
@@ -246,16 +249,16 @@ class SshPl {
             await this.sshClient.ensureRemoteDirCreated(dir);
             this.logger.info(`Created directory ${dir}`);
         }
-        await onProgress?.('Folder structure created.');
+        await onProgress?.("Folder structure created.");
     }
     async doStepGenerateNewConfig(state, onProgress, ops) {
-        state.step = 'generateNewConfig';
-        await onProgress?.('Generating new config...');
+        state.step = "generateNewConfig";
+        await onProgress?.("Generating new config...");
         const config = await generateSshPlConfigs({
             logger: this.logger,
             workingDir: workDir(state.remoteHome),
             portsMode: {
-                type: 'customWithMinio',
+                type: "customWithMinio",
                 ports: {
                     debug: state.ports.debug.remote,
                     grpc: state.ports.grpc.remote,
@@ -274,51 +277,51 @@ class SshPl {
             useMinio: state.shouldUseMinio ?? false,
         });
         state.generatedConfig = { ...config };
-        await onProgress?.('New config generated');
+        await onProgress?.("New config generated");
     }
     async doStepFetchPorts(state) {
-        state.step = 'fetchPorts';
+        state.step = "fetchPorts";
         state.ports = await this.fetchPorts(state.remoteHome, state.arch);
-        if (!state.ports.debug.remote
-            || !state.ports.grpc.remote
-            || !state.ports.minioPort.remote
-            || !state.ports.minioConsolePort.remote
-            || !state.ports.monitoring.remote
-            || !state.ports.http?.remote) {
+        if (!state.ports.debug.remote ||
+            !state.ports.grpc.remote ||
+            !state.ports.minioPort.remote ||
+            !state.ports.minioConsolePort.remote ||
+            !state.ports.monitoring.remote ||
+            !state.ports.http?.remote) {
             throw new Error(`SshPl.platformaInit: remote ports are not defined`);
         }
     }
     async doStepDownloadBinaries(state, onProgress, ops) {
-        state.step = 'downloadBinaries';
-        await onProgress?.('Downloading and uploading required binaries...');
+        state.step = "downloadBinaries";
+        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, state.shouldUseMinio ?? false, ops.proxy);
-        await onProgress?.('All required binaries have been downloaded and uploaded.');
+        await onProgress?.("All required binaries have been downloaded and uploaded.");
         state.binPaths = { ...downloadRes, history: undefined };
         state.downloadedBinaries = downloadRes.history;
     }
     async doStepDetectArch(state, onProgress) {
-        state.step = 'detectArch';
-        await onProgress?.('Detecting server architecture...');
+        state.step = "detectArch";
+        await onProgress?.("Detecting server architecture...");
         state.arch = await this.getArch();
-        await onProgress?.('Server architecture detected.');
+        await onProgress?.("Server architecture detected.");
     }
     async doStepDetectHome(state, onProgress) {
-        state.step = 'detectHome';
-        await onProgress?.('Fetching user home directory...');
+        state.step = "detectHome";
+        await onProgress?.("Fetching user home directory...");
         state.remoteHome = await this.getUserHomeDirectory();
-        await onProgress?.('User home directory retrieved.');
+        await onProgress?.("User home directory retrieved.");
     }
     async doStepReadExistedConfig(state, ops, onProgress) {
-        state.step = 'checkAlive';
-        await onProgress?.('Checking platform status...');
+        state.step = "checkAlive";
+        await onProgress?.("Checking platform status...");
         state.alive = await this.isAlive();
         if (!state.alive?.platforma) {
             return true;
         }
-        await onProgress?.('All required services are running.');
+        await onProgress?.("All required services are running.");
         state.existedSettings = await this.readExistedConfig(state.remoteHome);
         if (!state.existedSettings) {
             throw new Error(`SshPl.platformaInit: platforma is alive but existed settings are not found`);
@@ -335,10 +338,10 @@ class SshPl {
             this.logger.info(`SshPl.platformaInit: minio is not used`);
         }
         if (!state.needRestart) {
-            await onProgress?.('Server setup completed.');
+            await onProgress?.("Server setup completed.");
             return false;
         }
-        await onProgress?.('Stopping services...');
+        await onProgress?.("Stopping services...");
         await this.stop();
         return true;
     }
@@ -346,13 +349,13 @@ class SshPl {
         const state = [];
         const dispatcher = defaultHttpDispatcher(proxy);
         try {
-            const pl = await this.downloadAndUntar(localWorkdir, remoteHome, arch, 'pl', `pl-${plBinary.version}`, dispatcher);
+            const pl = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "pl", `pl-${plBinary.version}`, dispatcher);
             state.push(pl);
-            const supervisor = await this.downloadAndUntar(localWorkdir, remoteHome, arch, 'supervisord', supervisordDirName, dispatcher);
+            const supervisor = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "supervisord", supervisordDirName, dispatcher);
             state.push(supervisor);
             const minioPath = minioBin(remoteHome, arch.arch);
             if (shouldUseMinio) {
-                const minio = await this.downloadAndUntar(localWorkdir, remoteHome, arch, 'minio', minioDirName, dispatcher);
+                const minio = await this.downloadAndUntar(localWorkdir, remoteHome, arch, "minio", minioDirName, dispatcher);
                 state.push(minio);
                 await this.sshClient.chmod(minioPath, 0o750);
             }
@@ -381,7 +384,7 @@ class SshPl {
             // Example:
             // COMMAND     PID    USER   FD   TYPE DEVICE SIZE/OFF     NODE NAME
             // platforma 11628 rfiskov   10u   REG   1,16        0 66670038 ./LOCK
-            const lines = output.split('\n');
+            const lines = output.split("\n");
             if (lines.length <= 1) {
                 return null;
             }
@@ -461,11 +464,11 @@ class SshPl {
         }
     }
     /** We have to extract pl in the remote server,
-    * because Windows doesn't support symlinks
-    * that are found in Linux pl binaries tgz archive.
-    * For this reason, we extract all to the remote server.
-    * It requires `tar` to be installed on the server
-    * (it's not installed for Rocky Linux for example). */
+     * because Windows doesn't support symlinks
+     * that are found in Linux pl binaries tgz archive.
+     * For this reason, we extract all to the remote server.
+     * It requires `tar` to be installed on the server
+     * (it's not installed for Rocky Linux for example). */
     async downloadAndUntar(localWorkdir, remoteHome, arch, softwareName, tgzName, dispatcher) {
         const state = {};
         state.binBasePath = binariesDir(remoteHome);
@@ -496,14 +499,14 @@ class SshPl {
         state.downloadResult = notEmpty(downloadBinaryResult);
         state.localArchivePath = upath.resolve(state.downloadResult.archivePath);
         state.remoteDir = upath.join(state.binBasePath, state.downloadResult.baseName);
-        state.remoteArchivePath = state.remoteDir + '.tgz';
+        state.remoteArchivePath = state.remoteDir + ".tgz";
         await this.sshClient.ensureRemoteDirCreated(state.remoteDir);
         await this.sshClient.uploadFile(state.localArchivePath, state.remoteArchivePath);
         state.uploadDone = true;
         try {
-            await this.sshClient.exec('hash tar');
+            await this.sshClient.exec("hash tar");
         }
-        catch (_) {
+        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
@@ -517,9 +520,9 @@ class SshPl {
         const checkPathSupervisor = supervisorBin(remoteHome, arch.arch);
         const checkPathMinio = minioDir(remoteHome, arch.arch);
         const checkPathPlatforma = platformaBin(remoteHome, arch.arch);
-        if (!await this.sshClient.checkFileExists(checkPathPlatforma)
-            || !await this.sshClient.checkFileExists(checkPathMinio)
-            || !await this.sshClient.checkFileExists(checkPathSupervisor)) {
+        if (!(await this.sshClient.checkFileExists(checkPathPlatforma)) ||
+            !(await this.sshClient.checkFileExists(checkPathMinio)) ||
+            !(await this.sshClient.checkFileExists(checkPathSupervisor))) {
             return true;
         }
         return false;
@@ -532,7 +535,7 @@ class SshPl {
             await sleep(interval);
             total += interval;
             if (total > maxMs) {
-                throw new Error(`isAliveWithInterval: The process did not ${shouldStart ? 'started' : 'stopped'} after ${maxMs} ms. Live status: ${JSON.stringify(alive)}`);
+                throw new Error(`isAliveWithInterval: The process did not ${shouldStart ? "started" : "stopped"} after ${maxMs} ms. Live status: ${JSON.stringify(alive)}`);
             }
             alive = await this.isAlive();
         }
@@ -588,17 +591,17 @@ class SshPl {
         return +stdout;
     }
     async getArch() {
-        const { stdout, stderr } = await this.sshClient.exec('uname -s && uname -m');
+        const { stdout, stderr } = await this.sshClient.exec("uname -s && uname -m");
         if (stderr)
             throw new Error(`getArch: stderr is not empty: ${stderr}, stdout: ${stdout}`);
-        const arr = stdout.split('\n');
+        const arr = stdout.split("\n");
         return {
             platform: arr[0],
             arch: arr[1],
         };
     }
     async getUserHomeDirectory() {
-        const { stdout, stderr } = await this.sshClient.exec('echo $HOME');
+        const { stdout, stderr } = await this.sshClient.exec("echo $HOME");
         if (stderr) {
             const home = `/home/${this.username}`;
             console.warn(`getUserHomeDirectory: stderr is not empty: ${stderr}, stdout: ${stdout}, will get a default home: ${home}`);
@@ -610,7 +613,7 @@ class SshPl {
 const defaultSshPlConfig = {
     useGlobalAccess: false,
     plBinary: {
-        type: 'Download',
+        type: "Download",
         version: getDefaultPlVersion(),
     },
 };
@@ -621,7 +624,7 @@ const defaultSshPlConfig = {
  */
 async function getGlibcVersion(logger, sshClient) {
     try {
-        const { stdout, stderr } = await sshClient.exec('ldd --version | head -n 1');
+        const { stdout, stderr } = await sshClient.exec("ldd --version | head -n 1");
         if (stderr) {
             throw new Error(`Failed to check glibc version: ${stderr}`);
         }