Add support for HTTP Daemon

Author: keithwhor

index.js

@@ -1,5 +1,6 @@
 module.exports = {
   FunctionParser: require('./lib/parser/function_parser.js'),
+  Daemon: require('./lib/daemon.js'),
   Gateway: require('./lib/gateway.js'),
   types: require('./lib/types.js')
 };

lib/daemon.js

@@ -0,0 +1,317 @@
+const cluster = require('cluster');
+const os = require('os');
+const http = require('http');
+const fs = require('fs');
+
+const Gateway = require('./gateway.js');
+
+/**
+* Multi-process HTTP Daemon that resets when files changed (in development)
+* @class
+*/
+class Daemon {
+
+  constructor (name, cpus) {
+
+    this.name = name || 'HTTP';
+
+    this._watchers = null;
+
+    this._error = null;
+    this._server = null;
+    this._port = null;
+
+    this.cpus = parseInt(cpus) || os.cpus().length;
+    this.children = [];
+
+    process.on('exit', (code) => {
+
+      console.log(`[${this.name}.Daemon] Shutdown: Exited with code ${code}`);
+
+    });
+
+  }
+
+  /**
+  * Starts the Daemon. If all application services fail, will launch a
+  *   dummy error app on the port provided.
+  * @param {Number} port
+  */
+  start(port) {
+
+    this._port = port || 3000;
+
+    console.log(`[${this.name}.Daemon] Startup: Initializing`);
+
+    if ((process.env.NODE_ENV || 'development') === 'development') {
+
+      this.watch('', (changes) => {
+
+        changes.forEach(change => {
+          console.log(`[${this.name}.Daemon] ${change.event[0].toUpperCase()}${change.event.substr(1)}: ${change.path}`);
+        });
+
+        this.children.forEach(child => child.send({invalidate: true}));
+        this.children = [];
+        !this.children.length && this.unwatch() && this.start();
+
+      });
+
+    }
+
+    this._server && this._server.close();
+    this._server = null;
+
+    for (var i = 0; i < this.cpus; i++) {
+
+      let child = cluster.fork();
+      this.children.push(child);
+
+      child.on('message', this.message.bind(this));
+      child.on('exit', this.exit.bind(this, child));
+
+    }
+
+    console.log(`[${this.name}.Daemon] Startup: Spawning HTTP Workers`);
+
+  }
+
+  /**
+  * Daemon failed to load, set it in idle state (accept connections, give dummy response)
+  */
+  idle() {
+
+    let port = this._port || 3000;
+
+    this._server = http
+      .createServer((req, res) => {
+        this.error(req, res, this._error);
+        req.connection.destroy();
+      })
+      .listen(port);
+
+    console.log(`[${this.name}.Daemon] Idle: Unable to spawn HTTP Workers, listening on port ${port}`);
+
+  }
+
+  error(req, res, error) {
+
+    res.writeHead(500, {'Content-Type': 'text/plain'});
+    res.end(`Application Error:\n${error.stack}`);
+
+  }
+
+  message(data) {
+
+    data.error && this.logError(data.error);
+
+  }
+
+  /**
+  * Shut down a child process given a specific exit code. (Reboot if clean shutdown.)
+  * @param {child_process} child
+  * @param {Number} code Exit status codes
+  */
+  exit(child, code) {
+
+    let index = this.children.indexOf(child);
+
+    if (index === -1) {
+      return;
+    }
+
+    this.children.splice(index, 1);
+
+    if (code === 0) {
+      child = cluster.fork();
+      this.children.push(child);
+      child.on('message', this.message.bind(this));
+      child.on('exit', this.exit.bind(this, child));
+    }
+
+    if (this.children.length === 0) {
+      this.idle();
+    }
+
+  }
+
+  /**
+  * Log an error on the Daemon
+  * @param {Error} error
+  */
+  logError(error) {
+
+    this._error = error;
+    this._server = null;
+    console.log(`[${this.name}.Daemon] ${error.name}: ${error.message}`);
+    console.log(error.stack);
+
+  }
+
+  /**
+  * Stops watching a directory tree for changes
+  */
+  unwatch() {
+
+    clearInterval(this._watchers.interval);
+    this._watchers = null;
+    return true;
+
+  }
+
+  /**
+  * Watches a directory tree for changes
+  * @param {string} path Directory tree to watch
+  * @param {function} onChange Method to be executed when a change is detected
+  */
+  watch(path, onChange) {
+
+    function watchDir(cwd, dirname, watchers) {
+
+      if (!watchers) {
+
+        watchers = Object.create(null);
+        watchers.directories = Object.create(null);
+        watchers.interval = null;
+
+      }
+
+      let path = [cwd, dirname].join('');
+      let files = fs.readdirSync(path);
+
+      watchers.directories[path] = Object.create(null);
+
+      files.forEach(function(v) {
+
+        if (v === 'node_modules' || v.indexOf('.') === 0) {
+          return;
+        }
+
+        let filename = [dirname, v].join('/');
+        let fullPath = [cwd, filename].join('/');
+
+        let stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+          watchDir(cwd, filename, watchers);
+          return;
+        }
+
+        watchers.directories[path][v] = stat;
+
+      });
+
+      return watchers;
+
+    }
+
+    let watchers = watchDir(process.cwd(), path || '');
+    let self = this;
+
+    watchers.iterate = function(changes) {
+
+      if (changes.length) {
+        onChange.call(self, changes);
+      }
+
+    };
+
+    watchers.interval = setInterval(function() {
+
+      let changes = [];
+
+      Object.keys(watchers.directories).forEach(function(dirPath) {
+
+        let dir = watchers.directories[dirPath];
+        let files = fs.readdirSync(dirPath);
+        let added = [];
+
+        let contents = Object.create(null);
+
+        files.forEach(function(v) {
+
+          if (v === 'node_modules' || v.indexOf('.') === 0) {
+            return;
+          }
+
+          let fullPath = [dirPath, v].join('/');
+          let stat = fs.statSync(fullPath);
+
+          if (stat.isDirectory()) {
+            return;
+          }
+
+          if (!dir[v]) {
+            added.push([v, stat]);
+            changes.push({event: 'added', path: fullPath});
+            return;
+          }
+
+          if (stat.mtime.toString() !== dir[v].mtime.toString()) {
+            dir[v] = stat;
+            changes.push({event: 'modified', path: fullPath});
+          }
+
+          contents[v] = true;
+
+        });
+
+        Object.keys(dir).forEach(function(v) {
+
+          let fullPath = [dirPath, v].join('/');
+
+          if (!contents[v]) {
+            delete dir[v];
+            changes.push({event: 'removed', path: fullPath});
+          }
+
+        });
+
+        added.forEach(function(v) {
+          dir[v[0]] = v[1];
+        });
+
+      });
+
+      watchers.iterate(changes);
+
+    }, 1000);
+
+    return this._watchers = watchers;
+
+  }
+
+}
+
+class FunctionScriptDaemon extends Daemon {
+  constructor (cpus) {
+    super('FunctionScript', cpus);
+  }
+}
+
+FunctionScriptDaemon.Gateway = class FunctionScriptDaemonGateway extends Gateway {
+
+  constructor (cfg) {
+    super(cfg);
+    process.on('uncaughtException', e => {
+      process.send({
+        error: {
+          name: e.name,
+          message: e.message,
+          stack: e.stack
+        }
+      });
+      process.exit(1);
+    });
+    process.on('message', data => data.invalidate && process.exit(0));
+    process.on('exit', code => console.log(`${this.formatName(this.name)} Shutdown: Exited with code ${code}`));
+  }
+
+  listen () {
+    super.listen();
+    process.send({message: 'ready'});
+  }
+
+}
+
+module.exports = FunctionScriptDaemon;

lib/gateway.js

@@ -10,7 +10,7 @@ const types = require('./types.js');
 const background = require('./background.js');
 
 const DEFAULT_PORT = 8170;
-const DEFAULT_NAME = 'FunctionScript Gateway';
+const DEFAULT_NAME = 'FunctionScript.Gateway';
 const DEFAULT_MAX_REQUEST_SIZE_MB = 128;
 
 class Gateway extends EventEmitter {
@@ -43,7 +43,7 @@ class Gateway extends EventEmitter {
   }
 
   formatName (name) {
-    return `[${name}]`;
+    return `[${name}.${process.pid}]`;
   }
 
   formatRequest (req) {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionscript",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "A language and specification for turning JavaScript functions into typed HTTP APIs",
   "author": "Keith Horwood <keithwhor@gmail.com>",
   "main": "index.js",
@@ -17,6 +17,6 @@
   "devDependencies": {
     "chai": "^3.5.0",
     "form-data": "^2.3.2",
-    "mocha": "^3.2.0"
+    "mocha": "^6.1.4"
   }
 }