libdragon 10.2.1 → 10.4.1

package/modules/actions/index.js

@@ -0,0 +1,43 @@
+const { spawnProcess } = require('../helpers');
+const { checkContainerRunning } = require('./utils');
+
+const { fn: exec } = require('./exec');
+
+const stop = async (libdragonInfo) => {
+  const running =
+    libdragonInfo.containerId &&
+    (await checkContainerRunning(libdragonInfo.containerId));
+  if (!running) {
+    return;
+  }
+
+  await spawnProcess('docker', ['container', 'stop', running]);
+};
+
+const make = async (libdragonInfo, params) => {
+  await exec(libdragonInfo, ['make', ...params]);
+};
+
+// TODO: separate into files
+module.exports = {
+  start: require('./start'),
+  stop: {
+    name: 'stop',
+    fn: stop,
+    showStatus: false, // This will only print out the id
+  },
+  init: require('./init'),
+
+  exec: require('./exec'),
+  make: {
+    name: 'make',
+    fn: make,
+    forwardsRestParams: true,
+    showStatus: true,
+  },
+
+  install: require('./install'),
+  update: require('./update'),
+
+  help: require('./help'),
+};

package/modules/actions/init.js

@@ -0,0 +1,190 @@
+const fs = require('fs/promises');
+const path = require('path');
+
+const chalk = require('chalk');
+
+const { fn: install } = require('./install');
+const { fn: start } = require('./start');
+const {
+  installDependencies,
+  tryCacheContainerId,
+  updateImage,
+  runGitMaybeHost,
+} = require('./utils');
+
+const {
+  LIBDRAGON_PROJECT_MANIFEST,
+  LIBDRAGON_SUBMODULE,
+  LIBDRAGON_BRANCH,
+  LIBDRAGON_GIT,
+} = require('../constants');
+const {
+  log,
+  copyDirContents,
+  CommandError,
+  ParameterError,
+} = require('../helpers');
+const { setProjectInfoToSave } = require('../project-info');
+
+const autoVendor = async (libdragonInfo) => {
+  await runGitMaybeHost(libdragonInfo, ['init']);
+
+  if (libdragonInfo.vendorStrategy === 'submodule') {
+    await runGitMaybeHost(libdragonInfo, [
+      'submodule',
+      'add',
+      '--force',
+      '--name',
+      LIBDRAGON_SUBMODULE,
+      '--branch',
+      LIBDRAGON_BRANCH,
+      LIBDRAGON_GIT,
+      libdragonInfo.vendorDirectory,
+    ]);
+  } else if (libdragonInfo.vendorStrategy === 'subtree') {
+    // Create a commit if it does not exist. This is required for subtree.
+    try {
+      await runGitMaybeHost(libdragonInfo, ['rev-parse', 'HEAD']);
+    } catch (e) {
+      if (!(e instanceof CommandError)) throw e;
+
+      // This will throw if git user name/email is not set up. Let's not assume
+      // anything for now. This means subtree is not supported for someone without
+      // git on the host machine.
+      await runGitMaybeHost(libdragonInfo, [
+        'commit',
+        '--allow-empty',
+        '-n',
+        '-m',
+        'Initial commit.',
+      ]);
+    }
+
+    await runGitMaybeHost(libdragonInfo, [
+      'subtree',
+      'add',
+      '--prefix',
+      path.relative(libdragonInfo.root, libdragonInfo.vendorDirectory),
+      LIBDRAGON_GIT,
+      LIBDRAGON_BRANCH,
+      '--squash',
+    ]);
+  }
+
+  return libdragonInfo;
+};
+
+/**
+ * Initialize a new libdragon project in current working directory
+ * Also downloads the image
+ */
+async function init(libdragonInfo) {
+  log(`Initializing a libdragon project at ${libdragonInfo.root}`);
+
+  // TODO: use exists instead & check if it is a directory
+  const files = await fs.readdir(libdragonInfo.root);
+
+  const manifestFile = files.find(
+    (name) => name === LIBDRAGON_PROJECT_MANIFEST
+  );
+
+  let newInfo = libdragonInfo;
+
+  // Validate vendoring strategy. Do not allow a switch after successful initialization
+  if (
+    manifestFile &&
+    newInfo.options.VENDOR_STRAT &&
+    newInfo.options.VENDOR_STRAT !== 'manual' &&
+    newInfo.vendorStrategy !== newInfo.options.VENDOR_STRAT
+  ) {
+    throw new Error(
+      `Requested strategy switch: ${newInfo.vendorStrategy} -> ${newInfo.options.VENDOR_STRAT} It is not possible to switch vendoring strategy after initializing a project. You can always switch to manual and handle libdragon yourself.`
+    );
+  }
+
+  // Update the strategy information for the project if the flag is provided
+  if (newInfo.options.VENDOR_STRAT) {
+    newInfo = setProjectInfoToSave({
+      ...newInfo,
+      vendorStrategy: newInfo.options.VENDOR_STRAT,
+    });
+  }
+
+  // Update the directory information for the project if the flag is provided
+  if (newInfo.options.VENDOR_DIR) {
+    // Validate vendoring path
+    if (path.isAbsolute(newInfo.options.VENDOR_DIR)) {
+      throw new ParameterError(
+        '`--directory` must be project-relative as it will be mounted to the docker container.'
+      );
+    }
+
+    newInfo = setProjectInfoToSave({
+      ...newInfo,
+      vendorDirectory: newInfo.options.VENDOR_DIR,
+    });
+  }
+
+  if (manifestFile) {
+    log(
+      `${path.join(
+        newInfo.root,
+        manifestFile
+      )} exists. This is already a libdragon project, starting it...`
+    );
+    if (newInfo.options.DOCKER_IMAGE) {
+      log(
+        `Not changing docker image. Use the install action if you want to override the image.`
+      );
+    }
+    await install(newInfo);
+    return;
+  }
+
+  newInfo.imageName =
+    (await updateImage(newInfo, newInfo.imageName)) || newInfo.imageName;
+  // Download image and start it
+  const containerReadyPromise = start(newInfo).then((newId) => ({
+    ...newInfo,
+    containerId: newId,
+  }));
+
+  let vendorAndGitReadyPromise = containerReadyPromise;
+  if (newInfo.vendorStrategy !== 'manual') {
+    const libdragonFile = files.find((name) =>
+      name.match(
+        new RegExp(`^${path.relative(newInfo.root, newInfo.vendorDirectory)}$`)
+      )
+    );
+
+    if (libdragonFile) {
+      throw new Error(
+        `${path.join(
+          newInfo.root,
+          libdragonFile
+        )} already exists. That is the libdragon vendoring target, please remove and retry.`
+      );
+    }
+
+    vendorAndGitReadyPromise = containerReadyPromise.then(autoVendor);
+  }
+
+  log(`Preparing project files...`);
+  const skeletonFolder = path.join(__dirname, '../../skeleton');
+
+  await Promise.all([
+    // We have created a new container, save the new info
+    vendorAndGitReadyPromise.then(tryCacheContainerId),
+    vendorAndGitReadyPromise.then(installDependencies),
+    // node copy functions does not work with pkg
+    copyDirContents(skeletonFolder, newInfo.root),
+  ]);
+
+  log(chalk.green(`libdragon ready at \`${newInfo.root}\`.`));
+}
+
+module.exports = {
+  name: 'init',
+  fn: init,
+  showStatus: true,
+};

