@milaboratories/pl-deployments 2.4.6 → 2.4.8

package/dist/local/trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.js","sources":["../../src/local/trace.ts"],"sourcesContent":["import type { MiLogger } from '@milaboratories/ts-helpers';\n\n/** Records all inputs and outputs of one's choice, so if the error happened\n * one can check how it was by just printing this structure. */\nexport type Trace = Record<string, any>;\n\nexport function newTrace(): Trace {\n  return {};\n}\n\nexport function trace(t: Trace, k: string, v: any) {\n  t[k] = v;\n  return v;\n}\n\n/** Creates a trace and runs a function with it. The function can record all its\n * logs or traces using `trace` fn. */\nexport async function withTrace<T>(\n  logger: MiLogger,\n  fn: (trace: (k: string, v: any) => typeof v, t: Trace) => Promise<T>,\n): Promise<T> {\n  const t = newTrace();\n  try {\n    const result = await fn((k: string, v: any) => trace(t, k, v), t);\n    return result;\n  } catch (e: any) {\n    logger.error(`error ${e} while doing traced operation, state: ${JSON.stringify(t)}`);\n    throw e;\n  }\n}\n"],"names":[],"mappings":"SAMgB,QAAQ,GAAA;AACtB,IAAA,OAAO,EAAE;AACX;SAEgB,KAAK,CAAC,CAAQ,EAAE,CAAS,EAAE,CAAM,EAAA;AAC/C,IAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACR,IAAA,OAAO,CAAC;AACV;AAEA;AACsC;AAC/B,eAAe,SAAS,CAC7B,MAAgB,EAChB,EAAoE,EAAA;AAEpE,IAAA,MAAM,CAAC,GAAG,QAAQ,EAAE;AACpB,IAAA,IAAI;QACF,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,CAAS,EAAE,CAAM,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACjE,QAAA,OAAO,MAAM;IACf;IAAE,OAAO,CAAM,EAAE;AACf,QAAA,MAAM,CAAC,KAAK,CAAC,CAAA,MAAA,EAAS,CAAC,CAAA,sCAAA,EAAyC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA,CAAE,CAAC;AACpF,QAAA,MAAM,CAAC;IACT;AACF;;;;"}

package/dist/package.json.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var packageJson = {
+	"pl-version": "1.35.2"};
+
+module.exports = packageJson;
+//# sourceMappingURL=package.json.cjs.map

package/dist/package.json.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.json.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/package.json.js

@@ -0,0 +1,5 @@
+var packageJson = {
+	"pl-version": "1.35.2"};
+
+export { packageJson as default };
+//# sourceMappingURL=package.json.js.map

package/dist/package.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

package/dist/ssh/__tests__/common-utils.d.ts

@@ -9,4 +9,3 @@ export declare function getContainerHostAndPort(container: StartedTestContainer)
 };
 export declare function getConnectionForSsh(container: StartedTestContainer, debug?: boolean): ConnectConfig;
 export declare function cleanUp(container: StartedTestContainer): Promise<void>;
-//# sourceMappingURL=common-utils.d.ts.map

package/dist/ssh/connection_info.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+var zod = require('zod');
+
+/** We store all info about the connection on the server,
+ * so that another client could read the file and connect from another machine. */
+//
+// Types
+//
+const PortPair = zod.z.object({
+    local: zod.z.number(),
+    remote: zod.z.number(),
+});
+const SshPlPorts = zod.z.object({
+    grpc: PortPair,
+    http: PortPair.optional(),
+    monitoring: PortPair,
+    debug: PortPair,
+    /** @deprecated */
+    minioPort: PortPair,
+    /** @deprecated */
+    minioConsolePort: PortPair,
+});
+const ConnectionInfo = zod.z.object({
+    plUser: zod.z.string(),
+    plPassword: zod.z.string(),
+    ports: SshPlPorts,
+    // It's false by default because it was added later,
+    // and in some deployments there won't be useGlobalAccess flag in the file.
+    useGlobalAccess: zod.z.boolean().default(false),
+    // We added the field afterwards, the pl backend was this version.
+    plVersion: zod.z.string().default('1.18.3'),
+    // It's true by default because it was added later and previous installation use minio.
+    minioIsUsed: zod.z.boolean().default(true),
+});
+//
+// Funcs
+//
+function newConnectionInfo(plUser, plPassword, ports, useGlobalAccess, plVersion, minioIsUsed) {
+    return {
+        plUser,
+        plPassword,
+        ports,
+        useGlobalAccess,
+        plVersion,
+        minioIsUsed: minioIsUsed,
+    };
+}
+function parseConnectionInfo(content) {
+    return ConnectionInfo.parse(JSON.parse(content));
+}
+function stringifyConnectionInfo(conn) {
+    return JSON.stringify(conn, undefined, 2);
+}
+
+exports.ConnectionInfo = ConnectionInfo;
+exports.PortPair = PortPair;
+exports.SshPlPorts = SshPlPorts;
+exports.newConnectionInfo = newConnectionInfo;
+exports.parseConnectionInfo = parseConnectionInfo;
+exports.stringifyConnectionInfo = stringifyConnectionInfo;
+//# sourceMappingURL=connection_info.cjs.map

