Merge pull request #3 from ember-fastboot/caching

Add support for caching layer

Author: tomdale

lib/express-http-server.js

@@ -7,10 +7,12 @@ class ExpressHTTPServer {
   constructor(options) {
     options = options || {};
 
+    this.ui = options.ui;
     this.username = options.username;
     this.password = options.password;
+    this.cache = options.cache;
+
     this.app = express();
-    this.ui = options.ui;
   }
 
   serve(middleware) {
@@ -23,6 +25,10 @@ class ExpressHTTPServer {
       app.use(basicAuth(username, password));
     }
 
+    if (this.cache) {
+      app.get('/*', this.buildCacheMiddleware());
+    }
+
     app.get('/*', middleware);
 
     return new Promise(resolve => {
@@ -36,6 +42,46 @@ class ExpressHTTPServer {
       });
     });
   }
+
+  buildCacheMiddleware() {
+    return (req, res, next) => {
+      let path = req.path;
+
+      Promise.resolve(this.cache.fetch(path, req))
+        .then(response => {
+          if (response) {
+            this.ui.writeLine(`cache hit; path=${path}`);
+            res.send(response);
+          } else {
+            this.ui.writeLine(`cache miss; path=${path}`);
+            this.interceptResponseCompletion(path, res);
+            next();
+          }
+        })
+        .catch(() => next());
+    };
+  }
+
+  interceptResponseCompletion(path, res) {
+    let send = res.send.bind(res);
+
+    res.send = (body) => {
+      let ret = send(body);
+
+      this.cache.put(path, body)
+        .then(() => {
+          this.ui.writeLine(`stored in cache; path=${path}`);
+        })
+        .catch(() => {
+          let truncatedBody = body.replace(/\n/g).substr(0, 200);
+          this.ui.writeLine(`error storing cache; path=${path}; body=${truncatedBody}...`);
+        });
+
+      res.send = send;
+
+      return ret;
+    };
+  }
 }
 
 module.exports = ExpressHTTPServer;

lib/fastboot-app-server.js

@@ -3,31 +3,47 @@
 const assert           = require('assert');
 const cluster          = require('cluster');
 const os               = require('os');
-const path             = require('path');
 
