Support C++ and detach algorithms and tracers submodules

Author: 64json

.gitignore

@@ -3,4 +3,5 @@
 /build
 /npm-debug.log
 /package-lock.json
+/src/backend/public
 .DS_Store

.gitmodules

@@ -15,7 +15,11 @@ if (__DEV__) {
 
   let lastHash = null;
   let httpServer = null;
-  compiler.watch({}, (err, stats) => {
+  compiler.watch({
+    watchOptions: {
+      ignored: /public/,
+    },
+  }, (err, stats) => {
     if (err) {
       lastHash = null;
       compiler.purgeInputFileSystem();
@@ -25,7 +29,7 @@ if (__DEV__) {
       lastHash = stats.hash;
       console.info(stats.toString({
         cached: false,
-        colors: true
+        colors: true,
       }));
 
       try {

app/backend.js

@@ -3,7 +3,7 @@
   "version": "2.0.0",
   "description": "Algorithm Visualizer",
   "scripts": {
-    "postinstall": "docker pull baekjoon/onlinejudge-java:1.8",
+    "postinstall": "docker pull openjdk:8 && docker pull gcc:8.1",
     "dev": "NODE_ENV=development node bin/www",
     "start": "NODE_ENV=production node bin/www",
     "build": "npm run build:frontend && npm run build:backend",

package.json

@@ -1 +1,16 @@
-export {};
+import Promise from 'bluebird';
+import child_process from 'child_process';
+
+const execute = (command, cwd, { stdout = process.stdout, stderr = process.stderr } = {}) => new Promise((resolve, reject) => {
+  if (!cwd) return reject(new Error('CWD Not Specified'));
+  const child = child_process.exec(command, { cwd }, (error, stdout, stderr) => {
+    if (error) return reject(new Error(stderr));
+    resolve(stdout);
+  });
+  if (stdout) child.stdout.pipe(stdout);
+  if (stderr) child.stderr.pipe(stderr);
+});
+
+export {
+  execute,
+};

src/backend/common/util.js

@@ -1,18 +1,22 @@
 import express from 'express';
-import fs from 'fs';
+import Promise from 'bluebird';
+import fs from 'fs-extra';
 import path from 'path';
 import { NotFoundError } from '/common/error';
-import { exec } from 'child_process';
 import { GitHubApi } from '/apis';
+import { execute } from '/common/util';
 
 const router = express.Router();
 
-const getPath = (...args) => path.resolve(__dirname, '..', 'public', 'algorithms', ...args);
-const createKey = name => name.toLowerCase().replace(/ /g, '-');
-const list = dirPath => fs.readdirSync(dirPath).filter(fileName => !fileName.startsWith('.'));
+const repoPath = path.resolve(__dirname, '..', 'public', 'algorithms');
+const getPath = (...args) => path.resolve(repoPath, ...args);
 
 const cacheCategories = () => {
   const allFiles = [];
+
+  const createKey = name => name.toLowerCase().replace(/ /g, '-');
+  const list = dirPath => fs.readdirSync(dirPath).filter(fileName => !fileName.startsWith('.'));
+
   const cacheCategory = categoryName => {
     const categoryKey = createKey(categoryName);
     const categoryPath = getPath(categoryName);
@@ -64,54 +68,53 @@ const cacheCategories = () => {
       return cacheCommitAuthors(page + 1, commitAuthors);
     }
   });
-  const cacheContributors = (commitAuthors, fileIndex = 0) => {
-    const file = allFiles[fileIndex];
-    if (file) {
-      const cwd = getPath();
-      exec(`git --no-pager log --follow --no-merges --format="%H" "${file.path}"`, { cwd }, (error, stdout, stderr) => {
-        if (!error && !stderr) {
-          const output = stdout.toString().replace(/\n$/, '');
-          const shas = output.split('\n').reverse();
-          const contributors = [];
-          for (const sha of shas) {
-            const author = commitAuthors[sha];
-            if (author && !contributors.find(contributor => contributor.login === author.login)) {
-              contributors.push(author);
-            }
+  const cacheContributors = commitAuthors => Promise.each(allFiles, file => {
+    return execute(`git --no-pager log --follow --no-merges --format="%H" "${file.path}"`, getPath(), { stdout: null })
+      .then(stdout => {
+        const output = stdout.toString().replace(/\n$/, '');
+        const shas = output.split('\n').reverse();
+        const contributors = [];
+        for (const sha of shas) {
+          const author = commitAuthors[sha];
+          if (author && !contributors.find(contributor => contributor.login === author.login)) {
+            contributors.push(author);
           }
-          file.contributors = contributors;
         }
-        cacheContributors(commitAuthors, fileIndex + 1);
+        file.contributors = contributors;
       });
-    }
-  };
+  });
   cacheCommitAuthors().then(cacheContributors);
 
   return categories;
 };
-const cachedCategories = cacheCategories(); // TODO: cache again when webhooked
-
-const getCategories = (req, res, next) => {
-  res.json({ categories: cachedCategories });
-};
 
-const getAlgorithm = (req, res, next) => {
-  const { categoryKey, algorithmKey } = req.params;
+const downloadCategories = () => (
+  fs.pathExistsSync(repoPath) ?
+    execute(`git fetch && git reset --hard origin/master`, repoPath) :
+    execute(`git clone [email protected]:algorithm-visualizer/algorithms ${repoPath}`, __dirname)
+);
 
-  const category = cachedCategories.find(category => category.key === categoryKey);
-  if (!category) return next(new NotFoundError());
-  const algorithm = category.algorithms.find(algorithm => algorithm.key === algorithmKey);
-  if (!algorithm) return next(new NotFoundError());
+let categories = []; // TODO: download again when webhooked
+downloadCategories().then(() => categories = cacheCategories());
 
-  const titles = [category.name, algorithm.name];
-  const files = algorithm.files.map(({ name, content, contributors }) => ({ name, content, contributors }));
-  res.json({ algorithm: { titles, files } });
-};
 
 router.route('/')
-  .get(getCategories);
+  .get((req, res, next) => {
+    res.json({ categories });
+  });
 
 router.route('/:categoryKey/:algorithmKey')
-  .get(getAlgorithm);
+  .get((req, res, next) => {
+    const { categoryKey, algorithmKey } = req.params;
+
+    const category = categories.find(category => category.key === categoryKey);
+    if (!category) return next(new NotFoundError());
+    const algorithm = category.algorithms.find(algorithm => algorithm.key === algorithmKey);
+    if (!algorithm) return next(new NotFoundError());
+
+    const titles = [category.name, algorithm.name];
+    const files = algorithm.files.map(({ name, content, contributors }) => ({ name, content, contributors }));
+    res.json({ algorithm: { titles, files } });
+  });
 
 export default router;

src/backend/controllers/categories.js

@@ -1,57 +1,79 @@
-import Promise from 'bluebird';
 import express from 'express';
 import fs from 'fs-extra';
 import uuid from 'uuid';
 import path from 'path';
-import child_process from 'child_process';
 import { GitHubApi } from '/apis';
-import { __PROD__ } from '/environment';
+import { execute } from '/common/util';
 import { CompileError, RuntimeError } from '/common/error';
 
 const router = express.Router();
 
-const getLibPath = (...args) => path.resolve(__dirname, '..', 'public', 'libs', ...args);
+const repoPath = path.resolve(__dirname, '..', 'public', 'tracers');
+const getLibsPath = (...args) => path.resolve(repoPath, 'libs', ...args);
+const getCodesPath = (...args) => path.resolve(__dirname, '..', 'public', 'codes', ...args);
 
-const downloadLibs = () => {
-  GitHubApi.getLatestRelease('algorithm-visualizer', 'tracers').then(release => {
-    return Promise.each(release.assets, asset => GitHubApi.download(asset.browser_download_url, getLibPath(asset.name)));
-  });
-};
-if (__PROD__) downloadLibs(); // TODO: download again when webhooked
+const buildRelease = release => (
+  fs.pathExistsSync(repoPath) ?
+    execute(`git fetch && ! git diff-index --quiet ${release.target_commitish}`, repoPath) :
+    execute(`git clone [email protected]:algorithm-visualizer/tracers ${repoPath}`, __dirname)
+).then(() => execute(`git reset --hard ${release.target_commitish} && npm install && npm run build`, repoPath));
+
+GitHubApi.getLatestRelease('algorithm-visualizer', 'tracers').then(buildRelease);
+// TODO: build release when webhooked
 
 const getJsWorker = (req, res, next) => {
-  res.sendFile(getLibPath('js.js'));
+  res.sendFile(getLibsPath('js', 'tracers.js'));
 };
 
-const execute = (imageId, srcPath, command, ErrorClass) => new Promise((resolve, reject) => {
-  const libPath = getLibPath();
+const executeInDocker = (imageId, ext, srcPath, command) => {
   // TODO: memory limit + time limit + space limit?
-  const dockerCommand = `docker run --rm -w=/usr/judge -t -v=${libPath}:/usr/bin/tracers:ro -v=${srcPath}:/usr/judge:rw -e MAX_TRACES=1000000 -e MAX_TRACERS=100 ${imageId}`;
-  child_process.exec(`${dockerCommand} ${command}`, (error, stdout, stderr) => {
-    if (error) return reject(new ErrorClass(stdout));
-    resolve();
-  });
-});
-
-const trace = ({ imageId, compileCommand, runCommand }) => (req, res, next) => {
+  const libsPath = getLibsPath(ext);
+  const dockerCommand = [
+    `docker run --rm`,
+    '-w=/usr/judge',
+    `-v=${libsPath}:/usr/bin/tracers:ro`,
+    `-v=${srcPath}:/usr/judge:rw`,
+    `-e MAX_TRACES=${1e6} -e MAX_TRACERS=${1e2}`,
+    imageId,
+  ].join(' ');
+  return execute(`${dockerCommand} ${command}`, repoPath, { stdout: null, stderr: null });
+};
+
+const trace = ({ ext, imageId, compileCommand, runCommand }) => (req, res, next) => {
   const { code } = req.body;
-  const srcPath = path.resolve(__dirname, '..', 'public', 'codes', uuid.v4());
-  fs.outputFile(path.resolve(srcPath, 'code.java'), code)
-    .then(() => execute(imageId, srcPath, compileCommand, CompileError))
-    .then(() => execute(imageId, srcPath, runCommand, RuntimeError))
+  const srcPath = getCodesPath(uuid.v4());
+  fs.outputFile(path.resolve(srcPath, `Main.${ext}`), code)
+    .then(() => executeInDocker(imageId, ext, srcPath, compileCommand)
+      .catch(error => {
+        throw new CompileError(error);
+      }))
+    .then(() => executeInDocker(imageId, ext, srcPath, runCommand)
+      .catch(error => {
+        throw new RuntimeError(error);
+      }))
     .then(() => res.sendFile(path.resolve(srcPath, 'traces.json')))
     .catch(next)
     .finally(() => fs.remove(srcPath));
 };
 
+
 router.route('/js')
   .get(getJsWorker);
 
 router.route('/java')
   .post(trace({
-    imageId: 'baekjoon/onlinejudge-java:1.8',
-    compileCommand: 'javac -cp /usr/bin/tracers/java.jar code.java',
-    runCommand: 'java -cp /usr/bin/tracers/java.jar:. Main',
+    ext: 'java',
+    imageId: 'openjdk:8',
+    compileCommand: 'javac -cp /usr/bin/tracers/tracers.jar Main.java',
+    runCommand: 'java -cp /usr/bin/tracers/tracers.jar:. Main',
+  }));
+
+router.route('/cpp')
+  .post(trace({
+    ext: 'cpp',
+    imageId: 'gcc:8.1',
+    compileCommand: 'g++ Main.cpp -o Main -O2 -std=c++11 -L/usr/bin/tracers/lib -l:tracers.a -I/usr/bin/tracers/include',
+    runCommand: './Main',
   }));
 
 export default router;