@milaboratories/pl-deployments 1.1.2 → 1.1.4

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

@@ -12,7 +12,7 @@ let testContainer: StartedTestContainer;
 beforeAll(async () => {
   testContainer = await initContainer('ssh');
   client = await SshClient.init(new ConsoleLoggerAdapter(), getConnectionForSsh(testContainer));
-});
+}, 200000);
 
 describe('SSH Tests', () => {
   it('isPassphraseRequiredForKey', async () => {
@@ -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);
@@ -148,7 +167,8 @@ describe('sshConnect', () => {
     await expect(SshClient.init(new ConsoleLoggerAdapter(), { ...getConnectionForSsh(testContainer), username: 'dfasdfa' })).rejects.toThrow();
   });
 
-  it('should fail with invalid passphrase', async () => {
+  // FIXME
+  it.skip('should fail with invalid passphrase', async () => {
     let catched = false;
     try {
       await SshClient.init(new ConsoleLoggerAdapter(), { ...getConnectionForSsh(testContainer), passphrase: 'dfasdfa' });
@@ -225,4 +245,4 @@ describe('sshExec', () => {
 
 afterAll(async () => {
   await cleanUp(testContainer);
-});
+}, 200000);

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

@@ -10,10 +10,14 @@ import type { MiLogger } from '@milaboratories/ts-helpers';
 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 +36,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 +45,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.
@@ -286,6 +298,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) => {