API caching

Author: ericingram

lib/cache.js

@@ -1,7 +1,9 @@
 var inherits = require('util').inherits;
 var events = require('events');
+var crypto = require('crypto');
 var fs = require('fs');
 
+var DEFAULT_STORAGE = 'memory';
 var DEFAULT_WRITE_PERMS = '0644';
 var DEFAULT_INDEX_LIMIT = 1000;
 
@@ -14,16 +16,25 @@ var DEFAULT_INDEX_LIMIT = 1000;
 var Cache = function(clientId, options) {
   events.EventEmitter.call(this);
 
+  this.versions = null;
+  this.indexes = null;
+  this.memory = {};
+
   options = options || {};
   if (typeof options === 'string') {
     options = { path: options };
   }
   this.params = {
     clientId: clientId,
-    path: options.path,
+    path: options.path ? String(options.path) : '',
+    storage: options.storage || DEFAULT_STORAGE,
     writePerms: options.writePerms || DEFAULT_WRITE_PERMS,
     indexLimit: options.indexLimit || DEFAULT_INDEX_LIMIT
   };
+
+  if (this.params.storage !== 'memory') {
+    throw new Error(this.params.storage + ' storage is not currently supported');
+  }
 };
 
 inherits(Cache, events.EventEmitter);
@@ -35,7 +46,32 @@ inherits(Cache, events.EventEmitter);
  * @param  mixed data
  */
 Cache.prototype.get = function(url, data) {
+  data = data || null;
+
+  var cacheKey = this.getKey(url, data);
+  var result = this.getCache(cacheKey, 'result');
+
+  if (result) {
+    // Ensure cache_key exists in index
+    this.getIndex();
+    if (result.$collection !== undefined) {
+      var collection = result.$collection;
+      if (this.indexes[collection] && this.indexes[collection][cacheKey]) {
+        return result;
+      }
+    }
+
+    // Not found in proper index, then clear?
+    var resultCollections = this.resultCollections(result);
+    for (var i = 0; i < resultCollections.length; i++) {
+      var collection = resultCollections[i];
+      var where = {};
+      where[collection] = cacheKey;
+      this.clearIndexes(where);
+    }
+  }
 
+  return null;
 };
 
 /**
@@ -46,7 +82,10 @@ Cache.prototype.get = function(url, data) {
  * @return string
  */
 Cache.prototype.getKey = function(url, data) {
-
+  data = data || null;
+  var saneUrl = String(url).trim().replace(/^\/|\/$/g, '');
+  var keyData = JSON.stringify([ saneUrl, data ]);
+  return crypto.createHash('md5').update(keyData).digest('hex');
 };
 
 /**
@@ -55,7 +94,11 @@ Cache.prototype.getKey = function(url, data) {
  * @return string
  */
 Cache.prototype.getPath = function(url, data) {
-
+  return this.params.path.replace(/\/$/, '') +
+    '/client.' +
+    this.params.clientId +
+    '.' +
+    Array.prototype.slice.call(arguments).join('.');
 };
 
 /**
@@ -64,7 +107,10 @@ Cache.prototype.getPath = function(url, data) {
  * @return array
  */
 Cache.prototype.getVersions = function() {
-
+  if (!this.versions) {
+    this.versions = this.getCache('versions') || {};
+  }
+  return this.versions;
 };
 
 /**
@@ -73,7 +119,10 @@ Cache.prototype.getVersions = function() {
  * @return array
  */
 Cache.prototype.getIndex = function() {
-
+  if (!this.indexes) {
+    this.indexes = this.getCache('index') || {};
+  }
+  return this.indexes;
 };
 
 /**
@@ -84,7 +133,37 @@ Cache.prototype.getIndex = function() {
  * @param  mixed result
  */
 Cache.prototype.put = function(url, data, result) {
+  if (result.$data === undefined) {
+    result.$data = null; // Allows for null response
+  }
 
+  this.getVersions();
+
+  var cacheContent = Object.assign({}, result);
+  cacheContent.$cached = true;
+
+  var cacheKey = this.getKey(url, data);
+  var cachePath = this.getPath(cacheKey, 'result');
+
+  var size = this.writeCache(cachePath, cacheContent);
+
+  if (size > 0) {
+    if (result.$cached !== undefined) {
+      var cached = result.$cached;
+      var resultCollections = this.resultCollections(result);
+      for (var i = 0; i < resultCollections.length; i++) {
+        var collection = resultCollections[i];
+        // Collection may not be cacheable
+        if (cached[collection] === undefined && this.versions[collection] === undefined) {
+          continue;
+        }
+        this.putIndex(collection, cacheKey, size);
+        if (cached[collection] !== undefined) {
+          this.putVersion(collection, cached[collection]);
+        }
+      }
+    }
+  }
 };
 
 /**
@@ -95,7 +174,21 @@ Cache.prototype.put = function(url, data, result) {
  * @param  string size
  */
 Cache.prototype.putIndex = function(collection, key, size) {
+  this.getIndex();
+
+  // Limit size of index per client/collection
+  if (this.indexes[collection] !== undefined) {
+    if (Object.keys(this.indexes[collection]).length >= this.params.indexLimit) {
+      this.truncateIndex(collection);
+    }
+  }
 
+  this.indexes[collection] = this.indexes[collection] || {};
+  this.indexes[collection][key] = size;
+
+  var indexPath = this.getPath('index');
+
+  return this.writeCache(indexPath, this.indexes);
 };
 
 /**
@@ -106,7 +199,10 @@ Cache.prototype.putIndex = function(collection, key, size) {
  * @param  mixed data
  */
 Cache.prototype.remove = function(url, data) {
-
+  data = data || null;
+  var cacheKey = this.getKey(url, data);
+  var cachePath = this.getPath(cacheKey, 'result');
+  this.clearCache(cachePath);
 };
 
 /**
@@ -117,29 +213,71 @@ Cache.prototype.remove = function(url, data) {
  * @return bool
  */
 Cache.prototype.truncateIndex = function(collection) {
-
+  this.getIndex();
+  if (this.indexes[collection] === undefined) {
+    return;
+  }
+  var keys = Object.keys(this.indexes[collection]);
+  var lastKey = keys[keys.length - 1];
+  var invalid = {};
+  invalid[collection] = lastKey;
+  this.clearIndexes(invalid);
 };
 
 /**
  * Update/write the cache version file
  *
  * @param  string collection
- * @param  string cacheKey
+ * @param  number version
  * @return number
  */
