@platforma-sdk/bootstrap 2.0.0 → 2.0.1

package/src/package.ts

@@ -1,54 +0,0 @@
-import { resolve, join } from 'path';
-import fs from 'fs';
-import os from 'os';
-
-export function path(...p: string[]): string {
-  return resolve(__dirname, '..', ...p);
-}
-
-export function dist(...p: string[]): string {
-  return path('dist', ...p);
-}
-
-export function assets(...p: string[]): string {
-  return path('assets', ...p);
-}
-
-export function binaries(...p: string[]): string {
-  return path('binaries', ...p);
-}
-
-export function composeFiles(): string[] {
-  const dockerDirEntries = fs.readdirSync(assets());
-  return dockerDirEntries
-    .filter((entry) => {
-      return entry.startsWith('compose-') && entry.endsWith('.yaml');
-    })
-    .map((value) => assets(value));
-}
-
-export function readFileSync(...p: string[]): Buffer {
-  return fs.readFileSync(path(...p));
-}
-
-export type packageJson = {
-  'pl-version': string;
-};
-
-var _packageJson: packageJson;
-
-export function getPackageJson(): packageJson {
-  if (!_packageJson) {
-    _packageJson = JSON.parse(readFileSync('package.json').toString());
-  }
-
-  return _packageJson;
-}
-
-export function plImageTag(version?: string): string {
-  if (!version) {
-    version = getPackageJson()['pl-version'];
-  }
-
-  return `quay.io/milaboratories/platforma:${version}`;
-}

package/src/platforma.ts