package/dist/ssh/connection_info.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection_info.cjs","sources":["../../src/ssh/connection_info.ts"],"sourcesContent":["/** We store all info about the connection on the server,\n * so that another client could read the file and connect from another machine. */\nimport { z } from 'zod';\n\n//\n// Types\n//\n\nexport const PortPair = z.object({\n  local: z.number(),\n  remote: z.number(),\n});\n/** The pair of ports for forwarding. */\nexport type PortPair = z.infer<typeof PortPair>;\n\nexport const SshPlPorts = z.object({\n  grpc: PortPair,\n  http: PortPair.optional(),\n  monitoring: PortPair,\n  debug: PortPair,\n  /** @deprecated */\n  minioPort: PortPair,\n  /** @deprecated */\n  minioConsolePort: PortPair,\n});\n/** All info about ports that are forwarded. */\nexport type SshPlPorts = z.infer<typeof SshPlPorts>;\n\nexport const ConnectionInfo = z.object({\n  plUser: z.string(),\n  plPassword: z.string(),\n  ports: SshPlPorts,\n\n  // It's false by default because it was added later,\n  // and in some deployments there won't be useGlobalAccess flag in the file.\n  useGlobalAccess: z.boolean().default(false),\n\n  // We added the field afterwards, the pl backend was this version.\n  plVersion: z.string().default('1.18.3'),\n\n  // It's true by default because it was added later and previous installation use minio.\n  minioIsUsed: z.boolean().default(true),\n});\n/** The content of the file that holds all the info about the connection on the remote server. */\nexport type ConnectionInfo = z.infer<typeof ConnectionInfo>;\n\n//\n// Funcs\n//\n\nexport function newConnectionInfo(\n  plUser: string,\n  plPassword: string,\n  ports: SshPlPorts,\n  useGlobalAccess: boolean,\n  plVersion: string,\n  minioIsUsed: boolean,\n): ConnectionInfo {\n  return {\n    plUser,\n    plPassword,\n    ports,\n    useGlobalAccess,\n    plVersion,\n    minioIsUsed: minioIsUsed,\n  };\n}\n\nexport function parseConnectionInfo(content: string): ConnectionInfo {\n  return ConnectionInfo.parse(JSON.parse(content));\n}\n\nexport function stringifyConnectionInfo(conn: ConnectionInfo): string {\n  return JSON.stringify(conn, undefined, 2);\n}\n"],"names":["z"],"mappings":";;;;AAAA;AACkF;AAGlF;AACA;AACA;AAEO,MAAM,QAAQ,GAAGA,KAAC,CAAC,MAAM,CAAC;AAC/B,IAAA,KAAK,EAAEA,KAAC,CAAC,MAAM,EAAE;AACjB,IAAA,MAAM,EAAEA,KAAC,CAAC,MAAM,EAAE;AACnB,CAAA;AAIM,MAAM,UAAU,GAAGA,KAAC,CAAC,MAAM,CAAC;AACjC,IAAA,IAAI,EAAE,QAAQ;AACd,IAAA,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE;AACzB,IAAA,UAAU,EAAE,QAAQ;AACpB,IAAA,KAAK,EAAE,QAAQ;;AAEf,IAAA,SAAS,EAAE,QAAQ;;AAEnB,IAAA,gBAAgB,EAAE,QAAQ;AAC3B,CAAA;AAIM,MAAM,cAAc,GAAGA,KAAC,CAAC,MAAM,CAAC;AACrC,IAAA,MAAM,EAAEA,KAAC,CAAC,MAAM,EAAE;AAClB,IAAA,UAAU,EAAEA,KAAC,CAAC,MAAM,EAAE;AACtB,IAAA,KAAK,EAAE,UAAU;;;IAIjB,eAAe,EAAEA,KAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;;IAG3C,SAAS,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC;;IAGvC,WAAW,EAAEA,KAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;AACvC,CAAA;AAID;AACA;AACA;AAEM,SAAU,iBAAiB,CAC/B,MAAc,EACd,UAAkB,EAClB,KAAiB,EACjB,eAAwB,EACxB,SAAiB,EACjB,WAAoB,EAAA;IAEpB,OAAO;QACL,MAAM;QACN,UAAU;QACV,KAAK;QACL,eAAe;QACf,SAAS;AACT,QAAA,WAAW,EAAE,WAAW;KACzB;AACH;AAEM,SAAU,mBAAmB,CAAC,OAAe,EAAA;IACjD,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAClD;AAEM,SAAU,uBAAuB,CAAC,IAAoB,EAAA;IAC1D,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;AAC3C;;;;;;;;;"}

