"use strict";
// Import external names locally
var Shared = require('./Shared'),
fs = require('fs'),
async = require('async'),
FdbCompress = require('./PersistCompress'),// jshint ignore:line
FdbCrypto = require('./PersistCrypto'),// jshint ignore:line
Db,
Collection,
CollectionDrop,
CollectionGroup,
CollectionInit,
DbInit,
DbDrop,
NodePersist,
Overload;
NodePersist = function () {
this.init.apply(this, arguments);
};
/**
* The init method that can be overridden or extended.
* @param {Db} db The ForerunnerDB database instance.
*/
NodePersist.prototype.init = function (db) {
var self = this;
// Default to saving data via files
this.mode('file');
this._encodeSteps = [
function () { return self._encode.apply(self, arguments); }
];
this._decodeSteps = [
function () { return self._decode.apply(self, arguments); }
];
this._db = db;
this._opQueue = {};
};
Shared.addModule('NodePersist', NodePersist);
Shared.mixin(NodePersist.prototype, 'Mixin.Common');
Shared.mixin(NodePersist.prototype, 'Mixin.ChainReactor');
Db = Shared.modules.Db;
Collection = require('./Collection');
CollectionDrop = Collection.prototype.drop;
CollectionGroup = require('./CollectionGroup');
CollectionInit = Collection.prototype.init;
DbInit = Db.prototype.init;
DbDrop = Db.prototype.drop;
Overload = Shared.overload;
/**
* Gets / sets the persistent storage mode.
* @param {String} type The library to use for storage. Defaults
* to file.
* @returns {*}
*/
Shared.synthesize(NodePersist.prototype, 'mode');
/**
* Gets / sets the auto flag which determines if the persistence module
* will automatically load data for collections the first time they are
* accessed and save data whenever it changes. This is disabled by
* default.
* @param {Boolean} val Set to true to enable, false to disable.
* @param {Object=} objNames Optional object of type keys with an array
* of object names under them for which auto-persist is enabled.
* @returns {*}
*/
NodePersist.prototype.auto = function (val, objNames) {
var self = this;
if (val !== undefined) {
if (val) {
if (objNames) {
this._autoNames = objNames;
}
// Hook db events
this._db.on('create', function (obj, objType, name) {
var arr;
if (!self._autoNames) {
self._autoLoad.call(self, obj, objType, name);
} else {
// Get list of names
arr = self._autoNames[objType];
// Check if this object is in the list of objects to auto-persist
if (arr && arr.indexOf(name) > -1) {
self._autoLoad.call(self, obj, objType, name);
}
}
});
this._db.on('change', function (obj, objType, name) {
var arr;
if (!self._autoNames) {
self._autoSave.call(self, obj, objType, name);
} else {
// Get list of names
arr = self._autoNames[objType];
// Check if this object is in the list of objects to auto-persist
if (arr && arr.indexOf(name) > -1) {
self._autoSave.call(self, obj, objType, name);
}
}
});
if (this._db.debug()) {
console.log(this._db.logIdentifier() + ' Automatic load/save enabled');
}
} else {
// Un-hook db events
this._db.off('create', this._autoLoad);
this._db.off('change', this._autoSave);
if (this._db.debug()) {
console.log(this._db.logIdentifier() + ' Automatic load/save disbled');
}
}
this._auto = val;
return this;
}
return this._auto;
};
NodePersist.prototype._autoLoad = function (obj, objType, name) {
var self = this;
if (typeof obj.load === 'function') {
if (self._db.debug()) {
console.log(self._db.logIdentifier() + ' Auto-loading data for ' + objType + ':', name);
}
obj.load(function (err, data) {
if (err && self._db.debug()) {
console.log(self._db.logIdentifier() + ' Automatic load failed:', err);
}
});
} else {
if (self._db.debug()) {
console.log(self._db.logIdentifier() + ' Auto-load for ' + objType + ':', name, 'no load method, skipping');
}
}
};
NodePersist.prototype._autoSave = function (obj, objType, name) {
var self = this;
if (typeof obj.save === 'function') {
if (self._db.debug()) {
console.log(self._db.logIdentifier() + ' Auto-saving data for ' + objType + ':', name);
}
obj.save(function (err, data) {
if (err && self._db.debug()) {
console.log(self._db.logIdentifier() + ' Automatic save failed:', err);
}
});
}
};
/**
* Starts a decode waterfall process.
* @param {*} val The data to be decoded.
* @param {Function} finished The callback to pass final data to.
*/
NodePersist.prototype.decode = function (val, finished) {
async.waterfall([function (callback) {
if (callback) { callback(false, val, {}); }
}].concat(this._decodeSteps), finished);
};
/**
* Starts an encode waterfall process.
* @param {*} val The data to be encoded.
* @param {Function} finished The callback to pass final data to.
*/
NodePersist.prototype.encode = function (val, finished) {
async.waterfall([function (callback) {
if (callback) { callback(false, val, {}); }
}].concat(this._encodeSteps), finished);
};
Shared.synthesize(NodePersist.prototype, 'encodeSteps');
Shared.synthesize(NodePersist.prototype, 'decodeSteps');
/**
* Adds an encode/decode step to the persistent storage system so
* that you can add custom functionality.
* @param {Function} encode The encode method called with the data from the
* previous encode step. When your method is complete it MUST call the
* callback method. If you provide anything other than false to the err
* parameter the encoder will fail and throw an error.
* @param {Function} decode The decode method called with the data from the
* previous decode step. When your method is complete it MUST call the
* callback method. If you provide anything other than false to the err
* parameter the decoder will fail and throw an error.
* @param {Number=} index Optional index to add the encoder step to. This
* allows you to place a step before or after other existing steps. If not
* provided your step is placed last in the list of steps. For instance if
* you are providing an encryption step it makes sense to place this last
* since all previous steps will then have their data encrypted by your
* final step.
*/
NodePersist.prototype.addStep = new Overload({
'object': function (obj) {
this.$main.call(this, function objEncode () { obj.encode.apply(obj, arguments); }, function objDecode () { obj.decode.apply(obj, arguments); }, 0);
},
'function, function': function (encode, decode) {
this.$main.call(this, encode, decode, 0);
},
'function, function, number': function (encode, decode, index) {
this.$main.call(this, encode, decode, index);
},
$main: function (encode, decode, index) {
if (index === 0 || index === undefined) {
this._encodeSteps.push(encode);
this._decodeSteps.unshift(decode);
} else {
// Place encoder step at index then work out correct
// index to place decoder step
this._encodeSteps.splice(index, 0, encode);
this._decodeSteps.splice(this._decodeSteps.length - index, 0, decode);
}
}
});
NodePersist.prototype.unwrap = function (dataStr) {
var parts = dataStr.split('::fdb::'),
data;
switch (parts[0]) {
case 'json':
data = this.jParse(parts[1]);
break;
case 'raw':
data = parts[1];
break;
default:
break;
}
};
/**
* Takes encoded data and decodes it for use as JS native objects and arrays.
* @param {String} val The currently encoded string data.
* @param {Object} meta Meta data object that can be used to pass back useful
* supplementary data.
* @param {Function} finished The callback method to call when decoding is
* completed.
* @private
*/
NodePersist.prototype._decode = function (val, meta, finished) {
var parts,
data;
if (val) {
parts = val.split('::fdb::');
switch (parts[0]) {
case 'json':
data = this.jParse(parts[1]);
break;
case 'raw':
data = parts[1];
break;
default:
break;
}
if (data) {
meta.foundData = true;
meta.rowCount = data.length || 0;
} else {
meta.foundData = false;
meta.rowCount = 0;
}
if (finished) {
finished(false, data, meta);
}
} else {
meta.foundData = false;
meta.rowCount = 0;
if (finished) {
finished(false, val, meta);
}
}
};
/**
* Takes native JS data and encodes it for for storage as a string.
* @param {Object} val The current un-encoded data.
* @param {Object} meta Meta data object that can be used to pass back useful
* supplementary data.
* @param {Function} finished The callback method to call when encoding is
* completed.
* @private
*/
NodePersist.prototype._encode = function (val, meta, finished) {
var data = val;
if (typeof val === 'object') {
val = 'json::fdb::' + this.jStringify(val);
} else {
val = 'raw::fdb::' + val;
}
if (data) {
meta.foundData = true;
meta.rowCount = data.length || 0;
} else {
meta.foundData = false;
meta.rowCount = 0;
}
if (finished) {
finished(false, val, meta);
}
};
/**
* Encodes passed data and then stores it in a data file.
* @param {String} key The key to store the data under in the persistent
* storage.
* @param {Object} data The data to store under the key.
* @param {Function=} callback The method to call when the save process
* has completed.
*/
NodePersist.prototype.save = function (key, data, callback) {
var self = this;
switch (this.mode()) {
case 'file':
this.encode(data, function (err, data, tableStats) {
self.saveDataFile(key, data, function (err, data) {
if (!err) {
if (callback) {
callback(false, data, tableStats);
}
} else {
if (callback) { callback(err); }
}
});
});
break;
default:
if (callback) { callback('No data handler.'); }
break;
}
};
/**
* Loads and decodes data from the passed key.
* @param {String} key The key to retrieve data from in the persistent
* storage.
* @param {Function=} callback The method to call when the load process
* has completed.
*/
NodePersist.prototype.load = function (key, callback) {
var self = this;
switch (this.mode()) {
case 'file':
self.checkDataFile(key, function (err) {
if (!err) {
self.loadDataFile(key, function (err, val) {
if (!err) {
self.decode(val, callback);
} else {
if (callback) {
callback(err);
}
}
});
} else {
callback(false);
}
});
break;
default:
if (callback) { callback('No data handler or unrecognised data type.'); }
break;
}
};
/**
* Deletes data in persistent storage stored under the passed key.
* @param {String} key The key to drop data for in the storage.
* @param {Function=} callback The method to call when the data is dropped.
*/
NodePersist.prototype.drop = function (key, callback) {
var self = this;
switch (this.mode()) {
case 'file':
self.removeDataFile(key, function (err) {
if (callback) { callback(err); }
});
break;
default:
if (callback) { callback('No data handler or unrecognised data type.'); }
break;
}
};
Shared.synthesize(NodePersist.prototype, 'dataDir', function (val) {
if (val !== undefined) {
// Ensure the folder exists
fs.stat(val, function (err, stats) {
if (!err) {
if (!stats.isDirectory() && !stats.isFile()) {
fs.mkdir(val, function (err) {});
}
} else {
try {
fs.mkdir(val, function (err) {});
} catch (e) {
}
}
});
}
return this.$super.call(this, val);
});
NodePersist.prototype.saveDataFile = function (key, data, callback) {
fs.writeFile(this.dataDir() + "/" + key + '.fdb', data, callback);
};
NodePersist.prototype.loadDataFile = function (key, callback) {
fs.readFile(this.dataDir() + "/" + key + '.fdb', 'utf8', callback);
};
NodePersist.prototype.removeDataFile = function (key, callback) {
fs.unlink(this.dataDir() + "/" + key + '.fdb', callback);
};
NodePersist.prototype.checkDataFile = function (key, callback) {
fs.stat(this.dataDir() + "/" + key + '.fdb', function (err, stats) {
callback(err, !err, stats);
});
};
NodePersist.prototype.dataExists = function (collectionName, callback) {
this.checkDataFile(this._db._name + '-' + collectionName, callback);
};
// Extend the Collection prototype with persist methods
Collection.prototype.drop = new Overload({
/**
* Drop collection and persistent storage.
* @name drop
* @method Collection.drop
*/
'': function () {
if (!this.isDropped()) {
this.drop(true);
}
},
/**
* Drop collection and persistent storage with callback.
* @name drop
* @method Collection.drop
* @param {Function} callback Callback method.
*/
'function': function (callback) {
if (!this.isDropped()) {
this.drop(true, callback);
}
},
/**
* Drop collection and optionally drop persistent storage.
* @name drop
* @method Collection.drop
* @param {Boolean} removePersistent True to drop persistent storage, false to keep it.
*/
'boolean': function (removePersistent) {
if (!this.isDropped()) {
// Remove persistent storage
if (removePersistent) {
if (this._name) {
if (this._db) {
// Drop the collection data from storage
this._db.persist.drop(this._db._name + '-' + this._name);
this._db.persist.drop(this._db._name + '-' + this._name + '-metaData');
}
} else {
throw('ForerunnerDB.NodePersist: Cannot drop a collection\'s persistent storage when no name assigned to collection!');
}
}
// Call the original method
CollectionDrop.apply(this);
}
},
/**
* Drop collections and optionally drop persistent storage with callback.
* @name drop
* @method Collection.drop
* @param {Boolean} removePersistent True to drop persistent storage, false to keep it.
* @param {Function} callback Callback method.
*/
'boolean, function': function (removePersistent, callback) {
var self = this;
if (!this.isDropped()) {
// Remove persistent storage
if (removePersistent) {
if (this._name) {
if (this._db) {
// Drop the collection data from storage
this._db.persist.drop(this._db._name + '-' + this._name, function () {
self._db.persist.drop(self._db._name + '-' + self._name + '-metaData', callback);
});
} else {
if (callback) { callback('Cannot drop a collection\'s persistent storage when the collection is not attached to a database!'); }
}
} else {
if (callback) { callback('Cannot drop a collection\'s persistent storage when no name assigned to collection!'); }
}
}
// Call the original method
CollectionDrop.apply(this, callback);
}
}
});
/**
* Saves an entire collection's data to persistent storage.
* @param {Function=} callback The method to call when the save function
* has completed.
*/
Collection.prototype.save = function (callback) {
var self = this,
processSave;
if (self._name) {
if (self._db) {
processSave = function () {
// Save the collection data
self._asyncPending('save');
self._db.persist.save(self._db._name + '-' + self._name, self._data, function (err, data, tableStats) {
if (!err) {
self._db.persist.save(self._db._name + '-' + self._name + '-metaData', self.metaData(), function (err, data, metaStats) {
self._asyncComplete('save');
if (!err) {
self.deferEmit('save', tableStats, metaStats);
}
if (callback) { callback(err, data, tableStats, metaStats); }
});
} else {
self._asyncComplete('save');
if (callback) { callback(err); }
}
});
};
// Check for processing queues
if (self.isProcessingQueue()) {
// Hook queue complete to process save
self.on('queuesComplete', function () {
processSave();
});
} else {
// Process save immediately
processSave();
}
} else {
if (callback) { callback('Cannot save a collection that is not attached to a database!'); }
}
} else {
if (callback) { callback('Cannot save a collection with no assigned name!'); }
}
};
/**
* Loads an entire collection's data from persistent storage.
* @param {Function=} callback The method to call when the load function
* has completed.
*/
Collection.prototype.load = function (callback) {
var self = this;
if (self._name) {
if (self._db) {
// Load the collection data
self._asyncPending('load');
self._db.persist.load(self._db._name + '-' + self._name, function (err, data, tableStats) {
if (!err) {
if (data) {
//self.remove({});
//self.insert(data);
self.setData(data);
}
// Now load the collection's metadata
self._db.persist.load(self._db._name + '-' + self._name + '-metaData', function (err, data, metaStats) {
if (!err) {
if (data) {
self.metaData(data);
}
}
self._asyncComplete('load');
self.deferEmit('load', tableStats, metaStats);
if (callback) { callback(err, tableStats, metaStats); }
});
} else {
self._asyncComplete('load');
self.deferEmit('load', tableStats);
if (callback) { callback(err); }
}
});
} else {
if (callback) { callback('Cannot load a collection that is not attached to a database!'); }
}
} else {
if (callback) { callback('Cannot load a collection with no assigned name!'); }
}
};
// Override the DB init to instantiate the plugin
Db.prototype.init = function () {
DbInit.apply(this, arguments);
this.persist = new NodePersist(this);
};
/**
* Loads an entire database's data from persistent storage.
* @param {Function=} callback The method to call when the load function
* has completed.
*/
Db.prototype.load = function (callback) {
// Loop the collections in the database
var self = this,
obj,
keys,
keyCount,
loadCallback,
index;
obj = this._collection;
keys = Object.keys(obj);
keyCount = keys.length;
if (keyCount <= 0) {
return callback(false);
}
loadCallback = function (err) {
if (!err) {
keyCount--;
if (keyCount <= 0) {
self.deferEmit('load');
if (callback) { callback(false); }
}
} else {
if (callback) {
callback(err);
}
}
};
for (index in obj) {
if (obj.hasOwnProperty(index)) {
// Call the collection load method
obj[index].load(loadCallback);
}
}
};
/**
* Saves an entire database's data to persistent storage.
* @param {Function=} callback The method to call when the save function
* has completed.
*/
Db.prototype.save = function (callback) {
// Loop the collections in the database
var self = this,
obj,
keys,
keyCount,
saveCallback,
index;
obj = this._collection;
keys = Object.keys(obj);
keyCount = keys.length;
if (keyCount <= 0) {
return callback(false);
}
saveCallback = function (err) {
if (!err) {
keyCount--;
if (keyCount <= 0) {
self.deferEmit('save');
if (callback) { callback(false); }
}
} else {
if (callback) { callback(err); }
}
};
for (index in obj) {
if (obj.hasOwnProperty(index)) {
// Call the collection save method
obj[index].save(saveCallback);
}
}
};
Shared.finishModule('NodePersist');
module.exports = NodePersist;