@@ -1,194 +0,0 @@
-import os from 'os';
-import fs from 'fs';
-import https from 'https';
-import * as tar from 'tar';
-import winston from 'winston';
-import * as pkg from './package';
-import path from 'path';
-
-export const OSes = ['linux', 'macos', 'windows'] as const;
-export type OSType = (typeof OSes)[number];
-
-export function archiveOS(osName?: string): OSType {
-  const platform = osName ?? os.platform();
-
-  switch (platform) {
-    case 'darwin':
-      return 'macos';
-    case 'linux':
-      return 'linux';
-    case 'win32':
-      return 'windows';
-    default:
-      throw new Error(
-        `operating system '${platform}' is not currently supported by Platforma ecosystem. The list of OSes supported: ` +
-          JSON.stringify(OSes)
-      );
-  }
-}
-
-export const Arches = ['amd64', 'arm64'] as const;
-export type ArchType = (typeof Arches)[number];
-
-export function archiveArch(archName?: string): ArchType {
-  const arch = archName ?? os.arch();
-
-  switch (arch) {
-    case 'arm64':
-      return 'arm64';
-    case 'x64':
-      return 'amd64';
-    default:
-      throw new Error(
-        `processor architecture '${arch}' is not currently supported by Platforma ecosystem. The list of architectures supported: ` +
-          JSON.stringify(Arches)
-      );
-  }
-}
-
-export function downloadArchive(
-  logger: winston.Logger,
-  options?: {
-    version?: string;
-    showProgress?: boolean;
-    downloadURL?: string;
-    saveTo?: string;
-  }
-): Promise<string> {
-  const version = options?.version ?? pkg.getPackageJson()['pl-version'];
-  const showProgress = options?.showProgress ?? process.stdout.isTTY;
-
-  const archiveName = `pl-${version}-${archiveArch()}.tgz`;
-  const downloadURL = options?.downloadURL ?? `https://cdn.platforma.bio/software/pl/${archiveOS()}/${archiveName}`;
-
-  const archiveFilePath = options?.saveTo ?? pkg.binaries(archiveName);
-  if (fs.existsSync(archiveFilePath)) {
-    logger.info(`Platforma Backend archive download skipped: '${archiveFilePath}' already exists`);
-    return Promise.resolve(archiveFilePath);
-  }
-
-  fs.mkdirSync(path.dirname(archiveFilePath), { recursive: true });
-
-  logger.info(`Downloading Platforma Backend archive:\n  URL:     ${downloadURL}\n  Save to: ${archiveFilePath}`);
-
-  const request = https.get(downloadURL);
-
-  return new Promise((resolve, reject) => {
-    request.on('response', (response) => {
-      if (!response.statusCode) {
-        const err = new Error('failed to download archive: no HTTP status code in response from server');
-        request.destroy();
-        reject(err);
-        return;
-      }
-      if (response.statusCode !== 200) {
-        const err = new Error(`failed to download archive: ${response.statusCode} ${response.statusMessage}`);
-        request.destroy();
-        reject(err);
-        return;
-      }
-
-      const totalBytes = parseInt(response.headers['content-length'] || '0', 10);
-      let downloadedBytes = 0;
-
-      const archive = fs.createWriteStream(archiveFilePath);
-
-      response.pipe(archive);
-      response.on('data', (chunk) => {
-        downloadedBytes += chunk.length;
-        const progress = (downloadedBytes / totalBytes) * 100;
-        if (showProgress) {
-          process.stdout.write(`  downloading: ${progress.toFixed(2)}%\r`);
-        }
-      });
-
-      response.on('error', (err: Error) => {
-        fs.unlinkSync(archiveFilePath);
-        logger.error(`Failed to download Platforma Binary: ${err.message}`);
-        request.destroy();
-        reject(err);
-      });
-
-      archive.on('finish', () => {
-        archive.close();
-        logger.info(`  ... download done.`);
-        request.destroy();
-        resolve(archiveFilePath);
-      });
-    });
-  });
-}
-
-export function extractArchive(
-  logger: winston.Logger,
-  options?: {
-    version?: string;
-    archivePath?: string;
-    extractTo?: string;
-  }
-): string {
-  logger.debug('extracting archive...');
-
-  const version = options?.version ?? pkg.getPackageJson()['pl-version'];
-  logger.debug(`  version: '${version}'`);
-  const archiveName = `${binaryDirName({ version })}.tgz`;
-
-  const archivePath = options?.archivePath ?? pkg.binaries(archiveName);
-  logger.debug(`  archive path: '${archivePath}'`);
-
-  const targetDir = options?.extractTo ?? trimExtension(archivePath);
-  logger.debug(`  target dir: '${targetDir}'`);
-
-  if (fs.existsSync(targetDir)) {
-    logger.info(`Platforma Backend binaries unpack skipped: '${targetDir}' exists`);
-    return targetDir;
-  }
-
-  if (!fs.existsSync(archivePath)) {
-    const msg = `Platforma Backend binary archive not found at '${archivePath}'`;
-    logger.error(msg);
-    throw new Error(msg);
-  }
-
-  if (!fs.existsSync(targetDir)) {
-    logger.debug(`  creating target dir '${targetDir}'`);
-    fs.mkdirSync(targetDir, { recursive: true });
-  }
-
-  logger.info(`Unpacking Platforma Backend archive:\n  Archive:   ${archivePath}\n  Target dir: ${targetDir}`);
-
-  tar.x({
-    file: archivePath,
-    cwd: targetDir,
-    gzip: true,
-    sync: true
-  });
-
-  logger.info(`  ... unpack done.`);
-
-  return targetDir;
-}
-
-export function getBinary(
-  logger: winston.Logger,
-  options?: { version?: string; showProgress?: boolean }
-): Promise<string> {
-  return downloadArchive(logger, options).then((archivePath) => extractArchive(logger, { archivePath }));
-}
-
-function binaryDirName(options?: { version?: string }): string {
-  const version = options?.version ?? pkg.getPackageJson()['pl-version'];
-  return `pl-${version}-${archiveArch()}`;
-}
-
-export function binaryPath(version?: string, ...p: string[]): string {
-  return pkg.binaries(binaryDirName({ version }), ...p);
-}
-
-function trimExtension(filename: string): string {
-  const lastDotIndex = filename.lastIndexOf('.');
-  if (lastDotIndex === -1) {
-    return filename;
-  }
-  return filename.slice(0, lastDotIndex);
-}

package/src/run.ts

