@milaboratories/pl-deployments 2.4.3 → 2.4.4

package/README.md

@@ -1 +1,18 @@
-# pl-local
+# pl-deployments
+
+## Test tips
+
+### Regenerate `ssh` keys
+`ssh2` lib has a way to generate private and public ssh keys.
+
+`cd` into pl-deployments and then run it in `node` repl:
+
+```js
+let keys = require("ssh2").utils.generateKeyPairSync('ecdsa', { bits: 256, comment: 'node.js rules!', passphrase: 'password', cipher: 'aes256-cbc' });
+
+require("fs").writeFileSync('test-assets/public-key.pem', keys.public);
+require("fs").writeFileSync('test-assets/private-key.pem', keys.private);
+```
+
+### Clean docker containers
+If something went wrong with testcontainers, use `pnpm run cleanup-docker` from pl-deployments root.

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

@@ -1,13 +1,7 @@
 import { StartedTestContainer } from 'testcontainers';
 import { ConnectConfig } from 'ssh2';
-export declare const localFileUpload: string;
-export declare const localFileDownload: string;
-export declare const downloadsFolder: string;
-export declare const recUpload: string;
-export declare function createTestDirForRecursiveUpload(): Promise<void>;
-export declare function getPathForFile(fileName: string): string;
-export declare function generateKeys(): void;
-export declare function initPrivateKey(): string;
+export declare const testAssetsPath: string;
+export declare function readPrivateKey(): string;
 export declare function initContainer(name: string): Promise<StartedTestContainer>;
 export declare function getContainerHostAndPort(container: StartedTestContainer): {
     port: number;

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

@@ -1 +1 @@
-{"version":3,"file":"common-utils.d.ts","sourceRoot":"","sources":["../../../src/ssh/__tests__/common-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAK3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAS1C,eAAO,MAAM,eAAe,QAAkC,CAAC;AAC/D,eAAO,MAAM,iBAAiB,QAA2C,CAAC;AAC1E,eAAO,MAAM,eAAe,QAAwE,CAAC;AACrG,eAAO,MAAM,SAAS,QAAsF,CAAC;AAE7G,wBAAsB,+BAA+B,kBAqBpD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,UAE9C;AAED,wBAAgB,YAAY,SAM3B;AAED,wBAAgB,cAAc,IAAI,MAAM,CAGvC;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA4B/E;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,oBAAoB;;;EAKtE;AAgBD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,oBAAoB,EAAE,KAAK,GAAE,OAAe,GAAG,aAAa,CAa1G;AAED,wBAAsB,OAAO,CAAC,SAAS,EAAE,oBAAoB,iBAc5D"}
+{"version":3,"file":"common-utils.d.ts","sourceRoot":"","sources":["../../../src/ssh/__tests__/common-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAI3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAK1C,eAAO,MAAM,cAAc,QAA2D,CAAC;AASvF,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAgB/E;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,oBAAoB;;;EAKtE;AAgBD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,oBAAoB,EAAE,KAAK,GAAE,OAAe,GAAG,aAAa,CAa1G;AAED,wBAAsB,OAAO,CAAC,SAAS,EAAE,oBAAoB,iBAE5D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-deployments",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "pl-version": "1.35.2",
   "description": "MiLaboratories Platforma Backend code service run wrapper",
   "engines": {
@@ -38,7 +38,7 @@
     "testcontainers": "^10.18.0",
     "ts-jest": "^29.2.6",
     "tsconfig-paths": "^4.2.0",
-    "typescript": "~5.5.4",
+    "typescript": "~5.6.3",
     "utility-types": "^3.11.0",
     "vite": "^6.3.5",
     "vitest": "^2.1.9",

package/src/ssh/__tests__/common-utils.ts

@@ -1,90 +1,41 @@
 import type { StartedTestContainer } from 'testcontainers';
 import { GenericContainer } from 'testcontainers';
-import { writeFileSync, readFileSync, unlinkSync, existsSync } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
+import { readFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
 import type { ConnectConfig } from 'ssh2';
-import ssh from 'ssh2';
 import fs from 'node:fs';
 
 const SSH_PORT = [22, 3001];
 
-const publicKeyPath = getPathForFile('pub-key.pub');
-const privateKeyPath = getPathForFile('private-key.private');
+export const testAssetsPath = path.resolve(__dirname, '..', '..', '..', 'test-assets');
 
-export const localFileUpload = getPathForFile('test-file.txt');
-export const localFileDownload = getPathForFile('test-file-download.txt');
-export const downloadsFolder = path.resolve(__dirname, '..', '..', '..', 'test-assets', 'downloads');
-export const recUpload = path.resolve(__dirname, '..', '..', '..', 'test-assets', 'downloads', 'rec-upload');
-
-export async function createTestDirForRecursiveUpload() {
-  const pathBase = path.resolve(__dirname, '..', '..', '..', 'test-assets', 'downloads', 'rec-upload', 'sub-1');
-  const path2 = path.resolve(__dirname, '..', '..', '..', 'test-assets', 'downloads', 'rec-upload', 'sub-1', 'sub-1-1');
-
-  await mkdir(pathBase, { recursive: true });
-  await mkdir(path2, { recursive: true });
-
-  for (let i = 0; i < 19; i++) {
-    const path2 = path.resolve(__dirname, '..', '..', '..', 'test-assets', 'downloads', 'rec-upload', 'sub-1', `sub-1-${i}`);
-    await mkdir(path2, { recursive: true });
-
-    for (let i = 0; i < 3; i++) {
-      writeFileSync(path.resolve(path2, `test-${i}.txt`), `test-${i}`);
-    }
-  }
-
-  for (let i = 1; i < 100; i++) {
-    writeFileSync(path.resolve(pathBase, `test-${i}.txt`), `test-${i}`);
-  }
-  writeFileSync(path.resolve(pathBase, `test.txt`), `test-1`);
-  writeFileSync(path.resolve(path2, 'test-5.txt'), 'test-5');
-}
-
-export function getPathForFile(fileName: string) {
-  return path.resolve(__dirname, '..', '..', '..', 'test-assets', fileName);
+const publicKeyPath = path.resolve(testAssetsPath, 'public-key.pem');
+const privateKeyPath = path.resolve(testAssetsPath, 'private-key.pem');
+if (!existsSync(publicKeyPath) || !existsSync(privateKeyPath)) {
+  console.error('SSH keys does not exist, see pl-deployments/README.md and regenerate them');
+  process.exit(1);
 }
 
-export function generateKeys() {
-  const keys = ssh.utils.generateKeyPairSync('ecdsa', { bits: 256, comment: 'node.js rules!', passphrase: 'password', cipher: 'aes256-cbc' });
-  if (!existsSync(publicKeyPath) || !existsSync(privateKeyPath)) {
-    writeFileSync(publicKeyPath, keys.public);
-    writeFileSync(privateKeyPath, keys.private);
-  }
-}
-
-export function initPrivateKey(): string {
-  generateKeys();
+export function readPrivateKey(): string {
   return readFileSync(privateKeyPath, { encoding: 'utf-8' });
 }
 
 export async function initContainer(name: string): Promise<StartedTestContainer> {
-  await createTestDirForRecursiveUpload();
-
   const imageName = `pl-ssh-test-container-${name}:1.0.0`;
   const containerName = `pl-ssh-test-${name}`;
 
-  try {
-    const container = new GenericContainer(imageName)
-      .withExposedPorts(...SSH_PORT)
-      .withReuse()
-      .withName(containerName);
-
-    return await container.start();
-  } catch {
-    console.log('No worries, creating a new container');
+  console.log('No worries, creating a new container');
 
-    generateKeys();
-    const container = await GenericContainer
-      .fromDockerfile(path.resolve(__dirname, '..', '..', '..'))
-      .withCache(true)
-      .build(imageName, { deleteOnExit: false });
+  const container = await GenericContainer
+    .fromDockerfile(path.resolve(__dirname, '..', '..', '..'))
+    .withCache(true)
+    .build(imageName, { deleteOnExit: false });
 
-    return await container
-      .withExposedPorts(...SSH_PORT)
-      .withReuse()
-      .withName(containerName)
-      .start();
-  }
+  return await container
+    .withExposedPorts(...SSH_PORT)
+    .withReuse()
+    .withName(containerName)
+    .start();
 }
 
 export function getContainerHostAndPort(container: StartedTestContainer) {
@@ -96,7 +47,7 @@ export function getContainerHostAndPort(container: StartedTestContainer) {
 
 function logToFile(message: string) {
   const logFileName = 'log.txt';
-  const logFilePath = path.join(__dirname, '..', '..', '..', 'test-assets', logFileName);
+  const logFilePath = path.join(testAssetsPath, logFileName);
 
   const timestamp = new Date().toISOString();
   const logMessage = `[${timestamp}] ${message}\n`;
@@ -110,7 +61,7 @@ function logToFile(message: string) {
 
 export function getConnectionForSsh(container: StartedTestContainer, debug: boolean = false): ConnectConfig {
   const hostData = getContainerHostAndPort(container);
-  const privateKey = initPrivateKey();
+  const privateKey = readPrivateKey();
   const config = {
     host: hostData.host,
     port: hostData.port,
@@ -125,16 +76,4 @@ export function getConnectionForSsh(container: StartedTestContainer, debug: bool
 
 export async function cleanUp(container: StartedTestContainer) {
   await container.stop();
-
-  if (existsSync(localFileUpload)) {
-    unlinkSync(localFileUpload);
-  }
-
-  if (existsSync(localFileDownload)) {
-    unlinkSync(localFileDownload);
-  }
-
-  if (existsSync(recUpload)) {
-    await rm(recUpload, { recursive: true });
-  }
 }

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

@@ -1,5 +1,5 @@
 import { describe, it, beforeAll, expect, afterAll } from 'vitest';
-import { initContainer, getConnectionForSsh, cleanUp as cleanUpT } from './common-utils';
+import { initContainer, getConnectionForSsh, cleanUp as cleanUpT, testAssetsPath } from './common-utils';
 import { SshPl } from '../pl';
 import upath from 'upath';
 import { getDefaultPlVersion } from '../../common/pl_version';
@@ -10,19 +10,11 @@ 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');
+const testContainer = await initContainer('pl');
 
-async function cleanUp() {
-  const version = getDefaultPlVersion();
-  const arch = await sshPl.getArch();
-  const tgzName = 'supervisord-0.7.3';
+const downloadDestination = upath.resolve(testAssetsPath, 'downloads');
 
-  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));
@@ -240,6 +232,16 @@ describe('SshPl', async () => {
   });
 });
 
+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 });
+}
+
 afterAll(async () => {
   await cleanUp();
   await cleanUpT(testContainer);

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

@@ -1,20 +1,25 @@
 import type { StartedTestContainer } from 'testcontainers';
 import { describe, it, beforeAll, afterAll, expect } from 'vitest';
-import { writeFileSync, readFileSync } from 'fs';
+import * as fs from 'node:fs/promises';
 import { SshClient } from '../ssh';
 import ssh from 'ssh2';
-import { downloadsFolder, cleanUp, getConnectionForSsh, getContainerHostAndPort, initContainer, localFileDownload, localFileUpload } from './common-utils';
+import { cleanUp, getConnectionForSsh, getContainerHostAndPort, initContainer, testAssetsPath } from './common-utils';
 import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
+import path from 'path';
+import { fileExists } from '@milaboratories/ts-helpers';
 
 let client: SshClient;
 let testContainer: StartedTestContainer;
 
+export const localFileUpload = path.resolve(testAssetsPath, 'test-file.txt');
+export const localFileDownload = path.resolve(testAssetsPath, 'test-file-download.txt');
+export const downloadsFolder = path.resolve(testAssetsPath, 'downloads');
+export const recUpload = path.resolve(testAssetsPath, 'downloads', 'rec-upload');
+
 beforeAll(async () => {
-  // FIXME: sometimes it fails with the error here.
-  // Then we will have a container available in docker ps.
-  // If it happened, try to retry to build the container the second time here and ask me (Gleb).
   testContainer = await initContainer('ssh');
   client = await SshClient.init(new ConsoleLoggerAdapter(), getConnectionForSsh(testContainer));
+  await createTestDirForRecursiveUpload();
 }, 200000);
 
 describe('SSH Tests', () => {
@@ -94,7 +99,7 @@ describe('SSH Tests', () => {
   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);
+    await fs.writeFile(localFileUpload, data);
     const result = await client.uploadFile(localFileUpload, remoteFile);
     expect(result).toBe(true);
     const execResult = await testContainer.exec(['cat', remoteFile]);
@@ -107,14 +112,14 @@ describe('SSH Tests', () => {
     // const localFile = './test-file-upload.txt';
     const remoteFile = '/home/pl-doctor/uploaded-file.txt';
 
-    writeFileSync(localFileDownload, data);
+    await fs.writeFile(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);
+    expect(await fs.readFile(localFileDownload, { encoding: 'utf-8' })).toBe(data);
   });
 
   it('Simple server should forward remote SSH port to a local port', async () => {
@@ -246,6 +251,44 @@ describe('sshExec', () => {
   });
 });
 
+export async function createTestDirForRecursiveUpload() {
+  const pathBase = path.resolve(testAssetsPath, 'downloads', 'rec-upload', 'sub-1');
+  const path2 = path.resolve(testAssetsPath, 'downloads', 'rec-upload', 'sub-1', 'sub-1-1');
+
+  await fs.mkdir(pathBase, { recursive: true });
+  await fs.mkdir(path2, { recursive: true });
+
+  for (let i = 0; i < 19; i++) {
+    const path2 = path.resolve(testAssetsPath, 'downloads', 'rec-upload', 'sub-1', `sub-1-${i}`);
+    await fs.mkdir(path2, { recursive: true });
+
+    for (let i = 0; i < 3; i++) {
+      await fs.writeFile(path.resolve(path2, `test-${i}.txt`), `test-${i}`);
+    }
+  }
+
+  for (let i = 1; i < 100; i++) {
+    await fs.writeFile(path.resolve(pathBase, `test-${i}.txt`), `test-${i}`);
+  }
+  await fs.writeFile(path.resolve(pathBase, `test.txt`), `test-1`);
+  await fs.writeFile(path.resolve(path2, 'test-5.txt'), 'test-5');
+}
+
+export async function cleanUpTestAssets() {
+  if (await fileExists(localFileUpload)) {
+    await fs.unlink(localFileUpload);
+  }
+
+  if (await fileExists(localFileDownload)) {
+    await fs.unlink(localFileDownload);
+  }
+
+  if (await fileExists(recUpload)) {
+    await fs.rm(recUpload, { recursive: true });
+  }
+}
+
 afterAll(async () => {
+  await cleanUpTestAssets();
   await cleanUp(testContainer);
 }, 200000);