@milaboratories/pl-deployments 1.1.3 → 1.1.5

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

@@ -131,6 +131,25 @@ describe('SSH Tests', () => {
     server.close();
   });
 
+  it('Remove directory', async () => {
+    const rootFolder = '/home/pl-doctor/upload';
+    await client.createRemoteDirectory(`${rootFolder}/upload/nested`);
+    await client.createRemoteDirectory(`${rootFolder}/2-nested`);
+    await client.createRemoteDirectory(`${rootFolder}/2-nested/3-sub`);
+    await client.writeFileOnTheServer(`${rootFolder}/2-nested/3-sub/qwerty.txt`, 'HELLO FROM SSH');
+
+    const text = await client.readFile(`${rootFolder}/2-nested/3-sub/qwerty.txt`);
+    expect(text).toBe('HELLO FROM SSH');
+
+    let data = await client.checkPathExists(rootFolder);
+    expect(data.exists).toBe(true);
+
+    await client.deleteFolder(rootFolder);
+
+    data = await client.checkPathExists(rootFolder);
+    expect(data.exists).toBe(false);
+  });
+
   it('Auth types', async () => {
     const hostData = getContainerHostAndPort(testContainer);
     const types = await SshClient.getAuthTypes(hostData.host, hostData.port);

package/src/ssh/pl.ts

@@ -60,7 +60,7 @@ export class SshPl {
       // We are waiting for Platforma to run to ensure that it has started.
       return await this.checkIsAliveWithInterval();
     } catch (e: unknown) {
-      const msg = `ssh.start: error occurred ${e}`
+      const msg = `ssh.start: error occurred ${e}`;
       this.logger.error(msg);
       throw new Error(msg);
     }
@@ -74,12 +74,24 @@ export class SshPl {
       await supervisorCtlShutdown(this.sshClient, remoteHome, arch.arch);
       return await this.checkIsAliveWithInterval(undefined, undefined, false);
     } catch (e: unknown) {
-      const msg = `ssh.stop: error occurred ${e}`
+      const msg = `ssh.stop: error occurred ${e}`;
       this.logger.error(msg);
-      throw new Error(msg)
+      throw new Error(msg);
     }
   }
 
+  public async reset(): Promise<boolean> {
+    const workDir = await this.getUserHomeDirectory();
+
+    this.logger.info(`pl.reset: Stop Platforma on the server`);
+    await this.stop();
+
+    this.logger.info(`pl.reset: Deleting Platforma workDir ${workDir} on the server`);
+    await this.sshClient.deleteFolder(plpath.workDir(workDir));
+
+    return true;
+  }
+
   public async platformaInit(localWorkdir: string): Promise<SshInitReturnTypes> {
     const state: PlatformaInitState = { localWorkdir };
 
@@ -232,7 +244,6 @@ export class SshPl {
     softwareName: string,
     tgzName: string,
   ): Promise<DownloadAndUntarState> {
-
     const state: DownloadAndUntarState = {};
     state.binBasePath = plpath.binariesDir(remoteHome);
     await this.sshClient.createRemoteDirectory(state.binBasePath);
@@ -242,7 +253,7 @@ export class SshPl {
     const attempts = 5;
     for (let i = 1; i <= attempts; i++) {
       try {
-         downloadBinaryResult = await downloadBinaryNoExtract(
+        downloadBinaryResult = await downloadBinaryNoExtract(
           this.logger,
           localWorkdir,
           softwareName,
@@ -250,7 +261,7 @@ export class SshPl {
           arch.arch, arch.platform,
         );
         break;
-      } catch(e: unknown) {
+      } catch (e: unknown) {
         await sleep(300);
         if (i == attempts) {
           throw new Error(`downloadAndUntar: ${attempts} attempts, last error: ${e}`);

package/src/ssh/ssh.ts

@@ -5,15 +5,20 @@ import dns from 'dns';
 import fs from 'fs';
 import { readFile } from 'fs/promises';
 import upath from 'upath';
-import type { MiLogger } from '@milaboratories/ts-helpers';
+import { RetryablePromise, type MiLogger } from '@milaboratories/ts-helpers';
+import { randomBytes } from 'crypto';
 
 const defaultConfig: ConnectConfig = {
   keepaliveInterval: 60000,
   keepaliveCountMax: 10,
-}
+};
 
 export type SshAuthMethods = 'publickey' | 'password';
 export type SshAuthMethodsResult = SshAuthMethods[];
+export type SshDirContent = {
+  files: string[];
+  directories: string[];
+};
 
 export class SshClient {
   private config?: ConnectConfig;
@@ -32,7 +37,7 @@ export class SshClient {
   public static async init(logger: MiLogger, config: ConnectConfig): Promise<SshClient> {
     const withDefaults = {
       ...defaultConfig,
-      ...config
+      ...config,
     };
 
     const client = new SshClient(logger, new Client());
@@ -41,6 +46,14 @@ export class SshClient {
     return client;
   }
 
+  public getFullHostName() {
+    return `${this.config?.host}:${this.config?.port}`;
+  }
+
+  public getUserName() {
+    return this.config?.username;
+  }
+
   /**
    * Connects to the SSH server using the specified configuration.
    * @param config - The connection configuration object for the SSH client.
@@ -48,16 +61,7 @@ export class SshClient {
    */
   public async connect(config: ConnectConfig) {
     this.config = config;
-    return new Promise((resolve, reject) => {
-      this.client.on('ready', () => {
-        resolve(undefined);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      }).on('error', (err: any) => {
-        reject(new Error(`ssh.connect: error occurred: ${err}`));
-      }).on('timeout', () => {
-        reject(new Error(`timeout was occurred while waiting for SSH connection.`));
-      }).connect(config);
-    });
+    return await connect(this.client, config, () => {}, () => {});
   }
 
   /**
@@ -142,61 +146,95 @@ export class SshClient {
    * @returns { server: net.Server } A promise resolving with the created server instance.
    */
   public async forwardPort(ports: { remotePort: number; localPort: number; localHost?: string }, config?: ConnectConfig): Promise<{ server: net.Server }> {
+    const log = `ssh.forward:${ports.localPort}:${ports.remotePort}.id_${randomBytes(1).toString('hex')}`;
     config = config ?? this.config;
-    return new Promise((resolve, reject) => {
-      if (!config) {
-        reject('No config defined');
-        return;
-      }
-      const conn = new Client();
-      let server: net.Server;
-      conn.on('ready', () => {
-        this.logger.info(`[SSH] Connection to ${config.host}. Remote port ${ports.remotePort} will be available locally on the ${ports.localPort}`);
-        server = net.createServer({ pauseOnConnect: true }, (localSocket) => {
-          conn.forwardOut('127.0.0.1', 0, '127.0.0.1', ports.remotePort,
-            (err, stream) => {
-              if (err) {
-                console.error('Error opening SSH channel:', err.message);
-                localSocket.end();
-                return;
-              }
-              localSocket.pipe(stream);
-              stream.pipe(localSocket);
-              localSocket.resume();
-            },
-          );
+
+    // we make this thing persistent so that if the connection
+    // drops (it happened in the past because of lots of errors and forwardOut opened channels),
+    // we'll recreate it here.
+    const persistentClient = new RetryablePromise((p: RetryablePromise<Client>) => {
+      return new Promise<Client>((resolve, reject) => {
+        const client = new Client();
+
+        client.on('ready', () => {
+          this.logger.info(`${log}.client.ready`);
+          resolve(client);
         });
-        server.listen(ports.localPort, '127.0.0.1', () => {
-          this.logger.info(`[+] Port local ${ports.localPort} available locally for remote port → :${ports.remotePort}`);
-          resolve({ server });
+
+        client.on('error', (err) => {
+          this.logger.info(`${log}.client.error: ${err}`);
+          p.reset();
+          reject(err);
         });
 
-        server.on('error', (err) => {
-          conn.end();
-          server.close();
-          reject(new Error(`ssh.forwardPort: server error: ${err}`));
+        client.on('close', () => {
+          this.logger.info(`${log}.client.closed`);
+          p.reset();
         });
 
-        server.on('close', () => {
-          this.logger.info(`Server closed ${JSON.stringify(ports)}`);
-          if (conn) {
-            this.logger.info(`End SSH connection`);
-            conn.end();
-          }
+        client.connect(config!);
+      });
+    });
+
+    await persistentClient.ensure(); // warm up a connection
+
+    return new Promise((resolve, reject) => {
+      const server = net.createServer({ pauseOnConnect: true }, async (localSocket) => {
+        const sockLog = `${log}.sock_${randomBytes(1).toString('hex')}`;
+        // this.logger.info(`${sockLog}.localSocket: start connection`);
+        let conn: Client;
+        try {
+          conn = await persistentClient.ensure();
+        } catch (e: unknown) {
+          this.logger.info(`${sockLog}.persistentClient.catch: ${e}`);
+          localSocket.end();
+          return;
+        }
+
+        let stream: ClientChannel;
+        try {
+          stream = await forwardOut(this.logger, conn, '127.0.0.1', 0, '127.0.0.1', ports.remotePort);
+        } catch (e: unknown) {
+          this.logger.error(`${sockLog}.forwardOut.err: ${e}`);
+          localSocket.end();
+          return;
+        }
+
+        localSocket.pipe(stream);
+        stream.pipe(localSocket);
+        localSocket.resume();
+        // this.logger.info(`${sockLog}.forwardOut: connected`);
+
+        stream.on('error', (err: unknown) => {
+          this.logger.error(`${sockLog}.stream.error: ${err}`);
+          localSocket.end();
+          stream.end();
+        });
+        stream.on('close', () => {
+          // this.logger.info(`${sockLog}.stream.close: closed`);
+          localSocket.end();
+          stream.end();
+        });
+        localSocket.on('close', () => {
+          this.logger.info(`${sockLog}.localSocket: closed`);
+          localSocket.end();
+          stream.end();
         });
       });
 
-      conn.on('error', (err) => {
-        this.logger.error(`[SSH] SSH connection error, ports: ${JSON.stringify(ports)}, err: ${err.message}`);
-        server?.close();
-        reject(`ssh.forwardPort: conn.err: ${err}`);
+      server.listen(ports.localPort, '127.0.0.1', () => {
+        this.logger.info(`${log}.server: started listening`);
+        resolve({ server });
       });
 
-      conn.on('close', () => {
-        this.logger.info(`[SSH] Connection closed, ports: ${JSON.stringify(ports)}`);
+      server.on('error', (err) => {
+        server.close();
+        reject(new Error(`${log}.server: error: ${JSON.stringify(err)}`));
       });
 
-      conn.connect(config);
+      server.on('close', () => {
+        this.logger.info(`${log}.server: closed ${JSON.stringify(ports)}`);
+      });
     });
   }
 
@@ -286,6 +324,73 @@ export class SshClient {
     });
   }
 
+  public async getForderStructure(sftp: SFTPWrapper, remotePath: string, data: SshDirContent = { files: [], directories: [] }): Promise<SshDirContent> {
+    return new Promise((resolve, reject) => {
+      sftp.readdir(remotePath, async (err, items) => {
+        if (err) {
+          return reject(err);
+        }
+
+        for (const item of items) {
+          const itemPath = `${remotePath}/${item.filename}`;
+          if (item.attrs.isDirectory()) {
+            data.directories.push(itemPath);
+            try {
+              await this.getForderStructure(sftp, itemPath, data);
+            } catch (error) {
+              return reject(error);
+            }
+          } else {
+            data.files.push(itemPath);
+          }
+        }
+        resolve(data);
+      });
+    });
+  }
+
+  public rmdir(sftp: SFTPWrapper, path: string) {
+    return new Promise((resolve, reject) => {
+      sftp.rmdir(path, (err) => err ? reject(err) : resolve(true));
+    });
+  }
+
+  public unlink(sftp: SFTPWrapper, path: string) {
+    return new Promise((resolve, reject) => {
+      sftp.unlink(path, (err) => err ? reject(err) : resolve(true));
+    });
+  }
+
+  public async deleteFolder(path: string) {
+    return this.withSftp(async (sftp) => {
+      try {
+        const list = await this.getForderStructure(sftp, path);
+        this.logger.info(`ssh.deleteFolder list of files and directories`);
+        this.logger.info(`ssh.deleteFolder list of files: ${list.files}`);
+        this.logger.info(`ssh.deleteFolder list of directories: ${list.directories}`);
+
+        for (const filePath of list.files) {
+          this.logger.info(`ssh.deleteFolder unlink file ${filePath}`);
+          await this.unlink(sftp, filePath);
+        }
+
+        list.directories.sort((a, b) => b.length - a.length);
+
+        for (const directoryPath of list.directories) {
+          this.logger.info(`ssh.deleteFolder rmdir  ${directoryPath}`);
+          await this.rmdir(sftp, directoryPath);
+        }
+
+        await this.rmdir(sftp, path);
+        return true;
+      } catch (e: unknown) {
+        this.logger.error(e);
+        const message = e instanceof Error ? e.message : '';
+        throw new Error(`ssh.deleteFolder: path: ${path}, message: ${message}`);
+      }
+    });
+  }
+
   public async readFile(remotePath: string): Promise<string> {
     return this.withSftp(async (sftp) => {
       return new Promise((resolve, reject) => {
@@ -361,7 +466,7 @@ export class SshClient {
 
   public uploadFileUsingExistingSftp(sftp: SFTPWrapper, localPath: string, remotePath: string, mode: number = 0o660) {
     return new Promise((resolve, reject) => {
-      readFile(localPath).then(async (result) => {
+      readFile(localPath).then(async (result: Buffer) => {
         this.writeFile(sftp, remotePath, result, mode)
           .then(() => {
             resolve(undefined);
@@ -519,3 +624,40 @@ export class SshClient {
 }
 
 export type SshExecResult = { stdout: string; stderr: string };
+
+async function connect(
+  client: Client,
+  config: ConnectConfig,
+  onError: (e: unknown) => void,
+  onClose: () => void,
+): Promise<Client> {
+  return new Promise((resolve, reject) => {
+    client.on('ready', () => {
+      resolve(client);
+    });
+
+    client.on('error', (err: unknown) => {
+      onError(err);
+      reject(new Error(`ssh.connect: error occurred: ${err}`));
+    });
+
+    client.on('close', () => {
+      onClose();
+    });
+
+    client.connect(config);
+  });
+}
+
+async function forwardOut(logger: MiLogger, conn: Client, localHost: string, localPort: number, remoteHost: string, remotePort: number): Promise<ClientChannel> {
+  return new Promise((resolve, reject) => {
+    conn.forwardOut(localHost, localPort, remoteHost, remotePort, (err, stream) => {
+      if (err) {
+        logger.error(`forwardOut.error: ${err}`);
+        return reject(err);
+      }
+
+      return resolve(stream);
+    });
+  });
+}