cloudcms-server 3.3.1-beta.8 → 4.0.0-beta.1

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();
-				});
-			});
-		});
-	
-	}
-
-});