-Cache.prototype.putVersion = function(collection, cacheKey) {
-
+Cache.prototype.putVersion = function(collection, version) {
+  if (!version) {
+    return;
+  }
+  this.getVersions();
+  this.versions[collection] = version;
+  var versionPath = this.getPath('versions');
+  this.writeCache(versionPath, this.versions);
 };
 
 /**
  * Clear all cache entries made invalid by result
  *
- * @param  string url
- * @param  mixed data
  * @param  mixed result
  */
-Cache.prototype.clear = function(url, data, result) {
+Cache.prototype.clear = function(result) {
+  if (result.$cached === undefined) {
+    return;
+  }
+
+  this.getVersions();
+
+  var invalid = {};
+  var cachedCollections = Object.keys(result.$cached);
+  for (var i = 0; i < cachedCollections.length; i++) {
+    var collection = cachedCollections[i];
+    var version = result.$cached[collection];
+    if (this.versions[collection] === undefined || version !== this.versions[collection]) {
+      this.putVersion(collection, version);
+      invalid[collection] = true;
+      // Hack to make admin.settings affect other api.settings
+      // TODO: figure out how to do this on the server side
+      if (collection === 'admin.settings') {
+        var versionCollections = Object.keys(this.versions);
+        for (var j = 0; j < versionCollections.length; j++) {
+          var verCollection = versionCollections[j];
+          if (String(verCollection).match(/\.settings$/)) {
+            invalid[verCollection] = true;
+          }
+        }
+      }
+    }
+  }
 
+  if (Object.keys(invalid).length > 0) {
+    this.clearIndexes(invalid);
+  }
 };
 
 /**
@@ -148,7 +286,36 @@ Cache.prototype.clear = function(url, data, result) {
  * @param  array invalid
  */
 Cache.prototype.clearIndexes = function(invalid) {
+  if (!invalid || Object.keys(invalid).length === 0) {
+    return;
+  }
+
+  this.getIndex();
+  var invalidCollections = Object.keys(invalid);
+  for (var i = 0; i < invalidCollections.length; i++) {
+    var collection = invalidCollections[i];
+    if (this.indexes[collection] !== undefined) {
+      if (invalid[collection] === true) {
+        // Clear all indexes per collection
+        var cacheKeys = Object.keys(this.indexes[collection]);
+        for (var j = 0; j < cacheKeys.length; j++) {
+          var key = cacheKeys[j];
+          var cachePath = this.getPath(key, 'result');
+          this.clearCache(cachePath);
+          delete this.indexes[collection][key];
+        }
+      } else if (invalid[collection] && this.indexes[collection][invalid[collection]] !== undefined) {
+        // Clear a single index element by key
+        var key = invalid[collection];
+        var cachePath = this.getPath(key, 'result');
+        this.clearCache(cachePath);
+        delete this.indexes[collection][key];
+      }
+    }
+  }
 
+  var indexPath = this.getPath('index');
+  this.writeCache(indexPath, this.indexes);
 };
 
 /**
@@ -157,7 +324,11 @@ Cache.prototype.clearIndexes = function(invalid) {
  * @return string
  */
 Cache.prototype.getCache = function() {
-
+  var cachePath = this.getPath.apply(this, arguments);
+  if (this.memory[cachePath] !== undefined) {
+    return JSON.parse(this.memory[cachePath]);
+  }
+  return null;
 };
 
 /**
@@ -168,7 +339,13 @@ Cache.prototype.getCache = function() {
  * @return number
  */
 Cache.prototype.writeCache = function(cachePath, content) {
+  var cacheContent = JSON.stringify(content);
+  var cacheSize = cacheContent.length;
 
+  // TODO: file system storage
+  this.memory[cachePath] = cacheContent;
+
+  return cacheSize;
 };
 
 /**
@@ -177,7 +354,7 @@ Cache.prototype.writeCache = function(cachePath, content) {
  * @param  string cachePath
  */
 Cache.prototype.clearCache = function(cachePath) {
-
+  delete this.memory[cachePath];
 };
 
 /**
@@ -187,7 +364,17 @@ Cache.prototype.clearCache = function(cachePath) {
  * @return array
  */
 Cache.prototype.resultCollections = function(result) {
-
+  var collections = result.$collection !== undefined ? [ result.$collection ] : [];
+  // Combine $collection and $expanded headers
+  if (result.$expanded !== undefined) {
+    for (var i = 0; i < result.$expanded.length; i++) {
+      var expCollection = result.$expanded[i];
+      if (collections.indexOf(expCollection) === -1) {
+        collections.push(expCollection);
+      }
+    }
+  }
+  return collections;
 };