feat (invoke-action) handle SHUTDOWN tasks

- stop CodeRunner when SHUTDOWN task received (BKNDLSS-12038)
- refactor task name (rename InvokeMethodTask to InvokeHandlerTask)
- refactor invoke-action executor (get rid of switch)

Author: vengrov

lib/server-code/runners/debug.js

@@ -7,8 +7,7 @@ const logger             = require('../../util/logger'),
       denodeify          = require('../../util/promise').denodeify,
       ServerCodeService  = require('../services/server-code'),
       tasksExecutor      = require('./tasks/executor'),
-      ServerCodeModel    = require('../model'),
-      Backendless        = require('backendless');
+      ServerCodeModel    = require('../model');
 
 const TASKS_AWAIT_TIMEOUT = 10;
 const SESSION_TTL = 60;

lib/server-code/runners/tasks/executor.js

@@ -1,13 +1,10 @@
 'use strict';
 
-const wrapper = require('./util/result-wrapper'),
-    Backendless = require('backendless');
+const wrapper = require('./util/result-wrapper');
+const Backendless = require('backendless');
 
-const executors = {
-    ['com.backendless.coderunner.commons.protocol.RequestMethodInvocation']: './invoke-method',
-    ['com.backendless.coderunner.commons.protocol.RequestActionInvocation']: './invoke-action',
-    ['com.backendless.coderunner.commons.protocol.RequestServiceInvocation']: './invoke-service'
-};
+const SHUTDOWN_CODE = 32768;
+const SHUTDOWN_ACTION = 'SHUTDOWN';
 
 /**
  * @typedef {Object} InitAppData
@@ -28,49 +25,74 @@ const executors = {
 
 const executor = module.exports = {};
 
+executor.RMI = 'com.backendless.coderunner.commons.protocol.RequestMethodInvocation';
+executor.RAI = 'com.backendless.coderunner.commons.protocol.RequestActionInvocation';
+executor.RSI = 'com.backendless.coderunner.commons.protocol.RequestServiceInvocation';
+
+const executors = {
+  [executor.RMI]: './invoke-handler',
+  [executor.RAI]: './invoke-action',
+  [executor.RSI]: './invoke-service'
+};
+
 /**
  * @param {?Error|ExceptionWrapper|String} err
  * @param {*} result
  * @returns {String}
  */
 function invocationResult(err, result) {
-    return JSON.stringify(wrapper.invocationResult(err, result));
+  return JSON.stringify(wrapper.invocationResult(err, result));
 }
 
 /**
  * @param {CodeRunnerTask} task
  * @returns {Function} task executor
  */
 function getTaskExecutor(task) {
-    const taskClass = task.___jsonclass;
+  const taskClass = task.___jsonclass;
 
-    if (!executors[taskClass]) {
-        throw new Error(`Unknown task [${taskClass}]`);
-    }
+  if (!executors[taskClass]) {
+    throw new Error(`Unknown task [${taskClass}]`);
+  }
 
-    return require(executors[taskClass]);
+  return require(executors[taskClass]);
 }
 
 /**
  * @param {CodeRunnerTask} task
  */
 function initClientSdk(task) {
+  if (task.initAppData) {
     Backendless.serverURL = task.initAppData.url;
     Backendless.initApp(task.applicationId, task.initAppData.secretKey, task.initAppData.appVersionName);
+  }
+}
+
+/**
+ * A temporal workaround for http://bugs.backendless.com/browse/BKNDLSS-12041
+ *
+ * @param {CodeRunnerTask} task
+ */
+function fixTask(task) {
+  if (task.___jsonclass === executor.RMI && task.eventId === SHUTDOWN_CODE) {
+    task.___jsonclass = executor.RAI;
+    task.actionType = SHUTDOWN_ACTION;
+  }
 }
 
 /**
  * @param {CodeRunnerTask} task
  * @param {Object} runnerOpts
- * @param {?ServerCodeModel} model
+ * @param {ServerCodeModel=} model
  * @returns {Promise.<string>} InvocationResult JSON string
  */
-executor.execute = function (task, runnerOpts, model) {
+executor.execute = function(task, runnerOpts, model) {
+  return Promise.resolve()
+    .then(() => initClientSdk(task))
+    .then(() => fixTask(task))
+    .then(() => getTaskExecutor(task))
+    .then((taskExecutor) => taskExecutor(task, runnerOpts, model))
+    .then(result => result && invocationResult(null, result))
+    .catch(invocationResult);
+};
 
-    return Promise.resolve()
-        .then(() => initClientSdk(task))
-        .then(() => getTaskExecutor(task))
-        .then((taskExecutor) => taskExecutor(task, runnerOpts, model))
-        .then(result => result && invocationResult(null, result))
-        .catch(invocationResult);
-};

lib/server-code/runners/tasks/invoke-action.js

@@ -5,33 +5,6 @@ const logger          = require('../../../util/logger'),
       ServerCodeModel = require('../../model'),
       path            = require('path');
 