package/dist/ssh/connection_info.d.ts

@@ -317,4 +317,3 @@ export type ConnectionInfo = z.infer<typeof ConnectionInfo>;
 export declare function newConnectionInfo(plUser: string, plPassword: string, ports: SshPlPorts, useGlobalAccess: boolean, plVersion: string, minioIsUsed: boolean): ConnectionInfo;
 export declare function parseConnectionInfo(content: string): ConnectionInfo;
 export declare function stringifyConnectionInfo(conn: ConnectionInfo): string;
-//# sourceMappingURL=connection_info.d.ts.map

package/dist/ssh/connection_info.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+
+/** We store all info about the connection on the server,
+ * so that another client could read the file and connect from another machine. */
+//
+// Types
+//
+const PortPair = z.object({
+    local: z.number(),
+    remote: z.number(),
+});
+const SshPlPorts = z.object({
+    grpc: PortPair,
+    http: PortPair.optional(),
+    monitoring: PortPair,
+    debug: PortPair,
+    /** @deprecated */
+    minioPort: PortPair,
+    /** @deprecated */
+    minioConsolePort: PortPair,
+});
+const ConnectionInfo = z.object({
+    plUser: z.string(),
+    plPassword: z.string(),
+    ports: SshPlPorts,
+    // It's false by default because it was added later,
+    // and in some deployments there won't be useGlobalAccess flag in the file.
+    useGlobalAccess: z.boolean().default(false),
+    // We added the field afterwards, the pl backend was this version.
+    plVersion: z.string().default('1.18.3'),
+    // It's true by default because it was added later and previous installation use minio.
+    minioIsUsed: z.boolean().default(true),
+});
+//
+// Funcs
+//
+function newConnectionInfo(plUser, plPassword, ports, useGlobalAccess, plVersion, minioIsUsed) {
+    return {
+        plUser,
+        plPassword,
+        ports,
+        useGlobalAccess,
+        plVersion,
+        minioIsUsed: minioIsUsed,
+    };
+}
+function parseConnectionInfo(content) {
+    return ConnectionInfo.parse(JSON.parse(content));
+}
+function stringifyConnectionInfo(conn) {
+    return JSON.stringify(conn, undefined, 2);
+}
+
+export { ConnectionInfo, PortPair, SshPlPorts, newConnectionInfo, parseConnectionInfo, stringifyConnectionInfo };
+//# sourceMappingURL=connection_info.js.map

