using single execute function

Author: jatinkatyal13

src/taskmaster.ts

@@ -2,8 +2,9 @@ const nr = require('newrelic');
 import * as Raven from 'raven'
 import * as amqp from 'amqplib/callback_api'
 import {Connection} from 'amqplib/callback_api'
-import { runExecutor, submissionExecutor } from './tasks'
+import { execute } from './tasks'
 import config = require('../config.js')
+import { SubmitJob, RunJob } from 'tasks/job';
 
 // =============== Setup Raven
 Raven.config(config.SENTRY.DSN, {
@@ -25,13 +26,14 @@ amqp.connect(`amqp://${config.AMQP.USER}:${config.AMQP.PASS}@${config.AMQP.HOST}
     channel.assertQueue(jobQ);
     channel.consume(jobQ, async (msg) => {
       try {
-        const job = JSON.parse(msg.content.toString())
-        let jobResult
-        if (job.testcases) {
-          jobResult = await submissionExecutor(job)
+        const payload = JSON.parse(msg.content.toString())
+        let job
+        if (payload.testcases) {
+          job = new SubmitJob(payload)
         } else {
-          jobResult = await runExecutor(job)
+          job = new RunJob(payload)
         }
+        const jobResult = await execute(job)
 
         // TODO
         channel.sendToQueue(successQ, (new Buffer(JSON.stringify(jobResult))))

src/tasks/index.ts

@@ -1,14 +1,15 @@
-import { RunJob, SubmissionJob, Job } from "types/job";
-import { RunResult, SubmissionResult, Result } from 'types/result'
+import { Result, RunResult, SubmissionResult } from 'types/result'
 import config = require('../../config.js')
 import {exec, mkdir, rm} from 'shelljs'
 import * as path from 'path'
 
 import RunScenario from './run'
 import SubmissionScenario from './submission'
-import { Scenario } from "types/scenario";
+import { RunJob, SubmitJob } from "./job";
 
-export const executor = <J, R>(scenario: Scenario) => async (job: Job & J): Promise<Result & R> => {
+export function execute(job: RunJob): Promise<RunResult>
+export function execute(job: SubmitJob): Promise<SubmissionResult>
+export async function execute (job) {
   // Create RUNBOX
   rm('-rf', config.RUNBOX.DIR)
   mkdir('-p', config.RUNBOX.DIR)
@@ -17,6 +18,13 @@ export const executor = <J, R>(scenario: Scenario) => async (job: Job & J): Prom
 
   const LANG_CONFIG = config.LANGS[job.lang]
 
+  let scenario
+  if (job instanceof RunJob) {
+    scenario = RunScenario
+  } else if (job instanceof SubmitJob) {
+    scenario = SubmissionScenario
+  }
+
   // Setup RUNBOX
   await scenario.setup(currentJobDir, job) // TODO:
 
@@ -33,12 +41,9 @@ export const executor = <J, R>(scenario: Scenario) => async (job: Job & J): Prom
   `)
 
   // Get result
-  const result = <Result & R>(await scenario.result(currentJobDir, job.id))
+  const result = await scenario.result(currentJobDir, job.id)
 
   rm('-rf', currentJobDir)
 
   return result
 }
-
-export const runExecutor = executor<RunJob, RunResult>(RunScenario)
-export const submissionExecutor = executor<SubmissionJob, SubmissionResult>(SubmissionScenario)

src/tasks/job.ts

@@ -0,0 +1,49 @@
+type JobConstructorOpts = {
+  id: number
+  source: string
+  lang: string
+  timelimit?: number
+} 
+type RunJobConstructorOpts = JobConstructorOpts & {
+  stdin: string
+}
+type TestcaseOpts = {
+  id: number, 
+  input: string, 
+  output: string
+}
+type SubmitJobConstructorOpts = JobConstructorOpts & {
+  testcases: Array<TestcaseOpts>
+}
+
+export class Job { 
+  id: number
+  source: string
+  lang: string
+  timelimit?: number
+
+  constructor({ id, source, lang, timelimit = 5 }: JobConstructorOpts) {
+    this.id = id
+    this.source = source
+    this.lang = lang
+    this.timelimit = timelimit
+  }
+}
+
+export class RunJob extends Job {
+  stdin: string
+
+  constructor({ id, source, lang, timelimit, stdin }: RunJobConstructorOpts) {
+    super({id, source, lang, timelimit})
+    this.stdin = stdin
+  }
+}
+
+export class SubmitJob extends Job {
+  testcases: Array<TestcaseOpts>
+
+  constructor({ id, source, lang, timelimit, testcases }: SubmitJobConstructorOpts) {
+    super({id, source, lang, timelimit})
+    this.testcases = testcases
+  }
+}

src/tasks/run.ts

@@ -1,6 +1,6 @@
 import config = require('../../config.js')
 import {cat, exec, mkdir, rm, touch, head} from 'shelljs'
-import { RunJob } from 'types/job'
+import { RunJob } from './job'
 import { RunResult } from 'types/result'
 import * as path from 'path'
 import * as fs from 'fs'

src/tasks/submission.ts

@@ -1,6 +1,6 @@
 import config = require('../../config.js')
 import { cat, ls, mkdir, exec } from 'shelljs'
-import { SubmissionJob } from 'types/job'
+import { SubmitJob } from './job'
 import { SubmissionResult } from 'types/result'
 import * as path from 'path'
 import * as fs from 'fs'
@@ -23,7 +23,7 @@ export const download = (url: string, dest: string): Promise<ClientRequest> => {
 }
 
 class SubmissionScenario implements Scenario {
-  setup(currentJobDir: string, job: SubmissionJob) {
+  setup(currentJobDir: string, job: SubmitJob) {
     const LANG_CONFIG = config.LANGS[job.lang]
 
     fs.writeFileSync(path.join(currentJobDir, LANG_CONFIG.SOURCE_FILE),

src/types/job.d.ts

@@ -1,21 +1,21 @@
-export interface Result {
+export type Result = {
   id: number,
   stderr: string
 }
 
-export interface TestcaseResult { 
+export type TestcaseResult = { 
   id: number, 
   score: number, 
   time: string, 
   result: string 
 }
 
-export interface RunResult extends Result {
+export type RunResult = Result & {
   stdout: string,
   time: number,
   code: number
 }
 
-export interface SubmissionResult extends Result {
+export type SubmissionResult = Result & {
   testcases: Array<TestcaseResult>
 }

src/types/result.d.ts

@@ -1,4 +1,5 @@
-import { Job, Result } from "./job";
+import { Job } from '../tasks/job';
+import { Result } from './result';
 
 export interface Scenario {
   setup(currentJobDir: string, job: Job)

src/types/scenario.d.ts

@@ -1,15 +1,13 @@
-import {runExecutor} from '../../src/tasks/'
+import {execute} from '../../src/tasks/'
 import {expect} from 'chai'
-
-
+import { RunJob } from '../../src/tasks/job'
 describe('run - c', () => {
   it('.c file runs correctly', async () => {
-    const runResult = await runExecutor({
+    const runResult = await execute(new RunJob({
       id: 19,
       lang: 'c',
       source: (new Buffer(`
 #include <stdio.h>
-
 int main () {
     char in[10];
     scanf("%s", in);
@@ -18,7 +16,7 @@ int main () {
 }
       `)).toString('base64'),
       stdin: (new Buffer('World')).toString('base64')
-    })
+    }))
     expect(new Buffer(runResult.stdout, 'base64').toString('ascii')).to.eq('Hello World')
   })
 })

test/run/run.c.spec.ts

@@ -1,10 +1,10 @@
-import {runExecutor} from '../../src/tasks/'
+import {execute} from '../../src/tasks/'
 import {expect} from 'chai'
-
+import { RunJob } from '../../src/tasks/job'
 
 describe('run - cpp', () => {
   it('.cpp file runs correctly', async () => {
-    const runResult = await runExecutor({
+    const runResult = await execute(new RunJob({
       id: 20,
       lang: 'cpp',
       source: (new Buffer(`
@@ -18,7 +18,7 @@ int main () {
 }
       `)).toString('base64'),
       stdin: (new Buffer('World')).toString('base64')
-    })
+    }))
     expect(new Buffer(runResult.stdout, 'base64').toString('ascii')).to.eq('Hello World')
   })
 })