-const WORKER_PATH = path.join(__dirname, './worker.js');
+const Worker = require('./worker');
 
 class FastBootAppServer {
   constructor(options) {
     options = options || {};
 
-    this.downloader = options.downloader;
     this.distPath = options.distPath;
+    this.downloader = options.downloader;
     this.notifier = options.notifier;
-    this.workerCount = options.workerCount || os.cpus().length;
+    this.cache = options.cache;
     this.ui = options.ui;
 
     if (!this.ui) {
       let UI = require('./ui');
       this.ui = new UI();
-      this.propagateUI();
     }
 
-    assert(this.distPath || this.downloader, "FastBootAppServer must be provided with either a distPath or a downloader option.");
-    assert(!(this.distPath && this.downloader), "FastBootAppServer must be provided with either a distPath or a downloader option, but not both.");
+    this.propagateUI();
+
+    if (cluster.isWorker) {
+      this.worker = new Worker({
+        ui: this.ui,
+        distPath: this.distPath || process.env.FASTBOOT_DIST_PATH,
+        cache: this.cache
+      });
+
+      this.worker.start();
+    } else {
+      this.workerCount = options.workerCount ||
+        (process.env.NODE_ENV === 'test' ? 1 : null) ||
+        os.cpus().length;
+
+      assert(this.distPath || this.downloader, "FastBootAppServer must be provided with either a distPath or a downloader option.");
+      assert(!(this.distPath && this.downloader), "FastBootAppServer must be provided with either a distPath or a downloader option, but not both.");
+    }
   }
 
   start() {
+    if (cluster.isWorker) { return; }
+
     return this.initializeApp()
       .then(() => this.subscribeToNotifier())
       .then(() => this.forkWorkers())
@@ -44,6 +60,7 @@ class FastBootAppServer {
   propagateUI() {
     if (this.downloader) { this.downloader.ui = this.ui; }
     if (this.notifier) { this.notifier.ui = this.ui; }
+    if (this.cache) { this.cache.ui = this.ui; }
   }
 
   initializeApp() {
@@ -118,10 +135,6 @@ class FastBootAppServer {
   }
 
   forkWorker() {
-    cluster.setupMaster({
-      exec: WORKER_PATH
-    });
-
     let env = this.buildWorkerEnv();
     let worker = cluster.fork(env);
 

lib/worker.js

@@ -3,17 +3,19 @@
 const FastBoot           = require('fastboot');
 const fastbootMiddleware = require('fastboot-express-middleware');
 const ExpressHTTPServer  = require('./express-http-server');
-const UI                 = require('./ui');
 
 class Worker {
   constructor(options) {
     this.distPath = options.distPath;
     this.httpServer = options.httpServer;
     this.ui = options.ui;
+    this.cache = options.cache;
 
     if (!this.httpServer) {
-      this.httpServer = new ExpressHTTPServer();
-      this.httpServer.ui = this.ui;
+      this.httpServer = new ExpressHTTPServer({
+        ui: this.ui,
+        cache: this.cache
+      });
     }
   }
 
@@ -75,9 +77,4 @@ class Worker {
   }
 }
 
-let worker = new Worker({
-  distPath: process.env.FASTBOOT_DIST_PATH || false,
-  ui: new UI()
-});
-
-worker.start();
+module.exports = Worker;

package.json

@@ -4,7 +4,7 @@
   "description": "A production-ready app server for running Ember FastBoot apps",
   "main": "lib/fastboot-app-server.js",
   "scripts": {
-    "test": "mocha"
+    "test": "NODE_ENV=test mocha"
   },
   "repository": {
     "type": "git",

test/app-server-test.js

@@ -1,12 +1,22 @@
 "use strict";
 
+const path              = require('path');
+const fork              = require('child_process').fork;
 const expect            = require('chai').expect;
 const FastBootAppServer = require('../lib/fastboot-app-server');
 const request           = require('request-promise').defaults({ simple: false, resolveWithFullResponse: true });
 
+let server;
+
 describe("FastBootAppServer", function() {
   this.timeout(3000);
 
+  afterEach(function() {
+    if (server) {
+      server.kill();
+    }
+  });
+
   it("throws if no distPath or downloader is provided", function() {
     expect(() => {
       new FastBootAppServer();
@@ -23,16 +33,7 @@ describe("FastBootAppServer", function() {
   });
 
   it("serves an HTTP 500 response if the app can't be found", function() {
-    let server = new FastBootAppServer({
-      workerCount: 1,
-      downloader: {
-        download() {
-          return Promise.resolve();
-        }
-      }
-    });
-
-    return server.start()
+    return runServer('not-found-server')
       .then(() => request('http://localhost:3000'))
       .then(response => {
         expect(response.statusCode).to.equal(500);
@@ -41,3 +42,24 @@ describe("FastBootAppServer", function() {
   });
 
 });
+
+function runServer(name) {
+  return new Promise((res, rej) => {
+    let serverPath = path.join(__dirname, 'fixtures', `${name}.js`);
+    server = fork(serverPath, {
+      silent: true
+    });
+
+    server.on('error', rej);
+
+    server.stdout.on('data', data => {
+      if (data.toString().match(/HTTP server started/)) {
+        res();
+      }
+    });
+
+    server.stderr.on('data', data => {
+      console.log(data.toString());
+    });
+  });
+}

test/fixtures/not-found-server.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const FastBootAppServer = require('../../lib/fastboot-app-server.js');
+
+let server = new FastBootAppServer({
+  downloader: {
+    download() {
+      return Promise.resolve();
+    }
+  }
+});
+
+server.start();