package/modules/actions/install.js

@@ -0,0 +1,52 @@
+const { log } = require('../helpers');
+const {
+  destroyContainer,
+  installDependencies,
+  updateImage,
+} = require('./utils');
+const { fn: start } = require('./start');
+
+/**
+ * Updates the image if flag is provided and install vendors onto the container.
+ * We should probably remove the image installation responsibility from this
+ * action but it might be a breaking change. Maybe we can keep it backward
+ * compatible with additional flags.
+ * @param libdragonInfo
+ */
+const install = async (libdragonInfo) => {
+  let containerId;
+  const oldImageName = libdragonInfo.imageName;
+  const imageName = libdragonInfo.options.DOCKER_IMAGE;
+  // If an image is provided, always attempt to install it
+  // See https://github.com/anacierdem/libdragon-docker/issues/47
+  if (imageName) {
+    log(`Changing image from \`${oldImageName}\` to \`${imageName}\``);
+
+    // Download the new image and if it is different, re-create the container
+    if (await updateImage(libdragonInfo, imageName)) {
+      await destroyContainer(libdragonInfo);
+    }
+
+    containerId = await start({
+      ...libdragonInfo,
+      imageName,
+    });
+  } else {
+    // Make sure existing one is running
+    containerId = await start(libdragonInfo);
+  }
+
+  // Re-install vendors on new image
+  // TODO: skip this if unnecessary
+  await installDependencies({
+    ...libdragonInfo,
+    imageName,
+    containerId,
+  });
+};
+
+module.exports = {
+  name: 'install',
+  fn: install,
+  showStatus: true,
+};

package/modules/actions/start.js

