feat(serve): Added /stop endpoint to stop containers by ID

beneboy · beneboy · commit aef52bf180eb · 2019-01-31T03:44:06.000Z
diff --git a/src/Environment.ts b/src/Environment.ts
@@ -172,7 +172,7 @@ export default class Environment {
    * @param options Optional attributes for the environment e.g. `packages`, `meta`
    * @param force If the environment already exists should it be overitten?
    */
-  static async create (name: string, options: {[key: string]: any} = {}, force: boolean = false): Promise<Environment> {
+  static async create (name: string, options: { [key: string]: any } = {}, force: boolean = false): Promise<Environment> {
     const env = new Environment(name, false)
 
     if (!force) {
@@ -380,7 +380,7 @@ export default class Environment {
    *
    * @param pure Should the shell that this command is executed in be 'pure'?
    */
-  async vars (pure: boolean = false): Promise<{[key: string]: string}> {
+  async vars (pure: boolean = false): Promise<{ [key: string]: string }> {
     const location = nix.location(this.name)
 
     let PATH = `${location}/bin:${location}/sbin`
@@ -422,25 +422,25 @@ export default class Environment {
     const { command, cpuShares, memoryLimit } = sessionParameters
     const nixLocation = nix.location(this.name)
     const shellArgs = [
-          dockerCommand, '--interactive', '--tty', '--rm',
-          // Prepend the environment path to the PATH variable
-          '--env', `PATH=${nixLocation}/bin:${nixLocation}/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`,
-          // We also need to tell R where to find libraries
-          '--env', `R_LIBS_SITE=${nixLocation}/library`,
-          // Read-only bind mount of the Nix store
-          '--volume', '/nix/store:/nix/store:ro',
-          // Apply CPU shares
-          `--cpu-shares=${cpuShares}`,
-          // Apply memory limit
-          `--memory=${memoryLimit}`,
-          // We use Alpine Linux as a base image because it is very small but has some basic
-          // shell utilities (lkike ls and uname) that are good for debugging but also sometimes
-          // required for things like R
-          'alpine'
-        ].concat(
-          // Command to execute in the container
-          command ? command.split(' ') : DOCKER_DEFAULT_COMMAND
-        )
+      dockerCommand, '--interactive', '--tty', '--rm',
+      // Prepend the environment path to the PATH variable
+      '--env', `PATH=${nixLocation}/bin:${nixLocation}/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`,
+      // We also need to tell R where to find libraries
+      '--env', `R_LIBS_SITE=${nixLocation}/library`,
+      // Read-only bind mount of the Nix store
+      '--volume', '/nix/store:/nix/store:ro',
+      // Apply CPU shares
+      `--cpu-shares=${cpuShares}`,
+      // Apply memory limit
+      `--memory=${memoryLimit}`,
+      // We use Alpine Linux as a base image because it is very small but has some basic
+      // shell utilities (lkike ls and uname) that are good for debugging but also sometimes
+      // required for things like R
+      'alpine'
+    ].concat(
+        // Command to execute in the container
+        command ? command.split(' ') : DOCKER_DEFAULT_COMMAND
+    )
 
     if (daemonize) shellArgs.splice(1, 0, '-d')
 
@@ -562,9 +562,9 @@ export default class Environment {
   /**
    * Determine if a Docker container is running using 'docker ps'
    *
-   * @param containerId The ID of the container, can either be the long or truncated version.
+   * @param containerId The ID of the container, must be truncated version (12 alphanumeric characters).
    */
-  private async checkContainerRunning (containerId: string): Promise<boolean> {
+  async containerIsRunning (containerId: string): Promise<boolean> {
     const containerRegex = new RegExp(/^[^_\W]{12}$/)
     if (containerRegex.exec(containerId) === null) {
       throw new Error(`'${containerId}' is not a valid docker container ID.`)
@@ -593,6 +593,16 @@ export default class Environment {
     return dockerProcess.toString().trim().substr(0, DOCKER_CONTAINER_ID_SHORT_LENGTH)
   }
 
+  /**
+   * Stop a running Docker container. Return true if the container was stopped or false if there was an error.
+   *
+   * @param containerId
+   */
+  async stopContainer (containerId: string): Promise<boolean> {
+    const dockerStopProcess = await spawn('docker', ['stop', containerId])
+    return dockerStopProcess.toString().trim().substr(0, DOCKER_CONTAINER_ID_SHORT_LENGTH) === containerId.substr(0, DOCKER_CONTAINER_ID_SHORT_LENGTH)
+  }
+
   /**
    * Build a Docker container for this environment
    */
diff --git a/src/serve.ts b/src/serve.ts
@@ -35,6 +35,64 @@ app.use(express.static(path.join(__dirname, 'static')))
 const jsonParser = require('body-parser').json()
 app.use(jsonParser)
 
+/**
+ * Validates that all the `requiredParameters` are properties of `body`.
+ * Returns an array of all parameters that are missing.
+ *
+ * @param body
+ * @param requiredParameters
+ */
+function validateParameters (body: any, requiredParameters: Array<string>): Array<string> {
+  let missingParameters: Array<string> = []
+
+  requiredParameters.forEach(parameter => {
+    if (!body[parameter]) {
+      missingParameters.push(parameter)
+    }
+  })
+
+  return missingParameters
+}
+
+/**
+ * Send a 400 status code to the response, with the `errorMessage` as a JSON response.
+ *
+ * @param response
+ * @param errorMessage
+ */
+function sendBadRequestResponse (response: express.Response, errorMessage: string) {
+  response.status(400).json({
+    error: errorMessage
+  })
+}
+
+/**
+ * Validate that a request has a valid JSON body and has all the `requiredParameters`. It sends appropriate error
+ * messages back to the client, and then returns false, if the request is not valid; the calling function should
+ * then stop sending its response. If this function returns true the calling function should continue as normal.
+ *
+ * @param request
+ * @param response
+ * @param requiredParameters
+ */
+function doRequestValidation (request: express.Request, response: express.Response,
+                              requiredParameters: Array<string>): boolean {
+  if (!request.body) {
+    sendBadRequestResponse(response, 'Valid JSON body was not found.')
+    return false
+  }
+
+  const missingParameters = validateParameters(request.body, requiredParameters)
+
+  if (missingParameters.length) {
+    const missingParametersStr = missingParameters.join(', ')
+    sendBadRequestResponse(response, `Missing parameter(s) in body: ${missingParametersStr}.`)
+    return false
+  }
+
+  return true
+}
+
 // todo: rename shell to interact
 // Instantiate shell and set up data handlers
 expressWs.app.ws('/shell', async (ws: any, req: express.Request) => {
@@ -76,23 +134,50 @@ app.use((error: Error, req: express.Request, res: express.Response, next: any) =
   next(error)
 })
 
-expressWs.app.post('/execute', jsonParser, async (req: any, res: any) => {
-  // req: some JSON -> new SessionParameters object to start in env.execute (new execute method)
-  if (!req.body) return res.sendStatus(400)
+expressWs.app.post('/execute', jsonParser, async (req: express.Request, res: express.Response) => {
+  if (!doRequestValidation(req, res, ['environmentId'])) {
+    return res.end()
+  }
 
   const env = new Environment(req.body.environmentId)
+
   const sessionParameters = new SessionParameters()
   sessionParameters.platform = Platform.DOCKER
   sessionParameters.command = req.body.command || ''
 
   const containerId = await env.execute(sessionParameters)
-  res.status(200).json({
+  return res.json({
     containerId: containerId
   })
 })
 
-expressWs.app.post('/stop', async (req: any, res: any) => {
+expressWs.app.post('/stop', async (req: express.Request, res: express.Response) => {
   // req: some JSON -> with container ID that will stop the container
+  if (!doRequestValidation(req, res, ['environmentId', 'containerId'])) {
+    return res.end()
+  }
+
+  const env = new Environment(req.body.environmentId)
+  const sessionParameters = new SessionParameters()
+  sessionParameters.platform = Platform.DOCKER
+
+  const containerId = req.body.containerId
+
+  if (!await env.containerIsRunning(containerId)) {
+    sendBadRequestResponse(res, `Container ${containerId} is not running.`)
+    return res.end()
+  }
+
+  if (await env.stopContainer(containerId)) {
+    return res.json({
+      message: `Container ${containerId} stopped.`
+    })
+  } else {
+    return res.status(500).json({
+      error: `Container ${containerId} was not stopped.`
+    })
+  }
+
 })
 
 app.listen(argv.port, argv.address)
