Implement Container Autograding

devU-api/package.json

@@ -42,6 +42,7 @@
     "@types/morgan": "^1.9.2",
     "@types/multer": "^1.4.7",
     "@types/node": "^15.12.2",
+    "@types/node-fetch": "^2.6.11",
     "@types/passport": "^1.0.6",
     "@types/passport-strategy": "^0.2.35",
     "@types/swagger-jsdoc": "^6.0.0",
@@ -61,6 +62,7 @@
     "body-parser": "^1.19.0",
     "colors": "^1.4.0",
     "config": "^3.3.6",
+    "node-fetch": "^2.7.0",
     "cookie-parser": "^1.4.5",
     "cors": "^2.8.5",
     "devu-shared-modules": "./devu-shared-modules",
@@ -71,6 +73,7 @@
     "minio": "^7.0.18",
     "morgan": "^1.10.0",
     "multer": "^1.4.2",
+    "node-fetch": "^2.7.0",
     "passport": "^0.6.0",
     "passport-saml": "^3.2.2",
     "pg": "^8.4.0",

devU-api/src/entities/containerAutoGrader/containerAutoGrader.service.ts

@@ -80,12 +80,12 @@ export async function update(
     containerAutoGrader.graderFile = filename
   }
 
-  if (makefileInputFile) {
-    const bucket: string = 'makefiles'
-    const makefileFilename: string = generateFilename(makefileInputFile.originalname, userId)
-    await filesUpload(bucket, makefileInputFile, containerAutoGrader, makefileFilename, userId)
-    containerAutoGrader.makefileFile = makefileFilename
-  }
+    if (makefileInputFile) {
+        const bucket: string = 'makefiles'
+        const makefileFilename: string = generateFilename(makefileInputFile.originalname, userId)
+        await filesUpload(bucket, makefileInputFile, containerAutoGrader, makefileFilename, userId)
+        containerAutoGrader.makefileFile = makefileFilename
+    }
 
   const { id, assignmentId, graderFile, makefileFile, autogradingImage, timeout } = containerAutoGrader
   return await connect().update(id, { assignmentId, graderFile, makefileFile, autogradingImage, timeout })
@@ -110,10 +110,9 @@ export async function getGraderObjectByAssignmentId(assignmentId: number) {
   return await connect().find({ assignmentId: assignmentId, deletedAt: IsNull() })
 }
 
-export async function listByAssignmentId(assignmentId: number) {
-  if (!assignmentId) throw new Error('Missing AssignmentId')
-  return await connect().find({ assignmentId: assignmentId, deletedAt: IsNull() })
-}
+export async function getGraderByAssignmentId(assignmentId: number){
+    const containerAutoGraders = await connect().findOne({ assignmentId: assignmentId, deletedAt: IsNull() })
+    if (!containerAutoGraders) return {graderData: null, makefileData: null, autogradingImage: null, timeout: null}
 
 export async function getGraderByAssignmentId(assignmentId: number) {
   const containerAutoGraders = await connect().findOne({ assignmentId: assignmentId, deletedAt: IsNull() })

devU-api/src/entities/containerAutoGrader/containerAutoGrader.validator.ts

@@ -4,9 +4,8 @@ import validate from '../../middleware/validator/generic.validator'
 
 const assignmentId = check('assignmentId').isNumeric()
 
-const graderFile = check('graderFile')
-  .optional({ nullable: true })
-  .custom(({ req }) => {
+const graderFile = check('graderFile').optional({ nullable: true }).custom(({req}) => {
+
     const file = req?.files['grader']
     if (file !== null) {
       if (file.size <= 0) {

devU-api/src/entities/grader/grader.controller.ts

@@ -2,21 +2,31 @@ import { Request, Response, NextFunction } from 'express'
 
 import GraderService from './grader.service'
 
-import { GenericResponse, NotFound } from '../../utils/apiResponse.utils'
+import { GenericResponse } from '../../utils/apiResponse.utils' //, NotFound
 
-import { serialize } from './grader.serializer'
+//import { serialize } from '../grader/grader.serializer'
 
 export async function grade(req: Request, res: Response, next: NextFunction) {
-  try {
-    const submissionId = parseInt(req.params.id)
-    const grade = await GraderService.grade(submissionId)
-    if (!grade || grade.length === 0) return res.status(404).json(NotFound)
-    const response = serialize(grade)
-
-    res.status(200).json(response)
-  } catch (err) {
-    res.status(400).json(new GenericResponse(err.message))
-  }
+    try {
+        const submissionId = parseInt(req.params.id)
+        const response = await GraderService.grade(submissionId) //grade
+
+        res.status(200).json(response)
+    } catch (err) {
+        res.status(400).json(new GenericResponse(err.message))
+    }
+}
+
+export async function tangoCallback(req: Request, res: Response, next: NextFunction) {
+    try {
+        const outputFile = req.params.outputFile
+        const response = await GraderService.tangoCallback(outputFile)
+
+        res.status(200).json(response)
+    } catch (err) {
+        res.status(400).json(new GenericResponse(err.message))
+    }
+
 }
 
-export default { grade }
+export default { grade, tangoCallback }

devU-api/src/entities/grader/grader.router.ts

@@ -4,8 +4,10 @@ import express from 'express'
 // Middleware
 //import validator from './grader.validator'
 import { asInt } from '../../middleware/validator/generic.validator'
+
 import { isAuthorized } from '../../authorization/authorization.middleware'
 
+
 // Controller
 import GraderController from './grader.controller'
 
@@ -31,12 +33,36 @@ const Router = express.Router({ mergeParams: true })
  *         schema:
  *           type: integer
  */
-Router.post('/:id', isAuthorized('enrolled'), asInt(), GraderController.grade)
-// TODO: This one might be tricky. Can every student hit this endpoint for their own submissions? That's probably
+Router.post('/:id', asInt(), GraderController.grade)
+
+/**
+ * @swagger
+ * tags:
+ *    - name: Grader callback
+ *      description: 
+ * /grade/callback/{outputFilename}:
+ *   post:
+ *     summary: Not directly called by the user. Tells the API that a container grading job has finished and creates relevant entities from the results.
+ *     tags:
+ *       - Grader
+ *     responses:
+ *       '200':
+ *         description: OK
+ *     parameters:
+ *       - name: outputFilename
+ *         in: path
+ *         required: true
+ *         schema:
+ *           type: string
+ */
+Router.post('/callback/:outputFile', GraderController.tangoCallback) //Unauthorized route so tango can make callback without needing token
+
+// TODO: This one might be tricky for authorization. Can every student hit this endpoint for their own submissions? That's probably
 //       the easiest way to handle it. If not, how does this endpoint get hit when they make a submission without
 //       sacrificing RESTfullness? eg. Sometimes we want to make submissions without running the grader so the front end
 //       should have control of this endpoint
 //       -or- do we only let students hit this once per submission. Regrades must be by someone with permission. Then
 //            add a second endpoint that is /regrade
 
+
 export default Router