package/dist/ssh/connection_info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection_info.js","sources":["../../src/ssh/connection_info.ts"],"sourcesContent":["/** We store all info about the connection on the server,\n * so that another client could read the file and connect from another machine. */\nimport { z } from 'zod';\n\n//\n// Types\n//\n\nexport const PortPair = z.object({\n  local: z.number(),\n  remote: z.number(),\n});\n/** The pair of ports for forwarding. */\nexport type PortPair = z.infer<typeof PortPair>;\n\nexport const SshPlPorts = z.object({\n  grpc: PortPair,\n  http: PortPair.optional(),\n  monitoring: PortPair,\n  debug: PortPair,\n  /** @deprecated */\n  minioPort: PortPair,\n  /** @deprecated */\n  minioConsolePort: PortPair,\n});\n/** All info about ports that are forwarded. */\nexport type SshPlPorts = z.infer<typeof SshPlPorts>;\n\nexport const ConnectionInfo = z.object({\n  plUser: z.string(),\n  plPassword: z.string(),\n  ports: SshPlPorts,\n\n  // It's false by default because it was added later,\n  // and in some deployments there won't be useGlobalAccess flag in the file.\n  useGlobalAccess: z.boolean().default(false),\n\n  // We added the field afterwards, the pl backend was this version.\n  plVersion: z.string().default('1.18.3'),\n\n  // It's true by default because it was added later and previous installation use minio.\n  minioIsUsed: z.boolean().default(true),\n});\n/** The content of the file that holds all the info about the connection on the remote server. */\nexport type ConnectionInfo = z.infer<typeof ConnectionInfo>;\n\n//\n// Funcs\n//\n\nexport function newConnectionInfo(\n  plUser: string,\n  plPassword: string,\n  ports: SshPlPorts,\n  useGlobalAccess: boolean,\n  plVersion: string,\n  minioIsUsed: boolean,\n): ConnectionInfo {\n  return {\n    plUser,\n    plPassword,\n    ports,\n    useGlobalAccess,\n    plVersion,\n    minioIsUsed: minioIsUsed,\n  };\n}\n\nexport function parseConnectionInfo(content: string): ConnectionInfo {\n  return ConnectionInfo.parse(JSON.parse(content));\n}\n\nexport function stringifyConnectionInfo(conn: ConnectionInfo): string {\n  return JSON.stringify(conn, undefined, 2);\n}\n"],"names":[],"mappings":";;AAAA;AACkF;AAGlF;AACA;AACA;AAEO,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC;AAC/B,IAAA,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;AACjB,IAAA,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;AACnB,CAAA;AAIM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;AACjC,IAAA,IAAI,EAAE,QAAQ;AACd,IAAA,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE;AACzB,IAAA,UAAU,EAAE,QAAQ;AACpB,IAAA,KAAK,EAAE,QAAQ;;AAEf,IAAA,SAAS,EAAE,QAAQ;;AAEnB,IAAA,gBAAgB,EAAE,QAAQ;AAC3B,CAAA;AAIM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;AACrC,IAAA,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;AAClB,IAAA,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;AACtB,IAAA,KAAK,EAAE,UAAU;;;IAIjB,eAAe,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;;IAG3C,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC;;IAGvC,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;AACvC,CAAA;AAID;AACA;AACA;AAEM,SAAU,iBAAiB,CAC/B,MAAc,EACd,UAAkB,EAClB,KAAiB,EACjB,eAAwB,EACxB,SAAiB,EACjB,WAAoB,EAAA;IAEpB,OAAO;QACL,MAAM;QACN,UAAU;QACV,KAAK;QACL,eAAe;QACf,SAAS;AACT,QAAA,WAAW,EAAE,WAAW;KACzB;AACH;AAEM,SAAU,mBAAmB,CAAC,OAAe,EAAA;IACjD,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAClD;AAEM,SAAU,uBAAuB,CAAC,IAAoB,EAAA;IAC1D,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;AAC3C;;;;"}

package/dist/ssh/pl.cjs

