test: simple run support

Author: undefined-moe

judger/hosts/hydro.js

@@ -77,6 +77,11 @@ class JudgeTask {
         await judger[this.config.type || 'default'].judge(this);
     }
 
+    async run() {
+        this.stat.judge = new Date();
+        await judger.run.judge(this);
+    }
+
     getNext(that) { // eslint-disable-line class-methods-use-this
         that.nextId = 1;
         that.nextWaiting = [];

judger/judger/index.js

@@ -3,4 +3,5 @@ module.exports = {
     submit_snawer: require('./submit_answer'),
     interactive: require('./interactive'),
     remotejudge: require('./remotejudge'),
+    run: require('./run'),
 };

judger/judger/run.js

@@ -0,0 +1,66 @@
+const fs = require('fs');
+const path = require('path');
+const {
+    STATUS_JUDGING, STATUS_COMPILING, STATUS_RUNTIME_ERROR,
+    STATUS_TIME_LIMIT_EXCEEDED, STATUS_MEMORY_LIMIT_EXCEEDED,
+    STATUS_ACCEPTED,
+} = require('../status');
+const { run } = require('../sandbox');
+const compile = require('../compile');
+const signals = require('../signals');
+
+exports.judge = async (ctx) => {
+    ctx.stat.judge = new Date();
+    ctx.next({ status: STATUS_COMPILING });
+    ctx.execute = await compile(ctx.lang, ctx.code, 'code', {}, ctx.next);
+    ctx.clean.push(ctx.execute.clean);
+    ctx.next({ status: STATUS_JUDGING, progress: 0 });
+    const { copyIn } = ctx.execute;
+    const stdin = path.resolve(ctx.tmpdir, 'stdin');
+    const stdout = path.resolve(ctx.tmpdir, 'stdout');
+    const stderr = path.resolve(ctx.tmpdir, 'stderr');
+    fs.writeFileSync(stdin, ctx.config.input || '');
+    const res = await run(
+        ctx.execute.execute.replace(/\$\{name\}/g, 'code'),
+        {
+            stdin,
+            stdout,
+            stderr,
+            copyIn,
+            time_limit_ms: ctx.config.time,
+            memory_limit_mb: ctx.config.memory,
+        },
+    );
+    const { code, time_usage_ms, memory_usage_kb } = res;
+    let { status } = res;
+    if (!fs.existsSync(stdout)) fs.writeFileSync(stdout, '');
+    let message = '';
+    if (status === STATUS_ACCEPTED) {
+        if (time_usage_ms > ctx.config.time) {
+            status = STATUS_TIME_LIMIT_EXCEEDED;
+        } else if (memory_usage_kb > ctx.config.memory * 1024) {
+            status = STATUS_MEMORY_LIMIT_EXCEEDED;
+        }
+    } else if (code) {
+        status = STATUS_RUNTIME_ERROR;
+        if (code < 32) message = signals[code];
+        else message = `您的程序返回了 ${code}.`;
+    }
+    ctx.next({
+        status,
+        case: {
+            status,
+            time_ms: time_usage_ms,
+            memory_kb: memory_usage_kb,
+            judge_text: message,
+        },
+    });
+    ctx.stat.done = new Date();
+    ctx.next({ judge_text: JSON.stringify(ctx.stat) });
+    ctx.end({
+        stdout: fs.readFileSync(stdout).toString(),
+        stderr: fs.readFileSync(stderr).toString(),
+        time_ms: Math.floor(time_usage_ms * 1000000) / 1000000,
+        memory_kb: memory_usage_kb,
+    });
+};

module/service.js

@@ -129,28 +129,28 @@ async function postInit() {
             this.stat = {};
             this.stat.receive = new Date();
             this.request = request;
-            console.log(this.request);
         }
 
         async handle() {
             try {
                 this.stat.handle = new Date();
                 this.event = this.request.event;
-                this.pid = this.request.pid.toString();
+                this.pid = (this.request.pid || 'unknown').toString();
                 this.rid = this.request.rid.toString();
                 this.domainId = this.request.domainId;
                 this.lang = this.request.lang;
                 this.code = this.request.code;
                 this.data = this.request.data;
+                this.config = this.request.config;
                 this.next = getNext(this);
                 this.end = getEnd(this.domainId, this.rid);
-                console.log(config.TEMP_DIR, 'tmp', this.rid);
                 this.tmpdir = path.resolve(config.TEMP_DIR, 'tmp', this.rid);
                 this.clean = [];
                 mkdirp(this.tmpdir);
                 tmpfs.mount(this.tmpdir, '64m');
                 log.submission(`${this.rid}`, { pid: this.pid });
                 if (!this.event) await this.submission();
+                else if (this.event === 'run') await this.run();
                 else throw new SystemError(`Unsupported type: ${this.type}`);
             } catch (e) {
                 if (e instanceof CompileError) {
@@ -189,10 +189,19 @@ async function postInit() {
             this.stat.judge = new Date();
             await judger[this.config.type || 'default'].judge(this);
         }
+
+        async run() {
+            this.stat.judge = new Date();
+            await judger.run.judge(this);
+        }
     }
+
     task.consume({ type: 'judge' }, (t) => {
         (new JudgeTask(t)).handle().catch((e) => log.error(e));
     });
+    task.consume({ type: 'run' }, (t) => {
+        (new JudgeTask(t).handle().catch((e) => log.error(e)));
+    });
 }
 
 global.Hydro.service.judger = module.exports = { postInit };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hydrojudger",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "main": "judger/daemon.js",
   "author": "masnn",
   "dependencies": {
@@ -27,7 +27,7 @@
     "webpack": "webpack --config webpack.config.js",
     "build": "cd module && hydro-build",
     "pack": "pkg .",
-    "lint": "eslint judger build.js service.js --fix"
+    "lint": "eslint judger module --fix"
   },
   "pkg": {
     "scripts": [