@@ -0,0 +1,114 @@
+const chalk = require('chalk');
+
+const { CONTAINER_TARGET_PATH } = require('../constants');
+const { spawnProcess, log, dockerExec } = require('../helpers');
+const { setProjectInfoToSave } = require('../project-info');
+
+const {
+  checkContainerAndClean,
+  checkContainerRunning,
+  destroyContainer,
+} = require('./utils');
+
+/**
+ * Create a new container
+ */
+const initContainer = async (libdragonInfo) => {
+  let newId;
+  try {
+    // Create a new container
+    libdragonInfo.showStatus && log('Creating new container...');
+    newId = (
+      await spawnProcess('docker', [
+        'run',
+        '-d', // Detached
+        '--mount',
+        'type=bind,source=' +
+          libdragonInfo.root +
+          ',target=' +
+          CONTAINER_TARGET_PATH, // Mount files
+        '-w=' + CONTAINER_TARGET_PATH, // Set working directory
+        libdragonInfo.imageName,
+        'tail',
+        '-f',
+        '/dev/null',
+      ])
+    ).trim();
+
+    const newInfo = {
+      ...libdragonInfo,
+      containerId: newId,
+    };
+
+    // chown the installation folder once on init
+    const { uid, gid } = libdragonInfo.userInfo;
+    await dockerExec(newInfo, [
+      'chown',
+      '-R',
+      `${uid >= 0 ? uid : ''}:${gid >= 0 ? gid : ''}`,
+      '/n64_toolchain',
+    ]);
+  } catch (e) {
+    // Dispose the invalid container, clean and exit
+    await destroyContainer({
+      ...libdragonInfo,
+      containerId: newId,
+    });
+    log(
+      chalk.red(
+        'We were unable to initialize libdragon. Done cleanup. Check following logs for the actual error.'
+      )
+    );
+    throw e;
+  }
+
+  const name = await spawnProcess('docker', [
+    'container',
+    'inspect',
+    newId,
+    '--format',
+    '{{.Name}}',
+  ]);
+
+  libdragonInfo.showStatus &&
+    log(
+      chalk.green(`Successfully initialized docker container: ${name.trim()}`)
+    );
+
+  // Schedule an update to write image name
+  setProjectInfoToSave(libdragonInfo);
+  return newId;
+};
+
+const start = async (libdragonInfo) => {
+  const running =
+    libdragonInfo.containerId &&
+    (await checkContainerRunning(libdragonInfo.containerId));
+
+  if (running) {
+    log(`Container ${running} already running.`, true);
+    log(libdragonInfo.containerId);
+    return running;
+  }
+
+  let id = await checkContainerAndClean(libdragonInfo);
+
+  if (!id) {
+    log(`Container does not exist, re-initializing...`, true);
+    id = await initContainer(libdragonInfo);
+    log(id);
+    return id;
+  }
+
+  log(`Starting container: ${id}`, true);
+  await spawnProcess('docker', ['container', 'start', id]);
+
+  log(id);
+  return id;
+};
+
+module.exports = {
+  name: 'start',
+  fn: start,
+  showStatus: false, // This will only print out the id
+};

package/modules/actions/update.js

@@ -0,0 +1,48 @@
+const path = require('path');
+
+const { log } = require('../helpers');
+const { LIBDRAGON_GIT, LIBDRAGON_BRANCH } = require('../constants');
+const { runGitMaybeHost } = require('./utils');
+const { fn: start } = require('./start');
+const { fn: install } = require('./install');
+
+const update = async (libdragonInfo) => {
+  const containerId = await start(libdragonInfo);
+
+  const newInfo = {
+    ...libdragonInfo,
+    containerId,
+  };
+
+  if (newInfo.vendorStrategy !== 'manual') {
+    log(`Updating ${newInfo.vendorStrategy}...`);
+  }
+
+  if (newInfo.vendorStrategy === 'submodule') {
+    await runGitMaybeHost(newInfo, [
+      'submodule',
+      'update',
+      '--remote',
+      '--merge',
+      newInfo.vendorDirectory,
+    ]);
+  } else if (newInfo.vendorStrategy === 'subtree') {
+    await runGitMaybeHost(newInfo, [
+      'subtree',
+      'pull',
+      '--prefix',
+      path.relative(libdragonInfo.root, libdragonInfo.vendorDirectory),
+      LIBDRAGON_GIT,
+      LIBDRAGON_BRANCH,
+      '--squash',
+    ]);
+  }
+
+  await install(newInfo);
+};
+
+module.exports = {
+  name: 'update',
+  fn: update,
+  showStatus: true,
+};