@@ -0,0 +1,500 @@
+'use strict';
+
+var ssh = require('./ssh.cjs');
+var tsHelpers = require('@milaboratories/ts-helpers');
+var pl_binary_download = require('../common/pl_binary_download.cjs');
+var upath = require('upath');
+var pl_paths = require('./pl_paths.cjs');
+var pl_version = require('../common/pl_version.cjs');
+var net = require('node:net');
+var plConfig = require('@milaboratories/pl-config');
+var supervisord = require('./supervisord.cjs');
+var connection_info = require('./connection_info.cjs');
+
+const minRequiredGlibcVersion = 2.28;
+class SshPl {
+    logger;
+    sshClient;
+    username;
+    initState = { step: 'init' };
+    constructor(logger, sshClient, username) {
+        this.logger = logger;
+        this.sshClient = sshClient;
+        this.username = username;
+    }
+    info() {
+        return {
+            username: this.username,
+            initState: this.initState,
+        };
+    }
+    static async init(logger, config) {
+        try {
+            const sshClient = await ssh.SshClient.init(logger, config);
+            return new SshPl(logger, sshClient, tsHelpers.notEmpty(config.username));
+        }
+        catch (e) {
+            logger.error(`Connection error in SshClient.init: ${e}`);
+            throw e;
+        }
+    }
+    cleanUp() {
+        this.sshClient.close();
+    }
+    /** Provides an info if the platforma and minio are running along with the debug info. */
+    async isAlive() {
+        const arch = await this.getArch();
+        const remoteHome = await this.getUserHomeDirectory();
+        return await supervisord.supervisorStatus(this.logger, this.sshClient, remoteHome, arch.arch);
+    }
+    /** Starts all the services on the server.
+      * Idempotent semantic: we could call it several times. */
+    async start(shouldUseMinio) {
+        const arch = await this.getArch();
+        const remoteHome = await this.getUserHomeDirectory();
+        try {
+            if (!supervisord.isAllAlive(await this.isAlive(), shouldUseMinio)) {
+                await supervisord.supervisorCtlStart(this.sshClient, remoteHome, arch.arch);
+                // We are waiting for Platforma to run to ensure that it has started.
+                return await this.checkIsAliveWithInterval(shouldUseMinio);
+            }
+        }
+        catch (e) {
+            let msg = `SshPl.start: ${e}`;
+            let logs = '';
+            try {
+                logs = await this.sshClient.readFile(pl_paths.platformaCliLogs(remoteHome));
+                msg += `, platforma cli logs: ${logs}`;
+            }
+            catch (e) {
+                msg += `, Can not read platforma cli logs: ${e}`;
+            }
+            this.logger.error(msg);
+            throw new Error(msg);
+        }
+    }
+    /** Stops all the services on the server.
+      * Idempotent semantic: we could call it several times. */
+    async stop() {
+        const arch = await this.getArch();
+        const remoteHome = await this.getUserHomeDirectory();
+        try {
+            const alive = await this.isAlive();
+            if (supervisord.isSupervisordRunning(alive)) {
+                await supervisord.supervisorStop(this.sshClient, remoteHome, arch.arch);
+                // Check if Minio is running by looking at the alive status
+                const shouldUseMinio = alive.minio === true;
+                return await this.checkIsAliveWithInterval(shouldUseMinio, 1000, 15, false);
+            }
+        }
+        catch (e) {
+            const msg = `PlSsh.stop: ${e}`;
+            this.logger.error(msg);
+            throw new Error(msg);
+        }
+    }
+    /** Stops the services, deletes a directory with the state and closes SSH connection. */
+    async reset() {
+        await this.stopAndClean();
+        this.cleanUp();
+        return true;
+    }
+    /** Stops platforma and deletes its state. */
+    async stopAndClean() {
+        const remoteHome = await this.getUserHomeDirectory();
+        this.logger.info(`pl.reset: Stop Platforma on the server`);
+        await this.stop();
+        this.logger.info(`pl.reset: Deleting Platforma workDir ${pl_paths.workDir(remoteHome)} on the server`);
+        await this.sshClient.deleteFolder(pl_paths.workDir(remoteHome));
+    }
+    /** Downloads binaries and untar them on the server,
+     * generates all the configs, creates necessary dirs,
+     * and finally starts all the services. */
+    async platformaInit(options) {
+        const state = { localWorkdir: options.localWorkdir, step: 'init' };
+        const { onProgress } = options;
+        // merge options with default ops.
+        const ops = {
+            ...defaultSshPlConfig,
+            ...options,
+        };
+        state.plBinaryOps = ops.plBinary;
+        try {
+            await this.doStepDetectArch(state, onProgress);
+            await this.doStepDetectHome(state, onProgress);
+            const needRestartPlatforma = await this.doStepReadExistedConfig(state, ops, onProgress);
+            if (!needRestartPlatforma) {
+                await onProgress?.('Platforma is already running. Skipping initialization.');
+                return state.existedSettings;
+            }
+            await this.doStepStopExistedPlatforma(state, onProgress);
+            await onProgress?.('Installation platforma...');
+            await this.doStepDownloadBinaries(state, onProgress, ops);
+            await this.doStepFetchPorts(state);
+            await this.doStepGenerateNewConfig(state, onProgress, ops);
+            await this.doStepCreateFoldersAndSaveFiles(state, onProgress);
+            await this.doStepConfigureSupervisord(state, onProgress);
+            await this.doStepSaveNewConnectionInfo(state, onProgress, ops);
+            await this.doStepStartPlatforma(state, onProgress);
+            return state.connectionInfo;
+        }
+        catch (e) {
+            const msg = `SshPl.platformaInit: ${e}, state: ${JSON.stringify(this.removeSensitiveData(state))}`;
+            this.logger.error(msg);
+            throw new Error(msg);
+        }
+    }
+    async doStepStopExistedPlatforma(state, onProgress) {
+        state.step = 'stopExistedPlatforma';
+        if (!supervisord.isAllAlive(state.alive, state.shouldUseMinio ?? false)) {
+            return;
+        }
+        await onProgress?.('Stopping services...');
+        await this.stop();
+    }
+    removeSensitiveData(state) {
+        const stateCopy = { ...state };
+        stateCopy.generatedConfig = { ...stateCopy.generatedConfig, filesToCreate: { skipped: 'sanitized' } };
+        return stateCopy;
+    }
+    async doStepStartPlatforma(state, onProgress) {
+        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.');
+    }
+    async doStepSaveNewConnectionInfo(state, onProgress, ops) {
+        state.step = 'saveNewConnectionInfo';
+        const config = state.generatedConfig;
+        await onProgress?.('Saving connection information...');
+        state.connectionInfo = connection_info.newConnectionInfo(config.plUser, config.plPassword, state.ports, tsHelpers.notEmpty(ops.useGlobalAccess), ops.plBinary.version, state.shouldUseMinio ?? false);
+        await this.sshClient.writeFileOnTheServer(pl_paths.connectionInfo(state.remoteHome), connection_info.stringifyConnectionInfo(state.connectionInfo));
+        await onProgress?.('Connection information saved.');
+    }
+    async doStepConfigureSupervisord(state, onProgress) {
+        await onProgress?.('Writing supervisord configuration...');
+        state.step = 'configureSupervisord';
+        const config = state.generatedConfig;
+        let supervisorConfig;
+        if (state.shouldUseMinio) {
+            supervisorConfig = supervisord.generateSupervisordConfigWithMinio(config.minioConfig.storageDir, config.minioConfig.envs, await this.getFreePortForPlatformaOnServer(state.remoteHome, state.arch), config.workingDir, config.plConfig.configPath, state.binPaths.minioRelPath, state.binPaths.downloadedPl);
+        }
+        else {
+            supervisorConfig = supervisord.generateSupervisordConfig(await this.getFreePortForPlatformaOnServer(state.remoteHome, state.arch), config.workingDir, config.plConfig.configPath, state.binPaths.downloadedPl);
+        }
+        const writeResult = await this.sshClient.writeFileOnTheServer(pl_paths.supervisorConf(state.remoteHome), supervisorConfig);
+        if (!writeResult) {
+            throw new Error(`Can not write supervisord config on the server ${pl_paths.workDir(state.remoteHome)}`);
+        }
+        await onProgress?.('Supervisord configuration written.');
+    }
+    async doStepCreateFoldersAndSaveFiles(state, onProgress) {
+        state.step = 'createFoldersAndSaveFiles';
+        const config = state.generatedConfig;
+        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}`);
+        }
+        for (const dir of config.dirsToCreate) {
+            await this.sshClient.ensureRemoteDirCreated(dir);
+            this.logger.info(`Created directory ${dir}`);
+        }
+        await onProgress?.('Folder structure created.');
+    }
+    async doStepGenerateNewConfig(state, onProgress, ops) {
+        state.step = 'generateNewConfig';
+        await onProgress?.('Generating new config...');
+        const config = await plConfig.generateSshPlConfigs({
+            logger: this.logger,
+            workingDir: pl_paths.workDir(state.remoteHome),
+            portsMode: {
+                type: 'customWithMinio',
+                ports: {
+                    debug: state.ports.debug.remote,
+                    grpc: state.ports.grpc.remote,
+                    http: state.ports.http.remote,
+                    minio: state.ports.minioPort.remote,
+                    minioConsole: state.ports.minioConsolePort.remote,
+                    monitoring: state.ports.monitoring.remote,
+                    httpLocal: state.ports.http.local,
+                    grpcLocal: state.ports.grpc.local,
+                    minioLocal: state.ports.minioPort.local,
+                },
+            },
+            licenseMode: ops.license,
+            useGlobalAccess: tsHelpers.notEmpty(ops.useGlobalAccess),
+            plConfigPostprocessing: ops.plConfigPostprocessing,
+            useMinio: state.shouldUseMinio ?? false,
+        });
+        state.generatedConfig = { ...config };
+        await onProgress?.('New config generated');
+    }
+    async doStepFetchPorts(state) {
+        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) {
+            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...');
+        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);
+        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.arch = await this.getArch();
+        await onProgress?.('Server architecture detected.');
+    }
+    async doStepDetectHome(state, onProgress) {
+        state.step = 'detectHome';
+        await onProgress?.('Fetching user home directory...');
+        state.remoteHome = await this.getUserHomeDirectory();
+        await onProgress?.('User home directory retrieved.');
+    }
+    async doStepReadExistedConfig(state, ops, onProgress) {
+        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.');
+        state.existedSettings = await this.readExistedConfig(state.remoteHome);
+        if (!state.existedSettings) {
+            throw new Error(`SshPl.platformaInit: platforma is alive but existed settings are not found`);
+        }
+        const sameGA = state.existedSettings.useGlobalAccess == ops.useGlobalAccess;
+        const samePlVersion = state.existedSettings.plVersion == ops.plBinary.version;
+        state.needRestart = !(sameGA && samePlVersion);
+        this.logger.info(`SshPl.platformaInit: need restart? ${state.needRestart}`);
+        state.shouldUseMinio = state.existedSettings.minioIsUsed;
+        if (state.shouldUseMinio) {
+            this.logger.info(`SshPl.platformaInit: minio is used`);
+        }
+        else {
+            this.logger.info(`SshPl.platformaInit: minio is not used`);
+        }
+        if (!state.needRestart) {
+            await onProgress?.('Server setup completed.');
+            return false;
+        }
+        await onProgress?.('Stopping services...');
+        await this.stop();
+        return true;
+    }
+    async downloadBinariesAndUploadToTheServer(localWorkdir, plBinary, remoteHome, arch, shouldUseMinio) {
+        const state = [];
+        try {
+            const pl = await this.downloadAndUntar(localWorkdir, remoteHome, arch, 'pl', `pl-${plBinary.version}`);
+            state.push(pl);
+            const supervisor = await this.downloadAndUntar(localWorkdir, remoteHome, arch, 'supervisord', pl_paths.supervisordDirName);
+            state.push(supervisor);
+            const minioPath = pl_paths.minioBin(remoteHome, arch.arch);
+            if (shouldUseMinio) {
+                const minio = await this.downloadAndUntar(localWorkdir, remoteHome, arch, 'minio', pl_paths.minioDirName);
+                state.push(minio);
+                await this.sshClient.chmod(minioPath, 0o750);
+            }
+            return {
+                history: state,
+                minioRelPath: shouldUseMinio ? minioPath : undefined,
+                downloadedPl: pl_paths.platformaBin(remoteHome, arch.arch),
+            };
+        }
+        catch (e) {
+            const msg = `SshPl.downloadBinariesAndUploadToServer: ${e}, state: ${JSON.stringify(state)}`;
+            this.logger.error(msg);
+            throw e;
+        }
+    }
+    /** 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). */
+    async downloadAndUntar(localWorkdir, remoteHome, arch, softwareName, tgzName) {
+        const state = {};
+        state.binBasePath = pl_paths.binariesDir(remoteHome);
+        await this.sshClient.ensureRemoteDirCreated(state.binBasePath);
+        state.binBasePathCreated = true;
+        let downloadBinaryResult = null;
+        const attempts = 5;
+        for (let i = 1; i <= attempts; i++) {
+            try {
+                downloadBinaryResult = await pl_binary_download.downloadBinaryNoExtract(this.logger, localWorkdir, softwareName, tgzName, arch.arch, arch.platform);
+                break;
+            }
+            catch (e) {
+                await tsHelpers.sleep(300);
+                if (i == attempts) {
+                    throw new Error(`downloadAndUntar: ${attempts} attempts, last error: ${e}`);
+                }
+            }
+        }
+        state.downloadResult = tsHelpers.notEmpty(downloadBinaryResult);
+        state.localArchivePath = upath.resolve(state.downloadResult.archivePath);
+        state.remoteDir = upath.join(state.binBasePath, state.downloadResult.baseName);
+        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');
+        }
+        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 new Error(`downloadAndUntar: untar: stderr occurred: ${untarResult.stderr}, stdout: ${untarResult.stdout}`);
+        state.untarDone = true;
+        return state;
+    }
+    async needDownload(remoteHome, arch) {
+        const checkPathSupervisor = pl_paths.supervisorBin(remoteHome, arch.arch);
+        const checkPathMinio = pl_paths.minioDir(remoteHome, arch.arch);
+        const checkPathPlatforma = pl_paths.platformaBin(remoteHome, arch.arch);
+        if (!await this.sshClient.checkFileExists(checkPathPlatforma)
+            || !await this.sshClient.checkFileExists(checkPathMinio)
+            || !await this.sshClient.checkFileExists(checkPathSupervisor)) {
+            return true;
+        }
+        return false;
+    }
+    async checkIsAliveWithInterval(shouldUseMinio, interval = 1000, count = 15, shouldStart = true) {
+        const maxMs = count * interval;
+        let total = 0;
+        let alive = await this.isAlive();
+        while (shouldStart ? !supervisord.isAllAlive(alive, shouldUseMinio) : supervisord.isAllAlive(alive, shouldUseMinio)) {
+            await tsHelpers.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)}`);
+            }
+            alive = await this.isAlive();
+        }
+    }
+    async readExistedConfig(remoteHome) {
+        const connectionInfo = await this.sshClient.readFile(pl_paths.connectionInfo(remoteHome));
+        return connection_info.parseConnectionInfo(connectionInfo);
+    }
+    async fetchPorts(remoteHome, arch) {
+        const ports = {
+            grpc: {
+                local: await plConfig.getFreePort(),
+                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
+            },
+            monitoring: {
+                local: await plConfig.getFreePort(),
+                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
+            },
+            debug: {
+                local: await plConfig.getFreePort(),
+                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
+            },
+            http: {
+                local: await plConfig.getFreePort(),
+                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
+            },
+            minioPort: {
+                local: await plConfig.getFreePort(),
+                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
+            },
+            minioConsolePort: {
+                local: await plConfig.getFreePort(),
+                remote: await this.getFreePortForPlatformaOnServer(remoteHome, arch),
+            },
+        };
+        return ports;
+    }
+    async getLocalFreePort() {
+        return new Promise((res) => {
+            const srv = net.createServer();
+            srv.listen(0, () => {
+                const port = srv.address().port;
+                srv.close((_) => res(port));
+            });
+        });
+    }
+    async getFreePortForPlatformaOnServer(remoteHome, arch) {
+        const freePortBin = pl_paths.platformaFreePortBin(remoteHome, arch.arch);
+        const { stdout, stderr } = await this.sshClient.exec(`${freePortBin}`);
+        if (stderr) {
+            throw new Error(`getFreePortForPlatformaOnServer: stderr is not empty: ${stderr}, stdout: ${stdout}`);
+        }
+        return +stdout;
+    }
+    async getArch() {
+        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');
+        return {
+            platform: arr[0],
+            arch: arr[1],
+        };
+    }
+    async getUserHomeDirectory() {
+        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}`);
+            return home;
+        }
+        return stdout.trim();
+    }
+}
+const defaultSshPlConfig = {
+    useGlobalAccess: false,
+    plBinary: {
+        type: 'Download',
+        version: pl_version.getDefaultPlVersion(),
+    },
+};
+/**
+ * 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, sshClient) {
+    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) {
+        logger.error(`glibc version check failed: ${e}`);
+        throw e;
+    }
+}
+function parseGlibcVersion(output) {
+    const versionMatch = output.match(/\d+\.\d+/);
+    if (!versionMatch) {
+        throw new Error(`Could not parse glibc version from: ${output}`);
+    }
+    return parseFloat(versionMatch[0]);
+}
+
+exports.SshPl = SshPl;
+exports.parseGlibcVersion = parseGlibcVersion;
+//# sourceMappingURL=pl.cjs.map