libdragon 10.0.0 → 10.3.1

package/modules/actions.js

@@ -2,12 +2,15 @@ const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
 const _ = require('lodash');
+
 const {
   LIBDRAGON_SUBMODULE,
   LIBDRAGON_BRANCH,
   LIBDRAGON_GIT,
-  CACHED_CONTAINER_FILE,
+  CONTAINER_TARGET_PATH,
+  LIBDRAGON_PROJECT_MANIFEST,
 } = require('./constants');
+
 const {
   spawnProcess,
   checkContainerAndClean,
@@ -20,11 +23,14 @@ const {
   log,
   dockerExec,
   dockerRelativeWorkdirParams,
-  dockerByteSwapParams,
   runGitMaybeHost,
   dockerHostUserParams,
+  dockerRelativeWorkdir,
+  tryCacheContainerId,
 } = require('./helpers');
 
+const { printUsage } = require('./usage');
+
 const destroyContainer = async (libdragonInfo) => {
   if (libdragonInfo.containerId) {
     await spawnProcess('docker', [
@@ -42,12 +48,8 @@ const destroyContainer = async (libdragonInfo) => {
 };
 
 const initSubmodule = async (libdragonInfo) => {
-  // Try to make sure submodule is there, in case it is deleted manually
-  try {
-    await runGitMaybeHost(libdragonInfo, ['restore', '.gitmodules']);
-  } catch {
-    // No need to do anything else here
-  }
+  await runGitMaybeHost(libdragonInfo, ['init']);
+
   await runGitMaybeHost(libdragonInfo, [
     'submodule',
     'add',
@@ -62,28 +64,73 @@ const initSubmodule = async (libdragonInfo) => {
 };
 
 /**
- * Will donload image, create a new container and install everything in it
+ * Downloads the given docker image. Returns false if the local image is the
+ * same, new image name otherwise.
+ * @param libdragonInfo
+ * @param newImageName
+ * @returns false | string
+ */
+const updateImage = async (libdragonInfo, newImageName) => {
+  // Will not take too much time if already have the same
+  const download = async () => {
+    libdragonInfo.showStatus &&
+      log(`Downloading docker image: ${newImageName}`);
+    await spawnProcess(
+      'docker',
+      ['pull', newImageName],
+      false,
+      libdragonInfo.showStatus
+    );
+  };
+
+  const getDigest = async () =>
+    await spawnProcess(
+      'docker',
+      ['images', '-q', '--no-trunc', newImageName],
+      false,
+      libdragonInfo.showStatus
+    );
+
+  // Attempt to compare digests if the new image name is the same
+  // Even if they are not the same tag, it is possible to have a different
+  // image but we already attempt a download in any case. It would just take
+  // less time as we already have the layers.
+  if (libdragonInfo.imageName === newImageName) {
+    const existingDigest = await getDigest();
+    await download();
+    const newDigest = await getDigest();
+
+    if (existingDigest === newDigest) {
+      libdragonInfo.showStatus && log(`Image is the same: ${newImageName}`);
+      return false;
+    }
+  } else {
+    await download();
+  }
+
+  libdragonInfo.showStatus && log(`Image is different: ${newImageName}`);
+  return newImageName;
+};
+
+/**
+ * Create a new container
  */
 const initContainer = async (libdragonInfo) => {
   let newId;
   try {
-    const imageName = await updateImageName(libdragonInfo);
-
-    // Download image
-    libdragonInfo.showStatus && log(`Downloading docker image: ${imageName}`);
-    await spawnProcess('docker', ['pull', imageName]);
-
     // Create a new container
     libdragonInfo.showStatus && log('Creating new container...');
     newId = (
       await spawnProcess('docker', [
         'run',
-        ...dockerByteSwapParams(libdragonInfo),
         '-d', // Detached
         '--mount',
-        'type=bind,source=' + libdragonInfo.root + ',target=/libdragon', // Mount files
-        '-w=/libdragon', // Set working directory
-        imageName,
+        'type=bind,source=' +
+          libdragonInfo.root +
+          ',target=' +
+          CONTAINER_TARGET_PATH, // Mount files
+        '-w=' + CONTAINER_TARGET_PATH, // Set working directory
+        libdragonInfo.imageName,
         'tail',
         '-f',
         '/dev/null',
@@ -93,7 +140,6 @@ const initContainer = async (libdragonInfo) => {
     const newInfo = {
       ...libdragonInfo,
       containerId: newId,
-      imageName,
     };
 
     // chown the installation folder once on init
@@ -104,11 +150,6 @@ const initContainer = async (libdragonInfo) => {
       `${uid >= 0 ? uid : ''}:${gid >= 0 ? gid : ''}`,
       '/n64_toolchain',
     ]);
-
-    await runGitMaybeHost(libdragonInfo, ['init']);
-    await initSubmodule(libdragonInfo);
-
-    await installDependencies(newInfo);
   } catch (e) {
     // Dispose the invalid container, clean and exit
     await destroyContainer({
@@ -131,15 +172,13 @@ const initContainer = async (libdragonInfo) => {
     '{{.Name}}',
   ]);
 
-  // We have created a new container, save the new info
-  fs.writeFileSync(
-    path.join(libdragonInfo.root, '.git', CACHED_CONTAINER_FILE),
-    newId
-  );
   libdragonInfo.showStatus &&
     log(
       chalk.green(`Successfully initialized docker container: ${name.trim()}`)
     );
+
+  // Update the image name only after everything is OK
+  await updateImageName(libdragonInfo);
   return newId;
 };
 
@@ -147,12 +186,15 @@ const initContainer = async (libdragonInfo) => {
  * Recursively copies directories and files
  */
 function copyDirContents(src, dst) {
+  log(`Copying from ${src} to ${dst}`, true);
+
   if (fs.existsSync(dst) && !fs.statSync(dst).isDirectory()) {
     log(`${dst} is not a directory, skipping.`);
     return;
   }
 
   if (!fs.existsSync(dst)) {
+    log(`Creating a directory at ${dst}.`, true);
     fs.mkdirSync(dst);
   }
 
@@ -166,6 +208,7 @@ function copyDirContents(src, dst) {
     } else if (stats.isFile()) {
       const content = fs.readFileSync(source);
       try {
+        log(`Writing to ${dest}`, true);
         fs.writeFileSync(dest, content, {
           flag: 'wx',
         });
@@ -179,22 +222,72 @@ function copyDirContents(src, dst) {
 
 /**
  * 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}.`);
-  const isNewProject = await createManifestIfNotExist(libdragonInfo);
+  log(`Initializing a libdragon project at ${libdragonInfo.root}`);
+
+  const files = fs.readdirSync(libdragonInfo.root);
+
+  const manifestFile = files.find(
+    (name) => name === LIBDRAGON_PROJECT_MANIFEST
+  );
+
+  if (manifestFile) {
+    log(
+      `${path.join(
+        libdragonInfo.root,
+        manifestFile
+      )} exists. This is already a libdragon project, starting it...`
+    );
+    if (libdragonInfo.options.DOCKER_IMAGE) {
+      log(
+        `Not changing docker image. Use the install action if you want to override the image.`
+      );
+    }
+    await install(libdragonInfo);
+    return;
+  }
 
-  log(`Preparing the docker container...`);
-  await start(libdragonInfo);
+  const libdragonFile = files.find((name) =>
+    name.match(new RegExp(`^${LIBDRAGON_SUBMODULE}.?`))
+  );
 
-  if (isNewProject) {
-    log(`Copying project files...`);
-    const skeletonFolder = path.join(__dirname, '../skeleton');
-    // node copy functions does not work with pkg
-    copyDirContents(skeletonFolder, libdragonInfo.root);
+  if (libdragonFile) {
+    throw new Error(
+      `${path.join(
+        libdragonInfo.root,
+        libdragonFile
+      )} already exists. That is the libdragon vendoring target, please remove and retry.`
+    );
   }
 
-  log(chalk.green(`libdragon ready at \`${libdragonInfo.root}\`.`));
+  await createManifestIfNotExist(libdragonInfo);
+  // Download image and start it
+  const newId = await start({
+    ...libdragonInfo,
+    imageName:
+      (await updateImage(libdragonInfo, libdragonInfo.imageName)) ||
+      libdragonInfo.imageName,
+  });
+  const newInfo = {
+    ...libdragonInfo,
+    containerId: newId,
+  };
+
+  await initSubmodule(newInfo);
+
+  // We have created a new container, save the new info
+  tryCacheContainerId(newInfo);
+
+  await installDependencies(newInfo);
+
+  log(`Copying project files...`);
+  const skeletonFolder = path.join(__dirname, '../skeleton');
+  // node copy functions does not work with pkg
+  copyDirContents(skeletonFolder, newInfo.root);
+
+  log(chalk.green(`libdragon ready at \`${newInfo.root}\`.`));
 }
 
 const start = async (libdragonInfo) => {
@@ -217,12 +310,8 @@ const start = async (libdragonInfo) => {
     return id;
   }
 
-  log(`Starting container: ${libdragonInfo.containerId}`, true);
-  await spawnProcess('docker', [
-    'container',
-    'start',
-    libdragonInfo.containerId,
-  ]);
+  log(`Starting container: ${id}`, true);
+  await spawnProcess('docker', ['container', 'start', id]);
 
   log(id);
   return id;
@@ -239,29 +328,33 @@ const stop = async (libdragonInfo) => {
   await spawnProcess('docker', ['container', 'stop', running]);
 };
 
-const make = async (libdragonInfo, params) => {
-  const workdir = toPosixPath(path.relative(libdragonInfo.root, process.cwd()));
-  log(`Running make at ${workdir ?? '.'} with [${params}]`, true);
+const exec = async (libdragonInfo, commandAndParams) => {
+  log(
+    `Running ${commandAndParams[0]} at ${dockerRelativeWorkdir(
+      libdragonInfo
+    )} with [${commandAndParams.slice(1)}]`,
+    true
+  );
 
-  const tryMake = (libdragonInfo) =>
+  const tryCmd = (libdragonInfo) =>
     libdragonInfo.containerId &&
     dockerExec(
       libdragonInfo,
       [
         ...dockerRelativeWorkdirParams(libdragonInfo),
-        ...dockerByteSwapParams(libdragonInfo),
         ...dockerHostUserParams(libdragonInfo),
       ],
-      ['make', ...params],
-      true
+      commandAndParams,
+      true,
+      true // Cannot use "full" here, we need to know if the container is alive
     );
 
   let started = false;
-  const startOnceAndMake = async () => {
+  const startOnceAndCmd = async () => {
     if (!started) {
       const newId = await start(libdragonInfo);
       started = true;
-      await tryMake({
+      await tryCmd({
         ...libdragonInfo,
         containerId: newId,
       });
@@ -271,12 +364,12 @@ const make = async (libdragonInfo, params) => {
 
   if (!libdragonInfo.containerId) {
     log(`Container does not exist for sure, restart`, true);
-    await startOnceAndMake();
+    await startOnceAndCmd();
     return;
   }
 
   try {
-    await tryMake(libdragonInfo);
+    await tryCmd(libdragonInfo);
   } catch (e) {
     if (
       !e.out ||
@@ -285,19 +378,36 @@ const make = async (libdragonInfo, params) => {
     ) {
       throw e;
     }
-    await startOnceAndMake();
+    await startOnceAndCmd();
   }
 };
 
+const make = async (libdragonInfo, params) => {
+  await exec(libdragonInfo, ['make', ...params]);
+};
+
 const installDependencies = async (libdragonInfo) => {
-  libdragonInfo.showStatus && log('Vendoring libdragon...');
+  const buildScriptPath = path.join(
+    libdragonInfo.root,
+    'libdragon',
+    'build.sh'
+  );
+  if (
+    !fs.existsSync(buildScriptPath) ||
+    !fs.statSync(buildScriptPath).isFile()
+  ) {
+    throw new Error(
+      'build.sh not found. Make sure you have a vendored libdragon copy at ./libdragon'
+    );
+  }
+
+  libdragonInfo.showStatus && log('Installing libdragon to the container...');
 
   await dockerExec(
     libdragonInfo,
     [
       '--workdir',
-      '/libdragon/' + LIBDRAGON_SUBMODULE,
-      ...dockerByteSwapParams(libdragonInfo),
+      CONTAINER_TARGET_PATH + '/' + LIBDRAGON_SUBMODULE,
       ...dockerHostUserParams(libdragonInfo),
     ],
     ['/bin/bash', './build.sh']
@@ -348,7 +458,10 @@ const installDependencies = async (libdragonInfo) => {
               const relativePath = toPosixPath(
                 path.relative(libdragonInfo.root, paths[0])
               );
-              const containerPath = path.posix.join('/libdragon', relativePath);
+              const containerPath = path.posix.join(
+                CONTAINER_TARGET_PATH,
+                relativePath
+              );
               const makePath = path.posix.join(containerPath, 'Makefile');
 
               await dockerExec(
@@ -378,52 +491,29 @@ const installDependencies = async (libdragonInfo) => {
   }
 };
 
-const requiresContainer = async (libdragonInfo) => {
-  const id = await checkContainerAndClean(libdragonInfo);
-
-  if (!id) {
-    throw new Error(
-      'libdragon is not properly initialized. Initialize with `libdragon init` first.'
-    );
-  }
-
-  return id;
-};
-
-const maybeStartNewImage = async (libdragonInfo) => {
-  let containerId = libdragonInfo.containerId;
-  const oldImageName = libdragonInfo.imageName;
-  const imageName = await updateImageName(libdragonInfo);
-  if (oldImageName !== imageName) {
-    log(`Changing image from \`${oldImageName}\` to \`${imageName}\``);
-    await destroyContainer(libdragonInfo);
-
-    // Start the new image
-    containerId = await start({
-      ...libdragonInfo,
-      imageName,
-    });
-  }
+const update = async (libdragonInfo) => {
+  const containerId = await start(libdragonInfo);
 
-  return {
+  const newInfo = {
     ...libdragonInfo,
-    imageName,
     containerId,
   };
-};
-
-const update = async (libdragonInfo) => {
-  let containerId = await requiresContainer(libdragonInfo);
-
-  // Start existing
-  containerId = await start(libdragonInfo);
 
   // Update submodule
   log('Updating submodule...');
 
-  await initSubmodule(libdragonInfo);
+  try {
+    await initSubmodule(newInfo);
+  } catch {
+    throw new Error(
+      `Unable to re-initialize vendored libdragon. Probably git does not know the vendoring target (${path.join(
+        libdragonInfo.root,
+        LIBDRAGON_SUBMODULE
+      )}) Removing it might resolve this issue.`
+    );
+  }
 
-  await runGitMaybeHost(libdragonInfo, [
+  await runGitMaybeHost(newInfo, [
     'submodule',
     'update',
     '--remote',
@@ -431,72 +521,91 @@ const update = async (libdragonInfo) => {
     './' + LIBDRAGON_SUBMODULE,
   ]);
 
-  await install({
-    ...libdragonInfo,
-    containerId,
-  });
+  await install(newInfo);
 };
 
+/**
+ * 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 = await requiresContainer(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);
+    }
 
-  const newInfo = await maybeStartNewImage({
+    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,
   });
-
-  // Re-install vendors on new image
-  await installDependencies(newInfo);
-};
-
-const help = () => {
-  log(`${chalk.green('Usage:')}
-  libdragon [flags] <action>
-
-${chalk.green('Available Commands:')}
-  help        Display this help information.
-  init        Create a libdragon project in the current directory.
-  make        Run the libdragon build system in the current directory.
-  start       Start the container for current project.
-  stop        Stop the container for current project.
-  install     Vendor libdragon as is.
-  update      Update libdragon and do an install.
-
-${chalk.green('Flags:')}
-  --image <docker-image>  Provide a custom image.
-  --byte-swap             Enable byte-swapped ROM output.
-  --verbose               Be verbose
-`);
 };
 
+// TODO: separate into files
 module.exports = {
   start: {
+    name: 'start',
     fn: start,
     showStatus: false, // This will only print out the id
   },
   init: {
+    name: 'init',
     fn: init,
     showStatus: true,
   },
   make: {
+    name: 'make',
     fn: make,
     forwardsRestParams: true,
     showStatus: true,
   },
+  exec: {
+    name: 'exec',
+    fn: exec,
+    forwardsRestParams: true,
+    showStatus: true,
+  },
   stop: {
+    name: 'stop',
     fn: stop,
     showStatus: false, // This will only print out the id
   },
   install: {
+    name: 'install',
     fn: install,
     showStatus: true,
   },
   update: {
+    name: 'update',
     fn: update,
     showStatus: true,
   },
   help: {
-    fn: help,
+    name: 'help',
+    fn: printUsage,
     showStatus: true,
+    forwardsRestParams: true,
   },
 };

package/modules/constants.js

@@ -5,6 +5,7 @@ module.exports = {
   LIBDRAGON_GIT: 'https://github.com/DragonMinded/libdragon',
   LIBDRAGON_BRANCH: 'trunk',
   LIBDRAGON_SUBMODULE: 'libdragon',
+  CONTAINER_TARGET_PATH: '/libdragon',
 
   LIBDRAGON_PROJECT_MANIFEST: '.libdragon',
   CACHED_CONTAINER_FILE: 'libdragon-docker-container',