Add option to run handlers in separate node processes (dherault#368)

* Add option to run handlers in separate node processes

* Use Object.assign instead of spread

* Handle child_process exit/error

* Use Set for inflight; lodash.omitBy for process.env workaround

Author: encounter

package.json

@@ -106,6 +106,7 @@
     "jsonpath-plus": "^0.16.0",
     "jsonwebtoken": "^7.4.3",
     "lodash": "^4.17.4",
+    "uuid": "^3.2.1",
     "velocityjs": "^0.9.3"
   },
   "devDependencies": {

src/functionHelper.js

@@ -1,6 +1,13 @@
 'use strict';
 
 const debugLog = require('./debugLog');
+const fork = require('child_process').fork;
+const _ = require('lodash');
+const path = require('path');
+const uuid = require('uuid/v4');
+
+const handlerCache = {};
+const messageCallbacks = {};
 
 module.exports = {
   getFunctionOptions(fun, funName, servicePath) {
@@ -18,9 +25,69 @@ module.exports = {
     };
   },
 
+  createExternalHandler(funOptions, options) {
+    let handlerContext = handlerCache[funOptions.handlerPath];
+
+    function handleFatal(error) {
+      debugLog(`External handler receieved fatal error ${JSON.stringify(error)}`);
+      handlerContext.inflight.forEach(id => messageCallbacks[id](error));
+      handlerContext.inflight.clear();
+      delete handlerCache[funOptions.handlerPath];
+    }
+
+    if (!handlerContext) {
+      debugLog(`Loading external handler... (${funOptions.handlerPath})`);
+
+      const helperPath = path.resolve(__dirname, 'ipcHelper.js');
+      const ipcProcess = fork(helperPath, [funOptions.handlerPath], {
+        env: _.omitBy(process.env, _.isUndefined),
+        stdio: [0, 1, 2, 'ipc'],
+      });
+      handlerContext = { process: ipcProcess, inflight: new Set() };
+      if (options.skipCacheInvalidation) {
+        handlerCache[funOptions.handlerPath] = handlerContext;
+      }
+
+      ipcProcess.on('message', message => {
+        debugLog(`External handler received message ${JSON.stringify(message)}`);
+        if (message.id) {
+          messageCallbacks[message.id](message.error, message.ret);
+          handlerContext.inflight.delete(message.id);
+          delete messageCallbacks[message.id];
+        }
+        else if (message.error) {
+          // Handler died!
+          handleFatal(message.error);
+        }
+
+        if (!options.skipCacheInvalidation) {
+          handlerContext.process.kill();
+          delete handlerCache[funOptions.handlerPath];
+        }
+      });
+
+      ipcProcess.on('error', error => handleFatal(error));
+      ipcProcess.on('exit', code => handleFatal(`Handler process exited with code ${code}`));
+    }
+    else {
+      debugLog(`Using existing external handler for ${funOptions.handlerPath}`);
+    }
+
+    return (event, context, done) => {
+      const id = uuid();
+      messageCallbacks[id] = done;
+      handlerContext.inflight.add(id);
+      handlerContext.process.send({ id, name: funOptions.handlerName, event, context });
+    };
+  },
+
   // Create a function handler
   // The function handler is used to simulate Lambda functions
   createHandler(funOptions, options) {
+    if (options.useSeparateProcesses) {
+      return this.createExternalHandler(funOptions, options);
+    }
+
     if (!options.skipCacheInvalidation) {
       debugLog('Invalidating cache...');
 

src/index.js

@@ -117,6 +117,9 @@ class Offline {
           noAuth: {
             usage: 'Turns off all authorizers',
           },
+          useSeparateProcesses: {
+            usage: 'Uses separate node processes for handlers',
+          }
         },
       },
     };
@@ -229,6 +232,7 @@ class Offline {
       corsAllowHeaders: 'accept,content-type,x-api-key',
       corsAllowCredentials: true,
       apiKey: crypto.createHash('md5').digest('hex'),
+      useSeparateProcesses: false,
     };
 
     this.options = _.merge({}, defaultOpts, (this.service.custom || {})['serverless-offline'], this.options);

src/ipcHelper.js

@@ -0,0 +1,21 @@
+'use strict';
+
+process.on('uncaughtException', e => {
+  process.send({ error: e });
+});
+
+const handler = require(process.argv[2]);
+
+process.on('message', opts => {
+  function done(error, ret) {
+    process.send({ id: opts.id, error, ret });
+  }
+
+  const context = Object.assign(opts.context, {
+    done,
+    succeed: res => done(null, res),
+    fail:    err => done(err, null),
+    // TODO implement getRemainingTimeInMillis
+  });
+  handler[opts.name](opts.event, context, done);
+});