piston/api/src/package.js

const logger = require('logplease').create('package');
const semver = require('semver');
const config = require('./config');
const globals = require('./globals');
const fetch = require('node-fetch');
const path = require('path');
const fs = require('fs/promises');
const fss = require('fs');
const cp = require('child_process');
const crypto = require('crypto');
const runtime = require('./runtime');
const chownr = require('chownr');
const util = require('util');

class Package {
  constructor({ language, version, download, checksum }) {
    this.language = language;
    this.version = semver.parse(version);
    this.checksum = checksum;
    this.download = download;
  }

  get installed() {
    return fss.exists_sync(
      path.join(this.install_path, globals.pkg_installed_file)
    );
  }

  get install_path() {
    return path.join(
      config.data_directory,
      globals.data_directories.packages,
      this.language,
      this.version.raw
    );
  }

  async install() {
    if (this.installed) {
      throw new Error('Already installed');
    }

    logger.info(`Installing ${this.language}-${this.version.raw}`);

    if (fss.exists_sync(this.install_path)) {
      logger.warn(
        `${this.language}-${this.version.raw} has residual files. Removing them.`
      );
      await fs.rm(this.install_path, { recursive: true, force: true });
    }

    logger.debug(`Making directory ${this.install_path}`);
    await fs.mkdir(this.install_path, { recursive: true });

    logger.debug(
      `Downloading package from ${this.download} in to ${this.install_path}`
    );
    const pkgpath = path.join(this.install_path, 'pkg.tar.gz');
    const download = await fetch(this.download);

    const file_stream = fss.create_write_stream(pkgpath);
    await new Promise((resolve, reject) => {
      download.body.pipe(file_stream);
      download.body.on('error', reject);

      file_stream.on('finish', resolve);
    });

    logger.debug('Validating checksums');
    logger.debug(`Assert sha256(pkg.tar.gz) == ${this.checksum}`);
    const cs = crypto
      .create_hash('sha256')
      .update(fss.readFileSync(pkgpath))
      .digest('hex');

    if (cs !== this.checksum) {
      throw new Error(`Checksum miss-match want: ${val} got: ${cs}`);
    }

    logger.debug(
      `Extracting package files from archive ${pkgpath} in to ${this.install_path}`
    );

    await new Promise((resolve, reject) => {
      const proc = cp.exec(
        `bash -c 'cd "${this.install_path}" && tar xzf ${pkgpath}'`
      );

      proc.once('exit', (code, _) => {
        code === 0 ? resolve() : reject();
      });

      proc.stdout.pipe(process.stdout);
      proc.stderr.pipe(process.stderr);

      proc.once('error', reject);
    });

    logger.debug('Registering runtime');
    runtime.load_package(this.install_path);

    logger.debug('Caching environment');
    const get_env_command = `cd ${this.install_path}; source environment; env`;

    const envout = await new Promise((resolve, reject) => {
      let stdout = '';

      const proc = cp.spawn('env', ['-i', 'bash', '-c', `${get_env_command}`], {
        stdio: ['ignore', 'pipe', 'pipe'],
      });

      proc.once('exit', (code, _) => {
        code === 0 ? resolve(stdout) : reject();
      });

      proc.stdout.on('data', (data) => {
        stdout += data;
      });

      proc.once('error', reject);
    });

    const filtered_env = envout
      .split('\n')
      .filter(
        (l) => !['PWD', 'OLDPWD', '_', 'SHLVL'].includes(l.split('=', 2)[0])
      )
      .join('\n');

    await fs.write_file(path.join(this.install_path, '.env'), filtered_env);

    logger.debug('Changing Ownership of package directory');
    await util.promisify(chownr)(this.install_path, 0, 0);

    logger.debug('Writing installed state to disk');
    await fs.write_file(
      path.join(this.install_path, globals.pkg_installed_file),
      Date.now().toString()
    );

    logger.info(`Installed ${this.language}-${this.version.raw}`);

    return {
      language: this.language,
      version: this.version.raw,
    };
  }

  async uninstall() {
    logger.info(`Uninstalling ${this.language}-${this.version.raw}`);

    logger.debug('Finding runtime');
    const found_runtime = runtime.get_runtime_by_name_and_version(
      this.language,
      this.version.raw
    );

    if (!found_runtime) {
      logger.error(
        `Uninstalling ${this.language}-${this.version.raw} failed: Not installed`
      );
      throw new Error(`${this.language}-${this.version.raw} is not installed`);
    }

    logger.debug('Unregistering runtime');
    found_runtime.unregister();

    logger.debug('Cleaning files from disk');
    await fs.rmdir(this.install_path, { recursive: true });

    logger.info(`Uninstalled ${this.language}-${this.version.raw}`);

    return {
      language: this.language,
      version: this.version.raw,
    };
  }

  static async get_package_list() {
    const repo_content = await fetch(config.repo_url).then((x) => x.text());

    const entries = repo_content.split('\n').filter((x) => x.length > 0);

    return entries.map((line) => {
      const [language, version, checksum, download] = line.split(',', 4);

      return new Package({
        language,
        version,
        checksum,
        download,
      });
    });
  }

  static async get_package(lang, version) {
    const packages = await Package.get_package_list();

    const candidates = packages.filter((pkg) => {
      return pkg.language == lang && semver.satisfies(pkg.version, version);
    });

    candidates.sort((a, b) => semver.rcompare(a.version, b.version));

    return candidates[0] || null;
  }
}

module.exports = Package;