-const PARSE_SERVICE = 'PARSE_CUSTOM_SERVICE_FROM_JAR';
-const VALIDATE_SERVER_CODE = 'VALIDATE_SERVER_CODE';
-
-/**
- * @typedef {CodeRunnerTask} InvokeActionTask
- * @property {String} actionType
- * @property {Object} argObject
- */
-
-/**
- * @param {InvokeActionTask} task
- * @param {Object} runnerOpts
- * @returns {*} Task Execution Result
- */
-module.exports = function(task, runnerOpts) { //
-  switch (task.actionType) {
-    case(PARSE_SERVICE):
-      return parseService(task);
-
-    case(VALIDATE_SERVER_CODE):
-      return validateServerCode(task, runnerOpts);
-
-    default:
-      throw new Error(`Unknown action type: [${task.actionType}]`);
-  }
-};
-
 /**
  * @param {InvokeActionTask} task
  */
@@ -43,10 +16,48 @@ function parseService(task) {
   throw new Error('Not implemented yet');
 }
 
-function validateServerCode(task, runnerOpts) {
+/**
+ * @param {InvokeActionTask} task
+ * @param {Object} runnerOpts
+ *
+ * @returns {String} ServerCodeModel JSON
+ */
+function analyseServerCode(task, runnerOpts) {
   const codePath = path.resolve(`${runnerOpts.repoPath}}/${task.relativePath}`);
 
   const files = file.expand([`${codePath}/**`], { nodir: true });
 
   return JSON.stringify(ServerCodeModel.build(codePath, files));
-}
+}
+
+function shutdown() {
+  logger.info('Received a shutdown request from Backendless');
+  process.exit(0);
+}
+
+const actions = {
+  PARSE_CUSTOM_SERVICE_FROM_JAR: parseService,
+  ANALYSE_SERVER_CODE          : analyseServerCode,
+  SHUTDOWN                     : shutdown
+};
+
+/**
+ * @typedef {CodeRunnerTask} InvokeActionTask
+ * @property {String} actionType
+ * @property {Object} argObject
+ */
+
+/**
+ * @param {InvokeActionTask} task
+ * @param {Object} runnerOpts
+ * @returns {*} Task Execution Result
+ */
+module.exports = function(task, runnerOpts) {
+  const action = actions[task.actionType];
+
+  if (!action) {
+    throw new Error(`Unknown action type: [${task.actionType}]`);
+  }
+
+  return action(task, runnerOpts);
+};

lib/server-code/runners/tasks/invoke-method.js renamed to lib/server-code/runners/tasks/invoke-handler.js

@@ -14,15 +14,15 @@ const TIMED_OUT_ERR = 'Task execution aborted due to timeout';
 const defaultClassMappings = { [Backendless.User.prototype.___class]: Backendless.User };
 
 /**
- * @typedef {CodeRunnerTask} InvokeMethodTask
+ * @typedef {CodeRunnerTask} InvokeHandlerTask
  * @property {number} eventId
  * @property {string} target
  * @property {boolean} async
  * @property {Array.<number>} arguments
  */
 
 /**
- * @param {InvokeMethodTask} task
+ * @param {InvokeHandlerTask} task
  * @param {Object} runnerOpts
  * @param {ServerCodeModel} model
  * @returns {Promise.<?Array<number>>}
@@ -98,7 +98,7 @@ module.exports = function(task, runnerOpts, model) {
 };
 
 /**
- * @param {InvokeMethodTask} task
+ * @param {InvokeHandlerTask} task
  * @param {Object} runnerOpts
  * @returns {ServerCodeModel}
  */

test/invoke-action-task.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const executor = require('../lib/server-code/runners/tasks/executor');
+const should = require('should');
+const SHUTDOWN = 'SHUTDOWN';
+
+require('mocha');
+
+/**
+ * @param {String} actionType
+ * @returns {CodeRunnerTask}
+ */
+function createTask(actionType) {
+  return {
+    ___jsonclass: executor.RAI,
+    actionType : actionType
+  };
+}
+
+describe('[invoke-action] task executor', function() {
+  describe('on SHUTDOWN action', function() {
+    it('should stop the CodeRunner process', function() {
+      const exit = process.exit;
+      let exitCalled = false;
+
+      process.exit = function() {
+        exitCalled = true;
+      };
+
+      process.exit.restore = function() {
+        process.exit = exit;
+      };
+
+      return executor.execute(createTask(SHUTDOWN), {})
+        .then(process.exit.restore, process.exit.restore)
+        .then(() => should.equal(exitCalled, true));
+    });
+  });
+});

test/rmi-task.js renamed to test/invoke-handler-task.js

@@ -11,8 +11,6 @@ const should        = require('should'),
 
 require('mocha');
 
-const INVOKE_METHOD_TASK = 'com.backendless.coderunner.commons.protocol.RequestMethodInvocation';
-
 function stringToBytes(s) {
   return s.split('').map((c, i) => s.charCodeAt(i));
 }
@@ -34,7 +32,7 @@ function modelStub(handlerFn, classMappings) {
 
 function createTask(event, args, async) {
   return {
-    ___jsonclass: INVOKE_METHOD_TASK,
+    ___jsonclass: executor.RMI,
     eventId     : event.id,
     async       : !!async,
     initAppData : {},
@@ -53,7 +51,7 @@ function invokeAndParse(task, model) {
     });
 }
 
-describe('[invoke-method] task executor', function() {
+describe('[invoke-handler] task executor', function() {
   it('should fill [request] params', function() {
     const task = createTask(BEFORE_CREATE, [{}, { name: 'John' }]);