diff options
Diffstat (limited to 'common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native')
6 files changed, 727 insertions, 0 deletions
diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/ReadPreference.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/ReadPreference.js new file mode 100644 index 0000000..e921d60 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/ReadPreference.js @@ -0,0 +1,45 @@ +/*! + * Module dependencies. + */ + +var mongodb = require('mongodb'); +var ReadPref = mongodb.ReadPreference; + +/*! + * Converts arguments to ReadPrefs the driver + * can understand. + * + * @param {String|Array} pref + * @param {Array} [tags] + */ + +module.exports = function readPref(pref, tags) { + if (Array.isArray(pref)) { + tags = pref[1]; + pref = pref[0]; + } + + if (pref instanceof ReadPref) { + return pref; + } + + switch (pref) { + case 'p': + pref = 'primary'; + break; + case 'pp': + pref = 'primaryPreferred'; + break; + case 's': + pref = 'secondary'; + break; + case 'sp': + pref = 'secondaryPreferred'; + break; + case 'n': + pref = 'nearest'; + break; + } + + return new ReadPref(pref, tags); +}; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/binary.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/binary.js new file mode 100644 index 0000000..657efde --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/binary.js @@ -0,0 +1,8 @@ + +/*! + * Module dependencies. + */ + +var Binary = require('mongodb').Binary; + +module.exports = exports = Binary; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/collection.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/collection.js new file mode 100644 index 0000000..fd0da30 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/collection.js @@ -0,0 +1,267 @@ +/*! + * Module dependencies. + */ + +var MongooseCollection = require('../../collection'), + Collection = require('mongodb').Collection, + utils = require('../../utils'); + +/** + * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) collection implementation. + * + * All methods methods from the [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) driver are copied and wrapped in queue management. + * + * @inherits Collection + * @api private + */ + +function NativeCollection() { + this.collection = null; + MongooseCollection.apply(this, arguments); +} + +/*! + * Inherit from abstract Collection. + */ + +NativeCollection.prototype.__proto__ = MongooseCollection.prototype; + +/** + * Called when the connection opens. + * + * @api private + */ + +NativeCollection.prototype.onOpen = function() { + var _this = this; + + // always get a new collection in case the user changed host:port + // of parent db instance when re-opening the connection. + + if (!_this.opts.capped.size) { + // non-capped + callback(null, _this.conn.db.collection(_this.name)); + return _this.collection; + } + + // capped + return _this.conn.db.collection(_this.name, function(err, c) { + if (err) return callback(err); + + // discover if this collection exists and if it is capped + _this.conn.db.listCollections({name: _this.name}).toArray(function(err, docs) { + if (err) { + return callback(err); + } + var doc = docs[0]; + var exists = !!doc; + + if (exists) { + if (doc.options && doc.options.capped) { + callback(null, c); + } else { + var msg = 'A non-capped collection exists with the name: ' + _this.name + '\n\n' + + ' To use this collection as a capped collection, please ' + + 'first convert it.\n' + + ' http://www.mongodb.org/display/DOCS/Capped+Collections#CappedCollections-Convertingacollectiontocapped'; + err = new Error(msg); + callback(err); + } + } else { + // create + var opts = utils.clone(_this.opts.capped); + opts.capped = true; + _this.conn.db.createCollection(_this.name, opts, callback); + } + }); + }); + + function callback(err, collection) { + if (err) { + // likely a strict mode error + _this.conn.emit('error', err); + } else { + _this.collection = collection; + MongooseCollection.prototype.onOpen.call(_this); + } + } +}; + +/** + * Called when the connection closes + * + * @api private + */ + +NativeCollection.prototype.onClose = function() { + MongooseCollection.prototype.onClose.call(this); +}; + +/*! + * Copy the collection methods and make them subject to queues + */ + +function iter(i) { + NativeCollection.prototype[i] = function() { + if (this.buffer) { + this.addQueue(i, arguments); + return; + } + + var collection = this.collection, + args = arguments, + _this = this, + debug = _this.conn.base.options.debug; + + if (debug) { + if (typeof debug === 'function') { + debug.apply(debug, + [_this.name, i].concat(utils.args(args, 0, args.length - 1))); + } else { + this.$print(_this.name, i, args); + } + } + + try { + return collection[i].apply(collection, args); + } catch (error) { + // Collection operation may throw because of max bson size, catch it here + // See gh-3906 + if (args.length > 0 && + typeof args[args.length - 1] === 'function') { + args[args.length - 1](error); + } else { + throw error; + } + } + }; +} + +for (var i in Collection.prototype) { + // Janky hack to work around gh-3005 until we can get rid of the mongoose + // collection abstraction + try { + if (typeof Collection.prototype[i] !== 'function') { + continue; + } + } catch (e) { + continue; + } + + iter(i); +} + +/** + * Debug print helper + * + * @api public + * @method $print + */ + +NativeCollection.prototype.$print = function(name, i, args) { + var moduleName = '\x1B[0;36mMongoose:\x1B[0m '; + var functionCall = [name, i].join('.'); + var _args = []; + for (var j = args.length - 1; j >= 0; --j) { + if (this.$format(args[j]) || _args.length) { + _args.unshift(this.$format(args[j])); + } + } + var params = '(' + _args.join(', ') + ')'; + + console.error(moduleName + functionCall + params); +}; + +/** + * Formatter for debug print args + * + * @api public + * @method $format + */ + +NativeCollection.prototype.$format = function(arg) { + var type = typeof arg; + if (type === 'function' || type === 'undefined') return ''; + return format(arg); +}; + +/*! + * Debug print helper + */ + +function map(o) { + return format(o, true); +} +function formatObjectId(x, key) { + var representation = 'ObjectId("' + x[key].toHexString() + '")'; + x[key] = {inspect: function() { return representation; }}; +} +function formatDate(x, key) { + var representation = 'new Date("' + x[key].toUTCString() + '")'; + x[key] = {inspect: function() { return representation; }}; +} +function format(obj, sub) { + if (obj && typeof obj.toBSON === 'function') { + obj = obj.toBSON(); + } + var x = utils.clone(obj, {retainKeyOrder: 1, transform: false}); + var representation; + + if (x != null) { + if (x.constructor.name === 'Binary') { + x = 'BinData(' + x.sub_type + ', "' + x.toString('base64') + '")'; + } else if (x.constructor.name === 'ObjectID') { + representation = 'ObjectId("' + x.toHexString() + '")'; + x = {inspect: function() { return representation; }}; + } else if (x.constructor.name === 'Date') { + representation = 'new Date("' + x.toUTCString() + '")'; + x = {inspect: function() { return representation; }}; + } else if (x.constructor.name === 'Object') { + var keys = Object.keys(x); + var numKeys = keys.length; + var key; + for (var i = 0; i < numKeys; ++i) { + key = keys[i]; + if (x[key]) { + if (typeof x[key].toBSON === 'function') { + x[key] = x[key].toBSON(); + } + if (x[key].constructor.name === 'Binary') { + x[key] = 'BinData(' + x[key].sub_type + ', "' + + x[key].buffer.toString('base64') + '")'; + } else if (x[key].constructor.name === 'Object') { + x[key] = format(x[key], true); + } else if (x[key].constructor.name === 'ObjectID') { + formatObjectId(x, key); + } else if (x[key].constructor.name === 'Date') { + formatDate(x, key); + } else if (Array.isArray(x[key])) { + x[key] = x[key].map(map); + } + } + } + } + if (sub) return x; + } + + return require('util') + .inspect(x, false, 10, true) + .replace(/\n/g, '') + .replace(/\s{2,}/g, ' '); +} + +/** + * Retreives information about this collections indexes. + * + * @param {Function} callback + * @method getIndexes + * @api public + */ + +NativeCollection.prototype.getIndexes = NativeCollection.prototype.indexInformation; + +/*! + * Module exports. + */ + +module.exports = NativeCollection; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/connection.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/connection.js new file mode 100644 index 0000000..c17330d --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/connection.js @@ -0,0 +1,386 @@ +/*! + * Module dependencies. + */ + +var MongooseConnection = require('../../connection'); +var mongo = require('mongodb'); +var Db = mongo.Db; +var Server = mongo.Server; +var Mongos = mongo.Mongos; +var STATES = require('../../connectionstate'); +var ReplSetServers = mongo.ReplSet; +var DisconnectedError = require('../../error/disconnected'); + +/** + * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) connection implementation. + * + * @inherits Connection + * @api private + */ + +function NativeConnection() { + MongooseConnection.apply(this, arguments); + this._listening = false; +} + +/** + * Expose the possible connection states. + * @api public + */ + +NativeConnection.STATES = STATES; + +/*! + * Inherits from Connection. + */ + +NativeConnection.prototype.__proto__ = MongooseConnection.prototype; + +/** + * Opens the connection to MongoDB. + * + * @param {Function} fn + * @return {Connection} this + * @api private + */ + +NativeConnection.prototype.doOpen = function(fn) { + var _this = this; + var server = new Server(this.host, this.port, this.options.server); + + if (this.options && this.options.mongos) { + var mongos = new Mongos([server], this.options.mongos); + this.db = new Db(this.name, mongos, this.options.db); + } else { + this.db = new Db(this.name, server, this.options.db); + } + + this.db.open(function(err) { + listen(_this); + + if (!mongos) { + server.s.server.on('error', function(error) { + if (/after \d+ attempts/.test(error.message)) { + _this.emit('error', new DisconnectedError(server.s.server.name)); + } + }); + } + + if (err) return fn(err); + + fn(); + }); + + return this; +}; + +/** + * Switches to a different database using the same connection pool. + * + * Returns a new connection object, with the new db. + * + * @param {String} name The database name + * @return {Connection} New Connection Object + * @api public + */ + +NativeConnection.prototype.useDb = function(name) { + // we have to manually copy all of the attributes... + var newConn = new this.constructor(); + newConn.name = name; + newConn.base = this.base; + newConn.collections = {}; + newConn.models = {}; + newConn.replica = this.replica; + newConn.hosts = this.hosts; + newConn.host = this.host; + newConn.port = this.port; + newConn.user = this.user; + newConn.pass = this.pass; + newConn.options = this.options; + newConn._readyState = this._readyState; + newConn._closeCalled = this._closeCalled; + newConn._hasOpened = this._hasOpened; + newConn._listening = false; + + // First, when we create another db object, we are not guaranteed to have a + // db object to work with. So, in the case where we have a db object and it + // is connected, we can just proceed with setting everything up. However, if + // we do not have a db or the state is not connected, then we need to wait on + // the 'open' event of the connection before doing the rest of the setup + // the 'connected' event is the first time we'll have access to the db object + + var _this = this; + + if (this.db && this._readyState === STATES.connected) { + wireup(); + } else { + this.once('connected', wireup); + } + + function wireup() { + newConn.db = _this.db.db(name); + newConn.onOpen(); + // setup the events appropriately + listen(newConn); + } + + newConn.name = name; + + // push onto the otherDbs stack, this is used when state changes + this.otherDbs.push(newConn); + newConn.otherDbs.push(this); + + return newConn; +}; + +/*! + * Register listeners for important events and bubble appropriately. + */ + +function listen(conn) { + if (conn.db._listening) { + return; + } + conn.db._listening = true; + + conn.db.on('close', function() { + if (conn._closeCalled) return; + + // the driver never emits an `open` event. auto_reconnect still + // emits a `close` event but since we never get another + // `open` we can't emit close + if (conn.db.serverConfig.autoReconnect) { + conn.readyState = STATES.disconnected; + conn.emit('close'); + return; + } + conn.onClose(); + }); + conn.db.on('error', function(err) { + conn.emit('error', err); + }); + conn.db.on('reconnect', function() { + conn.readyState = STATES.connected; + conn.emit('reconnected'); + }); + conn.db.on('timeout', function(err) { + var error = new Error(err && err.err || 'connection timeout'); + conn.emit('error', error); + }); + conn.db.on('open', function(err, db) { + if (STATES.disconnected === conn.readyState && db && db.databaseName) { + conn.readyState = STATES.connected; + conn.emit('reconnected'); + } + }); + conn.db.on('parseError', function(err) { + conn.emit('parseError', err); + }); +} + +/** + * Opens a connection to a MongoDB ReplicaSet. + * + * See description of [doOpen](#NativeConnection-doOpen) for server options. In this case `options.replset` is also passed to ReplSetServers. + * + * @param {Function} fn + * @api private + * @return {Connection} this + */ + +NativeConnection.prototype.doOpenSet = function(fn) { + var servers = [], + _this = this; + + this.hosts.forEach(function(server) { + var host = server.host || server.ipc; + var port = server.port || 27017; + servers.push(new Server(host, port, _this.options.server)); + }); + + var server = this.options.mongos + ? new Mongos(servers, this.options.mongos) + : new ReplSetServers(servers, this.options.replset || this.options.replSet); + this.db = new Db(this.name, server, this.options.db); + + this.db.on('fullsetup', function() { + _this.emit('fullsetup'); + }); + + this.db.on('all', function() { + _this.emit('all'); + }); + + this.db.open(function(err) { + if (err) return fn(err); + fn(); + listen(_this); + }); + + return this; +}; + +/** + * Closes the connection + * + * @param {Function} fn + * @return {Connection} this + * @api private + */ + +NativeConnection.prototype.doClose = function(fn) { + this.db.close(fn); + return this; +}; + +/** + * Prepares default connection options for the node-mongodb-native driver. + * + * _NOTE: `passed` options take precedence over connection string options._ + * + * @param {Object} passed options that were passed directly during connection + * @param {Object} [connStrOptions] options that were passed in the connection string + * @api private + */ + +NativeConnection.prototype.parseOptions = function(passed, connStrOpts) { + var o = passed || {}; + o.db || (o.db = {}); + o.auth || (o.auth = {}); + o.server || (o.server = {}); + o.replset || (o.replset = o.replSet) || (o.replset = {}); + o.server.socketOptions || (o.server.socketOptions = {}); + o.replset.socketOptions || (o.replset.socketOptions = {}); + o.mongos || (o.mongos = (connStrOpts && connStrOpts.mongos)); + (o.mongos === true) && (o.mongos = {}); + + var opts = connStrOpts || {}; + Object.keys(opts).forEach(function(name) { + switch (name) { + case 'ssl': + o.server.ssl = opts.ssl; + o.replset.ssl = opts.ssl; + o.mongos && (o.mongos.ssl = opts.ssl); + break; + case 'poolSize': + if (typeof o.server[name] === 'undefined') { + o.server[name] = o.replset[name] = opts[name]; + } + break; + case 'slaveOk': + if (typeof o.server.slave_ok === 'undefined') { + o.server.slave_ok = opts[name]; + } + break; + case 'autoReconnect': + if (typeof o.server.auto_reconnect === 'undefined') { + o.server.auto_reconnect = opts[name]; + } + break; + case 'socketTimeoutMS': + case 'connectTimeoutMS': + if (typeof o.server.socketOptions[name] === 'undefined') { + o.server.socketOptions[name] = o.replset.socketOptions[name] = opts[name]; + } + break; + case 'authdb': + if (typeof o.auth.authdb === 'undefined') { + o.auth.authdb = opts[name]; + } + break; + case 'authSource': + if (typeof o.auth.authSource === 'undefined') { + o.auth.authSource = opts[name]; + } + break; + case 'retries': + case 'reconnectWait': + case 'rs_name': + if (typeof o.replset[name] === 'undefined') { + o.replset[name] = opts[name]; + } + break; + case 'replicaSet': + if (typeof o.replset.rs_name === 'undefined') { + o.replset.rs_name = opts[name]; + } + break; + case 'readSecondary': + if (typeof o.replset.read_secondary === 'undefined') { + o.replset.read_secondary = opts[name]; + } + break; + case 'nativeParser': + if (typeof o.db.native_parser === 'undefined') { + o.db.native_parser = opts[name]; + } + break; + case 'w': + case 'safe': + case 'fsync': + case 'journal': + case 'wtimeoutMS': + if (typeof o.db[name] === 'undefined') { + o.db[name] = opts[name]; + } + break; + case 'readPreference': + if (typeof o.db.readPreference === 'undefined') { + o.db.readPreference = opts[name]; + } + break; + case 'readPreferenceTags': + if (typeof o.db.read_preference_tags === 'undefined') { + o.db.read_preference_tags = opts[name]; + } + break; + case 'sslValidate': + o.server.sslValidate = opts.sslValidate; + o.replset.sslValidate = opts.sslValidate; + o.mongos && (o.mongos.sslValidate = opts.sslValidate); + } + }); + + if (!('auto_reconnect' in o.server)) { + o.server.auto_reconnect = true; + } + + // mongoose creates its own ObjectIds + o.db.forceServerObjectId = false; + + // default safe using new nomenclature + if (!('journal' in o.db || 'j' in o.db || + 'fsync' in o.db || 'safe' in o.db || 'w' in o.db)) { + o.db.w = 1; + } + + if (o.promiseLibrary) { + o.db.promiseLibrary = o.promiseLibrary; + } + + validate(o); + return o; +}; + +/*! + * Validates the driver db options. + * + * @param {Object} o + */ + +function validate(o) { + if (o.db.w === -1 || o.db.w === 0) { + if (o.db.journal || o.db.fsync || o.db.safe) { + throw new Error( + 'Invalid writeConcern: ' + + 'w set to -1 or 0 cannot be combined with safe|fsync|journal'); + } + } +} + +/*! + * Module exports. + */ + +module.exports = NativeConnection; diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/index.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/index.js new file mode 100644 index 0000000..fa5dbb4 --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/index.js @@ -0,0 +1,7 @@ +/*! + * Module exports. + */ + +exports.Binary = require('./binary'); +exports.ObjectId = require('./objectid'); +exports.ReadPreference = require('./ReadPreference'); diff --git a/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/objectid.js b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/objectid.js new file mode 100644 index 0000000..69fc08f --- /dev/null +++ b/common/src/main/webapp/usageguide/appserver/node_modules/mongoose/lib/drivers/node-mongodb-native/objectid.js @@ -0,0 +1,14 @@ + +/*! + * [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) ObjectId + * @constructor NodeMongoDbObjectId + * @see ObjectId + */ + +var ObjectId = require('mongodb').ObjectId; + +/*! + * ignore + */ + +module.exports = exports = ObjectId; |