@@ -1,120 +0,0 @@
-import fs from 'fs';
-import { spawnSync, SpawnOptions, SpawnSyncReturns, ChildProcess, spawn } from 'child_process';
-import state, { dockerRunInfo, processRunInfo } from './state';
-import winston from 'winston';
-
-export function runDocker(
-  logger: winston.Logger,
-  args: readonly string[],
-  options: SpawnOptions,
-  stateToSave?: dockerRunInfo
-) {
-  state.lastRun = {
-    ...state.lastRun,
-
-    mode: 'docker',
-    cmd: 'docker',
-    args: args,
-    workdir: options.cwd as string,
-    envs: options.env,
-
-    docker: {
-      ...state.lastRun?.docker,
-      ...stateToSave
-    }
-  };
-
-  return runSync(logger, 'docker', args, options);
-}
-
-export function runProcess(
-  logger: winston.Logger,
-  cmd: string,
-  args: readonly string[],
-  options: SpawnOptions,
-  stateToSave?: processRunInfo
-): ChildProcess {
-  state.lastRun = {
-    ...state.lastRun,
-
-    mode: 'process',
-    cmd: cmd,
-    args: args,
-    workdir: options.cwd as string,
-    envs: options.env,
-
-    process: {
-      ...state.lastRun?.process,
-      ...stateToSave
-    }
-  };
-
-  const result = run(logger, cmd, args, options);
-  state.lastRun.process = {
-    ...state.lastRun.process,
-    pid: result.pid
-  };
-  return result;
-}
-
-export function rerunLast(logger: winston.Logger, options: SpawnOptions): SpawnSyncReturns<Buffer> {
-  if (!state.lastRun) {
-    throw new Error('no previous run info found: this is the first run after package installation');
-  }
-
-  options = {
-    cwd: state.lastRun.workdir,
-    env: {
-      ...state.lastRun.envs,
-      ...options.env
-    },
-    ...options
-  };
-
-  return runSync(logger, state.lastRun.cmd, state.lastRun.args, options);
-}
-
-function run(logger: winston.Logger, cmd: string, args: readonly string[], options: SpawnOptions): ChildProcess {
-  logger.debug(
-    `Running:\n  env: ${JSON.stringify(options.env)}\n  cmd: ${JSON.stringify([cmd, ...args])}\n  wd: ${options.cwd}`
-  );
-
-  options.env = { ...process.env, ...options.env };
-  logger.debug('  spawning child process');
-  const child = spawn(cmd, args, options);
-  var exitAfterChild: boolean = false;
-
-  //
-  // Ensure Ctrl+C causes right finalization order: first stop child process, then stop the parent.
-  //
-  const sigintHandler = () => {
-    child.kill('SIGINT');
-    exitAfterChild = true;
-  };
-
-  logger.debug('  setting up signal handler');
-  process.on('SIGINT', sigintHandler);
-
-  child.on('close', (code) => {
-    process.removeListener('SIGINT', sigintHandler);
-    if (exitAfterChild) {
-      process.exit(code);
-    }
-  });
-
-  return child;
-}
-
-function runSync(
-  logger: winston.Logger,
-  cmd: string,
-  args: readonly string[],
-  options: SpawnOptions
-): SpawnSyncReturns<Buffer> {
-  logger.debug(
-    `Running:\n  env: ${JSON.stringify(options.env)}\n  cmd: ${JSON.stringify([cmd, ...args])}\n  wd: ${options.cwd}`
-  );
-
-  options.env = { ...process.env, ...options.env };
-  return spawnSync(cmd, args, options);
-}

package/src/state.ts

@@ -1,105 +0,0 @@
-import os from 'os';
-import fs from 'fs';
-import path from 'path';
-import * as pkg from './package';
-
-export type runMode = 'docker' | 'process';
-
-export type dockerRunInfo = {
-  plImage?: string;
-  composePath?: string;
-
-  primaryPath?: string;
-  workPath?: string;
-  libraryPath?: string;
-};
-
-export type processRunInfo = {
-  pid?: number;
-  storagePath?: string;
-};
-
-export type lastRun = {
-  docker?: dockerRunInfo;
-  process?: processRunInfo;
-
-  mode: runMode;
-  cmd: string;
-  args: readonly string[];
-  workdir?: string;
-  envs?: NodeJS.Dict<string>;
-};
-
-export function reset() {
-  fs.rmSync(State.getInstance().filePath);
-}
-
-type state = {
-  lastRun: lastRun | undefined;
-  isActive: boolean;
-};
-
-class State {
-  private static instance: State;
-
-  private state: state = {
-    lastRun: undefined,
-    isActive: false
-  };
-
-  public readonly filePath: string;
-  private readonly dirPath: string;
-
-  constructor(stateDir?: string) {
-    stateDir = stateDir ?? path.resolve(os.homedir(), '.config', 'pl-bootstrap');
-
-    const stateFile = path.join(stateDir, 'state.json');
-
-    this.dirPath = stateDir;
-    this.filePath = stateFile;
-
-    if (!fs.existsSync(stateDir)) {
-      fs.mkdirSync(stateDir, { recursive: true });
-    }
-
-    if (fs.existsSync(stateFile)) {
-      this.state = JSON.parse(pkg.readFileSync(stateFile).toString());
-    }
-  }
-
-  public static getInstance(): State {
-    if (!State.instance) {
-      State.instance = new State();
-    }
-
-    return State.instance;
-  }
-
-  public path(...p: string[]): string {
-    return path.join(this.dirPath, ...p);
-  }
-
-  private writeState() {
-    fs.writeFileSync(this.filePath, JSON.stringify(this.state));
-  }
-
-  get isActive(): boolean {
-    return this.state.isActive;
-  }
-
-  set isActive(value: boolean) {
-    this.state.isActive = value;
-    this.writeState();
-  }
-
-  get lastRun(): lastRun | undefined {
-    return this.state.lastRun;
-  }
-
-  set lastRun(info: lastRun) {
-    this.state.lastRun = info;
-    this.writeState();
-  }
-}
-
-export default State.getInstance();