@milaboratories/pl-deployments 1.1.0

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

@@ -0,0 +1,192 @@
+import { describe, it, beforeAll, expect, afterAll } from 'vitest';
+import { initContainer, getConnectionForSsh, cleanUp as cleanUpT } from './common-utils';
+import { SshPl } from '../pl';
+import upath from 'upath';
+import { getDefaultPlVersion } from '../../common/pl_version';
+import { existsSync, unlinkSync, rmSync } from 'fs';
+import { newArch } from '../../common/os_and_arch';
+import { downloadBinary, downloadPlBinary } from '../../common/pl_binary_download';
+import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
+import * as plpath from '../pl_paths';
+
+let sshPl: SshPl;
+const testContainer = await initContainer('pl');
+
+const downloadDestination = upath.resolve(__dirname, '..', 'test-assets', 'downloads');
+
+async function cleanUp() {
+  const version = getDefaultPlVersion();
+  const arch = await sshPl.getArch();
+  const tgzName = 'supervisord-0.7.3';
+
+  unlinkSync(`${downloadDestination}/pl-${version}-${newArch(arch!.arch)}.tgz`);
+  unlinkSync(`${downloadDestination}/${tgzName}-${newArch(arch!.arch)}.tgz`);
+  rmSync(downloadDestination, { recursive: true });
+}
+beforeAll(async () => {
+  const logger = new ConsoleLoggerAdapter();
+  sshPl = await SshPl.init(logger, getConnectionForSsh(testContainer));
+});
+
+describe('SshPl', async () => {
+  it('User home direcory', async () => {
+    const home = await sshPl.getUserHomeDirectory();
+    expect(home).toBe('/home/pl-doctor');
+  });
+
+  it('Get OS arch', async () => {
+    const platformInfo = await sshPl.getArch();
+    expect(platformInfo).toHaveProperty('platform');
+    expect(platformInfo).toHaveProperty('arch');
+
+    expect(platformInfo?.arch).toBe('x86_64');
+    expect(platformInfo?.platform).toBe('Linux');
+  });
+
+  it('Check start/stop cmd', async () => {
+    await sshPl.platformaInit(downloadDestination);
+    expect(await sshPl.isAlive()).toBe(true);
+
+    await sshPl.stop();
+    expect(await sshPl.isAlive()).toBe(false);
+
+    // FIXME: it doesn't work in CI
+    // await sshPl.start();
+    // expect(await sshPl.isAlive()).toBe(true);
+  });
+
+  it('downloadBinariesAndUploadToServer', async () => {
+    await sshPl.stop();
+
+    const arch = await sshPl.getArch();
+    const remoteHome = await sshPl.getUserHomeDirectory();
+    await sshPl.stop(); // ensure stopped
+    await sshPl.downloadBinariesAndUploadToTheServer(downloadDestination, remoteHome, arch);
+
+    const pathSupervisor = `${plpath.supervisorBinDir(remoteHome, arch.arch)}/supervisord`;
+    const pathMinio = `${plpath.minioDir(remoteHome, arch.arch)}/minio`;
+
+    expect((await sshPl?.sshClient.checkPathExists(pathSupervisor))?.exists).toBe(true);
+    expect((await sshPl?.sshClient.checkPathExists(pathMinio))?.exists).toBe(true);
+  });
+
+  it('platformaInit', async () => {
+    const result = await sshPl.platformaInit(downloadDestination);
+
+    const remoteHome = await sshPl.getUserHomeDirectory();
+
+    expect(await sshPl?.sshClient.checkFileExists(`${plpath.workDir(remoteHome)}/config.yaml`)).toBe(true);
+    expect(typeof result?.ports).toBe('object');
+    expect(result?.plPassword).toBeTruthy();
+    expect(result?.plUser).toBeTruthy();
+  });
+
+  it('Transfer Platforma to server', async () => {
+    const arch = await sshPl.getArch();
+
+    const plPath = await downloadPlBinary(
+      new ConsoleLoggerAdapter(),
+      downloadDestination,
+      getDefaultPlVersion(),
+      arch.arch,
+      arch.platform,
+    );
+
+    const plFolderName = upath.basename(plPath.targetFolder);
+    const dirPath = upath.resolve(downloadDestination, plFolderName);
+    await sshPl.sshClient.uploadDirectory(dirPath, `/home/pl-doctor/${plFolderName}`);
+
+    console.log(plPath, dirPath);
+
+    const execResult2 = await testContainer!.exec(['cat', `/home/pl-doctor/${plFolderName}/.ok`]);
+    const output2 = execResult2.output.trim();
+    expect(output2).toBe('ok');
+  });
+
+  it('Get free port', async () => {
+    await sshPl?.platformaInit(downloadDestination);
+    const isAlive = await sshPl?.isAlive();
+    expect(isAlive).toBe(true);
+
+    const arch = await sshPl.getArch();
+    const remoteHome = await sshPl.getUserHomeDirectory();
+    const port = await sshPl.getFreePortForPlatformaOnServer(remoteHome, arch);
+
+    expect(typeof port).toBe('number');
+  });
+
+  it('fetchPorts', async () => {
+    const arch = await sshPl.getArch();
+    const remoteHome = await sshPl.getUserHomeDirectory();
+    const ports = await sshPl.fetchPorts(remoteHome, arch);
+
+    if (ports) {
+      Object.entries(ports).forEach(([, port]) => {
+        expect(typeof port.local).toBe('number');
+        expect(typeof port.remote).toBe('number');
+      });
+    }
+
+    expect(ports?.grpc).toMatchObject({
+      local: expect.anything(),
+      remote: expect.anything(),
+    });
+    expect(ports?.monitoring).toMatchObject({
+      local: expect.anything(),
+      remote: expect.anything(),
+    });
+    expect(ports?.debug).toMatchObject({
+      local: expect.anything(),
+      remote: expect.anything(),
+    });
+    expect(ports?.minioPort).toMatchObject({
+      local: expect.anything(),
+      remote: expect.anything(),
+    });
+    expect(ports?.minioConsolePort).toMatchObject({
+      local: expect.anything(),
+      remote: expect.anything(),
+    });
+  });
+});
+
+describe('SshPl download binaries', async () => {
+  it('Download pl. We have archive and extracted data', async () => {
+    const arch = await sshPl.getArch();
+
+    const result = await downloadPlBinary(
+      new ConsoleLoggerAdapter(),
+      downloadDestination,
+      getDefaultPlVersion(),
+      arch.arch,
+      arch.platform,
+    );
+
+    const version = getDefaultPlVersion();
+    expect(!!result).toBe(true);
+    expect(existsSync(`${downloadDestination}/pl-${version}-${newArch(arch.arch)}.tgz`)).toBe(true);
+  });
+
+  it('Download other software', async () => {
+    const arch = await sshPl.getArch();
+
+    const softwareName = 'supervisord';
+    const tgzName = 'supervisord-0.7.3';
+
+    const result = await downloadBinary(
+      new ConsoleLoggerAdapter(),
+      downloadDestination,
+      softwareName, tgzName,
+      arch.arch,
+      arch.platform,
+    );
+
+    expect(!!result).toBe(true);
+    expect(existsSync(`${downloadDestination}/${tgzName}-${newArch(arch.arch)}.tgz`)).toBe(true);
+  });
+});
+
+afterAll(async () => {
+  await cleanUp();
+  await cleanUpT(testContainer);
+});

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

