libdragon 10.3.1 → 10.4.2

package/modules/actions/init.js

@@ -0,0 +1,201 @@
+const fs = require('fs/promises');
+const path = require('path');
+
+const chalk = require('chalk');
+
+const { fn: install } = require('./install');
+const { 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,
+  ValidationError,
+} = 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}`);
+
+  let newInfo = libdragonInfo;
+
+  // Validate manifest
+  const manifestPath = path.join(newInfo.root, LIBDRAGON_PROJECT_MANIFEST);
+  const manifestStats = await fs.stat(manifestPath).catch((e) => {
+    if (e.code !== 'ENOENT') throw e;
+    return false;
+  });
+
+  if (manifestStats && !manifestStats.isDirectory()) {
+    throw new ValidationError(
+      'There is already a `.libdragon` file and it is not a directory.'
+    );
+  }
+
+  // Validate vendoring strategy. Do not allow a switch after successful initialization
+  if (
+    newInfo.haveProjectConfig &&
+    newInfo.options.VENDOR_STRAT &&
+    newInfo.options.VENDOR_STRAT !== 'manual' &&
+    newInfo.vendorStrategy !== newInfo.options.VENDOR_STRAT
+  ) {
+    throw new ParameterError(
+      `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 (newInfo.haveProjectConfig) {
+    log(
+      `${path.join(
+        newInfo.root,
+        LIBDRAGON_PROJECT_MANIFEST
+      )} 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.`
+      );
+    }
+    // TODO: we may make sure git and submodule is initialized here
+    await install(newInfo);
+    return;
+  }
+
+  newInfo.imageName =
+    (await updateImage(newInfo, newInfo.imageName)) || newInfo.imageName;
+  // Download image and start it
+  const containerReadyPromise = start(newInfo, true).then((newId) => ({
+    ...newInfo,
+    containerId: newId,
+  }));
+
+  let vendorAndGitReadyPromise = containerReadyPromise;
+  if (newInfo.vendorStrategy !== 'manual') {
+    const vendorTarget = path.relative(newInfo.root, newInfo.vendorDirectory);
+    const [vendorTargetExists] = await Promise.all([
+      fs.stat(vendorTarget).catch((e) => {
+        if (e.code !== 'ENOENT') throw e;
+        return false;
+      }),
+      containerReadyPromise,
+    ]);
+
+    if (vendorTargetExists) {
+      throw new ValidationError(
+        `${path.resolve(
+          newInfo.root,
+          newInfo.vendorDirectory
+        )} 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,48 @@
+const chalk = require('chalk');
+
+const { installDependencies, mustHaveProject } = require('./utils');
+const { start } = require('./start');
+const { updateAndStart } = require('./update-and-start');
+const { log } = require('../helpers');
+
+/**
+ * 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.
+ * @param libdragonInfo
+ * @param skipUpdate This is added to skip the update when calling this from
+ * the update action as it already does an update itself. install doing an image
+ * update is pretty much a useless operation, but let's keep it in case someone
+ * depends on it. It used to only update the image if the flag is provided and
+ * we still keep that logic but with a deprecation warning.
+ */
+const install = async (libdragonInfo, skipUpdate) => {
+  await mustHaveProject(libdragonInfo);
+  let updatedInfo = libdragonInfo;
+  const imageName = libdragonInfo.options.DOCKER_IMAGE;
+  // If an image is provided, attempt to install
+  if (imageName && skipUpdate !== true) {
+    log(
+      chalk.yellow(
+        'Using `install` action to update the docker image is deprecated. Use the `update` action instead.'
+      )
+    );
+    updatedInfo = await updateAndStart(libdragonInfo);
+  } else {
+    // Make sure existing one is running
+    updatedInfo = {
+      ...updatedInfo,
+      containerId: await start(libdragonInfo),
+    };
+  }
+
+  // Re-install vendors on new image
+  // TODO: skip this if unnecessary
+  await installDependencies(updatedInfo);
+};
+
+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,
+  mustHaveProject,
+} = 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, skipProjectCheck) => {
+  !skipProjectCheck && (await mustHaveProject(libdragonInfo));
+  const running =
+    libdragonInfo.containerId &&
+    (await checkContainerRunning(libdragonInfo.containerId));
+
+  if (running) {
+    log(`Container ${running} already running.`, true);
+    return running;
+  }
+
+  let id = await checkContainerAndClean(libdragonInfo);
+
+  if (!id) {
+    log(`Container does not exist, re-initializing...`, true);
+    id = await initContainer(libdragonInfo);
+    return id;
+  }
+
+  log(`Starting container: ${id}`, true);
+  await spawnProcess('docker', ['container', 'start', id]);
+
+  return id;
+};
+
+module.exports = {
+  name: 'start',
+  fn: async (libdragonInfo) => log(await start(libdragonInfo)),
+  start,
+  showStatus: false, // This will only print out the id
+};

package/modules/actions/stop.js

@@ -0,0 +1,21 @@
+const { spawnProcess } = require('../helpers');
+
+const { checkContainerRunning, mustHaveProject } = require('./utils');
+
+const stop = async (libdragonInfo) => {
+  await mustHaveProject(libdragonInfo);
+  const running =
+    libdragonInfo.containerId &&
+    (await checkContainerRunning(libdragonInfo.containerId));
+  if (!running) {
+    return;
+  }
+
+  await spawnProcess('docker', ['container', 'stop', running]);
+};
+
+module.exports = {
+  name: 'stop',
+  fn: stop,
+  showStatus: false, // This will only print out the id
+};

package/modules/actions/update-and-start.js

@@ -0,0 +1,33 @@
+const { log } = require('../helpers');
+const { updateImage, destroyContainer } = require('./utils');
+const { start } = require('./start');
+
+async function updateAndStart(libdragonInfo) {
+  const oldImageName = libdragonInfo.imageName;
+  const imageName = libdragonInfo.options.DOCKER_IMAGE ?? oldImageName;
+  // If an image is provided, always attempt to install it
+  // See https://github.com/anacierdem/libdragon-docker/issues/47
+  if (oldImageName !== imageName) {
+    log(`Updating image from \`${oldImageName}\` to \`${imageName}\``);
+  } else {
+    log(`Updating image \`${oldImageName}\``);
+  }
+
+  // Download the new image and if it is different, re-create the container
+  if (await updateImage(libdragonInfo, imageName)) {
+    await destroyContainer(libdragonInfo);
+  }
+
+  return {
+    ...libdragonInfo,
+    imageName,
+    containerId: await start({
+      ...libdragonInfo,
+      imageName,
+    }),
+  };
+}
+
+module.exports = {
+  updateAndStart,
+};

package/modules/actions/update.js

@@ -0,0 +1,46 @@
+const path = require('path');
+
+const { log } = require('../helpers');
+const { LIBDRAGON_GIT, LIBDRAGON_BRANCH } = require('../constants');
+const { runGitMaybeHost, mustHaveProject } = require('./utils');
+const { fn: install } = require('./install');
+const { updateAndStart } = require('./update-and-start');
+
+const update = async (libdragonInfo) => {
+  await mustHaveProject(libdragonInfo);
+  const newInfo = await updateAndStart(libdragonInfo);
+
+  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',
+    ]);
+  }
+
+  // The second parameter forces it to skip the image update step as we already
+  // do that above.
+  await install(newInfo, true);
+};
+
+module.exports = {
+  name: 'update',
+  fn: update,
+  showStatus: true,
+};