cloudcms-server 3.2.285 → 3.2.287

package/broadcast/broadcast.js

@@ -11,12 +11,15 @@ module.exports = function()
         var self = this;
 
         // set up defaults
-        if (!process.env.CLOUDCMS_BROADCAST_TYPE) {
+        if (!process.env.CLOUDCMS_BROADCAST_TYPE)
+        {
             process.env.CLOUDCMS_BROADCAST_TYPE = "local";
-
-            // if (process.configuration.setup !== "single") {
-            //     process.env.CLOUDCMS_BROADCAST_TYPE = "redis";
-            // }
+    
+            // auto-configure
+            if (process.env.CLOUDCMS_LAUNCHPAD_SETUP === "redis")
+            {
+                process.env.CLOUDCMS_BROADCAST_TYPE = "redis";
+            }
         }
 
         var config = process.configuration;

package/locks/locks.js

@@ -39,10 +39,12 @@ exports = module.exports = function()
         if (!process.env.CLOUDCMS_LOCKS_TYPE)
         {
             process.env.CLOUDCMS_LOCKS_TYPE = "memory";
-
-            // if (process.configuration.setup !== "single") {
-            //     process.env.CLOUDCMS_LOCKS_TYPE = "redis";
-            // }
+    
+            // auto-configure
+            if (process.env.CLOUDCMS_LAUNCHPAD_SETUP === "redis")
+            {
+                process.env.CLOUDCMS_LOCKS_TYPE = "redis";
+            }
         }
 
         if (!process.configuration.locks) {

package/middleware/awareness/awareness.js

@@ -43,10 +43,12 @@ exports = module.exports = function()
         if (!process.env.CLOUDCMS_AWARENESS_TYPE)
         {
             process.env.CLOUDCMS_AWARENESS_TYPE = "memory";
-
-            // if (process.configuration.setup !== "single") {
-            //     process.env.CLOUDCMS_AWARENESS_TYPE = "redis";
-            // }
+    
+            // auto-configure
+            if (process.env.CLOUDCMS_LAUNCHPAD_SETUP === "redis")
+            {
+                process.env.CLOUDCMS_AWARENESS_TYPE = "redis";
+            }
         }
 
         if (!process.configuration.awareness) {

package/middleware/cache/cache.js

@@ -27,10 +27,12 @@ exports = module.exports = function()
         if (!process.env.CLOUDCMS_CACHE_TYPE) {
 
             process.env.CLOUDCMS_CACHE_TYPE = "memory";
-
-            // if (process.configuration.setup !== "single") {
-            //     process.env.CLOUDCMS_CACHE_TYPE = "redis";
-            // }
+    
+            // auto-configure
+            if (process.env.CLOUDCMS_LAUNCHPAD_SETUP === "redis")
+            {
+                process.env.CLOUDCMS_CACHE_TYPE = "redis";
+            }
         }
 
         if (!process.configuration.cache.type)

package/middleware/cache/providers/shared-memory.js

@@ -1,7 +1,7 @@
-var path = require("path");
-var memored = require('../../../temp/memored');
+//var path = require("path");
+var memored = require("memored");
 
-var cluster = require("cluster");
+//var cluster = require("cluster");
 
 /**
  * Shared cluster memory using memored

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "cloudcms-server",
   "description": "Cloud CMS Application Server Module",
-  "version": "3.2.285",
+  "version": "3.2.287",
   "repository": {
     "type": "git",
     "url": "git://github.com/gitana/cloudcms-server.git"
@@ -50,8 +50,9 @@
     "json5": "^1.0.1",
     "jsonwebtoken": "^8.5.1",
     "klaw": "^1.3.1",
-    "lru-cache": "^4.1.5",
+    "lru-cache": "^7.14.0",
     "marked": "^4.0.14",
+    "memored": "^1.1.1",
     "memorystore": "^1.6.1",
     "mime": "^1.6.0",
     "mkdirp": "^0.5.1",

package/util/auth.js

@@ -8,16 +8,18 @@ var http = require("http");
 var https = require("https");
 var async = require("async");
 
+var LRU = require("lru-cache");
+
 // trusted profile cache size 100
-var TRUSTED_PROFILE_CACHE = require("lru-cache")({
+var TRUSTED_PROFILE_CACHE = new LRU({
     max:100,
-    maxAge: 1000 * 60 * 15 // 15 minutes
+    ttl: 1000 * 60 * 15 // 15 minutes
 });
 
 // user entry cache size 100
-var USER_ENTRY_CACHE = require("lru-cache")({
+var USER_ENTRY_CACHE = new LRU({
     max: 100,
-    maxAge: 1000 * 60 * 15 // 15 minutes
+    ttl: 1000 * 60 * 15 // 15 minutes
 });
 
 var Gitana = require("gitana");

package/util/proxy-factory.js

@@ -10,6 +10,8 @@ var oauth2 = require("./oauth2")();
 var urlTool = require("url");
 const finalhandler = require("finalhandler");
 
+var LRU = require("lru-cache");
+
 var exports = module.exports;
 
 var _LOCK = function(lockIdentifiers, workFunction)
@@ -18,9 +20,9 @@ var _LOCK = function(lockIdentifiers, workFunction)
     process.locks.lock(name, workFunction);
 };
 
-var NAMED_PROXY_HANDLERS_CACHE = require("lru-cache")({
+var NAMED_PROXY_HANDLERS_CACHE = new LRU({
     max: 200,
-    maxAge: 1000 * 60 * 60 // 60 minutes
+    ttl: 1000 * 60 * 60 // 60 minutes
 });
 
 var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pathPrefix, callback)
@@ -30,7 +32,6 @@ var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pa
     // is it already in LRU cache?
     // if so hand it back
     var _cachedHandler = NAMED_PROXY_HANDLERS_CACHE[name];
-    _cachedHandler = null;
     if (_cachedHandler)
     {
         return callback(null, _cachedHandler);
@@ -49,7 +50,6 @@ var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pa
 
         // second check to make sure another thread didn't create the handler in the meantime
         _cachedHandler = NAMED_PROXY_HANDLERS_CACHE[name];
-        _cachedHandler = null;
         if (_cachedHandler)
         {
             releaseLockFn();
@@ -57,7 +57,7 @@ var acquireProxyHandler = exports.acquireProxyHandler = function(proxyTarget, pa
         }
 
         // create the proxy handler and cache it into LRU cache
-        console.log("Acquiring proxy handler: " + name + ", for target: " + proxyTarget + " and prefix: " + pathPrefix);
+        //console.log("Acquiring proxy handler: " + name + ", for target: " + proxyTarget + " and prefix: " + pathPrefix);
         _cachedHandler = createProxyHandler(proxyTarget, pathPrefix);
     
         // store back into LRU cache
@@ -274,8 +274,8 @@ var createProxyHandler = function(proxyTarget, pathPrefix)
         });
     };
     
-    
     // cookie domain rewrite?
+    // not needed - this is handled intrinsically by http2-proxy
 
     return proxyRequestHandler;
 };

package/temp/memored/.jshintrc

@@ -1,4 +0,0 @@
-{
-	"node": true,
-	"unused": true
-}

package/temp/memored/README.md

@@ -1,240 +0,0 @@
-# Memored
-
-Memored implements an in-memory shared cache to use in nodejs applications which uses [cluster](http://nodejs.org/api/cluster.html) module.
-
-Let's say you want your application to take advantage of multi-core CPUs using nodejs cluster module; you will be able to run several _isolated_ processes which shared nothing but a communication channel with parent process.
-If you need a fast volatile cache, common solutions would create an in-memory map for every process you run, so you end up with the same data stored several times in your machine RAM.
-
-Memored uses communication channel between master process and its workers to use a unique in-memory storage, reducing the amount of memory your application would use.
-
-## Getting Started
-Install this module with _npm_:
-```javascript
-npm install memored
-```
-
-Store and read values is straightforward:
-```javascript
-var cluster = require('cluster'),
-	memored = require('memored');
-
-if (cluster.isMaster) {
-	cluster.fork();
-} else {
-	var han = {
-			firstname: 'Han',
-			lastname: 'Solo'
-		},
-		luke = {
-			firstname: 'Luke',
-			lastname: 'Skywalker'
-		};
-
-	// Store and read
-	memored.store('character1', han, function() {
-		console.log('Value stored!');
-
-		memored.read('character1', function(err, value) {
-			console.log('Read value:', value);
-		});
-	});
-
-	// You can also set a ttl (milliseconds)
-	memored.store('character2', luke, 1000, function(err, expirationTime) {
-		console.log('Value stored until:', new Date(expirationTime));
-
-		setTimeout(function() {
-			memored.read('character2', function(err, value) {
-				console.log('Value is gone?', value === undefined);
-
-				process.exit();
-			});
-		}, 1050);
-	});
-}
-```
-
-## Invalidation management
-By default, _memored_ will evict cache entries (stored with _ttl_) passively. This is, when you read an expired entry, you will get no value on return and _memored_ will delete the value from its internal cache.
-
-You can also configure _memored_ to actively evict expired entries every N milliseconds. For this to work, you need to pass the attribute *purgeInterval* to the *setup* function.
-This will trigger an internal function which looks for expired entries and deletes them from its internal cache.
-
-Example:
-```javascript
-var cluster = require('cluster'),
-	async = require('async'),
-	memored = require('memored');
-
-if (cluster.isMaster) {
-
-	cluster.fork();
-	memored.setup({ purgeInterval: 500});
-
-} else {
-
-	async.series({
-		storeValue: function(next) {
-			memored.store('key1', 'My simple string value', 100, next);
-		},
-		readCacheSize: function(next) {
-			memored.size(function(err, size) {
-				console.log('Current size is 1?', size === 1);
-				next();
-			});
-		},
-		wait: function(next) {
-			setTimeout(next, 600);
-		},
-		readCacheSizeAgain: function(next) {
-			memored.size(function(err, size) {
-				console.log('Current size is 0?', size === 0);
-				next();
-			});
-		}
-	}, process.exit);
-}
-```
-
-## API
-Documentation for every module function:
-
-
-### setup(options)
-
-This function is used to configure _memored_.
-
-**Arguments**:
-
-- **purgeInterval** {Number} (optional): Configures and triggers _memored_ expired entries auto deletion. Value expressed in milliseconds. _It's only used when called this method from the master process of your application_.
-- **logger** {Object} (optional): In you want _memored_ to log something, you must provide an object implementing *log* and *warn* functions.
-
-**Example**:
-```javascript
-memored.setup({
-	purgeInterval: 15000,
-	logger: console
-});
-```
-
-### store(key, value, [ttl], callback)
-
-This function stores a value in the cache.
-_It is intended to be called from a worker process_.
-
-**Arguments**:
-
-- **key** {String} (required): Key used to lookup the entry
-- **value** {Mixed} (required): Whatever you want to store
-- **ttl** {Number} (optional): Time to live for this value in the cache (milliseconds)
-- **callback** {Function} (optional): Function to be call on store completion. Callback arguments:
-	- _err_ {Error}: Optional error
-	- _expirationTime_ {Number}: The timestamp of the moment when this entry will expire. If _ttl_ is not used, this value will be undefined.
-
-**Examples**:
-```javascript
-memored.store('key1', {firstname: 'Han', lastname: 'Solo'}, function() {
-	console.log('Value stored!');
-});
-
-memored.store('key2', ['a', 'b', 'c'], 15000, function(err, expirationTime) {
-	console.log('This value will expire on:', new Date(expirationTime));
-});
-```
-
-### read(key, callback)
-
-This function reads a value from the cache.
-_It is intended to be called from a worker process_.
-
-**Arguments**:
-
-- **key** {String} (required): Key used to lookup the entry
-- **callback** {Function} (required): Function to be called on read completion. Callback arguments:
-	- _err_ {Error}: Optional error
-	- _value_ {Mixed}: Contents of the cached entry. If the value is not found or is expired, it will be undefined.
-
-**Example**:
-```javascript
-memored.read('key1', function(err, value) {
-	console.log('Key1 value:', value);
-});
-
-memored.read('key1', function(err, value, expirationTime) {
-	console.log('Key1 value:', value);
-	console.log('Key1 expiration time:', new Date(expirationTime));
-});
-
-memored.read('unknownKey', function(err, value) {
-	console.log('No data read?', value === undefined);
-});
-```
-
-### remove(key, callback)
-
-This function removes an entry from the cache.
-_It is intended to be called from a worker process_.
-
-**Arguments**:
-
-- **key** {String} (required): Key used to lookup the entry
-- **callback** {Function} (optional): Function to be called on read completion.
-
-**Example**:
-```javascript
-memored.remove('key1', function() {
-	console.log('Key removed from the cache.');
-});
-```
-
-### clean(callback)
-
-This function removes all the entries from the cache.
-_It is intended to be called from a worker process_.
-
-**Arguments**:
-
-- **callback** {Function} (optional): Function to be called on read completion.
-
-**Example**:
-```javascript
-memored.clean(function() {
-	console.log('All cache entries have been deleted.');
-});
-```
-
-### size(callback)
-
-This function returns the number of entries in the cache.
-
-**Arguments**:
-
-- **callback** {Function} (required): Function to be called on size calculation is complete. Callback arguments:
-	- _err_ {Error}: Optional error
-	- _size_ {Number}: The number of entries in the cache.
-
-**Example**:
-
-```javascript
-memored.size(function(err, size) {
-	console.log('Cache size:', size);
-});
-```
-
-### version
-
-This is an attribute wich provides module's version number
-
-
-# Final note
-All the callbacks first parameter is an optional error object. Actually, this param will never be an error because there is no expected error in the internal code. There's no function call that can possible throw an expected error that this module would deal with.
-The existence of this param is to follow the *convention* about libraries callbacks in nodejs. As everybody expects this first callback parameter to be an optional one, I decided to include it.
-
-- [Nodeguide](http://nodeguide.com/style.html#callbacks)
-- [Nodejitsu](http://docs.nodejitsu.com/articles/errors/what-are-the-error-conventions)
-- [GoSquared](https://engineering.gosquared.com/node-js-error-handling-callbacks-vs-promises)
-
-
-## License
-Copyright (c) 2014 PaquitoSoft  
-Licensed under the MIT license.

package/temp/memored/demo/demo1.js

@@ -1,37 +0,0 @@
-var cluster = require('cluster'),
-	memored = require('../index');
-
-if (cluster.isMaster) {
-	cluster.fork();
-} else {
-	var han = {
-			firstname: 'Han',
-			lastname: 'Solo'
-		},
-		luke = {
-			firstname: 'Luke',
-			lastname: 'Skywalker'
-		};
-
-	// Store and read
-	memored.store('character1', han, function() {
-		console.log('Value stored!');
-
-		memored.read('character1', function(err, value) {
-			console.log('Read value:', value);
-		});
-	});
-
-	// You can also set a ttl (milliseconds)
-	memored.store('character2', luke, 1000, function(err, expirationTime) {
-		console.log('Value stored until:', new Date(expirationTime));
-
-		setTimeout(function() {
-			memored.read('character2', function(err, value) {
-				console.log('Value is gone?', value === undefined);
-
-				process.exit();
-			});
-		}, 1050);
-	});
-}

package/temp/memored/demo/demo2.js

@@ -1,32 +0,0 @@
-var cluster = require('cluster'),
-	async = require('async'),
-	memored = require('../index');
-
-if (cluster.isMaster) {
-
-	cluster.fork();
-	memored.setup({ purgeInterval: 500});
-
-} else {
-
-	async.series({
-		storeValue: function(next) {
-			memored.store('key1', 'My simple string value', 100, next);
-		},
-		readCacheSize: function(next) {
-			memored.size(function(err, size) {
-				console.log('Current size is 1?', size === 1);
-				next();
-			});
-		},
-		wait: function(next) {
-			setTimeout(next, 600);
-		},
-		readCacheSizeAgain: function(next) {
-			memored.size(function(err, size) {
-				console.log('Current size is 0?', size === 0);
-				next();
-			});
-		}
-	}, process.exit);
-}

package/temp/memored/gulpfile.js

@@ -1,8 +0,0 @@
-var gulp = require('gulp'),
-	mocha = require('gulp-mocha')/*,
-	plumber = require('gulp-plumber')*/;
-
-gulp.task('default', function() {
-	return gulp.src('spec/*.spec.js', {read: true})
-		.pipe(mocha({ui: 'bdd', reporter: 'spec'}));
-});

package/temp/memored/index.js

@@ -1,343 +0,0 @@
-'use strict';
-
-var cluster = require('cluster'),
-	packageInfo = require('./package');
-
-var logger = {
-	log: function() {},
-	warn: function() {}
-};
-
-var messagesCounter = 0;
-
-var activeMessages = {};
-
-var purgeIntervalObj;
-
-/*
- message
- - workerPid
- - type
- - requestParams
- */
-
-var cache = {};
-
-function CacheEntry(data) { // ttl -> milliseconds
-	this.key = data.key;
-	this.value = data.value;
-	this.creationTime = Date.now();
-	if (data.ttl) {
-		this.ttl = data.ttl;
-		this.expirationTime = this.creationTime + data.ttl;
-	}
-}
-CacheEntry.prototype.isExpired = function() {
-	return this.expirationTime && Date.now() > this.expirationTime;
-};
-CacheEntry.prototype.toString = function() {
-	return "Key: " + this.key + "; Value: " + this.value + "; Ttl: " + this.ttl;
-};
-
-function _findWorkerByPid(workerPid) {
-	var i = 0,
-		workerIds = Object.keys(cluster.workers),
-		len = workerIds.length,
-		worker;
-
-	for (; i < len; i++) {
-		if (cluster.workers[workerIds[i]].process.pid == workerPid) {
-			worker = cluster.workers[workerIds[i]];
-			break;
-		}
-	}
-
-	return worker;
-}
-
-function _getResultParamsValues(paramsObj) {
-	var result = [null],
-		prop;
-	if (paramsObj) {
-		for (prop in paramsObj) {
-			result.push(paramsObj[prop]);
-		}
-	}
-	return result;
-}
-
-function _sendMessageToWorker(message) {
-	var worker = _findWorkerByPid(message.workerPid);
-	worker.send(message);
-}
-
-function _sendMessageToMaster(message) {
-	message.channel = 'memored';
-	message.workerPid = process.pid;
-	message.id = process.pid + '::' + messagesCounter++;
-	process.send(message);
-	if (message.callback) {
-		activeMessages[message.id] = message;
-	}
-}
-
-function _readCacheValue(message) {
-	var cacheEntry = cache[message.requestParams.key];
-	if (!cacheEntry) return _sendMessageToWorker(message);
-	if (cacheEntry.isExpired()) {
-		process.nextTick(function() {
-			delete cache[message.requestParams.key];
-		});
-		cacheEntry = null;
-	}
-
-	if (cacheEntry) {
-		message.responseParams = {
-			value: cacheEntry.value
-		};
-		if (cacheEntry.expirationTime) {
-			message.responseParams.expirationTime = cacheEntry.expirationTime;
-		}
-	}
-
-	_sendMessageToWorker(message);
-}
-
-function _storeCacheValue(message) {
-	cache[message.requestParams.key] = new CacheEntry(message.requestParams);
-	if (message.requestParams.ttl) {
-		message.responseParams = {
-			expirationTime: cache[message.requestParams.key].expirationTime
-		};
-	}
-	_sendMessageToWorker(message);
-}
-
-function _removeCacheValue(message) {
-	delete cache[message.requestParams.key];
-	_sendMessageToWorker(message);
-}
-
-function _cleanCache(message) {
-	cache = {};
-	_sendMessageToWorker(message);
-}
-
-function _getCacheSize(message) {
-	message.responseParams = {
-		size: Object.keys(cache).length
-	};
-	_sendMessageToWorker(message);
-}
-
-function _getCacheKeys(message) {
-	message.responseParams = {
-		keys: Object.keys(cache)
-	};
-	_sendMessageToWorker(message);
-}
-
-function _purgeCache() {
-	var now = Date.now();
-	Object.keys(cache).forEach(function(cacheKey) {
-		if (cache[cacheKey].expirationTime && cache[cacheKey].expirationTime < now) {
-			delete cache[cacheKey];
-		}
-	});
-}
-
-function _masterIncomingMessagesHanlder(message) {
-	logger.log('Master received message:', message);
-
-	if (!message || message.channel !== 'memored') return false;
-
-	switch (message.type) {
-		case 'read':
-			_readCacheValue(message);
-			break;
-		case 'store':
-			_storeCacheValue(message);
-			break;
-		case 'remove':
-			_removeCacheValue(message);
-			break;
-		case 'clean':
-			_cleanCache(message);
-			break;
-		case 'size':
-			_getCacheSize(message);
-			break;
-		case 'keys':
-			_getCacheKeys(message);
-			break;
-		default:
-			logger.warn('Received an invalid message type:', message.type);
-	}
-}
-
-function _workerIncomingMessagesHandler(message) {
-	logger.log('Worker received message:', message);
-
-	var pendingMessage;
-
-	if (!message || message.channel !== 'memored') return false;
-
-	pendingMessage = activeMessages[message.id];
-	if (pendingMessage && pendingMessage.callback) {
-		pendingMessage.callback.apply(null, _getResultParamsValues(message.responseParams));
-		delete activeMessages[message.id];
-	}
-
-}
-
-if (cluster.isMaster) {
-
-	Object.keys(cluster.workers).forEach(function(workerId) {
-		cluster.workers[workerId].on('message', _masterIncomingMessagesHanlder);
-	});
-
-	// Listen for new workers so we can listen to its messages
-	cluster.on('fork', function(worker) {
-		worker.on('message', _masterIncomingMessagesHanlder);
-	});
-
-	// TODO: Only for testing purposes
-	// setInterval(function() {
-	//	logger.log('\n------------------------------------------');
-	//	logger.log(cache);
-	//	logger.log('------------------------------------------\n');
-	// }, 2000).unref();
-
-} else {
-
-	process.on('message', _workerIncomingMessagesHandler);
-
-}
-
-function _setup(options) {
-	options = options || {};
-	logger = options.logger || logger;
-
-	if (cluster.isMaster) {
-
-		if (options.mockData) {
-			options.mockData.forEach(function(mock) {
-				// key, value, ttl
-				cache[mock.key] = new CacheEntry(mock);
-			});
-		}
-
-		if (options.purgeInterval) {
-			purgeIntervalObj = setInterval(function() {
-				_purgeCache();
-			}, options.purgeInterval).unref();
-		}
-	}
-}
-
-function _read(key, callback) {
-	if (cluster.isWorker) {
-		_sendMessageToMaster({
-			type: 'read',
-			requestParams: {
-				key: key
-			},
-			callback: callback
-		});
-	} else {
-		logger.warn('Memored::read# Cannot call this function from master process');
-	}
-}
-
-function _store(key, value, ttl, callback) {
-	if (cluster.isWorker) {
-		if (callback === undefined) {
-			callback = ttl;
-			ttl = undefined;
-		}
-
-		_sendMessageToMaster({
-			type: 'store',
-			requestParams: {
-				key: key,
-				value: value,
-				ttl: ttl
-			},
-			callback: callback
-		});
-	} else {
-		logger.warn('Memored::store# Cannot call this function from master process');
-	}
-}
-
-function _remove(key, callback) {
-	if (cluster.isWorker) {
-		_sendMessageToMaster({
-			type: 'remove',
-			requestParams: {
-				key: key
-			},
-			callback: callback
-		});
-	} else {
-		logger.warn('Memored::remove# Cannot call this function from master process');
-	}
-}
-
-function _clean(callback) {
-	if (cluster.isWorker) {
-		_sendMessageToMaster({
-			type: 'clean',
-			callback: callback
-		});
-	} else {
-		logger.warn('Memored::clean# Cannot call this function from master process');
-	}
-}
-
-function _size(callback) {
-	if (cluster.isWorker) {
-		_sendMessageToMaster({
-			type: 'size',
-			callback: callback
-		});
-	} else {
-		setImmediate(callback,{
-			size: Object.keys(cache).length
-		});
-	}
-}
-
-function _reset(callback) {
-	if (cluster.isMaster) {
-		clearInterval(purgeIntervalObj);
-		setImmediate(callback);
-	} else {
-		logger.warn('Memored::reset# Cannot call this function from a worker process');
-	}
-}
-
-function _keys(callback) {
-	if (cluster.isWorker) {
-		_sendMessageToMaster({
-			type: 'keys',
-			callback: callback
-		});
-	} else {
-		setImmediate(callback,{
-			keys: Object.keys(cache)
-		});
-	}
-}
-
-module.exports = {
-	version: packageInfo.version,
-	setup: _setup,
-	read: _read,
-	store: _store,
-	remove: _remove,
-	clean: _clean,
-	size: _size,
-	reset: _reset,
-	keys: _keys
-};

package/temp/memored/package.json

@@ -1,54 +0,0 @@
-{
-  "name": "memored",
-  "version": "0.0.4",
-  "description": "Shared in-memory module for cluster applications",
-  "main": "index.js",
-  "scripts": {
-    "test": "gulp"
-  },
-  "author": {
-    "name": "Paquitosoft"
-  },
-  "license": "MIT",
-  "keywords": [
-    "cache",
-    "memory",
-    "shared"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/PaquitoSoft/memored.git"
-  },
-  "bugs": {
-    "url": "https://github.com/PaquitoSoft/memored/issues"
-  },
-  "devDependencies": {
-    "async": "^0.9.0",
-    "chai": "^1.9.1",
-    "faker": "^1.1.0",
-    "gulp": "^3.8.7",
-    "gulp-mocha": "^1.0.0"
-  },
-  "gitHead": "37d1ab5e06ab4fc5d3ff99d36bf4be7cbe019567",
-  "homepage": "https://github.com/PaquitoSoft/memored",
-  "_id": "memored@0.0.4",
-  "_shasum": "70b21f1707cb28f04ea2ef9629109b75f8cf7791",
-  "_from": "memored@*",
-  "_npmVersion": "1.4.21",
-  "_npmUser": {
-    "name": "paquitosoft",
-    "email": "paquitosoftware@gmail.com"
-  },
-  "maintainers": [
-    {
-      "name": "paquitosoft",
-      "email": "paquitosoftware@gmail.com"
-    }
-  ],
-  "dist": {
-    "shasum": "70b21f1707cb28f04ea2ef9629109b75f8cf7791",
-    "tarball": "http://registry.npmjs.org/memored/-/memored-0.0.4.tgz"
-  },
-  "directories": {},
-  "_resolved": "https://registry.npmjs.org/memored/-/memored-0.0.4.tgz"
-}

package/temp/memored/spec/memored.spec.js

@@ -1,265 +0,0 @@
-'use strict';
-
-/* global describe, after, it */
-var cluster = require('cluster'),
-	expect = require('chai').expect,
-	faker = require('faker'),
-	async = require('async'),
-	memored = require('../index.js');
-
-function _createUser() {
-	return {
-		firstName: faker.Name.findName(),
-		lastName: faker.Name.lastName(),
-		email: faker.Internet.email(),
-		address: {
-			streetAddress: faker.Address.streetName() + ' - ' + faker.Address.streetAddress(),
-			zipCode: faker.Address.zipCode(),
-			city: faker.Address.city()
-		}
-	};
-}
-
-describe('Memored test suite', function() {
-	
-	if (cluster.isMaster) {
-		cluster.fork();
-		
-		describe('Memored - purge', function() {
-
-			var mockedData = [
-				{
-					key: 'mock1',
-					value: _createUser(),
-					ttl: 25
-				},
-				{
-					key: 'mock2',
-					value: _createUser(),
-					ttl: 75
-				},
-				{
-					key: 'mock3',
-					value: _createUser()
-				}
-			];
-
-			it.only('Should auto-remove old data if configured to purge', function(done) {
-				async.series({
-					setup: function(next) {
-						memored.setup({purgeInterval: 50, mockData: mockedData});
-						next();
-					},
-					getCacheSize: function(next) {
-						memored.size(function(data) {
-							expect(data.size).to.equal(3);
-							next();
-						});
-					},
-					wait: function(next) {
-						setTimeout(next, 60);
-					},
-					getCacheSize2: function(next) {
-						memored.size(function(data) {
-							expect(data.size).to.equal(2);
-							next();
-						});
-					},
-					waitAgain: function(next) {
-						setTimeout(next, 50);
-					},
-					getCacheSize3: function(next) {
-						memored.size(function(data) {
-							expect(data.size).to.equal(1);
-							next();
-						});
-					},
-				}, done);
-			});
-		});
-
-	} else {
-
-		after(function() {
-			process.exit();
-		});
-
-		describe('Memored - store', function() {
-
-			it('Should store a value in the cache', function(done) {
-				var user1 = _createUser();
-				memored.store('user1', user1, function(err, expirationTime) {
-					expect(err).to.equal(null);
-					expect(expirationTime).to.equal(undefined);
-					done();
-				});
-			});
-
-			it('Should store a value and create an expiration time when ttl is used', function(done) {
-				var user2 = _createUser(),
-					t1 = Date.now();
-				memored.store('user2', user2, 100, function(err, expirationTime) {
-					expect(err).to.equals(null);
-					expect(expirationTime).to.be.a('number');
-					expect(expirationTime).to.be.least(t1 + 100);
-					done();
-				});
-			});
-
-		});
-
-		describe('Memored - read', function() {
-
-			it('Should read a cache entry', function(done) {
-				var user3 = _createUser();
-				async.series({
-					storeValue: function(next) {
-						memored.store('user3', user3, next);
-					},
-					readValue: function(next) {
-						memored.read('user3', function(err, value) {
-							expect(err).to.equals(null);
-							expect(value).to.eql(user3);
-							next();
-						});
-					}
-				}, done);
-			});
-			
-			it('Should return an undefined entry when looking for a non-existing cache entry', function(done) {
-				memored.read('unknownKey', function(err, value) {
-					expect(err).to.equals(null);
-					expect(value).to.equal(undefined);
-					done();
-				});
-			});
-			
-			it('Should respect cache entry ttl', function(done) {
-				var user4 = _createUser(),
-					t1 = Date.now();
-
-				async.series({
-					storeValue: function(next) {
-						memored.store('user4', user4, 20, next);
-					},
-					readValue1: function(next) {
-						memored.read('user4', function(err, value, expirationTime) {
-							expect(err).to.equals(null);
-							expect(value).to.eql(user4);
-							expect(expirationTime).to.least(t1 + 20);
-							next();
-						});
-					},
-					readValue2: function(next) {
-						setTimeout(function() {
-							memored.read('user4', function(err, value) {
-								expect(err).to.equals(null);
-								expect(value).to.equal(undefined);
-								next();
-							});
-						}, 30);
-					}
-				}, done);
-			});
-			
-		});
-
-		describe('Memored - remove', function() {
-
-			it('Should remove a cache entry', function(done) {
-				var user5 = _createUser();
-				async.series({
-					storeValue: function(next) {
-						memored.store('user5', user5, next);
-					},
-					readValue1: function(next) {
-						memored.read('user5', function(err, value) {
-							expect(err).to.equals(null);
-							expect(value).to.eql(user5);
-							next();
-						});
-					},
-					removeValue: function(next) {
-						memored.remove('user5', next);
-					},
-					readValue2: function(next) {
-						memored.read('user5', function(err, value) {
-							expect(err).to.equals(null);
-							expect(value).to.equal(undefined);
-							next();
-						});
-					}
-				}, done);
-			});
-
-		});
-
-		describe('Memored - clean', function() {
-			it('Should remove all values in cache', function(done) {
-				var user6 = _createUser(),
-					user7 = _createUser();
-				
-				async.series({
-					soreValue1: function(next) {
-						memored.store('user6', user6, next);
-					},
-					storeValue2: function(next) {
-						memored.store('user7', user7, next);
-					},
-					readValue1: function(next) {
-						memored.read('user6', function(err, value) {
-							expect(err).to.equals(null);
-							expect(value).to.eql(user6);
-							next();
-						});
-					},
-					readValue2: function(next) {
-						memored.read('user7', function(err, value) {
-							expect(err).to.equals(null);
-							expect(value).to.eql(user7);
-							next();
-						});
-					},
-					cleanCache: function(next) {
-						memored.clean(next);
-					},
-					readValue4: function(next) {
-						memored.read('user6', function(err, value) {
-							expect(err).to.equals(null);
-							expect(value).to.equal(undefined);
-							next();
-						});
-					},
-					readValue5: function(next) {
-						memored.read('user7', function(err, value) {
-							expect(err).to.equals(null);
-							expect(value).to.equal(undefined);
-							next();
-						});
-					},
-				}, done);
-			});
-		});
-
-		describe('Memored - setup -- logger', function() {
-			var customLogger = {
-				messages: [],
-				log: function() {
-					this.messages.push(Array.prototype.slice.call(arguments).join(','));
-				}
-			};
-			it('Should use a custom logger when requested', function(done) {
-				memored.setup({
-					logger: customLogger
-				});
-				expect(customLogger.messages).to.be.have.length(0);
-				memored.store('user8', _createUser(), function() {
-					expect(customLogger.messages).to.have.length(1);
-					done();
-				});
-			});
-		});
-	
-	}
-
-});