@@ -0,0 +1,175 @@
+import { describe, it, beforeAll, afterAll, expect } from 'vitest';
+import { writeFileSync, readFileSync } from 'fs';
+import { SshClient } from '../ssh';
+import ssh from 'ssh2';
+import { downloadsFolder, cleanUp, getConnectionForSsh, getContainerHostAndPort, initContainer, localFileDownload, localFileUpload } from './common-utils';
+import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
+
+let client: SshClient;
+const testContainer = await initContainer('ssh');
+
+beforeAll(async () => {
+  client = await SshClient.init(new ConsoleLoggerAdapter(), getConnectionForSsh(testContainer));
+});
+
+describe('SSH Tests', () => {
+  it('isPassphraseRequiredForKey', async () => {
+    const k1 = ssh.utils.generateKeyPairSync('rsa', {
+      passphrase: 'password',
+      cipher: 'aes256-cbc',
+      bits: 2048,
+    });
+    expect(await SshClient.isPassphraseRequiredForKey(k1.private)).toBe(true);
+
+    const k2 = ssh.utils.generateKeyPairSync('rsa', {
+      cipher: 'aes256-cbc',
+      bits: 2048,
+    });
+    expect(await SshClient.isPassphraseRequiredForKey(k2.private)).toBe(false);
+
+    const k3 = ssh.utils.generateKeyPairSync('ecdsa', { bits: 256, comment: 'node.js rules!', passphrase: 'password', cipher: 'aes256-cbc' });
+    expect(await SshClient.isPassphraseRequiredForKey(k3.private)).toBe(true);
+
+    const k4 = ssh.utils.generateKeyPairSync('ecdsa', { bits: 256, comment: 'node.js rules!', cipher: 'aes256-cbc' });
+    expect(await SshClient.isPassphraseRequiredForKey(k4.private)).toBe(false);
+  });
+  it('should create file from string', async () => {
+    expect(await client.writeFileOnTheServer('/home/pl-doctor/from-string.txt', 'hello'));
+
+    const execResult = await testContainer.exec(['cat', `/home/pl-doctor/from-string.txt`]);
+    const output = execResult.output.trim();
+    expect(output).toBe('hello');
+  });
+  it('should create all directories if none exist', async () => {
+    const remotePath = '/home/pl-doctor/upload/nested/directory';
+    await expect(client.createRemoteDirectory(remotePath)).resolves.not.toThrow();
+
+    // Additional check to ensure the directory exists
+    await client.withSftp(async (sftp) => {
+      const stat = await new Promise((resolve, reject) => {
+        sftp.stat(remotePath, (err, stats) => {
+          if (err) return reject(err);
+          resolve(stats);
+        });
+      });
+      expect(stat).toBeDefined();
+    });
+  });
+
+  it('should handle existing directories gracefully', async () => {
+    const remotePath = '/home/pl-doctor/upload/nested';
+
+    await expect(client.createRemoteDirectory(remotePath)).resolves.not.toThrow();
+    await expect(client.createRemoteDirectory(remotePath)).resolves.not.toThrow();
+  });
+
+  it('should throw an error if an invalid path is provided', async () => {
+    const remotePath = '/invalid_path/nested';
+
+    await expect(client.createRemoteDirectory(remotePath)).rejects.toThrow();
+  });
+
+  it('Upload directory', async () => {
+    const remoteDir = '/home/pl-doctor';
+    await client.uploadDirectory(`${downloadsFolder}/rec-upload`, '/home/pl-doctor/rec-upload');
+
+    const execResult = await testContainer.exec(['cat', `${remoteDir}/rec-upload/sub-1/test.txt`]);
+    const output = execResult.output.trim();
+    expect(output).toBe('test-1');
+
+    const execResult1 = await testContainer.exec(['cat', `${remoteDir}/rec-upload/sub-1/sub-1-1/test-5.txt`]);
+    const output1 = execResult1.output.trim();
+    expect(output1).toBe('test-5');
+
+    const execResult2 = await testContainer.exec(['cat', `${remoteDir}/rec-upload/sub-1/sub-1-18/test-2.txt`]);
+    const output2 = execResult2.output.trim();
+    expect(output2).toBe('test-2');
+  });
+
+  it('should upload a file to the SSH server', async () => {
+    const data = `Test data ${new Date().getTime()}`;
+    const remoteFile = '/home/pl-doctor/uploaded-file.txt';
+    writeFileSync(localFileUpload, data);
+    const result = await client.uploadFile(localFileUpload, remoteFile);
+    expect(result).toBe(true);
+    const execResult = await testContainer.exec(['cat', remoteFile]);
+    const output = execResult.output.trim();
+    expect(output).toBe(data);
+  });
+
+  it('should download file from SSH server', async () => {
+    const data = `Test data ${new Date().getTime()}`;
+    // const localFile = './test-file-upload.txt';
+    const remoteFile = '/home/pl-doctor/uploaded-file.txt';
+
+    writeFileSync(localFileDownload, data);
+
+    const uploadResult = await client.uploadFile(localFileDownload, remoteFile);
+    expect(uploadResult).toBe(true);
+
+    const downloadResult = await client.downloadFile(remoteFile, localFileDownload);
+    expect(downloadResult).toBe(true);
+    expect(readFileSync(localFileDownload, { encoding: 'utf-8' })).toBe(data);
+  });
+
+  it('Simple server should forward remote SSH port to a local port', async () => {
+    const localPort = 3001;
+
+    const resFailed = await fetch(`http://127.0.0.1:${localPort}`).catch((err) => console.log('Must fail'));
+    expect(resFailed).toBe(undefined);
+
+    const { server } = await client.forwardPort({
+      remotePort: localPort,
+      localPort,
+    });
+
+    const res = await fetch(`http://127.0.0.1:${localPort}`);
+    expect(await res.text()).toBe('Hello, this is a simple Node.js server!');
+
+    server.close();
+  });
+
+  it('Auth types', async () => {
+    const hostData = getContainerHostAndPort(testContainer);
+    const types = await SshClient.getAuthTypes(hostData.host, hostData.port);
+    expect(types[0]).toBe('publickey');
+  });
+});
+
+describe('sshConnect', () => {
+  it('should successfully connect to the SSH server', async () => {
+    const client = await SshClient.init(new ConsoleLoggerAdapter(), getConnectionForSsh(testContainer));
+    client.close();
+  });
+
+  it('should fail with invalid credentials', async () => {
+    await expect(SshClient.init(new ConsoleLoggerAdapter(), { ...getConnectionForSsh(testContainer), privateKey: '123' })).rejects.toThrow();
+  });
+
+  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');
+  });
+});
+
+describe('sshExec', () => {
+  it('should execute a valid command and return stdout', async () => {
+    const { stdout, stderr } = await client.exec('echo "Hello, SSH"');
+    expect(stdout.trim()).toBe('Hello, SSH');
+    expect(stderr).toBe('');
+  });
+
+  it('should capture stderr for an invalid command', async () => {
+    const command = 'nonexistentcommand';
+    await expect(client.exec(command)).rejects.toThrow();
+  });
+
+  it('should handle a command with both stdout and stderr', async () => {
+    const { stdout, stderr } = await client.exec('sh -c "echo stdout && echo stderr >&2"');
+    expect(stdout.trim()).toBe('stdout');
+    expect(stderr.trim()).toBe('stderr');
+  });
+});
+
+afterAll(async () => {
+  await cleanUp(testContainer);
+});